Struct VecMap 

pub struct VecMap<K: Eq + PartialEq, V> { /* private fields */ }

Implementations

impl<K: Eq + PartialEq, V> VecMap<K, V>

pub fn new() -> Self

pub fn with_capacity(capacity: usize) -> Self

pub fn set(&mut self, key: K, value: V) -> bool

pub fn append(&mut self, key: K, value: V)

pub fn with_append(self, key: K, value: V) -> Self

pub fn insert(&mut self, idx: usize, key: K, value: V)

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

where K: Borrow<Q> + PartialEq<Q>,

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

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

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

where K: Borrow<Q> + PartialEq<Q>,

pub fn remove_all(&mut self, key: &K)

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

pub fn swap_remove(&mut self, index: usize) -> V

pub fn is_empty(&self) -> bool

pub fn len(&self) -> usize

pub fn clear(&mut self)

pub fn iter(&self) -> impl Iterator<Item = (&K, &V)>

pub fn iter_by_key<'x, 'y: 'x>( &'x self, key: &'y K, ) -> impl Iterator<Item = &'x V> + 'x

pub fn iter_mut(&mut self) -> impl Iterator<Item = (&mut K, &mut V)>

pub fn iter_mut_by_key<'x, 'y: 'x>( &'x mut self, key: &'y K, ) -> impl Iterator<Item = &'x mut V> + 'x

pub fn keys(&self) -> impl Iterator<Item = &K>

pub fn values(&self) -> impl Iterator<Item = &V>

pub fn values_mut(&mut self) -> impl Iterator<Item = &mut V>

pub fn get_mut_or_insert_with( &mut self, key: K, fnc: impl FnOnce() -> V, ) -> &mut V

pub fn with_key_value(self, key: K, value: V) -> Self

pub fn sort_unstable(&mut self)

where K: Ord, V: Ord,

impl<K: Eq + PartialEq, V: Default> VecMap<K, V>

pub fn get_mut_or_insert(&mut self, key: K) -> &mut V

Trait Implementations

impl<K: Eq + PartialEq, V> Archive for VecMap<K, V>

where Vec<KeyValue<K, V>>: Archive,

type Archived = ArchivedVecMap<K, V>

The archived representation of this type.

type Resolver = VecMapResolver<K, V>

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

fn resolve(&self, resolver: Self::Resolver, out: Place<Self::Archived>)

Creates the archived version of this value at the given position and writes it to the given output.

const COPY_OPTIMIZATION: CopyOptimization<Self> = _

An optimization flag that allows the bytes of this type to be copied directly to a writer instead of calling serialize.

impl<K: Clone + Eq + PartialEq, V: Clone> Clone for VecMap<K, V>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K: Debug + Eq + PartialEq, V: Debug> Debug for VecMap<K, V>

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

Formats the value using the given formatter.

impl<K: Eq + PartialEq, V> Default for VecMap<K, V>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, K: Eq + PartialEq + Deserialize<'de>, V: Deserialize<'de>> Deserialize<'de> for VecMap<K, V>

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<__D: Fallible + ?Sized, K: Eq + PartialEq, V> Deserialize<VecMap<K, V>, __D> for Archived<VecMap<K, V>>

where Vec<KeyValue<K, V>>: Archive, <Vec<KeyValue<K, V>> as Archive>::Archived: Deserialize<Vec<KeyValue<K, V>>, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<VecMap<K, V>, <__D as Fallible>::Error>

Deserializes using the given deserializer

impl<K: Eq + PartialEq, V> FromIterator<(K, V)> for VecMap<K, V>

fn from_iter<T>(iter: T) -> Self

where T: IntoIterator<Item = (K, V)>,

Creates a value from an iterator.

impl<K, V> Hash for VecMap<K, V>

where K: Eq + PartialEq + Hash, V: Hash,

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'x, K: Eq + PartialEq, V> IntoIterator for &'x VecMap<K, V>

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

The type of the elements being iterated over.

type IntoIter = Map<Iter<'x, KeyValue<K, V>>, fn(&'x KeyValue<K, V>) -> (&'x K, &'x V)>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<K: Eq + PartialEq, V> IntoIterator for VecMap<K, V>

type Item = (K, V)

The type of the elements being iterated over.

type IntoIter = Map<IntoIter<KeyValue<K, V>>, fn(KeyValue<K, V>) -> (K, V)>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T: FromStr + Eq, V> IntoValid for VecMap<MaybeIdReference<T>, V>

type Item = (T, V)

fn into_valid(self) -> impl Iterator<Item = Self::Item>

impl<T: FromStr + Eq, V> IntoValid for VecMap<MaybeInvalid<T>, V>

type Item = (T, V)

fn into_valid(self) -> impl Iterator<Item = Self::Item>

impl<K: PartialEq + Eq + PartialEq, V: PartialEq> PartialEq for VecMap<K, V>

fn eq(&self, other: &VecMap<K, V>) -> 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<__S: Fallible + ?Sized, K: Eq + PartialEq, V> Serialize<__S> for VecMap<K, V>

where Vec<KeyValue<K, V>>: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Self as Archive>::Resolver, <__S as Fallible>::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

impl<K: Eq + PartialEq + Serialize, V: Serialize> Serialize for VecMap<K, V>

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<K: Eq + Eq + PartialEq, V: Eq> Eq for VecMap<K, V>

impl<K: Eq + PartialEq, V> StructuralPartialEq for VecMap<K, V>