Skip to main content

bevy_ron/
value.rs

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