Add ability to skip in tree searches

Author: Andrew Jeffery

automerge/src/op_tree.rs

@@ -98,7 +98,8 @@ impl OpTreeInternal {
         self.root_node
             .as_ref()
             .map(|root| match query.query_node_with_metadata(root, m) {
-                QueryResult::Descend => root.search(&mut query, m),
+                QueryResult::Descend => root.search(&mut query, m, None),
+                QueryResult::Skip(skip) => root.search(&mut query, m, Some(skip)),
                 _ => true,
             });
         query
@@ -212,31 +213,62 @@ impl OpTreeNode {
         }
     }
 
-    pub(crate) fn search<'a, 'b: 'a, Q>(&'b self, query: &mut Q, m: &OpSetMetadata) -> bool
+    pub(crate) fn search<'a, 'b: 'a, Q>(
+        &'b self,
+        query: &mut Q,
+        m: &OpSetMetadata,
+        skip: Option<usize>,
+    ) -> bool
     where
         Q: TreeQuery<'a>,
     {
         if self.is_leaf() {
-            for e in &self.elements {
+            let skip = skip.unwrap_or(0);
+            for e in self.elements.iter().skip(skip) {
                 if query.query_element_with_metadata(e, m) == QueryResult::Finish {
                     return true;
                 }
             }
             false
         } else {
+            let mut skip = skip.unwrap_or(0);
             for (child_index, child) in self.children.iter().enumerate() {
-                match query.query_node_with_metadata(child, m) {
-                    QueryResult::Descend => {
-                        if child.search(query, m) {
-                            return true;
+                match skip.cmp(&child.len()) {
+                    Ordering::Greater => {
+                        // not in this child at all
+                        // take off the number of elements in the child as well as the next element
+                        skip -= child.len() + 1;
+                    }
+                    Ordering::Equal => {
+                        // just try the element
+                        skip -= child.len();
+                        if let Some(e) = self.elements.get(child_index) {
+                            if query.query_element_with_metadata(e, m) == QueryResult::Finish {
+                                return true;
+                            }
                         }
                     }
-                    QueryResult::Finish => return true,
-                    QueryResult::Next => (),
-                }
-                if let Some(e) = self.elements.get(child_index) {
-                    if query.query_element_with_metadata(e, m) == QueryResult::Finish {
-                        return true;
+                    Ordering::Less => {
+                        // descend and try find it
+                        match query.query_node_with_metadata(child, m) {
+                            QueryResult::Descend => {
+                                // search in the child node, passing in the number of items left to
+                                // skip
+                                if child.search(query, m, Some(skip)) {
+                                    return true;
+                                }
+                            }
+                            QueryResult::Finish => return true,
+                            QueryResult::Next => (),
+                            QueryResult::Skip(_) => panic!("had skip from non-root node"),
+                        }
+                        if let Some(e) = self.elements.get(child_index) {
+                            if query.query_element_with_metadata(e, m) == QueryResult::Finish {
+                                return true;
+                            }
+                        }
+                        // reset the skip to zero so we continue iterating normally
+                        skip = 0;
                     }
                 }
             }

automerge/src/query.rs

@@ -86,6 +86,8 @@ pub(crate) trait TreeQuery<'a> {
 #[derive(Debug, Clone, PartialEq)]
 pub(crate) enum QueryResult {
     Next,
+    /// Skip this many elements, only allowed from the root node.
+    Skip(usize),
     Descend,
     Finish,
 }

automerge/src/query/prop.rs

@@ -47,16 +47,12 @@ impl<'a> TreeQuery<'a> for Prop<'a> {
             // in the root node find the first op position for the key
             let start = binary_search_by(child, |op| m.key_cmp(&op.key, &self.key));
             self.start = Some(start);
-            QueryResult::Descend
+            self.pos = start;
+            QueryResult::Skip(start)
         }
     }
 
     fn query_element(&mut self, op: &'a Op) -> QueryResult {
-        // skip to our start
-        if self.pos < self.start.unwrap() {
-            self.pos += 1;
-            return QueryResult::Next;
-        }
         // don't bother looking at things past our key
         if op.key != self.key {
             return QueryResult::Finish;