Struct rkyv::collections::index_map::ArchivedIndexMap

#[repr(C)]
pub struct ArchivedIndexMap<K, V> { /* private fields */ }

An archived IndexMap.

Implementations

impl<K, V> ArchivedIndexMap<K, V>

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

where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

Returns whether a key is present in the hash map.

pub fn first(&self) -> Option<(&K, &V)>

Returns the first key-value pair.

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

where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

Gets the value associated with the given key.

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

where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

Gets the index, key, and value associated with the given key.

pub fn get_index(&self, index: usize) -> Option<(&K, &V)>

Gets a key-value pair by index.

pub fn get_index_of<Q>(&self, key: &Q) -> Option<usize>

where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

Gets the index of a key if it exists in the map.

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

where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

Gets the key-value pair associated with the given key.

pub fn hasher(&self) -> HashBuilder

Gets the hasher for this index map.

pub const fn is_empty(&self) -> bool

Returns true if the map contains no elements.

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

Returns an iterator over the key-value pairs of the map in order

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

Returns an iterator over the keys of the map in order

pub fn last(&self) -> Option<(&K, &V)>

Returns the last key-value pair.

pub const fn len(&self) -> usize

Gets the number of items in the index map.

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

Returns an iterator over the values of the map in order.

pub unsafe fn resolve_from_len( len: usize, pos: usize, resolver: IndexMapResolver, out: *mut Self, )

Resolves an archived index map from a given length and parameters.

Safety

• len must be the number of elements that were serialized
• pos must be the position of out within the archive
• resolver must be the result of serializing a hash map

impl<K, V> ArchivedIndexMap<K, V>

pub unsafe fn serialize_from_iter_index<'a, UK, UV, I, F, S>( iter: I, index: F, serializer: &mut S, ) -> Result<IndexMapResolver, S::Error>

where UK: 'a + Serialize<S, Archived = K> + Hash + Eq, UV: 'a + Serialize<S, Archived = V>, I: Clone + ExactSizeIterator<Item = (&'a UK, &'a UV)>, F: Fn(&UK) -> usize, S: Serializer + ScratchSpace + ?Sized,

Serializes an iterator of key-value pairs as an index map.

Safety

• The keys returned by the iterator must be unique
• The index function must return the index of the given key within the iterator

Trait Implementations

impl<K, V, C> CheckBytes<C> for ArchivedIndexMap<K, V>

where K: CheckBytes<C> + Eq + Hash, V: CheckBytes<C>, C: ArchiveContext + ?Sized, C::Error: Error,

type Error = IndexMapError<<K as CheckBytes<C>>::Error, <V as CheckBytes<C>>::Error, <C as Fallible>::Error>

The error that may result from checking the type.

unsafe fn check_bytes<'a>( value: *const Self, context: &mut C, ) -> Result<&'a Self, Self::Error>

Checks whether the given pointer points to a valid value within the given context.

impl<K: Debug, V: Debug> Debug for ArchivedIndexMap<K, V>

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

Formats the value using the given formatter.

impl<K, V, D, S> Deserialize<IndexMap<K, V, S>, D> for ArchivedIndexMap<K::Archived, V::Archived>

where K: Archive + Hash + Eq, K::Archived: Deserialize<K, D>, V: Archive, V::Archived: Deserialize<V, D>, D: Fallible + ?Sized, S: Default + BuildHasher,

fn deserialize( &self, deserializer: &mut D, ) -> Result<IndexMap<K, V, S>, D::Error>

Deserializes using the given deserializer

impl<UK, K, UV, V, S> PartialEq<IndexMap<UK, UV, S>> for ArchivedIndexMap<K, V>

where K: PartialEq<UK>, V: PartialEq<UV>, S: BuildHasher,

fn eq(&self, other: &IndexMap<UK, UV, S>) -> bool

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<K: PartialEq, V: PartialEq> PartialEq for ArchivedIndexMap<K, V>

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

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.