Struct amadeus::prelude::data::Map

pub struct Map<K, V>(_)
 where
    K: Eq + Hash;

Map<K, V> corresponds to the Map logical type.

Methods

impl<K, V> Map<K, V> where
    K: Hash + Eq, 

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn get<Q>(&self, k: &Q) -> Option<&V> where
    K: Borrow<Q>,
    Q: Hash + Eq + ?Sized, 

Returns a reference to the value corresponding to the key.

pub fn iter(&self) -> Iter<K, V>

Returns an iterator over the (ref key, ref value) pairs of the Map.

Trait Implementations

impl<K, V> PostgresData for Map<K, V> where
    K: Hash + Eq + PostgresData,
    V: PostgresData, 

fn query(_f: &mut Formatter, _name: Option<&Names>) -> Result<(), Error>

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Map<K, V>, Box<dyn Error + 'static + Send + Sync>>

impl<K, V> IntoIterator for Map<K, V> where
    K: Hash + Eq, 

type Item = (K, V)

The type of the elements being iterated over.

type IntoIter = IntoIter<K, V>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <Map<K, V> as IntoIterator>::IntoIter

Creates an iterator over the (key, value) pairs of the Map.

impl<K, V> Clone for Map<K, V> where
    K: Eq + Clone + Hash,
    V: Clone, 

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<K, V> Eq for Map<K, V> where
    K: Eq + Hash,
    V: Eq, 

impl<K, V, V1> PartialOrd<Map<K, V1>> for Map<K, V> where
    K: Eq + Hash,
    V: PartialOrd<V1>, 

fn partial_cmp(&self, other: &Map<K, V1>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<K, V> Serialize for Map<K, V> where
    K: Eq + Hash + Serialize,
    V: Serialize, 

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl DowncastImpl<Value> for Map<Value, Value>

fn downcast_impl(self_: Value) -> Result<Map<Value, Value>, DowncastError>

impl<K, V> DowncastImpl<Value> for Map<K, V> where
    K: DowncastImpl<Value> + Hash + Eq,
    V: DowncastImpl<Value>, 

default fn downcast_impl(self_: Value) -> Result<Map<K, V>, DowncastError>

impl From<Map<Value, Value>> for Value

fn from(value: Map<Value, Value>) -> Value

Performs the conversion.

impl<K, V> From<Map<K, V>> for Value where
    K: Into<Value> + Hash + Eq,
    V: Into<Value>, 

default fn from(value: Map<K, V>) -> Value

Performs the conversion.

impl<K, V> From<HashMap<K, V, RandomState>> for Map<K, V> where
    K: Hash + Eq, 

fn from(hashmap: HashMap<K, V, RandomState>) -> Map<K, V>

Performs the conversion.

impl<K, V> Debug for Map<K, V> where
    K: Hash + Eq + Debug,
    V: Debug, 

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

Formats the value using the given formatter.

impl<K, V> Into<HashMap<K, V, RandomState>> for Map<K, V> where
    K: Hash + Eq, 

fn into(self) -> HashMap<K, V, RandomState>

Performs the conversion.

impl<'de, K, V> Deserialize<'de> for Map<K, V> where
    K: Eq + Hash + Deserialize<'de>,
    V: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<Map<K, V>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<K, V> PartialEq<Map<K, V>> for Value where
    K: Hash + Eq + Clone + Into<Value>,
    Value: PartialEq<K>,
    Value: PartialEq<V>, 

fn eq(&self, other: &Map<K, V>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl<K, V, V1> PartialEq<Map<K, V1>> for Map<K, V> where
    K: Eq + Hash,
    V: PartialEq<V1>, 

fn eq(&self, other: &Map<K, V1>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl<K, V> SerdeData for Map<K, V> where
    K: Hash + Eq + SerdeData,
    V: SerdeData, 

fn serialize<S>(
    &self,
    _serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 

fn deserialize<'de, D>(
    _deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Map<K, V>, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl<K, V> Data for Map<K, V> where
    K: Hash + Eq + Data,
    V: Data, 

fn cast<D: Data>(self) -> Result<D, CastError>

fn eq<D: Data>(self, other: D) -> bool

fn partial_cmp<D: Data>(self, other: D) -> Option<Ordering>

fn hash<H: Hasher>(self, state: &mut H)