Struct GenMapOf 

pub struct GenMapOf<K, V, Gen = u32, S = HashMap<K, V>>
where
    K: Clone,
    Gen: IGeneration,
{ /* private fields */ }

A Generational Map Collection.

GenID stay stable, even after inserting the same key twice.

Implementations

impl<K, V, Gen, S> GenMapOf<K, V, Gen, S>

where K: Clone, Gen: IGeneration,

pub fn new() -> GenMapOf<K, V, Gen, S>

where S: Default,

pub fn len(&self) -> usize

where GenMapOf<K, V, Gen, S>: Length,

pub fn get<Idx>(&self, index: Idx) -> Option<&V>

where GenMapOf<K, V, Gen, S>: Get<Idx, Output = V>,

pub fn get_mut<Idx>(&mut self, index: Idx) -> Option<&mut V>

where GenMapOf<K, V, Gen, S>: GetMut<Idx, Output = V>,

pub fn try_get<Idx>( &self, index: Idx, ) -> Result<&V, <GenMapOf<K, V, Gen, S> as TryGet<Idx>>::Error>

where GenMapOf<K, V, Gen, S>: TryGet<Idx, Output = V>,

pub fn try_get_mut<Idx>( &mut self, index: Idx, ) -> Result<&mut V, <GenMapOf<K, V, Gen, S> as TryGet<Idx>>::Error>

where GenMapOf<K, V, Gen, S>: TryGetMut<Idx, Output = V>,

pub fn insert(&mut self, key: K, value: V) -> (GenIDOf<V, Gen>, Option<V>)

where S: Insert<K, GenIDOf<V, Gen>>,

pub fn insert_cyclic<'s, F>( &'s mut self, key: K, init: F, ) -> (GenIDOf<V, Gen>, Option<V>)

where F: FnOnce(GenIDOf<V, Gen>) -> V, S: Insert<K, GenIDOf<V, Gen>>,

pub fn remove<Idx>(&mut self, index: Idx) -> Option<V>

where GenMapOf<K, V, Gen, S>: Remove<Idx, Output = V>,

pub fn iter(&self) -> Iter<'_, K, V, Gen>

pub fn iter_mut(&mut self) -> IterMut<'_, K, V, Gen>

pub fn ids(&self) -> impl Iterator<Item = GenIDOf<V, Gen>>

pub fn values(&self) -> impl Iterator<Item = &V>

pub fn values_mut(&mut self) -> impl Iterator<Item = &mut V>

Trait Implementations

impl<K, V, Gen, S> AsRef<GenSeq<Entry<K, V>, Gen>> for GenMapOf<K, V, Gen, S>

where K: Clone, Gen: IGeneration,

fn as_ref(&self) -> &GenSeq<Entry<K, V>, Gen>

Converts this type into a shared reference of the (usually inferred) input type.

impl<K, V, Gen, S> Capacity for GenMapOf<K, V, Gen, S>

where K: Clone, Gen: IGeneration, S: Capacity,

fn capacity(&self) -> usize

impl<K, V, Gen, S> Clone for GenMapOf<K, V, Gen, S>

where K: Clone, V: Clone, Gen: Clone + IGeneration, S: Clone,

fn clone(&self) -> GenMapOf<K, V, Gen, S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K, V, Gen, S> Debug for GenMapOf<K, V, Gen, S>

where K: Clone + Debug, Gen: IGeneration, V: Debug,

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

Formats the value using the given formatter.

impl<K, V, Gen, S> Default for GenMapOf<K, V, Gen, S>

where K: Clone, Gen: IGeneration, S: Default,

fn default() -> GenMapOf<K, V, Gen, S>

Returns the “default value” for a type.

impl<'de, K, V, Gen, St> Deserialize<'de> for GenMapOf<K, V, Gen, St>

where K: Clone + Deserialize<'de>, Gen: IGeneration + Deserialize<'de>, V: Deserialize<'de>, St: Default + Insert<K, GenIDOf<V, Gen>>, GenSeq<Entry<K, V>, Gen>: Deserialize<'de>,

Available on crate feature serde only.

fn deserialize<D>( deserializer: D, ) -> Result<GenMapOf<K, V, Gen, St>, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<K, V, Gen, S> Extend<(K, V)> for GenMapOf<K, V, Gen, S>

where K: Clone, Gen: IGeneration, S: Insert<K, GenIDOf<V, Gen>>, GenMapOf<K, V, Gen, S>: Reserve,

fn extend<I>(&mut self, iter: I)

where I: IntoIterator<Item = (K, V)>,

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, V, Gen, S> From<GenSeq<Entry<K, V>, Gen>> for GenMapOf<K, V, Gen, S>

where K: Clone, Gen: IGeneration, S: Default + Insert<K, GenIDOf<V, Gen>>,

fn from(values: GenSeq<Entry<K, V>, Gen>) -> GenMapOf<K, V, Gen, S>

Converts to this type from the input type.

impl<K, V, Gen, S> FromIterator<(K, V)> for GenMapOf<K, V, Gen, S>

where K: Clone, Gen: IGeneration, S: Default + Insert<K, GenIDOf<V, Gen>>, GenMapOf<K, V, Gen, S>: WithCapacity + Reserve, <GenMapOf<K, V, Gen, S> as WithCapacity>::Param: Default,

fn from_iter<I>(iter: I) -> GenMapOf<K, V, Gen, S>

where I: IntoIterator<Item = (K, V)>,

Creates a value from an iterator.

impl<'a, Q, K, V, Gen, S> Get<&'a Q> for GenMapOf<K, V, Gen, S>

where K: Clone + Borrow<Q>, Gen: IGeneration, S: Get<&'a Q, Output = GenIDOf<V, Gen>>, Q: ?Sized,

type Output = V

fn get( &self, index: &'a Q, ) -> Option<&<GenMapOf<K, V, Gen, S> as Get<&'a Q>>::Output>

Returns a reference to the value.

fn get_or_panic(&self, index: Idx) -> &Self::Output

Returns a reference to the value.

unsafe fn get_unchecked(&self, index: Idx) -> &Self::Output

Returns a reference to the value.

fn is_index_valid(&self, index: Idx) -> bool

True if get(index) return Some, false otherwise.

fn is_index_invalid(&self, index: Idx) -> bool

True if get(index) return None, false otherwise.

fn contains(&self, index: Idx) -> bool

impl<K, V, Gen, S> Get<GenIDOf<V, Gen>> for GenMapOf<K, V, Gen, S>

where K: Clone, Gen: IGeneration, S: Collection,

type Output = V

fn get( &self, index: GenIDOf<V, Gen>, ) -> Option<&<GenMapOf<K, V, Gen, S> as Get<GenIDOf<V, Gen>>>::Output>

Returns a reference to the value.

unsafe fn get_unchecked( &self, index: GenIDOf<V, Gen>, ) -> &<GenMapOf<K, V, Gen, S> as Get<GenIDOf<V, Gen>>>::Output

Returns a reference to the value.

fn get_or_panic(&self, index: Idx) -> &Self::Output

Returns a reference to the value.

fn is_index_valid(&self, index: Idx) -> bool

True if get(index) return Some, false otherwise.

fn is_index_invalid(&self, index: Idx) -> bool

True if get(index) return None, false otherwise.

fn contains(&self, index: Idx) -> bool

impl<K, V, Gen, S> Get<UntypedGenIDOf<Gen>> for GenMapOf<K, V, Gen, S>

where K: Clone, Gen: IGeneration, S: Collection,

type Output = V

fn get( &self, index: UntypedGenIDOf<Gen>, ) -> Option<&<GenMapOf<K, V, Gen, S> as Get<UntypedGenIDOf<Gen>>>::Output>

Returns a reference to the value.

unsafe fn get_unchecked( &self, index: UntypedGenIDOf<Gen>, ) -> &<GenMapOf<K, V, Gen, S> as Get<UntypedGenIDOf<Gen>>>::Output

Returns a reference to the value.

fn get_or_panic(&self, index: Idx) -> &Self::Output

Returns a reference to the value.

fn is_index_valid(&self, index: Idx) -> bool

True if get(index) return Some, false otherwise.

fn is_index_invalid(&self, index: Idx) -> bool

True if get(index) return None, false otherwise.

fn contains(&self, index: Idx) -> bool

impl<K, V, Gen, S> GetManyMut<GenIDOf<V, Gen>> for GenMapOf<K, V, Gen, S>

where K: Clone, Gen: IGeneration, S: Collection,

fn try_get_many_mut<const N: usize>( &mut self, indices: [GenIDOf<V, Gen>; N], ) -> Result<[&mut <GenMapOf<K, V, Gen, S> as Get<GenIDOf<V, Gen>>>::Output; N], GetDisjointMutError>

unsafe fn get_many_unchecked_mut<const N: usize>( &mut self, indices: [GenIDOf<V, Gen>; N], ) -> [&mut <GenMapOf<K, V, Gen, S> as Get<GenIDOf<V, Gen>>>::Output; N]

Returns multiples mutables references to the values. All values that can be accessed with the indices must be disjoint.

fn get_many_mut<const N: usize>( &mut self, indices: [Idx; N], ) -> Option<[&mut Self::Output; N]>

Returns multiples mutables references to the values. All values that can be accessed with the indices must be disjoint.

fn get_many_mut_or_panic<const N: usize>( &mut self, indices: [Idx; N], ) -> [&mut Self::Output; N]

Returns multiples mutables references to the values. All values that can be accessed with the indices must be disjoint.

fn swap(&mut self, a: Idx, b: Idx) -> bool

where Self::Output: Sized,

Swaps the values at two mutable locations, without deinitializing either one.

fn swap_or_panic(&mut self, a: Idx, b: Idx)

where Self::Output: Sized,

Swaps the values at two mutable locations, without deinitializing either one.

unsafe fn swap_unchecked(&mut self, a: Idx, b: Idx)

where Self::Output: Sized,

Swaps the values at two mutable locations, without deinitializing either one.

impl<K, V, Gen, S> GetManyMut<UntypedGenIDOf<Gen>> for GenMapOf<K, V, Gen, S>

where K: Clone, Gen: IGeneration, S: Collection,

fn try_get_many_mut<const N: usize>( &mut self, indices: [UntypedGenIDOf<Gen>; N], ) -> Result<[&mut <GenMapOf<K, V, Gen, S> as Get<UntypedGenIDOf<Gen>>>::Output; N], GetDisjointMutError>

unsafe fn get_many_unchecked_mut<const N: usize>( &mut self, indices: [UntypedGenIDOf<Gen>; N], ) -> [&mut <GenMapOf<K, V, Gen, S> as Get<UntypedGenIDOf<Gen>>>::Output; N]

Returns multiples mutables references to the values. All values that can be accessed with the indices must be disjoint.

fn get_many_mut<const N: usize>( &mut self, indices: [Idx; N], ) -> Option<[&mut Self::Output; N]>

Returns multiples mutables references to the values. All values that can be accessed with the indices must be disjoint.

fn get_many_mut_or_panic<const N: usize>( &mut self, indices: [Idx; N], ) -> [&mut Self::Output; N]

Returns multiples mutables references to the values. All values that can be accessed with the indices must be disjoint.

fn swap(&mut self, a: Idx, b: Idx) -> bool

where Self::Output: Sized,

Swaps the values at two mutable locations, without deinitializing either one.

fn swap_or_panic(&mut self, a: Idx, b: Idx)

where Self::Output: Sized,

Swaps the values at two mutable locations, without deinitializing either one.

unsafe fn swap_unchecked(&mut self, a: Idx, b: Idx)

where Self::Output: Sized,

Swaps the values at two mutable locations, without deinitializing either one.

impl<'a, Q, K, V, Gen, S> GetMut<&'a Q> for GenMapOf<K, V, Gen, S>

where K: Clone + Borrow<Q>, Gen: IGeneration, S: Get<&'a Q, Output = GenIDOf<V, Gen>>, Q: ?Sized,

fn get_mut( &mut self, index: &'a Q, ) -> Option<&mut <GenMapOf<K, V, Gen, S> as Get<&'a Q>>::Output>

Returns a mutable reference to the value.

fn get_mut_or_panic(&mut self, index: Idx) -> &mut Self::Output

unsafe fn get_unchecked_mut(&mut self, index: Idx) -> &mut Self::Output

Returns a mutable reference to the value.

fn replace(&mut self, index: Idx, value: Self::Output) -> Option<Self::Output>

where Self::Output: Sized,

Replace the value and return the old one.

fn replace_or_panic(&mut self, index: Idx, value: Self::Output) -> Self::Output

where Self::Output: Sized,

Replace the value and return the old one.

unsafe fn replace_unchecked( &mut self, index: Idx, value: Self::Output, ) -> Self::Output

where Self::Output: Sized,

Replace the value and return the old one.

fn set(&mut self, index: Idx, value: Self::Output) -> bool

where Self::Output: Sized,

Set the value and drop the previous one.

fn set_or_panic(&mut self, index: Idx, value: Self::Output) -> &mut Self

where Self::Output: Sized,

Set the value and drop the previous one.

unsafe fn set_unchecked(&mut self, index: Idx, value: Self::Output) -> &mut Self

where Self::Output: Sized,

impl<K, V, Gen, S> GetMut<GenIDOf<V, Gen>> for GenMapOf<K, V, Gen, S>

where K: Clone, Gen: IGeneration, S: Collection,

fn get_mut( &mut self, index: GenIDOf<V, Gen>, ) -> Option<&mut <GenMapOf<K, V, Gen, S> as Get<GenIDOf<V, Gen>>>::Output>

Returns a mutable reference to the value.

unsafe fn get_unchecked_mut( &mut self, index: GenIDOf<V, Gen>, ) -> &mut <GenMapOf<K, V, Gen, S> as Get<GenIDOf<V, Gen>>>::Output

Returns a mutable reference to the value.

fn get_mut_or_panic(&mut self, index: Idx) -> &mut Self::Output

fn replace(&mut self, index: Idx, value: Self::Output) -> Option<Self::Output>

where Self::Output: Sized,

Replace the value and return the old one.

fn replace_or_panic(&mut self, index: Idx, value: Self::Output) -> Self::Output

where Self::Output: Sized,

Replace the value and return the old one.

unsafe fn replace_unchecked( &mut self, index: Idx, value: Self::Output, ) -> Self::Output

where Self::Output: Sized,

Replace the value and return the old one.

fn set(&mut self, index: Idx, value: Self::Output) -> bool

where Self::Output: Sized,

Set the value and drop the previous one.

fn set_or_panic(&mut self, index: Idx, value: Self::Output) -> &mut Self

where Self::Output: Sized,

Set the value and drop the previous one.

unsafe fn set_unchecked(&mut self, index: Idx, value: Self::Output) -> &mut Self

where Self::Output: Sized,

impl<K, V, Gen, S> GetMut<UntypedGenIDOf<Gen>> for GenMapOf<K, V, Gen, S>

where K: Clone, Gen: IGeneration, S: Collection,

fn get_mut( &mut self, index: UntypedGenIDOf<Gen>, ) -> Option<&mut <GenMapOf<K, V, Gen, S> as Get<UntypedGenIDOf<Gen>>>::Output>

Returns a mutable reference to the value.

unsafe fn get_unchecked_mut( &mut self, index: UntypedGenIDOf<Gen>, ) -> &mut <GenMapOf<K, V, Gen, S> as Get<UntypedGenIDOf<Gen>>>::Output

Returns a mutable reference to the value.

fn get_mut_or_panic(&mut self, index: Idx) -> &mut Self::Output

fn replace(&mut self, index: Idx, value: Self::Output) -> Option<Self::Output>

where Self::Output: Sized,

Replace the value and return the old one.

fn replace_or_panic(&mut self, index: Idx, value: Self::Output) -> Self::Output

where Self::Output: Sized,

Replace the value and return the old one.

unsafe fn replace_unchecked( &mut self, index: Idx, value: Self::Output, ) -> Self::Output

where Self::Output: Sized,

Replace the value and return the old one.

fn set(&mut self, index: Idx, value: Self::Output) -> bool

where Self::Output: Sized,

Set the value and drop the previous one.

fn set_or_panic(&mut self, index: Idx, value: Self::Output) -> &mut Self

where Self::Output: Sized,

Set the value and drop the previous one.

unsafe fn set_unchecked(&mut self, index: Idx, value: Self::Output) -> &mut Self

where Self::Output: Sized,

impl<K, V, Gen, S> Hash for GenMapOf<K, V, Gen, S>

where K: Clone + Hash, Gen: IGeneration, V: Hash,

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

where H: Hasher,

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, Q, K, V, Gen, S> Index<&'a Q> for GenMapOf<K, V, Gen, S>

where K: Clone + Borrow<Q>, Gen: IGeneration, S: Get<&'a Q, Output = GenIDOf<V, Gen>>, Q: ?Sized,

type Output = V

The returned type after indexing.

fn index( &self, index: &'a Q, ) -> &<GenMapOf<K, V, Gen, S> as Index<&'a Q>>::Output

Performs the indexing (container[index]) operation.

impl<K, V, Gen, S> Index<GenIDOf<V, Gen>> for GenMapOf<K, V, Gen, S>

where K: Clone, Gen: IGeneration, S: Collection,

type Output = V

The returned type after indexing.

fn index( &self, index: GenIDOf<V, Gen>, ) -> &<GenMapOf<K, V, Gen, S> as Index<GenIDOf<V, Gen>>>::Output

Performs the indexing (container[index]) operation.

impl<K, V, Gen, S> Index<UntypedGenIDOf<Gen>> for GenMapOf<K, V, Gen, S>

where K: Clone, Gen: IGeneration, S: Collection,

type Output = V

The returned type after indexing.

fn index( &self, index: UntypedGenIDOf<Gen>, ) -> &<GenMapOf<K, V, Gen, S> as Index<UntypedGenIDOf<Gen>>>::Output

Performs the indexing (container[index]) operation.

impl<'a, Q, K, V, Gen, S> IndexMut<&'a Q> for GenMapOf<K, V, Gen, S>

where K: Clone + Borrow<Q>, Gen: IGeneration, S: Get<&'a Q, Output = GenIDOf<V, Gen>>, Q: ?Sized,

fn index_mut( &mut self, index: &'a Q, ) -> &mut <GenMapOf<K, V, Gen, S> as Index<&'a Q>>::Output

Performs the mutable indexing (container[index]) operation.

impl<K, V, Gen, S> IndexMut<GenIDOf<V, Gen>> for GenMapOf<K, V, Gen, S>

where K: Clone, Gen: IGeneration, S: Collection,

fn index_mut( &mut self, index: GenIDOf<V, Gen>, ) -> &mut <GenMapOf<K, V, Gen, S> as Index<GenIDOf<V, Gen>>>::Output

Performs the mutable indexing (container[index]) operation.

impl<K, V, Gen, S> IndexMut<UntypedGenIDOf<Gen>> for GenMapOf<K, V, Gen, S>

where K: Clone, Gen: IGeneration, S: Collection,

fn index_mut( &mut self, index: UntypedGenIDOf<Gen>, ) -> &mut <GenMapOf<K, V, Gen, S> as Index<UntypedGenIDOf<Gen>>>::Output

Performs the mutable indexing (container[index]) operation.

impl<K, V, Gen, S> Insert<K, V> for GenMapOf<K, V, Gen, S>

where K: Clone, Gen: IGeneration, S: Insert<K, GenIDOf<V, Gen>>,

fn insert(&mut self, key: K, value: V) -> Option<V>

Insert the (key, value), and return the old value

impl<'a, K, V, Gen, S> IntoIterator for &'a GenMapOf<K, V, Gen, S>

where K: Clone, Gen: IGeneration,

type Item = (GenIDOf<V, Gen>, &'a K, &'a V)

The type of the elements being iterated over.

type IntoIter = Iter<'a, K, V, Gen>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <&'a GenMapOf<K, V, Gen, S> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, K, V, Gen, S> IntoIterator for &'a mut GenMapOf<K, V, Gen, S>

where K: Clone, Gen: IGeneration,

type Item = (GenIDOf<V, Gen>, &'a K, &'a mut V)

The type of the elements being iterated over.

type IntoIter = IterMut<'a, K, V, Gen>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <&'a mut GenMapOf<K, V, Gen, S> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<K, V, Gen, S> IntoIterator for GenMapOf<K, V, Gen, S>

where K: Clone, Gen: IGeneration,

type Item = (GenIDOf<V, Gen>, K, V)

The type of the elements being iterated over.

type IntoIter = IntoIter<K, V, Gen>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <GenMapOf<K, V, Gen, S> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<K, V, Gen, S> Length for GenMapOf<K, V, Gen, S>

where K: Clone, Gen: IGeneration, S: Collection,

fn len(&self) -> usize

fn is_empty(&self) -> bool

True if the container contains 0 elements.

fn is_not_empty(&self) -> bool

True if the container contains at least one element. Will always be different than is_empty().

impl<K, V, Gen, S> PartialEq for GenMapOf<K, V, Gen, S>

where K: Clone + PartialEq, Gen: IGeneration, V: PartialEq,

fn eq(&self, other: &GenMapOf<K, V, Gen, S>) -> 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, Q, K, V, Gen, S> Remove<&'a Q> for GenMapOf<K, V, Gen, S>

where K: Clone + Borrow<Q>, Gen: IGeneration, S: Remove<&'a Q, Output = GenIDOf<V, Gen>>, Q: ?Sized,

type Output = V

fn remove( &mut self, index: &'a Q, ) -> Option<<GenMapOf<K, V, Gen, S> as Remove<&'a Q>>::Output>

impl<K, V, Gen, S> Remove<GenIDOf<V, Gen>> for GenMapOf<K, V, Gen, S>

where K: Clone, Gen: IGeneration, S: for<'a> Remove<&'a K, Output = GenIDOf<V, Gen>>,

type Output = V

fn remove( &mut self, index: GenIDOf<V, Gen>, ) -> Option<<GenMapOf<K, V, Gen, S> as Remove<GenIDOf<V, Gen>>>::Output>

impl<K, V, Gen, S> Remove<UntypedGenIDOf<Gen>> for GenMapOf<K, V, Gen, S>

where K: Clone, Gen: IGeneration, S: for<'a> Remove<&'a K, Output = GenIDOf<V, Gen>>,

type Output = V

fn remove( &mut self, index: UntypedGenIDOf<Gen>, ) -> Option<<GenMapOf<K, V, Gen, S> as Remove<UntypedGenIDOf<Gen>>>::Output>

impl<K, V, Gen, S> Reserve for GenMapOf<K, V, Gen, S>

where K: Clone, Gen: IGeneration, S: Reserve + Length,

fn reserve(&mut self, additional: usize)

fn reserve_exact(&mut self, additional: usize)

fn try_reserve(&mut self, additional: usize) -> Result<(), TryReserveError>

fn try_reserve_exact( &mut self, additional: usize, ) -> Result<(), TryReserveError>

fn reserve_total(&mut self, total: usize)

where Self: Length,

Ensure total capacity is at least total. Does nothing if the current capacity is already >= total.

fn try_reserve_total(&mut self, total: usize) -> Result<(), TryReserveError>

where Self: Length,

Ensure total capacity is at least total. Does nothing if the current capacity is already >= total.

fn reserve_total_exact(&mut self, total: usize)

where Self: Length,

Ensure total capacity is at least total. Does nothing if the current capacity is already >= total.

fn try_reserve_total_exact( &mut self, total: usize, ) -> Result<(), TryReserveError>

where Self: Length,

Ensure total capacity is at least total. Does nothing if the current capacity is already >= total.

impl<K, V, Gen, St> Serialize for GenMapOf<K, V, Gen, St>

where K: Clone + Serialize, Gen: IGeneration + Serialize, V: Serialize, GenSeq<Entry<K, V>, Gen>: Serialize,

Available on crate feature serde only.

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<K, V, Gen, S> Shrink for GenMapOf<K, V, Gen, S>

where K: Clone, Gen: IGeneration, S: Shrink,

fn shrink_to_fit(&mut self)

Shrinks the capacity as much as possible.

fn shrink_to(&mut self, min_capacity: usize)

Shrinks the capacity with a lower bound. The capacity will remain at least as large as both the length and the supplied value. If the current capacity is less than the lower limit, this is a no-op.

impl<'a, Q, K, V, Gen, S> TryGet<&'a Q> for GenMapOf<K, V, Gen, S>

where Q: Clone + ?Sized, K: Clone + Borrow<Q>, Gen: IGeneration, S: Get<&'a Q, Output = GenIDOf<V, Gen>>,

type Error = MissingKey<Q>

fn try_get( &self, index: &'a Q, ) -> Result<&<GenMapOf<K, V, Gen, S> as Get<&'a Q>>::Output, <GenMapOf<K, V, Gen, S> as TryGet<&'a Q>>::Error>

Returns a reference to the value.

impl<K, V, Gen, S> TryGet<GenIDOf<V, Gen>> for GenMapOf<K, V, Gen, S>

where K: Clone, Gen: IGeneration, S: Collection,

type Error = <GenSeq<Entry<K, V>, Gen> as TryGet<GenIDOf<Entry<K, V>, Gen>>>::Error

fn try_get( &self, index: GenIDOf<V, Gen>, ) -> Result<&<GenMapOf<K, V, Gen, S> as Get<GenIDOf<V, Gen>>>::Output, <GenMapOf<K, V, Gen, S> as TryGet<GenIDOf<V, Gen>>>::Error>

Returns a reference to the value.

impl<K, V, Gen, S> TryGet<UntypedGenIDOf<Gen>> for GenMapOf<K, V, Gen, S>

where K: Clone, Gen: IGeneration, S: Collection,

type Error = <GenSeq<Entry<K, V>, Gen> as TryGet<UntypedGenIDOf<Gen>>>::Error

fn try_get( &self, index: UntypedGenIDOf<Gen>, ) -> Result<&<GenMapOf<K, V, Gen, S> as Get<UntypedGenIDOf<Gen>>>::Output, <GenMapOf<K, V, Gen, S> as TryGet<UntypedGenIDOf<Gen>>>::Error>

Returns a reference to the value.

impl<'a, Q, K, V, Gen, S> TryGetMut<&'a Q> for GenMapOf<K, V, Gen, S>

where Q: Clone + ?Sized, K: Clone + Borrow<Q>, Gen: IGeneration, S: Get<&'a Q, Output = GenIDOf<V, Gen>>,

fn try_get_mut( &mut self, index: &'a Q, ) -> Result<&mut <GenMapOf<K, V, Gen, S> as Get<&'a Q>>::Output, <GenMapOf<K, V, Gen, S> as TryGet<&'a Q>>::Error>

Returns a mutable reference to the value.

fn try_replace( &mut self, index: Idx, value: Self::Output, ) -> Result<Self::Output, Self::Error>

where Self::Output: Sized,

Replace the value and return the old one.

fn try_set( &mut self, index: Idx, value: Self::Output, ) -> Result<(), Self::Error>

where Self::Output: Sized,

Set the value and drop the previous one.

impl<K, V, Gen, S> TryGetMut<GenIDOf<V, Gen>> for GenMapOf<K, V, Gen, S>

where K: Clone, Gen: IGeneration, S: Collection,

fn try_get_mut( &mut self, index: GenIDOf<V, Gen>, ) -> Result<&mut <GenMapOf<K, V, Gen, S> as Get<GenIDOf<V, Gen>>>::Output, <GenMapOf<K, V, Gen, S> as TryGet<GenIDOf<V, Gen>>>::Error>

Returns a mutable reference to the value.

fn try_replace( &mut self, index: Idx, value: Self::Output, ) -> Result<Self::Output, Self::Error>

where Self::Output: Sized,

Replace the value and return the old one.

fn try_set( &mut self, index: Idx, value: Self::Output, ) -> Result<(), Self::Error>

where Self::Output: Sized,

Set the value and drop the previous one.

impl<K, V, Gen, S> TryGetMut<UntypedGenIDOf<Gen>> for GenMapOf<K, V, Gen, S>

where K: Clone, Gen: IGeneration, S: Collection,

fn try_get_mut( &mut self, index: UntypedGenIDOf<Gen>, ) -> Result<&mut <GenMapOf<K, V, Gen, S> as Get<UntypedGenIDOf<Gen>>>::Output, <GenMapOf<K, V, Gen, S> as TryGet<UntypedGenIDOf<Gen>>>::Error>

Returns a mutable reference to the value.

fn try_replace( &mut self, index: Idx, value: Self::Output, ) -> Result<Self::Output, Self::Error>

where Self::Output: Sized,

Replace the value and return the old one.

fn try_set( &mut self, index: Idx, value: Self::Output, ) -> Result<(), Self::Error>

where Self::Output: Sized,

Set the value and drop the previous one.

impl<K, V, Gen, S> WithCapacity for GenMapOf<K, V, Gen, S>

where K: Clone, Gen: IGeneration, S: WithCapacity + Length, <S as WithCapacity>::Param: Default,

type Param = ()

fn with_capacity_and_param( capacity: usize, _: <GenMapOf<K, V, Gen, S> as WithCapacity>::Param, ) -> GenMapOf<K, V, Gen, S>

fn with_capacity(capacity: usize) -> Self

where Self: Sized, Self::Param: Default,

impl<K, V, Gen, S> Collection for GenMapOf<K, V, Gen, S>

where K: Clone, Gen: IGeneration, S: Collection,

impl<K, V, Gen, S> CollectionBijective for GenMapOf<K, V, Gen, S>

where K: Clone, Gen: IGeneration, S: Collection,

impl<K, V, Gen, S> Eq for GenMapOf<K, V, Gen, S>

where K: Clone + Eq, Gen: IGeneration, V: Eq,