Ensure invariance

Author: aneubeck

crates/geo_filters/src/diff_count.rs

@@ -210,17 +210,16 @@ impl<C: GeoConfig<Diff>> GeoDiffCount<'_, C> {
             match msb.binary_search_by(|k| bucket.cmp(k)) {
                 Ok(idx) => {
                     msb.remove(idx);
-                    let (first, second) = {
+                    let first = {
                         let mut lsb = iter_ones(self.lsb.bit_chunks().peekable());
-                        (lsb.next(), lsb.next())
+                        lsb.next()
                     };
-                    let new_smallest = if let Some(smallest) = first {
+                    if let Some(smallest) = first {
                         msb.push(C::BucketType::from_usize(smallest));
-                        second.map(|_| smallest).unwrap_or(0)
+                        self.lsb.resize(smallest);
                     } else {
-                        0
+                        self.lsb.resize(0);
                     };
-                    self.lsb.resize(new_smallest);
                 }
                 Err(idx) => {
                     msb.insert(idx, bucket);
@@ -236,6 +235,12 @@ impl<C: GeoConfig<Diff>> GeoDiffCount<'_, C> {
                             .into_usize();
                         self.lsb.resize(new_smallest);
                         self.lsb.toggle(smallest);
+                    } else if msb.len() == self.config.max_msb_len() {
+                        let smallest = msb
+                            .last()
+                            .expect("should have at least one element")
+                            .into_usize();
+                        self.lsb.resize(smallest);
                     }
                 }
             }

crates/geo_filters/src/diff_count/bitvec.rs

@@ -12,20 +12,12 @@ use crate::config::BITS_PER_BLOCK;
 /// bit consumes 1 byte). It only implements the minimum number of operations that we need for our
 /// GeoDiffCount implementation. In particular it supports xor-ing of two bit vectors and
 /// iterating through one bits.
-#[derive(Clone, Default, Debug)]
+#[derive(Clone, Default, Debug, Eq, PartialEq)]
 pub(crate) struct BitVec<'a> {
     num_bits: usize,
     blocks: Cow<'a, [u64]>,
 }
 
-impl PartialEq for BitVec<'_> {
-    fn eq(&self, other: &Self) -> bool {
-        self.bit_chunks().eq(other.bit_chunks())
-    }
-}
-
-impl Eq for BitVec<'_> {}
-
 impl Ord for BitVec<'_> {
     fn cmp(&self, other: &Self) -> std::cmp::Ordering {
         match self.num_bits.cmp(&other.num_bits) {
@@ -49,11 +41,9 @@ impl BitVec<'_> {
     /// NOTE: If the bitchunks iterator is empty, the result is NOT sized to `num_bits` but will
     ///       be EMPTY instead.
     pub fn from_bit_chunks<I: Iterator<Item = BitChunk>>(
-        mut chunks: Peekable<I>,
+        chunks: Peekable<I>,
         num_bits: usize,
     ) -> Self {
-        // if there are no chunks, we keep the size zero
-        let num_bits = chunks.peek().map(|_| num_bits).unwrap_or_default();
         let mut result = Self::default();
         result.resize(num_bits);
         let blocks = result.blocks.to_mut();