ron/
value.rs

1//! Value module.
2
3use std::{
4    cmp::{Eq, Ordering},
5    hash::{Hash, Hasher},
6    iter::FromIterator,
7    ops::{Index, IndexMut},
8};
9
10use serde::{
11    de::{DeserializeOwned, DeserializeSeed, Deserializer, MapAccess, SeqAccess, Visitor},
12    forward_to_deserialize_any,
13};
14use serde_derive::{Deserialize, Serialize};
15
16use crate::{de::Error, error::Result};
17
18/// A [`Value`] to [`Value`] map.
19///
20/// This structure either uses a [BTreeMap](std::collections::BTreeMap) or the
21/// [IndexMap](indexmap::IndexMap) internally.
22/// The latter can be used by enabling the `indexmap` feature. This can be used
23/// to preserve the order of the parsed map.
24#[derive(Clone, Debug, Default, Deserialize, Serialize)]
25#[serde(transparent)]
26pub struct Map(MapInner);
27
28impl Map {
29    /// Creates a new, empty [`Map`].
30    pub fn new() -> Map {
31        Default::default()
32    }
33
34    /// Returns the number of elements in the map.
35    pub fn len(&self) -> usize {
36        self.0.len()
37    }
38
39    /// Returns `true` if `self.len() == 0`, `false` otherwise.
40    pub fn is_empty(&self) -> bool {
41        self.0.len() == 0
42    }
43
44    /// Inserts a new element, returning the previous element with this `key` if
45    /// there was any.
46    pub fn insert(&mut self, key: Value, value: Value) -> Option<Value> {
47        self.0.insert(key, value)
48    }
49
50    /// Removes an element by its `key`.
51    pub fn remove(&mut self, key: &Value) -> Option<Value> {
52        self.0.remove(key)
53    }
54
55    /// Iterate all key-value pairs.
56    pub fn iter(&self) -> impl Iterator<Item = (&Value, &Value)> + DoubleEndedIterator {
57        self.0.iter()
58    }
59
60    /// Iterate all key-value pairs mutably.
61    pub fn iter_mut(&mut self) -> impl Iterator<Item = (&Value, &mut Value)> + DoubleEndedIterator {
62        self.0.iter_mut()
63    }
64
65    /// Iterate all keys.
66    pub fn keys(&self) -> impl Iterator<Item = &Value> + DoubleEndedIterator {
67        self.0.keys()
68    }
69
70    /// Iterate all values.
71    pub fn values(&self) -> impl Iterator<Item = &Value> + DoubleEndedIterator {
72        self.0.values()
73    }
74
75    /// Iterate all values mutably.
76    pub fn values_mut(&mut self) -> impl Iterator<Item = &mut Value> + DoubleEndedIterator {
77        self.0.values_mut()
78    }
79
80    /// Retains only the elements specified by the `keep` predicate.
81    ///
82    /// In other words, remove all pairs `(k, v)` for which `keep(&k, &mut v)`
83    /// returns `false`.
84    ///
85    /// The elements are visited in iteration order.
86    pub fn retain<F>(&mut self, keep: F)
87    where
88        F: FnMut(&Value, &mut Value) -> bool,
89    {
90        self.0.retain(keep);
91    }
92}
93
94impl FromIterator<(Value, Value)> for Map {
95    fn from_iter<T: IntoIterator<Item = (Value, Value)>>(iter: T) -> Self {
96        Map(MapInner::from_iter(iter))
97    }
98}
99
100impl IntoIterator for Map {
101    type Item = (Value, Value);
102
103    type IntoIter = <MapInner as IntoIterator>::IntoIter;
104
105    fn into_iter(self) -> Self::IntoIter {
106        self.0.into_iter()
107    }
108}
109
110/// Note: equality is only given if both values and order of values match
111impl Eq for Map {}
112
113impl Hash for Map {
114    fn hash<H: Hasher>(&self, state: &mut H) {
115        self.iter().for_each(|x| x.hash(state));
116    }
117}
118
119impl Index<&Value> for Map {
120    type Output = Value;
121
122    fn index(&self, index: &Value) -> &Self::Output {
123        &self.0[index]
124    }
125}
126
127impl IndexMut<&Value> for Map {
128    fn index_mut(&mut self, index: &Value) -> &mut Self::Output {
129        self.0.get_mut(index).expect("no entry found for key")
130    }
131}
132
133impl Ord for Map {
134    fn cmp(&self, other: &Map) -> Ordering {
135        self.iter().cmp(other.iter())
136    }
137}
138
139/// Note: equality is only given if both values and order of values match
140impl PartialEq for Map {
141    fn eq(&self, other: &Map) -> bool {
142        self.iter().zip(other.iter()).all(|(a, b)| a == b)
143    }
144}
145
146impl PartialOrd for Map {
147    fn partial_cmp(&self, other: &Map) -> Option<Ordering> {
148        self.iter().partial_cmp(other.iter())
149    }
150}
151
152#[cfg(not(feature = "indexmap"))]
153type MapInner = std::collections::BTreeMap<Value, Value>;
154#[cfg(feature = "indexmap")]
155type MapInner = indexmap::IndexMap<Value, Value>;
156
157/// A wrapper for a number, which can be either [`f64`] or [`i64`].
158#[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq, Hash, Ord)]
159pub enum Number {
160    Integer(i64),
161    Float(Float),
162}
163
164/// A wrapper for [`f64`], which guarantees that the inner value
165/// is finite and thus implements [`Eq`], [`Hash`] and [`Ord`].
166#[derive(Copy, Clone, Debug)]
167pub struct Float(f64);
168
169impl Float {
170    /// Construct a new [`Float`].
171    pub fn new(v: f64) -> Self {
172        Float(v)
173    }
174
175    /// Returns the wrapped float.
176    pub fn get(self) -> f64 {
177        self.0
178    }
179}
180
181impl Number {
182    /// Construct a new number.
183    pub fn new(v: impl Into<Number>) -> Self {
184        v.into()
185    }
186
187    /// Returns the [`f64`] representation of the [`Number`] regardless of
188    /// whether the number is stored as a float or integer.
189    ///
190    /// # Example
191    ///
192    /// ```
193    /// # use ron::value::Number;
194    /// let i = Number::new(5);
195    /// let f = Number::new(2.0);
196    /// assert_eq!(i.into_f64(), 5.0);
197    /// assert_eq!(f.into_f64(), 2.0);
198    /// ```
199    pub fn into_f64(self) -> f64 {
200        self.map_to(|i| i as f64, |f| f)
201    }
202
203    /// If the [`Number`] is a float, return it. Otherwise return [`None`].
204    ///
205    /// # Example
206    ///
207    /// ```
208    /// # use ron::value::Number;
209    /// let i = Number::new(5);
210    /// let f = Number::new(2.0);
211    /// assert_eq!(i.as_f64(), None);
212    /// assert_eq!(f.as_f64(), Some(2.0));
213    /// ```
214    pub fn as_f64(self) -> Option<f64> {
215        self.map_to(|_| None, Some)
216    }
217
218    /// If the [`Number`] is an integer, return it. Otherwise return [`None`].
219    ///
220    /// # Example
221    ///
222    /// ```
223    /// # use ron::value::Number;
224    /// let i = Number::new(5);
225    /// let f = Number::new(2.0);
226    /// assert_eq!(i.as_i64(), Some(5));
227    /// assert_eq!(f.as_i64(), None);
228    /// ```
229    pub fn as_i64(self) -> Option<i64> {
230        self.map_to(Some, |_| None)
231    }
232
233    /// Map this number to a single type using the appropriate closure.
234    ///
235    /// # Example
236    ///
237    /// ```
238    /// # use ron::value::Number;
239    /// let i = Number::new(5);
240    /// let f = Number::new(2.0);
241    /// assert!(i.map_to(|i| i > 3, |f| f > 3.0));
242    /// assert!(!f.map_to(|i| i > 3, |f| f > 3.0));
243    /// ```
244    pub fn map_to<T>(
245        self,
246        integer_fn: impl FnOnce(i64) -> T,
247        float_fn: impl FnOnce(f64) -> T,
248    ) -> T {
249        match self {
250            Number::Integer(i) => integer_fn(i),
251            Number::Float(Float(f)) => float_fn(f),
252        }
253    }
254}
255
256impl From<f64> for Number {
257    fn from(f: f64) -> Number {
258        Number::Float(Float(f))
259    }
260}
261
262impl From<i64> for Number {
263    fn from(i: i64) -> Number {
264        Number::Integer(i)
265    }
266}
267
268impl From<i32> for Number {
269    fn from(i: i32) -> Number {
270        Number::Integer(i64::from(i))
271    }
272}
273
274/// The following [`Number`] conversion checks if the integer fits losslessly
275/// into an [`i64`], before constructing a [`Number::Integer`] variant.
276/// If not, the conversion defaults to [`Number::Float`].
277
278impl From<u64> for Number {
279    fn from(i: u64) -> Number {
280        if i <= std::i64::MAX as u64 {
281            Number::Integer(i as i64)
282        } else {
283            Number::new(i as f64)
284        }
285    }
286}
287
288/// Partial equality comparison
289/// In order to be able to use [`Number`] as a mapping key, NaN floating values
290/// wrapped in [`Float`] are equal to each other. It is not the case for
291/// underlying [`f64`] values itself.
292impl PartialEq for Float {
293    fn eq(&self, other: &Self) -> bool {
294        self.0.is_nan() && other.0.is_nan() || self.0 == other.0
295    }
296}
297
298/// Equality comparison
299/// In order to be able to use [`Float`] as a mapping key, NaN floating values
300/// wrapped in [`Float`] are equal to each other. It is not the case for
301/// underlying [`f64`] values itself.
302impl Eq for Float {}
303
304impl Hash for Float {
305    fn hash<H: Hasher>(&self, state: &mut H) {
306        state.write_u64(self.0.to_bits());
307    }
308}
309
310/// Partial ordering comparison
311/// In order to be able to use [`Number`] as a mapping key, NaN floating values
312/// wrapped in [`Number`] are equal to each other and are less then any other
313/// floating value. It is not the case for the underlying [`f64`] values
314/// themselves.
315///
316/// ```
317/// use ron::value::Number;
318/// assert!(Number::new(std::f64::NAN) < Number::new(std::f64::NEG_INFINITY));
319/// assert_eq!(Number::new(std::f64::NAN), Number::new(std::f64::NAN));
320/// ```
321impl PartialOrd for Float {
322    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
323        match (self.0.is_nan(), other.0.is_nan()) {
324            (true, true) => Some(Ordering::Equal),
325            (true, false) => Some(Ordering::Less),
326            (false, true) => Some(Ordering::Greater),
327            _ => self.0.partial_cmp(&other.0),
328        }
329    }
330}
331
332/// Ordering comparison
333/// In order to be able to use [`Float`] as a mapping key, NaN floating values
334/// wrapped in [`Float`] are equal to each other and are less then any other
335/// floating value. It is not the case for underlying [`f64`] values itself.
336/// See the [`PartialEq`] implementation.
337impl Ord for Float {
338    fn cmp(&self, other: &Self) -> Ordering {
339        self.partial_cmp(other).expect("Bug: Contract violation")
340    }
341}
342
343#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
344pub enum Value {
345    Bool(bool),
346    Char(char),
347    Map(Map),
348    Number(Number),
349    Option(Option<Box<Value>>),
350    String(String),
351    Seq(Vec<Value>),
352    Unit,
353}
354
355impl Value {
356    /// Tries to deserialize this [`Value`] into `T`.
357    pub fn into_rust<T>(self) -> Result<T>
358    where
359        T: DeserializeOwned,
360    {
361        T::deserialize(self)
362    }
363}
364
365/// Deserializer implementation for RON [`Value`].
366/// This does not support enums (because [`Value`] does not store them).
367impl<'de> Deserializer<'de> for Value {
368    type Error = Error;
369
370    forward_to_deserialize_any! {
371        bool f32 f64 char str string bytes
372        byte_buf option unit unit_struct newtype_struct seq tuple
373        tuple_struct map struct enum identifier ignored_any
374    }
375
376    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
377    where
378        V: Visitor<'de>,
379    {
380        match self {
381            Value::Bool(b) => visitor.visit_bool(b),
382            Value::Char(c) => visitor.visit_char(c),
383            Value::Map(m) => {
384                let old_len = m.len();
385
386                let mut items: Vec<(Value, Value)> = m.into_iter().collect();
387                items.reverse();
388
389                let value = visitor.visit_map(MapAccessor {
390                    items: &mut items,
391                    value: None,
392                })?;
393
394                if items.is_empty() {
395                    Ok(value)
396                } else {
397                    Err(Error::ExpectedDifferentLength {
398                        expected: format!("a map of length {}", old_len - items.len()),
399                        found: old_len,
400                    })
401                }
402            }
403            Value::Number(Number::Float(ref f)) => visitor.visit_f64(f.get()),
404            Value::Number(Number::Integer(i)) => visitor.visit_i64(i),
405            Value::Option(Some(o)) => visitor.visit_some(*o),
406            Value::Option(None) => visitor.visit_none(),
407            Value::String(s) => visitor.visit_string(s),
408            Value::Seq(mut seq) => {
409                let old_len = seq.len();
410
411                seq.reverse();
412                let value = visitor.visit_seq(Seq { seq: &mut seq })?;
413
414                if seq.is_empty() {
415                    Ok(value)
416                } else {
417                    Err(Error::ExpectedDifferentLength {
418                        expected: format!("a sequence of length {}", old_len - seq.len()),
419                        found: old_len,
420                    })
421                }
422            }
423            Value::Unit => visitor.visit_unit(),
424        }
425    }
426
427    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value>
428    where
429        V: Visitor<'de>,
430    {
431        self.deserialize_i64(visitor)
432    }
433
434    fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value>
435    where
436        V: Visitor<'de>,
437    {
438        self.deserialize_i64(visitor)
439    }
440
441    fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value>
442    where
443        V: Visitor<'de>,
444    {
445        self.deserialize_i64(visitor)
446    }
447
448    fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value>
449    where
450        V: Visitor<'de>,
451    {
452        match self {
453            Value::Number(Number::Integer(i)) => visitor.visit_i64(i),
454            v => Err(Error::Message(format!("Expected a number, got {:?}", v))),
455        }
456    }
457
458    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value>
459    where
460        V: Visitor<'de>,
461    {
462        self.deserialize_u64(visitor)
463    }
464
465    fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value>
466    where
467        V: Visitor<'de>,
468    {
469        self.deserialize_u64(visitor)
470    }
471
472    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value>
473    where
474        V: Visitor<'de>,
475    {
476        self.deserialize_u64(visitor)
477    }
478
479    fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value>
480    where
481        V: Visitor<'de>,
482    {
483        match self {
484            Value::Number(Number::Integer(i)) => visitor.visit_u64(i as u64),
485            v => Err(Error::Message(format!("Expected a number, got {:?}", v))),
486        }
487    }
488}
489
490struct MapAccessor<'a> {
491    items: &'a mut Vec<(Value, Value)>,
492    value: Option<Value>,
493}
494
495impl<'a, 'de> MapAccess<'de> for MapAccessor<'a> {
496    type Error = Error;
497
498    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
499    where
500        K: DeserializeSeed<'de>,
501    {
502        // The `Vec` is reversed, so we can pop to get the originally first element
503        match self.items.pop() {
504            Some((key, value)) => {
505                self.value = Some(value);
506                seed.deserialize(key).map(Some)
507            }
508            None => Ok(None),
509        }
510    }
511
512    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
513    where
514        V: DeserializeSeed<'de>,
515    {
516        match self.value.take() {
517            Some(value) => seed.deserialize(value),
518            None => panic!("Contract violation: value before key"),
519        }
520    }
521
522    fn size_hint(&self) -> Option<usize> {
523        Some(self.items.len())
524    }
525}
526
527struct Seq<'a> {
528    seq: &'a mut Vec<Value>,
529}
530
531impl<'a, 'de> SeqAccess<'de> for Seq<'a> {
532    type Error = Error;
533
534    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
535    where
536        T: DeserializeSeed<'de>,
537    {
538        // The `Vec` is reversed, so we can pop to get the originally first element
539        self.seq
540            .pop()
541            .map_or(Ok(None), |v| seed.deserialize(v).map(Some))
542    }
543
544    fn size_hint(&self) -> Option<usize> {
545        Some(self.seq.len())
546    }
547}
548
549#[cfg(test)]
550mod tests {
551    use std::{collections::BTreeMap, fmt::Debug};
552
553    use serde::Deserialize;
554
555    use super::*;
556
557    fn assert_same<'de, T>(s: &'de str)
558    where
559        T: Debug + Deserialize<'de> + PartialEq,
560    {
561        use crate::de::from_str;
562
563        let direct: T = from_str(s).unwrap();
564        let value: Value = from_str(s).unwrap();
565        let value = T::deserialize(value).unwrap();
566
567        assert_eq!(direct, value, "Deserialization for {:?} is not the same", s);
568    }
569
570    #[test]
571    fn boolean() {
572        assert_same::<bool>("true");
573        assert_same::<bool>("false");
574    }
575
576    #[test]
577    fn float() {
578        assert_same::<f64>("0.123");
579        assert_same::<f64>("-4.19");
580    }
581
582    #[test]
583    fn int() {
584        assert_same::<u32>("626");
585        assert_same::<i32>("-50");
586    }
587
588    #[test]
589    fn char() {
590        assert_same::<char>("'4'");
591        assert_same::<char>("'c'");
592    }
593
594    #[test]
595    fn map() {
596        assert_same::<BTreeMap<char, String>>(
597            "{
598'a': \"Hello\",
599'b': \"Bye\",
600        }",
601        );
602    }
603
604    #[test]
605    fn option() {
606        assert_same::<Option<char>>("Some('a')");
607        assert_same::<Option<char>>("None");
608    }
609
610    #[test]
611    fn seq() {
612        assert_same::<Vec<f64>>("[1.0, 2.0, 3.0, 4.0]");
613    }
614
615    #[test]
616    fn unit() {
617        assert_same::<()>("()");
618    }
619}
ron/value.rs

ron/
value.rs
