substrate-data 0.3.1

One data model, text syntax, binary form, packed frames and schema system — for any program's files, saves and wire messages.
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

//! A field that becomes optional, or stops being.

use substrate_data::Schema;

use crate::verdict::Group::Options;
use crate::verdict::{Row, row};

/// Every row of this group.
pub(crate) const ROWS: &[fn() -> Row] = &[
    required_to_option,
    option_to_required_some,
    option_to_required_none,
    text_to_option,
];

#[derive(Schema, Debug, PartialEq)]
struct Needed {
    v: u32,
    after: u8,
}

#[derive(Schema, Debug, PartialEq)]
struct Maybe {
    v: Option<u32>,
    after: u8,
}

fn required_to_option() -> Row {
    row(
        Options,
        "`u32` to `Option<u32>`",
        (
            Needed { v: 7, after: 5 },
            Some(Maybe {
                v: Some(7),
                after: 5,
            }),
        ),
        (
            Maybe {
                v: Some(7),
                after: 5,
            },
            Some(Needed { v: 7, after: 5 }),
        ),
    )
}

fn option_to_required_some() -> Row {
    row(
        Options,
        "`Option<u32>` to `u32`, the old value `Some`",
        (
            Maybe {
                v: Some(7),
                after: 5,
            },
            Some(Needed { v: 7, after: 5 }),
        ),
        (
            Needed { v: 7, after: 5 },
            Some(Maybe {
                v: Some(7),
                after: 5,
            }),
        ),
    )
}

fn option_to_required_none() -> Row {
    row(
        Options,
        "`Option<u32>` to `u32`, the old value `None`",
        (Maybe { v: None, after: 5 }, None),
        (
            Needed { v: 7, after: 5 },
            Some(Maybe {
                v: Some(7),
                after: 5,
            }),
        ),
    )
}

#[derive(Schema, Debug, PartialEq)]
struct Text {
    v: String,
    after: u8,
}

#[derive(Schema, Debug, PartialEq)]
struct MaybeText {
    v: Option<String>,
    after: u8,
}

fn text_to_option() -> Row {
    row(
        Options,
        "`String` to `Option<String>`",
        (
            Text {
                v: "s".into(),
                after: 5,
            },
            Some(MaybeText {
                v: Some("s".into()),
                after: 5,
            }),
        ),
        (
            MaybeText {
                v: Some("s".into()),
                after: 5,
            },
            Some(Text {
                v: "s".into(),
                after: 5,
            }),
        ),
    )
}