Struct NonEmptyIndexSet 

pub struct NonEmptyIndexSet<K, S = RandomState> { /* private fields */ }

A wrapper around ::indexmap::IndexSet that is guaranteed to have at least one element by the Rust’s type system: it consists of a first element and an indexed set (which could be empty) rest elements.

Implementations

impl<K> NonEmptyIndexSet<K, RandomState>

pub fn new(first: K) -> Self

Creates a set with a default hasher.

pub fn with_capacity(first: K, capacity: usize) -> Self

Creates a set with a given capacity.

pub fn from_iterator(i: impl IntoIterator<Item = K>) -> Result<Self, Error>

where K: Hash + Eq,

Creates a set from a given iterator with a default hasher.

impl<K, S> NonEmptyIndexSet<K, S>

where K: Eq + Hash, S: BuildHasher,

pub fn with_hasher(first: K, hash_builder: S) -> Self

Creates a set with a given hasher.

pub fn with_capacity_and_hasher( first: K, capacity: usize, hash_builder: S, ) -> Self

Creates a set with a given capacity.

pub fn iter(&self) -> impl Iterator<Item = &K>

Iterates over key-value paris of the set in an immutable way.

pub fn from_iter_with_hasher( i: impl IntoIterator<Item = K>, hasher: S, ) -> Result<Self, Error>

Creates a set from a given iterator with a given hasher.

pub fn get<Q>(&self, key: &Q) -> Option<&K>

where K: Borrow<Q>, Q: Eq + Hash + ?Sized,

Gets a stored key from the set.

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

where K: Borrow<Q>, Q: Eq + Hash + ?Sized,

Checks whether a given key exists in the set.

pub fn take<Q>(&mut self, key: &Q) -> Result<Option<K>, Error>

where K: Borrow<Q>, Q: Eq + Hash + ?Sized,

Removes and returns a value from the set that is equal to a given key, if any.

An attempt to remove the last element will cause an Error to be returned.

pub fn remove<Q>(&mut self, key: &Q) -> Result<bool, Error>

where K: Borrow<Q>, Q: Eq + Hash + ?Sized,

Removes a value from the set that is equal to a given key, if any. Returns true if the value was present in the set.

An attempt to remove the last element will cause an Error to be returned.

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

Adds a value to the set.

If there was no such a value in the set before, true is returned.

If the value is in the set already, it remains unchaged and false is returned.

pub fn replace(&mut self, key: K) -> Option<K>

Replaces a value in the set with a given one. An old value is returned, if any.

pub fn len(&self) -> usize

Returns the number of elements in the set.

pub fn is_empty(&self) -> bool

Checks whether or not the set is empty.

As one would expect it always evaluates to false :)

assert!(!NonEmptyIndexSet::new("key").is_empty());

pub fn get_first(&self) -> &K

Gets an immutable reference to the first element.

pub fn get_first_mut(&mut self) -> &mut K

Gets a mutable reference to the first element.

pub fn get_rest(&self) -> &IndexSet<K, S>

Gets an immutable reference to the rest indexed set of elements.

pub fn get_rest_mut(&mut self) -> &mut IndexSet<K, S>

Gets a mutable reference to the rest indexed set of elements.

pub fn remove_first(&mut self) -> Result<(), Error>

Attempts to remove the first element. Will fail if it is the only one element in the set.

pub fn retain<F>(&mut self, keep: F) -> Result<(), Error>

where F: FnMut(&K) -> bool,

Scans the collection and keeps only the items on which the provided keep function returns true. Will fail if in the end only one element will remain.

Trait Implementations

impl<K: Clone, S: Clone> Clone for NonEmptyIndexSet<K, S>

fn clone(&self) -> NonEmptyIndexSet<K, S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K, S> Debug for NonEmptyIndexSet<K, S>

where K: Eq + Hash + Debug, S: BuildHasher,

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

Formats the value using the given formatter.

impl<'de, K, S> Deserialize<'de> for NonEmptyIndexSet<K, S>

where K: Deserialize<'de> + Eq + Hash, S: BuildHasher + Default,

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<K, S> Extend<K> for NonEmptyIndexSet<K, S>

where K: Eq + Hash, S: BuildHasher,

fn extend<T: IntoIterator<Item = K>>(&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<K: Eq + Hash, S: BuildHasher> Into<IndexSet<K, S>> for NonEmptyIndexSet<K, S>

fn into(self) -> IndexSet<K, S>

Converts this type into the (usually inferred) input type.

impl<K, S> IntoIterator for NonEmptyIndexSet<K, S>

where K: Eq + Hash, S: BuildHasher,

type IntoIter = IntoIter<K>

Which kind of iterator are we turning this into?

type Item = K

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<K, S1, S2> PartialEq<NonEmptyIndexSet<K, S1>> for NonEmptyIndexSet<K, S2>

where K: Hash + Eq, S1: BuildHasher, S2: BuildHasher,

fn eq(&self, other: &NonEmptyIndexSet<K, S1>) -> 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<K, H> Serialize for NonEmptyIndexSet<K, H>

where K: Serialize + Eq + Hash, H: BuildHasher,

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<K, S> Eq for NonEmptyIndexSet<K, S>

where K: Hash + Eq, S: BuildHasher,