Struct BitSet

pub struct BitSet<I = usize>(/* private fields */);

A simple unbounded bitset that fits in 2 usizes worth of memory

It resizes its heap allocation whenever a number that wouldn’t otherwise fit in memory is added and doesn’t ever shrink its memory so it could end of wasting memory if a very large element is added and then removed

Implementations

impl<I: Into<usize>> BitSet<I>

pub fn insert(&mut self, x: I) -> bool

Adds an element to the set

If the set did not have this value present, true is returned.

If the set did have this value present, false is returned.

use default_vec2::BitSet;
let mut s: BitSet<usize> = BitSet::default();
assert!(s.insert(0));
assert!(!s.insert(0));

pub fn remove(&mut self, x: I) -> bool

Removes an element form the set.

Returns whether the value was present in the set.

use default_vec2::BitSet;
let mut s: BitSet<usize> = BitSet::default();
assert!(!s.remove(0));
s.insert(0);
assert!(s.remove(0));
assert!(!s.remove(0))

pub fn set(&mut self, x: I, v: bool) -> bool

Inserts x if v is true, or removes it otherwise.

Returns whether self used to contain x

use default_vec2::BitSet;
let mut s: BitSet<usize> = BitSet::default();
assert!(!s.set(0, false));
assert!(!s.set(0, true));
assert!(s.set(0, true));
assert!(s.set(0, false));

pub fn contains(&self, x: I) -> bool

Checks if the set contains an element

pub fn contains_mut(&mut self, x: I) -> bool

Same as contains but already reserves space for x

pub fn clear(&mut self)

Removes all elements from the set

impl<I: From<usize> + Into<usize> + Copy> BitSet<I>

pub fn iter(&self) -> impl Iterator<Item = I> + '_

Iterate over all elements in the set

Run time is proportional to the largest element that has ever been in the set

Trait Implementations

impl<'a, I> BitAndAssign<&'a BitSet> for BitSet<I>

fn bitand_assign(&mut self, rhs: &'a BitSet)

Sets *self to the intersection of self and other

Example:

use default_vec2::BitSet;
let mut s1: BitSet<usize> = BitSet::from_iter([0, 1]);
let s2 = BitSet::from_iter([0, 42]);
s1 &= &s2;

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

impl<'a, I> BitOrAssign<&'a BitSet> for BitSet<I>

fn bitor_assign(&mut self, rhs: &'a BitSet)

Sets *self to the intersection of self and other

Example:

use default_vec2::BitSet;
let mut s1: BitSet<usize> = BitSet::from_iter([0, 1]);
let s2 = BitSet::from_iter([0, 42]);
s1 |= &s2;

assert_eq!(vec![0, 1, 42], s1.iter().collect::<Vec<_>>());

impl<'a, I> BitXorAssign<&'a BitSet> for BitSet<I>

fn bitxor_assign(&mut self, rhs: &'a BitSet)

Sets *self to the set symmetric difference of self and other

Example:

use default_vec2::BitSet;
let mut s1: BitSet<usize> = BitSet::from_iter([0, 1]);
let s2 = BitSet::from_iter([0, 42]);
s1 ^= &s2;

assert_eq!(vec![1, 42], s1.iter().collect::<Vec<_>>());

impl<I> Clone for BitSet<I>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<I: From<usize> + Into<usize> + Copy + Debug> Debug for BitSet<I>

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

Formats the value using the given formatter.

impl<I> Default for BitSet<I>

fn default() -> Self

Returns the “default value” for a type.

impl<I: Into<usize>> Extend<I> for BitSet<I>

fn extend<T: IntoIterator<Item = I>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<I: Into<usize>> FromIterator<I> for BitSet<I>

fn from_iter<T: IntoIterator<Item = I>>(iter: T) -> Self

Creates a value from an iterator.

impl<I> PartialEq for BitSet<I>

fn eq(&self, other: &Self) -> 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<'a, I> SubAssign<&'a BitSet> for BitSet<I>

fn sub_assign(&mut self, rhs: &'a BitSet)

Sets *self to the set difference of self and other

Example:

use default_vec2::BitSet;
let mut s1: BitSet<usize> = BitSet::from_iter([0, 1]);
let s2 = BitSet::from_iter([0, 42]);
s1 -= &s2;

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

impl<I> Eq for BitSet<I>