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.

SECURITY WARNING: This code is currently subject to a denial of service attack if you create a map containing the key u32::MAX, which should never happen in normal data. It would be pretty easy to provide a safe deserializing mechanism which addressed this problem.

Implementations

impl<T> IndexMap<T>

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

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

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.

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.

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) -> Iter<'_, 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<'a, T: 'static> IntoIterator for &'a IndexMap<T>

type Item = (u32, &'a T)

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<T> IntoIterator for IndexMap<T>

type Item = (u32, T)

The type of the elements being iterated over.

type IntoIter = IntoIter<T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IntoIter<T>

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>