colla 0.1.0

Operational Transformation library for nested documents with text and rich-text
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

use crate::path::Path;
use crate::value::ValueType;
use thiserror::Error;

#[derive(Debug, Clone, PartialEq, Eq, Error)]
#[non_exhaustive]
pub enum ValueError {
    #[error("float must be finite")]
    NonFiniteFloat,
    #[error("duplicate key: {0}")]
    DuplicateKey(String),
}

#[derive(Debug, Clone, PartialEq, Eq, Error)]
#[non_exhaustive]
pub enum ApplyError {
    #[error("type mismatch at {path}: expected {expected:?}, got {actual:?}")]
    TypeMismatch {
        path: Path,
        expected: ValueType,
        actual: ValueType,
    },
    #[error("missing map key at {path}: {key}")]
    MissingKey { path: Path, key: String },
    #[error("map key already exists at {path}: {key}")]
    ExistingKey { path: Path, key: String },
    #[error("list index {index} out of bounds at {path} (len {len})")]
    IndexOutOfBounds {
        path: Path,
        index: usize,
        len: usize,
    },
    #[error("sequence operation consumes beyond the input at {path}")]
    SequenceOutOfBounds { path: Path },
    #[error("integer addition overflow at {path}")]
    IntegerOverflow { path: Path },
}

#[derive(Debug, Clone, PartialEq, Eq, Error)]
#[non_exhaustive]
pub enum ComposeError {
    #[error("incompatible sequential changes: {left} then {right}")]
    IncompatibleKinds {
        left: &'static str,
        right: &'static str,
    },
    #[error("sequential map operations are incompatible for key {0}")]
    IncompatibleMapEntry(String),
    #[error(transparent)]
    Apply(#[from] ApplyError),
}

#[derive(Debug, Clone, PartialEq, Eq, Error)]
#[non_exhaustive]
pub enum TransformError {
    #[error("changes cannot share one base value: {left} vs {right}")]
    IncompatibleKinds {
        left: &'static str,
        right: &'static str,
    },
    #[error("map entry changes cannot share one base key: {0}")]
    IncompatibleMapEntry(String),
}

#[derive(Debug, Clone, PartialEq, Eq, Error)]
#[non_exhaustive]
pub enum InvertError {
    #[error(transparent)]
    Apply(#[from] ApplyError),
}

#[derive(Debug, Clone, PartialEq, Eq, Error)]
#[non_exhaustive]
pub enum BuildError {
    #[error(transparent)]
    Apply(#[from] ApplyError),
    #[error(transparent)]
    Compose(#[from] ComposeError),
}

#[derive(Debug, Clone, PartialEq, Eq, Error)]
#[non_exhaustive]
pub enum CodecError {
    #[error("unexpected end of input at byte {offset}")]
    UnexpectedEof { offset: usize },
    #[error("unknown tag 0x{tag:02x} for {context} at byte {offset}")]
    UnknownTag {
        offset: usize,
        tag: u8,
        context: &'static str,
    },
    #[error("non-minimal varint at byte {offset}")]
    NonMinimalVarint { offset: usize },
    #[error("integer is out of range at byte {offset}")]
    IntegerOutOfRange { offset: usize },
    #[error("invalid UTF-8 at byte {offset}")]
    InvalidUtf8 { offset: usize },
    #[error("non-canonical {context} at byte {offset}: {reason}")]
    NonCanonical {
        offset: usize,
        context: &'static str,
        reason: &'static str,
    },
    #[error("trailing bytes beginning at byte {offset}")]
    TrailingBytes { offset: usize },
    #[error("resource limit exceeded: {name} ({actual} > {limit})")]
    LimitExceeded {
        name: &'static str,
        actual: usize,
        limit: usize,
    },
    #[error(transparent)]
    Value(#[from] ValueError),
}