Struct IndexMap

pub struct IndexMap<T> { /* private fields */ }

A map from non-contiguous u32 keys to values of type T, which is serialized and deserialized ascending order of the keys. Normally used for relative dense maps with occasional “holes”, and stored as an array.

Implementations

impl<T> IndexMap<T>

pub fn new() -> IndexMap<T>

Create an empty IndexMap.

pub fn with_capacity(_capacity: usize) -> IndexMap<T>

👎Deprecated

Create an empty IndexMap, preallocating enough space to store capacity entries without needing to reallocate the underlying memory.

Note

Currently, this method has no effect and is equivalent to IndexMap::new call.

pub fn clear(&mut self)

Clear the map.

pub fn get(&self, idx: u32) -> Option<&T>

Return the name for the specified index, if it exists.

pub fn contains_key(&self, idx: u32) -> bool

Does the map contain an entry for the specified index?

pub fn insert(&mut self, idx: u32, value: T) -> Option<T>

Insert a name into our map, returning the existing value if present.

pub fn remove(&mut self, idx: u32) -> Option<T>

Remove an item if present and return it.

pub fn len(&self) -> usize

The number of items in this map.

pub fn is_empty(&self) -> bool

Is this map empty?

pub fn iter(&self) -> impl Iterator<Item = (u32, &T)>

Create a non-consuming iterator over this IndexMap’s keys and values.

pub fn deserialize_with<R, F>( max_entry_space: usize, deserialize_value: &F, rdr: &mut R, ) -> Result<IndexMap<T>, Error>

where R: Read, F: Fn(u32, &mut R) -> Result<T, Error>,

Custom deserialization routine.

We will allocate an underlying array no larger than max_entry_space to hold the data, so the maximum index must be less than max_entry_space. This prevents mallicious *.wasm files from having a single entry with the index u32::MAX, which would consume far too much memory.

The deserialize_value function will be passed the index of the value being deserialized, and must deserialize the value.

impl<T> IndexMap<T>

where T: Deserialize, Error: From<<T as Deserialize>::Error>,

pub fn deserialize<R: Read>( max_entry_space: usize, rdr: &mut R, ) -> Result<Self, Error>

Deserialize a map containing simple values that support Deserialize. We will allocate an underlying array no larger than max_entry_space to hold the data, so the maximum index must be less than max_entry_space.

Trait Implementations

impl<T: Clone> Clone for IndexMap<T>

fn clone(&self) -> IndexMap<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for IndexMap<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for IndexMap<T>

fn default() -> IndexMap<T>

Returns the “default value” for a type.

impl<T> FromIterator<(u32, T)> for IndexMap<T>

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

where I: IntoIterator<Item = (u32, T)>,

Create an IndexMap from an iterator.

Note: This API is designed for reasonably dense indices based on valid data. Inserting a huge idx will use up a lot of RAM, and this function will not try to protect you against that.

impl<T> IntoIterator for IndexMap<T>

type Item = (u32, T)

The type of the elements being iterated over.

type IntoIter = <BTreeMap<u32, T> as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T: PartialEq> PartialEq for IndexMap<T>

fn eq(&self, other: &IndexMap<T>) -> 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<T> Serialize for IndexMap<T>

where T: Serialize, Error: From<<T as Serialize>::Error>,

type Error = Error

Serialization error produced by serialization routine.

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

Serialize type to serial i/o

impl<T: Eq> Eq for IndexMap<T>