Struct crdts::vclock::VClock

pub struct VClock<A: Ord + Clone + Serialize + DeserializeOwned> {
    pub dots: BTreeMap<A, Counter>,
}

A VClock is a standard vector clock. It contains a set of "actors" and associated counters. When a particular actor witnesses a mutation, their associated counter in a VClock is incremented. VClock is typically used as metadata for associated application data, rather than as the container for application data. VClock just tracks causality. It can tell you if something causally descends something else, or if different replicas are "concurrent" (were mutated in isolation, and need to be resolved externally).

Fields

dots: BTreeMap<A, Counter>

dots is the mapping from actors to their associated counters

Methods

impl<A: Ord + Clone + Serialize + DeserializeOwned> VClock<A>

fn new() -> VClock<A>

Returns a new VClock instance.

fn witness(&mut self, actor: A, counter: Counter) -> Result<(), ()>

For a particular actor, possibly store a new counter if it dominates.

Examples

use crdts::VClock;
let (mut a, mut b) = (VClock::new(), VClock::new());
a.witness("A".to_string(), 2);
a.witness("A".to_string(), 0); // ignored because 2 dominates 0
b.witness("A".to_string(), 1);
assert!(a > b);

fn increment(&mut self, actor: A) -> Counter

For a particular actor, increment the associated counter.

Examples

use crdts::VClock;
let (mut a, mut b) = (VClock::new(), VClock::new());
a.increment("A".to_string());
a.increment("A".to_string());
a.witness("A".to_string(), 0); // ignored because 2 dominates 0
b.increment("A".to_string());
assert!(a > b);

fn merge(&mut self, other: VClock<A>)

Merge another vector clock into this one, without regard to dominance.

Examples

use crdts::VClock;
let (mut a, mut b, mut c) = (VClock::new(), VClock::new(), VClock::new());
a.increment("A".to_string());
b.increment("B".to_string());
c.increment("A".to_string());
c.increment("B".to_string());
a.merge(b);
assert_eq!(a, c);

fn contains_descendent_element(&self, actor: &A, counter: &Counter) -> bool

Determine if a single element is present and descendent. Generally prefer using the higher-level comparison operators between vclocks over this specific method.

fn concurrent(&self, other: &VClock<A>) -> bool

True if two vector clocks have diverged.

Examples

use crdts::VClock;
let (mut a, mut b) = (VClock::new(), VClock::new());
a.increment("A".to_string());
b.increment("B".to_string());
assert!(a.concurrent(&b));

fn get(&self, actor: &A) -> Option<Counter>

Return the associated counter for this actor, if present.

fn is_empty(&self) -> bool

Returns true if this vector clock contains nothing.

fn dominating_dots(&self, dots: &BTreeMap<A, Counter>) -> BTreeMap<A, Counter>

Return the dots that self dominates compared to another clock.

fn dominating_vclock(&self, other: &VClock<A>) -> VClock<A>

Return a new VClock that contains the entries for which we have a counter that dominates another VClock.

Examples

use crdts::VClock;
let (mut a, mut b) = (VClock::new(), VClock::new());
a.witness("A".to_string(), 3);
a.witness("B".to_string(), 2);
a.witness("D".to_string(), 14);
a.witness("G".to_string(), 22);

b.witness("A".to_string(), 4);
b.witness("B".to_string(), 1);
b.witness("C".to_string(), 1);
b.witness("D".to_string(), 14);
b.witness("E".to_string(), 5);
b.witness("F".to_string(), 2);

let dom = a.dominating_vclock(&b);
assert_eq!(dom.get(&"B".to_string()), Some(2));
assert_eq!(dom.get(&"G".to_string()), Some(22));

fn intersection(&self, other: &VClock<A>) -> VClock<A>

Returns the common elements (same actor and counter) for two VClock instances.

Trait Implementations

impl<A: Debug + Ord + Clone + Serialize + DeserializeOwned> Debug for VClock<A>

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<A: Clone + Ord + Clone + Serialize + DeserializeOwned> Clone for VClock<A>

fn clone(&self) -> VClock<A>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A: Ord + Ord + Clone + Serialize + DeserializeOwned> Ord for VClock<A>

fn cmp(&self, __arg_0: &VClock<A>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

impl<A: PartialEq + Ord + Clone + Serialize + DeserializeOwned> PartialEq for VClock<A>

fn eq(&self, __arg_0: &VClock<A>) -> bool

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

fn ne(&self, __arg_0: &VClock<A>) -> bool

This method tests for !=.

impl<A: Eq + Ord + Clone + Serialize + DeserializeOwned> Eq for VClock<A>

impl<A: Hash + Ord + Clone + Serialize + DeserializeOwned> Hash for VClock<A>

fn hash<__HA: Hasher>(&self, __arg_0: &mut __HA)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl<A: Ord + Clone + Serialize + DeserializeOwned> PartialOrd for VClock<A>

fn partial_cmp(&self, other: &VClock<A>) -> Option<Ordering>

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

fn lt(&self, other: &Rhs) -> bool

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

fn le(&self, other: &Rhs) -> bool

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

fn gt(&self, other: &Rhs) -> bool

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

fn ge(&self, other: &Rhs) -> bool

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