serde_json/
number.rs

1use error::Error;
2use serde::de::{self, Unexpected, Visitor};
3use serde::{Deserialize, Deserializer, Serialize, Serializer};
4use std::fmt::{self, Debug, Display};
5
6#[cfg(feature = "arbitrary_precision")]
7use itoa;
8#[cfg(feature = "arbitrary_precision")]
9use ryu;
10#[cfg(feature = "arbitrary_precision")]
11use serde::de::{IntoDeserializer, MapAccess};
12
13use de::ParserNumber;
14
15#[cfg(feature = "arbitrary_precision")]
16use error::ErrorCode;
17
18#[cfg(feature = "arbitrary_precision")]
19/// Not public API. Should be pub(crate).
20#[doc(hidden)]
21pub const TOKEN: &'static str = "$serde_json::private::Number";
22
23/// Represents a JSON number, whether integer or floating point.
24#[derive(Clone, PartialEq)]
25pub struct Number {
26    n: N,
27}
28
29#[cfg(not(feature = "arbitrary_precision"))]
30#[derive(Copy, Clone, PartialEq)]
31enum N {
32    PosInt(u64),
33    /// Always less than zero.
34    NegInt(i64),
35    /// Always finite.
36    Float(f64),
37}
38
39#[cfg(feature = "arbitrary_precision")]
40type N = String;
41
42impl Number {
43    /// Returns true if the `Number` is an integer between `i64::MIN` and
44    /// `i64::MAX`.
45    ///
46    /// For any Number on which `is_i64` returns true, `as_i64` is guaranteed to
47    /// return the integer value.
48    ///
49    /// ```edition2018
50    /// # use serde_json::json;
51    /// #
52    /// let big = i64::max_value() as u64 + 10;
53    /// let v = json!({ "a": 64, "b": big, "c": 256.0 });
54    ///
55    /// assert!(v["a"].is_i64());
56    ///
57    /// // Greater than i64::MAX.
58    /// assert!(!v["b"].is_i64());
59    ///
60    /// // Numbers with a decimal point are not considered integers.
61    /// assert!(!v["c"].is_i64());
62    /// ```
63    #[inline]
64    pub fn is_i64(&self) -> bool {
65        #[cfg(not(feature = "arbitrary_precision"))]
66        match self.n {
67            N::PosInt(v) => v <= i64::max_value() as u64,
68            N::NegInt(_) => true,
69            N::Float(_) => false,
70        }
71        #[cfg(feature = "arbitrary_precision")]
72        self.as_i64().is_some()
73    }
74
75    /// Returns true if the `Number` is an integer between zero and `u64::MAX`.
76    ///
77    /// For any Number on which `is_u64` returns true, `as_u64` is guaranteed to
78    /// return the integer value.
79    ///
80    /// ```edition2018
81    /// # use serde_json::json;
82    /// #
83    /// let v = json!({ "a": 64, "b": -64, "c": 256.0 });
84    ///
85    /// assert!(v["a"].is_u64());
86    ///
87    /// // Negative integer.
88    /// assert!(!v["b"].is_u64());
89    ///
90    /// // Numbers with a decimal point are not considered integers.
91    /// assert!(!v["c"].is_u64());
92    /// ```
93    #[inline]
94    pub fn is_u64(&self) -> bool {
95        #[cfg(not(feature = "arbitrary_precision"))]
96        match self.n {
97            N::PosInt(_) => true,
98            N::NegInt(_) | N::Float(_) => false,
99        }
100        #[cfg(feature = "arbitrary_precision")]
101        self.as_u64().is_some()
102    }
103
104    /// Returns true if the `Number` can be represented by f64.
105    ///
106    /// For any Number on which `is_f64` returns true, `as_f64` is guaranteed to
107    /// return the floating point value.
108    ///
109    /// Currently this function returns true if and only if both `is_i64` and
110    /// `is_u64` return false but this is not a guarantee in the future.
111    ///
112    /// ```edition2018
113    /// # use serde_json::json;
114    /// #
115    /// let v = json!({ "a": 256.0, "b": 64, "c": -64 });
116    ///
117    /// assert!(v["a"].is_f64());
118    ///
119    /// // Integers.
120    /// assert!(!v["b"].is_f64());
121    /// assert!(!v["c"].is_f64());
122    /// ```
123    #[inline]
124    pub fn is_f64(&self) -> bool {
125        #[cfg(not(feature = "arbitrary_precision"))]
126        match self.n {
127            N::Float(_) => true,
128            N::PosInt(_) | N::NegInt(_) => false,
129        }
130        #[cfg(feature = "arbitrary_precision")]
131        {
132            for c in self.n.chars() {
133                if c == '.' || c == 'e' || c == 'E' {
134                    return self.n.parse::<f64>().ok().map_or(false, |f| f.is_finite());
135                }
136            }
137            false
138        }
139    }
140
141    /// If the `Number` is an integer, represent it as i64 if possible. Returns
142    /// None otherwise.
143    ///
144    /// ```edition2018
145    /// # use serde_json::json;
146    /// #
147    /// let big = i64::max_value() as u64 + 10;
148    /// let v = json!({ "a": 64, "b": big, "c": 256.0 });
149    ///
150    /// assert_eq!(v["a"].as_i64(), Some(64));
151    /// assert_eq!(v["b"].as_i64(), None);
152    /// assert_eq!(v["c"].as_i64(), None);
153    /// ```
154    #[inline]
155    pub fn as_i64(&self) -> Option<i64> {
156        #[cfg(not(feature = "arbitrary_precision"))]
157        match self.n {
158            N::PosInt(n) => {
159                if n <= i64::max_value() as u64 {
160                    Some(n as i64)
161                } else {
162                    None
163                }
164            }
165            N::NegInt(n) => Some(n),
166            N::Float(_) => None,
167        }
168        #[cfg(feature = "arbitrary_precision")]
169        self.n.parse().ok()
170    }
171
172    /// If the `Number` is an integer, represent it as u64 if possible. Returns
173    /// None otherwise.
174    ///
175    /// ```edition2018
176    /// # use serde_json::json;
177    /// #
178    /// let v = json!({ "a": 64, "b": -64, "c": 256.0 });
179    ///
180    /// assert_eq!(v["a"].as_u64(), Some(64));
181    /// assert_eq!(v["b"].as_u64(), None);
182    /// assert_eq!(v["c"].as_u64(), None);
183    /// ```
184    #[inline]
185    pub fn as_u64(&self) -> Option<u64> {
186        #[cfg(not(feature = "arbitrary_precision"))]
187        match self.n {
188            N::PosInt(n) => Some(n),
189            N::NegInt(_) | N::Float(_) => None,
190        }
191        #[cfg(feature = "arbitrary_precision")]
192        self.n.parse().ok()
193    }
194
195    /// Represents the number as f64 if possible. Returns None otherwise.
196    ///
197    /// ```edition2018
198    /// # use serde_json::json;
199    /// #
200    /// let v = json!({ "a": 256.0, "b": 64, "c": -64 });
201    ///
202    /// assert_eq!(v["a"].as_f64(), Some(256.0));
203    /// assert_eq!(v["b"].as_f64(), Some(64.0));
204    /// assert_eq!(v["c"].as_f64(), Some(-64.0));
205    /// ```
206    #[inline]
207    pub fn as_f64(&self) -> Option<f64> {
208        #[cfg(not(feature = "arbitrary_precision"))]
209        match self.n {
210            N::PosInt(n) => Some(n as f64),
211            N::NegInt(n) => Some(n as f64),
212            N::Float(n) => Some(n),
213        }
214        #[cfg(feature = "arbitrary_precision")]
215        self.n.parse().ok()
216    }
217
218    /// Converts a finite `f64` to a `Number`. Infinite or NaN values are not JSON
219    /// numbers.
220    ///
221    /// ```edition2018
222    /// # use std::f64;
223    /// #
224    /// # use serde_json::Number;
225    /// #
226    /// assert!(Number::from_f64(256.0).is_some());
227    ///
228    /// assert!(Number::from_f64(f64::NAN).is_none());
229    /// ```
230    #[inline]
231    pub fn from_f64(f: f64) -> Option<Number> {
232        if f.is_finite() {
233            let n = {
234                #[cfg(not(feature = "arbitrary_precision"))]
235                {
236                    N::Float(f)
237                }
238                #[cfg(feature = "arbitrary_precision")]
239                {
240                    ryu::Buffer::new().format_finite(f).to_owned()
241                }
242            };
243            Some(Number { n: n })
244        } else {
245            None
246        }
247    }
248
249    #[cfg(feature = "arbitrary_precision")]
250    /// Not public API. Only tests use this.
251    #[doc(hidden)]
252    #[inline]
253    pub fn from_string_unchecked(n: String) -> Self {
254        Number { n: n }
255    }
256}
257
258impl fmt::Display for Number {
259    #[cfg(not(feature = "arbitrary_precision"))]
260    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
261        match self.n {
262            N::PosInt(u) => Display::fmt(&u, formatter),
263            N::NegInt(i) => Display::fmt(&i, formatter),
264            N::Float(f) => Display::fmt(&f, formatter),
265        }
266    }
267
268    #[cfg(feature = "arbitrary_precision")]
269    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
270        Display::fmt(&self.n, formatter)
271    }
272}
273
274impl Debug for Number {
275    #[cfg(not(feature = "arbitrary_precision"))]
276    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
277        let mut debug = formatter.debug_tuple("Number");
278        match self.n {
279            N::PosInt(i) => {
280                debug.field(&i);
281            }
282            N::NegInt(i) => {
283                debug.field(&i);
284            }
285            N::Float(f) => {
286                debug.field(&f);
287            }
288        }
289        debug.finish()
290    }
291
292    #[cfg(feature = "arbitrary_precision")]
293    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
294        write!(formatter, "Number({})", &self.n)
295    }
296}
297
298impl Serialize for Number {
299    #[cfg(not(feature = "arbitrary_precision"))]
300    #[inline]
301    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
302    where
303        S: Serializer,
304    {
305        match self.n {
306            N::PosInt(u) => serializer.serialize_u64(u),
307            N::NegInt(i) => serializer.serialize_i64(i),
308            N::Float(f) => serializer.serialize_f64(f),
309        }
310    }
311
312    #[cfg(feature = "arbitrary_precision")]
313    #[inline]
314    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
315    where
316        S: Serializer,
317    {
318        use serde::ser::SerializeStruct;
319
320        let mut s = serializer.serialize_struct(TOKEN, 1)?;
321        s.serialize_field(TOKEN, &self.n)?;
322        s.end()
323    }
324}
325
326impl<'de> Deserialize<'de> for Number {
327    #[inline]
328    fn deserialize<D>(deserializer: D) -> Result<Number, D::Error>
329    where
330        D: Deserializer<'de>,
331    {
332        struct NumberVisitor;
333
334        impl<'de> Visitor<'de> for NumberVisitor {
335            type Value = Number;
336
337            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
338                formatter.write_str("a JSON number")
339            }
340
341            #[inline]
342            fn visit_i64<E>(self, value: i64) -> Result<Number, E> {
343                Ok(value.into())
344            }
345
346            #[inline]
347            fn visit_u64<E>(self, value: u64) -> Result<Number, E> {
348                Ok(value.into())
349            }
350
351            #[inline]
352            fn visit_f64<E>(self, value: f64) -> Result<Number, E>
353            where
354                E: de::Error,
355            {
356                Number::from_f64(value).ok_or_else(|| de::Error::custom("not a JSON number"))
357            }
358
359            #[cfg(feature = "arbitrary_precision")]
360            #[inline]
361            fn visit_map<V>(self, mut visitor: V) -> Result<Number, V::Error>
362            where
363                V: de::MapAccess<'de>,
364            {
365                let value = visitor.next_key::<NumberKey>()?;
366                if value.is_none() {
367                    return Err(de::Error::invalid_type(Unexpected::Map, &self));
368                }
369                let v: NumberFromString = visitor.next_value()?;
370                Ok(v.value)
371            }
372        }
373
374        deserializer.deserialize_any(NumberVisitor)
375    }
376}
377
378#[cfg(feature = "arbitrary_precision")]
379struct NumberKey;
380
381#[cfg(feature = "arbitrary_precision")]
382impl<'de> de::Deserialize<'de> for NumberKey {
383    fn deserialize<D>(deserializer: D) -> Result<NumberKey, D::Error>
384    where
385        D: de::Deserializer<'de>,
386    {
387        struct FieldVisitor;
388
389        impl<'de> de::Visitor<'de> for FieldVisitor {
390            type Value = ();
391
392            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
393                formatter.write_str("a valid number field")
394            }
395
396            fn visit_str<E>(self, s: &str) -> Result<(), E>
397            where
398                E: de::Error,
399            {
400                if s == TOKEN {
401                    Ok(())
402                } else {
403                    Err(de::Error::custom("expected field with custom name"))
404                }
405            }
406        }
407
408        deserializer.deserialize_identifier(FieldVisitor)?;
409        Ok(NumberKey)
410    }
411}
412
413#[cfg(feature = "arbitrary_precision")]
414pub struct NumberFromString {
415    pub value: Number,
416}
417
418#[cfg(feature = "arbitrary_precision")]
419impl<'de> de::Deserialize<'de> for NumberFromString {
420    fn deserialize<D>(deserializer: D) -> Result<NumberFromString, D::Error>
421    where
422        D: de::Deserializer<'de>,
423    {
424        struct Visitor;
425
426        impl<'de> de::Visitor<'de> for Visitor {
427            type Value = NumberFromString;
428
429            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
430                formatter.write_str("string containing a number")
431            }
432
433            fn visit_str<E>(self, s: &str) -> Result<NumberFromString, E>
434            where
435                E: de::Error,
436            {
437                let n = try!(s.parse().map_err(de::Error::custom));
438                Ok(NumberFromString { value: n })
439            }
440        }
441
442        deserializer.deserialize_str(Visitor)
443    }
444}
445
446#[cfg(feature = "arbitrary_precision")]
447fn invalid_number() -> Error {
448    Error::syntax(ErrorCode::InvalidNumber, 0, 0)
449}
450
451macro_rules! deserialize_any {
452    (@expand [$($num_string:tt)*]) => {
453        #[cfg(not(feature = "arbitrary_precision"))]
454        #[inline]
455        fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
456        where
457            V: Visitor<'de>,
458        {
459            match self.n {
460                N::PosInt(u) => visitor.visit_u64(u),
461                N::NegInt(i) => visitor.visit_i64(i),
462                N::Float(f) => visitor.visit_f64(f),
463            }
464        }
465
466        #[cfg(feature = "arbitrary_precision")]
467        #[inline]
468        fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
469            where V: Visitor<'de>
470        {
471            if let Some(u) = self.as_u64() {
472                return visitor.visit_u64(u);
473            } else if let Some(i) = self.as_i64() {
474                return visitor.visit_i64(i);
475            } else if let Some(f) = self.as_f64() {
476                if ryu::Buffer::new().format_finite(f) == self.n || f.to_string() == self.n {
477                    return visitor.visit_f64(f);
478                }
479            }
480
481            visitor.visit_map(NumberDeserializer {
482                number: Some(self.$($num_string)*),
483            })
484        }
485    };
486
487    (owned) => {
488        deserialize_any!(@expand [n]);
489    };
490
491    (ref) => {
492        deserialize_any!(@expand [n.clone()]);
493    };
494}
495
496macro_rules! deserialize_number {
497    ($deserialize:ident => $visit:ident) => {
498        #[cfg(not(feature = "arbitrary_precision"))]
499        fn $deserialize<V>(self, visitor: V) -> Result<V::Value, Error>
500        where
501            V: Visitor<'de>,
502        {
503            self.deserialize_any(visitor)
504        }
505
506        #[cfg(feature = "arbitrary_precision")]
507        fn $deserialize<V>(self, visitor: V) -> Result<V::Value, Error>
508        where
509            V: de::Visitor<'de>,
510        {
511            visitor.$visit(self.n.parse().map_err(|_| invalid_number())?)
512        }
513    }
514}
515
516impl<'de> Deserializer<'de> for Number {
517    type Error = Error;
518
519    deserialize_any!(owned);
520
521    deserialize_number!(deserialize_i8 => visit_i8);
522    deserialize_number!(deserialize_i16 => visit_i16);
523    deserialize_number!(deserialize_i32 => visit_i32);
524    deserialize_number!(deserialize_i64 => visit_i64);
525    deserialize_number!(deserialize_u8 => visit_u8);
526    deserialize_number!(deserialize_u16 => visit_u16);
527    deserialize_number!(deserialize_u32 => visit_u32);
528    deserialize_number!(deserialize_u64 => visit_u64);
529    deserialize_number!(deserialize_f32 => visit_f32);
530    deserialize_number!(deserialize_f64 => visit_f64);
531
532    serde_if_integer128! {
533        deserialize_number!(deserialize_i128 => visit_i128);
534        deserialize_number!(deserialize_u128 => visit_u128);
535    }
536
537    forward_to_deserialize_any! {
538        bool char str string bytes byte_buf option unit unit_struct
539        newtype_struct seq tuple tuple_struct map struct enum identifier
540        ignored_any
541    }
542}
543
544impl<'de, 'a> Deserializer<'de> for &'a Number {
545    type Error = Error;
546
547    deserialize_any!(ref);
548
549    deserialize_number!(deserialize_i8 => visit_i8);
550    deserialize_number!(deserialize_i16 => visit_i16);
551    deserialize_number!(deserialize_i32 => visit_i32);
552    deserialize_number!(deserialize_i64 => visit_i64);
553    deserialize_number!(deserialize_u8 => visit_u8);
554    deserialize_number!(deserialize_u16 => visit_u16);
555    deserialize_number!(deserialize_u32 => visit_u32);
556    deserialize_number!(deserialize_u64 => visit_u64);
557    deserialize_number!(deserialize_f32 => visit_f32);
558    deserialize_number!(deserialize_f64 => visit_f64);
559
560    serde_if_integer128! {
561        deserialize_number!(deserialize_i128 => visit_i128);
562        deserialize_number!(deserialize_u128 => visit_u128);
563    }
564
565    forward_to_deserialize_any! {
566        bool char str string bytes byte_buf option unit unit_struct
567        newtype_struct seq tuple tuple_struct map struct enum identifier
568        ignored_any
569    }
570}
571
572#[cfg(feature = "arbitrary_precision")]
573// Not public API. Should be pub(crate).
574#[doc(hidden)]
575pub struct NumberDeserializer {
576    pub number: Option<String>,
577}
578
579#[cfg(feature = "arbitrary_precision")]
580impl<'de> MapAccess<'de> for NumberDeserializer {
581    type Error = Error;
582
583    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error>
584    where
585        K: de::DeserializeSeed<'de>,
586    {
587        if self.number.is_none() {
588            return Ok(None);
589        }
590        seed.deserialize(NumberFieldDeserializer).map(Some)
591    }
592
593    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error>
594    where
595        V: de::DeserializeSeed<'de>,
596    {
597        seed.deserialize(self.number.take().unwrap().into_deserializer())
598    }
599}
600
601#[cfg(feature = "arbitrary_precision")]
602struct NumberFieldDeserializer;
603
604#[cfg(feature = "arbitrary_precision")]
605impl<'de> Deserializer<'de> for NumberFieldDeserializer {
606    type Error = Error;
607
608    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
609    where
610        V: de::Visitor<'de>,
611    {
612        visitor.visit_borrowed_str(TOKEN)
613    }
614
615    forward_to_deserialize_any! {
616        bool u8 u16 u32 u64 u128 i8 i16 i32 i64 i128 f32 f64 char str string seq
617        bytes byte_buf map struct option unit newtype_struct ignored_any
618        unit_struct tuple_struct tuple enum identifier
619    }
620}
621
622impl From<ParserNumber> for Number {
623    fn from(value: ParserNumber) -> Self {
624        let n = match value {
625            ParserNumber::F64(f) => {
626                #[cfg(not(feature = "arbitrary_precision"))]
627                {
628                    N::Float(f)
629                }
630                #[cfg(feature = "arbitrary_precision")]
631                {
632                    f.to_string()
633                }
634            }
635            ParserNumber::U64(u) => {
636                #[cfg(not(feature = "arbitrary_precision"))]
637                {
638                    N::PosInt(u)
639                }
640                #[cfg(feature = "arbitrary_precision")]
641                {
642                    u.to_string()
643                }
644            }
645            ParserNumber::I64(i) => {
646                #[cfg(not(feature = "arbitrary_precision"))]
647                {
648                    N::NegInt(i)
649                }
650                #[cfg(feature = "arbitrary_precision")]
651                {
652                    i.to_string()
653                }
654            }
655            #[cfg(feature = "arbitrary_precision")]
656            ParserNumber::String(s) => s,
657        };
658        Number { n: n }
659    }
660}
661
662macro_rules! impl_from_unsigned {
663    (
664        $($ty:ty),*
665    ) => {
666        $(
667            impl From<$ty> for Number {
668                #[inline]
669                fn from(u: $ty) -> Self {
670                    let n = {
671                        #[cfg(not(feature = "arbitrary_precision"))]
672                        { N::PosInt(u as u64) }
673                        #[cfg(feature = "arbitrary_precision")]
674                        {
675                            itoa::Buffer::new().format(u).to_owned()
676                        }
677                    };
678                    Number { n: n }
679                }
680            }
681        )*
682    };
683}
684
685macro_rules! impl_from_signed {
686    (
687        $($ty:ty),*
688    ) => {
689        $(
690            impl From<$ty> for Number {
691                #[inline]
692                fn from(i: $ty) -> Self {
693                    let n = {
694                        #[cfg(not(feature = "arbitrary_precision"))]
695                        {
696                            if i < 0 {
697                                N::NegInt(i as i64)
698                            } else {
699                                N::PosInt(i as u64)
700                            }
701                        }
702                        #[cfg(feature = "arbitrary_precision")]
703                        {
704                            itoa::Buffer::new().format(i).to_owned()
705                        }
706                    };
707                    Number { n: n }
708                }
709            }
710        )*
711    };
712}
713
714impl_from_unsigned!(u8, u16, u32, u64, usize);
715impl_from_signed!(i8, i16, i32, i64, isize);
716
717#[cfg(feature = "arbitrary_precision")]
718serde_if_integer128! {
719    impl From<i128> for Number {
720        fn from(i: i128) -> Self {
721            Number { n: i.to_string() }
722        }
723    }
724
725    impl From<u128> for Number {
726        fn from(u: u128) -> Self {
727            Number { n: u.to_string() }
728        }
729    }
730}
731
732impl Number {
733    #[cfg(not(feature = "arbitrary_precision"))]
734    // Not public API. Should be pub(crate).
735    #[doc(hidden)]
736    #[cold]
737    pub fn unexpected(&self) -> Unexpected {
738        match self.n {
739            N::PosInt(u) => Unexpected::Unsigned(u),
740            N::NegInt(i) => Unexpected::Signed(i),
741            N::Float(f) => Unexpected::Float(f),
742        }
743    }
744
745    #[cfg(feature = "arbitrary_precision")]
746    // Not public API. Should be pub(crate).
747    #[doc(hidden)]
748    #[cold]
749    pub fn unexpected(&self) -> Unexpected {
750        Unexpected::Other("number")
751    }
752}