Struct MapContext 

pub struct MapContext<E: Entry, C: Converter> { /* private fields */ }

The common implementation of all map-like contexts.

Implementations

impl<E: Entry, C: Converter> MapContext<E, C>

pub fn new() -> Self

Creates a new MapContext.

Trait Implementations

impl<E: Entry, C: Converter> AbstractContext for MapContext<E, C>

type Key = <E as Entry>::Key

The key of each entry.

type Value = <E as Entry>::Value

The value of each entry.

type Entry = E

The entry stored in this context.

type Iter<'a> = CommonIter<'a, E, Iter<'a, E>> where E: 'a

The iterator over this context’s entries.

fn iter(&self) -> Self::Iter<'_>

Returns the context’s iterator.

impl<E: Entry, C: Converter> Context for MapContext<E, C>

type Converter = C

The default converter used by the context, which transforms values to AbstractContext::Value before insertions.

fn insert<Q, R>(&mut self, key: Q, value: R)

where Q: Into<Self::Key>, R: Into<Self::Value>,

Inserts the context information represented as a key-value pair. Any types that are compatible with AbstractContext::Key and AbstractContext::Value through the Into trait respectively are expected.

fn get<Q>(&self, key: &Q) -> Option<&<Self::Entry as Entry>::ValueBorrowed>

where <Self::Entry as Entry>::KeyBorrowed: Borrow<Q>, Q: Debug + Eq + Hash + ?Sized,

Returns the value corresponding to the given key.

fn insert_with<C, Q, R>(&mut self, key: Q, value: R)

where Q: Into<Self::Key>, C: Converter, R: Convertable<C, Self::Value>,

Converts the context information represented as a key-value pair using the specified converter C and then inserts the converted pair. Any types that are compatible with AbstractContext::Key and AbstractContext::Value through the Into and Convertable trait respectively are expected.

impl<E: Debug + Entry, C: Debug + Converter> Debug for MapContext<E, C>

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

Formats the value using the given formatter.

impl<E: Entry, C: Converter> Default for MapContext<E, C>

fn default() -> Self

Returns the “default value” for a type.

impl<E: Eq + Entry, C: Eq + Converter> Eq for MapContext<E, C>

impl<E: Entry, C: Converter, Q, R> From<Vec<(Q, R)>> for MapContext<E, C>

where Q: Into<<Self as AbstractContext>::Key>, R: Into<<Self as AbstractContext>::Value>,

fn from(entries: Vec<(Q, R)>) -> Self

Converts to this type from the input type.

impl<E: Entry, C: Converter> From<Vec<E>> for MapContext<E, C>

fn from(entries: Vec<E>) -> Self

Converts to this type from the input type.

impl<E: Entry, C: Converter, Q, R> FromIterator<(Q, R)> for MapContext<E, C>

where Q: Into<<Self as AbstractContext>::Key>, R: Into<<Self as AbstractContext>::Value>,

fn from_iter<T: IntoIterator<Item = (Q, R)>>(iter: T) -> Self

Creates a value from an iterator.

impl<E: Entry, C: Converter> FromIterator<E> for MapContext<E, C>

fn from_iter<T: IntoIterator<Item = E>>(iter: T) -> Self

Creates a value from an iterator.

impl<E: PartialEq + Entry, C: PartialEq + Converter> PartialEq for MapContext<E, C>

fn eq(&self, other: &MapContext<E, C>) -> 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<E: PartialEq + Entry, C: PartialEq + Converter> StructuralPartialEq for MapContext<E, C>