Struct Map

pub struct Map<K, V>
where
    K: TypedIndex,
{ /* private fields */ }

Dense item map

Implementations

impl<K, V> Map<K, V>

where K: TypedIndex,

pub fn new() -> Self

Creates a new Map.

pub fn with_capacity(capacity: usize) -> Self

Creates a new empty Map with the given capacity.

pub fn clear(&mut self)

Clears the map. Keeps the allocated memory for future use.

pub fn len(&self) -> usize

Returns the size of this map.

pub fn is_empty(&self) -> bool

Returns true if this map is empty.

pub fn push(&mut self, value: V) -> K

Adds a new value to this map.

pub fn next_index(&self) -> K

Returns the next index into the map.

pub fn reserve_exact(&mut self, size: usize)

Reserves the given size.

pub fn into_boxed_map(self) -> BoxedMap<K, V>

Convert this into a BoxedMap.

pub fn into_vec(self) -> Vec<V>

Convert this into a Vec.

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

Iterate over the values of the map in order.

impl<K, V> Map<K, V>

where K: TypedIndex, V: Clone,

pub fn resize(&mut self, new_len: usize, value: V)

Resize this map to the given new length and value.

Methods from Deref<Target = SliceMap<K, V>>

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

Gets a reference to the value at the given index.

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

Gets a mutable reference to the value at the given index.

pub fn len(&self) -> usize

Gets the length of this slice map.

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

Returns an iterator for this slice map.

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

Returns a mutable iterator for this slice map.

pub fn as_ptr(&self) -> *const V

Gets a pointer to the SliceMap.

pub fn as_mut_ptr(&mut self) -> *mut V

Gets a mutable pointer to the SliceMap.

Trait Implementations

impl<K, V> BorshDeserialize for Map<K, V>

where K: TypedIndex, Vec<V>: BorshDeserialize,

fn deserialize(buf: &mut &[u8]) -> Result<Self, Error>

Deserializes this instance from a given slice of bytes. Updates the buffer to point at the remaining bytes.

fn try_from_slice(v: &[u8]) -> Result<Self, Error>

Deserialize this instance from a slice of bytes.

impl<K, V> BorshSerialize for Map<K, V>

where K: TypedIndex, Vec<V>: BorshSerialize,

fn serialize<W: Write>(&self, writer: &mut W) -> Result<(), Error>

fn try_to_vec(&self) -> Result<Vec<u8>, Error>

Serialize this instance into a vector of bytes.

impl<K, V: Clone> Clone for Map<K, V>

where K: TypedIndex + Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

where K: TypedIndex + Debug,

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

Formats the value using the given formatter.

impl<K, V> DerefMut for Map<K, V>

where K: TypedIndex,

fn deref_mut(&mut self) -> &mut SliceMap<K, V>

Mutably dereferences the value.

impl<'de, K, V> Deserialize<'de> for Map<K, V>

where K: TypedIndex, 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, V> Extend<V> for Map<K, V>

where K: TypedIndex,

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

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<K, V> FromIterator<V> for Map<K, V>

where K: TypedIndex,

fn from_iter<I: IntoIterator<Item = V>>(iter: I) -> Self

Creates a value from an iterator.

impl<'a, K, V> IntoIterator for &'a Map<K, V>

where K: TypedIndex,

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) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, K, V> IntoIterator for &'a mut Map<K, V>

where K: TypedIndex,

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) -> Self::IntoIter

Creates an iterator from a value.

impl<K, V> IntoIterator for Map<K, V>

where K: TypedIndex,

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> Serialize for Map<K, V>

where K: TypedIndex, V: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<K, V> Deref for Map<K, V>

where K: TypedIndex,

type Target = SliceMap<K, V>

The resulting type after dereferencing.

fn deref(&self) -> &SliceMap<K, V>

Dereferences the value.