merde 10.0.7

Serialize and deserialize with declarative macros
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

use merde::CowStr;

fn main() {
    let events = vec![
        ExampleEvent::MouseUp(MouseUp { x: 10, y: 20 }),
        ExampleEvent::MouseDown(MouseDown { x: 30, y: 40 }),
        ExampleEvent::TextInput(TextInput {
            text: "Hello".into(),
        }),
        ExampleEvent::StringStuff(StringStuff("Some string".into())),
        ExampleEvent::Emergency(Box::new(Emergency::NoPizzaLeft)),
    ];

    for event in events {
        let json = merde::json::to_string(&event).unwrap();
        println!("JSON: {}", json);
        let deserialized: ExampleEvent = merde::json::from_str(&json).unwrap();
        println!("Deserialized: {:?}", deserialized);
        assert_eq!(event, deserialized);
    }

    println!("All events successfully round-tripped through JSON!");
}

#[derive(Debug, PartialEq, Eq)]
enum ExampleEvent<'s> {
    MouseUp(MouseUp),
    MouseDown(MouseDown),
    TextInput(TextInput<'s>),
    StringStuff(StringStuff<'s>),
    Emergency(Box<Emergency>),
}

merde::derive! {
    impl (Serialize, Deserialize) for enum ExampleEvent<'s>
    externally_tagged {
        "mouseup" => MouseUp,
        "mousedown" => MouseDown,
        "textinput" => TextInput,
        "stringstuff" => StringStuff,
        "emergency" => Emergency,
    }
}

#[derive(Debug, PartialEq, Eq)]
struct MouseUp {
    x: i32,
    y: i32,
}

merde::derive! {
    impl (Serialize, Deserialize) for struct MouseUp {
        x,
        y
    }
}

#[derive(Debug, PartialEq, Eq)]
struct MouseDown {
    x: i32,
    y: i32,
}

merde::derive! {
    impl (Serialize, Deserialize) for struct MouseDown {
        x,
        y
    }
}

#[derive(Debug, PartialEq, Eq)]
struct TextInput<'s> {
    text: CowStr<'s>,
}

merde::derive! { impl (Serialize, Deserialize) for struct TextInput<'s> { text } }

#[derive(Debug, PartialEq, Eq)]
struct StringStuff<'s>(CowStr<'s>);

merde::derive! {
    impl (Serialize, Deserialize) for struct StringStuff<'s> transparent
}

#[derive(Debug, PartialEq, Eq)]
enum Emergency {
    NoPizzaLeft,
    CuddlesRequired,
    SmoothieReady,
}

merde::derive! {
    impl (Serialize, Deserialize) for enum Emergency string_like {
        "nopizza" => NoPizzaLeft,
        "cuddles" => CuddlesRequired,
        "smoothie" => SmoothieReady,
    }
}