pot/
value.rs

1use std::borrow::Cow;
2use std::fmt::{Display, Write};
3use std::marker::PhantomData;
4use std::ops::{Deref, DerefMut};
5
6use serde::de::{EnumAccess, MapAccess, SeqAccess, VariantAccess, Visitor};
7use serde::ser::{
8    SerializeMap, SerializeSeq, SerializeStruct, SerializeStructVariant, SerializeTuple,
9    SerializeTupleStruct, SerializeTupleVariant,
10};
11use serde::{Deserialize, Serialize};
12
13use crate::format::{Float, InnerFloat, InnerInteger, Integer};
14
15/// A Pot-encoded value. This type can be used to deserialize to and from Pot
16/// without knowing the original data structure.
17#[derive(Debug, Clone)]
18pub enum Value<'a> {
19    /// A value representing `None`.
20    None,
21    /// A value representing unit (`()`).
22    Unit,
23    /// A boolean value
24    Bool(bool),
25    /// An integer value.
26    Integer(Integer),
27    /// A floating point value.
28    Float(Float),
29    /// A value containing arbitrary bytes.
30    Bytes(Cow<'a, [u8]>),
31    /// A string value.
32    String(Cow<'a, str>),
33    /// A sequence of values.
34    Sequence(Vec<Self>),
35    /// A sequence of key-value mappings.
36    Mappings(Vec<(Self, Self)>),
37}
38
39impl<'a> Value<'a> {
40    /// Creates a `Value` from the given Serde-compatible type.
41    ///
42    /// ```rust
43    /// # fn test() -> Result<(), pot::ValueError> {
44    /// use pot::Value;
45    /// use serde_derive::Serialize;
46    ///
47    /// #[derive(Serialize, Debug)]
48    /// enum Example {
49    ///     Hello,
50    ///     World,
51    /// }
52    ///
53    /// let original = vec![Example::Hello, Example::World];
54    /// let serialized = Value::from_serialize(&original)?;
55    /// assert_eq!(
56    ///     serialized,
57    ///     Value::Sequence(vec![
58    ///         Value::from(String::from("Hello")),
59    ///         Value::from(String::from("World"))
60    ///     ])
61    /// );
62    /// # Ok(())
63    /// # }
64    /// ```
65    #[inline]
66    pub fn from_serialize<T: Serialize>(value: T) -> Result<Self, ValueError> {
67        value.serialize(Serializer)
68    }
69
70    /// Attempts to create an instance of `T` from this value.
71    ///
72    /// ```rust
73    /// # fn test() -> Result<(), pot::ValueError> {
74    /// use pot::Value;
75    /// use serde_derive::{Deserialize, Serialize};
76    ///
77    /// #[derive(Serialize, Deserialize, Debug, Eq, PartialEq)]
78    /// enum Example {
79    ///     Hello,
80    ///     World,
81    /// }
82    ///
83    /// let original = vec![Example::Hello, Example::World];
84    /// let serialized = Value::from_serialize(&original)?;
85    /// let deserialized: Vec<Example> = serialized.deserialize_as()?;
86    /// assert_eq!(deserialized, original);
87    /// # Ok(())
88    /// # }
89    /// ```
90    #[inline]
91    pub fn deserialize_as<'de, T: Deserialize<'de>>(&'de self) -> Result<T, ValueError> {
92        T::deserialize(Deserializer(self))
93    }
94
95    /// Returns a new value from an iterator of items that can be converted into a value.
96    ///
97    /// ```rust
98    /// # use pot::Value;
99    /// let mappings = Value::from_sequence(Vec::<String>::new());
100    /// assert!(matches!(mappings, Value::Sequence(_)));
101    /// ```
102    #[inline]
103    pub fn from_sequence<IntoIter: IntoIterator<Item = T>, T: Into<Self>>(
104        sequence: IntoIter,
105    ) -> Self {
106        Self::from_iter(sequence)
107    }
108
109    /// Returns a new value from an iterator of 2-element tuples representing key-value pairs.
110    ///
111    /// ```rust
112    /// # use pot::Value;
113    /// # use std::collections::HashMap;
114    /// let mappings = Value::from_mappings(HashMap::<String, u32>::new());
115    /// assert!(matches!(mappings, Value::Mappings(_)));
116    /// ```
117    #[inline]
118    pub fn from_mappings<IntoIter: IntoIterator<Item = (K, V)>, K: Into<Self>, V: Into<Self>>(
119        mappings: IntoIter,
120    ) -> Self {
121        Self::from_iter(mappings)
122    }
123
124    /// Returns `true` if the value contained is considered empty.
125    ///
126    /// ```rust
127    /// # use pot::Value;
128    /// // Value::None is always empty.
129    /// assert_eq!(Value::None.is_empty(), true);
130    ///
131    /// // All primitive values, including Unit, are always not empty, even if they contain the value 0.
132    /// assert_eq!(Value::Unit.is_empty(), false);
133    /// assert_eq!(Value::from(false).is_empty(), false);
134    /// assert_eq!(Value::from(0_u8).is_empty(), false);
135    /// assert_eq!(Value::from(0_f32).is_empty(), false);
136    ///
137    /// // For all other types, having a length of 0 will result in is_empty returning true.
138    /// assert_eq!(Value::from(Vec::<u8>::new()).is_empty(), true);
139    /// assert_eq!(Value::from(b"").is_empty(), true);
140    /// assert_eq!(Value::from(vec![0_u8]).is_empty(), false);
141    ///
142    /// assert_eq!(Value::from("").is_empty(), true);
143    /// assert_eq!(Value::from("hi").is_empty(), false);
144    ///
145    /// assert_eq!(Value::Sequence(Vec::new()).is_empty(), true);
146    /// assert_eq!(Value::from(vec![Value::None]).is_empty(), false);
147    ///
148    /// assert_eq!(Value::Mappings(Vec::new()).is_empty(), true);
149    /// assert_eq!(
150    ///     Value::from(vec![(Value::None, Value::None)]).is_empty(),
151    ///     false
152    /// );
153    /// ```
154    #[must_use]
155    #[inline]
156    pub fn is_empty(&self) -> bool {
157        match self {
158            Value::None => true,
159            Value::Unit | Value::Bool(_) | Value::Integer(_) | Value::Float(_) => false,
160            Value::Bytes(value) => value.is_empty(),
161            Value::String(value) => value.is_empty(),
162            Value::Sequence(value) => value.is_empty(),
163            Value::Mappings(value) => value.is_empty(),
164        }
165    }
166
167    /// Returns the value as a `bool`.
168    ///
169    /// ```rust
170    /// # use pot::Value;
171    /// // Value::None is always false.
172    /// assert_eq!(Value::None.as_bool(), false);
173    ///
174    /// // Value::Unit is always true.
175    /// assert_eq!(Value::Unit.as_bool(), true);
176    ///
177    /// // Value::Bool will return the contained value
178    /// assert_eq!(Value::from(false).as_bool(), false);
179    /// assert_eq!(Value::from(true).as_bool(), true);
180    ///
181    /// // All primitive values return true if the value is non-zero.
182    /// assert_eq!(Value::from(0_u8).as_bool(), false);
183    /// assert_eq!(Value::from(1_u8).as_bool(), true);
184    /// assert_eq!(Value::from(0_f32).as_bool(), false);
185    /// assert_eq!(Value::from(1_f32).as_bool(), true);
186    ///
187    /// // For all other types, as_bool() returns the result of `!is_empty()`.
188    /// assert_eq!(Value::from(Vec::<u8>::new()).as_bool(), false);
189    /// assert_eq!(Value::from(b"").as_bool(), false);
190    /// assert_eq!(Value::from(vec![0_u8]).as_bool(), true);
191    ///
192    /// assert_eq!(Value::from("").as_bool(), false);
193    /// assert_eq!(Value::from("hi").as_bool(), true);
194    ///
195    /// assert_eq!(Value::Sequence(Vec::new()).as_bool(), false);
196    /// assert_eq!(Value::from(vec![Value::None]).as_bool(), true);
197    ///
198    /// assert_eq!(Value::Mappings(Vec::new()).as_bool(), false);
199    /// assert_eq!(
200    ///     Value::from(vec![(Value::None, Value::None)]).as_bool(),
201    ///     true
202    /// );
203    /// ```
204    #[must_use]
205    #[inline]
206    pub fn as_bool(&self) -> bool {
207        match self {
208            Value::None => false,
209            Value::Unit => true,
210            Value::Bool(value) => *value,
211            Value::Integer(value) => !value.is_zero(),
212            Value::Float(value) => !value.is_zero(),
213            Value::Bytes(value) => !value.is_empty(),
214            Value::String(value) => !value.is_empty(),
215            Value::Sequence(value) => !value.is_empty(),
216            Value::Mappings(value) => !value.is_empty(),
217        }
218    }
219
220    /// Returns the value as an [`Integer`]. Returns `None` if the value is not a
221    /// [`Self::Float`] or [`Self::Integer`]. Also returns `None` if the value is
222    /// a float, but cannot be losslessly converted to an integer.
223    #[must_use]
224    #[inline]
225    pub fn as_integer(&self) -> Option<Integer> {
226        match self {
227            Value::Integer(value) => Some(*value),
228            Value::Float(value) => value.as_integer().ok(),
229            _ => None,
230        }
231    }
232
233    /// Returns the value as an [`Float`]. Returns `None` if the value is not a
234    /// [`Self::Float`] or [`Self::Integer`]. Also returns `None` if the value is
235    /// an integer, but cannot be losslessly converted to a float.
236    #[must_use]
237    #[inline]
238    pub fn as_float(&self) -> Option<Float> {
239        match self {
240            Value::Integer(value) => value.as_float().ok(),
241            Value::Float(value) => Some(*value),
242            _ => None,
243        }
244    }
245
246    /// Returns the value as a string, or `None` if the value is not representable
247    /// by a string. This will only return a value with variants
248    /// [`Self::String`] and [`Self::Bytes`]. Bytes will only be returned if the
249    /// contained bytes can be safely interpretted as UTF-8.
250    #[must_use]
251    #[inline]
252    pub fn as_str(&self) -> Option<&str> {
253        match self {
254            Self::Bytes(bytes) => std::str::from_utf8(bytes).ok(),
255            Self::String(string) => Some(string),
256            _ => None,
257        }
258    }
259
260    /// Returns the value as bytes, or `None` if the value is not stored as a
261    /// representation of bytes. This will only return a value with variants
262    /// [`Self::String`] and [`Self::Bytes`].
263    #[must_use]
264    #[inline]
265    pub fn as_bytes(&self) -> Option<&[u8]> {
266        match self {
267            Self::Bytes(bytes) => Some(bytes),
268            Self::String(string) => Some(string.as_bytes()),
269            _ => None,
270        }
271    }
272
273    /// Returns an iterator that iterates over all values contained inside of
274    /// this value. Returns an empty iterator if not a [`Self::Sequence`] or
275    /// [`Self::Mappings`]. If a [`Self::Mappings`], only the value portion of
276    /// the mapping is returned.
277    #[must_use]
278    #[inline]
279    pub fn values(&self) -> ValueIter<'_> {
280        match self {
281            Self::Sequence(sequence) => ValueIter(SequenceIterState::Sequence(sequence.iter())),
282            Self::Mappings(mappings) => ValueIter(SequenceIterState::Mappings(mappings.iter())),
283            _ => ValueIter(SequenceIterState::Sequence([].iter())),
284        }
285    }
286
287    /// Returns an iterator that iterates over all mappings contained inside of
288    /// this value. Returns an empty iterator if not a [`Self::Sequence`] or
289    /// [`Self::Mappings`]. If a [`Self::Sequence`], the key will always be
290    /// `Self::None`.
291    #[inline]
292    pub fn mappings(&self) -> std::slice::Iter<'_, (Self, Self)> {
293        match self {
294            Self::Mappings(mappings) => mappings.iter(),
295            _ => [].iter(),
296        }
297    }
298
299    /// Converts `self` to a `'static` lifetime by cloning any borrowed data.
300    pub fn into_static(self) -> Value<'static> {
301        match self {
302            Self::None => Value::None,
303            Self::Unit => Value::Unit,
304            Self::Bool(value) => Value::Bool(value),
305            Self::Integer(value) => Value::Integer(value),
306            Self::Float(value) => Value::Float(value),
307            Self::Bytes(Cow::Owned(value)) => Value::Bytes(Cow::Owned(value)),
308            Self::Bytes(Cow::Borrowed(value)) => Value::Bytes(Cow::Owned(value.to_vec())),
309            Self::String(Cow::Owned(value)) => Value::String(Cow::Owned(value)),
310            Self::String(Cow::Borrowed(value)) => Value::String(Cow::Owned(value.to_string())),
311            Self::Sequence(value) => {
312                Value::Sequence(value.into_iter().map(Value::into_static).collect())
313            }
314            Self::Mappings(value) => Value::Mappings(
315                value
316                    .into_iter()
317                    .map(|(k, v)| (k.into_static(), v.into_static()))
318                    .collect(),
319            ),
320        }
321    }
322
323    /// Converts `self` to a `'static` lifetime by cloning all data.
324    pub fn to_static(&self) -> Value<'static> {
325        match self {
326            Self::None => Value::None,
327            Self::Unit => Value::Unit,
328            Self::Bool(value) => Value::Bool(*value),
329            Self::Integer(value) => Value::Integer(*value),
330            Self::Float(value) => Value::Float(*value),
331            Self::Bytes(Cow::Owned(value)) => Value::Bytes(Cow::Owned(value.clone())),
332            Self::Bytes(Cow::Borrowed(value)) => Value::Bytes(Cow::Owned(value.to_vec())),
333            Self::String(Cow::Owned(value)) => Value::String(Cow::Owned(value.clone())),
334            Self::String(Cow::Borrowed(value)) => Value::String(Cow::Owned((*value).to_string())),
335            Self::Sequence(value) => Value::Sequence(value.iter().map(Value::to_static).collect()),
336            Self::Mappings(value) => Value::Mappings(
337                value
338                    .iter()
339                    .map(|(k, v)| (k.to_static(), v.to_static()))
340                    .collect(),
341            ),
342        }
343    }
344}
345
346impl<'a, 'b> PartialEq<Value<'b>> for Value<'a> {
347    #[inline]
348    fn eq(&self, other: &Value<'b>) -> bool {
349        match (self, other) {
350            (Self::Bool(l0), Value::Bool(r0)) => l0 == r0,
351            (Self::Integer(l0), Value::Integer(r0)) => l0 == r0,
352            (Self::Float(l0), Value::Float(r0)) => l0 == r0,
353            (Self::Bytes(l0), Value::Bytes(r0)) => l0 == r0,
354            (Self::String(l0), Value::String(r0)) => l0 == r0,
355            (Self::Bytes(l0), Value::String(r0)) => *l0 == r0.as_bytes(),
356            (Self::String(l0), Value::Bytes(r0)) => l0.as_bytes() == &**r0,
357            (Self::Sequence(l0), Value::Sequence(r0)) => l0 == r0,
358            (Self::Mappings(l0), Value::Mappings(r0)) => l0 == r0,
359            _ => core::mem::discriminant(self) == core::mem::discriminant(other),
360        }
361    }
362}
363
364impl<'a> Display for Value<'a> {
365    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
366        match self {
367            Value::None => f.write_str("None"),
368            Value::Unit => f.write_str("()"),
369            Value::Bool(true) => f.write_str("true"),
370            Value::Bool(false) => f.write_str("false"),
371            Value::Integer(value) => Display::fmt(value, f),
372            Value::Float(value) => Display::fmt(value, f),
373            Value::Bytes(bytes) => {
374                f.write_str("0x")?;
375                for (index, byte) in bytes.iter().enumerate() {
376                    if index > 0 && index % 4 == 0 {
377                        f.write_char('_')?;
378                    }
379                    write!(f, "{byte:02x}")?;
380                }
381                Ok(())
382            }
383            Value::String(string) => f.write_str(string),
384            Value::Sequence(sequence) => {
385                f.write_char('[')?;
386                for (index, value) in sequence.iter().enumerate() {
387                    if index > 0 {
388                        f.write_str(", ")?;
389                    }
390                    Display::fmt(value, f)?;
391                }
392                f.write_char(']')
393            }
394            Value::Mappings(mappings) => {
395                f.write_char('{')?;
396                for (index, (key, value)) in mappings.iter().enumerate() {
397                    if index > 0 {
398                        f.write_str(", ")?;
399                    }
400                    Display::fmt(key, f)?;
401                    f.write_str(": ")?;
402                    Display::fmt(value, f)?;
403                }
404                f.write_char('}')
405            }
406        }
407    }
408}
409
410impl<'a> Serialize for Value<'a> {
411    #[inline]
412    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
413    where
414        S: serde::Serializer,
415    {
416        match self {
417            Value::None => serializer.serialize_none(),
418            Value::Unit => serializer.serialize_unit(),
419            Value::Bool(value) => serializer.serialize_bool(*value),
420            Value::Integer(integer) => match integer.0 {
421                InnerInteger::I8(value) => serializer.serialize_i8(value),
422                InnerInteger::I16(value) => serializer.serialize_i16(value),
423                InnerInteger::I32(value) => serializer.serialize_i32(value),
424                InnerInteger::I64(value) => serializer.serialize_i64(value),
425                InnerInteger::I128(value) => serializer.serialize_i128(value),
426                InnerInteger::U8(value) => serializer.serialize_u8(value),
427                InnerInteger::U16(value) => serializer.serialize_u16(value),
428                InnerInteger::U32(value) => serializer.serialize_u32(value),
429                InnerInteger::U64(value) => serializer.serialize_u64(value),
430                InnerInteger::U128(value) => serializer.serialize_u128(value),
431            },
432            Value::Float(value) => match value.0 {
433                InnerFloat::F64(value) => serializer.serialize_f64(value),
434                InnerFloat::F32(value) => serializer.serialize_f32(value),
435            },
436            Value::Bytes(value) => serializer.serialize_bytes(value),
437            Value::String(value) => serializer.serialize_str(value),
438            Value::Sequence(values) => {
439                let mut seq = serializer.serialize_seq(Some(values.len()))?;
440                for value in values {
441                    seq.serialize_element(value)?;
442                }
443                seq.end()
444            }
445            Value::Mappings(keys_and_values) => {
446                let mut map = serializer.serialize_map(Some(keys_and_values.len()))?;
447                for (key, value) in keys_and_values {
448                    map.serialize_entry(key, value)?;
449                }
450                map.end()
451            }
452        }
453    }
454}
455
456impl<'de: 'a, 'a> Deserialize<'de> for Value<'a> {
457    #[inline]
458    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
459    where
460        D: serde::Deserializer<'de>,
461    {
462        deserializer.deserialize_any(ValueVisitor::default())
463    }
464}
465
466/// A <code>[Value]&lt;&apos;static&gt;</code> wrapper that supports
467/// [`DeserializeOwned`](serde::de::DeserializeOwned).
468///
469/// Because `Value<'a>` can borrow strings and bytes during deserialization,
470/// `Value<'static>` can't be used when `DeserializeOwned` is needed.
471/// [`OwnedValue`] implements [`Deserialize`] by first deserializing a
472/// `Value<'a>` and then using [`Value::into_static`] to convert borrowed data
473/// to owned data.
474#[derive(Debug, Clone, PartialEq)]
475pub struct OwnedValue(pub Value<'static>);
476
477impl Deref for OwnedValue {
478    type Target = Value<'static>;
479
480    #[inline]
481    fn deref(&self) -> &Self::Target {
482        &self.0
483    }
484}
485
486impl DerefMut for OwnedValue {
487    #[inline]
488    fn deref_mut(&mut self) -> &mut Self::Target {
489        &mut self.0
490    }
491}
492
493impl Serialize for OwnedValue {
494    #[inline]
495    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
496    where
497        S: serde::Serializer,
498    {
499        self.0.serialize(serializer)
500    }
501}
502
503impl<'de> Deserialize<'de> for OwnedValue {
504    #[inline]
505    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
506    where
507        D: serde::Deserializer<'de>,
508    {
509        deserializer
510            .deserialize_any(ValueVisitor::default())
511            .map(|value| Self(value.into_static()))
512    }
513}
514
515impl<'a> From<Value<'a>> for OwnedValue {
516    #[inline]
517    fn from(value: Value<'a>) -> Self {
518        Self(value.into_static())
519    }
520}
521
522impl<'a> From<&'a Value<'a>> for OwnedValue {
523    #[inline]
524    fn from(value: &'a Value<'a>) -> Self {
525        Self(value.to_static())
526    }
527}
528
529#[derive(Default)]
530struct ValueVisitor<'a>(PhantomData<&'a ()>);
531
532impl<'de: 'a, 'a> Visitor<'de> for ValueVisitor<'a> {
533    type Value = Value<'a>;
534
535    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
536        formatter.write_str("any value")
537    }
538
539    #[inline]
540    fn visit_none<E>(self) -> Result<Self::Value, E>
541    where
542        E: serde::de::Error,
543    {
544        Ok(Value::None)
545    }
546
547    #[inline]
548    fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
549    where
550        E: serde::de::Error,
551    {
552        Ok(Value::Bool(v))
553    }
554
555    #[inline]
556    fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E>
557    where
558        E: serde::de::Error,
559    {
560        Ok(Value::Integer(Integer::from(v)))
561    }
562
563    #[inline]
564    fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
565    where
566        E: serde::de::Error,
567    {
568        Ok(Value::Integer(Integer::from(v)))
569    }
570
571    #[inline]
572    fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
573    where
574        E: serde::de::Error,
575    {
576        Ok(Value::Integer(Integer::from(v)))
577    }
578
579    #[inline]
580    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
581    where
582        E: serde::de::Error,
583    {
584        Ok(Value::Integer(Integer::from(v)))
585    }
586
587    #[inline]
588    fn visit_i128<E>(self, v: i128) -> Result<Self::Value, E>
589    where
590        E: serde::de::Error,
591    {
592        Ok(Value::Integer(Integer::from(v)))
593    }
594
595    #[inline]
596    fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E>
597    where
598        E: serde::de::Error,
599    {
600        Ok(Value::Integer(Integer::from(v)))
601    }
602
603    #[inline]
604    fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
605    where
606        E: serde::de::Error,
607    {
608        Ok(Value::Integer(Integer::from(v)))
609    }
610
611    #[inline]
612    fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
613    where
614        E: serde::de::Error,
615    {
616        Ok(Value::Integer(Integer::from(v)))
617    }
618
619    #[inline]
620    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
621    where
622        E: serde::de::Error,
623    {
624        Ok(Value::Integer(Integer::from(v)))
625    }
626
627    #[inline]
628    fn visit_u128<E>(self, v: u128) -> Result<Self::Value, E>
629    where
630        E: serde::de::Error,
631    {
632        Ok(Value::Integer(Integer::from(v)))
633    }
634
635    #[inline]
636    fn visit_f32<E>(self, v: f32) -> Result<Self::Value, E>
637    where
638        E: serde::de::Error,
639    {
640        Ok(Value::Float(Float::from(v)))
641    }
642
643    #[inline]
644    fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E>
645    where
646        E: serde::de::Error,
647    {
648        Ok(Value::Float(Float::from(v)))
649    }
650
651    #[inline]
652    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
653    where
654        E: serde::de::Error,
655    {
656        Ok(Value::String(Cow::Owned(v.to_string())))
657    }
658
659    #[inline]
660    fn visit_borrowed_str<E>(self, v: &'a str) -> Result<Self::Value, E>
661    where
662        E: serde::de::Error,
663    {
664        Ok(Value::String(Cow::Borrowed(v)))
665    }
666
667    #[inline]
668    fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
669    where
670        E: serde::de::Error,
671    {
672        Ok(Value::String(Cow::Owned(v)))
673    }
674
675    #[inline]
676    fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
677    where
678        E: serde::de::Error,
679    {
680        Ok(Value::Bytes(Cow::Owned(v.to_vec())))
681    }
682
683    #[inline]
684    fn visit_borrowed_bytes<E>(self, v: &'a [u8]) -> Result<Self::Value, E>
685    where
686        E: serde::de::Error,
687    {
688        Ok(Value::Bytes(Cow::Borrowed(v)))
689    }
690
691    #[inline]
692    fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
693    where
694        E: serde::de::Error,
695    {
696        Ok(Value::Bytes(Cow::Owned(v)))
697    }
698
699    #[inline]
700    fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
701    where
702        D: serde::Deserializer<'de>,
703    {
704        deserializer.deserialize_any(Self::default())
705    }
706
707    #[inline]
708    fn visit_unit<E>(self) -> Result<Self::Value, E>
709    where
710        E: serde::de::Error,
711    {
712        Ok(Value::Unit)
713    }
714
715    #[inline]
716    fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
717    where
718        A: serde::de::SeqAccess<'de>,
719    {
720        let mut values = if let Some(hint) = seq.size_hint() {
721            Vec::with_capacity(hint)
722        } else {
723            Vec::new()
724        };
725        while let Some(value) = seq.next_element()? {
726            values.push(value);
727        }
728        Ok(Value::Sequence(values))
729    }
730
731    #[inline]
732    fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
733    where
734        A: serde::de::MapAccess<'de>,
735    {
736        let mut values = if let Some(hint) = map.size_hint() {
737            Vec::with_capacity(hint)
738        } else {
739            Vec::new()
740        };
741        while let Some(value) = map.next_entry()? {
742            values.push(value);
743        }
744        Ok(Value::Mappings(values))
745    }
746}
747
748impl<'a> From<Option<Value<'a>>> for Value<'a> {
749    #[inline]
750    fn from(value: Option<Value<'a>>) -> Self {
751        if let Some(value) = value {
752            value
753        } else {
754            Value::None
755        }
756    }
757}
758
759impl<'a> From<()> for Value<'a> {
760    #[inline]
761    fn from(_: ()) -> Self {
762        Value::Unit
763    }
764}
765
766impl<'a> From<bool> for Value<'a> {
767    #[inline]
768    fn from(value: bool) -> Self {
769        Value::Bool(value)
770    }
771}
772
773macro_rules! define_value_from_primitive {
774    ($container:ident, $variant:ident, $primitive:ty) => {
775        impl<'a> From<$primitive> for Value<'a> {
776            #[inline]
777            fn from(value: $primitive) -> Self {
778                Self::$container($container::from(value))
779            }
780        }
781    };
782}
783
784define_value_from_primitive!(Integer, U8, u8);
785define_value_from_primitive!(Integer, U16, u16);
786define_value_from_primitive!(Integer, U32, u32);
787define_value_from_primitive!(Integer, U64, u64);
788define_value_from_primitive!(Integer, U128, u128);
789
790define_value_from_primitive!(Integer, I8, i8);
791define_value_from_primitive!(Integer, I16, i16);
792define_value_from_primitive!(Integer, I32, i32);
793define_value_from_primitive!(Integer, I64, i64);
794define_value_from_primitive!(Integer, I128, i128);
795
796define_value_from_primitive!(Float, F32, f32);
797define_value_from_primitive!(Float, F64, f64);
798
799impl<'a> From<&'a [u8]> for Value<'a> {
800    #[inline]
801    fn from(bytes: &'a [u8]) -> Self {
802        Self::Bytes(Cow::Borrowed(bytes))
803    }
804}
805
806impl<'a> From<Vec<u8>> for Value<'a> {
807    #[inline]
808    fn from(bytes: Vec<u8>) -> Self {
809        Self::Bytes(Cow::Owned(bytes))
810    }
811}
812
813impl<'a, const N: usize> From<&'a [u8; N]> for Value<'a> {
814    #[inline]
815    fn from(bytes: &'a [u8; N]) -> Self {
816        Self::Bytes(Cow::Borrowed(bytes))
817    }
818}
819
820impl<'a> From<&'a str> for Value<'a> {
821    #[inline]
822    fn from(string: &'a str) -> Self {
823        Self::String(Cow::Borrowed(string))
824    }
825}
826
827impl<'a> From<String> for Value<'a> {
828    #[inline]
829    fn from(string: String) -> Self {
830        Self::String(Cow::Owned(string))
831    }
832}
833
834impl<'a> From<Vec<Value<'a>>> for Value<'a> {
835    #[inline]
836    fn from(value: Vec<Value<'a>>) -> Self {
837        Self::Sequence(value)
838    }
839}
840
841impl<'a> From<Vec<(Value<'a>, Value<'a>)>> for Value<'a> {
842    #[inline]
843    fn from(value: Vec<(Value<'a>, Value<'a>)>) -> Self {
844        Self::Mappings(value)
845    }
846}
847
848impl<'a, A> FromIterator<A> for Value<'a>
849where
850    A: Into<Value<'a>>,
851{
852    #[inline]
853    fn from_iter<T: IntoIterator<Item = A>>(iter: T) -> Self {
854        Self::from(iter.into_iter().map(A::into).collect::<Vec<_>>())
855    }
856}
857
858impl<'a, K, V> FromIterator<(K, V)> for Value<'a>
859where
860    K: Into<Value<'a>>,
861    V: Into<Value<'a>>,
862{
863    #[inline]
864    fn from_iter<T: IntoIterator<Item = (K, V)>>(iter: T) -> Self {
865        Self::from(
866            iter.into_iter()
867                .map(|(k, v)| (k.into(), v.into()))
868                .collect::<Vec<_>>(),
869        )
870    }
871}
872
873/// An iterator over values contained within a [`Value`].
874pub struct ValueIter<'a>(SequenceIterState<'a>);
875
876enum SequenceIterState<'a> {
877    Sequence(std::slice::Iter<'a, Value<'a>>),
878    Mappings(std::slice::Iter<'a, (Value<'a>, Value<'a>)>),
879}
880
881impl<'a> Iterator for ValueIter<'a> {
882    type Item = &'a Value<'a>;
883
884    #[inline]
885    fn next(&mut self) -> Option<Self::Item> {
886        match &mut self.0 {
887            SequenceIterState::Sequence(sequence) => sequence.next(),
888            SequenceIterState::Mappings(mappings) => mappings.next().map(|(_k, v)| v),
889        }
890    }
891}
892
893impl<'a> ExactSizeIterator for ValueIter<'a> {
894    fn len(&self) -> usize {
895        match &self.0 {
896            SequenceIterState::Sequence(iter) => iter.len(),
897            SequenceIterState::Mappings(iter) => iter.len(),
898        }
899    }
900}
901
902impl<'a> DoubleEndedIterator for ValueIter<'a> {
903    fn next_back(&mut self) -> Option<Self::Item> {
904        match &mut self.0 {
905            SequenceIterState::Sequence(iter) => iter.next_back(),
906            SequenceIterState::Mappings(iter) => iter.next_back().map(|(_k, v)| v),
907        }
908    }
909}
910
911#[test]
912#[allow(clippy::cognitive_complexity)]
913fn value_display_tests() {
914    // Specials
915    assert_eq!(Value::None.to_string(), "None");
916    assert_eq!(Value::Unit.to_string(), "()");
917
918    // Boolean
919    assert_eq!(Value::Bool(false).to_string(), "false");
920    assert_eq!(Value::Bool(true).to_string(), "true");
921
922    // Integer
923    assert_eq!(Value::from(1_u8).to_string(), "1");
924    assert_eq!(Value::from(1_u16).to_string(), "1");
925    assert_eq!(Value::from(1_u32).to_string(), "1");
926    assert_eq!(Value::from(1_u64).to_string(), "1");
927    assert_eq!(Value::from(1_u128).to_string(), "1");
928    assert_eq!(Value::from(1_i8).to_string(), "1");
929    assert_eq!(Value::from(1_i16).to_string(), "1");
930    assert_eq!(Value::from(1_i32).to_string(), "1");
931    assert_eq!(Value::from(1_i64).to_string(), "1");
932    assert_eq!(Value::from(1_i128).to_string(), "1");
933
934    // Float
935    assert_eq!(Value::from(1.1_f32).to_string(), "1.1");
936    assert_eq!(Value::from(1.1_f64).to_string(), "1.1");
937
938    // Bytes
939    assert_eq!(Value::from(b"\xFE\xED\xD0\xD0").to_string(), "0xfeedd0d0");
940    assert_eq!(
941        Value::from(b"\xFE\xED\xD0\xD0\xDE\xAD\xBE\xEF").to_string(),
942        "0xfeedd0d0_deadbeef"
943    );
944
945    // String
946    assert_eq!(Value::from("hello world").to_string(), "hello world");
947
948    // Sequence
949    assert_eq!(
950        Value::from_sequence(Vec::<Value<'_>>::new()).to_string(),
951        "[]"
952    );
953    assert_eq!(
954        Value::from_sequence(vec![Value::None]).to_string(),
955        "[None]"
956    );
957    assert_eq!(
958        Value::from_sequence(vec![Value::None, Value::Unit]).to_string(),
959        "[None, ()]"
960    );
961
962    // Mappings
963    assert_eq!(
964        Value::from_mappings(Vec::<(Value<'_>, Value<'_>)>::new()).to_string(),
965        "{}"
966    );
967    assert_eq!(
968        Value::from_mappings(vec![(Value::from(0_u8), Value::None)]).to_string(),
969        "{0: None}"
970    );
971    assert_eq!(
972        Value::from_mappings(vec![
973            (Value::from(0_u8), Value::None),
974            (Value::from(1_u8), Value::Unit)
975        ])
976        .to_string(),
977        "{0: None, 1: ()}"
978    );
979}
980
981#[test]
982#[allow(clippy::manual_assert)] // approx::assert_relative_eq false positive
983fn value_as_float_tests() {
984    approx::assert_relative_eq!(
985        Value::from(u8::MAX)
986            .as_float()
987            .expect("u8 conversion failed")
988            .as_f32()
989            .expect("f32 conversion failed"),
990        255_f32,
991    );
992    approx::assert_relative_eq!(
993        Value::from(u32::MAX)
994            .as_float()
995            .expect("u32 conversion failed")
996            .as_f64(),
997        4_294_967_295_f64,
998    );
999    assert!(Value::from(u32::MAX)
1000        .as_float()
1001        .expect("u32 conversion failed")
1002        .as_f32()
1003        .is_err());
1004
1005    approx::assert_relative_eq!(Value::from(0_f64).as_float().unwrap().as_f32().unwrap(), 0.);
1006}
1007
1008#[test]
1009fn value_as_integer_tests() {
1010    macro_rules! test_signed {
1011        ($primitive:ty, $signed_method:ident, $unsigned:ty, $unsigned_method:ident, $float:ty) => {
1012            assert_eq!(
1013                Value::from(<$primitive>::MAX)
1014                    .as_integer()
1015                    .expect("integer conversion failed")
1016                    .$signed_method()
1017                    .unwrap(),
1018                <$primitive>::MAX,
1019            );
1020            assert_eq!(
1021                Value::from(<$primitive>::MIN)
1022                    .as_integer()
1023                    .expect("integer conversion failed")
1024                    .$signed_method()
1025                    .unwrap(),
1026                <$primitive>::MIN,
1027            );
1028            assert_eq!(
1029                Value::from(<$primitive>::MAX)
1030                    .as_integer()
1031                    .expect("integer conversion failed")
1032                    .$unsigned_method()
1033                    .unwrap(),
1034                <$unsigned>::try_from(<$primitive>::MAX).unwrap(),
1035            );
1036
1037            assert_eq!(
1038                Value::from(<$float>::from(<$primitive>::MAX))
1039                    .as_integer()
1040                    .expect("integer conversion failed")
1041                    .$signed_method()
1042                    .unwrap(),
1043                <$primitive>::MAX,
1044            );
1045            assert_eq!(
1046                Value::from(<$float>::from(<$primitive>::MIN))
1047                    .as_integer()
1048                    .expect("integer conversion failed")
1049                    .$signed_method()
1050                    .unwrap(),
1051                <$primitive>::MIN,
1052            );
1053            assert_eq!(
1054                Value::from(<$float>::from(<$primitive>::MAX))
1055                    .as_integer()
1056                    .expect("integer conversion failed")
1057                    .$unsigned_method()
1058                    .unwrap(),
1059                <$unsigned>::try_from(<$primitive>::MAX).unwrap(),
1060            );
1061        };
1062    }
1063
1064    test_signed!(i8, as_i8, u8, as_u8, f32);
1065    test_signed!(i16, as_i16, u16, as_u16, f32);
1066    test_signed!(i32, as_i32, u32, as_u32, f64);
1067
1068    macro_rules! test_unsigned {
1069        ($primitive:ty, $unsigned_method:ident, $signed:ty, $signed_method:ident, $float:ty) => {
1070            assert_eq!(
1071                Value::from(<$primitive>::MAX)
1072                    .as_integer()
1073                    .expect("integer conversion failed")
1074                    .$unsigned_method()
1075                    .unwrap(),
1076                <$primitive>::MAX,
1077            );
1078            assert!(Value::from(<$primitive>::MAX)
1079                .as_integer()
1080                .expect("integer conversion failed")
1081                .$signed_method()
1082                .is_err());
1083            assert_eq!(
1084                Value::from(<$float>::from(<$primitive>::MAX))
1085                    .as_integer()
1086                    .expect("integer conversion failed")
1087                    .$unsigned_method()
1088                    .unwrap(),
1089                <$primitive>::MAX,
1090            );
1091            assert!(Value::from(<$float>::from(<$primitive>::MAX))
1092                .as_integer()
1093                .expect("integer conversion failed")
1094                .$signed_method()
1095                .is_err());
1096        };
1097    }
1098
1099    test_unsigned!(u8, as_u8, i8, as_i8, f32);
1100    test_unsigned!(u16, as_u16, i16, as_i16, f32);
1101    test_unsigned!(u32, as_u32, i32, as_i32, f64);
1102}
1103
1104struct Serializer;
1105
1106impl serde::Serializer for Serializer {
1107    type Error = ValueError;
1108    type Ok = Value<'static>;
1109    type SerializeMap = MappingsSerializer;
1110    type SerializeSeq = SequenceSerializer;
1111    type SerializeStruct = MappingsSerializer;
1112    type SerializeStructVariant = StructVariantSerializer;
1113    type SerializeTuple = SequenceSerializer;
1114    type SerializeTupleStruct = SequenceSerializer;
1115    type SerializeTupleVariant = TupleVariantSerializer;
1116
1117    fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
1118        Ok(Value::Bool(v))
1119    }
1120
1121    fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
1122        Ok(Value::Integer(Integer::from(v)))
1123    }
1124
1125    fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
1126        Ok(Value::Integer(Integer::from(v)))
1127    }
1128
1129    fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
1130        Ok(Value::Integer(Integer::from(v)))
1131    }
1132
1133    fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
1134        Ok(Value::Integer(Integer::from(v)))
1135    }
1136
1137    fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error> {
1138        Ok(Value::Integer(Integer::from(v)))
1139    }
1140
1141    fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
1142        Ok(Value::Integer(Integer::from(v)))
1143    }
1144
1145    fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
1146        Ok(Value::Integer(Integer::from(v)))
1147    }
1148
1149    fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
1150        Ok(Value::Integer(Integer::from(v)))
1151    }
1152
1153    fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
1154        Ok(Value::Integer(Integer::from(v)))
1155    }
1156
1157    fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error> {
1158        Ok(Value::Integer(Integer::from(v)))
1159    }
1160
1161    fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
1162        Ok(Value::Float(Float::from(v)))
1163    }
1164
1165    fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
1166        Ok(Value::Float(Float::from(v)))
1167    }
1168
1169    fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
1170        Ok(Value::Integer(Integer::from(u32::from(v))))
1171    }
1172
1173    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
1174        Ok(Value::String(Cow::Owned(v.to_string())))
1175    }
1176
1177    fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
1178        Ok(Value::Bytes(Cow::Owned(v.to_vec())))
1179    }
1180
1181    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
1182        Ok(Value::None)
1183    }
1184
1185    fn serialize_some<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
1186    where
1187        T: Serialize + ?Sized,
1188    {
1189        value.serialize(Self)
1190    }
1191
1192    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
1193        Ok(Value::Unit)
1194    }
1195
1196    fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
1197        Ok(Value::Unit)
1198    }
1199
1200    fn serialize_unit_variant(
1201        self,
1202        _name: &'static str,
1203        _variant_index: u32,
1204        variant: &'static str,
1205    ) -> Result<Self::Ok, Self::Error> {
1206        Ok(Value::String(Cow::Borrowed(variant)))
1207    }
1208
1209    fn serialize_newtype_struct<T>(
1210        self,
1211        _name: &'static str,
1212        value: &T,
1213    ) -> Result<Self::Ok, Self::Error>
1214    where
1215        T: Serialize + ?Sized,
1216    {
1217        value.serialize(Self)
1218    }
1219
1220    fn serialize_newtype_variant<T>(
1221        self,
1222        _name: &'static str,
1223        _variant_index: u32,
1224        variant: &'static str,
1225        value: &T,
1226    ) -> Result<Self::Ok, Self::Error>
1227    where
1228        T: Serialize + ?Sized,
1229    {
1230        Ok(Value::Mappings(vec![(
1231            Value::String(Cow::Borrowed(variant)),
1232            value.serialize(Self)?,
1233        )]))
1234    }
1235
1236    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
1237        Ok(SequenceSerializer(
1238            len.map_or_else(Vec::new, Vec::with_capacity),
1239        ))
1240    }
1241
1242    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
1243        Ok(SequenceSerializer(Vec::with_capacity(len)))
1244    }
1245
1246    fn serialize_tuple_struct(
1247        self,
1248        _name: &'static str,
1249        len: usize,
1250    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
1251        Ok(SequenceSerializer(Vec::with_capacity(len)))
1252    }
1253
1254    fn serialize_tuple_variant(
1255        self,
1256        _name: &'static str,
1257        _variant_index: u32,
1258        variant: &'static str,
1259        len: usize,
1260    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
1261        Ok(TupleVariantSerializer {
1262            variant,
1263            sequence: Vec::with_capacity(len),
1264        })
1265    }
1266
1267    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
1268        Ok(MappingsSerializer(
1269            len.map_or_else(Vec::new, Vec::with_capacity),
1270        ))
1271    }
1272
1273    fn serialize_struct(
1274        self,
1275        _name: &'static str,
1276        len: usize,
1277    ) -> Result<Self::SerializeStruct, Self::Error> {
1278        Ok(MappingsSerializer(Vec::with_capacity(len)))
1279    }
1280
1281    fn serialize_struct_variant(
1282        self,
1283        _name: &'static str,
1284        _variant_index: u32,
1285        variant: &'static str,
1286        len: usize,
1287    ) -> Result<Self::SerializeStructVariant, Self::Error> {
1288        Ok(StructVariantSerializer {
1289            variant,
1290            mappings: Vec::with_capacity(len),
1291        })
1292    }
1293}
1294
1295struct SequenceSerializer(Vec<Value<'static>>);
1296
1297impl SerializeSeq for SequenceSerializer {
1298    type Error = ValueError;
1299    type Ok = Value<'static>;
1300
1301    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
1302    where
1303        T: Serialize + ?Sized,
1304    {
1305        self.0.push(value.serialize(Serializer)?);
1306        Ok(())
1307    }
1308
1309    fn end(self) -> Result<Self::Ok, Self::Error> {
1310        Ok(Value::Sequence(self.0))
1311    }
1312}
1313
1314impl SerializeTuple for SequenceSerializer {
1315    type Error = ValueError;
1316    type Ok = Value<'static>;
1317
1318    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
1319    where
1320        T: Serialize + ?Sized,
1321    {
1322        self.0.push(value.serialize(Serializer)?);
1323        Ok(())
1324    }
1325
1326    fn end(self) -> Result<Self::Ok, Self::Error> {
1327        Ok(Value::Sequence(self.0))
1328    }
1329}
1330
1331impl SerializeTupleStruct for SequenceSerializer {
1332    type Error = ValueError;
1333    type Ok = Value<'static>;
1334
1335    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
1336    where
1337        T: Serialize + ?Sized,
1338    {
1339        self.0.push(value.serialize(Serializer)?);
1340        Ok(())
1341    }
1342
1343    fn end(self) -> Result<Self::Ok, Self::Error> {
1344        Ok(Value::Sequence(self.0))
1345    }
1346}
1347
1348struct TupleVariantSerializer {
1349    variant: &'static str,
1350    sequence: Vec<Value<'static>>,
1351}
1352
1353impl SerializeTupleVariant for TupleVariantSerializer {
1354    type Error = ValueError;
1355    type Ok = Value<'static>;
1356
1357    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
1358    where
1359        T: Serialize + ?Sized,
1360    {
1361        self.sequence.push(value.serialize(Serializer)?);
1362        Ok(())
1363    }
1364
1365    fn end(self) -> Result<Self::Ok, Self::Error> {
1366        Ok(Value::Mappings(vec![(
1367            Value::String(Cow::Borrowed(self.variant)),
1368            Value::Sequence(self.sequence),
1369        )]))
1370    }
1371}
1372
1373struct MappingsSerializer(Vec<(Value<'static>, Value<'static>)>);
1374
1375impl SerializeMap for MappingsSerializer {
1376    type Error = ValueError;
1377    type Ok = Value<'static>;
1378
1379    fn serialize_key<T>(&mut self, key: &T) -> Result<(), Self::Error>
1380    where
1381        T: Serialize + ?Sized,
1382    {
1383        self.0.push((key.serialize(Serializer)?, Value::None));
1384        Ok(())
1385    }
1386
1387    fn serialize_value<T>(&mut self, value: &T) -> Result<(), Self::Error>
1388    where
1389        T: Serialize + ?Sized,
1390    {
1391        self.0
1392            .last_mut()
1393            .expect("serialize_value called without serialize_key")
1394            .1 = value.serialize(Serializer)?;
1395        Ok(())
1396    }
1397
1398    fn end(self) -> Result<Self::Ok, Self::Error> {
1399        Ok(Value::Mappings(self.0))
1400    }
1401}
1402
1403impl SerializeStruct for MappingsSerializer {
1404    type Error = ValueError;
1405    type Ok = Value<'static>;
1406
1407    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
1408    where
1409        T: Serialize + ?Sized,
1410    {
1411        self.0.push((
1412            Value::String(Cow::Borrowed(key)),
1413            value.serialize(Serializer)?,
1414        ));
1415        Ok(())
1416    }
1417
1418    fn end(self) -> Result<Self::Ok, Self::Error> {
1419        Ok(Value::Mappings(self.0))
1420    }
1421}
1422
1423struct StructVariantSerializer {
1424    variant: &'static str,
1425    mappings: Vec<(Value<'static>, Value<'static>)>,
1426}
1427
1428impl SerializeStructVariant for StructVariantSerializer {
1429    type Error = ValueError;
1430    type Ok = Value<'static>;
1431
1432    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
1433    where
1434        T: Serialize + ?Sized,
1435    {
1436        self.mappings.push((
1437            Value::String(Cow::Borrowed(key)),
1438            value.serialize(Serializer)?,
1439        ));
1440        Ok(())
1441    }
1442
1443    fn end(self) -> Result<Self::Ok, Self::Error> {
1444        Ok(Value::Mappings(vec![(
1445            Value::String(Cow::Borrowed(self.variant)),
1446            Value::Mappings(self.mappings),
1447        )]))
1448    }
1449}
1450
1451struct Deserializer<'de>(&'de Value<'de>);
1452
1453impl<'de> serde::Deserializer<'de> for Deserializer<'de> {
1454    type Error = ValueError;
1455
1456    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1457    where
1458        V: Visitor<'de>,
1459    {
1460        match &self.0 {
1461            Value::None => visitor.visit_none(),
1462            Value::Unit => visitor.visit_unit(),
1463            Value::Bool(value) => visitor.visit_bool(*value),
1464            Value::Integer(integer) => match integer.0 {
1465                InnerInteger::I8(value) => visitor.visit_i8(value),
1466                InnerInteger::I16(value) => visitor.visit_i16(value),
1467                InnerInteger::I32(value) => visitor.visit_i32(value),
1468                InnerInteger::I64(value) => visitor.visit_i64(value),
1469                InnerInteger::I128(value) => visitor.visit_i128(value),
1470                InnerInteger::U8(value) => visitor.visit_u8(value),
1471                InnerInteger::U16(value) => visitor.visit_u16(value),
1472                InnerInteger::U32(value) => visitor.visit_u32(value),
1473                InnerInteger::U64(value) => visitor.visit_u64(value),
1474                InnerInteger::U128(value) => visitor.visit_u128(value),
1475            },
1476            Value::Float(float) => match float.0 {
1477                InnerFloat::F64(value) => visitor.visit_f64(value),
1478                InnerFloat::F32(value) => visitor.visit_f32(value),
1479            },
1480            Value::Bytes(bytes) => visitor.visit_bytes(bytes),
1481            Value::String(str) => visitor.visit_str(str),
1482            Value::Sequence(seq) => visitor.visit_seq(SequenceDeserializer(seq)),
1483            Value::Mappings(mappings) => visitor.visit_map(MappingsDeserializer(mappings)),
1484        }
1485    }
1486
1487    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1488    where
1489        V: Visitor<'de>,
1490    {
1491        if let Value::Bool(value) = &self.0 {
1492            visitor.visit_bool(*value)
1493        } else {
1494            Err(ValueError::Expected {
1495                kind: "bool",
1496                value: self.0.to_static(),
1497            })
1498        }
1499    }
1500
1501    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1502    where
1503        V: Visitor<'de>,
1504    {
1505        if let Value::Integer(value) = &self.0 {
1506            if let Ok(value) = value.as_i8() {
1507                return visitor.visit_i8(value);
1508            }
1509        }
1510
1511        Err(ValueError::Expected {
1512            kind: "i8",
1513            value: self.0.to_static(),
1514        })
1515    }
1516
1517    fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1518    where
1519        V: Visitor<'de>,
1520    {
1521        if let Value::Integer(value) = &self.0 {
1522            if let Ok(value) = value.as_i16() {
1523                return visitor.visit_i16(value);
1524            }
1525        }
1526
1527        Err(ValueError::Expected {
1528            kind: "i16",
1529            value: self.0.to_static(),
1530        })
1531    }
1532
1533    fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1534    where
1535        V: Visitor<'de>,
1536    {
1537        if let Value::Integer(value) = &self.0 {
1538            if let Ok(value) = value.as_i32() {
1539                return visitor.visit_i32(value);
1540            }
1541        }
1542
1543        Err(ValueError::Expected {
1544            kind: "i32",
1545            value: self.0.to_static(),
1546        })
1547    }
1548
1549    fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1550    where
1551        V: Visitor<'de>,
1552    {
1553        if let Value::Integer(value) = &self.0 {
1554            if let Ok(value) = value.as_i64() {
1555                return visitor.visit_i64(value);
1556            }
1557        }
1558
1559        Err(ValueError::Expected {
1560            kind: "i64",
1561            value: self.0.to_static(),
1562        })
1563    }
1564
1565    fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1566    where
1567        V: Visitor<'de>,
1568    {
1569        if let Value::Integer(value) = &self.0 {
1570            if let Ok(value) = value.as_i128() {
1571                return visitor.visit_i128(value);
1572            }
1573        }
1574
1575        Err(ValueError::Expected {
1576            kind: "i128",
1577            value: self.0.to_static(),
1578        })
1579    }
1580
1581    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1582    where
1583        V: Visitor<'de>,
1584    {
1585        if let Value::Integer(value) = &self.0 {
1586            if let Ok(value) = value.as_u8() {
1587                return visitor.visit_u8(value);
1588            }
1589        }
1590
1591        Err(ValueError::Expected {
1592            kind: "u8",
1593            value: self.0.to_static(),
1594        })
1595    }
1596
1597    fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1598    where
1599        V: Visitor<'de>,
1600    {
1601        if let Value::Integer(value) = &self.0 {
1602            if let Ok(value) = value.as_u16() {
1603                return visitor.visit_u16(value);
1604            }
1605        }
1606
1607        Err(ValueError::Expected {
1608            kind: "u16",
1609            value: self.0.to_static(),
1610        })
1611    }
1612
1613    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1614    where
1615        V: Visitor<'de>,
1616    {
1617        if let Value::Integer(value) = &self.0 {
1618            if let Ok(value) = value.as_u32() {
1619                return visitor.visit_u32(value);
1620            }
1621        }
1622
1623        Err(ValueError::Expected {
1624            kind: "u32",
1625            value: self.0.to_static(),
1626        })
1627    }
1628
1629    fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1630    where
1631        V: Visitor<'de>,
1632    {
1633        if let Value::Integer(value) = &self.0 {
1634            if let Ok(value) = value.as_u64() {
1635                return visitor.visit_u64(value);
1636            }
1637        }
1638
1639        Err(ValueError::Expected {
1640            kind: "u64",
1641            value: self.0.to_static(),
1642        })
1643    }
1644
1645    fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1646    where
1647        V: Visitor<'de>,
1648    {
1649        if let Value::Integer(value) = &self.0 {
1650            if let Ok(value) = value.as_u128() {
1651                return visitor.visit_u128(value);
1652            }
1653        }
1654
1655        Err(ValueError::Expected {
1656            kind: "u128",
1657            value: self.0.to_static(),
1658        })
1659    }
1660
1661    fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1662    where
1663        V: Visitor<'de>,
1664    {
1665        if let Value::Float(value) = &self.0 {
1666            if let Ok(value) = value.as_f32() {
1667                return visitor.visit_f32(value);
1668            }
1669        }
1670
1671        Err(ValueError::Expected {
1672            kind: "f32",
1673            value: self.0.to_static(),
1674        })
1675    }
1676
1677    fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1678    where
1679        V: Visitor<'de>,
1680    {
1681        if let Value::Float(value) = &self.0 {
1682            visitor.visit_f64(value.as_f64())
1683        } else {
1684            Err(ValueError::Expected {
1685                kind: "f64",
1686                value: self.0.to_static(),
1687            })
1688        }
1689    }
1690
1691    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1692    where
1693        V: Visitor<'de>,
1694    {
1695        if let Value::Integer(value) = &self.0 {
1696            if let Ok(value) = value.as_u32() {
1697                if let Ok(char) = char::try_from(value) {
1698                    return visitor.visit_char(char);
1699                }
1700            }
1701        }
1702
1703        Err(ValueError::Expected {
1704            kind: "char",
1705            value: self.0.to_static(),
1706        })
1707    }
1708
1709    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1710    where
1711        V: Visitor<'de>,
1712    {
1713        if let Value::String(value) = &self.0 {
1714            visitor.visit_borrowed_str(value)
1715        } else {
1716            Err(ValueError::Expected {
1717                kind: "str",
1718                value: self.0.to_static(),
1719            })
1720        }
1721    }
1722
1723    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1724    where
1725        V: Visitor<'de>,
1726    {
1727        if let Value::String(value) = &self.0 {
1728            visitor.visit_borrowed_str(value)
1729        } else {
1730            Err(ValueError::Expected {
1731                kind: "String",
1732                value: self.0.to_static(),
1733            })
1734        }
1735    }
1736
1737    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1738    where
1739        V: Visitor<'de>,
1740    {
1741        if let Value::Bytes(value) = &self.0 {
1742            visitor.visit_borrowed_bytes(value)
1743        } else {
1744            Err(ValueError::Expected {
1745                kind: "bytes",
1746                value: self.0.to_static(),
1747            })
1748        }
1749    }
1750
1751    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1752    where
1753        V: Visitor<'de>,
1754    {
1755        if let Value::Bytes(value) = &self.0 {
1756            visitor.visit_borrowed_bytes(value)
1757        } else {
1758            Err(ValueError::Expected {
1759                kind: "byte buf",
1760                value: self.0.to_static(),
1761            })
1762        }
1763    }
1764
1765    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1766    where
1767        V: Visitor<'de>,
1768    {
1769        if matches!(&self.0, Value::None) {
1770            visitor.visit_none()
1771        } else {
1772            visitor.visit_some(self)
1773        }
1774    }
1775
1776    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1777    where
1778        V: Visitor<'de>,
1779    {
1780        if let Value::Unit = &self.0 {
1781            visitor.visit_unit()
1782        } else {
1783            Err(ValueError::Expected {
1784                kind: "()",
1785                value: self.0.to_static(),
1786            })
1787        }
1788    }
1789
1790    fn deserialize_unit_struct<V>(
1791        self,
1792        _name: &'static str,
1793        visitor: V,
1794    ) -> Result<V::Value, Self::Error>
1795    where
1796        V: Visitor<'de>,
1797    {
1798        if let Value::Unit = &self.0 {
1799            visitor.visit_unit()
1800        } else {
1801            Err(ValueError::Expected {
1802                kind: "()",
1803                value: self.0.to_static(),
1804            })
1805        }
1806    }
1807
1808    fn deserialize_newtype_struct<V>(
1809        self,
1810        _name: &'static str,
1811        visitor: V,
1812    ) -> Result<V::Value, Self::Error>
1813    where
1814        V: Visitor<'de>,
1815    {
1816        visitor.visit_newtype_struct(self)
1817    }
1818
1819    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1820    where
1821        V: Visitor<'de>,
1822    {
1823        if let Value::Sequence(sequence) = &self.0 {
1824            visitor.visit_seq(SequenceDeserializer(sequence))
1825        } else {
1826            Err(ValueError::Expected {
1827                kind: "sequence",
1828                value: self.0.to_static(),
1829            })
1830        }
1831    }
1832
1833    fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
1834    where
1835        V: Visitor<'de>,
1836    {
1837        if let Value::Sequence(sequence) = &self.0 {
1838            visitor.visit_seq(SequenceDeserializer(sequence))
1839        } else {
1840            Err(ValueError::Expected {
1841                kind: "tuple",
1842                value: self.0.to_static(),
1843            })
1844        }
1845    }
1846
1847    fn deserialize_tuple_struct<V>(
1848        self,
1849        _name: &'static str,
1850        _len: usize,
1851        visitor: V,
1852    ) -> Result<V::Value, Self::Error>
1853    where
1854        V: Visitor<'de>,
1855    {
1856        if let Value::Sequence(sequence) = &self.0 {
1857            visitor.visit_seq(SequenceDeserializer(sequence))
1858        } else {
1859            Err(ValueError::Expected {
1860                kind: "tuple struct",
1861                value: self.0.to_static(),
1862            })
1863        }
1864    }
1865
1866    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1867    where
1868        V: Visitor<'de>,
1869    {
1870        if let Value::Mappings(sequence) = &self.0 {
1871            visitor.visit_map(MappingsDeserializer(sequence))
1872        } else {
1873            Err(ValueError::Expected {
1874                kind: "map",
1875                value: self.0.to_static(),
1876            })
1877        }
1878    }
1879
1880    fn deserialize_struct<V>(
1881        self,
1882        _name: &'static str,
1883        _fields: &'static [&'static str],
1884        visitor: V,
1885    ) -> Result<V::Value, Self::Error>
1886    where
1887        V: Visitor<'de>,
1888    {
1889        if let Value::Mappings(sequence) = &self.0 {
1890            visitor.visit_map(MappingsDeserializer(sequence))
1891        } else {
1892            Err(ValueError::Expected {
1893                kind: "map",
1894                value: self.0.to_static(),
1895            })
1896        }
1897    }
1898
1899    fn deserialize_enum<V>(
1900        self,
1901        _name: &'static str,
1902        _variants: &'static [&'static str],
1903        visitor: V,
1904    ) -> Result<V::Value, Self::Error>
1905    where
1906        V: Visitor<'de>,
1907    {
1908        visitor.visit_enum(self)
1909    }
1910
1911    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1912    where
1913        V: Visitor<'de>,
1914    {
1915        self.deserialize_str(visitor)
1916    }
1917
1918    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1919    where
1920        V: Visitor<'de>,
1921    {
1922        self.deserialize_any(visitor)
1923    }
1924}
1925
1926impl<'de> EnumAccess<'de> for Deserializer<'de> {
1927    type Error = ValueError;
1928    type Variant = Self;
1929
1930    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
1931    where
1932        V: serde::de::DeserializeSeed<'de>,
1933    {
1934        match &self.0 {
1935            Value::Mappings(mapping) => {
1936                if !mapping.is_empty() {
1937                    let variant = seed.deserialize(Deserializer(&mapping[0].0))?;
1938                    return Ok((variant, Deserializer(&mapping[0].1)));
1939                }
1940            }
1941            Value::String(_) => {
1942                let variant = seed.deserialize(Deserializer(self.0))?;
1943                return Ok((variant, Deserializer(&Value::Unit)));
1944            }
1945            _ => {}
1946        }
1947
1948        Err(ValueError::Expected {
1949            kind: "enum variant",
1950            value: self.0.to_static(),
1951        })
1952    }
1953}
1954
1955impl<'de> VariantAccess<'de> for Deserializer<'de> {
1956    type Error = ValueError;
1957
1958    fn unit_variant(self) -> Result<(), Self::Error> {
1959        if matches!(self.0, Value::Unit) {
1960            Ok(())
1961        } else {
1962            Err(ValueError::Expected {
1963                kind: "unit",
1964                value: self.0.to_static(),
1965            })
1966        }
1967    }
1968
1969    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Self::Error>
1970    where
1971        T: serde::de::DeserializeSeed<'de>,
1972    {
1973        seed.deserialize(self)
1974    }
1975
1976    fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
1977    where
1978        V: Visitor<'de>,
1979    {
1980        if let Value::Sequence(sequence) = &self.0 {
1981            visitor.visit_seq(SequenceDeserializer(sequence))
1982        } else {
1983            Err(ValueError::Expected {
1984                kind: "tuple variant",
1985                value: self.0.to_static(),
1986            })
1987        }
1988    }
1989
1990    fn struct_variant<V>(
1991        self,
1992        _fields: &'static [&'static str],
1993        visitor: V,
1994    ) -> Result<V::Value, Self::Error>
1995    where
1996        V: Visitor<'de>,
1997    {
1998        if let Value::Mappings(mappings) = &self.0 {
1999            visitor.visit_map(MappingsDeserializer(mappings))
2000        } else {
2001            Err(ValueError::Expected {
2002                kind: "struct variant",
2003                value: self.0.to_static(),
2004            })
2005        }
2006    }
2007}
2008
2009struct SequenceDeserializer<'de>(&'de [Value<'de>]);
2010
2011impl<'de> SeqAccess<'de> for SequenceDeserializer<'de> {
2012    type Error = ValueError;
2013
2014    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
2015    where
2016        T: serde::de::DeserializeSeed<'de>,
2017    {
2018        if self.0.is_empty() {
2019            Ok(None)
2020        } else {
2021            let value = seed.deserialize(Deserializer(&self.0[0]))?;
2022            self.0 = &self.0[1..];
2023            Ok(Some(value))
2024        }
2025    }
2026
2027    fn size_hint(&self) -> Option<usize> {
2028        Some(self.0.len())
2029    }
2030}
2031
2032struct MappingsDeserializer<'de>(&'de [(Value<'de>, Value<'de>)]);
2033
2034impl<'de> MapAccess<'de> for MappingsDeserializer<'de> {
2035    type Error = ValueError;
2036
2037    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
2038    where
2039        K: serde::de::DeserializeSeed<'de>,
2040    {
2041        if self.0.is_empty() {
2042            Ok(None)
2043        } else {
2044            let key = seed.deserialize(Deserializer(&self.0[0].0))?;
2045            Ok(Some(key))
2046        }
2047    }
2048
2049    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
2050    where
2051        V: serde::de::DeserializeSeed<'de>,
2052    {
2053        let value = seed.deserialize(Deserializer(&self.0[0].1))?;
2054        self.0 = &self.0[1..];
2055        Ok(value)
2056    }
2057
2058    fn size_hint(&self) -> Option<usize> {
2059        Some(self.0.len())
2060    }
2061}
2062
2063/// An error from deserializing a type using [`Value::deserialize_as`].
2064#[derive(Debug, PartialEq)]
2065pub enum ValueError {
2066    /// A kind of data was expected, but the [`Value`] cannot be interpreted as
2067    /// that kind.
2068    Expected {
2069        /// The kind of data expected.
2070        kind: &'static str,
2071        /// The value that was encountered.
2072        value: Value<'static>,
2073    },
2074    /// A custom deserialization error. These errors originate outside of Pot.
2075    Custom(String),
2076}
2077
2078impl std::error::Error for ValueError {}
2079
2080impl Display for ValueError {
2081    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2082        match self {
2083            ValueError::Expected { kind, value } => write!(f, "expected {kind} but got {value}"),
2084            ValueError::Custom(msg) => f.write_str(msg),
2085        }
2086    }
2087}
2088
2089impl serde::de::Error for ValueError {
2090    fn custom<T>(msg: T) -> Self
2091    where
2092        T: Display,
2093    {
2094        Self::Custom(msg.to_string())
2095    }
2096}
2097
2098impl serde::ser::Error for ValueError {
2099    fn custom<T>(msg: T) -> Self
2100    where
2101        T: Display,
2102    {
2103        Self::Custom(msg.to_string())
2104    }
2105}
2106
2107#[test]
2108fn is_empty() {
2109    for expected_empty in [
2110        Value::None,
2111        Value::Bytes(Cow::Borrowed(b"")),
2112        Value::String(Cow::Borrowed("")),
2113        Value::Sequence(vec![]),
2114        Value::Mappings(vec![]),
2115    ] {
2116        assert!(expected_empty.is_empty(), "{expected_empty} was not empty");
2117    }
2118    for expected_not_empty in [
2119        Value::Unit,
2120        Value::Bool(true),
2121        Value::Integer(Integer::from(0)),
2122        Value::Float(Float::from(0f32)),
2123        Value::Bytes(Cow::Borrowed(b"a")),
2124        Value::String(Cow::Borrowed("a")),
2125        Value::Sequence(vec![Value::None]),
2126        Value::Mappings(vec![(Value::None, Value::None)]),
2127    ] {
2128        assert!(
2129            !expected_not_empty.is_empty(),
2130            "{expected_not_empty} was empty"
2131        );
2132    }
2133}
2134
2135#[test]
2136fn as_bool() {
2137    for expected_true in [
2138        Value::Unit,
2139        Value::Bool(true),
2140        Value::Integer(Integer::from(1)),
2141        Value::Float(Float::from(1f32)),
2142        Value::Bytes(Cow::Borrowed(b"a")),
2143        Value::String(Cow::Borrowed("a")),
2144        Value::Sequence(vec![Value::None]),
2145        Value::Mappings(vec![(Value::None, Value::None)]),
2146    ] {
2147        assert!(expected_true.as_bool(), "{expected_true} was false");
2148    }
2149    for expected_false in [
2150        Value::None,
2151        Value::Bool(false),
2152        Value::Integer(Integer::from(0)),
2153        Value::Float(Float::from(0f32)),
2154        Value::Bytes(Cow::Borrowed(b"")),
2155        Value::String(Cow::Borrowed("")),
2156        Value::Sequence(vec![]),
2157        Value::Mappings(vec![]),
2158    ] {
2159        assert!(!expected_false.as_bool(), "{expected_false} was true");
2160    }
2161}
2162
2163#[test]
2164fn as_integer() {
2165    assert_eq!(
2166        Value::from(1_i32).as_integer().unwrap().as_i32().unwrap(),
2167        1
2168    );
2169    assert_eq!(
2170        Value::from(1_f32).as_integer().unwrap().as_i32().unwrap(),
2171        1
2172    );
2173    assert_eq!(Value::from(true).as_integer(), None);
2174}
2175
2176#[test]
2177fn as_float() {
2178    approx::assert_abs_diff_eq!(
2179        Value::from(1_i32).as_float().unwrap().as_f32().unwrap(),
2180        1_f32
2181    );
2182
2183    approx::assert_abs_diff_eq!(
2184        Value::from(1_f32).as_float().unwrap().as_f32().unwrap(),
2185        1_f32
2186    );
2187    assert_eq!(Value::from(true).as_float(), None);
2188}
2189
2190#[test]
2191fn as_str() {
2192    assert_eq!(Value::from("asdf").as_str(), Some("asdf"));
2193    assert_eq!(Value::from(b"asdf").as_str(), Some("asdf"));
2194    assert_eq!(Value::from(false).as_str(), None);
2195}
2196
2197#[test]
2198fn as_bytes() {
2199    assert_eq!(Value::from(b"asdf").as_bytes(), Some(&b"asdf"[..]));
2200    assert_eq!(Value::from("asdf").as_bytes(), Some(&b"asdf"[..]));
2201    assert_eq!(Value::from(false).as_bytes(), None);
2202}
2203
2204#[test]
2205fn values() {
2206    assert_eq!(
2207        Value::from_sequence([Value::Bool(true), Value::Bool(false)])
2208            .values()
2209            .collect::<Vec<_>>(),
2210        &[&Value::Bool(true), &Value::Bool(false)]
2211    );
2212    assert_eq!(
2213        Value::from_mappings([(0, Value::Bool(true)), (1, Value::Bool(false))])
2214            .values()
2215            .collect::<Vec<_>>(),
2216        &[&Value::Bool(true), &Value::Bool(false)]
2217    );
2218    assert_eq!(Value::from(None).values().count(), 0);
2219}
2220
2221#[test]
2222fn mappings() {
2223    assert_eq!(
2224        Value::from_sequence([Value::Bool(true), Value::Bool(false)])
2225            .mappings()
2226            .cloned()
2227            .collect::<Vec<_>>(),
2228        &[]
2229    );
2230    assert_eq!(
2231        Value::from_mappings([(0, Value::Bool(true)), (1, Value::Bool(false))])
2232            .mappings()
2233            .collect::<Vec<_>>(),
2234        &[
2235            &(Value::from(0), Value::Bool(true)),
2236            &(Value::from(1), Value::Bool(false))
2237        ]
2238    );
2239    assert!(Value::from(false).mappings().collect::<Vec<_>>().is_empty());
2240}
2241
2242#[test]
2243fn into_static() {
2244    for borrowed in [
2245        Value::from(None),
2246        Value::from(Some(Value::from(()))),
2247        Value::from(true),
2248        Value::from(1_i32),
2249        Value::from(1_f32),
2250        Value::from(&b"hi"[..]),
2251        Value::from("hi"),
2252        Value::from_sequence([1]),
2253        Value::from_mappings([(1, 2)]),
2254    ] {
2255        let cloned = borrowed.clone();
2256        let s = borrowed.to_static();
2257        assert_eq!(borrowed.to_static(), borrowed);
2258        // The first pass had borrowed strings/bytes. The static version has
2259        // owned values, so these invocations take a slightly different path.
2260        assert_eq!(borrowed, s.to_static());
2261
2262        assert_eq!(borrowed.into_static(), cloned);
2263        assert_eq!(cloned, s.into_static());
2264    }
2265}
2266
2267#[test]
2268fn owned_deref() {
2269    let mut owned_value = OwnedValue::from(&Value::from("hello".to_string()));
2270    assert_eq!(owned_value.as_str(), Some("hello"));
2271    let Value::String(Cow::Owned(str)) = &mut *owned_value else {
2272        unreachable!()
2273    };
2274    str.push_str(", world");
2275    assert_eq!(owned_value.as_str(), Some("hello, world"));
2276}
2277
2278#[test]
2279fn owned_serialization() {
2280    let owned_value = OwnedValue::from(Value::from(b"asdf".to_vec()));
2281    let serialized = crate::to_vec(&owned_value).unwrap();
2282    let deserialized_owned: OwnedValue = crate::from_slice(&serialized).unwrap();
2283    assert_eq!(deserialized_owned, owned_value);
2284}
pot/value.rs

pot/
value.rs
