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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

use crate::{
    columnar::{
        column_range::{KeyIter, ObjIdIter, OpIdListIter, ValueIter},
        encoding, Key,
    },
    types::{ObjId, OpId},
    ScalarValue,
};

pub(crate) trait IntoColError: std::error::Error {
    fn into_col_error<S: AsRef<str>>(self, col_name: S) -> encoding::DecodeColumnError;
}

impl IntoColError for encoding::raw::Error {
    fn into_col_error<S: AsRef<str>>(self, col_name: S) -> encoding::DecodeColumnError {
        encoding::DecodeColumnError::decode_raw(col_name, self)
    }
}

impl IntoColError for encoding::DecodeColumnError {
    fn into_col_error<S: AsRef<str>>(self, col_name: S) -> encoding::DecodeColumnError {
        self.in_column(col_name)
    }
}

/// A helper trait which allows users to annotate decoders with errors containing a column name
///
/// Frequently we have an iterator which decodes values from some underlying column storage, e.g.
/// we might have a `BooleanDecoder` which decodes items from an `insert` column. In the context
/// where we are reading from this column we would like to produce errors which describe which
/// column the error occurred in - to this end we require that the error produced by the underlying
/// decoder implement `IntoColError` and we provide the `next_in_col` method to call
/// `into_col_error` on any errors produced by the decoder.
pub(crate) trait ColumnDecoder<T>: Iterator<Item = Result<T, Self::Error>> {
    type Error: IntoColError;
    type Value;

    fn maybe_next_in_col<S: AsRef<str>>(
        &mut self,
        col_name: S,
    ) -> Result<Option<Self::Value>, encoding::DecodeColumnError>;

    /// Decode the next value from this decoder, annotating any error with the `col_name`
    fn next_in_col<S: AsRef<str>>(
        &mut self,
        col_name: S,
    ) -> Result<Self::Value, encoding::DecodeColumnError> {
        self.maybe_next_in_col(&col_name)?
            .ok_or_else(|| encoding::DecodeColumnError::unexpected_null(col_name))
    }
}

impl ColumnDecoder<bool> for encoding::BooleanDecoder<'_> {
    type Error = encoding::raw::Error;
    type Value = bool;

    fn maybe_next_in_col<S: AsRef<str>>(
        &mut self,
        col_name: S,
    ) -> Result<Option<bool>, encoding::DecodeColumnError> {
        self.next()
            .transpose()
            .map_err(|e| e.into_col_error(col_name))
    }
}

impl<I, T, E> ColumnDecoder<Option<T>> for I
where
    I: Iterator<Item = Result<Option<T>, E>>,
    E: IntoColError,
{
    type Error = E;
    type Value = T;

    fn maybe_next_in_col<S: AsRef<str>>(
        &mut self,
        col_name: S,
    ) -> Result<Option<T>, encoding::DecodeColumnError> {
        Ok(self
            .next()
            .transpose()
            .map_err(|e| e.into_col_error(col_name))?
            .flatten())
    }
}

impl ColumnDecoder<Vec<OpId>> for OpIdListIter<'_> {
    type Error = encoding::DecodeColumnError;
    type Value = Vec<OpId>;

    fn maybe_next_in_col<S: AsRef<str>>(
        &mut self,
        col_name: S,
    ) -> Result<Option<Vec<OpId>>, encoding::DecodeColumnError> {
        self.next().transpose().map_err(|e| e.in_column(col_name))
    }
}

impl ColumnDecoder<ScalarValue> for ValueIter<'_> {
    type Error = encoding::DecodeColumnError;
    type Value = ScalarValue;

    fn maybe_next_in_col<S: AsRef<str>>(
        &mut self,
        col_name: S,
    ) -> Result<Option<Self::Value>, encoding::DecodeColumnError> {
        self.next().transpose().map_err(|e| e.in_column(col_name))
    }
}

impl ColumnDecoder<Key> for KeyIter<'_> {
    type Error = encoding::DecodeColumnError;
    type Value = Key;

    fn maybe_next_in_col<S: AsRef<str>>(
        &mut self,
        col_name: S,
    ) -> Result<Option<Self::Value>, encoding::DecodeColumnError> {
        self.next().transpose().map_err(|e| e.in_column(col_name))
    }
}

impl ColumnDecoder<ObjId> for ObjIdIter<'_> {
    type Value = ObjId;
    type Error = encoding::DecodeColumnError;

    fn maybe_next_in_col<S: AsRef<str>>(
        &mut self,
        col_name: S,
    ) -> Result<Option<Self::Value>, encoding::DecodeColumnError> {
        self.next().transpose().map_err(|e| e.in_column(col_name))
    }
}