serde_content/
number.rs

1/// A containter for all Rust number types.
2#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
3#[non_exhaustive] // In case Rust introduces new number types.
4pub enum Number {
5    /// Holds an 8-bit signed integer type.
6    I8(i8),
7    /// Holds an 8-bit unsigned integer type.
8    U8(u8),
9
10    /// Holds a 16-bit signed integer type.
11    I16(i16),
12    /// Holds a 16-bit unsigned integer type.
13    U16(u16),
14
15    /// Holds a 32-bit signed integer type.
16    I32(i32),
17    /// Holds a 32-bit unsigned integer type.
18    U32(u32),
19    /// Holds a 32-bit floating point type.
20    F32(f32),
21
22    /// Holds a 64-bit signed integer type.
23    I64(i64),
24    /// Holds a 64-bit unsigned integer type.
25    U64(u64),
26    /// Holds a 32-bit floating point type.
27    F64(f64),
28
29    /// Holds a 128-bit signed integer type.
30    I128(i128),
31    /// Holds a 128-bit unsigned integer type.
32    U128(u128),
33}
34
35impl From<i8> for Number {
36    fn from(value: i8) -> Self {
37        Self::I8(value)
38    }
39}
40
41impl From<u8> for Number {
42    fn from(value: u8) -> Self {
43        Self::U8(value)
44    }
45}
46
47impl From<i16> for Number {
48    fn from(value: i16) -> Self {
49        Self::I16(value)
50    }
51}
52
53impl From<u16> for Number {
54    fn from(value: u16) -> Self {
55        Self::U16(value)
56    }
57}
58
59impl From<i32> for Number {
60    fn from(value: i32) -> Self {
61        Self::I32(value)
62    }
63}
64
65impl From<u32> for Number {
66    fn from(value: u32) -> Self {
67        Self::U32(value)
68    }
69}
70
71impl From<f32> for Number {
72    fn from(value: f32) -> Self {
73        Self::F32(value)
74    }
75}
76
77impl From<i64> for Number {
78    fn from(value: i64) -> Self {
79        Self::I64(value)
80    }
81}
82
83impl From<u64> for Number {
84    fn from(value: u64) -> Self {
85        Self::U64(value)
86    }
87}
88
89impl From<f64> for Number {
90    fn from(value: f64) -> Self {
91        Self::F64(value)
92    }
93}
94
95impl From<i128> for Number {
96    fn from(value: i128) -> Self {
97        Self::I128(value)
98    }
99}
100
101impl From<u128> for Number {
102    fn from(value: u128) -> Self {
103        Self::U128(value)
104    }
105}