Struct compactmap::wrapped::CompactMap

pub struct CompactMap<K: Into<usize> + From<usize>, V> { /* fields omitted */ }

Special version of CompactMap that uses your usize-equivalent types as keys You are expected to use newtype-style structs like struct MyToken(usize); for this If needed, you can cheat with into_unwrapped, unwrapped and so on.

For example, this will fail:

#[macro_use]
extern crate compactmap;
fn main() {
  use compactmap::wrapped::CompactMap;
   
  declare_compactmap_token!(Mom);
  declare_compactmap_token!(Lol);
   
  let mut m1: CompactMap<Mom, u64> = CompactMap::new();
  let mut m2: CompactMap<Lol, u64> = CompactMap::new();
   
  let q = m1.insert(123);
  m2.remove(q); // expected type `main::Lol`, found type `main::Mom`
}

Methods

impl<K: Into<usize> + From<usize>, V> CompactMap<K, V>

fn into_unwrapped(self) -> CompactMap<V>

Extract underlying unwrapped map

fn from_unwrapped(s: CompactMap<V>) -> Self

Wrap the map. You are responsible that it is the correct one

fn unwrapped(&self) -> &CompactMap<V>

Temporarily use the map without the safety wrapper

fn unwrapped_mut(&mut self) -> &mut CompactMap<V>

Temporarily use the map without the safety wrapper

impl<K: Into<usize> + From<usize>, V> CompactMap<K, V>

fn new() -> Self

See super::CompactMap::new

fn with_capacity(capacity: usize) -> Self

See super::CompactMap::with_capacity

fn capacity(&self) -> usize

See super::CompactMap::capacity

fn reserve(&mut self, len: usize)

See super::CompactMap::reserve

fn reserve_exact(&mut self, len: usize)

See super::CompactMap::reserve_exact

fn clear(&mut self)

See super::CompactMap::clear

fn is_empty_slow(&self) -> bool

See super::CompactMap::is_empty_slow

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

See super::CompactMap::insert

fn insert_with<F>(&mut self, f: F) -> K where
    F: FnOnce(K) -> V, 

See super::CompactMap::insert_with

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

See super::CompactMap::remove

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

See super::CompactMap::get

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

See super::CompactMap::get_mut

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

Returns an iterator visiting all key-value pairs in unspecified order. The iterator's element type is (K, &'r V).

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

Returns an iterator visiting all key-value pairs in unspecified order, with mutable references to the values. The iterator's element type is (K, &'r mut V)

fn into_iter(self) -> IntoIter<K, V>

Returns an iterator visiting all key-value pairs in unspecified order, the keys, consuming the original CompactMap. The iterator's element type is (K, V).

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

Returns an iterator visiting all keys in some order. The iterator's element type is K.

fn values(&self) -> Values<V>

See super::CompactMap::values

fn values_mut(&mut self) -> ValuesMut<V>

See super::CompactMap::values_mut

fn len_slow(&self) -> usize

See super::CompactMap::len_slow

fn shrink_to_fit(&mut self)

See super::CompactMap::shrink_to_fit

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

Returns an iterator visiting all key-value pairs in ascending order of the keys, emptying (but not consuming) the original CompactMap. The iterator's element type is (K, V). Keeps the allocated memory for reuse.

Trait Implementations

impl<K: Default + Into<usize> + From<usize>, V: Default> Default for CompactMap<K, V>

fn default() -> CompactMap<K, V>

Returns the "default value" for a type.

impl<K: Hash + Into<usize> + From<usize>, V: Hash> Hash for CompactMap<K, V>

fn hash<__HKV: Hasher>(&self, __arg_0: &mut __HKV)

Feeds this value into the given [Hasher].

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

Feeds a slice of this type into the given [Hasher].

impl<K: PartialEq + Into<usize> + From<usize>, V: PartialEq> PartialEq for CompactMap<K, V>

fn eq(&self, __arg_0: &CompactMap<K, V>) -> bool

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

fn ne(&self, __arg_0: &CompactMap<K, V>) -> bool

This method tests for !=.

impl<K: Eq + Into<usize> + From<usize>, V: Eq> Eq for CompactMap<K, V>

impl<K: PartialOrd + Into<usize> + From<usize>, V: PartialOrd> PartialOrd for CompactMap<K, V>

fn partial_cmp(&self, __arg_0: &CompactMap<K, V>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, __arg_0: &CompactMap<K, V>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, __arg_0: &CompactMap<K, V>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, __arg_0: &CompactMap<K, V>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, __arg_0: &CompactMap<K, V>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<K: Ord + Into<usize> + From<usize>, V: Ord> Ord for CompactMap<K, V>

fn cmp(&self, __arg_0: &CompactMap<K, V>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

impl<K: Into<usize> + From<usize>, V> FromIterator<V> for CompactMap<K, V>

fn from_iter<I>(iter: I) -> CompactMap<K, V> where
    I: IntoIterator<Item = V>, 

Creates a value from an iterator.

impl<'a, K: Into<usize> + From<usize>, V> FromIterator<&'a V> for CompactMap<K, V> where
    V: Copy, 

fn from_iter<I>(iter: I) -> CompactMap<K, V> where
    I: IntoIterator<Item = &'a V>, 

Creates a value from an iterator.

impl<K: Into<usize> + From<usize>, V> Extend<V> for CompactMap<K, V>

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

Extends a collection with the contents of an iterator.

impl<'a, K: Into<usize> + From<usize>, V> Extend<&'a V> for CompactMap<K, V> where
    V: Copy, 

fn extend<I>(&mut self, iter: I) where
    I: IntoIterator<Item = &'a V>, 

Extends a collection with the contents of an iterator.

impl<V, K: Into<usize> + From<usize>> Index<K> for CompactMap<K, V>

type Output = V

The returned type after indexing.

fn index(&self, i: K) -> &V

Performs the indexing (container[index]) operation.

impl<'a, K: Copy + Into<usize> + From<usize>, V> Index<&'a K> for CompactMap<K, V>

type Output = V

The returned type after indexing.

fn index(&self, i: &K) -> &V

Performs the indexing (container[index]) operation.

impl<K: Into<usize> + From<usize>, V> IndexMut<K> for CompactMap<K, V>

fn index_mut(&mut self, i: K) -> &mut V

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

impl<'a, K: Copy + Into<usize> + From<usize>, V> IndexMut<&'a K> for CompactMap<K, V>

fn index_mut(&mut self, i: &K) -> &mut V

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

impl<K: Into<usize> + From<usize>, V: Debug> Debug for CompactMap<K, V>

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

Formats the value using the given formatter.

impl<'a, K: Into<usize> + From<usize>, V> IntoIterator for &'a CompactMap<K, V>

type Item = (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) -> Iter<'a, K, V>

Creates an iterator from a value.

impl<'a, K: Into<usize> + From<usize>, V: 'a> IntoIterator for &'a mut CompactMap<K, V>

type Item = (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) -> IterMut<'a, K, V>

Creates an iterator from a value.

impl<K: Into<usize> + From<usize>, V> IntoIterator for CompactMap<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) -> IntoIter<K, V>

Creates an iterator from a value.