treeclocks 0.6.3

Various Tree Clock data-structures and utilities
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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

use crate::{EventTree, IdTree};

/// Higher level construct around the Id Tree and Event Tree primitives. Provides a higher level
/// abstraction than the original paper.
#[derive(Debug, Clone, Default)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ItcPair {
    pub id: IdTree,
    pub timestamp: EventTree,
}

impl ItcPair {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn from(id: IdTree) -> Self {
        Self {
            id,
            timestamp: EventTree::new(),
        }
    }

    pub fn fork(&mut self) -> ItcPair {
        ItcPair {
            id: self.fork_id(),
            timestamp: self.timestamp.clone(),
        }
    }

    pub fn fork_id(&mut self) -> IdTree {
        let id = std::mem::take(&mut self.id);
        let (my_id, other) = id.fork();
        self.id = my_id;
        other
    }

    pub fn join(&mut self, other: ItcPair) {
        self.sync(&other.timestamp);

        let id = std::mem::take(&mut self.id);
        self.id = id.join(other.id);
    }

    pub fn sync(&mut self, other: &EventTree) {
        let other = other.clone();
        let timestamp = std::mem::take(&mut self.timestamp);
        self.timestamp = timestamp.join(other);
    }

    pub fn event(&mut self) {
        let timestamp = std::mem::take(&mut self.timestamp);
        self.timestamp = timestamp.event(&self.id);
    }
}

impl std::fmt::Display for ItcPair {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
        write!(f, "{} | {}", self.id, self.timestamp)
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_basic() {
        let mut n0 = ItcPair::new();
        let mut n1 = n0.fork();
        let mut n2 = n1.fork();

        n0.event();
        n0.event();
        n2.event();

        n0.join(n2);

        assert_eq!(&n0.to_string(), "(1, (0, 1)) | (0, 2, (0, 0, 1))");

        n1.event();
        n0.sync(&n1.timestamp);

        assert_eq!(&n0.to_string(), "(1, (0, 1)) | (1, 1, 0)");

        n0.join(n1);
        n0.event();

        assert_eq!(&n0.to_string(), "1 | 2");
    }

    #[test]
    fn test_difference() {
        let mut n0 = ItcPair::new();
        let mut n1 = n0.fork();
        let mut n2 = n1.fork();
        let mut n3 = n0.fork();

        n0.event();
        n3.sync(&n0.timestamp);

        n1.event();
        n2.sync(&n1.timestamp);

        let t = n3.timestamp.clone();
        let diff = t.diff(&n2.timestamp);

        assert_eq!(&diff.to_string(), "(0, (0, 1, 0), 0)");
    }
}