1use crate::{
2 BoolPacker, F32Packer, I8Packer, I16Packer, I32Packer, U8Packer, U16Packer, U32Packer,
3};
4
5macro_rules! impl_bool_packer_for_num {
6 ($t:ty) => {
7 impl BoolPacker for $t {
8 fn pack_bool(first: bool, second: bool) -> Self {
9 ((first as $t) << 1) | (second as $t)
10 }
11
12 fn first_bool(&self) -> bool {
13 (self & 0b10) != 0
14 }
15
16 fn second_bool(&self) -> bool {
17 (self & 0b01) != 0
18 }
19 }
20 };
21}
22
23impl_bool_packer_for_num!(u8);
24impl_bool_packer_for_num!(u16);
25impl_bool_packer_for_num!(u32);
26impl_bool_packer_for_num!(u64);
27impl_bool_packer_for_num!(usize);
28impl_bool_packer_for_num!(i8);
29impl_bool_packer_for_num!(i16);
30impl_bool_packer_for_num!(i32);
31impl_bool_packer_for_num!(i64);
32impl_bool_packer_for_num!(isize);
33
34macro_rules! impl_u8_packer_for_num {
36 ($t:ty) => {
37 impl U8Packer for $t {
38 fn pack_u8(first: u8, second: u8) -> Self {
39 ((first as $t) << 8) | (second as $t)
40 }
41
42 fn first_u8(&self) -> u8 {
43 ((self >> 8) & 0xFF) as u8
44 }
45
46 fn second_u8(&self) -> u8 {
47 (self & 0xFF) as u8
48 }
49 }
50 };
51}
52
53impl_u8_packer_for_num!(u16);
54impl_u8_packer_for_num!(u32);
55impl_u8_packer_for_num!(u64);
56impl_u8_packer_for_num!(usize);
57impl_u8_packer_for_num!(i16);
58impl_u8_packer_for_num!(i32);
59impl_u8_packer_for_num!(i64);
60impl_u8_packer_for_num!(isize);
61
62macro_rules! impl_u16_packer_for_num {
64 ($t:ty) => {
65 impl U16Packer for $t {
66 fn pack_u16(first: u16, second: u16) -> Self {
67 ((first as $t) << 16) | (second as $t)
68 }
69
70 fn first_u16(&self) -> u16 {
71 ((self >> 16) & 0xFFFF) as u16
72 }
73
74 fn second_u16(&self) -> u16 {
75 (self & 0xFFFF) as u16
76 }
77 }
78 };
79}
80
81impl_u16_packer_for_num!(u32);
82impl_u16_packer_for_num!(u64);
83#[cfg(any(target_pointer_width = "32", target_pointer_width = "64"))]
84impl_u16_packer_for_num!(usize);
85impl_u16_packer_for_num!(i32);
86impl_u16_packer_for_num!(i64);
87#[cfg(any(target_pointer_width = "32", target_pointer_width = "64"))]
88impl_u16_packer_for_num!(isize);
89
90macro_rules! impl_u32_packer_for_num {
92 ($t:ty) => {
93 impl U32Packer for $t {
94 fn pack_u32(first: u32, second: u32) -> Self {
95 ((first as $t) << 32) | (second as $t)
96 }
97
98 fn first_u32(&self) -> u32 {
99 ((self >> 32) & 0xFFFFFFFF) as u32
100 }
101
102 fn second_u32(&self) -> u32 {
103 (self & 0xFFFFFFFF) as u32
104 }
105 }
106 };
107}
108
109impl_u32_packer_for_num!(u64);
110#[cfg(target_pointer_width = "64")]
111impl_u32_packer_for_num!(usize);
112impl_u32_packer_for_num!(i64);
113#[cfg(target_pointer_width = "64")]
114impl_u32_packer_for_num!(isize);
115
116macro_rules! impl_i8_packer_for_num {
117 ($t:ty) => {
118 impl I8Packer for $t {
119 fn pack_i8(first: i8, second: i8) -> Self {
120 let first_u = first as u8 as $t;
121 let second_u = second as u8 as $t;
122 (first_u << 8) | second_u
123 }
124
125 fn first_i8(&self) -> i8 {
126 ((self >> 8) & 0xFF) as u8 as i8
127 }
128
129 fn second_i8(&self) -> i8 {
130 (self & 0xFF) as u8 as i8
131 }
132 }
133 };
134}
135
136impl_i8_packer_for_num!(i16);
137impl_i8_packer_for_num!(i32);
138impl_i8_packer_for_num!(i64);
139impl_i8_packer_for_num!(isize);
140impl_i8_packer_for_num!(u16);
141impl_i8_packer_for_num!(u32);
142impl_i8_packer_for_num!(u64);
143impl_i8_packer_for_num!(usize);
144
145macro_rules! impl_i16_packer_for_num {
146 ($t:ty) => {
147 impl I16Packer for $t {
148 fn pack_i16(first: i16, second: i16) -> Self {
149 let first_u = first as u16 as $t;
150 let second_u = second as u16 as $t;
151 (first_u << 16) | second_u
152 }
153
154 fn first_i16(&self) -> i16 {
155 ((self >> 16) & 0xFFFF) as u16 as i16
156 }
157
158 fn second_i16(&self) -> i16 {
159 (self & 0xFFFF) as u16 as i16
160 }
161 }
162 };
163}
164
165impl_i16_packer_for_num!(u32);
166impl_i16_packer_for_num!(u64);
167#[cfg(any(target_pointer_width = "32", target_pointer_width = "64"))]
168impl_i16_packer_for_num!(usize);
169impl_i16_packer_for_num!(i32);
170impl_i16_packer_for_num!(i64);
171#[cfg(any(target_pointer_width = "32", target_pointer_width = "64"))]
172impl_i16_packer_for_num!(isize);
173
174macro_rules! impl_i32_packer_for_num {
175 ($t:ty) => {
176 impl I32Packer for $t {
177 fn pack_i32(first: i32, second: i32) -> Self {
178 let first_u = first as u32 as $t;
179 let second_u = second as u32 as $t;
180 (first_u << 32) | second_u
181 }
182
183 fn first_i32(&self) -> i32 {
184 ((self >> 32) & 0xFFFFFFFF) as u32 as i32
185 }
186
187 fn second_i32(&self) -> i32 {
188 (self & 0xFFFFFFFF) as u32 as i32
189 }
190 }
191 };
192}
193
194impl_i32_packer_for_num!(u64);
195#[cfg(target_pointer_width = "64")]
196impl_i32_packer_for_num!(usize);
197impl_i32_packer_for_num!(i64);
198#[cfg(target_pointer_width = "64")]
199impl_i32_packer_for_num!(isize);
200
201macro_rules! impl_f32_packer_for_num {
202 ($t:ty) => {
203 impl F32Packer for $t {
204 fn pack_f32(first: f32, second: f32) -> Self {
205 let first_u = first.to_bits() as $t;
206 let second_u = second.to_bits() as $t;
207 (first_u << 32) | second_u
208 }
209
210 fn first_f32(&self) -> f32 {
211 let first = ((self >> 32) & 0xFFFFFFFF) as u32;
212 f32::from_bits(first)
213 }
214
215 fn second_f32(&self) -> f32 {
216 let second = (self & 0xFFFFFFFF) as u32;
217 f32::from_bits(second)
218 }
219 }
220 };
221}
222
223impl_f32_packer_for_num!(u64);
224#[cfg(target_pointer_width = "64")]
225impl_f32_packer_for_num!(usize);
226impl_f32_packer_for_num!(i64);
227#[cfg(target_pointer_width = "64")]
228impl_f32_packer_for_num!(isize);