asn1rs 0.3.1

ASN.1 to Rust, Protobuf and SQL compiler/code generator. Supports ASN.1 UPER
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
124
125
126
127

use crate::syn::BitVec;

/// In protobuf default-ish-values - such as '0' for numbers - might be serialized as `null`/`None`
/// if this is possible in the current context. [`ProtobufEq`] will consider these values as equal
/// while the strict implementations of [`PartialEq`] and [`Eq`] will consider them as not equal.
///
/// ```rust
/// use asn1rs::prelude::*;
///
/// // behaviour is equal to (Partial-)Eq in non-optional scenarios
/// assert_eq!(0_u64.protobuf_eq(&0_u64), 0_u64.eq(&0));
/// assert_eq!(1_u64.protobuf_eq(&0), 1_u64.eq(&0));
///
/// // behaviour might differ from (Partial-)Eq in optional scenarios
/// assert_ne!(Some(0_u64).protobuf_eq(&None), Some(0_u64).eq(&None));
/// assert_ne!(Some(String::default()).protobuf_eq(&None), Some(String::default()).eq(&None));
///
/// // behaviour might not differ from (Partial-)Eq in optional scenarios
/// assert_eq!(Some(0_u64).protobuf_eq(&Some(0)), Some(0_u64).eq(&Some(0)));
/// assert_eq!(Some(1_u64).protobuf_eq(&None), Some(1_u64).eq(&None));
/// ```
pub trait ProtobufEq<Rhs: ?Sized = Self> {
    /// Checks whether this and the other value are equal for the protobuf protocol, which considers
    /// default-ish values and `null`/`None` as equal.
    fn protobuf_eq(&self, other: &Rhs) -> bool;

    /// Inverse of [`ProtobufEq::protobuf_eq`]
    fn protobuf_ne(&self, other: &Rhs) -> bool {
        !self.protobuf_eq(other)
    }
}

impl<T: ProtobufEq + Default + PartialEq> ProtobufEq<Option<T>> for Option<T> {
    fn protobuf_eq(&self, other: &Option<T>) -> bool {
        match self {
            Some(ref v) => match other {
                Some(ref v_other) => v.protobuf_eq(v_other),
                None => v == &T::default(),
            },
            None => match other {
                Some(ref v_other) => &T::default() == v_other,
                None => true,
            },
        }
    }
}

impl<T: ProtobufEq> ProtobufEq<Vec<T>> for Vec<T> {
    fn protobuf_eq(&self, other: &Vec<T>) -> bool {
        if self.len() == other.len() {
            for (i, v) in self.iter().enumerate() {
                if !other[i].protobuf_eq(v) {
                    return false;
                }
            }
            true
        } else {
            false
        }
    }
}

impl ProtobufEq<BitVec> for BitVec {
    fn protobuf_eq(&self, other: &BitVec) -> bool {
        self.eq(other)
    }
}

impl ProtobufEq<bool> for bool {
    fn protobuf_eq(&self, other: &Self) -> bool {
        self == other
    }
}

impl ProtobufEq<u8> for u8 {
    fn protobuf_eq(&self, other: &Self) -> bool {
        self == other
    }
}

impl ProtobufEq<u16> for u16 {
    fn protobuf_eq(&self, other: &Self) -> bool {
        self == other
    }
}

impl ProtobufEq<u32> for u32 {
    fn protobuf_eq(&self, other: &Self) -> bool {
        self == other
    }
}

impl ProtobufEq<u64> for u64 {
    fn protobuf_eq(&self, other: &Self) -> bool {
        self == other
    }
}

impl ProtobufEq<i8> for i8 {
    fn protobuf_eq(&self, other: &Self) -> bool {
        self == other
    }
}

impl ProtobufEq<i16> for i16 {
    fn protobuf_eq(&self, other: &Self) -> bool {
        self == other
    }
}

impl ProtobufEq<i32> for i32 {
    fn protobuf_eq(&self, other: &Self) -> bool {
        self == other
    }
}

impl ProtobufEq<i64> for i64 {
    fn protobuf_eq(&self, other: &Self) -> bool {
        self == other
    }
}

impl ProtobufEq<String> for String {
    fn protobuf_eq(&self, other: &Self) -> bool {
        self == other
    }
}