cojson 0.6.0

Collaborative JSON (A high performance CRDT)
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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

use std::cmp::Ordering;

use super::ops::Op;

pub fn noncausal_sort(a: &Op, b: &Op) -> Ordering {
    a.time
        .cmp(&b.time)
        .then_with(|| a.id.0.cmp(&b.id.0))
        .then_with(|| a.id.1.cmp(&b.id.1))
}

pub(crate) fn only_in_first_sorted_list<
    T: Clone,
    L: IndexableList<T>,
    F: Fn(&T, &T) -> Ordering,
>(
    a: &L,
    b: &L,
    compare: F,
) -> Vec<T> {
    if b.size() == 0 {
        return a.iter().cloned().collect();
    }

    let mut result = vec![];

    let mut maybe_a_item = a.at(0);
    let mut maybe_b_item = b.at(0);

    let mut i_a = 0;
    let mut i_b = 0;

    while let Some(a_item) = maybe_a_item {
        if let Some(b_item) = maybe_b_item {
            let ordering = compare(a_item, b_item);

            match ordering {
                Ordering::Less => {
                    // missing in B
                    result.push(a_item.clone());
                    i_a += 1;
                    maybe_a_item = a.at(i_a);
                }
                Ordering::Greater => {
                    // missing in A, ignore
                    i_b += 1;
                    maybe_b_item = b.at(i_b);
                }
                Ordering::Equal => {
                    i_a += 1;
                    maybe_a_item = a.at(i_a);
                    i_b += 1;
                    maybe_b_item = b.at(i_b);
                }
            }
        } else {
            result.push(a_item.clone());
            i_a += 1;
            maybe_a_item = a.at(i_a);
        }
    }

    result
}

pub(crate) fn search_from_back<T, L: IndexableList<T>, F: Fn(&T, &T) -> Ordering>(
    list: &L,
    item: &T,
    compare: F,
) -> Result<usize, usize> {
    let mut insertion_pos = list.size();
    while insertion_pos > 0 {
        let prev = list
            .at(insertion_pos - 1)
            .expect("Should have never entered for loop if no deletes.");
        let ordering = compare(prev, item);
        match ordering {
            Ordering::Less => break,
            Ordering::Greater => {}
            Ordering::Equal => return Result::Ok(insertion_pos),
        }
        insertion_pos -= 1;
    }
    Result::Err(insertion_pos)
}

pub(crate) trait IndexableList<T> {
    fn size(&self) -> usize;
    fn at(&self, at: usize) -> Option<&T>;
    fn last(&self) -> Option<&T>;
    fn iter<'a>(&'a self) -> Box<dyn DoubleEndedIterator<Item = &T> + 'a>;
}

impl<T> IndexableList<T> for Box<dyn IndexableList<T>> {
    fn size(&self) -> usize {
        self.as_ref().size()
    }

    fn at(&self, at: usize) -> Option<&T> {
        self.as_ref().at(at)
    }

    fn last(&self) -> Option<&T> {
        self.as_ref().last()
    }

    fn iter<'a>(&'a self) -> Box<dyn DoubleEndedIterator<Item = &T> + 'a> {
        self.as_ref().iter()
    }
}

impl<T: Clone> IndexableList<T> for im::Vector<T> {
    fn size(&self) -> usize {
        self.len()
    }

    fn at(&self, at: usize) -> Option<&T> {
        self.get(at)
    }

    fn last(&self) -> Option<&T> {
        self.last()
    }

    fn iter<'a>(&'a self) -> Box<dyn DoubleEndedIterator<Item = &T> + 'a> {
        Box::new(self.iter())
    }
}