Struct VecMap

pub struct VecMap<K: Ord + 'static, V, const SORTED: bool> { /* private fields */ }

A map type implemented as a list of key/value pairs.

If the const generic SORTED is set to true, keys will be sorted in ascending order, lookups are O(log(n)), and insertions are O(n). If SORTED is set to false, keys will be sorted in insertion order, lookups are O(n), and insertions are O(1).

Implementations

impl<K: Ord + 'static, V, const SORTED: bool> VecMap<K, V, SORTED>

pub fn new() -> Self

Creates a new, empty map.

pub fn with_capacity(cap: usize) -> Self

Creates a new, empty map with the specified capacity.

pub fn get<Q: ?Sized + Ord>(&self, key: &Q) -> Option<&V>

where K: Borrow<Q>,

Gets an immutable reference to a stored value, if it exists.

pub fn get_mut<Q: ?Sized + Ord>(&mut self, key: &Q) -> Option<&mut V>

where K: Borrow<Q>,

Gets a mutable reference to a stored value, if it exists.

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

Inserts a new value into the map. If an entry with the same key already exists, the previous value is returned.

pub fn len(&self) -> usize

Gets the number of values stored in the map.

pub fn is_empty(&self) -> bool

Checks if the map is currently empty (no values).

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

Iterates through the map.

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

Iterates through the map.

pub fn as_slice(&self) -> &[Entry<K, V>]

Gets a raw slice of the entries stored in the map.

Trait Implementations

impl<K: Ord + 'static, V, const SORTED: bool> Collect for VecMap<K, V, SORTED>

where V: Collect,

fn needs_trace() -> bool

As an optimization, if this type can never hold a Gc pointer and trace is unnecessary to call, you may implement this method and return false. The default implementation returns true, signaling that Collect::trace must be called.

fn trace(&self, cc: &Collection)

Must call Collect::trace on all held Gc pointers. If this type holds inner types that implement Collect, a valid implementation would simply call Collect::trace on all the held values to ensure this.

impl<K: Debug + Ord + 'static, V: Debug, const SORTED: bool> Debug for VecMap<K, V, SORTED>

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

Formats the value using the given formatter.

impl<K: Ord + 'static, V, const SORTED: bool> Default for VecMap<K, V, SORTED>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, K, V, const SORTED: bool> Deserialize<'de> for VecMap<K, V, SORTED>

where K: Deserialize<'de> + Ord + 'static, V: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<K: Ord + 'static, V, const SORTED: bool> FromIterator<(K, V)> for VecMap<K, V, SORTED>

fn from_iter<T: IntoIterator<Item = (K, V)>>(iter: T) -> Self

Creates a value from an iterator.

impl<K: Ord + 'static, V, const SORTED: bool> IntoIterator for VecMap<K, V, SORTED>

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, V, const SORTED: bool> Serialize for VecMap<K, V, SORTED>

where K: Serialize + Ord + 'static, V: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.