Trait Node 

pub trait Node:
    Clone
    + Default
    + PartialEq {
    type Update;
    type Diff;

    const IS_CONTAINER: bool;

    // Required methods
    fn apply_update(&mut self, update: Self::Update);
    fn as_update(&self) -> Self::Update;
    fn compute_diff(&self, other: &Self) -> Option<Self::Diff>;
    fn apply_diff(&mut self, diff: Self::Diff);
    fn as_diff(&self) -> Self::Diff;
    fn merge(&self, merge: &mut Self);
    fn is_empty(&self) -> bool;
}

A trait implemented by datastructures that can be mutated by applying a succession of updates.

Required Associated Constants

const IS_CONTAINER: bool

Required Associated Types

type Update

The update type is the set of operations that can be applied to this datastructure to modify it.

type Diff

The diff type is a representation of the difference between to instances of this datastructure.

Required Methods

fn apply_update(&mut self, update: Self::Update)

Apply the given update to this struct

fn as_update(&self) -> Self::Update

Get the update corresponding to this struct, that is the update to be applied to the default instance to obtain this struct.

fn compute_diff(&self, other: &Self) -> Option<Self::Diff>

Get the differences between self and other.

The returned diff type represents the changes to apply to self to obtain other.

fn apply_diff(&mut self, diff: Self::Diff)

Apply the given diff to this struct

fn as_diff(&self) -> Self::Diff

Return the diff object to apply to obtain this current updatable value.

fn merge(&self, merge: &mut Self)

Overwrite the merge struct with the values from self.

This can be used for templating.

fn is_empty(&self) -> bool

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl<K, R> Node for RecordMap<K, R>

where K: PartialEq + Eq + Hash + Clone, R: Node + PartialEq,

const IS_CONTAINER: bool = true

type Update = RecordMapUpdates<K, R>

type Diff = RecordMapDiff<K, R>

impl<K, V> Node for ValueMap<K, V>

where K: PartialEq + Eq + Hash + Clone, V: Clone + PartialEq,

const IS_CONTAINER: bool = true

type Update = ValueMapUpdates<K, V>

type Diff = ValueMapDiff<K, V>

impl<K> Node for ValueSet<K>

where K: PartialEq + Eq + Hash + Clone,

const IS_CONTAINER: bool = true

type Update = ValueSetUpdates<K>

type Diff = ValueSetDiff<K>

impl<R> Node for OptRecord<R>

where R: Node,

A config item for amending a mandatory value

const IS_CONTAINER: bool = true

type Update = OptRecordUpdate<R>

type Diff = OptRecordDiff<R>

impl<V> Node for OptValue<V>

where V: Clone + PartialEq,

A config item for amending a mandatory value

const IS_CONTAINER: bool = true

type Update = OptValueUpdate<V>

type Diff = OptValueDiff<V>

impl<V> Node for Value<V>

where V: Clone + Default + PartialEq,

const IS_CONTAINER: bool = false

type Update = ValueUpdate<V>

type Diff = ValueDiff<V>

impl<V> Node for ValueList<V>

where V: Clone + PartialEq,

const IS_CONTAINER: bool = true

type Update = ValueListUpdates<V>

type Diff = ValueListDiff<V>