Struct IdSet

pub struct IdSet<I> { /* private fields */ }

A set of IDs.

Examples

Assume that you have a type named MyId, which represents a set of IDs from 0 to 10 (exclusive).

#[derive(Copy, Clone, Debug, Eq, PartialEq)]
pub struct MyId(u32);

// SAFETY: `MyId` maintains the 1:1 mapping invariant for 0..10.
unsafe impl Id for MyId {
    fn new_unchecked(raw_id: u32) -> Self { Self(raw_id) }
    fn cardinality() -> u32 { 10 } // Fixed cardinality for this example
}
impl From<MyId> for u32 { fn from(id: MyId) -> u32 { id.0 } }

Now you can use IdSet<MyId> as a container for MyIDs.

let mut my_id_set: IdSet<MyId> = IdSet::new_empty();

let id0 = MyId::new(0);
my_id_set.add(id0);
assert!(my_id_set.contains(id0));
assert_eq!(my_id_set.count(), 1);

let id5 = MyId::new(5);
my_id_set.add(id5);
assert!(my_id_set.contains(id5));
assert_eq!(my_id_set.count(), 2);

my_id_set.remove(id0);
assert!(!my_id_set.contains(id0));
assert_eq!(my_id_set.count(), 1);

let full_set = IdSet::<MyId>::new_full();
assert_eq!(full_set.count(), 10);
assert!(full_set.contains(MyId::new(9)));

Implementations

impl<I: Id> IdSet<I>

pub fn new_full() -> Self

Creates a new IdSet with all IDs in the system.

pub fn new_empty() -> Self

Creates a new IdSet with no IDs in the system.

pub fn add(&mut self, id: I)

Adds an ID to the set.

pub fn remove(&mut self, id: I)

Removes an ID from the set.

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

Returns true if the set contains the specified ID.

pub fn count(&self) -> usize

Returns the number of IDs in the set.

pub fn is_empty(&self) -> bool

Returns true if the set is empty.

pub fn is_full(&self) -> bool

Returns true if the set is full.

pub fn add_all(&mut self)

Adds all IDs to the set.

pub fn clear(&mut self)

Removes all IDs from the set.

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

Iterates over all IDs in the set.

The iteration is guaranteed to be in ascending order.

pub fn iter_in<S: IdSetSlicer<I>>( &self, slicer: S, ) -> impl Iterator<Item = I> + '_

Iterates over the IDs in the set within the specified range.

The iteration is guaranteed to be in ascending order. Only IDs that are both in the set and within the specified range will be returned.

Trait Implementations

impl<I: Clone> Clone for IdSet<I>

fn clone(&self) -> IdSet<I>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<I: Debug> Debug for IdSet<I>

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

Formats the value using the given formatter.

impl<I: Id> Default for IdSet<I>

fn default() -> Self

Returns the “default value” for a type.

impl<I: Id> From<I> for IdSet<I>

fn from(id: I) -> Self

Converts to this type from the input type.

impl<I: PartialEq> PartialEq for IdSet<I>

fn eq(&self, other: &IdSet<I>) -> 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<I: Eq> Eq for IdSet<I>

impl<I> StructuralPartialEq for IdSet<I>