Struct PlaceholderMap 

pub struct PlaceholderMap<K, V, S = DefaultHashBuilder, A = Global>
where
    A: Allocator,
{ /* private fields */ }

Implementations

impl<K, V, S, A> PlaceholderMap<K, V, S, A>

where S: Default, A: Allocator + Default,

pub fn new() -> Self

pub fn with_key_capacity(capacity: usize) -> Self

pub fn with_value_capacity(capacity: usize) -> Self

pub fn with_key_value_capacity( key_capacity: usize, value_capacity: usize, ) -> Self

impl<K, V, S, A> PlaceholderMap<K, V, S, A>

where S: Default, A: Allocator + Clone,

pub fn new_in(alloc: A) -> Self

pub fn with_key_capacity_in(capacity: usize, alloc: A) -> Self

pub fn with_value_capacity_in(capacity: usize, alloc: A) -> Self

pub fn with_key_value_capacity_in( key_capacity: usize, value_capacity: usize, alloc: A, ) -> Self

impl<K, V, S, A> PlaceholderMap<K, V, S, A>

where S: Clone, A: Allocator + Default,

pub fn with_hasher(hash_builder: S) -> Self

pub fn with_key_capacity_and_hasher(capacity: usize, hash_builder: S) -> Self

pub fn with_value_capacity_and_hasher(capacity: usize, hash_builder: S) -> Self

pub fn with_key_value_capacity_and_hasher( key_capacity: usize, value_capacity: usize, hash_builder: S, ) -> Self

impl<K, V, S, A> PlaceholderMap<K, V, S, A>

where S: Clone, A: Allocator + Clone,

pub fn with_hasher_in(hash_builder: S, alloc: A) -> Self

pub fn with_key_capacity_and_hasher_in( capacity: usize, hash_builder: S, alloc: A, ) -> Self

pub fn with_value_capacity_and_hasher_in( capacity: usize, hash_builder: S, alloc: A, ) -> Self

pub fn with_key_value_capacity_and_hasher_in( key_capacity: usize, value_capacity: usize, hash_builder: S, alloc: A, ) -> Self

impl<K, V, S, A> PlaceholderMap<K, V, S, A>

where A: Allocator,

pub fn key_allocator(&self) -> &A

pub fn value_allocator(&self) -> &A

pub fn key_hasher(&self) -> &S

pub fn value_hasher(&self) -> &S

pub fn key_capacity(&self) -> usize

pub fn value_capacity(&self) -> usize

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

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

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

pub fn len(&self) -> usize

pub fn values_len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn clear(&mut self)

pub fn into_keys(self) -> IntoKeys<K, V, A>

pub fn into_values(self) -> IntoValues<V, A>

impl<K, V, S, A> PlaceholderMap<K, V, S, A>

where K: Eq + Hash, S: BuildHasher, A: Allocator,

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

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

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

pub fn shrink_keys_to_fit(&mut self)

pub fn get<Q>(&self, k: &Q) -> Option<&V>

where Q: Hash + Equivalent<K> + ?Sized,

pub fn get_key_value<Q>(&self, k: &Q) -> Option<(&K, &V)>

where Q: Hash + Equivalent<K> + ?Sized,

pub fn contains_key<Q>(&self, k: &Q) -> bool

where Q: Hash + Equivalent<K> + ?Sized,

impl<K, V, S, A> PlaceholderMap<K, V, S, A>

where V: Eq + Hash, S: BuildHasher, A: Allocator,

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

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

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

pub fn shrink_values_to_fit(&mut self)

impl<K, V, S, A> PlaceholderMap<K, V, S, A>

where K: Eq + Hash, V: Eq + Hash, S: BuildHasher, A: Allocator,

pub fn reserve_keys_values( &mut self, additional_keys: usize, additional_values: usize, )

pub fn try_reserve_keys_values( &mut self, additional_keys: usize, additional_values: usize, ) -> Result<(), TryReserveKeysValuesError>

pub fn shrink_keys_values_to( &mut self, min_capacity_keys: usize, min_capacity_values: usize, )

pub fn shrink_keys_values_to_fit(&mut self)

pub fn insert(&mut self, k: K, v: V) -> &V

pub fn insert_value_ref(&mut self, k: K, v: &V) -> &V

where V: Clone,

Same as insert(), except takes a reference to value, and clones it if the value isn’t already present in the map

pub unsafe fn insert_unique_unchecked(&mut self, k: K, v: V) -> (&K, &V)

Safety

See safety docs of [hashbrown::HashMap::insert_unique_unchecked]

pub fn try_insert(&mut self, k: K, v: V) -> Result<&V, ()>

pub fn remove<Q>(&mut self, k: &Q) -> Option<V>

where Q: Hash + Equivalent<K> + ?Sized,

Removes a key from the map, returning the value at the key if the key was the last key to point at the value

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

where Q: Hash + Equivalent<K> + ?Sized,

Removes a key from the map, returning the stored key if the key was previously in the map, and the value at the key if the key was the last key to point at the value

pub fn allocation_size(&self) -> usize

Trait Implementations

impl<K, V, S, A> Clone for PlaceholderMap<K, V, S, A>

where K: Eq + Hash + Clone, V: Eq + Hash + Clone, S: BuildHasher + Clone, A: Allocator + Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K, V, S, A> Debug for PlaceholderMap<K, V, S, A>

where K: Debug, V: Debug, A: Allocator,

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

Formats the value using the given formatter.

impl<K, V> Default for PlaceholderMap<K, V>

fn default() -> Self

Returns the “default value” for a type.

impl<'h, K, V, S, A> Extend<&'h (K, V)> for PlaceholderMap<K, V, S, A>

where K: Eq + Hash + Clone, V: Eq + Hash + Clone, S: BuildHasher, A: Allocator,

fn extend<T: IntoIterator<Item = &'h (K, V)>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: T)

🔬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<'h, K, V, S, A> Extend<(&'h K, &'h V)> for PlaceholderMap<K, V, S, A>

where K: Eq + Hash + Clone, V: Eq + Hash + Clone, S: BuildHasher, A: Allocator,

fn extend<T: IntoIterator<Item = (&'h K, &'h V)>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: T)

🔬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, S, A> Extend<(K, V)> for PlaceholderMap<K, V, S, A>

where K: Eq + Hash, V: Eq + Hash, S: BuildHasher, A: Allocator,

fn extend<T: IntoIterator<Item = (K, V)>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: T)

🔬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, S, A> From<Vec<(K, V)>> for PlaceholderMap<K, V, S, A>

where K: Eq + Hash, V: Eq + Hash, S: Default + BuildHasher, A: Default + Allocator,

fn from(value: Vec<(K, V)>) -> Self

Converts to this type from the input type.

impl<K, V, S, A, const N: usize> From<[(K, V); N]> for PlaceholderMap<K, V, S, A>

where K: Eq + Hash, V: Eq + Hash, S: Default + BuildHasher, A: Default + Allocator,

fn from(value: [(K, V); N]) -> Self

Converts to this type from the input type.

impl<K, V, S, A> Send for PlaceholderMap<K, V, S, A>

where K: Send, V: Send, S: Send, A: Allocator + Send,