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) -> Result<(), Error>

Updates value witnessed by the given marker. An Err is returned if the given marker is exactly equal to the current marker

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

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

// updating with existing marker fails
assert!(reg.update(2, 2).is_err());
assert_eq!(reg, LWWReg { val: 1, marker: 2 });

// updating with same val and marker succeeds
assert!(reg.update(1, 2).is_ok());
assert_eq!(reg, LWWReg { val: 1, marker: 2 });

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

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: 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: Ord + 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: Eq, M: Eq> Eq for LWWReg<V, M>

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

type Error = Error

User chosen error type

type Op = Self

Same Op laws from non-funky CmRDT above

fn apply(&mut self, op: Self::Op) -> Result<(), Error>

Apply an Op to the CRDT

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

type Error = Error

User chosen error type

fn merge(
    &mut self,
    LWWReg { val: val, marker: marker }: Self
) -> Result<(), Error>

Combines two LWWReg instances according to the marker that tracks causality. Returns an error if the marker is identical but the contained element is different.

use crdts::{LWWReg, FunkyCvRDT};
let mut l1 = LWWReg { val: 1, marker: 2 };
let l2 = LWWReg { val: 3, marker: 2 };
// errors!
assert!(l1.merge(l2).is_err());

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, 

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: &LWWReg<V, M>) -> bool

This method tests for !=.

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, M> StructuralEq for LWWReg<V, M>

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