automerge 0.10.0

A JSON-like data structure (a CRDT) that can be modified concurrently by different users, and merged again automatically
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

use crate::{Change, ChangeHash};

use super::{Have, Message, MessageFlags, MessageVersion, State};

use std::borrow::Cow;

pub(super) struct MessageBuilder<'a> {
    heads: Vec<ChangeHash>,
    need: Vec<ChangeHash>,
    have: Vec<Have>,
    changes: Vec<Vec<u8>>,
    hashes: Cow<'a, [ChangeHash]>,
    flags: Option<MessageFlags>,
    version: MessageVersion,
}

impl<'a> MessageBuilder<'a> {
    pub(super) fn new(changes: Vec<Change>, sync_state: &State) -> MessageBuilder<'static> {
        if sync_state.supports_v2_messages() {
            MessageBuilder::new_v2_from_changes(changes)
        } else {
            MessageBuilder::new_v1(changes)
        }
    }

    fn new_v1(changes: Vec<Change>) -> MessageBuilder<'static> {
        let hashes = Cow::Owned(changes.iter().map(|c| c.hash()).collect());
        let changes = changes
            .into_iter()
            .map(|c| c.raw_bytes().to_vec())
            .collect();
        MessageBuilder {
            heads: Vec::new(),
            need: Vec::new(),
            have: Vec::new(),
            changes,
            hashes,
            flags: None,
            version: MessageVersion::V1,
        }
    }

    fn new_empty_v2() -> MessageBuilder<'static> {
        MessageBuilder {
            heads: Vec::new(),
            need: Vec::new(),
            hashes: Cow::Owned(vec![]),
            changes: Vec::new(),
            have: Vec::new(),
            flags: None,
            version: MessageVersion::V2,
        }
    }

    fn new_v2_from_changes(changes: Vec<Change>) -> MessageBuilder<'static> {
        let hashes: Cow<'static, _> = Cow::Owned(changes.iter().map(|c| c.hash()).collect());
        let size = changes.iter().map(|c| c.raw_bytes().len()).sum();
        let mut encoded = Vec::with_capacity(size);
        for c in changes {
            encoded.extend_from_slice(c.raw_bytes())
        }
        Self::new_v2(encoded, hashes)
    }

    pub(super) fn new_v2<'b>(data: Vec<u8>, hashes: Cow<'b, [ChangeHash]>) -> MessageBuilder<'b> {
        if data.is_empty() {
            return Self::new_empty_v2();
        }
        MessageBuilder {
            heads: Vec::new(),
            need: Vec::new(),
            hashes,
            changes: vec![data],
            have: Vec::new(),
            flags: None,
            version: MessageVersion::V2,
        }
    }

    pub(super) fn is_empty(&self) -> bool {
        self.hashes.is_empty()
    }

    pub(super) fn hashes(&self) -> impl Iterator<Item = &ChangeHash> {
        self.hashes.iter()
    }

    pub(super) fn heads(mut self, heads: Vec<ChangeHash>) -> Self {
        self.heads = heads;
        self
    }

    pub(super) fn need(mut self, need: Vec<ChangeHash>) -> Self {
        self.need = need;
        self
    }

    pub(super) fn have(mut self, have: Vec<Have>) -> Self {
        self.have = have;
        self
    }

    pub(super) fn flags(mut self, flags: Option<MessageFlags>) -> Self {
        self.flags = flags;
        self
    }

    pub(super) fn build(self) -> Message {
        Message {
            heads: self.heads,
            need: self.need,
            have: self.have,
            changes: super::ChunkList::from(self.changes),
            flags: self.flags,
            version: self.version,
        }
    }
}