lazily 0.38.1

Lazy reactive signals with dependency tracking and cache invalidation
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

//! Lossless mergeable document-tree contract (`#lzcrdttree`).

use crate::{TextCrdt, TextOp, TextVersionVector};

/// A lossless document CRDT with a compact distributed frontier and transport delta.
///
/// Implementations must make [`merge_from`](Self::merge_from) and delta application
/// commutative, associative, and idempotent. A snapshot is exactly
/// `delta_since(&Default::default())`, so snapshot and incremental replication share one
/// representation and preserve operation identity.
pub trait CrdtTree {
    type VersionVector: Clone + Default + PartialEq + Eq;
    type Delta: Clone + PartialEq + Eq;
    type Value: Clone + PartialEq + Eq;

    fn version_vector(&self) -> Self::VersionVector;
    fn delta_since(&self, version: &Self::VersionVector) -> Self::Delta;
    fn apply_delta(&mut self, delta: &Self::Delta) -> bool;
    fn text(&self) -> String;
    fn value(&self) -> Self::Value;
    fn merge_from(&mut self, other: &Self) -> bool;
}

impl CrdtTree for TextCrdt {
    type VersionVector = TextVersionVector;
    type Delta = Vec<TextOp>;
    type Value = String;

    fn version_vector(&self) -> Self::VersionVector {
        TextCrdt::version_vector(self)
    }

    fn delta_since(&self, version: &Self::VersionVector) -> Self::Delta {
        TextCrdt::delta_since(self, version)
    }

    fn apply_delta(&mut self, delta: &Self::Delta) -> bool {
        TextCrdt::apply_delta(self, delta)
    }

    fn text(&self) -> String {
        TextCrdt::text(self)
    }

    fn value(&self) -> Self::Value {
        TextCrdt::text(self)
    }

    fn merge_from(&mut self, other: &Self) -> bool {
        TextCrdt::merge(self, other)
    }
}