1use 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#[derive(Clone, Debug, Default, Deserialize, Serialize)]
26pub struct Map(MapInner);
27
28impl Map {
29 pub fn new() -> Map {
31 Default::default()
32 }
33
34 pub fn len(&self) -> usize {
36 self.0.len()
37 }
38
39 pub fn is_empty(&self) -> usize {
41 self.0.len()
42 }
43
44 pub fn insert(&mut self, key: Value, value: Value) -> Option<Value> {
47 self.0.insert(key, value)
48 }
49
50 pub fn remove(&mut self, key: &Value) -> Option<Value> {
52 self.0.remove(key)
53 }
54
55 pub fn iter(&self) -> impl Iterator<Item = (&Value, &Value)> + DoubleEndedIterator {
57 self.0.iter()
58 }
59
60 pub fn iter_mut(&mut self) -> impl Iterator<Item = (&Value, &mut Value)> + DoubleEndedIterator {
62 self.0.iter_mut()
63 }
64
65 pub fn keys(&self) -> impl Iterator<Item = &Value> + DoubleEndedIterator {
67 self.0.keys()
68 }
69
70 pub fn values(&self) -> impl Iterator<Item = &Value> + DoubleEndedIterator {
72 self.0.values()
73 }
74
75 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
87impl 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
116impl 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#[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq, Hash, Ord)]
136pub enum Number {
137 Integer(i64),
138 Float(Float),
139}
140
141#[derive(Copy, Clone, Debug)]
144pub struct Float(f64);
145
146impl Float {
147 pub fn new(v: f64) -> Self {
149 Float(v)
150 }
151
152 pub fn get(self) -> f64 {
154 self.0
155 }
156}
157
158impl Number {
159 pub fn new(v: impl Into<Number>) -> Self {
161 v.into()
162 }
163
164 pub fn into_f64(self) -> f64 {
177 self.map_to(|i| i as f64, |f| f)
178 }
179
180 pub fn as_f64(self) -> Option<f64> {
192 self.map_to(|_| None, Some)
193 }
194
195 pub fn as_i64(self) -> Option<i64> {
207 self.map_to(Some, |_| None)
208 }
209
210 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
251impl 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
264impl 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
274impl 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
286impl 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
306impl 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 pub fn into_rust<T>(self) -> Result<T>
332 where
333 T: DeserializeOwned,
334 {
335 T::deserialize(self)
336 }
337}
338
339impl<'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 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 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 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}