dson 0.3.0

A delta-state CRDT implementation
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

// (c) Copyright 2025 Helsing GmbH. All rights reserved.
use crate::{
    CausalContext, CausalDotStore, ExtensionType, Identifier, MvReg, OrArray, OrMap,
    crdts::{
        TypeVariantValue, Value,
        snapshot::{self, ToValue},
    },
};
use std::{borrow::Borrow, fmt, hash::Hash};

/// Returns the values of this map without collapsing conflicts.
pub fn values<K, C>(
    m: &OrMap<K, C>,
) -> snapshot::OrMap<'_, K, snapshot::AllValues<'_, C::ValueRef<'_>>>
where
    K: Hash + Eq + fmt::Display,
    C: ExtensionType,
{
    m.values()
}

/// Returns the values of this map assuming (and asserting) no conflicts on element values.
// NOTE: A type alias won't help much here :melt:.
#[allow(clippy::type_complexity)]
pub fn value<K, C>(
    m: &OrMap<K, C>,
) -> Result<
    snapshot::OrMap<'_, K, snapshot::CollapsedValue<'_, C::ValueRef<'_>>>,
    Box<snapshot::SingleValueError<<&OrMap<K, C> as ToValue>::LeafValue>>,
>
where
    K: Hash + Eq + fmt::Debug + fmt::Display + Clone,
    C: ExtensionType,
{
    m.value()
}

/// Creates a new map.
pub fn create<K, C>()
-> impl Fn(&OrMap<K, C>, &CausalContext, Identifier) -> CausalDotStore<OrMap<K, C>>
where
    K: Hash + Eq + fmt::Debug + Clone,
    C: ExtensionType,
{
    move |m, cc, id| m.create(cc, id)
}

/// Applies a function to the value at the given key.
pub fn apply<K, C, O>(
    o: O,
    k: K,
) -> impl FnOnce(&OrMap<K, C>, &CausalContext, Identifier) -> CausalDotStore<OrMap<K, C>>
where
    K: Hash + Eq + fmt::Debug + Clone,
    O: FnOnce(&TypeVariantValue<C>, &CausalContext, Identifier) -> CausalDotStore<Value<C>>,
    C: ExtensionType,
{
    move |m, cc, id| m.apply(o, k.clone(), cc, id)
}

/// Applies a function to the map at the given key.
pub fn apply_to_map<K, C, O>(
    o: O,
    k: K,
) -> impl FnOnce(&OrMap<K, C>, &CausalContext, Identifier) -> CausalDotStore<OrMap<K, C>>
where
    K: Hash + Eq + fmt::Debug + Clone,
    O: FnOnce(&OrMap<String, C>, &CausalContext, Identifier) -> CausalDotStore<OrMap<String, C>>,
    C: ExtensionType,
{
    move |m, cc, id| m.apply_to_map(o, k.clone(), cc, id)
}

/// Applies a function to the array at the given key.
pub fn apply_to_array<K, C, O>(
    o: O,
    k: K,
) -> impl FnOnce(&OrMap<K, C>, &CausalContext, Identifier) -> CausalDotStore<OrMap<K, C>>
where
    K: Hash + Eq + fmt::Debug + Clone,
    O: FnOnce(&OrArray<C>, &CausalContext, Identifier) -> CausalDotStore<OrArray<C>>,
    C: ExtensionType,
{
    move |m, cc, id| m.apply_to_array(o, k.clone(), cc, id)
}

/// Applies a function to the register at the given key.
pub fn apply_to_register<K, C, O>(
    o: O,
    k: K,
) -> impl FnOnce(&OrMap<K, C>, &CausalContext, Identifier) -> CausalDotStore<OrMap<K, C>>
where
    K: Hash + Eq + fmt::Debug + Clone,
    O: FnOnce(&MvReg, &CausalContext, Identifier) -> CausalDotStore<MvReg>,
    C: ExtensionType,
{
    move |m, cc, id| m.apply_to_register(o, k.clone(), cc, id)
}

/// Removes a key from the map.
pub fn remove<Q, K, C>(
    k: &Q,
) -> impl Fn(&OrMap<K, C>, &CausalContext, Identifier) -> CausalDotStore<OrMap<K, C>> + '_
where
    K: Hash + Eq + fmt::Debug + Clone + Borrow<Q>,
    Q: Hash + Eq + ?Sized,
    C: ExtensionType,
{
    move |m, cc, id| m.remove(k, cc, id)
}

/// Clears the map.
pub fn clear<K, C>()
-> impl Fn(&OrMap<K, C>, &CausalContext, Identifier) -> CausalDotStore<OrMap<K, C>>
where
    K: Hash + Eq + fmt::Debug + Clone,
    C: ExtensionType,
{
    move |m, cc, id| m.clear(cc, id)
}