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

use std::convert::Infallible;

/// Represents an error which occurred when splicing.
///
/// When splicing values into existing column storage there are two kinds of errors which can
/// occur, those caused by iterating over the existing items, and those caused by iterating over
/// the replacement items.
#[derive(Debug)]
pub(crate) enum SpliceError<E, R> {
    /// There was an error reading from the existing column storage
    ReadExisting(E),
    /// There was an error reading from the iterator of new rows
    ReadReplace(R),
}

impl<E> SpliceError<E, Infallible> {
    /// Map a spliceerror which is infallible in it's `Replace` error type into a different error.
    ///
    /// This is used when you have performed a splice with a `replace` iterator which is
    /// infallible and need to return a more general `SpliceError`
    pub(crate) fn existing<R>(self) -> SpliceError<E, R> {
        match self {
            SpliceError::ReadExisting(e) => SpliceError::ReadExisting(e),
            SpliceError::ReadReplace(_) => unreachable!("absurd"),
        }
    }
}

impl<E, R> std::error::Error for SpliceError<E, R>
where
    E: std::error::Error,
    R: std::error::Error,
{
}

impl<E, R> std::fmt::Display for SpliceError<E, R>
where
    E: std::fmt::Display,
    R: std::fmt::Display,
{
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::ReadExisting(e) => write!(f, "error reading from existing rows: {}", e),
            Self::ReadReplace(e) => write!(f, "error reading from replacement rows: {}", e),
        }
    }
}