unstructured 0.5.1

Generic types for unstructured data
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

use super::*;
use std::cmp::Ordering;
use std::hash::{Hash, Hasher};

impl Hash for Number {
    fn hash<H>(&self, hasher: &mut H)
    where
        H: Hasher,
    {
        self.discriminant().hash(hasher);
        match *self {
            Number::U8(v) => v.hash(hasher),
            Number::U16(v) => v.hash(hasher),
            Number::U32(v) => v.hash(hasher),
            Number::U64(v) => v.hash(hasher),
            Number::U128(v) => v.hash(hasher),
            Number::I8(v) => v.hash(hasher),
            Number::I16(v) => v.hash(hasher),
            Number::I32(v) => v.hash(hasher),
            Number::I64(v) => v.hash(hasher),
            Number::I128(v) => v.hash(hasher),
            Number::F32(v) => OrderedFloat(v).hash(hasher),
            Number::F64(v) => OrderedFloat(v).hash(hasher),
        }
    }
}

impl Eq for Number {}

impl PartialOrd for Number {
    fn partial_cmp(&self, rhs: &Self) -> Option<Ordering> {
        Some(self.cmp(rhs))
    }
}

impl Ord for Number {
    fn cmp(&self, rhs: &Self) -> Ordering {
        match (self, rhs) {
            (Number::I128(i), n) => i.cmp(&i128::from(n)),
            (Number::U128(i), n) => i.cmp(&u128::from(n)),
            (Number::F64(i), n) => OrderedFloat(*i).cmp(&OrderedFloat(f64::from(n))),
            (Number::I64(i), n) => i.cmp(&i64::from(n)),
            (Number::U64(i), n) => i.cmp(&u64::from(n)),
            (Number::F32(i), n) => OrderedFloat(*i).cmp(&OrderedFloat(f32::from(n))),
            (Number::I32(i), n) => i.cmp(&i32::from(n)),
            (Number::U32(i), n) => i.cmp(&u32::from(n)),
            (Number::I16(i), n) => i.cmp(&i16::from(n)),
            (Number::U16(i), n) => i.cmp(&u16::from(n)),
            (Number::I8(i), n) => i.cmp(&i8::from(n)),
            (Number::U8(i), n) => i.cmp(&u8::from(n)),
        }
    }
}

impl std::ops::Add<Number> for Number {
    type Output = Number;

    fn add(self, rhs: Number) -> Number {
        match (self, rhs) {
            (Number::I128(i), n) => (i + i128::from(n)).into(),
            (Number::U128(i), n) => (i + u128::from(n)).into(),
            (Number::F64(i), n) => (i + f64::from(n)).into(),
            (Number::I64(i), n) => (i + i64::from(n)).into(),
            (Number::U64(i), n) => (i + u64::from(n)).into(),
            (Number::F32(i), n) => (i + f32::from(n)).into(),
            (Number::I32(i), n) => (i + i32::from(n)).into(),
            (Number::U32(i), n) => (i + u32::from(n)).into(),
            (Number::I16(i), n) => (i + i16::from(n)).into(),
            (Number::U16(i), n) => (i + u16::from(n)).into(),
            (Number::I8(i), n) => (i + i8::from(n)).into(),
            (Number::U8(i), n) => (i + u8::from(n)).into(),
        }
    }
}

impl PartialEq<Number> for Number {
    fn eq(&self, rhs: &Number) -> bool {
        match (self, rhs) {
            (Number::I128(i), n) => i == &i128::from(n),
            (Number::U128(i), n) => i == &u128::from(n),
            (Number::F64(i), n) => OrderedFloat(*i) == OrderedFloat(f64::from(n)),
            (Number::I64(i), n) => i == &i64::from(n),
            (Number::U64(i), n) => i == &u64::from(n),
            (Number::F32(i), n) => OrderedFloat(*i) == OrderedFloat(f32::from(n)),
            (Number::I32(i), n) => i == &i32::from(n),
            (Number::U32(i), n) => i == &u32::from(n),
            (Number::I16(i), n) => i == &i16::from(n),
            (Number::U16(i), n) => i == &u16::from(n),
            (Number::I8(i), n) => i == &i8::from(n),
            (Number::U8(i), n) => i == &u8::from(n),
        }
    }
}

impl<T: UnstructuredDataTrait> PartialEq<Unstructured<T>> for Number {
    fn eq(&self, rhs: &Unstructured<T>) -> bool {
        match (rhs, self) {
            (Unstructured::<T>::Number(n1), n2) => n1 == n2,
            (Unstructured::<T>::Option(Some(n1)), n2) => &**n1 == n2,
            (Unstructured::<T>::Newtype(n1), n2) => &**n1 == n2,
            _ => false,
        }
    }
}

macro_rules! impl_partial_eq_number {
    ( $( $type:ty )* ) => {
        $(
            impl PartialEq<Number> for $type {
                fn eq(&self, rhs: &Number) -> bool {
                    &Number::from(self) == rhs
                }
            }

            impl PartialEq<$type> for Number {
                fn eq(&self, rhs: & $type) -> bool {
                    &Number::from(rhs) == self
                }
            }
        )*
    };
}
impl_partial_eq_number! { u8 u16 u32 u64 u128 i8 i16 i32 i64 i128 f32 f64 }