loro-internal 1.12.0

Loro internal library. Do not use it directly as it's not stable.
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

use loro_common::{LoroResult, LoroValue};
use loro_internal::{loro::ExportMode, LoroDoc};
use rand::{thread_rng, Rng};

#[derive(Debug, Clone, Copy)]
enum Kind {
    Map,
    List,
    MovableList,
    Text,
    Tree,
    Counter,
}

fn empty_state() -> Vec<u8> {
    let doc = LoroDoc::new_auto_commit();
    doc.export(ExportMode::StateOnly(None)).unwrap()
}

fn create_elem_sequentially(n: usize, kind: Kind) -> LoroResult<Vec<u8>> {
    let doc = LoroDoc::new_auto_commit();
    for i in 0..n {
        match kind {
            Kind::Map => {
                doc.get_map("map").insert(&i.to_string(), i as u32)?;
            }
            Kind::List => {
                doc.get_list("list").push(i as u32)?;
            }
            Kind::MovableList => {
                doc.get_movable_list("movable_list")
                    .push(LoroValue::from(i as u32))?;
            }
            Kind::Text => {
                let text = doc.get_text("text");
                text.insert_unicode(text.len_unicode(), &i.to_string())?;
            }
            Kind::Tree => {
                doc.get_tree("tree").enable_fractional_index(0);
                doc.get_tree("tree")
                    .create(loro_internal::TreeParentId::Root)?;
            }
            Kind::Counter => {
                #[cfg(feature = "counter")]
                {
                    doc.get_counter("counter").increment(i as f64)?;
                }
            }
        }
    }
    let bytes = doc.export(ExportMode::StateOnly(None)).unwrap();
    Ok(bytes)
}

fn create_elem_randomly(n: usize, kind: Kind) -> LoroResult<Vec<u8>> {
    let doc = LoroDoc::new_auto_commit();
    let mut rng = thread_rng();
    for _ in 0..n / 5 {
        for _ in 0..5 {
            match kind {
                Kind::Map => {
                    let i = rng.gen::<usize>() % 1000;
                    doc.get_map("map").insert(&i.to_string(), i as u32)?;
                }
                Kind::List => {
                    let list = doc.get_list("list");
                    let i = rng.gen::<usize>() % (list.len() + 1);
                    list.insert(i, i as u32)?;
                }
                Kind::MovableList => {
                    let list = doc.get_movable_list("movable_list");
                    let i = rng.gen::<usize>() % (list.len() + 1);
                    list.insert(i, i as u32)?;
                }
                Kind::Text => {
                    let text = doc.get_text("text");
                    let i = rng.gen::<usize>() % (text.len_unicode() + 1);
                    text.insert_unicode(i, &i.to_string())?;
                }
                Kind::Tree => {
                    doc.get_tree("tree").enable_fractional_index(0);
                    doc.get_tree("tree")
                        .create(loro_internal::TreeParentId::Root)?;
                }
                Kind::Counter => {
                    #[cfg(feature = "counter")]
                    {
                        doc.get_counter("counter").increment(rng.gen::<f64>())?;
                    }
                }
            }
        }
        doc.set_peer_id(rng.gen::<u64>()).unwrap();
    }
    let bytes = doc.export(ExportMode::StateOnly(None)).unwrap();
    Ok(bytes)
}

fn main() -> LoroResult<()> {
    for kind in [
        Kind::Map,
        Kind::List,
        Kind::MovableList,
        Kind::Text,
        #[allow(unused)]
        Kind::Tree,
        #[cfg(feature = "counter")]
        Kind::Counter,
    ] {
        println!("=============================");
        println!("{kind:?}");
        println!("=============================");

        for (title, bytes) in [
            ("empty", empty_state()),
            ("10 items", create_elem_sequentially(10, kind)?),
            (
                "1000 items sequentially",
                create_elem_sequentially(1000, kind)?,
            ),
            ("1000 items randomly", create_elem_randomly(1000, kind)?),
        ] {
            println!("{}: {} bytes", title, bytes.len())
        }
    }
    Ok(())
}