Struct causal_length::map::Map

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

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: Clone, V: Clone, Tag: Clone, CL: Clone> Clone for Map<K, V, Tag, CL> where
    K: Key + Ord,
    V: Value + Hash + Eq + Ord,
    Tag: TagT,
    CL: CausalLength, 

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<K: Debug, V: Debug, Tag: Debug, CL: Debug> Debug for Map<K, V, Tag, CL> where
    K: Key + Ord,
    V: Value + Hash + Eq + Ord,
    Tag: TagT,
    CL: CausalLength, 

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

Formats the value using the given formatter.

impl<K: Default, V: Default, Tag: Default, CL: Default> Default for Map<K, V, Tag, CL> where
    K: Key + Ord,
    V: Value + Hash + Eq + Ord,
    Tag: TagT,
    CL: CausalLength, 

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: Eq, V: Eq, Tag: Eq, CL: Eq> Eq for Map<K, V, Tag, CL> where
    K: Key + Ord,
    V: Value + Hash + Eq + Ord,
    Tag: TagT,
    CL: CausalLength, 

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

Performs the conversion.

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

Performs the conversion.

impl<K: PartialEq, V: PartialEq, Tag: PartialEq, CL: PartialEq> PartialEq<Map<K, V, Tag, CL>> for Map<K, V, Tag, CL> where
    K: Key + Ord,
    V: Value + Hash + Eq + Ord,
    Tag: TagT,
    CL: CausalLength, 

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

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

fn ne(&self, other: &Map<K, V, Tag, CL>) -> bool

This method tests for !=.

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> StructuralEq for Map<K, V, Tag, CL> where
    K: Key + Ord,
    V: Value + Hash + Eq + Ord,
    Tag: TagT,
    CL: CausalLength, 

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,