ensure Eq and Ord use logical instead of physical value

Author: DPlayer234

src/bst_iter.rs

@@ -0,0 +1,60 @@
+#[cfg(target_pointer_width = "64")]
+use crate::BST_BITS;
+use crate::{BitSliceType, INLINE_SLICE_PARTS, SmolBitSet};
+
+pub enum BstIter<'a> {
+    Inline(core::array::IntoIter<BitSliceType, INLINE_SLICE_PARTS>),
+    Heap(core::slice::Iter<'a, BitSliceType>),
+}
+
+impl<'a> BstIter<'a> {
+    pub fn new(sbs: &'a SmolBitSet) -> Self {
+        if sbs.is_inline() {
+            let data = unsafe { sbs.get_inline_data_unchecked() };
+            #[cfg(target_pointer_width = "32")]
+            let data = [data as BitSliceType];
+            #[cfg(target_pointer_width = "64")]
+            let data = [(data as BitSliceType), ((data >> BST_BITS) as BitSliceType)];
+            return Self::Inline(data.into_iter());
+        } else {
+            let slice = unsafe { sbs.as_slice_unchecked() };
+            return Self::Heap(slice.iter());
+        }
+    }
+}
+
+impl Iterator for BstIter<'_> {
+    type Item = BitSliceType;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        match self {
+            Self::Inline(iter) => iter.next(),
+            Self::Heap(iter) => iter.next().copied(),
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        match self {
+            Self::Inline(iter) => iter.size_hint(),
+            Self::Heap(iter) => iter.size_hint(),
+        }
+    }
+}
+
+impl DoubleEndedIterator for BstIter<'_> {
+    fn next_back(&mut self) -> Option<Self::Item> {
+        match self {
+            Self::Inline(iter) => iter.next_back(),
+            Self::Heap(iter) => iter.next_back().copied(),
+        }
+    }
+}
+
+impl ExactSizeIterator for BstIter<'_> {
+    fn len(&self) -> usize {
+        match self {
+            Self::Inline(iter) => iter.len(),
+            Self::Heap(iter) => iter.len(),
+        }
+    }
+}

src/cmp.rs

@@ -1,21 +1,17 @@
 use crate::SmolBitSet;
+use crate::bst_iter::BstIter;
 
-use core::cmp;
+use core::{cmp, iter};
 
 impl cmp::PartialEq for SmolBitSet {
     fn eq(&self, other: &Self) -> bool {
-        match (self.len(), other.len()) {
-            (0, 0) => unsafe {
-                self.get_inline_data_unchecked() == other.get_inline_data_unchecked()
-            },
-            (a, b) if a == b => {
-                let a = unsafe { self.as_slice_unchecked() };
-                let b = unsafe { other.as_slice_unchecked() };
-
-                a == b
-            }
-            _ => false,
-        }
+        let mut this = BstIter::new(self);
+        let mut other = BstIter::new(other);
+
+        // head must all have the same bits and the tail for the longer one must be all zeroes
+        this.by_ref().zip(other.by_ref()).all(|(t, o)| t == o)
+            && this.all(|x| x == 0)
+            && other.all(|x| x == 0)
     }
 }
 
@@ -29,27 +25,24 @@ impl cmp::PartialOrd for SmolBitSet {
 
 impl cmp::Ord for SmolBitSet {
     fn cmp(&self, other: &Self) -> cmp::Ordering {
-        match (self.len(), other.len()) {
-            (0, 0) => unsafe {
-                self.get_inline_data_unchecked()
-                    .cmp(&other.get_inline_data_unchecked())
-            },
-            (0, _) => cmp::Ordering::Less,
-            (_, 0) => cmp::Ordering::Greater,
-            (a, b) if a == b => unsafe {
-                let a = self.as_slice_unchecked();
-                let b = other.as_slice_unchecked();
-
-                for (a, b) in a.iter().zip(b.iter()).rev() {
-                    let cmp = a.cmp(b);
-                    if cmp != cmp::Ordering::Equal {
-                        return cmp;
-                    }
+        fn inner(long: BstIter<'_>, short: BstIter<'_>) -> cmp::Ordering {
+            let mut final_cmp = cmp::Ordering::Equal;
+            for (a, b) in long.zip(short.chain(iter::repeat(0))) {
+                let cmp = a.cmp(&b);
+                if cmp != cmp::Ordering::Equal {
+                    final_cmp = cmp;
                 }
+            }
+            final_cmp
+        }
+
+        let this = BstIter::new(self);
+        let other = BstIter::new(other);
 
-                cmp::Ordering::Equal
-            },
-            (a, b) => a.cmp(&b),
+        if this.len() > other.len() {
+            inner(this, other)
+        } else {
+            inner(other, this).reverse()
         }
     }
 }

src/fmt.rs

@@ -1,4 +1,5 @@
-use crate::{BST_BITS, BitSliceType, SmolBitSet};
+use crate::bst_iter::BstIter;
+use crate::{BST_BITS, SmolBitSet};
 
 #[cfg(feature = "std")]
 use std::fmt;
@@ -10,14 +11,7 @@ use fmt::{Binary, Debug, Display, Formatter, LowerHex, Octal, Result, UpperHex};
 
 impl Debug for SmolBitSet {
     fn fmt(&self, f: &mut Formatter<'_>) -> Result {
-        let data = if self.is_inline() {
-            let d = unsafe { self.get_inline_data_unchecked() };
-            &[d as BitSliceType, (d >> BST_BITS) as BitSliceType]
-        } else {
-            unsafe { self.as_slice_unchecked() }
-        };
-
-        f.debug_list().entries(data).finish()
+        f.debug_list().entries(BstIter::new(self)).finish()
     }
 }
 

src/lib.rs

@@ -62,6 +62,7 @@ macro_rules! highest_set_bit {
 }
 
 mod bitop;
+mod bst_iter;
 mod cmp;
 mod fmt;
 mod from;
@@ -1123,5 +1124,49 @@ mod tests {
             b <<= 72;
             assert!(a < b);
         }
+
+        #[test]
+        fn eq_but_not_physical_same() {
+            let mut a = SmolBitSet::from(u16::MAX);
+            let mut b = SmolBitSet::from(0xFFFFu16);
+
+            // ensure a is larger than b in memory
+            a.spill(256);
+
+            assert_eq!(a, b);
+            assert_eq!(b, a);
+
+            a <<= 55;
+            assert_ne!(a, b);
+            assert_ne!(b, a);
+
+            b <<= 55;
+            assert_eq!(a, b);
+            assert_eq!(b, a);
+        }
+
+        #[test]
+        fn ord_but_not_physical_same() {
+            let mut a = SmolBitSet::from(0xBEEFu16);
+            let mut b = SmolBitSet::from(0x00C5_F00Du32);
+
+            // ensure a is larger than b in memory
+            a.spill(256);
+
+            assert!(a < b);
+            assert!(b > a);
+
+            a <<= 18;
+            assert!(a > b);
+            assert!(b < a);
+
+            a <<= 54;
+            assert!(a > b);
+            assert!(b < a);
+
+            b <<= 72;
+            assert!(a < b);
+            assert!(b > a);
+        }
     }
 }