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