Struct Map 

pub struct Map<K, V> { /* private fields */ }

Simple CRDT Map

This types defines a CRDT for a map from keys to values. Values are CRDT types which can have their own updating logic.

Internally, the map is stored as a vector of keys and values, sorted by ascending key order. This is why the key type K must implement Ord (and also to ensure a unique serialization, such that two values can be compared for equality based on their hashes). As a consequence, insertions take O(n) time. This means that Map should be used for reasonably small maps. However, note that even if we were using a more efficient data structure such as a BTreeMap, the serialization cost O(n) would still have to be paid at each modification, so we are actually not losing anything here.

Implementations

impl<K, V> Map<K, V>

where K: Clone + Ord, V: Clone + Crdt,

pub fn new() -> Map<K, V>

Create a new empty map CRDT

pub fn put_mutator(k: K, v: V) -> Map<K, V>

Returns a map that contains a single mapping from the specified key to the specified value. This can be used to build a delta-mutator: when merged with another map, the value will be added or CRDT-merged if a previous value already exists.

pub fn put(&mut self, k: K, v: V)

Add a value to the map

pub fn clear(&mut self)

Removes all values from the map

pub fn get(&self, k: &K) -> Option<&V>

Get a reference to the value assigned to a key

pub fn items(&self) -> &[(K, V)]

Gets a reference to all of the items, as a slice. Useful to iterate on all map values.

pub fn len(&self) -> usize

Returns the number of items in the map

pub fn is_empty(&self) -> bool

Returns true if the map is empty

Trait Implementations

impl<K, V> Clone for Map<K, V>

where K: Clone, V: Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K, V> Crdt for Map<K, V>

where K: Clone + Ord, V: Clone + Crdt,

fn merge(&mut self, other: &Map<K, V>)

Merge the two datastructures according to the CRDT rules. self is modified to contain the merged CRDT value. other is not modified.

impl<K, V> Debug for Map<K, V>

where K: Debug, V: Debug,

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

Formats the value using the given formatter.

impl<K, V> Default for Map<K, V>

where K: Clone + Ord, V: Clone + Crdt,

fn default() -> Map<K, V>

Returns the “default value” for a type.

impl<'de, K, V> Deserialize<'de> for Map<K, V>

where K: 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> FromIterator<(K, V)> for Map<K, V>

where K: Clone + Ord, V: Clone + Crdt,

A crdt map can be created from an iterator of key-value pairs. Note that all keys in the iterator must be distinct: this function will throw a panic if it is not the case.

fn from_iter<T>(iter: T) -> Map<K, V>

where T: IntoIterator<Item = (K, V)>,

Creates a value from an iterator.

impl<K, V> PartialEq for Map<K, V>

where K: PartialEq, V: PartialEq,

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

where K: 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<K, V> Eq for Map<K, V>

where K: Eq, V: Eq,

impl<K, V> StructuralPartialEq for Map<K, V>