Struct crdt_tree::state::State

pub struct State<ID: TreeId, TM: TreeMeta, A: Actor> { /* fields omitted */ }

State. This is the primary interface for working with a Tree CRDT.

Implementations

impl<ID: TreeId, TM: TreeMeta, A: Actor> State<ID, TM, A>

pub fn new() -> Self

create a new State

pub fn tree(&self) -> &Tree<ID, TM>

returns tree reference

pub fn tree_mut(&mut self) -> &mut Tree<ID, TM>

returns mutable tree reference

pub fn log(&self) -> &Vec<LogOpMove<ID, TM, A>>

returns log reference

pub fn add_log_entry(&mut self, entry: LogOpMove<ID, TM, A>)

add_log_entry

pub fn truncate_log_before(&mut self, timestamp: &Clock<A>) -> bool

removes log entries before a given timestamp. not part of crdt-tree algo.

pub fn do_op(&mut self, op: OpMove<ID, TM, A>) -> LogOpMove<ID, TM, A>

The do_op function performs the actual work of applying a move operation.

This function takes as argument a pair consisting of a Move operation and the current tree and it returns a pair consisting of a LogMove operation (which will be added to the log) and an updated tree.

pub fn undo_op(&mut self, log: &LogOpMove<ID, TM, A>)

undo_op

pub fn redo_op(&mut self, log: LogOpMove<ID, TM, A>)

redo_op uses do_op to perform an operation again and recomputes the LogMove record (which might have changed due to the effect of the new operation)

pub fn apply_op(&mut self, op1: OpMove<ID, TM, A>)

See general description of apply/undo/redo above.

The apply_op func takes two arguments: a Move operation to apply and the current replica state; and it returns the new replica state. The constrains t::{linorder} in the type signature indicates that timestamps t are instance if linorder type class, and they can therefore be compared with the < operator during a linear (or total) order.

pub fn apply_ops_into(&mut self, ops: Vec<OpMove<ID, TM, A>>)

applies a list of operations and consume them. (no cloning)

pub fn apply_ops(&mut self, ops: &[OpMove<ID, TM, A>])

applies a list of operations reference, cloning each op.

Trait Implementations

impl<ID: Clone + TreeId, TM: Clone + TreeMeta, A: Clone + Actor> Clone for State<ID, TM, A>

fn clone(&self) -> State<ID, TM, A>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<ID: TreeId, TM: TreeMeta, A: Actor> CmRDT for State<ID, TM, A>

type Op = OpMove<ID, TM, A>

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.

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

Apply an operation to a State instance.

impl<ID: Debug + TreeId, TM: Debug + TreeMeta, A: Debug + Actor> Debug for State<ID, TM, A>

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

Formats the value using the given formatter.

impl<ID: TreeId, A: Actor, TM: TreeMeta> Default for State<ID, TM, A>

fn default() -> Self

Returns the "default value" for a type.

impl<'de, ID: TreeId, TM: TreeMeta, A: Actor> Deserialize<'de> for State<ID, TM, A> where
    ID: Deserialize<'de>,
    TM: Deserialize<'de>,
    A: Deserialize<'de>, 

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

Deserialize this value from the given Serde deserializer.

impl<ID: Eq + TreeId, TM: Eq + TreeMeta, A: Eq + Actor> Eq for State<ID, TM, A>

impl<ID: TreeId, A: Actor, TM: TreeMeta> From<(Vec<LogOpMove<ID, TM, A>>, Tree<ID, TM>)> for State<ID, TM, A>

fn from(e: (Vec<LogOpMove<ID, TM, A>>, Tree<ID, TM>)) -> Self

creates State from tuple (Vec, Tree)

impl<ID: PartialEq + TreeId, TM: PartialEq + TreeMeta, A: PartialEq + Actor> PartialEq<State<ID, TM, A>> for State<ID, TM, A>

fn eq(&self, other: &State<ID, TM, A>) -> bool

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

fn ne(&self, other: &State<ID, TM, A>) -> bool

This method tests for !=.

impl<ID: TreeId, TM: TreeMeta, A: Actor> Serialize for State<ID, TM, A> where
    ID: Serialize,
    TM: Serialize,
    A: Serialize, 

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

Serialize this value into the given Serde serializer.

impl<ID: TreeId, TM: TreeMeta, A: Actor> StructuralEq for State<ID, TM, A>

impl<ID: TreeId, TM: TreeMeta, A: Actor> StructuralPartialEq for State<ID, TM, A>