ns: Change read_to_end to accept QName

src/de/mod.rs

@@ -221,6 +221,7 @@ pub use crate::errors::serialize::DeError;
 use crate::{
     errors::Error,
     events::{BytesCData, BytesEnd, BytesStart, BytesText, Event},
+    name::QName,
     reader::Decoder,
     Reader,
 };
@@ -646,7 +647,7 @@ where
                     }
                     DeEvent::Eof => return Err(DeError::UnexpectedEof),
                 };
-                self.read_to_end(e.name().as_ref())?;
+                self.read_to_end(e.name())?;
                 Ok(t)
             }
             DeEvent::Start(e) => Err(DeError::UnexpectedStart(e.name().as_ref().to_owned())),
@@ -664,14 +665,14 @@ where
     /// Drops all events until event with [name](BytesEnd::name()) `name` won't be
     /// dropped. This method should be called after [`Self::next()`]
     #[cfg(feature = "overlapped-lists")]
-    fn read_to_end(&mut self, name: &[u8]) -> Result<(), DeError> {
+    fn read_to_end(&mut self, name: QName) -> Result<(), DeError> {
         let mut depth = 0;
         loop {
             match self.read.pop_front() {
-                Some(DeEvent::Start(e)) if e.name().as_ref() == name => {
+                Some(DeEvent::Start(e)) if e.name() == name => {
                     depth += 1;
                 }
-                Some(DeEvent::End(e)) if e.name().as_ref() == name => {
+                Some(DeEvent::End(e)) if e.name() == name => {
                     if depth == 0 {
                         return Ok(());
                     }
@@ -688,11 +689,11 @@ where
         }
     }
     #[cfg(not(feature = "overlapped-lists"))]
-    fn read_to_end(&mut self, name: &[u8]) -> Result<(), DeError> {
+    fn read_to_end(&mut self, name: QName) -> Result<(), DeError> {
         // First one might be in self.peek
         match self.next()? {
-            DeEvent::Start(e) => self.reader.read_to_end(e.name().as_ref())?,
-            DeEvent::End(e) if e.name().as_ref() == name => return Ok(()),
+            DeEvent::Start(e) => self.reader.read_to_end(e.name())?,
+            DeEvent::End(e) if e.name() == name => return Ok(()),
             _ => (),
         }
         self.reader.read_to_end(name)
@@ -760,7 +761,7 @@ where
             let name = e.name().as_ref().to_vec();
             let map = map::MapAccess::new(self, e, fields)?;
             let value = visitor.visit_map(map)?;
-            self.read_to_end(&name)?;
+            self.read_to_end(QName(&name))?;
             Ok(value)
         } else {
             Err(DeError::ExpectedStart)
@@ -791,7 +792,7 @@ where
     {
         match self.next()? {
             DeEvent::Start(s) => {
-                self.read_to_end(s.name().as_ref())?;
+                self.read_to_end(s.name())?;
                 visitor.visit_unit()
             }
             DeEvent::Text(_) | DeEvent::CData(_) => visitor.visit_unit(),
@@ -898,7 +899,7 @@ where
         V: Visitor<'de>,
     {
         match self.next()? {
-            DeEvent::Start(e) => self.read_to_end(e.name().as_ref())?,
+            DeEvent::Start(e) => self.read_to_end(e.name())?,
             DeEvent::End(e) => return Err(DeError::UnexpectedEnd(e.name().as_ref().to_owned())),
             DeEvent::Eof => return Err(DeError::UnexpectedEof),
             _ => (),
@@ -931,7 +932,7 @@ pub trait XmlRead<'i> {
 
     /// Skips until end element is found. Unlike `next()` it will not allocate
     /// when it cannot satisfy the lifetime.
-    fn read_to_end(&mut self, name: &[u8]) -> Result<(), DeError>;
+    fn read_to_end(&mut self, name: QName) -> Result<(), DeError>;
 
     /// A copy of the reader's decoder used to decode strings.
     fn decoder(&self) -> Decoder;
@@ -966,7 +967,7 @@ impl<'i, R: BufRead> XmlRead<'i> for IoReader<R> {
         event
     }
 
-    fn read_to_end(&mut self, name: &[u8]) -> Result<(), DeError> {
+    fn read_to_end(&mut self, name: QName) -> Result<(), DeError> {
         match self.reader.read_to_end(name, &mut self.buf) {
             Err(Error::UnexpectedEof(_)) => Err(DeError::UnexpectedEof),
             other => Ok(other?),
@@ -1002,7 +1003,7 @@ impl<'de> XmlRead<'de> for SliceReader<'de> {
         }
     }
 
-    fn read_to_end(&mut self, name: &[u8]) -> Result<(), DeError> {
+    fn read_to_end(&mut self, name: QName) -> Result<(), DeError> {
         match self.reader.read_to_end_unbuffered(name) {
             Err(Error::UnexpectedEof(_)) => Err(DeError::UnexpectedEof),
             other => Ok(other?),
@@ -1218,7 +1219,7 @@ mod tests {
                 de.next().unwrap(),
                 Start(BytesStart::borrowed_name(b"target"))
             );
-            de.read_to_end(b"target").unwrap();
+            de.read_to_end(QName(b"target")).unwrap();
             assert_eq!(de.read, vec![]);
             assert_eq!(
                 de.write,
@@ -1258,7 +1259,7 @@ mod tests {
                 de.next().unwrap(),
                 Start(BytesStart::borrowed_name(b"skip"))
             );
-            de.read_to_end(b"skip").unwrap();
+            de.read_to_end(QName(b"skip")).unwrap();
 
             assert_eq!(de.next().unwrap(), End(BytesEnd::borrowed(b"root")));
         }
@@ -1319,7 +1320,7 @@ mod tests {
             de.next().unwrap(),
             Start(BytesStart::borrowed(br#"tag a="1""#, 3))
         );
-        assert_eq!(de.read_to_end(b"tag").unwrap(), ());
+        assert_eq!(de.read_to_end(QName(b"tag")).unwrap(), ());
 
         assert_eq!(
             de.next().unwrap(),
@@ -1335,7 +1336,7 @@ mod tests {
             de.next().unwrap(),
             Start(BytesStart::borrowed(b"self-closed", 11))
         );
-        assert_eq!(de.read_to_end(b"self-closed").unwrap(), ());
+        assert_eq!(de.read_to_end(QName(b"self-closed")).unwrap(), ());
 
         assert_eq!(de.next().unwrap(), End(BytesEnd::borrowed(b"root")));
         assert_eq!(de.next().unwrap(), Eof);
@@ -1438,7 +1439,7 @@ mod tests {
             reader.next().unwrap(),
             DeEvent::Start(BytesStart::borrowed(b"item ", 4))
         );
-        reader.read_to_end(b"item").unwrap();
+        reader.read_to_end(QName(b"item")).unwrap();
         assert_eq!(reader.next().unwrap(), DeEvent::Eof);
     }
 

src/de/var.rs

@@ -67,7 +67,7 @@ where
 
     fn unit_variant(self) -> Result<(), DeError> {
         match self.de.next()? {
-            DeEvent::Start(e) => self.de.read_to_end(e.name().as_ref()),
+            DeEvent::Start(e) => self.de.read_to_end(e.name()),
             DeEvent::Text(_) | DeEvent::CData(_) => Ok(()),
             _ => unreachable!(),
         }