crdt-richtext 0.1.1

Richtext CRDT, Rust implementation of Peritext and Fugue
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

use super::*;
use generic_btree::{rle, BTreeTrait};

#[derive(Debug, Clone)]
pub(crate) struct RichTreeTrait;

impl BTreeTrait for RichTreeTrait {
    type Elem = Elem;

    type Cache = Cache;

    type CacheDiff = CacheDiff;

    const MAX_LEN: usize = 32;

    fn calc_cache_internal(
        cache: &mut Self::Cache,
        caches: &[generic_btree::Child<Self>],
        diff: Option<Self::CacheDiff>,
    ) -> Option<Self::CacheDiff> {
        match diff {
            Some(diff) => {
                cache.apply_diff(&diff);
                Some(diff)
            }
            None => {
                let mut len = 0;
                let mut utf16_len = 0;
                let mut anchor_set = CacheAnchorSet::default();
                for child in caches.iter() {
                    len += child.cache.len;
                    utf16_len += child.cache.utf16_len;
                    anchor_set.union_(&child.cache.anchor_set);
                }

                let anchor_diff = anchor_set.calc_diff(&cache.anchor_set);
                let diff = CacheDiff {
                    anchor_diff,
                    len_diff: len as isize - cache.len as isize,
                    utf16_len_diff: utf16_len as isize - cache.utf16_len as isize,
                };

                cache.len = len;
                cache.utf16_len = utf16_len;
                Some(diff)
            }
        }
    }

    fn calc_cache_leaf(
        cache: &mut Self::Cache,
        caches: &[Self::Elem],
        diff: Option<Self::CacheDiff>,
    ) -> Self::CacheDiff {
        match diff {
            Some(diff) => {
                cache.apply_diff(&diff);
                diff
            }
            None => {
                let mut len = 0;
                let mut utf16_len = 0;
                let mut anchor_set = CacheAnchorSet::default();
                for child in caches.iter() {
                    if !child.is_dead() {
                        len += child.string.len();
                        utf16_len += child.utf16_len;
                    }
                    anchor_set.union_elem_set(&child.anchor_set);
                }

                let anchor_diff = cache.anchor_set.calc_diff(&anchor_set);
                let diff = CacheDiff {
                    anchor_diff,
                    len_diff: len as isize - cache.len as isize,
                    utf16_len_diff: utf16_len as isize - cache.utf16_len as isize,
                };
                cache.len = len as u32;
                cache.utf16_len = utf16_len;
                diff
            }
        }
    }

    fn merge_cache_diff(diff1: &mut Self::CacheDiff, diff2: &Self::CacheDiff) {
        diff1.anchor_diff.merge(&diff2.anchor_diff);
        diff1.len_diff += diff2.len_diff;
        diff1.utf16_len_diff += diff2.utf16_len_diff;
    }

    fn insert(
        elements: &mut generic_btree::HeapVec<Self::Elem>,
        index: usize,
        offset: usize,
        elem: Self::Elem,
    ) {
        rle::insert_with_split(elements, index, offset, elem)
    }
}