feat: search::Outcome::copy_into() can now copy values from a previous search.

This allows to perform a search once, finding all attributes, and
then copy the results over to another outcome, typically one with
selected attributes.

Author: Byron

gix-attributes/src/search/outcome.rs

@@ -73,6 +73,26 @@ impl Outcome {
             self.selected.iter().filter(|(_name, id)| id.is_some()).count()
         });
     }
+
+    /// A performance optimization which allows results from this instance to be efficiently copied over to `dest`.
+    /// For this to work, `collection` must be the one used to initialize our state, and `dest` should not have been initialized
+    /// with any meaningful collection initially, i.e. be empty the first time this method is called.
+    ///
+    /// Note that it's safe to call it multiple times, so that it can be called after this instance was used to store a search result.
+    pub fn copy_into(&self, collection: &MetadataCollection, dest: &mut Self) {
+        dest.initialize(collection);
+        dest.matches_by_id = self.matches_by_id.clone();
+        if dest.patterns.len() != self.patterns.len() {
+            dest.patterns = self.patterns.clone();
+        }
+        if dest.assignments.len() != self.assignments.len() {
+            dest.assignments = self.assignments.clone();
+        }
+        if dest.source_paths.len() != self.source_paths.len() {
+            dest.source_paths = self.source_paths.clone();
+        }
+        dest.remaining = self.remaining;
+    }
 }
 
 /// Access

gix-attributes/src/search/refmap.rs

@@ -21,6 +21,9 @@ impl<T> RefMap<T>
 where
     T: Hash + Clone,
 {
+    pub(crate) fn len(&self) -> usize {
+        self.0.len()
+    }
     pub(crate) fn insert(&mut self, value: &T) -> RefMapKey {
         let mut s = DefaultHasher::new();
         value.hash(&mut s);

gix-attributes/tests/search/mod.rs

@@ -141,8 +141,10 @@ fn all_attributes_are_listed_in_declaration_order() -> crate::Result {
         true, /* use macros */
     )?;
 
-    let mut out = gix_attributes::search::Outcome::default();
+    let mut out = Outcome::default();
     out.initialize(&collection);
+    let mut alt = Outcome::default();
+    alt.initialize(&collection);
 
     let mut orders = collection
         .iter()
@@ -206,10 +208,13 @@ fn all_attributes_are_listed_in_declaration_order() -> crate::Result {
         assert_references(&out);
         let actual: Vec<_> = out.iter().map(|m| m.assignment).collect();
         assert_eq!(
-            by_name(actual),
+            by_name(actual.clone()),
             by_name(expected),
             "{rela_path}: the order of everything matches perfectly"
         );
+        out.copy_into(&collection, &mut alt);
+        let alt_actual: Vec<_> = alt.iter().map(|m| m.assignment).collect();
+        assert_eq!(alt_actual, actual);
     }
     assert_eq!(
         out.iter().count(),
@@ -234,8 +239,10 @@ fn given_attributes_are_made_available_in_given_order() -> crate::Result {
         true, /* use macros */
     )?;
 
-    let mut out = gix_attributes::search::Outcome::default();
+    let mut out = Outcome::default();
     out.initialize_with_selection(&collection, ["my-binary", "recursive", "unspecified"]);
+    let mut alt = Outcome::default();
+    alt.initialize_with_selection(&collection, ["my-binary", "unspecified"]);
 
     for (rela_path, expected) in (baseline::Expectations { lines: input.lines() }) {
         out.reset();
@@ -246,6 +253,10 @@ fn given_attributes_are_made_available_in_given_order() -> crate::Result {
             actual, expected,
             "{rela_path}: the order of everything matches perfectly"
         );
+        out.copy_into(&collection, &mut alt);
+        let alt_actual: Vec<_> = alt.iter_selected().map(|m| m.assignment).collect();
+        assert_eq!(alt_actual[0], actual[0]);
+        assert_eq!(alt_actual[1], actual[2]);
     }
     assert_eq!(
         out.iter().count(),
@@ -255,6 +266,15 @@ fn given_attributes_are_made_available_in_given_order() -> crate::Result {
     Ok(())
 }
 
+#[test]
+fn size_of_outcome() {
+    assert_eq!(
+        std::mem::size_of::<Outcome>(),
+        904,
+        "it's quite big, shouldn't change without us noticing"
+    )
+}
+
 fn by_name(assignments: Vec<AssignmentRef>) -> BTreeMap<NameRef, StateRef> {
     assignments.into_iter().map(|a| (a.name, a.state)).collect()
 }