xuko 0.10.0

Rust utility library
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

//! Number Endianness

/// Byte order of a number
#[derive(Debug, PartialEq, Eq, Clone, Copy, Hash)]
pub enum Endian {
    /// Big endian
    Big,
    /// Little endian
    Little,
}

impl Endian {
    /// The target endianness of the host machine
    #[cfg(target_endian = "little")]
    pub const TARGET: Self = Self::Little;
    #[cfg(target_endian = "big")]
    pub const TARGET: Self = Self::Big;

    /// Alias for [`Self::TARGET`]
    pub const HOST_ENDIAN: Self = Self::TARGET;

    /// Get [`Endianness`] from the byte representation of an number
    pub fn from_bytes(b: &[u8]) -> Endian {
        if b.is_sorted_by(|b1, b2| b1 <= b2) {
            Endian::Big
        } else {
            Endian::Little
        }
    }

    /// Swap the endianness of `self`
    pub fn swap(self) -> Endian {
        match self {
            Endian::Big => Endian::Little,
            Endian::Little => Endian::Big,
        }
    }
}

/// Same as [`Endianness::swap`]
impl core::ops::Not for Endian {
    type Output = Endian;
    fn not(self) -> Self::Output {
        self.swap()
    }
}

/// Will return the target endian
impl Default for Endian {
    fn default() -> Self {
        Self::TARGET
    }
}

/// Convert numbers to bytes, regardless of endianness
pub trait ToBytes: Sized {
    /// Type of bytes
    type Bytes: AsRef<[u8]>;

    /// Convert this number to its raw byte representation
    fn to_bytes(self) -> Self::Bytes;

    /// Get the endianness of the number
    fn endianness(self) -> Endian {
        let x = self.to_bytes();
        Endian::from_bytes(x.as_ref())
    }
}

macro_rules! impl_to_bytes {
    ($type:ty) => {
        impl ToBytes for $type {
            type Bytes = [u8; ::core::mem::size_of::<$type>()];

            fn to_bytes(self) -> Self::Bytes {
                #[allow(unnecessary_transmutes)]
                unsafe {
                    core::mem::transmute(self)
                }
            }
        }
    };
}

impl_to_bytes!(u8);
impl_to_bytes!(u16);
impl_to_bytes!(u32);
impl_to_bytes!(u64);
impl_to_bytes!(u128);

impl_to_bytes!(i8);
impl_to_bytes!(i16);
impl_to_bytes!(i32);
impl_to_bytes!(i64);
impl_to_bytes!(i128);

impl_to_bytes!(f32);
impl_to_bytes!(f64);

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn endianness() {
        let x: i32 = 43;

        assert_eq!(x.endianness(), Endian::TARGET);
        assert_eq!(x.to_be().endianness(), Endian::Big);

        let y: f32 = 7.9;
        assert_eq!(y.endianness(), Endian::TARGET);
    }
}