1 // Copyright 2017 The Chromium OS Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 //! Explicit endian types useful for embedding in structs or reinterpreting data. 6 //! 7 //! Each endian type is guarnteed to have the same size and alignment as a regular unsigned primiive 8 //! of the equal size. 9 //! 10 //! # Examples 11 //! 12 //! ``` 13 //! # use data_model::*; 14 //! let b: Be32 = From::from(3); 15 //! let l: Le32 = From::from(3); 16 //! 17 //! assert_eq!(b.to_native(), 3); 18 //! assert_eq!(l.to_native(), 3); 19 //! assert!(b == 3); 20 //! assert!(l == 3); 21 //! 22 //! let b_trans: u32 = unsafe { std::mem::transmute(b) }; 23 //! let l_trans: u32 = unsafe { std::mem::transmute(l) }; 24 //! 25 //! #[cfg(target_endian = "little")] 26 //! assert_eq!(l_trans, 3); 27 //! #[cfg(target_endian = "big")] 28 //! assert_eq!(b_trans, 3); 29 //! 30 //! assert_ne!(b_trans, l_trans); 31 //! ``` 32 33 use std::mem::{align_of, size_of}; 34 35 use assertions::const_assert; 36 use serde::{Deserialize, Deserializer, Serialize, Serializer}; 37 38 use crate::DataInit; 39 40 macro_rules! endian_type { 41 ($old_type:ident, $new_type:ident, $to_new:ident, $from_new:ident) => { 42 /// An integer type of with an explicit endianness. 43 /// 44 /// See module level documentation for examples. 45 #[derive(Copy, Clone, Eq, PartialEq, Debug, Default)] 46 pub struct $new_type($old_type); 47 48 impl $new_type { 49 fn _assert() { 50 const_assert!(align_of::<$new_type>() == align_of::<$old_type>()); 51 const_assert!(size_of::<$new_type>() == size_of::<$old_type>()); 52 } 53 54 /// Converts `self` to the native endianness. 55 pub fn to_native(self) -> $old_type { 56 $old_type::$from_new(self.0) 57 } 58 } 59 60 unsafe impl DataInit for $new_type {} 61 62 impl PartialEq<$old_type> for $new_type { 63 fn eq(&self, other: &$old_type) -> bool { 64 self.0 == $old_type::$to_new(*other) 65 } 66 } 67 68 impl PartialEq<$new_type> for $old_type { 69 fn eq(&self, other: &$new_type) -> bool { 70 $old_type::$to_new(other.0) == *self 71 } 72 } 73 74 impl From<$new_type> for $old_type { 75 fn from(v: $new_type) -> $old_type { 76 $old_type::$from_new(v.0) 77 } 78 } 79 80 impl From<$old_type> for $new_type { 81 fn from(v: $old_type) -> $new_type { 82 $new_type($old_type::$to_new(v)) 83 } 84 } 85 86 impl Serialize for $new_type { 87 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> 88 where 89 S: Serializer, 90 { 91 self.to_native().serialize(serializer) 92 } 93 } 94 95 impl<'de> Deserialize<'de> for $new_type { 96 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> 97 where 98 D: Deserializer<'de>, 99 { 100 Ok($old_type::deserialize(deserializer)?.into()) 101 } 102 } 103 }; 104 } 105 106 endian_type!(u16, Le16, to_le, from_le); 107 endian_type!(i16, SLe16, to_le, from_le); 108 endian_type!(u32, Le32, to_le, from_le); 109 endian_type!(i32, SLe32, to_le, from_le); 110 endian_type!(u64, Le64, to_le, from_le); 111 endian_type!(i64, SLe64, to_le, from_le); 112 endian_type!(usize, LeSize, to_le, from_le); 113 endian_type!(isize, SLeSize, to_le, from_le); 114 endian_type!(u16, Be16, to_be, from_be); 115 endian_type!(i16, SBe16, to_be, from_be); 116 endian_type!(u32, Be32, to_be, from_be); 117 endian_type!(i32, SBe32, to_be, from_be); 118 endian_type!(u64, Be64, to_be, from_be); 119 endian_type!(i64, SBe64, to_be, from_be); 120 endian_type!(usize, BeSize, to_be, from_be); 121 endian_type!(isize, SBeSize, to_be, from_be); 122 123 #[cfg(test)] 124 mod tests { 125 use super::*; 126 127 use std::convert::From; 128 use std::mem::transmute; 129 130 #[cfg(target_endian = "little")] 131 const NATIVE_LITTLE: bool = true; 132 #[cfg(target_endian = "big")] 133 const NATIVE_LITTLE: bool = false; 134 const NATIVE_BIG: bool = !NATIVE_LITTLE; 135 136 macro_rules! endian_test { 137 ($old_type:ty, $new_type:ty, $test_name:ident, $native:expr) => { 138 mod $test_name { 139 use super::*; 140 141 #[allow(overflowing_literals)] 142 #[test] 143 fn equality() { 144 let v = 0x0123456789ABCDEF as $old_type; 145 let endian_v: $new_type = From::from(v); 146 let endian_into: $old_type = endian_v.into(); 147 let endian_transmute: $old_type = unsafe { transmute(endian_v) }; 148 149 if $native { 150 assert_eq!(endian_v, endian_transmute); 151 } else { 152 assert_eq!(endian_v, endian_transmute.swap_bytes()); 153 } 154 155 assert_eq!(v, endian_into); 156 assert!(v == endian_v); 157 assert!(endian_v == v); 158 } 159 } 160 }; 161 } 162 163 endian_test!(u16, Le16, test_le16, NATIVE_LITTLE); 164 endian_test!(i16, SLe16, test_sle16, NATIVE_LITTLE); 165 endian_test!(u32, Le32, test_le32, NATIVE_LITTLE); 166 endian_test!(i32, SLe32, test_sle32, NATIVE_LITTLE); 167 endian_test!(u64, Le64, test_le64, NATIVE_LITTLE); 168 endian_test!(i64, SLe64, test_sle64, NATIVE_LITTLE); 169 endian_test!(usize, LeSize, test_le_size, NATIVE_LITTLE); 170 endian_test!(isize, SLeSize, test_sle_size, NATIVE_LITTLE); 171 endian_test!(u16, Be16, test_be16, NATIVE_BIG); 172 endian_test!(i16, SBe16, test_sbe16, NATIVE_BIG); 173 endian_test!(u32, Be32, test_be32, NATIVE_BIG); 174 endian_test!(i32, SBe32, test_sbe32, NATIVE_BIG); 175 endian_test!(u64, Be64, test_be64, NATIVE_BIG); 176 endian_test!(i64, SBe64, test_sbe64, NATIVE_BIG); 177 endian_test!(usize, BeSize, test_be_size, NATIVE_BIG); 178 endian_test!(isize, SBeSize, test_sbe_size, NATIVE_BIG); 179 } 180