generalize extension writing so that writing more will be easier

Byron · Byron · commit 8ef5378dfaef · 2022-08-13T10:32:42.000+08:00
diff --git a/git-index/src/extension/end_of_index_entry/write.rs b/git-index/src/extension/end_of_index_entry/write.rs
@@ -11,7 +11,7 @@ pub fn write_to(
     out: &mut impl std::io::Write,
     hash_kind: git_hash::Kind,
     offset_to_extensions: u32,
-    prior_extensions: &[(Signature, u32)],
+    prior_extensions: impl Iterator<Item = (Signature, u32)>,
 ) -> Result<(), std::io::Error> {
     out.write_all(&SIGNATURE)?;
     let extension_size: u32 = 4 + hash_kind.len_in_bytes() as u32;
@@ -21,7 +21,7 @@ pub fn write_to(
 
     let mut hasher = git_features::hash::hasher(hash_kind);
     for (signature, size) in prior_extensions {
-        hasher.update(signature);
+        hasher.update(&signature);
         hasher.update(&size.to_be_bytes());
     }
     out.write_all(&hasher.digest())?;
diff --git a/git-index/src/write.rs b/git-index/src/write.rs
@@ -63,21 +63,35 @@ impl State {
         let offset_to_entries = header(&mut write, version, num_entries)?;
         let offset_to_extensions = entries(&mut write, self, offset_to_entries)?;
 
-        let mut extensions = Vec::with_capacity(5);
-        if let Some(offset_past_tree_ext) = tree_cache_extension
-            .then(|| self.tree())
-            .flatten()
-            .map(|tree| tree.write_to(&mut write).map(|_| write.count))
-            .transpose()?
-        {
-            extensions.push((
-                extension::tree::SIGNATURE,
-                offset_past_tree_ext - offset_to_extensions - (extension::MIN_SIZE as u32),
-            ));
-        }
+        let extensions = {
+            let extensions: &[&dyn Fn(&mut dyn std::io::Write) -> Option<std::io::Result<extension::Signature>>] =
+                &[&|write| {
+                    tree_cache_extension
+                        .then(|| self.tree())
+                        .flatten()
+                        .map(|tree| tree.write_to(write).map(|_| extension::tree::SIGNATURE))
+                }];
+
+            let mut offset_to_previous_ext = offset_to_extensions;
+            let mut out = Vec::with_capacity(5);
+            for write_ext in extensions {
+                if let Some(signature) = write_ext(&mut write).transpose()? {
+                    let offset_past_ext = write.count;
+                    let ext_size = offset_past_ext - offset_to_previous_ext - (extension::MIN_SIZE as u32);
+                    offset_to_previous_ext = offset_past_ext;
+                    out.push((signature, ext_size));
+                }
+            }
+            out
+        };
 
         if num_entries > 0 && end_of_index_entry_extension && !extensions.is_empty() {
-            extension::end_of_index_entry::write_to(write.inner, hash_kind, offset_to_extensions, &extensions)?
+            extension::end_of_index_entry::write_to(
+                write.inner,
+                hash_kind,
+                offset_to_extensions,
+                extensions.into_iter(),
+            )?
         }
 
         Ok(())
