1#![no_std]
2
3pub trait Split16 : private::Sealed + Sized {
4 fn as_u8_array(self) -> [u8; 2];
5
6 #[inline]
7 fn as_i8_array(self) -> [i8; 2] {
8 let n = self.as_u8_array();
9 return [
10 n[0] as i8,
11 n[1] as i8
12 ]
13 }
14}
15
16impl Split16 for u16 {
17
18 #[inline]
19 fn as_u8_array(self) -> [u8; 2] {
20 self.to_ne_bytes()
21 }
22}
23
24impl Split16 for i16 {
25
26 #[inline]
27 fn as_u8_array(self) -> [u8; 2] {
28 self.to_ne_bytes()
29 }
30}
31
32pub trait Split32 : private::Sealed + Sized {
33 fn as_u8_array(self) -> [u8; 4];
34
35 #[inline]
36 fn as_i8_array(self) -> [i8; 4] {
37 let n = self.as_u8_array();
38 return [
39 n[0] as i8,
40 n[1] as i8,
41 n[2] as i8,
42 n[3] as i8
43 ]
44 }
45
46 #[inline]
47 fn as_u16_array(self) -> [u16; 2] {
48 let n = self.as_u8_array();
49 return [
50 u16::from_ne_bytes([n[0], n[1]]),
51 u16::from_ne_bytes([n[2], n[3]]),
52 ]
53 }
54
55 #[inline]
56 fn as_i16_array(self) -> [i16; 2] {
57 let n = self.as_u8_array();
58 return [
59 i16::from_ne_bytes([n[0], n[1]]),
60 i16::from_ne_bytes([n[2], n[3]]),
61 ]
62 }
63}
64
65impl Split32 for u32 {
66
67 #[inline]
68 fn as_u8_array(self) -> [u8; 4] {
69 self.to_ne_bytes()
70 }
71}
72
73impl Split32 for i32 {
74
75 #[inline]
76 fn as_u8_array(self) -> [u8; 4] {
77 self.to_ne_bytes()
78 }
79}
80
81impl Split32 for f32 {
82
83 #[inline]
84 fn as_u8_array(self) -> [u8; 4] {
85 self.to_ne_bytes()
86 }
87}
88
89pub trait Split64 : private::Sealed + Sized {
90 fn as_u8_array(self) -> [u8; 8];
91
92 #[inline]
93 fn as_i8_array(self) -> [i8; 8] {
94 let n = self.as_u8_array();
95 return [
96 n[0] as i8,
97 n[1] as i8,
98 n[2] as i8,
99 n[3] as i8,
100 n[4] as i8,
101 n[5] as i8,
102 n[6] as i8,
103 n[7] as i8,
104 ]
105 }
106
107 #[inline]
108 fn as_u16_array(self) -> [u16; 4] {
109 let n = self.as_u8_array();
110 return [
111 u16::from_ne_bytes([n[0], n[1]]),
112 u16::from_ne_bytes([n[2], n[3]]),
113 u16::from_ne_bytes([n[4], n[5]]),
114 u16::from_ne_bytes([n[6], n[7]]),
115 ]
116 }
117
118 #[inline]
119 fn as_i16_array(self) -> [i16; 4] {
120 let n = self.as_u8_array();
121 return [
122 i16::from_ne_bytes([n[0], n[1]]),
123 i16::from_ne_bytes([n[2], n[3]]),
124 i16::from_ne_bytes([n[4], n[5]]),
125 i16::from_ne_bytes([n[6], n[7]]),
126 ]
127 }
128
129 #[inline]
130 fn as_u32_array(self) -> [u32; 2] {
131 let n = self.as_u8_array();
132 return [
133 u32::from_ne_bytes([n[0], n[1], n[2], n[3]]),
134 u32::from_ne_bytes([n[4], n[5], n[6], n[7]]),
135 ]
136 }
137
138 #[inline]
139 fn as_i32_array(self) -> [i32; 2] {
140 let n = self.as_u8_array();
141 return [
142 i32::from_ne_bytes([n[0], n[1], n[2], n[3]]),
143 i32::from_ne_bytes([n[4], n[5], n[6], n[7]]),
144 ]
145 }
146
147 #[inline]
148 fn as_f32_array(self) -> [f32; 2] {
149 let n = self.as_u8_array();
150 return [
151 f32::from_ne_bytes([n[0], n[1], n[2], n[3]]),
152 f32::from_ne_bytes([n[4], n[5], n[6], n[7]]),
153 ]
154 }
155}
156
157impl Split64 for u64 {
158
159 #[inline]
160 fn as_u8_array(self) -> [u8; 8] {
161 self.to_ne_bytes()
162 }
163}
164
165impl Split64 for i64 {
166
167 #[inline]
168 fn as_u8_array(self) -> [u8; 8] {
169 self.to_ne_bytes()
170 }
171}
172
173impl Split64 for f64 {
174
175 #[inline]
176 fn as_u8_array(self) -> [u8; 8] {
177 self.to_ne_bytes()
178 }
179}
180
181pub trait Split128 : private::Sealed + Sized {
182 fn as_u8_array(self) -> [u8; 16];
183
184
185 #[inline]
186 fn as_i8_array(self) -> [i8; 16] {
187 let n = self.as_u8_array();
188 return [
189 n[0] as i8,
190 n[1] as i8,
191 n[2] as i8,
192 n[3] as i8,
193 n[4] as i8,
194 n[5] as i8,
195 n[6] as i8,
196 n[7] as i8,
197 n[8] as i8,
198 n[9] as i8,
199 n[10] as i8,
200 n[11] as i8,
201 n[12] as i8,
202 n[13] as i8,
203 n[14] as i8,
204 n[15] as i8,
205 ]
206 }
207
208 #[inline]
209 fn as_u16_array(self) -> [u16; 8] {
210 let n = self.as_u8_array();
211 return [
212 u16::from_ne_bytes([n[0], n[1]]),
213 u16::from_ne_bytes([n[2], n[3]]),
214 u16::from_ne_bytes([n[4], n[5]]),
215 u16::from_ne_bytes([n[6], n[7]]),
216 u16::from_ne_bytes([n[8], n[9]]),
217 u16::from_ne_bytes([n[10], n[11]]),
218 u16::from_ne_bytes([n[12], n[13]]),
219 u16::from_ne_bytes([n[14], n[15]]),
220 ]
221 }
222
223 #[inline]
224 fn as_i16_array(self) -> [i16; 8] {
225 let n = self.as_u8_array();
226 return [
227 i16::from_ne_bytes([n[0], n[1]]),
228 i16::from_ne_bytes([n[2], n[3]]),
229 i16::from_ne_bytes([n[4], n[5]]),
230 i16::from_ne_bytes([n[6], n[7]]),
231 i16::from_ne_bytes([n[8], n[9]]),
232 i16::from_ne_bytes([n[10], n[11]]),
233 i16::from_ne_bytes([n[12], n[13]]),
234 i16::from_ne_bytes([n[14], n[15]]),
235 ]
236 }
237
238 #[inline]
239 fn as_u32_array(self) -> [u32; 4] {
240 let n = self.as_u8_array();
241 return [
242 u32::from_ne_bytes([n[0], n[1], n[2], n[3]]),
243 u32::from_ne_bytes([n[4], n[5], n[6], n[7]]),
244 u32::from_ne_bytes([n[8], n[9], n[10], n[11]]),
245 u32::from_ne_bytes([n[12], n[13], n[14], n[15]]),
246 ]
247 }
248
249 #[inline]
250 fn as_i32_array(self) -> [i32; 4] {
251 let n = self.as_u8_array();
252 return [
253 i32::from_ne_bytes([n[0], n[1], n[2], n[3]]),
254 i32::from_ne_bytes([n[4], n[5], n[6], n[7]]),
255 i32::from_ne_bytes([n[8], n[9], n[10], n[11]]),
256 i32::from_ne_bytes([n[12], n[13], n[14], n[15]]),
257 ]
258 }
259
260 #[inline]
261 fn as_f32_array(self) -> [f32; 4] {
262 let n = self.as_u8_array();
263 return [
264 f32::from_ne_bytes([n[0], n[1], n[2], n[3]]),
265 f32::from_ne_bytes([n[4], n[5], n[6], n[7]]),
266 f32::from_ne_bytes([n[8], n[9], n[10], n[11]]),
267 f32::from_ne_bytes([n[12], n[13], n[14], n[15]]),
268 ]
269 }
270
271 #[inline]
272 fn as_u64_array(self) -> [u64; 2] {
273 let n = self.as_u8_array();
274 return [
275 u64::from_ne_bytes([n[0], n[1], n[2], n[3],n[4], n[5], n[6], n[7]]),
276 u64::from_ne_bytes([n[8], n[9], n[10], n[11],n[12], n[13], n[14], n[15]]),
277 ]
278 }
279
280 #[inline]
281 fn as_i64_array(self) -> [i64; 2] {
282 let n = self.as_u8_array();
283 return [
284 i64::from_ne_bytes([n[0], n[1], n[2], n[3],n[4], n[5], n[6], n[7]]),
285 i64::from_ne_bytes([n[8], n[9], n[10], n[11],n[12], n[13], n[14], n[15]]),
286 ]
287 }
288
289 #[inline]
290 fn as_f64_array(self) -> [f64; 2] {
291 let n = self.as_u8_array();
292 return [
293 f64::from_ne_bytes([n[0], n[1], n[2], n[3],n[4], n[5], n[6], n[7]]),
294 f64::from_ne_bytes([n[8], n[9], n[10], n[11],n[12], n[13], n[14], n[15]]),
295 ]
296 }
297}
298
299impl Split128 for u128 {
300
301 #[inline]
302 fn as_u8_array(self) -> [u8; 16] {
303 self.to_ne_bytes()
304 }
305}
306
307impl Split128 for i128 {
308
309 #[inline]
310 fn as_u8_array(self) -> [u8; 16] {
311 self.to_ne_bytes()
312 }
313}
314
315pub(crate) mod private {
316 pub trait Sealed {
317
318 }
319
320 impl Sealed for u16 {
321
322 }
323 impl Sealed for i16 {
324
325 }
326 impl Sealed for u32 {
327
328 }
329 impl Sealed for i32 {
330
331 }
332 impl Sealed for u64 {
333
334 }
335 impl Sealed for i64 {
336
337 }
338 impl Sealed for u128 {
339
340 }
341 impl Sealed for i128 {
342
343 }
344 impl Sealed for f32 {
345
346 }
347 impl Sealed for f64 {
348
349 }
350}