Struct SmallOrderedMap 

pub struct SmallOrderedMap<Key, Value>(/* private fields */);

A mapping optimized for very small maps.

Wrapping the vector_map::VecMap structure.

Implementations

impl<Key: Eq, Value> SmallOrderedMap<Key, Value>

pub fn new() -> Self

Creates a new empty map.

pub fn with_capacity(capacity: usize) -> Self

Creates a new map with the given capacity.

impl<Key: Eq, Value: Eq> SmallOrderedMap<Key, Value>

pub fn eq_unordered(&self, other: &Self) -> bool

Checks if the two maps have the same keys and values.

Methods from Deref<Target = VecMap<Key, Value>>

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn capacity(&self) -> usize

pub fn clear(&mut self)

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

where Q: PartialEq<K> + ?Sized,

pub fn get<'l, Q>(&'l self, key: &Q) -> Option<&'l V>

where Q: PartialEq<K> + ?Sized,

pub fn get_mut<'l, Q>(&'l mut self, key: &Q) -> Option<&'l mut V>

where Q: PartialEq<K> + ?Sized,

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

where K: PartialEq,

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

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

pub fn shrink_to_fit(&mut self)

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

where Q: PartialEq<K> + ?Sized,

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

where Q: PartialEq<K> + ?Sized,

pub fn entry(&mut self, key: K) -> Entry<'_, K, V>

where K: PartialEq,

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

where Q: PartialEq<K> + ?Sized,

pub fn retain<F>(&mut self, f: F)

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

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

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

pub fn sort(&mut self)

where K: Ord,

pub unsafe fn identical(&self, other: &VecMap<K, V>) -> bool

where K: PartialEq, V: PartialEq,

Much faster than self == other, but will return false if the order of the data isn’t identical.

Safety

Note that for the order of data with two VecMaps to be identical, they must either have been both sorted, or they must have undergone the insertion and removal of keys in the same order.

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

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

Trait Implementations

impl<Key: Clone, Value: Clone> Clone for SmallOrderedMap<Key, Value>

fn clone(&self) -> SmallOrderedMap<Key, Value>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Key: Debug, Value: Debug> Debug for SmallOrderedMap<Key, Value>

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

Formats the value using the given formatter.

impl<Key: Eq, Value> Default for SmallOrderedMap<Key, Value>

fn default() -> Self

Returns the “default value” for a type.

impl<Key, Value> Deref for SmallOrderedMap<Key, Value>

type Target = VecMap<Key, Value>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<Key, Value> DerefMut for SmallOrderedMap<Key, Value>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<Key: Eq, Value> FromIterator<(Key, Value)> for SmallOrderedMap<Key, Value>

fn from_iter<T: IntoIterator<Item = (Key, Value)>>(iter: T) -> Self

Creates a value from an iterator.

impl<Key, Value> IntoIterator for SmallOrderedMap<Key, Value>

type Item = (Key, Value)

The type of the elements being iterated over.

type IntoIter = IntoIter<Key, Value>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<Key: Eq, Value: HasZero + Clone + Eq> MergeCollection<Key, Value> for SmallOrderedMap<Key, Value>

Available on crate feature std only.

fn merge_collection( self, other: impl IntoIterator<Item = (Key, Value)>, action: impl Fn(Value, Value) -> Value, ) -> Self

Returns a collection which contains the combination by using action of the values from the given two collections, for each key.

impl<Key: Eq, Value: Eq> PartialEq for SmallOrderedMap<Key, Value>

fn eq(&self, other: &Self) -> 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<Key: Update + Eq, Value: Update> Update for SmallOrderedMap<Key, Value>

Available on crate feature salsa only.

unsafe fn maybe_update(old_pointer: *mut Self, new_map: Self) -> bool

Returns

impl<Key: Eq, Value: Eq> Eq for SmallOrderedMap<Key, Value>