Struct crdt_tree::logopmove::LogOpMove

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

From the paper:

In order to correctly apply move operations, a replica needs to maintain not only the current state of the tree, but also an operation log. The log is a list of LogMove records in descending timestamp order. LogMove t oldp p m c is similar to Move t p m c; the difference is that LogMove has an additional field oldp of type ('n x 'm) option. This option type means the field can either take the value None or a pair of a node ID and a metadata field.

When a replica applies a Move operation to its tree it also records a corresponding LogMove operation in its log. The t, p, m, and c fields are taken directly from the Move record while the oldp field is filled in based on the state of the tree before the move. If c did not exist in the tree, oldp is set to None. Else oldp records the previous parent metadata of c: if there exist p' and m' such that (p', m', c') E tree, then oldp is set to Some(p', m'). The get_parent() function implements this.

Implementations

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

pub fn new(
    op: OpMove<ID, TM, A>,
    oldp: Option<TreeNode<ID, TM>>
) -> LogOpMove<ID, TM, A>

create a new instance of LogOpMove

pub fn timestamp(&self) -> &Clock<A>

returns timestamp reference

pub fn parent_id(&self) -> &ID

returns parent_id reference

pub fn metadata(&self) -> &TM

returns metadata reference

pub fn child_id(&self) -> &ID

returns child_id reference

pub fn oldp(&self) -> &Option<TreeNode<ID, TM>>

returns oldp reference

pub fn op_into(self) -> OpMove<ID, TM, A>

converts LogOpMove into an OpMove

Trait Implementations

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

impl<'de, ID: TreeId, TM: TreeMeta, A: Actor> Deserialize<'de> for LogOpMove<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 LogOpMove<ID, TM, A>

impl<ID: TreeId, A: Actor, TM: TreeMeta> From<LogOpMove<ID, TM, A>> for OpMove<ID, TM, A>

fn from(l: LogOpMove<ID, TM, A>) -> Self

creates OpMove from a LogOpMove

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

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

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

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

This method tests for !=.

impl<ID: TreeId, TM: TreeMeta, A: Actor> Serialize for LogOpMove<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 LogOpMove<ID, TM, A>

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