#435: Fix incorrect results when nesting start_replay() calls

Author: Mingun

src/de/map.rs

@@ -554,6 +554,9 @@ where
             TagFilter::Exclude(self.map.fields)
         };
         visitor.visit_seq(MapValueSeqAccess {
+            #[cfg(feature = "overlapped-lists")]
+            checkpoint: self.map.de.skip_checkpoint(),
+
             map: self.map,
             filter,
         })
@@ -585,6 +588,12 @@ where
     /// When feature `overlapped-lists` is activated, all tags, that not pass
     /// this check, will be skipped.
     filter: TagFilter<'de>,
+
+    /// Checkpoint after which all skipped events should be returned. All events,
+    /// that was skipped before creating this checkpoint, will still stay buffered
+    /// and will not be returned
+    #[cfg(feature = "overlapped-lists")]
+    checkpoint: usize,
 }
 
 #[cfg(feature = "overlapped-lists")]
@@ -593,7 +602,7 @@ where
     R: XmlRead<'de>,
 {
     fn drop(&mut self) {
-        self.map.de.start_replay();
+        self.map.de.start_replay(self.checkpoint);
     }
 }
 

src/de/mod.rs

@@ -483,6 +483,14 @@ where
         self.reader.next()
     }
 
+    /// Returns the mark after which all events, skipped by [`Self::skip()`] call,
+    /// should be replayed after calling [`Self::start_replay()`].
+    #[cfg(feature = "overlapped-lists")]
+    #[inline]
+    fn skip_checkpoint(&self) -> usize {
+        self.write.len()
+    }
+
     /// Extracts XML tree of events from and stores them in the skipped events
     /// buffer from which they can be retrieved later. You MUST call
     /// [`Self::start_replay()`] after calling this to give access to the skipped
@@ -530,8 +538,8 @@ where
         Ok(())
     }
 
-    /// Moves all buffered events to the end of [`Self::write`] buffer and swaps
-    /// read and write buffers.
+    /// Moves buffered events, skipped after given `checkpoint` from [`Self::write`]
+    /// skip buffer to [`Self::read`] buffer.
     ///
     /// After calling this method, [`Self::peek()`] and [`Self::next()`] starts
     /// return events that was skipped previously by calling [`Self::skip()`],
@@ -541,9 +549,15 @@ where
     /// This method MUST be called if any number of [`Self::skip()`] was called
     /// after [`Self::new()`] or `start_replay()` or you'll lost events.
     #[cfg(feature = "overlapped-lists")]
-    fn start_replay(&mut self) {
-        self.write.append(&mut self.read);
-        std::mem::swap(&mut self.read, &mut self.write);
+    fn start_replay(&mut self, checkpoint: usize) {
+        if checkpoint == 0 {
+            self.write.append(&mut self.read);
+            std::mem::swap(&mut self.read, &mut self.write);
+        } else {
+            let mut read = self.write.split_off(checkpoint);
+            read.append(&mut self.read);
+            self.read = read;
+        }
     }
 
     fn next_start(&mut self) -> Result<Option<BytesStart<'de>>, DeError> {
@@ -1021,6 +1035,10 @@ mod tests {
             assert_eq!(de.next().unwrap(), Start(BytesStart::new("root")));
             assert_eq!(de.peek().unwrap(), &Start(BytesStart::new("inner")));
 
+            // Mark that start_replay() should begin replay from this point
+            let checkpoint = de.skip_checkpoint();
+            assert_eq!(checkpoint, 0);
+
             // Should skip first <inner> tree
             de.skip().unwrap();
             assert_eq!(de.read, vec![]);
@@ -1057,7 +1075,7 @@ mod tests {
             //
             //   <target/>
             // </root>
-            de.start_replay();
+            de.start_replay(checkpoint);
             assert_eq!(
                 de.read,
                 vec![
@@ -1071,6 +1089,10 @@ mod tests {
             assert_eq!(de.write, vec![]);
             assert_eq!(de.next().unwrap(), Start(BytesStart::new("inner")));
 
+            // Mark that start_replay() should begin replay from this point
+            let checkpoint = de.skip_checkpoint();
+            assert_eq!(checkpoint, 0);
+
             // Skip `#text` node and consume <inner/> after it
             de.skip().unwrap();
             assert_eq!(
@@ -1102,7 +1124,7 @@ mod tests {
             //
             //   <target/>
             // </root>
-            de.start_replay();
+            de.start_replay(checkpoint);
             assert_eq!(
                 de.read,
                 vec![
@@ -1142,6 +1164,10 @@ mod tests {
 
             assert_eq!(de.next().unwrap(), Start(BytesStart::new("root")));
 
+            // Mark that start_replay() should begin replay from this point
+            let checkpoint = de.skip_checkpoint();
+            assert_eq!(checkpoint, 0);
+
             // Skip the <skip> tree
             de.skip().unwrap();
             assert_eq!(de.read, vec![]);
@@ -1187,7 +1213,7 @@ mod tests {
             // and after that stream that messages:
             //
             // </root>
-            de.start_replay();
+            de.start_replay(checkpoint);
             assert_eq!(
                 de.read,
                 vec![
@@ -1232,6 +1258,10 @@ mod tests {
 
             assert_eq!(de.next().unwrap(), Start(BytesStart::new("root")));
 
+            // start_replay() should start replay from this point
+            let checkpoint1 = de.skip_checkpoint();
+            assert_eq!(checkpoint1, 0);
+
             // Should skip first and second <skipped-N/> elements
             de.skip().unwrap(); // skipped-1
             de.skip().unwrap(); // skipped-2
@@ -1268,18 +1298,23 @@ mod tests {
                 ]
             );
 
+            // start_replay() should start replay from this point
+            let checkpoint2 = de.skip_checkpoint();
+            assert_eq!(checkpoint2, 4);
+
             // Should skip third and forth <skipped-N/> elements
             de.skip().unwrap(); // skipped-3
             de.skip().unwrap(); // skipped-4
             assert_eq!(de.read, vec![]);
             assert_eq!(
                 de.write,
                 vec![
+                    // checkpoint 1
                     Start(BytesStart::new("skipped-1")),
                     End(BytesEnd::new("skipped-1")),
                     Start(BytesStart::new("skipped-2")),
                     End(BytesEnd::new("skipped-2")),
-                    // split point
+                    // checkpoint 2
                     Start(BytesStart::new("skipped-3")),
                     End(BytesEnd::new("skipped-3")),
                     Start(BytesStart::new("skipped-4")),
@@ -1313,7 +1348,8 @@ mod tests {
                 ]
             );
 
-            de.start_replay();
+            // Start replay events from checkpoint 2
+            de.start_replay(checkpoint2);
             assert_eq!(
                 de.read,
                 vec![
@@ -1369,7 +1405,8 @@ mod tests {
                 ]
             );
 
-            de.start_replay();
+            // Start replay events from checkpoint 1
+            de.start_replay(checkpoint1);
             assert_eq!(
                 de.read,
                 vec![

src/de/seq.rs

@@ -82,6 +82,12 @@ where
     /// When feature `overlapped-lists` is activated, all tags, that not pass
     /// this check, will be skipped.
     filter: TagFilter<'de>,
+
+    /// Checkpoint after which all skipped events should be returned. All events,
+    /// that was skipped before creating this checkpoint, will still stay buffered
+    /// and will not be returned
+    #[cfg(feature = "overlapped-lists")]
+    checkpoint: usize,
 }
 
 impl<'a, 'de, R> TopLevelSeqAccess<'de, 'a, R>
@@ -96,7 +102,13 @@ where
         } else {
             TagFilter::Exclude(&[])
         };
-        Ok(Self { de, filter })
+        Ok(Self {
+            #[cfg(feature = "overlapped-lists")]
+            checkpoint: de.skip_checkpoint(),
+
+            de,
+            filter,
+        })
     }
 }
 
@@ -106,7 +118,7 @@ where
     R: XmlRead<'de>,
 {
     fn drop(&mut self) {
-        self.de.start_replay();
+        self.de.start_replay(self.checkpoint);
     }
 }