Struct crdts::lwwreg::LWWReg

pub struct LWWReg<V, M> {
    pub val: V,
    pub marker: M,
}

LWWReg is a simple CRDT that contains an arbitrary value along with an Ord that tracks causality. It is the responsibility of the user to guarantee that the source of the causal element is monotonic. Don’t use timestamps unless you are comfortable with divergence.

M is a marker. It must grow monotonically and must be globally unique

Fields

val: V

val is the opaque element contained within this CRDT

marker: M

marker should be a monotonic value associated with this val

Implementations

impl<V: PartialEq, M: Ord> LWWReg<V, M>

pub fn update(&mut self, val: V, marker: M)

Updates value witnessed by the given marker.

use crdts::LWWReg;
let mut reg = LWWReg { val: 1, marker: 2 };

// updating with a smaller marker is a no-op
reg.update(2, 1);
assert_eq!(reg.val, 1);

// updating with larger marker succeeds
reg.update(2, 3);
assert_eq!(reg, LWWReg { val: 2, marker: 3 });

pub fn validate_update(&self, val: &V, marker: &M) -> Result<(), Validation>

An update is invalid if the marker is exactly the same as the current marker BUT the value is different:

use crdts::{lwwreg, LWWReg};
let mut reg = LWWReg { val: 1, marker: 2 };

// updating with a smaller marker is a no-op
assert_eq!(reg.validate_update(&32, &2), Err(lwwreg::Validation::ConflictingMarker));

Trait Implementations

impl<V: Clone, M: Clone> Clone for LWWReg<V, M>

fn clone(&self) -> LWWReg<V, M>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<V: PartialEq, M: Ord> CmRDT for LWWReg<V, M>

type Op = LWWReg<V, M>

Op defines a mutation to the CRDT. As long as Op’s from one actor are replayed in exactly the same order they were generated by that actor, the CRDT will converge. In other words, we must have a total ordering on each actors operations, while requiring only a partial order over all ops. E.g.

type Validation = Validation

The validation error returned by validate_op.

fn validate_op(&self, op: &Self::Op) -> Result<(), Self::Validation>

Some CRDT’s have stricter requirements on how they must be used. To avoid violating these requirements, CRDT’s provide an interface to optionally validate op’s before they are applied.

fn apply(&mut self, op: Self::Op)

Apply an Op to the CRDT

impl<V: PartialEq, M: Ord> CvRDT for LWWReg<V, M>

fn validate_merge(&self, other: &Self) -> Result<(), Self::Validation>

Validates whether a merge is safe to perfom

Returns an error if the marker is identical but the contained element is different.

use crdts::{lwwreg, LWWReg, CvRDT};
let mut l1 = LWWReg { val: 1, marker: 2 };
let l2 = LWWReg { val: 3, marker: 2 };
// errors!
assert_eq!(l1.validate_merge(&l2), Err(lwwreg::Validation::ConflictingMarker));

fn merge(&mut self, _: Self)

Combines two LWWReg instances according to the marker that tracks causality.

type Validation = Validation

The validation error returned by validate_merge.

impl<V: Debug, M: Debug> Debug for LWWReg<V, M>

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

Formats the value using the given formatter.

impl<V: Default, M: Default> Default for LWWReg<V, M>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, V, M> Deserialize<'de> for LWWReg<V, M>where V: Deserialize<'de>, M: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<V: Hash, M: Hash> Hash for LWWReg<V, M>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

impl<V: PartialEq, M: PartialEq> PartialEq<LWWReg<V, M>> for LWWReg<V, M>

fn eq(&self, other: &LWWReg<V, M>) -> bool

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<V, M> Serialize for LWWReg<V, M>where V: Serialize, M: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<V: Eq, M: Eq> Eq for LWWReg<V, M>

impl<V, M> StructuralEq for LWWReg<V, M>

impl<V, M> StructuralPartialEq for LWWReg<V, M>