Struct crdts::lwwreg::LWWReg

pub struct LWWReg<V: Val, M: Marker> {
    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.

Fields

val: V

val is the opaque element contained within this CRDT

marker: M

marker should be a monotonic value associated with this val

Methods

impl<V: Val, M: Marker> 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: Val, M: Marker> 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: Val, M: Marker> 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: Clone + Val, M: Clone + Marker> 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: Eq + Val, M: Eq + Marker> Eq for LWWReg<V, M>

impl<V: Val + Default, M: Marker + Default> Default for LWWReg<V, M>

fn default() -> LWWReg<V, M>

Returns the "default value" for a type.

impl<V: PartialEq + Val, M: PartialEq + Marker> 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: Hash + Val, M: Hash + Marker> Hash for LWWReg<V, M>

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

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: Debug + Val, M: Debug + Marker> Debug for LWWReg<V, M>

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

Formats the value using the given formatter.

impl<V: Val, M: Marker> 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<'de, V: Val, M: Marker> 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.