hash-value 1.0.1

A hashable, JSON-like, serde Value type.
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
139
140
141
142
143
144
145
146

use std::collections::HashMap;

use serde::{Deserialize, Serialize};

use crate::Value;

#[derive(Serialize, Deserialize, Debug, PartialEq)]
enum EnumUnit {
    X,
}

#[derive(Serialize, Deserialize, Debug, PartialEq)]
enum EnumNewType {
    N(u64),
}

#[derive(Serialize, Deserialize, Debug, PartialEq)]
enum EnumTuple {
    T(u64, String),
}

#[derive(Serialize, Deserialize, Debug, PartialEq)]
enum EnumStruct {
    S { x: u64 },
}

#[derive(Serialize, Deserialize, Debug, PartialEq)]
enum EnumStructUntagged {
    #[serde(untagged)]
    U { x: u64, y: u64 },
}

#[derive(Serialize, Deserialize, Debug, PartialEq)]
struct StructNewType(bool);

#[derive(Serialize, Deserialize, Debug, PartialEq)]
struct StructTuple(u64, String);

#[derive(Serialize, Deserialize, Debug, PartialEq)]
#[serde(rename_all = "camelCase")]
pub(crate) struct TestStruct {
    u_64: u64,
    u_32: u32,
    u_16: u16,
    u_8: u8,
    i_64: i64,
    i_32: i32,
    i_16: i16,
    i_8: i8,
    flag: bool,
    string: String,
    map: HashMap<String, String>,
    arr: Vec<String>,
    value: Value,
    unit: (),
    enum_unit: EnumUnit,
    enum_tuple: EnumTuple,
    enum_struct: EnumStruct,
    enum_new_type: EnumNewType,
    enum_untagged: EnumStructUntagged,
    struct_tuple: StructTuple,
    struct_new_type: StructNewType,
    tuple: (String, bool),
    optional_string: Option<String>,
}

pub(crate) fn test_value() -> Value {
    Value::object([
        ("u64", Value::unsigned(u64::MAX)),
        ("u32", u32::MAX.into()),
        ("u16", u16::MAX.into()),
        ("u8", u8::MAX.into()),
        ("i64", i64::MAX.into()),
        ("i32", i32::MAX.into()),
        ("i16", i16::MAX.into()),
        ("i8", i8::MAX.into()),
        ("flag", Value::bool(true)),
        ("string", Value::string("foo")),
        ("map", Value::object([("foo", Value::string("bar"))])),
        (
            "arr",
            Value::array([
                Value::string("one"),
                Value::string("two"),
                Value::string("three"),
            ]),
        ),
        ("value", Value::bool(true)),
        ("unit", Value::Null),
        ("enumUnit", Value::string("X")),
        (
            "enumTuple",
            Value::object([(
                "T",
                Value::array([Value::unsigned(1000), Value::string("foo")]),
            )]),
        ),
        (
            "enumStruct",
            Value::object([("S", Value::object([("x", Value::unsigned(1000))]))]),
        ),
        ("enumNewType", Value::object([("N", Value::unsigned(1000))])),
        (
            "enumUntagged",
            Value::object([("x", Value::unsigned(1000)), ("y", Value::unsigned(1000))]),
        ),
        (
            "structTuple",
            Value::array([Value::unsigned(1000), Value::string("foo")]),
        ),
        ("structNewType", Value::bool(true)),
        (
            "tuple",
            Value::array([Value::string("foo"), Value::bool(true)]),
        ),
        ("optionalString", Value::string("foo")),
    ])
}

pub(crate) fn test_struct() -> TestStruct {
    TestStruct {
        u_64: u64::MAX,
        u_32: u32::MAX,
        u_16: u16::MAX,
        u_8: u8::MAX,
        i_64: i64::MAX,
        i_32: i32::MAX,
        i_16: i16::MAX,
        i_8: i8::MAX,
        flag: true,
        string: "foo".into(),
        map: HashMap::from([("foo".into(), "bar".into())]),
        arr: vec!["one".into(), "two".into(), "three".into()],
        value: Value::bool(true),
        unit: (),
        enum_unit: EnumUnit::X,
        enum_tuple: EnumTuple::T(1000, "foo".into()),
        enum_struct: EnumStruct::S { x: 1000 },
        enum_new_type: EnumNewType::N(1000),
        enum_untagged: EnumStructUntagged::U { x: 1000, y: 1000 },
        struct_tuple: StructTuple(1000, "foo".into()),
        struct_new_type: StructNewType(true),
        tuple: ("foo".into(), true),
        optional_string: Some("foo".into()),
    }
}