Struct IdSet

pub struct IdSet { /* private fields */ }

A set of usize elements represented by a bit vector. Storage required is proportional to the maximum element in the set.

Implementations

impl IdSet

pub fn new() -> Self

Creates an empty IdSet.

pub fn new_filled(n: usize) -> Self

Creates a IdSet filled with all elements from 0 to n.

pub fn with_capacity(n: usize) -> Self

Creates a empty IdSet that can hold elements up to n before reallocating.

pub fn len(&self) -> usize

Returns the number of distinct elements in the set.

pub fn is_empty(&self) -> bool

Returns true if the set is empty.

pub fn capacity(&self) -> usize

Returns capacity of the set. Inserting any elements less than this will not cause reallocation.

pub fn reserve(&mut self, cap: usize)

Resizes the set such that capacity() >= cap.

pub fn shrink_to_fit(&mut self)

Resizes the set to minimise allocated memory.

pub fn clear(&mut self)

Removes all elements from the set.

pub fn insert(&mut self, id: Id) -> bool

Inserts the given element into the set, returning true if it was not already in the set.

pub fn remove(&mut self, id: Id) -> bool

Removes the given element from the set, returning true if it was in the set.

pub fn contains(&self, id: Id) -> bool

Returns true if the given element is in the set.

pub fn retain<F: FnMut(Id) -> bool>(&mut self, pred: F)

Remove all elements that don’t satisfy the predicate.

pub fn as_blocks(&self) -> &[Block]

Returns the underlying blocks as a slice.

pub fn iter(&self) -> Iter<'_>

An iterator over all elements in increasing order.

pub fn blocks(&self) -> Blocks<'_>

Returns an iterator over the blocks of the underlying representation.

pub fn into_blocks(self) -> IntoBlocks

Returns a consuming iterator over the blocks of the underlying representation.

pub fn union<I>(&self, other: I) -> BlockIter<Union<Blocks<'_>, I::Blocks>>

where I: IntoBlockIterator,

Takes the union of the set with another. Equivalent to self | other.

pub fn intersection<I>( &self, other: I, ) -> BlockIter<Intersection<Blocks<'_>, I::Blocks>>

where I: IntoBlockIterator,

Takes the intersection of the set with another. Equivalent to self & other.

pub fn difference<I>( &self, other: I, ) -> BlockIter<Difference<Blocks<'_>, I::Blocks>>

where I: IntoBlockIterator,

Takes the difference of the set with another. Equivalent to self - other.

pub fn symmetric_difference<I>( &self, other: I, ) -> BlockIter<SymmetricDifference<Blocks<'_>, I::Blocks>>

where I: IntoBlockIterator,

Takes the symmetric difference of the set with another. Equivalent to self ^ other.

pub fn into_union<I>(self, other: I) -> BlockIter<Union<IntoBlocks, I::Blocks>>

where I: IntoBlockIterator,

Consumes the set and takes the union with another.

pub fn into_intersection<I>( self, other: I, ) -> BlockIter<Intersection<IntoBlocks, I::Blocks>>

where I: IntoBlockIterator,

Consumes the set and takes the intersection with another.

pub fn into_difference<I>( self, other: I, ) -> BlockIter<Difference<IntoBlocks, I::Blocks>>

where I: IntoBlockIterator,

Consumes the set and takes the difference with another.

pub fn into_symmetric_difference<I>( self, other: I, ) -> BlockIter<SymmetricDifference<IntoBlocks, I::Blocks>>

where I: IntoBlockIterator,

Consumes the set and takes the symmetric difference with another.

pub fn inplace_union<I>(&mut self, other: I)

where I: IntoBlockIterator,

Take the union of the set inplace with another set. Equivalent to *self |= other.

pub fn inplace_intersection<I>(&mut self, other: I)

where I: IntoBlockIterator,

Take the intersection of the set inplace with another set. Equivalent to *self &= other.

pub fn inplace_difference<I>(&mut self, other: I)

where I: IntoBlockIterator,

Take the difference of the set inplace with another set. Equivalent to *self -= other.

pub fn inplace_symmetric_difference<I>(&mut self, other: I)

where I: IntoBlockIterator,

Take the symmetric difference of the set inplace with another set. Equivalent to *self ^= other.

pub fn is_disjoint(&self, other: &Self) -> bool

Returns true if the sets are disjoint.

pub fn is_superset(&self, other: &Self) -> bool

Returns true if self is a superset of other.

pub fn is_subset(&self, other: &Self) -> bool

Returns true if self is a subset of other.

Trait Implementations

impl<'a, I> BitAnd<I> for &'a IdSet

where I: IntoBlockIterator,

fn bitand(self, other: I) -> Self::Output

Takes the intersection of two objects.

type Output = BlockIter<Intersection<Iter<'a>, <I as IntoBlockIterator>::Blocks>>

The resulting type after applying the & operator.

impl<I> BitAnd<I> for IdSet

where I: IntoBlockIterator,

fn bitand(self, other: I) -> Self::Output

Takes the intersection of two objects.

type Output = BlockIter<Intersection<IntoIter, <I as IntoBlockIterator>::Blocks>>

The resulting type after applying the & operator.

impl<I> BitAndAssign<I> for IdSet

where I: IntoBlockIterator,

fn bitand_assign(&mut self, other: I)

Takes the inplace intersection of the set with another.

impl<'a, I> BitOr<I> for &'a IdSet

where I: IntoBlockIterator,

fn bitor(self, other: I) -> Self::Output

Takes the union of two objects.

type Output = BlockIter<Union<Iter<'a>, <I as IntoBlockIterator>::Blocks>>

The resulting type after applying the | operator.

impl<I> BitOr<I> for IdSet

where I: IntoBlockIterator,

fn bitor(self, other: I) -> Self::Output

Takes the union of two objects.

type Output = BlockIter<Union<IntoIter, <I as IntoBlockIterator>::Blocks>>

The resulting type after applying the | operator.

impl<I> BitOrAssign<I> for IdSet

where I: IntoBlockIterator,

fn bitor_assign(&mut self, other: I)

Takes the inplace union of the set with another.

impl<'a, I> BitXor<I> for &'a IdSet

where I: IntoBlockIterator,

fn bitxor(self, other: I) -> Self::Output

Takes the symmetric difference of two objects.

type Output = BlockIter<SymmetricDifference<Iter<'a>, <I as IntoBlockIterator>::Blocks>>

The resulting type after applying the ^ operator.

impl<I> BitXor<I> for IdSet

where I: IntoBlockIterator,

fn bitxor(self, other: I) -> Self::Output

Takes the symmetric difference of two objects.

type Output = BlockIter<SymmetricDifference<IntoIter, <I as IntoBlockIterator>::Blocks>>

The resulting type after applying the ^ operator.

impl<I> BitXorAssign<I> for IdSet

where I: IntoBlockIterator,

fn bitxor_assign(&mut self, other: I)

Takes the inplace symmetric difference of the set with another.

impl Clone for IdSet

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for IdSet

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

Formats the value using the given formatter.

impl Default for IdSet

fn default() -> Self

Returns the “default value” for a type.

impl Extend<usize> for IdSet

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

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 FromIterator<usize> for IdSet

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

Creates a value from an iterator.

impl<'a> IntoBlockIterator for &'a IdSet

type Blocks = Iter<'a>

The raw iterator type.

fn into_block_iter(self) -> BlockIter<Self::Blocks>

Creates a block iterator.

impl IntoBlockIterator for IdSet

type Blocks = IntoIter

The raw iterator type.

fn into_block_iter(self) -> BlockIter<Self::Blocks>

Creates a block iterator.

impl<'a> IntoIterator for &'a IdSet

type Item = usize

The type of the elements being iterated over.

type IntoIter = Iter<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl IntoIterator for IdSet

type Item = usize

The type of the elements being iterated over.

type IntoIter = IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl PartialEq for IdSet

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> Sub<I> for &'a IdSet

where I: IntoBlockIterator,

fn sub(self, other: I) -> Self::Output

Takes the difference of two objects.

type Output = BlockIter<Difference<Iter<'a>, <I as IntoBlockIterator>::Blocks>>

The resulting type after applying the - operator.

impl<I> Sub<I> for IdSet

where I: IntoBlockIterator,

fn sub(self, other: I) -> Self::Output

Takes the difference of two objects.

type Output = BlockIter<Difference<IntoIter, <I as IntoBlockIterator>::Blocks>>

The resulting type after applying the - operator.

impl<I> SubAssign<I> for IdSet

where I: IntoBlockIterator,

fn sub_assign(&mut self, other: I)

Takes the inplace difference of the set with another.

impl Eq for IdSet