zerialize 0.0.1

Zero-copy serialization
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

use crate::Month::{February, March, May};
use zerialize::*;

#[zerializable]
trait Person {
    #[n(0)]
    fn name(&self) -> &str;

    #[n(1)]
    fn children(&self) -> impl List<Item = impl Person + '_> + '_
    where
        Self: Sized;

    #[n(2)]
    fn date_of_birth(&self) -> DateOfBirth;
}

#[derive(Zerializable, Copy, Clone, PartialEq, Eq, Debug)]
enum Month {
    #[variant(0)]
    January,
    #[variant(1)]
    February,
    #[variant(2)]
    March,
    #[variant(3)]
    April,
    #[variant(4)]
    May,
    #[variant(5)]
    June,
    #[variant(6)]
    July,
    #[variant(7)]
    August,
    #[variant(8)]
    September,
    #[variant(9)]
    October,
    #[variant(10)]
    November,
    #[variant(11)]
    December,
}

#[derive(Zerializable, Copy, Clone, PartialEq, Eq, Debug)]
struct DateOfBirth {
    #[n(0)]
    day: u8,
    #[n(1)]
    month: Month,
    #[n(2)]
    year: u16,
}

struct SimplePerson {
    name: String,
    children: OwnedList<SimplePerson>,
    date_of_birth: DateOfBirth,
}

impl Person for SimplePerson {
    fn name(&self) -> &str {
        &self.name
    }

    fn children(&self) -> impl List<Item = impl Person + '_> + '_
    where
        Self: Sized,
    {
        &self.children
    }

    fn date_of_birth(&self) -> DateOfBirth {
        self.date_of_birth
    }
}

fn assert_eq_person<T1: Person, T2: Person>(p1: &T1, p2: &T2) {
    assert_eq!(p1.name(), p2.name());
    assert_eq!(p1.date_of_birth(), p2.date_of_birth());
    assert_eq!(p1.children().len(), p2.children().len());
    for i in 0..p1.children().len() {
        let child1 = p1.children().get(i).unwrap();
        let child2 = p2.children().get(i).unwrap();
        assert_eq!(child1.name(), child2.name());
        assert_eq!(child1.date_of_birth(), child2.date_of_birth());
        assert!(child1.children().is_empty());
        assert!(child2.children().is_empty());
    }
}

fn main() {
    let jimmy = SimplePerson {
        name: "Jimmy".to_string(),
        children: vec![].into(),
        date_of_birth: DateOfBirth {
            day: 1,
            month: February,
            year: 2020,
        },
    };
    let person = SimplePerson {
        name: "John".to_string(),
        children: vec![jimmy].into(),
        date_of_birth: DateOfBirth {
            day: 10,
            month: May,
            year: 1990,
        },
    };

    let encoded = encode::<dyn Person>(&person);
    let round_trip = decode::<dyn Person>(&encoded).unwrap();
    assert_eq_person(&person, &round_trip);

    // Encoding into a buffer of one's own appends to it, so a single
    // allocation may carry several messages, or be cleared and reused for the
    // next one. Each message is decoded from exactly the range it was written
    // to.
    let alice = SimplePerson {
        name: "Alice".to_string(),
        children: vec![].into(),
        date_of_birth: DateOfBirth {
            day: 3,
            month: March,
            year: 1985,
        },
    };

    let mut buffer = Vec::new();
    let first = encode_in::<dyn Person>(&person, &mut buffer);
    let second = encode_in::<dyn Person>(&alice, &mut buffer);
    assert_eq!(&buffer[first.clone()], encoded.as_slice());

    assert_eq_person(&person, &decode::<dyn Person>(&buffer[first]).unwrap());
    assert_eq_person(&alice, &decode::<dyn Person>(&buffer[second]).unwrap());
}