trs-data-value 0.2.0

Data Value for common data types
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
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244

use super::{DataValue, Extract};

macro_rules! impl_extract_nums {
    ($($t:ty),*) => {
        $(
        impl Extract for $t {
            #[inline]
            fn extract(v: &DataValue) -> $t {
                use DataValue::*;
                match v {
                    Bool(b) => (if b == &true { 1 } else { 0 })  as $t,
                    U32(i) => *i as $t,
                    I32(i) => *i as $t,
                    U8(i) => *i as $t,
                    U64(i) => *i as $t,
                    I64(i) => *i as $t,
                    F32(i) => *i as $t,
                    F64(i) => *i as $t,
                    U128(i) => *i as $t,
                    I128(i) => *i as $t,
                    EnumNumber(i) => *i as $t,
                    _ => 0 as $t,
                }
            }
        }
    )*
    };
}

impl_extract_nums!(u32, u64, i32, i64, f32, f64, u128, i128);
impl Extract for u8 {
    fn extract(v: &DataValue) -> u8 {
        use DataValue::*;
        match v {
            U8(i) => *i,
            _ => 0,
        }
    }
}

impl Extract for bool {
    fn extract(v: &DataValue) -> bool {
        match v {
            DataValue::Bool(i) => *i,
            DataValue::U8(i) => *i != 0,
            DataValue::U32(i) => *i != 0,
            DataValue::I32(i) => *i != 0,
            DataValue::U64(i) => *i != 0,
            DataValue::I64(i) => *i != 0,
            DataValue::F32(i) => *i != 0.,
            DataValue::F64(i) => *i != 0.,
            _ => false,
        }
    }
}

impl Extract for String {
    fn extract(v: &DataValue) -> String {
        match v {
            DataValue::String(i) => i.to_string(),
            v => format!("{v}"),
        }
    }
}

impl<T> Extract for Vec<T>
where
    T: Extract,
{
    fn extract(v: &DataValue) -> Vec<T> {
        use DataValue::*;
        match v {
            Vec(i) => i.iter().map(|x| T::extract(x)).collect(),
            _ => vec![],
        }
    }
}

impl<V> Extract for std::collections::HashMap<smartstring::alias::String, V>
where
    V: Extract,
{
    fn extract(v: &DataValue) -> std::collections::HashMap<smartstring::alias::String, V> {
        use DataValue::*;
        match v {
            Map(i) => i.iter().map(|(k, v)| (k.clone(), V::extract(v))).collect(),
            _ => Default::default(),
        }
    }
}

#[cfg(test)]
mod test {
    use super::*;
    use rstest::*;

    #[rstest]
    #[case(DataValue::U8(1), 1)]
    #[case(DataValue::U32(1), 1)]
    #[case(DataValue::I32(1), 1)]
    #[case(DataValue::U64(1), 1)]
    #[case(DataValue::I64(1), 1)]
    #[case(DataValue::F32(1.0), 1)]
    #[case(DataValue::F64(1.0), 1)]
    #[case(DataValue::U128(1), 1)]
    #[case(DataValue::I128(1), 1)]
    #[case(DataValue::EnumNumber(1), 1)]
    #[case(DataValue::Bool(true), 1)]
    #[case(DataValue::Bool(false), 0)]
    #[case(DataValue::String("1".into()), 0)]
    fn test_extract_num(#[case] input: DataValue, #[case] expected: u32) {
        assert_eq!(u32::extract(&input), expected);
    }

    #[rstest]
    #[case(DataValue::U8(1), "1")]
    #[case(DataValue::U32(1), "1")]
    #[case(DataValue::I32(1), "1")]
    #[case(DataValue::U64(1), "1")]
    #[case(DataValue::I64(1), "1")]
    #[case(DataValue::F32(1.1), "1.1")]
    #[case(DataValue::F64(1.1), "1.1")]
    #[case(DataValue::U128(1), "1")]
    #[case(DataValue::I128(1), "1")]
    #[case(DataValue::EnumNumber(1), "1")]
    #[case(DataValue::Bool(true), "true")]
    #[case(DataValue::Bool(false), "false")]
    #[case(DataValue::String("1".into()), "1")]
    fn test_extract_string(#[case] input: DataValue, #[case] expected: &str) {
        assert_eq!(String::extract(&input), expected.to_string());
    }
    #[rstest]
    #[case(DataValue::U8(1), 1)]
    #[case(DataValue::U32(1), 1)]
    #[case(DataValue::I32(1), 1)]
    #[case(DataValue::U64(1), 1)]
    #[case(DataValue::I64(1), 1)]
    #[case(DataValue::F32(1.0), 1)]
    #[case(DataValue::F64(1.0), 1)]
    #[case(DataValue::U128(1), 1)]
    #[case(DataValue::I128(1), 1)]
    #[case(DataValue::EnumNumber(1), 1)]
    #[case(DataValue::Bool(true), 1)]
    #[case(DataValue::Bool(false), 0)]
    #[case(DataValue::String("1".into()), 0)]
    fn test_extract_u64(#[case] input: DataValue, #[case] expected: u64) {
        assert_eq!(u64::extract(&input), expected);
    }

    #[rstest]
    #[case(DataValue::U8(1), 1)]
    #[case(DataValue::U32(1), 1)]
    #[case(DataValue::I32(1), 1)]
    #[case(DataValue::U64(1), 1)]
    #[case(DataValue::I64(1), 1)]
    #[case(DataValue::F32(1.0), 1)]
    #[case(DataValue::F64(1.0), 1)]
    #[case(DataValue::U128(1), 1)]
    #[case(DataValue::I128(1), 1)]
    #[case(DataValue::EnumNumber(1), 1)]
    #[case(DataValue::Bool(true), 1)]
    #[case(DataValue::Bool(false), 0)]
    #[case(DataValue::String("1".into()), 0)]
    fn test_extract_i32(#[case] input: DataValue, #[case] expected: i32) {
        assert_eq!(i32::extract(&input), expected);
    }

    #[rstest]
    #[case(DataValue::U8(1), 1)]
    #[case(DataValue::U32(1), 1)]
    #[case(DataValue::I32(1), 1)]
    #[case(DataValue::U64(1), 1)]
    #[case(DataValue::I64(1), 1)]
    #[case(DataValue::F32(1.0), 1)]
    #[case(DataValue::F64(1.0), 1)]
    #[case(DataValue::U128(1), 1)]
    #[case(DataValue::I128(1), 1)]
    #[case(DataValue::EnumNumber(1), 1)]
    #[case(DataValue::Bool(true), 1)]
    #[case(DataValue::Bool(false), 0)]
    #[case(DataValue::String("1".into()), 0)]
    fn test_extract_i64(#[case] input: DataValue, #[case] expected: i64) {
        assert_eq!(i64::extract(&input), expected);
    }

    #[rstest]
    #[case(DataValue::U8(1), 1f64)]
    #[case(DataValue::U32(1), 1f64)]
    #[case(DataValue::I32(1), 1f64)]
    #[case(DataValue::U64(1), 1f64)]
    #[case(DataValue::I64(1), 1f64)]
    #[case(DataValue::F32(1.0), 1f64)]
    #[case(DataValue::F64(1.0), 1f64)]
    #[case(DataValue::U128(1), 1f64)]
    #[case(DataValue::I128(1), 1f64)]
    #[case(DataValue::EnumNumber(1), 1f64)]
    #[case(DataValue::Bool(true), 1f64)]
    #[case(DataValue::Bool(false), 0f64)]
    #[case(DataValue::String("1".into()), 0f64)]
    fn test_extract_f64(#[case] input: DataValue, #[case] expected: f64) {
        assert_eq!(f64::extract(&input), expected);
    }

    #[rstest]
    #[case(DataValue::U8(1), 1f32)]
    #[case(DataValue::U32(1), 1f32)]
    #[case(DataValue::I32(1), 1f32)]
    #[case(DataValue::U64(1), 1f32)]
    #[case(DataValue::I64(1), 1f32)]
    #[case(DataValue::F32(1.0), 1f32)]
    #[case(DataValue::F64(1.0), 1f32)]
    #[case(DataValue::U128(1), 1f32)]
    #[case(DataValue::I128(1), 1f32)]
    #[case(DataValue::EnumNumber(1), 1f32)]
    #[case(DataValue::Bool(true), 1f32)]
    #[case(DataValue::Bool(false), 0f32)]
    #[case(DataValue::String("1".into()), 0f32)]
    #[case(DataValue::Null, 0f32)]
    fn test_extract_f32(#[case] input: DataValue, #[case] expected: f32) {
        assert_eq!(f32::extract(&input), expected);
    }

    #[rstest]
    #[case(DataValue::Vec(vec![1.into()]), vec![1])]
    #[case(DataValue::Vec(vec![1.into(), 2.into()]), vec![1, 2])]
    #[case(DataValue::Vec(vec![1.into(), 2.into(), 3.into()]), vec![1, 2, 3])]
    fn test_extract_vec(#[case] input: DataValue, #[case] expected: Vec<u32>) {
        assert_eq!(Vec::<u32>::extract(&input), expected);
    }

    #[rstest]
    #[case(DataValue::Map(crate::stdhashmap!("a" => 1)), crate::stdhashmap!("a" => 1))]
    #[case(DataValue::Map(crate::stdhashmap!("a" => 1, "b" => 2)), crate::stdhashmap!("a" => 1, "b" => 2))]
    #[case(DataValue::Map(crate::stdhashmap!("a" => 1, "b" => 2, "c" => 3)), crate::stdhashmap!("a" => 1, "b" => 2, "c" => 3))]
    fn test_extract_map(
        #[case] input: DataValue,
        #[case] expected: std::collections::HashMap<smartstring::alias::String, i32>,
    ) {
        assert_eq!(
            std::collections::HashMap::<smartstring::alias::String, i32>::extract(&input),
            expected
        );
    }
}