256bit deserealization arithmetic overflow fix

src/bitset/serialization.rs

@@ -29,7 +29,10 @@ where
         let mut block_indices: BlockIndices = unsafe{MaybeUninit::zeroed().assume_init()};
         mask.for_each_bit(|i|{
             block_indices.as_mut()[i] = *index_offset;
-            *index_offset += Primitive::ONE;
+            // Allowed to overflow here, on the very last round with 
+            // BlockIndices::Item=u8 and 256bit config. 
+            // (root level with 256 items)
+            index_offset.wrapping_add(Primitive::ONE);
         });
         block_indices
     };

src/primitive.rs

@@ -36,6 +36,7 @@ pub trait Primitive:
 
     fn trailing_zeros(self) -> u32;
     fn wrapping_neg(self) -> Self;
+    fn wrapping_add(self, rhs: Self) -> Self;
 
     fn is_zero(self) -> bool;
 }
@@ -69,6 +70,11 @@ macro_rules! impl_primitive {
                 self.wrapping_neg()
             }
 
+            #[inline]
+            fn wrapping_add(self, rhs: Self) -> Self {
+                self.wrapping_add(rhs)
+            }
+
             #[inline]
             fn is_zero(self) -> bool {
                 self == 0

tests/serde.rs

@@ -0,0 +1,14 @@
+use rand::{thread_rng, Rng};
+
+type BitSet = hi_sparse_bitset::BitSet<hi_sparse_bitset::config::_256bit>;
+
+#[test]
+fn serde() {
+    let mut rng = thread_rng();
+    let bitset: BitSet = (0..BitSet::max_capacity())
+        .filter(|_| rng.gen())
+        .collect();
+    let mut buffer = Vec::new();
+    bitset.serialize(&mut buffer).unwrap();
+    assert_eq!(bitset, BitSet::deserialize(&mut buffer.as_slice()).unwrap());
+}