Struct bones_asset::SMap

pub struct SMap<K, V>where
    K: HasSchema,
    V: HasSchema,{ /* private fields */ }

Typed version of a SchemaMap.

This works essentially like a HashMap, but is compatible with the schema ecosystem.

It is also slightly more efficient to access an SMap compared to a SchemaMap because it doesn’t need to do a runtime schema check every time the map is accessed.

Implementations

impl<K, V> SMap<K, V>where K: HasSchema, V: HasSchema,

pub fn new() -> SMap<K, V>

Initialize the SMap.

pub fn insert(&mut self, k: K, v: V) -> Option<V>

Insert an entry into the map, returning the previous value, if it exists.

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

Get a reference to an item in the map.

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

Get a mutable reference to an item in the map.

pub fn remove(&mut self, key: &K) -> Option<V>

Remove an item from the map.

pub fn into_schema_map(self) -> SchemaMap

Convert into an untyped SchemaMap.

impl<K, V> SMap<K, V>where K: HasSchema, V: HasSchema,

pub fn iter( &self ) -> Map<Iter<'_, SchemaBox, SchemaBox>, for<'a> fn(_: (&'a SchemaBox, &'a SchemaBox)) -> (&'a K, &'a V)>

Iterate over entries in the map.

pub fn iter_mut( &mut self ) -> Map<IterMut<'_, SchemaBox, SchemaBox>, for<'a> fn(_: (&'a SchemaBox, &'a mut SchemaBox)) -> (&'a K, &'a mut V)>

Iterate over entries in the map.

pub fn keys( &self ) -> Map<Keys<'_, SchemaBox, SchemaBox>, for<'a> fn(_: &'a SchemaBox) -> &'a K>

Iterate over keys in the map.

pub fn values( &self ) -> Map<Values<'_, SchemaBox, SchemaBox>, for<'a> fn(_: &'a SchemaBox) -> &'a V>

Iterate over values in the map.

pub fn values_mut( &mut self ) -> Map<ValuesMut<'_, SchemaBox, SchemaBox>, for<'a> fn(_: &'a mut SchemaBox) -> &'a mut V>

Iterate over values in the map.

Trait Implementations

impl<K, V> Clone for SMap<K, V>where K: HasSchema, V: HasSchema,

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<K, V> Debug for SMap<K, V>where K: HasSchema + Debug, V: HasSchema + Debug,

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

Formats the value using the given formatter.

impl<K, V> Default for SMap<K, V>where K: HasSchema, V: HasSchema,

fn default() -> SMap<K, V>

Returns the “default value” for a type.

impl<K, V> FromIterator<(K, V)> for SMap<K, V>where K: HasSchema, V: HasSchema,

fn from_iter<T>(iter: T) -> SMap<K, V>where T: IntoIterator<Item = (K, V)>,

Creates a value from an iterator.

impl<K, V> HasSchema for SMap<K, V>where K: HasSchema, V: HasSchema,

fn schema() -> &'static Schema

Get this type’s [Schema].

fn register_schema()

Register this schema with the global schema registry.

fn cast<T>(this: &Self) -> &Twhere T: HasSchema,

Cast a reference of this type to a reference of another type with the same memory layout.

fn try_cast<T>(this: &Self) -> Result<&T, SchemaMismatchError>where T: HasSchema,

Cast a reference of this type to a reference of another type with the same memory layout.

fn cast_mut<T>(this: &mut Self) -> &mut Twhere T: HasSchema,

Cast a mutable reference of this type to a reference of another type with the same memory layout.

fn try_cast_mut<T>(this: &mut Self) -> Result<&mut T, SchemaMismatchError>where T: HasSchema,

Cast a mutable reference of this type to a reference of another type with the same memory layout.

fn as_schema_ref(&self) -> SchemaRef<'_>where Self: Sized,

Converts a reference of T to a SchemaRef

fn as_schema_mut(&mut self) -> SchemaRefMut<'_>where Self: Sized,

Converts a reference of T to a SchemaRefMut

impl<K, V> Index<&K> for SMap<K, V>where K: HasSchema, V: HasSchema,

type Output = V

The returned type after indexing.

fn index(&self, index: &K) -> &<SMap<K, V> as Index<&K>>::Output

Performs the indexing (container[index]) operation.

impl<K, V> IndexMut<&K> for SMap<K, V>where K: HasSchema, V: HasSchema,

fn index_mut(&mut self, index: &K) -> &mut <SMap<K, V> as Index<&K>>::Output

Performs the mutable indexing (container[index]) operation.

impl<'a, K, V> IntoIterator for &'a SMap<K, V>where K: HasSchema, V: HasSchema,

type Item = (&'a K, &'a V)

The type of the elements being iterated over.

type IntoIter = Map<Iter<'a, SchemaBox, SchemaBox>, for<'a> fn(_: (&'a SchemaBox, &'a SchemaBox)) -> (&'a K, &'a V)>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <&'a SMap<K, V> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, K, V> IntoIterator for &'a mut SMap<K, V>where K: HasSchema, V: HasSchema,

type Item = (&'a K, &'a mut V)

The type of the elements being iterated over.

type IntoIter = Map<IterMut<'a, SchemaBox, SchemaBox>, for<'a> fn(_: (&'a SchemaBox, &'a mut SchemaBox)) -> (&'a K, &'a mut V)>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <&'a mut SMap<K, V> as IntoIterator>::IntoIter

Creates an iterator from a value.