Struct ScalarBitSet

pub struct ScalarBitSet<T>(pub T);

A small bitset built on top of a single primitive integer type.

Example

use cranelift_bitset::ScalarBitSet;

// Create a new bitset backed with a `u32`.
let mut bitset = ScalarBitSet::<u32>::new();

// Bitsets are initially empty.
assert!(bitset.is_empty());
assert_eq!(bitset.len(), 0);

// Insert into the bitset.
bitset.insert(4);
bitset.insert(5);
bitset.insert(6);

// Now the bitset is not empty.
assert_eq!(bitset.len(), 3);
assert!(!bitset.is_empty());
assert!(bitset.contains(4));
assert!(bitset.contains(5));
assert!(bitset.contains(6));

// Remove an element from the bitset.
let was_present = bitset.remove(6);
assert!(was_present);
assert!(!bitset.contains(6));
assert_eq!(bitset.len(), 2);

// Can iterate over the elements in the set.
let elems: Vec<_> = bitset.iter().collect();
assert_eq!(elems, [4, 5]);

Tuple Fields

0: T

Implementations

impl<T> ScalarBitSet<T>

where T: ScalarBitSetStorage,

pub fn new() -> Self

Create a new, empty bitset.

Example

use cranelift_bitset::ScalarBitSet;

let bitset = ScalarBitSet::<u64>::new();

assert!(bitset.is_empty());

pub fn from_range(lo: u8, hi: u8) -> Self

Construct a bitset with the half-open range [lo, hi) inserted.

Example

use cranelift_bitset::ScalarBitSet;

let bitset = ScalarBitSet::<u64>::from_range(3, 6);

assert_eq!(bitset.len(), 3);

assert!(bitset.contains(3));
assert!(bitset.contains(4));
assert!(bitset.contains(5));

Panics

Panics if lo > hi or if hi > Self::capacity().

use cranelift_bitset::ScalarBitSet;

// The lower bound may not be larger than the upper bound.
let bitset = ScalarBitSet::<u64>::from_range(6, 3);

use cranelift_bitset::ScalarBitSet;

// The bounds must fit within the backing scalar type.
let bitset = ScalarBitSet::<u64>::from_range(3, 69);

pub fn capacity() -> u8

The maximum number of bits that can be stored in this bitset.

If you need more bits than this, use a CompoundBitSet instead of a ScalarBitSet.

Example

use cranelift_bitset::ScalarBitSet;

assert_eq!(ScalarBitSet::<u8>::capacity(), 8);
assert_eq!(ScalarBitSet::<u64>::capacity(), 64);

pub fn len(&self) -> u8

Get the number of elements in this set.

Example

use cranelift_bitset::ScalarBitSet;

let mut bitset = ScalarBitSet::<u64>::new();

assert_eq!(bitset.len(), 0);

bitset.insert(24);
bitset.insert(13);
bitset.insert(36);

assert_eq!(bitset.len(), 3);

pub fn is_empty(&self) -> bool

Is this bitset empty?

Example

use cranelift_bitset::ScalarBitSet;

let mut bitset = ScalarBitSet::<u16>::new();

assert!(bitset.is_empty());

bitset.insert(10);

assert!(!bitset.is_empty());

pub fn contains(&self, i: u8) -> bool

Check whether this bitset contains i.

Example

use cranelift_bitset::ScalarBitSet;

let mut bitset = ScalarBitSet::<u8>::new();

assert!(!bitset.contains(7));

bitset.insert(7);

assert!(bitset.contains(7));

Panics

Panics if i is greater than or equal to Self::capacity().

use cranelift_bitset::ScalarBitSet;

let mut bitset = ScalarBitSet::<u8>::new();

// A `ScalarBitSet<u8>` can only hold the elements `0..=7`, so `8` is
// out of bounds and will trigger a panic.
bitset.contains(8);

pub fn insert(&mut self, i: u8) -> bool

Insert i into this bitset.

Returns whether the value was newly inserted. That is:

• If the set did not previously contain i then true is returned.

• If the set already contained i then false is returned.

Example

use cranelift_bitset::ScalarBitSet;

let mut bitset = ScalarBitSet::<u8>::new();

// When an element is inserted that was not already present in the set,
// then `true` is returned.
let is_new = bitset.insert(7);
assert!(is_new);

// The element is now present in the set.
assert!(bitset.contains(7));

// And when the element is already in the set, `false` is returned from
// `insert`.
let is_new = bitset.insert(7);
assert!(!is_new);

Panics

Panics if i is greater than or equal to Self::capacity().

use cranelift_bitset::ScalarBitSet;

let mut bitset = ScalarBitSet::<u32>::new();

// A `ScalarBitSet<u32>` can only hold the elements `0..=31`, so `42` is
// out of bounds and will trigger a panic.
bitset.insert(42);

pub fn remove(&mut self, i: u8) -> bool

Remove i from this bitset.

Returns whether i was previously in this set or not.

Example

use cranelift_bitset::ScalarBitSet;

let mut bitset = ScalarBitSet::<u128>::new();

// Removing an element that was not present in the set returns `false`.
let was_present = bitset.remove(100);
assert!(!was_present);

// And when the element was in the set, `true` is returned.
bitset.insert(100);
let was_present = bitset.remove(100);
assert!(was_present);

Panics

Panics if i is greater than or equal to Self::capacity().

use cranelift_bitset::ScalarBitSet;

let mut bitset = ScalarBitSet::<u16>::new();

// A `ScalarBitSet<u16>` can only hold the elements `0..=15`, so `20` is
// out of bounds and will trigger a panic.
bitset.remove(20);

pub fn clear(&mut self)

Remove all entries from this bitset.

Example

use cranelift_bitset::ScalarBitSet;

let mut bitset = ScalarBitSet::<u32>::new();

bitset.insert(10);
bitset.insert(20);
bitset.insert(30);

bitset.clear();

assert!(bitset.is_empty());

pub fn pop_min(&mut self) -> Option<u8>

Remove and return the smallest value in the bitset.

Example

use cranelift_bitset::ScalarBitSet;

let mut bitset = ScalarBitSet::<u64>::new();

bitset.insert(0);
bitset.insert(24);
bitset.insert(13);
bitset.insert(36);

assert_eq!(bitset.pop_min(), Some(0));
assert_eq!(bitset.pop_min(), Some(13));
assert_eq!(bitset.pop_min(), Some(24));
assert_eq!(bitset.pop_min(), Some(36));
assert_eq!(bitset.pop_min(), None);

pub fn pop_max(&mut self) -> Option<u8>

Remove and return the largest value in the bitset.

Example

use cranelift_bitset::ScalarBitSet;

let mut bitset = ScalarBitSet::<u64>::new();

bitset.insert(0);
bitset.insert(24);
bitset.insert(13);
bitset.insert(36);

assert_eq!(bitset.pop_max(), Some(36));
assert_eq!(bitset.pop_max(), Some(24));
assert_eq!(bitset.pop_max(), Some(13));
assert_eq!(bitset.pop_max(), Some(0));
assert_eq!(bitset.pop_max(), None);

pub fn min(&self) -> Option<u8>

Return the smallest number contained in this bitset or None if this bitset is empty.

Example

use cranelift_bitset::ScalarBitSet;

let mut bitset = ScalarBitSet::<u64>::new();

// When the bitset is empty, `min` returns `None`.
assert_eq!(bitset.min(), None);

bitset.insert(28);
bitset.insert(1);
bitset.insert(63);

// When the bitset is not empty, it returns the smallest element.
assert_eq!(bitset.min(), Some(1));

pub fn max(&self) -> Option<u8>

Return the largest number contained in the bitset or None if this bitset is empty

Example

use cranelift_bitset::ScalarBitSet;

let mut bitset = ScalarBitSet::<u64>::new();

// When the bitset is empty, `max` returns `None`.
assert_eq!(bitset.max(), None);

bitset.insert(0);
bitset.insert(36);
bitset.insert(49);

// When the bitset is not empty, it returns the smallest element.
assert_eq!(bitset.max(), Some(49));

pub fn iter(self) -> Iter<T>

Iterate over the items in this set.

Items are always yielded in sorted order.

Example

use cranelift_bitset::ScalarBitSet;

let mut bitset = ScalarBitSet::<u64>::new();

bitset.insert(19);
bitset.insert(3);
bitset.insert(63);
bitset.insert(0);

assert_eq!(
    bitset.iter().collect::<Vec<_>>(),
    [0, 3, 19, 63],
);

Trait Implementations

impl<'a, T> Arbitrary<'a> for ScalarBitSet<T>

where T: ScalarBitSetStorage + Arbitrary<'a>,

fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self>

Generate an arbitrary value of Self from the given unstructured data.

fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self, Error>

Generate an arbitrary value of Self from the entirety of the given unstructured data.

fn size_hint(depth: usize) -> (usize, Option<usize>)

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

impl<T: Clone> Clone for ScalarBitSet<T>

fn clone(&self) -> ScalarBitSet<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> Debug for ScalarBitSet<T>

where T: ScalarBitSetStorage,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> Default for ScalarBitSet<T>

where T: ScalarBitSetStorage,

fn default() -> Self

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for ScalarBitSet<T>

where T: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: ScalarBitSetStorage> From<T> for ScalarBitSet<T>

fn from(bits: T) -> Self

Converts to this type from the input type.

impl<'a, T> IntoIterator for &'a ScalarBitSet<T>

where T: ScalarBitSetStorage,

type Item = u8

The type of the elements being iterated over.

type IntoIter = Iter<T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T> IntoIterator for ScalarBitSet<T>

where T: ScalarBitSetStorage,

type Item = u8

The type of the elements being iterated over.

type IntoIter = Iter<T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T: PartialEq> PartialEq for ScalarBitSet<T>

fn eq(&self, other: &ScalarBitSet<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> Serialize for ScalarBitSet<T>

where T: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: Copy> Copy for ScalarBitSet<T>

impl<T: Eq> Eq for ScalarBitSet<T>

impl<T> StructuralPartialEq for ScalarBitSet<T>