Merge pull request #7 from dewert99/bitset

Make bitset public

src/raw.rs

@@ -6,7 +6,8 @@ mod semi_persistent;
 /// One variant of semi_persistence
 pub mod semi_persistent1;
 
-mod bitset;
+/// A simple bitset
+pub mod bitset;
 pub(crate) mod language;
 /// Another variant of semi_persistence
 pub mod semi_persistent2;

src/raw/bitset.rs

@@ -4,6 +4,7 @@ use serde::{Deserialize, Serialize};
 use std::fmt::{Debug, Formatter};
 use std::mem;
 
+/// A mapping from indexes to values where all indexes initially map to [`Default::default`]
 #[derive(Debug, Default, Clone)]
 #[cfg_attr(feature = "serde-1", derive(Serialize, Deserialize))]
 pub struct DefaultVec<T>(Box<[T]>);
@@ -19,6 +20,7 @@ impl<T: Default> DefaultVec<T> {
         assert!(i < self.0.len())
     }
 
+    /// Returns mutable access to the element at `i`
     pub fn get_mut(&mut self, i: usize) -> &mut T {
         if i < self.0.len() {
             &mut self.0[i]
@@ -28,13 +30,15 @@ impl<T: Default> DefaultVec<T> {
         }
     }
 
+    /// Returns shared access to the element at `i`
     pub fn get(&self, i: usize) -> T
     where
         T: Copy,
     {
         self.0.get(i).copied().unwrap_or_default()
     }
 
+    /// Resets all elements to there default value
     pub fn clear(&mut self) {
         self.0.fill_with(Default::default)
     }
@@ -52,21 +56,27 @@ fn split(x: usize) -> (usize, Elt) {
     (x / Elt::BITS as usize, 1 << offset)
 }
 
+/// Set of indexes
 impl BitSet {
+    /// Adds an element to the set
     pub fn insert(&mut self, x: usize) -> bool {
         let (chunk_idx, mask) = split(x);
         let chunk = self.0.get_mut(chunk_idx);
         let res = (*chunk & mask) != 0;
         *chunk |= mask;
         res
     }
+
+    /// Removes an element form the set
     pub fn remove(&mut self, x: usize) -> bool {
         let (chunk_idx, mask) = split(x);
         let chunk = self.0.get_mut(chunk_idx);
         let res = (*chunk & mask) != 0;
         *chunk &= !mask;
         res
     }
+
+    /// Checks if the set contains an element
     pub fn contains(&self, x: usize) -> bool {
         let (chunk_idx, mask) = split(x);
         let chunk = self.0.get(chunk_idx);
@@ -80,10 +90,14 @@ impl BitSet {
         (chunk & mask) != 0
     }
 
+    /// Removes all elements from the set
     pub fn clear(&mut self) {
         self.0.clear()
     }
 
+    /// Iterate over all elements in the set
+    /// Run time is proportional to the largest element that has ever been in the set
+
     pub fn iter(&self) -> impl Iterator<Item = usize> + '_ {
         let max = self.0 .0.len() * (Elt::BITS as usize);
         (0..max).filter(|x| self.contains(*x))