Use InOrderIter from git-features (#293)

Author: Byron

git-features/src/parallel/in_order.rs

@@ -1,7 +1,7 @@
 use std::{cmp::Ordering, collections::BTreeMap};
 
-/// A counter for chunks to be able to put them back into original order later.
-pub type ChunkId = usize;
+/// A counter for items that are in sequence, to be able to put them back into original order later.
+pub type SequenceId = usize;
 
 /// An iterator which olds iterated items with a **sequential** ID starting at 0 long enough to dispense them in order.
 ///
@@ -10,14 +10,14 @@ pub type ChunkId = usize;
 pub struct InOrderIter<T, I> {
     /// The iterator yielding the out-of-order elements we are to yield in order.
     pub inner: I,
-    store: BTreeMap<ChunkId, T>,
-    next_chunk: ChunkId,
+    store: BTreeMap<SequenceId, T>,
+    next_chunk: SequenceId,
     is_done: bool,
 }
 
 impl<T, E, I> From<I> for InOrderIter<T, I>
 where
-    I: Iterator<Item = Result<(ChunkId, T), E>>,
+    I: Iterator<Item = Result<(SequenceId, T), E>>,
 {
     fn from(iter: I) -> Self {
         InOrderIter {
@@ -31,7 +31,7 @@ where
 
 impl<T, E, I> Iterator for InOrderIter<T, I>
 where
-    I: Iterator<Item = Result<(ChunkId, T), E>>,
+    I: Iterator<Item = Result<(SequenceId, T), E>>,
 {
     type Item = Result<T, E>;
 

git-features/src/parallel/mod.rs

@@ -42,7 +42,7 @@ mod serial;
 pub use serial::{in_parallel, join, threads};
 
 mod in_order;
-pub use in_order::InOrderIter;
+pub use in_order::{InOrderIter, SequenceId};
 
 mod eager_iter;
 pub use eager_iter::{EagerIter, EagerIterIf};

git-pack/src/data/output/entry/iter_from_counts.rs

@@ -1,8 +1,9 @@
 use std::{cmp::Ordering, sync::Arc};
 
+use git_features::parallel::SequenceId;
 use git_features::{parallel, progress::Progress};
 
-use crate::data::{output, output::ChunkId};
+use crate::data::output;
 
 /// Given a known list of object `counts`, calculate entries ready to be put into a data pack.
 ///
@@ -44,7 +45,7 @@ pub fn iter_from_counts<Find>(
         thread_limit,
         chunk_size,
     }: Options,
-) -> impl Iterator<Item = Result<(ChunkId, Vec<output::Entry>), Error<Find::Error>>>
+) -> impl Iterator<Item = Result<(SequenceId, Vec<output::Entry>), Error<Find::Error>>>
        + parallel::reduce::Finalize<Reduce = reduce::Statistics<Error<Find::Error>>>
 where
     Find: crate::Find + Send + Clone + 'static,
@@ -152,7 +153,7 @@ where
         },
         {
             let counts = Arc::clone(&counts);
-            move |(chunk_id, chunk_range): (ChunkId, std::ops::Range<usize>), (buf, progress)| {
+            move |(chunk_id, chunk_range): (SequenceId, std::ops::Range<usize>), (buf, progress)| {
                 let mut out = Vec::new();
                 let chunk = &counts[chunk_range];
                 let mut stats = Outcome::default();
@@ -277,8 +278,9 @@ mod reduce {
     use std::marker::PhantomData;
 
     use git_features::parallel;
+    use git_features::parallel::SequenceId;
 
-    use super::{ChunkId, Outcome};
+    use super::Outcome;
     use crate::data::output;
 
     pub struct Statistics<E> {
@@ -296,8 +298,8 @@ mod reduce {
     }
 
     impl<Error> parallel::Reduce for Statistics<Error> {
-        type Input = Result<(ChunkId, Vec<output::Entry>, Outcome), Error>;
-        type FeedProduce = (ChunkId, Vec<output::Entry>);
+        type Input = Result<(SequenceId, Vec<output::Entry>, Outcome), Error>;
+        type FeedProduce = (SequenceId, Vec<output::Entry>);
         type Output = Outcome;
         type Error = Error;
 

git-pack/src/data/output/in_order.rs

@@ -39,6 +39,3 @@ pub mod entry;
 
 ///
 pub mod bytes;
-
-mod in_order;
-pub use in_order::{ChunkId, InOrderIter};

git-pack/src/data/output/mod.rs

@@ -1,5 +1,6 @@
 use std::{convert::Infallible, sync::atomic::AtomicBool};
 
+use git_features::parallel::InOrderIter;
 use git_features::{parallel::reduce::Finalize, progress};
 use git_odb::{compound, pack, pack::FindExt};
 use git_pack::data::{
@@ -291,7 +292,7 @@ fn traversals() -> crate::Result {
                     ..Default::default()
                 },
             );
-            let entries: Vec<_> = output::InOrderIter::from(entries_iter.by_ref())
+            let entries: Vec<_> = InOrderIter::from(entries_iter.by_ref())
                 .collect::<Result<Vec<_>, _>>()?
                 .into_iter()
                 .flatten()

git-pack/tests/pack/data/output/count_and_entries.rs

@@ -44,4 +44,3 @@ fn db(kind: DbKind) -> crate::Result<git_odb::HandleArc> {
 }
 
 mod count_and_entries;
-mod in_order_iter;