automorph 0.2.0

Derive macros for bidirectional Automerge-Rust struct synchronization
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

//! Implementations for marker types.
//!
//! This module provides implementations for:
//! - `PhantomData<T>` - Zero-sized marker type

use std::marker::PhantomData;

use automerge::{ChangeHash, ObjId, Prop, ReadDoc, transaction::Transactable};

use crate::{Automorph, PrimitiveChanged, Result, ScalarCursor};

// PhantomData<T> is zero-sized and stores nothing
// We store it as unit () for consistency
impl<T> Automorph for PhantomData<T> {
    type Changes = PrimitiveChanged;
    type Cursor = ScalarCursor;

    fn save<D: Transactable + ReadDoc>(
        &self,
        doc: &mut D,
        obj: impl AsRef<ObjId>,
        prop: impl Into<Prop>,
    ) -> Result<()> {
        ().save(doc, obj, prop)
    }

    fn load<D: ReadDoc>(doc: &D, obj: impl AsRef<ObjId>, prop: impl Into<Prop>) -> Result<Self> {
        <()>::load(doc, obj, prop)?;
        Ok(PhantomData)
    }

    fn load_at<D: ReadDoc>(
        doc: &D,
        obj: impl AsRef<ObjId>,
        prop: impl Into<Prop>,
        heads: &[ChangeHash],
    ) -> Result<Self> {
        <()>::load_at(doc, obj, prop, heads)?;
        Ok(PhantomData)
    }

    fn diff<D: ReadDoc>(
        &self,
        doc: &D,
        obj: impl AsRef<ObjId>,
        prop: impl Into<Prop>,
    ) -> Result<Self::Changes> {
        ().diff(doc, obj, prop)
    }

    fn diff_at<D: ReadDoc>(
        &self,
        doc: &D,
        obj: impl AsRef<ObjId>,
        prop: impl Into<Prop>,
        heads: &[ChangeHash],
    ) -> Result<Self::Changes> {
        ().diff_at(doc, obj, prop, heads)
    }

    fn update<D: ReadDoc>(
        &mut self,
        doc: &D,
        obj: impl AsRef<ObjId>,
        prop: impl Into<Prop>,
    ) -> Result<Self::Changes> {
        // PhantomData is zero-sized, nothing to update
        ().diff(doc, obj, prop)
    }

    fn update_at<D: ReadDoc>(
        &mut self,
        doc: &D,
        obj: impl AsRef<ObjId>,
        prop: impl Into<Prop>,
        heads: &[ChangeHash],
    ) -> Result<Self::Changes> {
        // PhantomData is zero-sized, nothing to update
        ().diff_at(doc, obj, prop, heads)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use automerge::{AutoCommit, ROOT};

    #[test]
    fn test_phantom_data() {
        let mut doc = AutoCommit::new();

        let phantom: PhantomData<String> = PhantomData;
        phantom.save(&mut doc, &ROOT, "phantom").unwrap();

        let restored: PhantomData<String> = PhantomData::load(&doc, &ROOT, "phantom").unwrap();
        assert_eq!(restored, PhantomData);
    }
}