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

use std::time::Instant;

use loro_internal::{encoding::ExportMode, LoroDoc, TreeParentId};
use rand::{rngs::StdRng, Rng};

#[allow(unused)]
fn checkout() {
    let depth = 300;
    let loro = LoroDoc::new_auto_commit();
    let tree = loro.get_tree("tree");
    let mut ids = vec![];
    let mut versions = vec![];
    let id1 = tree.create_at(TreeParentId::Root, 0).unwrap();
    ids.push(id1);
    versions.push(loro.oplog_frontiers());
    for _ in 1..depth {
        let id = tree
            .create_at(TreeParentId::Node(*ids.last().unwrap()), 0)
            .unwrap();
        ids.push(id);
        versions.push(loro.oplog_frontiers());
    }
    let mut rng: StdRng = rand::SeedableRng::seed_from_u64(0);

    for _ in 0..1000 {
        let i = rng.gen::<usize>() % depth;
        let f = &versions[i];
        loro.checkout(f).unwrap();
    }
}

#[allow(unused)]
fn mov() {
    let loro = LoroDoc::new_auto_commit();
    let tree = loro.get_tree("tree");
    let mut ids = vec![];
    let size = 10000;
    for _ in 0..size {
        ids.push(tree.create_at(TreeParentId::Root, 0).unwrap())
    }
    let mut rng: StdRng = rand::SeedableRng::seed_from_u64(0);
    let n = 100000;

    for _ in 0..n {
        let i = rng.gen::<usize>() % size;
        let j = rng.gen::<usize>() % size;
        let children_num = tree.children_num(&TreeParentId::Node(ids[j])).unwrap_or(0);
        tree.move_to(ids[i], TreeParentId::Node(ids[j]), children_num)
            .unwrap_or_default();
    }
    println!(
        "encode snapshot size {:?}",
        loro.export(ExportMode::Snapshot).unwrap().len()
    );
    println!(
        "encode updates size {:?}",
        loro.export(ExportMode::all_updates()).unwrap().len()
    );
}

#[allow(unused)]
fn create() {
    let size = 100000;
    let loro = LoroDoc::default();
    let tree = loro.get_tree("tree");
    for _ in 0..size {
        tree.create_at(TreeParentId::Root, 0).unwrap();
    }
    println!(
        "encode snapshot size {:?}\n",
        loro.export(ExportMode::Snapshot).unwrap().len()
    );
    println!(
        "encode updates size {:?}",
        loro.export(ExportMode::all_updates()).unwrap().len()
    );
}

fn main() {
    let s = Instant::now();
    mov();
    println!("{} ms", s.elapsed().as_millis());
}