Struct Map 

pub struct Map<K, V, Tag, CL>
where
    K: Key + Ord,
    V: Value + Hash + Eq + Ord,
    Tag: TagT,
    CL: CausalLength,
{ /* private fields */ }

Causal Length Map

A CRDT map based on an adaptation of the causal length set.

Map uses the tag for garbage collection of old removed members, and to resolve conflicting values for the same key and causal length.

Implementations

impl<K, V, Tag, CL> Map<K, V, Tag, CL>

where K: Key + Ord, V: Value + Hash + Eq + Ord, Tag: TagT, CL: CausalLength,

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

Create an empty Map

pub fn get<Q>(&self, key: Q) -> Option<(&V, Tag)>

where Q: Borrow<K>,

Returns a reference to the value and tag corresponding to the key.

pub fn contains<Q>(&self, key: Q) -> bool

where Q: Borrow<K>,

Returns true if the map contains a value for the specified key.

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

Inserts a key, value, and tag 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, along with the old tag.

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

Remove a key from the map, returning the stored value and tag if the key was in the map.

pub fn iter(&self) -> impl Iterator<Item = (K, V, Tag)> + '_

An iterator visiting all key, value, tag tuples in arbitrary order.

pub fn register_iter( &self, ) -> impl Iterator<Item = Register<(K, V), Tag, CL>> + '_

An iterator visiting all delta registers in arbitrary order.

pub fn merge_register(&mut self, delta: Register<(K, V), Tag, CL>, min_tag: Tag)

Merge a delta Register into a map.

Remove deltas with a tag value less than min_tag will be ignored.

pub fn merge(&mut self, other: &Self, min_tag: Tag)

Merge two maps.

Remove deltas with a tag value less than min_tag will be ignored.

pub fn retain(&mut self, min_tag: Tag)

Filter out old remove tombstone deltas from the map.

Remove deltas with a tag value less than min_tag will be removed.

Trait Implementations

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

where K: Key + Ord + Clone, V: Value + Hash + Eq + Ord + Clone, Tag: TagT + Clone, CL: CausalLength + Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

where K: Key + Ord + Debug, V: Value + Hash + Eq + Ord + Debug, Tag: TagT + Debug, CL: CausalLength + Debug,

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

Formats the value using the given formatter.

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

where K: Key + Ord + Default, V: Value + Hash + Eq + Ord + Default, Tag: TagT + Default, CL: CausalLength + Default,

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

Returns the “default value” for a type.

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

where K: Key + Ord + Deserialize<'de>, V: Value + Hash + Ord + Deserialize<'de>, Tag: TagT + Deserialize<'de>, CL: CausalLength + Deserialize<'de>,

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<K, V, Tag, CL> From<Map<K, V, Tag, CL>> for HashMap<K, (V, Tag)>

where K: Key + Ord, V: Value + Hash + Eq + Ord, Tag: TagT, CL: CausalLength,

fn from(m: Map<K, V, Tag, CL>) -> Self

Converts to this type from the input type.

impl<K, V, Tag, CL> From<Map<K, V, Tag, CL>> for Set<(K, V), Tag, CL>

where K: Key + Ord, V: Value + Hash + Eq + Ord, Tag: TagT, CL: CausalLength,

fn from(m: Map<K, V, Tag, CL>) -> Self

Converts to this type from the input type.

impl<K, V, Tag, CL> From<Set<(K, V), Tag, CL>> for Map<K, V, Tag, CL>

where K: Key + Ord, V: Value + Hash + Eq + Ord, Tag: TagT, CL: CausalLength,

fn from(s: Set<(K, V), Tag, CL>) -> Self

Converts to this type from the input type.

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

where K: Key + Ord + PartialEq, V: Value + Hash + Eq + Ord + PartialEq, Tag: TagT + PartialEq, CL: CausalLength + PartialEq,

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

where K: Key + Ord + Serialize, V: Value + Hash + Ord + Serialize, Tag: TagT + Serialize, CL: CausalLength + Serialize,

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<K, V, Tag, CL> Eq for Map<K, V, Tag, CL>

where K: Key + Ord + Eq, V: Value + Hash + Eq + Ord + Eq, Tag: TagT + Eq, CL: CausalLength + Eq,

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

where K: Key + Ord, V: Value + Hash + Eq + Ord, Tag: TagT, CL: CausalLength,