Struct IdentitySet

pub struct IdentitySet<T, A: Allocator = Global> { /* private fields */ }

An ordered identity set.

This set records a list of keys wherein each key is unique.

Unlike other sets such as HashSet, this type only transforms keys as if the identity function was used.

Implementations

impl<T> IdentitySet<T>

pub const fn new() -> Self

Constructs a new, empty identity set.

pub fn with_capacity(cap: usize) -> Self

Preallocates a new identity set.

Panics

If [T; cap] could not be allocated using the global allocator, then this function will panic.

This function will also panic if cap is greater than isize::MAX.

pub unsafe fn from_raw_parts(ptr: *mut T, cap: usize, len: usize) -> Self

Constructs a new identity set from raw parts.

Safety

See IdentityMap::from_raw_parts.

impl<T, A: Allocator> IdentitySet<T, A>

pub const fn new_in(alloc: A) -> Self

Constructs a new, empty identity set with a specific allocator.

pub fn with_capacity_in(cap: usize, alloc: A) -> Self

Preallocates a new identity set with a specific allocator.

Panics

If [T; cap] could not be allocated with the given allocator, then this function will panic.

This function will also panic if cap is greater than isize::MAX.

pub unsafe fn from_raw_parts_in( ptr: *mut T, cap: usize, len: usize, alloc: A, ) -> Self

Constructs a new identity set from raw parts.

Safety

See IdentityMap::from_raw_parts_in.

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

Retains only keys as specified by a predicate.

In other words, each key k where !f(k) is true.

Panics

Panics if f panics.

pub fn clear(&mut self)

Clears the set.

All contained keys are dropped after a call to this method. The length counter is then reset to zero.

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

Reserves additional capacity for the set.

Panics

This method will panic if the internal buffer could not be grown. It will also panic if the new capacity of the set is greater than isize::MAX.

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

Shrinks the set to a specified length.

The capacity is shrunk such that it exactly contains the current data.

Panics

If the provided capacity is greater than the current, then this method will panic.

pub fn shrink_to_fit(&mut self)

Shrinks the set to the current length.

The capacity is shrunk such that it exactly contains the current data.

pub fn allocator(&self) -> &A

Borrows the set’s allocator.

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

Gets an iterator of the contained keys.

pub fn capacity(&self) -> usize

Retrieves the total capacity of the set.

Remember that this capacity can – if needed to – be increased using the reserve method.

pub fn len(&self) -> usize

Retrieves the current length of the set.

pub fn is_empty(&self) -> bool

Tests if the set is empty.

pub fn as_ptr(&self) -> *const T

Gets a pointer to the set buffer.

Note that this pointer may necessarily be dangling if the set isn’t currently in an allocated state.

pub fn as_mut_ptr(&mut self) -> *mut T

Gets a mutable pointer to the set buffer.

Note that this pointer may necessarily be dangling if the set isn’t currently in an allocated state.

pub fn as_slice(&self) -> &[T]

Gets a slice over the set’s keys.

pub fn as_mut_slice(&mut self) -> &mut [T]

Gets a mutable slice over the set’s keys.

impl<T, A> IdentitySet<T, A>

where T: Ord, A: Allocator,

pub fn insert(&mut self, key: T) -> bool

Inserts a new key pair into the set.

If the provided key already exists in the set, then this method will return true. In all other cases, it will return false.

Panics

If the set did not already hold key as a key and could not grow its buffer to accommodate the key, then this method will panic.

pub fn take<U>(&mut self, key: &U) -> Option<T>

where T: Borrow<U>, U: Ord + ?Sized,

Takes a specific key out from the set.

If the provided key was not present in the set, then this method will instead return a None instance.

pub fn remove(&mut self, key: &T) -> bool

Remove a specific key from the set.

This method will return true if the provided key was present in the set.

pub fn get<U>(&self, key: &U) -> Option<&T>

where T: Borrow<U>, U: Ord + ?Sized,

Borrows a key.

pub fn contains<U>(&self, key: &U) -> bool

where T: Borrow<U>, U: Ord + ?Sized,

Checks if the set contains the specified key.

pub fn intersection<'a>(&'a self, other: &'a Self) -> Intersection<'a, T, A>

Gets an iterator denoting the intersection between two sets.

pub fn difference<'a>(&'a self, other: &'a Self) -> Difference<'a, T, A>

Gets an iterator denoting the difference between two sets.

pub fn symmetric_difference<'a>( &'a self, other: &'a Self, ) -> SymmetricDifference<'a, T, A>

Gets an iterator denoting the symmetric difference between two sets

pub fn union<'a>(&'a self, other: &'a Self) -> Union<'a, T, A>

Gets an iterator denoting the union between two sets

Trait Implementations

impl<T, A> BitAnd for &IdentitySet<T, A>

where T: Clone + Ord, A: Allocator + Default,

type Output = IdentitySet<T, A>

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl<T, A> BitOr for &IdentitySet<T, A>

where T: Clone + Ord, A: Allocator + Default,

type Output = IdentitySet<T, A>

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl<T, A> BitXor for &IdentitySet<T, A>

where T: Clone + Ord, A: Allocator + Default,

type Output = IdentitySet<T, A>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Self) -> Self::Output

Performs the ^ operation.

impl<T: Clone, A: Clone + Allocator> Clone for IdentitySet<T, A>

fn clone(&self) -> IdentitySet<T, A>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, A> Debug for IdentitySet<T, A>

where T: Debug, A: Allocator,

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

Formats the value using the given formatter.

impl<T, A: Allocator + Default> Default for IdentitySet<T, A>

fn default() -> Self

Returns the “default value” for a type.

impl<T, A> Extend<T> for IdentitySet<T, A>

where T: Ord, A: Allocator,

fn extend<I: IntoIterator<Item = T>>(&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<T, A, const N: usize> From<[T; N]> for IdentitySet<T, A>

where T: Ord, A: Allocator + Default,

fn from(value: [T; N]) -> Self

Converts to this type from the input type.

impl<T, A> FromIterator<T> for IdentitySet<T, A>

where T: Ord, A: Allocator + Default,

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

Creates a value from an iterator.

impl<T, A> Hash for IdentitySet<T, A>

where T: Hash, A: Allocator,

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

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a, T, A: Allocator> IntoIterator for &'a IdentitySet<T, A>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T, A: Allocator> IntoIterator for IdentitySet<T, A>

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, A>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T, A> PartialEq for IdentitySet<T, A>

where T: PartialEq, A: Allocator,

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<T, A> Sub for &IdentitySet<T, A>

where T: Clone + Ord, A: Allocator + Default,

type Output = IdentitySet<T, A>

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl<T, A> Eq for IdentitySet<T, A>

where T: Eq, A: Allocator,