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

use musli::{Decode, Encode};

#[derive(Debug, PartialEq, Encode, Decode)]
#[musli(name_all = "name")]
enum EmptyVariants {
    Empty,
    Tuple(),
    Struct {},
}

#[test]
fn enum_with_empty_variant() {
    musli::macros::assert_roundtrip_eq!(full, EmptyVariants::Empty, json = r#"{"Empty":{}}"#);
    musli::macros::assert_roundtrip_eq!(full, EmptyVariants::Tuple(), json = r#"{"Tuple":{}}"#);
    musli::macros::assert_roundtrip_eq!(full, EmptyVariants::Struct {}, json = r#"{"Struct":{}}"#);
}

#[derive(Debug, PartialEq, Eq, Encode, Decode)]
#[musli(name_all = "name")]
enum NamedVariants {
    #[musli(name_all = "index")]
    Variant1 { field: u32 },
    #[musli(name_all = "index")]
    Variant2 { field: u32 },
}

#[test]
fn multiple_named_variants() {
    musli::macros::assert_roundtrip_eq!(
        full,
        NamedVariants::Variant1 { field: 1 },
        json = r#"{"Variant1":{"0":1}}"#
    );

    musli::macros::assert_roundtrip_eq!(
        full,
        NamedVariants::Variant2 { field: 2 },
        json = r#"{"Variant2":{"0":2}}"#
    );
}

#[derive(Debug, PartialEq, Encode, Decode)]
pub enum UntaggedVariants {
    #[musli(packed)]
    Empty,
    #[musli(packed)]
    Tuple(u32, u32),
    #[musli(packed)]
    Struct { a: u32, b: u32 },
}

/// Enums may contain packed variants.
#[test]
fn untagged_variants() {
    musli::macros::assert_roundtrip_eq!(full, UntaggedVariants::Empty, json = r#"{"Empty":[]}"#);
    musli::macros::assert_roundtrip_eq!(
        full,
        UntaggedVariants::Tuple(42, 84),
        json = r#"{"Tuple":[42,84]}"#
    );
    musli::macros::assert_roundtrip_eq!(
        full,
        UntaggedVariants::Struct { a: 42, b: 84 },
        json = r#"{"Struct":[42,84]}"#
    );
}

#[derive(Debug, Clone, PartialEq, Encode, Decode)]
enum UntaggedSingleFields {
    #[musli(packed)]
    Variant1(String),
    #[musli(packed)]
    Variant2(f64),
    #[musli(packed)]
    Variant3(u64),
}

#[test]
fn untagged_single_field_variant() {
    musli::macros::assert_roundtrip_eq!(
        full,
        UntaggedSingleFields::Variant1(String::from("hello"))
    );
    musli::macros::assert_roundtrip_eq!(full, UntaggedSingleFields::Variant2(1.0));
    musli::macros::assert_roundtrip_eq!(full, UntaggedSingleFields::Variant3(42));
}