vendor/serde_json/src/number.rs

   1 use error::Error;
   2 use serde::de::{self, Unexpected, Visitor};
   3 use serde::{Deserialize, Deserializer, Serialize, Serializer};
   4 use std::fmt::{self, Debug, Display};
   5
   6 #[cfg(feature = "arbitrary_precision")]
   7 use itoa;
   8 #[cfg(feature = "arbitrary_precision")]
   9 use ryu;
  10 #[cfg(feature = "arbitrary_precision")]
  11 use serde::de::{IntoDeserializer, MapAccess};
  12
  13 use de::ParserNumber;
  14
  15 #[cfg(feature = "arbitrary_precision")]
  16 use error::ErrorCode;
  17
  18 #[cfg(feature = "arbitrary_precision")]
  19 /// Not public API. Should be pub(crate).
  20 #[doc(hidden)]
  21 pub const TOKEN: &'static str = "$serde_json::private::Number";
  22
  23 /// Represents a JSON number, whether integer or floating point.
  24 #[derive(Clone, PartialEq)]
  25 pub struct Number {
  26     n: N,
  27 }
  28
  29 #[cfg(not(feature = "arbitrary_precision"))]
  30 #[derive(Copy, Clone, PartialEq)]
  31 enum 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")]
  40 type N = String;
  41
  42 impl 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
 258 impl 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
 274 impl 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
 298 impl 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
 326 impl<'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")]
 379 struct NumberKey;
 380
 381 #[cfg(feature = "arbitrary_precision")]
 382 impl<'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")]
 414 pub struct NumberFromString {
 415     pub value: Number,
 416 }
 417
 418 #[cfg(feature = "arbitrary_precision")]
 419 impl<'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")]
 447 fn invalid_number() -> Error {
 448     Error::syntax(ErrorCode::InvalidNumber, 0, 0)
 449 }
 450
 451 macro_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
 496 macro_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
 516 impl<'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
 544 impl<'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)]
 575 pub struct NumberDeserializer {
 576     pub number: Option<String>,
 577 }
 578
 579 #[cfg(feature = "arbitrary_precision")]
 580 impl<'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")]
 602 struct NumberFieldDeserializer;
 603
 604 #[cfg(feature = "arbitrary_precision")]
 605 impl<'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
 622 impl 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
 662 macro_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
 685 macro_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
 714 impl_from_unsigned!(u8, u16, u32, u64, usize);
 715 impl_from_signed!(i8, i16, i32, i64, isize);
 716
 717 #[cfg(feature = "arbitrary_precision")]
 718 serde_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
 732 impl 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 }