icydb_core/traits/
view.rs

1use crate::view::{ListPatch, MapPatch, SetPatch};
2use candid::CandidType;
3use std::{
4    collections::{
5        BTreeMap, BTreeSet, HashMap, HashSet, btree_map::Entry as BTreeMapEntry,
6        hash_map::Entry as HashMapEntry,
7    },
8    hash::{BuildHasher, Hash},
9    iter::IntoIterator,
10};
11
12///
13/// AsView
14///
15/// Recursive for all field/value nodes
16/// `from_view` is infallible; view values are treated as canonical.
17///
18
19pub trait AsView: Sized {
20    type ViewType: Default;
21
22    fn as_view(&self) -> Self::ViewType;
23    fn from_view(view: Self::ViewType) -> Self;
24}
25
26impl AsView for () {
27    type ViewType = Self;
28
29    fn as_view(&self) -> Self::ViewType {}
30
31    fn from_view((): Self::ViewType) -> Self {}
32}
33
34impl AsView for String {
35    type ViewType = Self;
36
37    fn as_view(&self) -> Self::ViewType {
38        self.clone()
39    }
40
41    fn from_view(view: Self::ViewType) -> Self {
42        view
43    }
44}
45
46// Make Box<T> *not* appear in the view type
47impl<T: AsView> AsView for Box<T> {
48    type ViewType = T::ViewType;
49
50    fn as_view(&self) -> Self::ViewType {
51        // Delegate to inner value
52        T::as_view(self.as_ref())
53    }
54
55    fn from_view(view: Self::ViewType) -> Self {
56        // Re-box after reconstructing inner
57        Self::new(T::from_view(view))
58    }
59}
60
61impl<T: AsView> AsView for Option<T> {
62    type ViewType = Option<T::ViewType>;
63
64    fn as_view(&self) -> Self::ViewType {
65        self.as_ref().map(AsView::as_view)
66    }
67
68    fn from_view(view: Self::ViewType) -> Self {
69        view.map(T::from_view)
70    }
71}
72
73impl<T: AsView> AsView for Vec<T> {
74    type ViewType = Vec<T::ViewType>;
75
76    fn as_view(&self) -> Self::ViewType {
77        self.iter().map(AsView::as_view).collect()
78    }
79
80    fn from_view(view: Self::ViewType) -> Self {
81        view.into_iter().map(T::from_view).collect()
82    }
83}
84
85impl<T, S> AsView for HashSet<T, S>
86where
87    T: AsView + Eq + Hash + Clone,
88    S: BuildHasher + Default,
89{
90    type ViewType = Vec<T::ViewType>;
91
92    fn as_view(&self) -> Self::ViewType {
93        self.iter().map(AsView::as_view).collect()
94    }
95
96    fn from_view(view: Self::ViewType) -> Self {
97        view.into_iter().map(T::from_view).collect()
98    }
99}
100
101impl<K, V, S> AsView for HashMap<K, V, S>
102where
103    K: AsView + Eq + Hash + Clone,
104    V: AsView,
105    S: BuildHasher + Default,
106{
107    type ViewType = Vec<(K::ViewType, V::ViewType)>;
108
109    fn as_view(&self) -> Self::ViewType {
110        self.iter()
111            .map(|(k, v)| (k.as_view(), v.as_view()))
112            .collect()
113    }
114
115    fn from_view(view: Self::ViewType) -> Self {
116        view.into_iter()
117            .map(|(k, v)| (K::from_view(k), V::from_view(v)))
118            .collect()
119    }
120}
121
122impl<T> AsView for BTreeSet<T>
123where
124    T: AsView + Ord + Clone,
125{
126    type ViewType = Vec<T::ViewType>;
127
128    fn as_view(&self) -> Self::ViewType {
129        self.iter().map(AsView::as_view).collect()
130    }
131
132    fn from_view(view: Self::ViewType) -> Self {
133        view.into_iter().map(T::from_view).collect()
134    }
135}
136
137impl<K, V> AsView for BTreeMap<K, V>
138where
139    K: AsView + Ord + Clone,
140    V: AsView,
141{
142    type ViewType = Vec<(K::ViewType, V::ViewType)>;
143
144    fn as_view(&self) -> Self::ViewType {
145        self.iter()
146            .map(|(k, v)| (k.as_view(), v.as_view()))
147            .collect()
148    }
149
150    fn from_view(view: Self::ViewType) -> Self {
151        view.into_iter()
152            .map(|(k, v)| (K::from_view(k), V::from_view(v)))
153            .collect()
154    }
155}
156
157#[macro_export]
158macro_rules! impl_view {
159    ($($type:ty),*) => {
160        $(
161            impl AsView for $type {
162                type ViewType = Self;
163
164                fn as_view(&self) -> Self::ViewType {
165                    *self
166                }
167
168                fn from_view(view: Self::ViewType) -> Self {
169                    view
170                }
171            }
172        )*
173    };
174}
175
176impl_view!(bool, i8, i16, i32, i64, u8, u16, u32, u64);
177
178impl AsView for f32 {
179    type ViewType = Self;
180
181    fn as_view(&self) -> Self::ViewType {
182        *self
183    }
184
185    fn from_view(view: Self::ViewType) -> Self {
186        if view.is_finite() {
187            if view == 0.0 { 0.0 } else { view }
188        } else {
189            0.0
190        }
191    }
192}
193
194impl AsView for f64 {
195    type ViewType = Self;
196
197    fn as_view(&self) -> Self::ViewType {
198        *self
199    }
200
201    fn from_view(view: Self::ViewType) -> Self {
202        if view.is_finite() {
203            if view == 0.0 { 0.0 } else { view }
204        } else {
205            0.0
206        }
207    }
208}
209
210///
211/// CreateView
212///
213
214pub trait CreateView: AsView {
215    /// Payload accepted when creating this value.
216    ///
217    /// This is often equal to ViewType, but may differ
218    /// (e.g. Option<T>, defaults, omissions).
219    type CreateViewType: CandidType + Default;
220
221    fn from_create_view(view: Self::CreateViewType) -> Self;
222}
223
224///
225/// UpdateView
226///
227
228pub trait UpdateView: AsView {
229    /// Payload accepted when updating this value.
230    type UpdateViewType: CandidType + Default;
231
232    /// Merge the update payload into self.
233    fn merge(&mut self, _update: Self::UpdateViewType) {}
234}
235
236impl<T> UpdateView for Option<T>
237where
238    T: UpdateView + Default,
239{
240    type UpdateViewType = Option<T::UpdateViewType>;
241
242    fn merge(&mut self, update: Self::UpdateViewType) {
243        match update {
244            None => {
245                // Field was provided (outer Some), inner None means explicit delete
246                *self = None;
247            }
248            Some(inner_update) => {
249                if let Some(inner_value) = self.as_mut() {
250                    inner_value.merge(inner_update);
251                } else {
252                    let mut new_value = T::default();
253                    new_value.merge(inner_update);
254                    *self = Some(new_value);
255                }
256            }
257        }
258    }
259}
260
261impl<T> UpdateView for Vec<T>
262where
263    T: UpdateView + Default,
264{
265    // Payload is T::UpdateViewType, which *is* CandidType
266    type UpdateViewType = Vec<ListPatch<T::UpdateViewType>>;
267
268    fn merge(&mut self, patches: Self::UpdateViewType) {
269        for patch in patches {
270            match patch {
271                ListPatch::Update { index, patch } => {
272                    if let Some(elem) = self.get_mut(index) {
273                        elem.merge(patch);
274                    }
275                }
276                ListPatch::Insert { index, value } => {
277                    let mut elem = T::default();
278                    elem.merge(value);
279                    let idx = index.min(self.len());
280                    self.insert(idx, elem);
281                }
282                ListPatch::Push { value } => {
283                    let mut elem = T::default();
284                    elem.merge(value);
285                    self.push(elem);
286                }
287                ListPatch::Overwrite { values } => {
288                    self.clear();
289                    self.reserve(values.len());
290
291                    for value in values {
292                        let mut elem = T::default();
293                        elem.merge(value);
294                        self.push(elem);
295                    }
296                }
297                ListPatch::Remove { index } => {
298                    if index < self.len() {
299                        self.remove(index);
300                    }
301                }
302                ListPatch::Clear => self.clear(),
303            }
304        }
305    }
306}
307
308impl<T, S> UpdateView for HashSet<T, S>
309where
310    T: UpdateView + Clone + Default + Eq + Hash,
311    S: BuildHasher + Default,
312{
313    type UpdateViewType = Vec<SetPatch<T::UpdateViewType>>;
314
315    fn merge(&mut self, patches: Self::UpdateViewType) {
316        for patch in patches {
317            match patch {
318                SetPatch::Insert(value) => {
319                    let mut elem = T::default();
320                    elem.merge(value);
321                    self.insert(elem);
322                }
323                SetPatch::Remove(value) => {
324                    let mut elem = T::default();
325                    elem.merge(value);
326                    self.remove(&elem);
327                }
328                SetPatch::Overwrite { values } => {
329                    self.clear();
330
331                    for value in values {
332                        let mut elem = T::default();
333                        elem.merge(value);
334                        self.insert(elem);
335                    }
336                }
337                SetPatch::Clear => self.clear(),
338            }
339        }
340    }
341}
342
343impl<K, V, S> UpdateView for HashMap<K, V, S>
344where
345    K: UpdateView + Clone + Default + Eq + Hash,
346    V: UpdateView + Default,
347    S: BuildHasher + Default,
348{
349    type UpdateViewType = Vec<MapPatch<K::UpdateViewType, V::UpdateViewType>>;
350
351    fn merge(&mut self, patches: Self::UpdateViewType) {
352        for patch in patches {
353            match patch {
354                MapPatch::Upsert { key, value } => {
355                    let mut key_value = K::default();
356                    key_value.merge(key);
357
358                    match self.entry(key_value) {
359                        HashMapEntry::Occupied(mut slot) => {
360                            slot.get_mut().merge(value);
361                        }
362                        HashMapEntry::Vacant(slot) => {
363                            let mut value_value = V::default();
364                            value_value.merge(value);
365                            slot.insert(value_value);
366                        }
367                    }
368                }
369                MapPatch::Remove { key } => {
370                    let mut key_value = K::default();
371                    key_value.merge(key);
372                    self.remove(&key_value);
373                }
374                MapPatch::Overwrite { entries } => {
375                    self.clear();
376                    self.reserve(entries.len());
377
378                    for (key, value) in entries {
379                        let mut key_value = K::default();
380                        key_value.merge(key);
381
382                        let mut value_value = V::default();
383                        value_value.merge(value);
384                        self.insert(key_value, value_value);
385                    }
386                }
387                MapPatch::Clear => self.clear(),
388            }
389        }
390    }
391}
392
393impl<T> UpdateView for BTreeSet<T>
394where
395    T: UpdateView + Clone + Default + Ord,
396{
397    type UpdateViewType = Vec<SetPatch<T::UpdateViewType>>;
398
399    fn merge(&mut self, patches: Self::UpdateViewType) {
400        for patch in patches {
401            match patch {
402                SetPatch::Insert(value) => {
403                    let mut elem = T::default();
404                    elem.merge(value);
405                    self.insert(elem);
406                }
407                SetPatch::Remove(value) => {
408                    let mut elem = T::default();
409                    elem.merge(value);
410                    self.remove(&elem);
411                }
412                SetPatch::Overwrite { values } => {
413                    self.clear();
414
415                    for value in values {
416                        let mut elem = T::default();
417                        elem.merge(value);
418                        self.insert(elem);
419                    }
420                }
421                SetPatch::Clear => self.clear(),
422            }
423        }
424    }
425}
426
427impl<K, V> UpdateView for BTreeMap<K, V>
428where
429    K: UpdateView + Clone + Default + Ord,
430    V: UpdateView + Default,
431{
432    type UpdateViewType = Vec<MapPatch<K::UpdateViewType, V::UpdateViewType>>;
433
434    fn merge(&mut self, patches: Self::UpdateViewType) {
435        for patch in patches {
436            match patch {
437                MapPatch::Upsert { key, value } => {
438                    let mut key_value = K::default();
439                    key_value.merge(key);
440
441                    match self.entry(key_value) {
442                        BTreeMapEntry::Occupied(mut slot) => {
443                            slot.get_mut().merge(value);
444                        }
445                        BTreeMapEntry::Vacant(slot) => {
446                            let mut value_value = V::default();
447                            value_value.merge(value);
448                            slot.insert(value_value);
449                        }
450                    }
451                }
452                MapPatch::Remove { key } => {
453                    let mut key_value = K::default();
454                    key_value.merge(key);
455                    self.remove(&key_value);
456                }
457                MapPatch::Overwrite { entries } => {
458                    self.clear();
459
460                    for (key, value) in entries {
461                        let mut key_value = K::default();
462                        key_value.merge(key);
463
464                        let mut value_value = V::default();
465                        value_value.merge(value);
466                        self.insert(key_value, value_value);
467                    }
468                }
469                MapPatch::Clear => self.clear(),
470            }
471        }
472    }
473}
474
475macro_rules! impl_update_view {
476    ($($type:ty),*) => {
477        $(
478            impl UpdateView for $type {
479                type UpdateViewType = Self;
480
481                fn merge(&mut self, update: Self::UpdateViewType) {
482                    *self = update;
483                }
484            }
485        )*
486    };
487}
488
489impl_update_view!(bool, i8, i16, i32, i64, u8, u16, u32, u64, String);
icydb_core/traits/view.rs

icydb_core/traits/
view.rs
