Struct counted_map::reassignable_counted_map::ReassignableCountedMap

pub struct ReassignableCountedMap<K: HashIndex, V> { /* private fields */ }

Implementations

impl<K: HashIndex, V> ReassignableCountedMap<K, V>

pub fn new() -> Self

pub unsafe fn new_unsafe( hash_map: HashMap<K, V>, counter: RemovableCounter<K> ) -> Self

pub fn with_hasher(hash_builder: RandomState) -> Self

pub fn with_capacity(capacity: usize) -> Self

pub fn with_capacity_and_hasher( capacity: usize, hash_builder: RandomState ) -> Self

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn capacity(&self) -> usize

pub fn clear(&mut self)

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

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

pub fn shrink_to_fit(&mut self)

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

pub fn drain(&mut self) -> Drain<'_, K, V>

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

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

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

pub fn keys(&self) -> Keys<'_, K, V>

pub fn values(&self) -> Values<'_, K, V>

pub fn values_mut(&mut self) -> ValuesMut<'_, K, V>

pub fn get_hash_map(&self) -> &HashMap<K, V>

pub unsafe fn get_hash_map_mut(&mut self) -> &mut HashMap<K, V>

pub fn extract_hash_map(self) -> HashMap<K, V>

pub fn get_counter(&self) -> &RemovableCounter<K>

pub unsafe fn get_counter_mut(&mut self) -> &mut RemovableCounter<K>

pub fn extract_counter(self) -> RemovableCounter<K>

pub fn extract(self) -> (HashMap<K, V>, RemovableCounter<K>)

pub fn push(&mut self, value: V) -> Result<K, HashMapFull>

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

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

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

pub fn remove_entry(&mut self, index: K) -> Option<(K, V)>

Trait Implementations

impl<K: HashIndex, V> AsRef<HashMap<K, V>> for ReassignableCountedMap<K, V>

fn as_ref(&self) -> &HashMap<K, V>

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

impl<K: HashIndex, V> AsRef<RemovableCounter<K>> for ReassignableCountedMap<K, V>

fn as_ref(&self) -> &RemovableCounter<K>

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

impl<K: Clone + HashIndex, V: Clone> Clone for ReassignableCountedMap<K, V>

fn clone(&self) -> ReassignableCountedMap<K, V>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<K: Debug + HashIndex, V: Debug> Debug for ReassignableCountedMap<K, V>

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

Formats the value using the given formatter.

impl<K: HashIndex, V> Default for ReassignableCountedMap<K, V>

fn default() -> Self

Returns the “default value” for a type.

impl<K: HashIndex, V> Index<&K> for ReassignableCountedMap<K, V>

type Output = V

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<K: HashIndex, V> IndexMut<&K> for ReassignableCountedMap<K, V>

fn index_mut(&mut self, index: &K) -> &mut Self::Output

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

impl<'a, K: HashIndex, V> IntoIterator for &'a ReassignableCountedMap<K, V>

type Item = (&'a K, &'a V)

The type of the elements being iterated over.

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

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, K: HashIndex, V> IntoIterator for &'a mut ReassignableCountedMap<K, V>

type Item = (&'a K, &'a mut V)

The type of the elements being iterated over.

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

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<K: HashIndex, V> IntoIterator for ReassignableCountedMap<K, V>

type Item = (K, V)

The type of the elements being iterated over.

type IntoIter = IntoIter<K, V>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<K: PartialEq + HashIndex, V: PartialEq> PartialEq for ReassignableCountedMap<K, V>

fn eq(&self, other: &ReassignableCountedMap<K, V>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<K: Eq + HashIndex, V: Eq> Eq for ReassignableCountedMap<K, V>

impl<K: HashIndex, V> StructuralPartialEq for ReassignableCountedMap<K, V>