Struct bones_schema::alloc::SMap

pub struct SMap<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: HasSchema, V: HasSchema> SMap<K, V>

pub fn new() -> Self

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.

pub fn contains_key(&self, key: &K) -> bool

Returns true if the map contains a value for the specified key.

pub fn len(&self) -> usize

Returns the number of elements in the map.

pub fn is_empty(&self) -> bool

Returns true if the map contains no elements.

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

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: HasSchema, V: HasSchema> Clone for SMap<K, V>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

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

fn default() -> Self

Returns the “default value” for a type.

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

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

Creates a value from an iterator.

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

fn schema() -> &'static Schema

Get this type’s Schema.

fn register_schema()

Register this schema with the global schema registry.

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

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

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

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

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

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

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

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: HasSchema, V: HasSchema> Index<&K> for SMap<K, V>

type Output = V

The returned type after indexing.

fn index(&self, index: &K) -> &Self::Output

Performs the indexing (container[index]) operation.

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

fn index_mut(&mut self, index: &K) -> &mut Self::Output

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

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

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

Creates an iterator from a value.

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

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

Creates an iterator from a value.