Struct rotary::bit_set::BitSet

#[repr(transparent)]pub struct BitSet<T> where
    T: Bits,  { /* fields omitted */ }

A fixed size bit set.

Examples

let mut set = rotary::BitSet::<u128>::empty();

assert!(!set.test(1));
set.set(1);
assert!(set.test(1));
set.clear(1);
assert!(!set.test(1));

The bit set can also use arrays as its backing storage.

let mut set = rotary::BitSet::<[u64; 16]>::empty();

assert!(!set.test(172));
set.set(172);
assert!(set.test(172));
set.clear(172);
assert!(!set.test(172));

Two bit sets of different kinds can be compared to each other.

let mut a = rotary::BitSet::<[u64; 2]>::empty();
let mut b = rotary::BitSet::<u128>::empty();

assert_eq!(a, b);

a.set(111);
assert_ne!(a, b);

b.set(111);
assert_eq!(a, b);

Implementations

impl<T> BitSet<T> where
    T: Bits, 

pub fn empty() -> Self

Construct a new bit set that is empty, where no element is set.

Examples

let set = rotary::BitSet::<u128>::empty();

assert_eq!(set.iter().collect::<Vec<_>>(), vec![])

pub fn full() -> Self

Construct a new bit set that is full, where every single element possible is set.

Examples

let set = rotary::BitSet::<u128>::full();

assert_eq!(set.iter().collect::<Vec<_>>(), (0..128usize).collect::<Vec<_>>())

pub fn test(&self, index: usize) -> bool

Test if the given bit is set.

Examples

let mut set = rotary::BitSet::<u128>::full();

assert!(set.test(0));
assert!(set.test(1));
assert!(set.test(127));

set.clear(1);

assert!(set.test(0));
assert!(!set.test(1));
assert!(set.test(127));

pub fn set(&mut self, index: usize)

Set the given bit.

Examples

let mut set = rotary::BitSet::<u128>::full();

assert!(set.test(0));
assert!(set.test(1));
assert!(set.test(127));

set.clear(1);

assert!(set.test(0));
assert!(!set.test(1));
assert!(set.test(127));

set.set(1);

assert!(set.test(0));
assert!(set.test(1));
assert!(set.test(127));

pub fn clear(&mut self, index: usize)

Clear the given bit.

Examples

let mut set = rotary::BitSet::<u128>::full();

assert!(set.test(0));
assert!(set.test(1));
assert!(set.test(127));

set.clear(1);

assert!(set.test(0));
assert!(!set.test(1));
assert!(set.test(127));

set.set(1);

assert!(set.test(0));
assert!(set.test(1));
assert!(set.test(127));

pub fn iter(&self) -> T::Iter

Construct an iterator over a bit set.

Examples

let mut set = rotary::BitSet::<u128>::empty();

set.set(3);
set.set(7);

assert_eq!(set.iter().collect::<Vec<_>>(), vec![3, 7]);

A larger bit set:

use rotary::Mask as _;

let mut set = rotary::BitSet::<[u32; 4]>::empty();

set.set(4);
set.set(63);
set.set(71);

assert_eq!(set.iter().collect::<Vec<_>>(), vec![4, 63, 71]);

Trait Implementations

impl<T: Clone> Clone for BitSet<T> where
    T: Bits, 

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Copy> Copy for BitSet<T> where
    T: Bits, 

impl<T> Debug for BitSet<T> where
    T: Bits, 

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

Formats the value using the given formatter.

impl<T> Eq for BitSet<T> where
    T: Bits, 

impl<T> Hash for BitSet<T> where
    T: Bits + Hash, 

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

pub fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl<T> IntoIterator for BitSet<T> where
    T: Bits, 

type IntoIter = T::Iter

Which kind of iterator are we turning this into?

type Item = <Self::IntoIter as Iterator>::Item

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T> Mask for BitSet<T> where
    T: Bits, 

type Iter = T::Iter

The iterator over a mask, indicating all items in the mask.

fn full() -> Self

Construct a bit set where all elements are set.

fn test(&self, index: usize) -> bool

Test if the given bit is set.

fn set(&mut self, index: usize)

Set the given bit.

fn clear(&mut self, index: usize)

Clear the given bit.

fn iter(&self) -> Self::Iter

Construct an iterator over a bit set.

impl<T> Ord for BitSet<T> where
    T: Bits, 

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

#[must_use]pub fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]pub fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl<T, U> PartialEq<BitSet<U>> for BitSet<T> where
    T: Bits,
    U: Bits, 

fn eq(&self, other: &BitSet<U>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T, U> PartialOrd<BitSet<U>> for BitSet<T> where
    T: Bits,
    U: Bits, 

fn partial_cmp(&self, other: &BitSet<U>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use]pub fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]pub fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]pub fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]pub fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.