lorosurgeon 0.2.1

Derive macros for bidirectional serialization between Rust types and Loro CRDT containers
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
134
135
136
137
138
139
140
141
142
143

//! Reconcile implementations for built-in types.

use crate::error::ReconcileError;
use crate::reconcile::{LoadKey, NoKey, Reconcile, Reconciler};

// ── Boolean ─────────────────────────────────────────────────────────────

impl Reconcile for bool {
    type Key = NoKey;
    fn reconcile<R: Reconciler>(&self, r: R) -> Result<(), ReconcileError> {
        r.boolean(*self)
    }
}

// ── Signed integers ─────────────────────────────────────────────────────

macro_rules! impl_reconcile_int {
    ($($t:ty),*) => {
        $(
            impl Reconcile for $t {
                type Key = NoKey;
                fn reconcile<R: Reconciler>(&self, r: R) -> Result<(), ReconcileError> {
                    r.i64(*self as i64)
                }
            }
        )*
    };
}

impl_reconcile_int!(i8, i16, i32, i64, u8, u16, u32, u64, usize);

// ── Floating point ──────────────────────────────────────────────────────

impl Reconcile for f64 {
    type Key = NoKey;
    fn reconcile<R: Reconciler>(&self, r: R) -> Result<(), ReconcileError> {
        r.f64(*self)
    }
}

impl Reconcile for f32 {
    type Key = NoKey;
    fn reconcile<R: Reconciler>(&self, r: R) -> Result<(), ReconcileError> {
        r.f64(*self as f64)
    }
}

// ── String ──────────────────────────────────────────────────────────────

impl Reconcile for String {
    type Key = NoKey;
    fn reconcile<R: Reconciler>(&self, r: R) -> Result<(), ReconcileError> {
        r.str(self)
    }
}

// ── Vec<u8> (Binary) ────────────────────────────────────────────────────

impl Reconcile for Vec<u8> {
    type Key = NoKey;
    fn reconcile<R: Reconciler>(&self, r: R) -> Result<(), ReconcileError> {
        r.bytes(self)
    }
}

// ── Option<T> ───────────────────────────────────────────────────────────

impl<T: Reconcile> Reconcile for Option<T> {
    type Key = NoKey;
    fn reconcile<R: Reconciler>(&self, r: R) -> Result<(), ReconcileError> {
        match self {
            None => r.null(),
            Some(v) => v.reconcile(r),
        }
    }
}

// ── serde_json::Value ───────────────────────────────────────────────────

impl Reconcile for serde_json::Value {
    type Key = NoKey;
    fn reconcile<R: Reconciler>(&self, r: R) -> Result<(), ReconcileError> {
        let s = serde_json::to_string(self)?;
        r.str(&s)
    }
}

// ── &str ──────────────────────────────────────────────────────────────

impl Reconcile for &str {
    type Key = NoKey;
    fn reconcile<R: Reconciler>(&self, r: R) -> Result<(), ReconcileError> {
        r.str(self)
    }
}

// ── &[T] ──────────────────────────────────────────────────────────────

impl<T: Reconcile> Reconcile for &[T] {
    type Key = NoKey;
    fn reconcile<R: Reconciler>(&self, r: R) -> Result<(), ReconcileError> {
        super::list::reconcile_vec_simple(self, r)
    }
}

// ── Box<T> ────────────────────────────────────────────────────────────

impl<T: Reconcile> Reconcile for Box<T> {
    type Key = T::Key;
    fn reconcile<R: Reconciler>(&self, r: R) -> Result<(), ReconcileError> {
        (**self).reconcile(r)
    }

    fn key(&self) -> LoadKey<Self::Key> {
        (**self).key()
    }
}

// ── Cow<'a, T> ────────────────────────────────────────────────────────

impl<'a, T: Reconcile + Clone + 'a> Reconcile for std::borrow::Cow<'a, T> {
    type Key = T::Key;
    fn reconcile<R: Reconciler>(&self, r: R) -> Result<(), ReconcileError> {
        self.as_ref().reconcile(r)
    }

    fn key(&self) -> LoadKey<Self::Key> {
        self.as_ref().key()
    }
}

// ── Reconcile for &T ────────────────────────────────────────────────────

impl<'b, T: Reconcile + 'b> Reconcile for &'b T {
    type Key = T::Key;
    fn reconcile<R: Reconciler>(&self, r: R) -> Result<(), ReconcileError> {
        (*self).reconcile(r)
    }

    fn key(&self) -> LoadKey<Self::Key> {
        (*self).key()
    }
}