[][src]Struct parity_wasm::elements::IndexMap

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

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.

Methods

impl<T> IndexMap<T>[src]

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

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

pub fn clear(&mut self)[src]

Clear the map.

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

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

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

Does the map contain an entry for the specified index?

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

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>[src]

Remove an item if present and return it.

pub fn len(&self) -> usize[src]

The number of items in this map.

pub fn is_empty(&self) -> bool[src]

Is this map empty?

pub fn iter(&self) -> Iter<T>[src]

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>, 
[src]

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: Deserialize> IndexMap<T> where
    T: Deserialize,
    Error: From<<T as Deserialize>::Error>, 
[src]

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

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> Serialize for IndexMap<T> where
    T: Serialize,
    Error: From<<T as Serialize>::Error>, 
[src]

type Error = Error

Serialization error produced by serialization routine.

impl<T: PartialEq> PartialEq<IndexMap<T>> for IndexMap<T>[src]

#[must_use]
fn ne(&self, other: &Rhs) -> bool
1.0.0
[src]

This method tests for !=.

impl<T: Eq> Eq for IndexMap<T>[src]

impl<T: Clone> Clone for IndexMap<T>[src]

fn clone_from(&mut self, source: &Self)
1.0.0
[src]

Performs copy-assignment from source. Read more

impl<T: Default> Default for IndexMap<T>[src]

impl<T> IntoIterator for IndexMap<T>[src]

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?

impl<'a, T: 'static> IntoIterator for &'a IndexMap<T>[src]

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?

impl<T: Debug> Debug for IndexMap<T>[src]

impl<T> FromIterator<(u32, T)> for IndexMap<T>[src]

fn from_iter<I>(iter: I) -> Self where
    I: IntoIterator<Item = (u32, T)>, 
[src]

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.

Auto Trait Implementations

impl<T> Send for IndexMap<T> where
    T: Send

impl<T> Sync for IndexMap<T> where
    T: Sync

Blanket Implementations

impl<T, U> Into for T where
    U: From<T>, 
[src]

impl<T> ToOwned for T where
    T: Clone
[src]

type Owned = T

impl<T> From for T[src]

impl<I> IntoIterator for I where
    I: Iterator
[src]

type Item = <I as Iterator>::Item

The type of the elements being iterated over.

type IntoIter = I

Which kind of iterator are we turning this into?

impl<T, U> TryFrom for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T> Borrow for T where
    T: ?Sized
[src]

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T> BorrowMut for T where
    T: ?Sized
[src]

impl<T, U> TryInto for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.