musli 0.0.149

Müsli is a flexible and efficient serialization framework.
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

#![cfg(feature = "test")]

use musli::{Decode, Encode};

#[derive(Debug, PartialEq, Encode, Decode)]
struct Inner {
    a: u32,
    b: u32,
}

#[derive(Debug, PartialEq, Encode, Decode)]
struct StructSkipped {
    #[musli(skip)]
    skip: u32,
    #[musli(skip, default = skip_default)]
    skip_default: u32,
    #[musli(skip, default = skip_complex_field)]
    complex_field: Option<Inner>,
}

#[derive(Debug, PartialEq, Encode, Decode)]
struct TupleSkipped(
    #[musli(skip)] u32,
    #[musli(skip, default = skip_default)] u32,
    #[musli(skip, default = skip_complex_field)] Option<Inner>,
);

#[derive(Debug, PartialEq, Encode, Decode)]
enum EnumSkipped {
    Struct {
        #[musli(skip)]
        skip: u32,
        #[musli(skip, default = skip_default)]
        skip_default: u32,
        #[musli(skip, default = skip_complex_field)]
        complex_field: Option<Inner>,
    },
    Tuple(
        #[musli(skip)] u32,
        #[musli(skip, default = skip_default)] u32,
        #[musli(skip, default = skip_complex_field)] Option<Inner>,
    ),
}

fn skip_default() -> u32 {
    42
}

fn skip_complex_field() -> Option<Inner> {
    Some(Inner { a: 1, b: 2 })
}

#[test]
fn skip() {
    musli::macros::assert_roundtrip_eq!(
        full,
        StructSkipped {
            skip: 0,
            skip_default: 42,
            complex_field: Some(Inner { a: 1, b: 2 }),
        },
        json = r#"{}"#,
    );

    musli::macros::assert_decode_eq!(
        full,
        StructSkipped {
            skip: 10,
            skip_default: 52,
            complex_field: Some(Inner { a: 3, b: 4 }),
        },
        StructSkipped {
            skip: 0,
            skip_default: 42,
            complex_field: Some(Inner { a: 1, b: 2 }),
        },
        json = r#"{}"#,
    );

    musli::macros::assert_decode_eq!(
        full,
        EnumSkipped::Struct {
            skip: 10,
            skip_default: 52,
            complex_field: Some(Inner { a: 3, b: 4 }),
        },
        EnumSkipped::Struct {
            skip: 0,
            skip_default: 42,
            complex_field: Some(Inner { a: 1, b: 2 }),
        },
        json = r#"{"Struct":{}}"#,
    );

    musli::macros::assert_roundtrip_eq!(
        full,
        TupleSkipped(0, 42, Some(Inner { a: 1, b: 2 }),),
        json = r#"{}"#,
    );

    musli::macros::assert_decode_eq!(
        full,
        TupleSkipped(10, 52, Some(Inner { a: 3, b: 4 }),),
        TupleSkipped(0, 42, Some(Inner { a: 1, b: 2 }),),
        json = r#"{}"#,
    );

    musli::macros::assert_decode_eq!(
        full,
        EnumSkipped::Tuple(10, 52, Some(Inner { a: 3, b: 4 }),),
        EnumSkipped::Tuple(0, 42, Some(Inner { a: 1, b: 2 }),),
        json = r#"{"Tuple":{}}"#,
    );
}