Struct MetadataMap 

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

A typed metadata map

Type Parameters

• T: The type of values stored in the metadata map.

Implementations

impl<T> MetadataMap<T>

pub fn new() -> MetadataMap<T>

Creates a new empty MetadataMap.

pub fn len(&self) -> usize

Returns the number of elements in the map.

pub fn is_empty(&self) -> bool

Returns true if the map is empty.

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

where K: Into<Cow<'static, str>>, V: Into<T>,

Inserts a key-value pair into the map.

If the map did not have this key present, None is returned.

If the map did have this key present, the value is updated, and the old value is returned. The key is not updated, though; it is retained as is (verbatim).

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

where K: AsRef<str>,

Gets a reference to the value associated with the given key.

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

where K: AsRef<str>,

Gets a mutable reference to the value associated with the given key.

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

where K: AsRef<str>,

Removes a key from the map, returning the value at the key if the key was previously in the map.

pub fn clear(&mut self)

Clears the map, removing all key-value pairs. Keeps the allocated memory for reuse.

pub fn iter(&self) -> Iter<'_, Cow<'static, str>, T>

Returns an iterator over the map’s entries.

pub fn iter_mut(&mut self) -> IterMut<'_, Cow<'static, str>, T>

Returns a mutable iterator over the map’s entries.

pub fn entry<K>(&mut self, key: K) -> Entry<'_, Cow<'static, str>, T>

where K: Into<Cow<'static, str>>,

Provides a view into a single entry in the map, which may or may not be present.

pub fn extend(&mut self, other: MetadataMap<T>)

Extends the map with the key-value pairs from the given map.

Trait Implementations

impl<T> Clone for MetadataMap<T>

where T: Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for MetadataMap<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Default for MetadataMap<T>

where T: Default,

fn default() -> MetadataMap<T>

Returns the “default value” for a type.

impl<Ctx> FromJobCallParts<Ctx> for MetadataMap<MetadataValue>

where Ctx: Send + Sync,

type Rejection = Infallible

If the extractor fails it’ll use this “rejection” type. A rejection is a kind of error that can be converted into a job result.

async fn from_job_call_parts( parts: &mut Parts, _: &Ctx, ) -> Result<MetadataMap<MetadataValue>, <MetadataMap<MetadataValue> as FromJobCallParts<Ctx>>::Rejection>

Perform the extraction.

impl IntoJobResult for MetadataMap<MetadataValue>

fn into_job_result(self) -> Option<JobResult>

Create a JobResult.

impl IntoJobResultParts for MetadataMap<MetadataValue>

type Error = Box<dyn Error + Send + Sync>

The type returned in the event of an error.

fn into_job_result_parts( self, res: JobResultParts, ) -> Result<JobResultParts, <MetadataMap<MetadataValue> as IntoJobResultParts>::Error>

Set parts of the response

impl<T> PartialEq for MetadataMap<T>

where T: PartialEq,

fn eq(&self, other: &MetadataMap<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> StructuralPartialEq for MetadataMap<T>