fix: calculation method both for bucket bits in std/nod_std

Author: cavivie

src/slotbkvec.rs

@@ -45,8 +45,14 @@ impl<'a, T, const N: usize> SlotBkVec<'a, T, N> {
         // N <= 4:  last tow bits   mask: 0b11   , buckets: (0,1,2,3)
         // N <= 8:  last three bits mask: 0b111  , buckets: (0,1,2,3,4,5,6,7)
         // N <= 16: last four bits  mask: 0b1111 , buckets: (0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15)
-        let buckets = N;
-        (buckets as f64).log2().ceil() as usize
+        // this calculation method only works in std: `(N as f64).log2().ceil() as usize`
+        match N {
+            1..=2 => 1,
+            3..=4 => 2,
+            5..=8 => 3,
+            9..=16 => 4,
+            _ => unreachable!(),
+        }
     }
 
     /// Returns the bucket mask from bucket bit numbers.
@@ -86,7 +92,7 @@ impl<'a, T, const N: usize> SlotBkVec<'a, T, N> {
         (index << bucket_bits) | (buket & bucket_mask)
     }
 
-    /// Iterates every element in all of bucket slices in this buckets, as mutable.
+    /// Iterates every element of all slices of the buckets, as mutable.
     #[auto_enums::auto_enum(DoubleEndedIterator)]
     fn iter_mut_impl<'s>(&'s mut self) -> impl DoubleEndedIterator<Item = &'s mut T> {
         // This implementation does not affect performance, because N is determined
@@ -194,17 +200,17 @@ impl<'a, T, const N: usize> SlotBkVec<'a, T, N> {
         self.buckets[buket].remove(index)
     }
 
-    /// Returns the number of valid elements in all of bucket slices in this buckets.
+    /// Returns the number of valid elements of all slices of the buckets.
     pub fn len(&self) -> usize {
         self.iter().count()
     }
 
-    /// Returns true if all of bucket slices in this buckets contains no valid elements.
+    /// Returns true if all slices of the buckets contains no valid elements.
     pub fn is_empty(&self) -> bool {
         self.len() == 0
     }
 
-    /// Iterates every element in the bucket slice of this buckets, as immutable.
+    /// Iterates every element of the bucket slice, as immutable.
     ///
     /// # Panics
     /// This function panics if the bucket number is overflow (>N).
@@ -218,7 +224,7 @@ impl<'a, T, const N: usize> SlotBkVec<'a, T, N> {
         .flatten()
     }
 
-    /// Iterates every element in the bucket slice of this buckets, as mutable.
+    /// Iterates every element of the bucket slice, as mutable.
     ///
     /// # Panics
     /// This function panics if the bucket number is overflow (>N).
@@ -235,12 +241,12 @@ impl<'a, T, const N: usize> SlotBkVec<'a, T, N> {
         .flatten()
     }
 
-    /// Iterates every element in all of bucket slices in this buckets, as immutable.
+    /// Iterates every element of all slices of the buckets, as immutable.
     pub fn iter<'s>(&'s self) -> impl DoubleEndedIterator<Item = &'s T> {
         self.buckets.iter().flat_map(|slice| slice.iter())
     }
 
-    /// Iterates every element in all of bucket slices in this buckets, as mutable.
+    /// Iterates every element of all slices of the buckets, as mutable.
     pub fn iter_mut<'s>(&'s mut self) -> impl DoubleEndedIterator<Item = &'s mut T> {
         // NB: In the future we may use a more concise Rust API like this.
         // Although it is possible to use the Captures trick here,

src/slotdeque.rs

@@ -128,15 +128,15 @@ impl<'a, T> SlotDeque<'a, T> {
         self.slices.bucket_iter_mut(Self::BUCKET_BACK)
     }
 
-    /// Iterates every element in this deque, as immutable.
+    /// Iterates every element of this deque, as immutable.
     pub fn iter<'s>(&'s self) -> impl DoubleEndedIterator<Item = &'s T> {
         // Compile ok because that borrow immutable on self.
         // self.front_iter().chain(self.back_iter())
         let [front, back] = self.slices.each_ref();
         front.rev().chain(back)
     }
 
-    /// Iterates every element in this deque, as mutable.
+    /// Iterates every element of this deque, as mutable.
     pub fn iter_mut<'s>(&'s mut self) -> impl DoubleEndedIterator<Item = &'s mut T> {
         // Compile error because that borrow twice mutable on self.
         // self.front_iter_mut().chain(self.back_iter_mut())

src/slotvec.rs

@@ -9,7 +9,7 @@ use super::ManagedSlice as Slice;
 
 /// Provides a slotvec based on external memory.
 ///
-/// Provides a mapping between slots and elements.
+/// Provides mappings between slots and elements.
 ///
 /// A slotvec provides a vector(`Vec`)-like interface where each entry is
 /// associated with a stable index. Lookup with the index will detect if
@@ -82,7 +82,7 @@ impl<'a, T> SlotVec<'a, T> {
         }
     }
 
-    /// Pushes an element to the back of the bucket slice in the vec.
+    /// Pushes an element to the back in the vec.
     ///
     /// Returns None if the slice is fixed-size (not a `Vec`) and is full.
     pub fn push(&mut self, elem: T) -> Option<usize> {
@@ -127,12 +127,12 @@ impl<'a, T> SlotVec<'a, T> {
         self.len() == 0
     }
 
-    /// Iterates every element in the bucket slice of this vec, as immutable.
+    /// Iterates every element of this vec, as immutable.
     pub fn iter<'s>(&'s self) -> impl DoubleEndedIterator<Item = &'s T> {
         self.slice.iter().filter_map(|slot| slot.as_ref())
     }
 
-    /// Iterates every element in the bucket slice of this vec, as mutable.
+    /// Iterates every element of this vec, as mutable.
     pub fn iter_mut<'s>(&'s mut self) -> impl DoubleEndedIterator<Item = &'s mut T> {
         self.slice.iter_mut().filter_map(|slot| slot.as_mut())
     }