Struct Map 

pub struct Map<TKey, TValue>
where
    TKey: Eq + Hash + Clone + PartialEq,
    TValue: Clone + PartialEq,
{
    pub entries: Vec<(TKey, TValue)>,
}

Represents an ordered key/value map array.

Internally uses Vec<(K, V)> for efficient storage, but serializes to/from the Serverless Workflow DSL format: [{"key1": "value1"}, {"key2": "value2"}].

Fields

entries: Vec<(TKey, TValue)>

The ordered entries as (key, value) pairs

Implementations

impl<TKey, TValue> Map<TKey, TValue>

where TKey: Eq + Hash + Clone + PartialEq, TValue: Clone + PartialEq,

pub fn new() -> Self

Initializes a new map

pub fn from(entries: Vec<(TKey, TValue)>) -> Self

Initializes a new map with the provided entries

pub fn add(&mut self, key: TKey, value: TValue)

Adds the specified entry

pub fn len(&self) -> usize

Gets the number of entries in the map

pub fn is_empty(&self) -> bool

Checks if the map is empty

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

Checks if the map contains an entry with the specified key

pub fn get(&self, key: &TKey) -> Option<&TValue>

Gets a reference to the value associated with the specified key

Trait Implementations

impl<TKey, TValue> Clone for Map<TKey, TValue>

where TKey: Eq + Hash + Clone + PartialEq + Clone, TValue: Clone + PartialEq + Clone,

fn clone(&self) -> Map<TKey, TValue>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<TKey, TValue> Debug for Map<TKey, TValue>

where TKey: Eq + Hash + Clone + PartialEq + Debug, TValue: Clone + PartialEq + Debug,

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

Formats the value using the given formatter.

impl<TKey, TValue> Default for Map<TKey, TValue>

where TKey: Eq + Hash + Clone + PartialEq, TValue: Clone + PartialEq,

fn default() -> Self

Returns the “default value” for a type.

impl<'de, TKey, TValue> Deserialize<'de> for Map<TKey, TValue>

where TKey: Eq + Hash + Clone + Deserialize<'de> + PartialEq, TValue: Clone + Deserialize<'de> + PartialEq,

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl<TKey, TValue> PartialEq for Map<TKey, TValue>

where TKey: Eq + Hash + Clone + PartialEq + PartialEq, TValue: Clone + PartialEq + PartialEq,

fn eq(&self, other: &Map<TKey, TValue>) -> 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<TKey, TValue> Serialize for Map<TKey, TValue>

where TKey: Eq + Hash + Clone + Serialize + PartialEq, TValue: Clone + Serialize + PartialEq,

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

Serialize this value into the given Serde serializer.

impl<TKey, TValue> Eq for Map<TKey, TValue>

where TKey: Eq + Hash + Clone + PartialEq + Eq, TValue: Clone + PartialEq + Eq,

impl<TKey, TValue> StructuralPartialEq for Map<TKey, TValue>

where TKey: Eq + Hash + Clone + PartialEq, TValue: Clone + PartialEq,