rasn 0.28.12

A safe no_std ASN.1 codec framework.
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
128
129
130
131
132
133
134
135

use num_traits::float::FloatCore;

/// Represents a real type in Rust that can be decoded or encoded into any
/// ASN.1 codec.
pub trait RealType: Sized + core::fmt::Debug + core::fmt::Display {
    /// The byte level width of the floating point type.
    const BYTE_WIDTH: usize;

    /// The infinity (∞) value
    const INFINITY: Self;

    /// The negative infinity (-∞) value
    const NEG_INFINITY: Self;

    /// The Not-a-Number value
    const NAN: Self;

    /// Returns the IEEE 754 encoded bytes of the real type, byte count defined in `usize`
    fn to_ieee754_bytes(&self) -> (impl AsRef<[u8]>, usize);

    /// Attempts to decode the IEEE 754 encoded bytes into `Self`
    fn try_from_ieee754_bytes(bytes: &[u8]) -> Result<Self, TryFromRealError>;

    /// Attempts to convert a generic floating point type into `Self`
    fn try_from_float(value: impl FloatCore) -> Option<Self>;

    /// Attempts to convert `Self` into a generic floating point type
    fn try_to_float(&self) -> Option<impl FloatCore>;

    /// Returns `true` if the value is positive infinity
    fn is_infinity(&self) -> bool;

    /// Returns `true` if the value is negative infinity
    fn is_neg_infinity(&self) -> bool;

    /// Returns `true` if the value is NaN
    fn is_nan(&self) -> bool;
}

#[cfg(feature = "f64")]
impl RealType for f64 {
    const BYTE_WIDTH: usize = core::mem::size_of::<Self>();
    const INFINITY: Self = Self::INFINITY;
    const NEG_INFINITY: Self = Self::NEG_INFINITY;
    const NAN: Self = Self::NAN;

    #[inline]
    fn to_ieee754_bytes(&self) -> (impl AsRef<[u8]>, usize) {
        let bytes = self.to_be_bytes();
        (bytes, bytes.len())
    }

    #[inline]
    fn try_from_ieee754_bytes(bytes: &[u8]) -> Result<Self, TryFromRealError> {
        let bytes = bytes
            .try_into()
            .map_err(|_| TryFromRealError::InvalidEncoding)?;

        Ok(f64::from_be_bytes(bytes))
    }

    fn try_from_float(value: impl FloatCore) -> Option<Self> {
        value.to_f64()
    }

    fn try_to_float(&self) -> Option<impl FloatCore> {
        Some(*self)
    }

    #[inline]
    fn is_infinity(&self) -> bool {
        *self == Self::INFINITY
    }

    #[inline]
    fn is_neg_infinity(&self) -> bool {
        *self == Self::NEG_INFINITY
    }

    #[inline]
    fn is_nan(&self) -> bool {
        Self::is_nan(*self)
    }
}

#[cfg(feature = "f32")]
impl RealType for f32 {
    const BYTE_WIDTH: usize = core::mem::size_of::<Self>();
    const INFINITY: Self = Self::INFINITY;
    const NEG_INFINITY: Self = Self::NEG_INFINITY;
    const NAN: Self = Self::NAN;

    #[inline]
    fn to_ieee754_bytes(&self) -> (impl AsRef<[u8]>, usize) {
        let bytes = self.to_be_bytes();
        (bytes, bytes.len())
    }

    #[inline]
    fn try_from_ieee754_bytes(bytes: &[u8]) -> Result<Self, TryFromRealError> {
        let bytes = bytes
            .try_into()
            .map_err(|_| TryFromRealError::InvalidEncoding)?;

        Ok(f32::from_be_bytes(bytes))
    }

    fn try_from_float(value: impl FloatCore) -> Option<Self> {
        value.to_f32()
    }

    fn try_to_float(&self) -> Option<impl FloatCore> {
        Some(*self)
    }

    #[inline]
    fn is_infinity(&self) -> bool {
        *self == Self::INFINITY
    }

    #[inline]
    fn is_neg_infinity(&self) -> bool {
        *self == Self::NEG_INFINITY
    }

    #[inline]
    fn is_nan(&self) -> bool {
        Self::is_nan(*self)
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum TryFromRealError {
    InvalidEncoding,
}