lilliput_core/
value.rs

1//! Values.
2
3#[cfg(any(test, feature = "testing"))]
4use proptest::{prelude::*, sample::SizeRange};
5
6mod bool;
7mod bytes;
8mod float;
9mod int;
10mod map;
11mod null;
12mod seq;
13mod string;
14mod unit;
15
16pub use self::{
17    bool::BoolValue,
18    bytes::BytesValue,
19    float::FloatValue,
20    int::{IntValue, SignedIntValue, UnsignedIntValue},
21    map::{Map, MapValue},
22    null::NullValue,
23    seq::{Seq, SeqValue},
24    string::StringValue,
25    unit::UnitValue,
26};
27
28/// Represents a value.
29#[derive(Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
30pub enum Value {
31    /// Represents a integer number.
32    Int(IntValue),
33
34    /// Represents a string.
35    String(StringValue),
36
37    /// Represents a sequence of values.
38    Seq(SeqValue),
39
40    /// Represents a map of key-value pairs.
41    ///
42    /// By default the map is backed by a `BTreeMap`. Enable the `preserve_order`
43    /// feature of serde_lilliput to use `OrderMap` instead, which preserves
44    /// entries in the order they are inserted into the map.
45    Map(MapValue),
46
47    /// Represents a floating-point number.
48    Float(FloatValue),
49
50    /// Represents a byte array.
51    Bytes(BytesValue),
52
53    /// Represents a boolean.
54    Bool(BoolValue),
55
56    /// Represents a unit value.
57    Unit(UnitValue),
58
59    /// Represents a null value.
60    Null(NullValue),
61}
62
63impl Default for Value {
64    fn default() -> Self {
65        Self::Null(NullValue)
66    }
67}
68
69impl From<IntValue> for Value {
70    fn from(value: IntValue) -> Self {
71        Self::Int(value)
72    }
73}
74
75impl From<StringValue> for Value {
76    fn from(value: StringValue) -> Self {
77        Self::String(value)
78    }
79}
80
81impl From<SeqValue> for Value {
82    fn from(value: SeqValue) -> Self {
83        Self::Seq(value)
84    }
85}
86
87impl From<MapValue> for Value {
88    fn from(value: MapValue) -> Self {
89        Self::Map(value)
90    }
91}
92
93impl From<FloatValue> for Value {
94    fn from(value: FloatValue) -> Self {
95        Self::Float(value)
96    }
97}
98
99impl From<BytesValue> for Value {
100    fn from(value: BytesValue) -> Self {
101        Self::Bytes(value)
102    }
103}
104
105impl From<BoolValue> for Value {
106    fn from(value: BoolValue) -> Self {
107        Self::Bool(value)
108    }
109}
110
111impl From<UnitValue> for Value {
112    fn from(value: UnitValue) -> Self {
113        Self::Unit(value)
114    }
115}
116
117impl From<NullValue> for Value {
118    fn from(value: NullValue) -> Self {
119        Self::Null(value)
120    }
121}
122
123impl std::fmt::Debug for Value {
124    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
125        if f.alternate() {
126            match self {
127                Self::Int(value) => f.debug_tuple("Int").field(value).finish(),
128                Self::String(value) => f.debug_tuple("String").field(value).finish(),
129                Self::Seq(value) => f.debug_tuple("Seq").field(value).finish(),
130                Self::Map(value) => f.debug_tuple("Map").field(value).finish(),
131                Self::Float(value) => f.debug_tuple("Float").field(value).finish(),
132                Self::Bytes(value) => f.debug_tuple("Bytes").field(value).finish(),
133                Self::Bool(value) => f.debug_tuple("Bool").field(value).finish(),
134                Self::Unit(value) => f.debug_tuple("Unit").field(value).finish(),
135                Self::Null(value) => f.debug_tuple("Null").field(value).finish(),
136            }
137        } else {
138            match self {
139                Self::Int(value) => std::fmt::Debug::fmt(value, f),
140                Self::String(value) => std::fmt::Debug::fmt(value, f),
141                Self::Seq(value) => std::fmt::Debug::fmt(value, f),
142                Self::Map(value) => std::fmt::Debug::fmt(value, f),
143                Self::Float(value) => std::fmt::Debug::fmt(value, f),
144                Self::Bytes(value) => std::fmt::Debug::fmt(value, f),
145                Self::Bool(value) => std::fmt::Debug::fmt(value, f),
146                Self::Unit(value) => std::fmt::Debug::fmt(value, f),
147                Self::Null(value) => std::fmt::Debug::fmt(value, f),
148            }
149        }
150    }
151}
152
153#[cfg(feature = "serde")]
154impl serde::Serialize for Value {
155    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
156    where
157        S: serde::Serializer,
158    {
159        match self {
160            Value::Int(value) => value.serialize(serializer),
161            Value::String(value) => value.serialize(serializer),
162            Value::Seq(value) => value.serialize(serializer),
163            Value::Map(value) => value.serialize(serializer),
164            Value::Float(value) => value.serialize(serializer),
165            Value::Bytes(value) => value.serialize(serializer),
166            Value::Bool(value) => value.serialize(serializer),
167            Value::Unit(value) => value.serialize(serializer),
168            Value::Null(value) => value.serialize(serializer),
169        }
170    }
171}
172
173#[cfg(feature = "serde")]
174impl<'de> serde::Deserialize<'de> for Value {
175    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
176    where
177        D: serde::Deserializer<'de>,
178    {
179        struct ValueVisitor;
180
181        impl<'de> serde::de::Visitor<'de> for ValueVisitor {
182            type Value = Value;
183
184            fn expecting(&self, formatter: &mut core::fmt::Formatter) -> core::fmt::Result {
185                formatter.write_str("any valid lilliput value")
186            }
187
188            fn visit_bool<E>(self, value: bool) -> Result<Self::Value, E>
189            where
190                E: serde::de::Error,
191            {
192                Ok(Value::Bool(BoolValue::from(value)))
193            }
194
195            fn visit_i8<E>(self, value: i8) -> Result<Self::Value, E>
196            where
197                E: serde::de::Error,
198            {
199                Ok(Value::Int(IntValue::from(value)))
200            }
201
202            fn visit_i16<E>(self, value: i16) -> Result<Self::Value, E>
203            where
204                E: serde::de::Error,
205            {
206                Ok(Value::Int(IntValue::from(value)))
207            }
208
209            fn visit_i32<E>(self, value: i32) -> Result<Self::Value, E>
210            where
211                E: serde::de::Error,
212            {
213                Ok(Value::Int(IntValue::from(value)))
214            }
215
216            fn visit_i64<E>(self, value: i64) -> Result<Self::Value, E>
217            where
218                E: serde::de::Error,
219            {
220                Ok(Value::Int(IntValue::from(value)))
221            }
222
223            fn visit_i128<E>(self, _value: i128) -> Result<Self::Value, E>
224            where
225                E: serde::de::Error,
226            {
227                Err(serde::de::Error::invalid_type(
228                    serde::de::Unexpected::Other("i128 value"),
229                    &self,
230                ))
231            }
232
233            fn visit_u8<E>(self, value: u8) -> Result<Self::Value, E>
234            where
235                E: serde::de::Error,
236            {
237                Ok(Value::Int(IntValue::from(value)))
238            }
239
240            fn visit_u16<E>(self, value: u16) -> Result<Self::Value, E>
241            where
242                E: serde::de::Error,
243            {
244                Ok(Value::Int(IntValue::from(value)))
245            }
246
247            fn visit_u32<E>(self, value: u32) -> Result<Self::Value, E>
248            where
249                E: serde::de::Error,
250            {
251                Ok(Value::Int(IntValue::from(value)))
252            }
253
254            fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
255            where
256                E: serde::de::Error,
257            {
258                Ok(Value::Int(IntValue::from(value)))
259            }
260
261            fn visit_u128<E>(self, _value: u128) -> Result<Self::Value, E>
262            where
263                E: serde::de::Error,
264            {
265                Err(serde::de::Error::invalid_type(
266                    serde::de::Unexpected::Other("u128 value"),
267                    &self,
268                ))
269            }
270
271            fn visit_f32<E>(self, value: f32) -> Result<Self::Value, E>
272            where
273                E: serde::de::Error,
274            {
275                Ok(Value::Float(FloatValue::from(value)))
276            }
277
278            fn visit_f64<E>(self, value: f64) -> Result<Self::Value, E>
279            where
280                E: serde::de::Error,
281            {
282                Ok(Value::Float(FloatValue::from(value)))
283            }
284
285            fn visit_char<E>(self, value: char) -> Result<Self::Value, E>
286            where
287                E: serde::de::Error,
288            {
289                self.visit_str(value.encode_utf8(&mut [0u8; 4]))
290            }
291
292            fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
293            where
294                E: serde::de::Error,
295            {
296                self.visit_string(value.to_owned())
297            }
298
299            fn visit_borrowed_str<E>(self, value: &'de str) -> Result<Self::Value, E>
300            where
301                E: serde::de::Error,
302            {
303                self.visit_string(value.to_owned())
304            }
305
306            fn visit_string<E>(self, value: String) -> Result<Self::Value, E>
307            where
308                E: serde::de::Error,
309            {
310                Ok(Value::String(StringValue::from(value)))
311            }
312
313            fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
314            where
315                E: serde::de::Error,
316            {
317                self.visit_byte_buf(value.to_owned())
318            }
319
320            fn visit_borrowed_bytes<E>(self, value: &'de [u8]) -> Result<Self::Value, E>
321            where
322                E: serde::de::Error,
323            {
324                self.visit_byte_buf(value.to_owned())
325            }
326
327            fn visit_byte_buf<E>(self, value: Vec<u8>) -> Result<Self::Value, E>
328            where
329                E: serde::de::Error,
330            {
331                Ok(Value::Bytes(BytesValue::from(value)))
332            }
333
334            fn visit_none<E>(self) -> Result<Self::Value, E>
335            where
336                E: serde::de::Error,
337            {
338                Ok(Value::Null(NullValue))
339            }
340
341            fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
342            where
343                D: serde::Deserializer<'de>,
344            {
345                serde::Deserialize::deserialize(deserializer)
346            }
347
348            fn visit_unit<E>(self) -> Result<Self::Value, E>
349            where
350                E: serde::de::Error,
351            {
352                Ok(Value::Unit(UnitValue))
353            }
354
355            fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
356            where
357                D: serde::Deserializer<'de>,
358            {
359                serde::Deserialize::deserialize(deserializer)
360            }
361
362            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
363            where
364                A: serde::de::SeqAccess<'de>,
365            {
366                let mut values = Vec::new();
367
368                while let Some(value) = seq.next_element()? {
369                    values.push(value);
370                }
371
372                Ok(Value::Seq(SeqValue::from(values)))
373            }
374
375            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
376            where
377                A: serde::de::MapAccess<'de>,
378            {
379                match map.next_key_seed(map::MapKeyClassifier)? {
380                    Some(map::MapKeyClass::Map(first_key)) => {
381                        let mut values = Map::new();
382
383                        values.insert(first_key, map.next_value()?);
384                        while let Some((key, value)) = map.next_entry()? {
385                            values.insert(key, value);
386                        }
387
388                        Ok(Value::Map(MapValue::from(values)))
389                    }
390                    None => Ok(Value::Map(MapValue::default())),
391                }
392            }
393
394            fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
395            where
396                A: serde::de::EnumAccess<'de>,
397            {
398                let _ = data;
399                Err(serde::de::Error::invalid_type(
400                    serde::de::Unexpected::Enum,
401                    &self,
402                ))
403            }
404        }
405
406        deserializer.deserialize_any(ValueVisitor)
407    }
408}
409
410#[doc(hidden)]
411#[cfg(any(test, feature = "testing"))]
412pub struct ValueArbitraryParameters {
413    pub depth: u32,
414    pub desired_size: u32,
415    pub expected_branch_size: u32,
416}
417
418#[cfg(any(test, feature = "testing"))]
419impl Default for ValueArbitraryParameters {
420    fn default() -> Self {
421        Self {
422            // 4 levels deep
423            depth: 4,
424            // Shoot for maximum size of 128 nodes
425            desired_size: 128,
426            // We put up to 5 items per collection
427            expected_branch_size: 5,
428        }
429    }
430}
431
432#[cfg(any(test, feature = "testing"))]
433impl proptest::arbitrary::Arbitrary for Value {
434    type Parameters = ValueArbitraryParameters;
435    type Strategy = proptest::prelude::BoxedStrategy<Value>;
436
437    fn arbitrary_with(args: Self::Parameters) -> Self::Strategy {
438        use proptest::prelude::*;
439
440        let ValueArbitraryParameters {
441            depth,
442            desired_size,
443            expected_branch_size,
444        } = args;
445
446        let leaf = prop_oneof![
447            IntValue::arbitrary().prop_map(Value::Int),
448            StringValue::arbitrary().prop_map(Value::String),
449            FloatValue::arbitrary().prop_map(Value::Float),
450            BytesValue::arbitrary().prop_map(Value::Bytes),
451            BoolValue::arbitrary().prop_map(Value::Bool),
452            UnitValue::arbitrary().prop_map(Value::Unit),
453            NullValue::arbitrary().prop_map(Value::Null),
454        ];
455
456        let len: SizeRange = (0..(expected_branch_size as usize)).into();
457
458        leaf.prop_recursive(depth, desired_size, expected_branch_size, move |inner| {
459            prop_oneof![
460                map::arbitrary_map_with(inner.clone(), inner.clone(), len.clone())
461                    .prop_map(|map| Value::Map(map.into())),
462                seq::arbitrary_seq_with(inner.clone(), len.clone())
463                    .prop_map(|seq| Value::Seq(seq.into())),
464            ]
465        })
466        .boxed()
467    }
468}
469
470#[cfg(test)]
471mod tests {
472    use test_log::test;
473
474    use super::*;
475
476    #[test]
477    fn debug() {
478        // Int
479        assert_eq!(format!("{:?}", Value::Int(IntValue::default())), "0");
480        assert_eq!(
481            format!("{:#?}", Value::Int(IntValue::default())),
482            "Int(\n    0_u8,\n)"
483        );
484
485        // String
486        assert_eq!(
487            format!("{:?}", Value::String(StringValue::default())),
488            "\"\""
489        );
490        assert_eq!(
491            format!("{:#?}", Value::String(StringValue::default())),
492            "String(\n    \"\",\n)"
493        );
494
495        // Seq
496        assert_eq!(format!("{:?}", Value::Seq(SeqValue::default())), "[]");
497        assert_eq!(
498            format!("{:#?}", Value::Seq(SeqValue::default())),
499            "Seq(\n    [],\n)"
500        );
501
502        // Map
503        assert_eq!(format!("{:?}", Value::Map(MapValue::default())), "{}");
504        assert_eq!(
505            format!("{:#?}", Value::Map(MapValue::default())),
506            "Map(\n    {},\n)"
507        );
508
509        // Float
510        assert_eq!(format!("{:?}", Value::Float(FloatValue::default())), "0.0");
511        assert_eq!(
512            format!("{:#?}", Value::Float(FloatValue::default())),
513            "Float(\n    0.0_f32,\n)"
514        );
515
516        // Bytes
517        assert_eq!(format!("{:?}", Value::Bytes(BytesValue::default())), "[]");
518        assert_eq!(
519            format!("{:#?}", Value::Bytes(BytesValue::default())),
520            "Bytes(\n    [],\n)"
521        );
522
523        // Bool
524        assert_eq!(format!("{:?}", Value::Bool(BoolValue::default())), "false");
525        assert_eq!(
526            format!("{:#?}", Value::Bool(BoolValue::default())),
527            "Bool(\n    false,\n)"
528        );
529
530        // Null
531        assert_eq!(format!("{:?}", Value::Null(NullValue)), "null");
532        assert_eq!(
533            format!("{:#?}", Value::Null(NullValue)),
534            "Null(\n    null,\n)"
535        );
536    }
537}
lilliput_core/value.rs

lilliput_core/
value.rs
