Struct LogOpMove 

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

Implements LogOpMove, a log entry used by State

From the paper[1]:

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.

[1] https://martin.kleppmann.com/papers/move-op.pdf

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 duplicate 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, TM, A> Deserialize<'de> for LogOpMove<ID, TM, A>

where ID: Deserialize<'de> + TreeId, TM: Deserialize<'de> + TreeMeta, A: Deserialize<'de> + Actor,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

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 for LogOpMove<ID, TM, A>

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl<ID, TM, A> Serialize for LogOpMove<ID, TM, A>

where ID: Serialize + TreeId, TM: Serialize + TreeMeta, A: Serialize + Actor,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

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

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