bit_byte_bit/conversion.rs
1use crate::{Bits};
2
3
4macro_rules! pack_bytes {
5 (4; $bytes:expr, $i:expr) => {
6 pack_to_int!(u64; $bytes[$i], $bytes[$i + 1], $bytes[$i + 2], $bytes[$i + 3])
7 };
8 (8; $bytes:expr, $i:expr) => {
9 pack_to_int!(u64;
10 $bytes[$i], $bytes[$i + 1], $bytes[$i + 2], $bytes[$i + 3],
11 $bytes[$i + 4], $bytes[$i + 5], $bytes[$i + 6], $bytes[$i + 7]
12 )
13 };
14 ($ty:ty; $bytes:expr) => {
15 match <$ty>::BITS {
16 32 => match $bytes.len() {
17 0 => 0,
18 1 => $bytes[0] as $ty,
19 2 => pack_to_int!($ty; $bytes[0], $bytes[1]),
20 3 => pack_to_int!($ty; $bytes[0], $bytes[1], $bytes[2]),
21 _ => pack_to_int!($ty; $bytes[0], $bytes[1], $bytes[2], $bytes[3])
22 },
23 _ => match $bytes.len() {
24 0 => 0,
25 1 => $bytes[0] as $ty,
26 2 => pack_to_int!($ty; $bytes[0], $bytes[1]),
27 3 => pack_to_int!($ty; $bytes[0], $bytes[1], $bytes[2]),
28 4 => pack_to_int!($ty; $bytes[0], $bytes[1], $bytes[2], $bytes[3]),
29 5 => pack_to_int!($ty; $bytes[0], $bytes[1], $bytes[2], $bytes[3], $bytes[4]),
30 6 => pack_to_int!($ty;
31 $bytes[0], $bytes[1], $bytes[2], $bytes[3], $bytes[4], $bytes[5]
32 ),
33 7 => pack_to_int!($ty;
34 $bytes[0], $bytes[1], $bytes[2], $bytes[3], $bytes[4], $bytes[5], $bytes[6]
35 ),
36 _ => pack_to_int!($ty;
37 $bytes[0], $bytes[1], $bytes[2], $bytes[3],
38 $bytes[4], $bytes[5], $bytes[6], $bytes[7]
39 )
40 }
41 }
42 };
43 ($ty:ty, $ty_nbits:tt, $ty_nbytes:tt, $ty_pow2:literal; $bits:expr) => {{
44 if $bits.nbits == 0 { return vec![]; }
45
46 let bytes = $bits.bytes();
47 let bytes_len = bytes.len();
48 let mut packed = Vec::with_capacity(((bytes_len - 1) >> $ty_pow2) + 1);
49 let remaining_byte_len = bytes_len & ($ty_nbytes - 1);
50 let max_byte = bytes_len - remaining_byte_len;
51
52 for i in (0..max_byte).step_by($ty_nbytes) {
53 packed.push(pack_bytes!($ty_nbytes; bytes, i) as $ty);
54 }
55
56 if remaining_byte_len > 0 {
57 let remaining_bytes = &bytes[max_byte..];
58 let remaining_bit_len = remaining_byte_len << 3;
59
60 packed.push(pack_to_int!($ty; remaining_bytes; remaining_bit_len; $ty_nbits));
61 }
62
63 packed
64 }};
65 ($ty:ty, $ity:ty, $uty_nbits:tt, $uty_nbytes:tt, $uty_pow2:literal; $bits:expr) => {{
66 if $bits.nbits == 0 { return vec![]; }
67
68 let bytes = $bits.bytes();
69 let bytes_len = bytes.len();
70 let mut packed = Vec::with_capacity(((bytes_len - 1) >> $uty_pow2) + 1);
71 let remaining_byte_len = bytes_len & ($uty_nbytes - 1);
72 let max_byte = bytes_len - remaining_byte_len;
73
74 for i in (0..max_byte).step_by($uty_nbytes) {
75 packed.push(pack_bytes!($uty_nbytes; bytes, i) as $ty);
76 }
77
78 if remaining_byte_len == 0 && $bits.padding == 0 { return packed; }
79
80 let overflow = 8 - $bits.padding;
81
82 let (last_bytes, length) = if remaining_byte_len == 0 {
83 (packed.pop().unwrap() as $ity, $uty_nbits - 8 + overflow)
84 } else {
85 let remaining_bytes = &bytes[max_byte..];
86 let remaining_bit_len = remaining_byte_len << 3;
87
88 (
89 pack_to_int!($ity; remaining_bytes; remaining_bit_len; $uty_nbits),
90 ((remaining_byte_len - 1) << 3) + overflow
91 )
92 };
93
94 packed.push(sign_extend!(last_bytes, length) as $ty);
95
96 packed
97 }}
98}
99
100macro_rules! pack_to_int {
101 ($int:ty; $bytes:expr; $length_in_bits:expr; 16) =>{{
102 if $length_in_bits == 0 {
103 0
104 } else {
105 let (sat_length, mask) = if $length_in_bits >= 16 {
106 (16, 0xFFFFu16 as $int)
107 } else {
108 ($length_in_bits, ((1u16 << $length_in_bits) - 1) as $int)
109 };
110
111 let packed_bytes = match sat_length {
112 n if n <= 8 => $bytes[0] as $int,
113 _ => pack_to_int!($int; $bytes[0], $bytes[1]),
114 };
115
116 packed_bytes & mask
117 }
118 }};
119 ($int:ty; $bytes:expr; $length_in_bits:expr; 32) =>{{
120 if $length_in_bits == 0 {
121 0
122 } else {
123 let (sat_length, mask) = if $length_in_bits >= 32 {
124 (32, 0xFFFFFFFFu32 as $int)
125 } else {
126 ($length_in_bits, ((1u32 << $length_in_bits) - 1) as $int)
127 };
128
129 let packed_bytes = match sat_length {
130 n if n <= 8 => $bytes[0] as $int,
131 n if n <= 16 => pack_to_int!($int; $bytes[0], $bytes[1]),
132 n if n <= 24 => pack_to_int!($int; $bytes[0], $bytes[1], $bytes[2]),
133 _ => pack_to_int!($int; $bytes[0], $bytes[1], $bytes[2], $bytes[3])
134 };
135
136 packed_bytes & mask
137 }
138 }};
139 ($int:ty; $bytes:expr; $length_in_bits:expr; 64) =>{{
140 if $length_in_bits == 0 {
141 0
142 } else {
143 let (sat_length, mask) = if $length_in_bits >= 64 {
144 (64, 0xFFFFFFFFFFFFFFFFu64 as $int)
145 } else {
146 ($length_in_bits, ((1u64 << $length_in_bits) - 1) as $int)
147 };
148
149 let packed_bytes = match sat_length {
150 n if n <= 8 => $bytes[0] as $int,
151 n if n <= 16 => pack_to_int!($int; $bytes[0], $bytes[1]),
152 n if n <= 24 => pack_to_int!($int; $bytes[0], $bytes[1], $bytes[2]),
153 n if n <= 32 => pack_to_int!($int; $bytes[0], $bytes[1], $bytes[2], $bytes[3]),
154 n if n <= 40 => pack_to_int!($int;
155 $bytes[0], $bytes[1], $bytes[2], $bytes[3], $bytes[4]
156 ),
157 n if n <= 48 => pack_to_int!($int;
158 $bytes[0], $bytes[1], $bytes[2], $bytes[3], $bytes[4], $bytes[5]
159 ),
160 n if n <= 56 => pack_to_int!($int;
161 $bytes[0], $bytes[1], $bytes[2], $bytes[3], $bytes[4], $bytes[5], $bytes[6]
162 ),
163 _ => pack_to_int!($int;
164 $bytes[0], $bytes[1], $bytes[2], $bytes[3],
165 $bytes[4], $bytes[5], $bytes[6], $bytes[7]
166 )
167 };
168
169 packed_bytes & mask
170 }
171 }};
172 ($ty:ty; $b0:expr, $b1:expr) =>{ ($b0 as $ty) | (($b1 as $ty) << 8) };
173 ($ty:ty; $b0:expr, $b1:expr, $b2:expr) => {
174 pack_to_int!($ty; $b0, $b1) | (($b2 as $ty) << 16)
175 };
176 ($ty:ty; $b0:expr, $b1:expr, $b2:expr, $b3:expr) => {
177 pack_to_int!($ty; $b0, $b1, $b2) | (($b3 as $ty) << 24)
178 };
179 ($ty:ty; $b0:expr, $b1:expr, $b2:expr, $b3:expr, $b4:expr) => {
180 pack_to_int!($ty; $b0, $b1, $b2, $b3) | (($b4 as $ty) << 32)
181 };
182 ($ty:ty; $b0:expr, $b1:expr, $b2:expr, $b3:expr, $b4:expr, $b5:expr) => {
183 pack_to_int!($ty; $b0, $b1, $b2, $b3, $b4) | (($b5 as $ty) << 40)
184 };
185 ($ty:ty; $b0:expr, $b1:expr, $b2:expr, $b3:expr, $b4:expr, $b5:expr, $b6:expr) => {
186 pack_to_int!($ty; $b0, $b1, $b2, $b3, $b4, $b5) | (($b6 as $ty) << 48)
187 };
188 ($ty:ty; $b0:expr, $b1:expr, $b2:expr, $b3:expr, $b4:expr, $b5:expr, $b6:expr, $b7:expr) => {
189 pack_to_int!($ty; $b0, $b1, $b2, $b3, $b4, $b5, $b6) | (($b7 as $ty) << 56)
190 };
191 ($bytes:expr; $length_in_bits:expr; 16) => {{
192 if $length_in_bits == 0 {
193 0
194 } else {
195 let (sat_length, mask) = if $length_in_bits >= 16 {
196 (16, 0xFFFFFu16)
197 } else {
198 ($length_in_bits, ((1 << $length_in_bits) - 1))
199 };
200
201 let packed = match sat_length {
202 n if n <= 8 => $bytes[0],
203 _ => pack_to_int!($bytes[0], $bytes[1])
204 };
205
206 packed & mask
207 }
208 }};
209 ($bytes:expr; $length_in_bits:expr; 32) => {{
210 if $length_in_bits == 0 {
211 0
212 } else {
213 let (sat_length, mask) = if $length_in_bits >= 32 {
214 (32, 0xFFFFFFFFFu64)
215 } else {
216 ($length_in_bits, ((1 << $length_in_bits) - 1))
217 };
218
219 let packed = match sat_length {
220 n if n <= 8 => $bytes[0],
221 n if n <= 16 => pack_to_int!($bytes[0], $bytes[1]),
222 n if n <= 24 => pack_to_int!($bytes[0], $bytes[1], $bytes[2]),
223 _ => pack_to_int!($bytes[0], $bytes[1], $bytes[2], $bytes[3])
224 };
225
226 packed & mask
227 }
228 }};
229 ($bytes:expr; $length_in_bits:expr; 64) => {{
230 if $length_in_bits == 0 {
231 0
232 } else {
233 let (sat_length, mask) = if $length_in_bits >= 64 {
234 (64, 0xFFFFFFFFFFFFFFFFu64)
235 } else {
236 ($length_in_bits, ((1 << $length_in_bits) - 1))
237 };
238
239 let packed = match sat_length {
240 n if n <= 8 => $bytes[0],
241 n if n <= 16 => pack_to_int!($bytes[0], $bytes[1]),
242 n if n <= 24 => pack_to_int!($bytes[0], $bytes[1], $bytes[2]),
243 n if n <= 32 => pack_to_int!($bytes[0], $bytes[1], $bytes[2], $bytes[3]),
244 n if n <= 40 => pack_to_int!($bytes[0], $bytes[1], $bytes[2], $bytes[3], $bytes[4]),
245 n if n <= 48 => pack_to_int!(
246 $bytes[0], $bytes[1], $bytes[2], $bytes[3], $bytes[4], $bytes[5]
247 ),
248 n if n <= 56 => pack_to_int!(
249 $bytes[0], $bytes[1], $bytes[2], $bytes[3], $bytes[4], $bytes[5], $bytes[6]
250 ),
251 _ => pack_to_int!(
252 $bytes[0], $bytes[1], $bytes[2], $bytes[3],
253 $bytes[4], $bytes[5], $bytes[6], $bytes[7]
254 )
255 };
256
257 packed & mask
258 }
259 }};
260 ($b0:expr, $b1:expr) =>{ $b0 | ( $b1 << 8) };
261 ($b0:expr, $b1:expr, $b2:expr) => { pack_to_int!($b0, $b1) | ($b2 << 16) };
262 ($b0:expr, $b1:expr, $b2:expr, $b3:expr) => { pack_to_int!($b0, $b1, $b2) | ($b3 << 24) };
263 ($b0:expr, $b1:expr, $b2:expr, $b3:expr, $b4:expr) => {
264 pack_to_int!($b0, $b1, $b2, $b3) | ($b4 << 32)
265 };
266 ($b0:expr, $b1:expr, $b2:expr, $b3:expr, $b4:expr, $b5:expr) => {
267 pack_to_int!($b0, $b1, $b2, $b3, $b4) | ($b5 << 40)
268 };
269 ($b0:expr, $b1:expr, $b2:expr, $b3:expr, $b4:expr, $b5:expr, $b6:expr) => {
270 pack_to_int!($b0, $b1, $b2, $b3, $b4, $b5) | ($b6 << 48)
271 };
272 ($b0:expr, $b1:expr, $b2:expr, $b3:expr, $b4:expr, $b5:expr, $b6:expr, $b7:expr) => {
273 pack_to_int!($b0, $b1, $b2, $b3, $b4, $b5, $b6) | ($b7 << 56)
274 }
275}
276
277macro_rules! sign_extend {
278 ($n:expr, $bits:expr) => {
279 $n | ((signed_bit_mask!($n, $bits) >> $bits) << $bits)
280 }
281}
282
283macro_rules! signed_bit_mask {
284 ($n:expr, $bits:expr) => {
285 (!(($n >> ($bits - 1)) & 1)).wrapping_add(1)
286 };
287}
288
289
290pub mod bits_as {
291
292 use crate::{Bits};
293
294 /// Converts a bit string to a vector of booleans
295 ///
296 /// # Example
297 /// ```
298 /// # use bit_byte_bit::{Bits, bits_as};
299 /// let bits = Bits::new([0x10, 0x32]);
300 /// let bools = bits_as::vec_bool(&bits);
301 ///
302 /// assert_eq!(bools.len(), bits.len());
303 ///
304 /// assert_eq!(
305 /// bools,
306 /// vec![
307 /// false, false, false, false, true, false, false, false,
308 /// false, true, false, false, true, true, false, false
309 /// ]
310 /// );
311 /// ```
312 pub fn vec_bool(bits: &Bits) -> Vec<bool> { bits.iter().map(|bit| bit == 1).collect() }
313
314 /// Converts a bit string to a vector of 32 bit floats
315 ///
316 /// # Example
317 /// ```
318 /// # use bit_byte_bit::{bits_as, Bits};
319 /// let bits = Bits::new([0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE]);
320 /// let floats = bits_as::vec_f32(&bits);
321 ///
322 /// assert_eq!(floats.len(), 2);
323 /// assert_eq!(floats, vec![f32::from_bits(0x76543210), f32::from_bits(0xFEDCBA98)]);
324 ///
325 /// let bits = Bits::new([0x10, 0x32, 0x54]);
326 /// let floats = bits_as::vec_f32(&bits);
327 ///
328 /// assert_eq!(floats.len(), 1);
329 /// assert_eq!(floats, vec![f32::from_bits(0x00543210)]);
330 /// ```
331 pub fn vec_f32(bits: &Bits) -> Vec<f32> {
332 if bits.nbits == 0 { return vec![]; }
333
334 let bytes = bits.bytes();
335 let bytes_len = bytes.len();
336 let mut packed = Vec::with_capacity(((bytes_len - 1) >> 2) + 1);
337
338 for i in (0..(bytes_len - (bytes_len & 3))).step_by(4) {
339 packed.push(
340 f32::from_bits(pack_to_int!(u32; bytes[i], bytes[i + 1], bytes[i + 2], bytes[i + 3]))
341 );
342 }
343
344 match bytes_len & 3 {
345 1 => packed.push(f32::from_bits(bytes[bytes_len - 1] as u32)),
346 2 => packed.push(
347 f32::from_bits(pack_to_int!(u32; bytes[bytes_len - 2], bytes[bytes_len - 1]))
348 ),
349 3 => packed.push(
350 f32::from_bits(pack_to_int!(u32;
351 bytes[bytes_len - 3],bytes[bytes_len - 2],bytes[bytes_len - 1]
352 ))
353 ),
354 _ => ()
355 }
356
357 packed
358 }
359
360 /// Converts a bit string to a vector of 64 bit floats
361 ///
362 /// # Example
363 /// ```
364 /// # use bit_byte_bit::{bits_as, Bits};
365 /// let bits = Bits::new([0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE]);
366 /// let floats = bits_as::vec_f64(&bits);
367 ///
368 /// assert_eq!(floats.len(), 1);
369 /// assert_eq!(floats, vec![f64::from_bits(0xFEDCBA9876543210)]);
370 ///
371 /// let bits = Bits::new([0x10, 0x32, 0x54]);
372 /// let floats = bits_as::vec_f64(&bits);
373 ///
374 /// assert_eq!(floats.len(), 1);
375 /// assert_eq!(floats, vec![f64::from_bits(0x0000000000543210)]);
376 /// ```
377 pub fn vec_f64(bits: &Bits) -> Vec<f64> {
378 if bits.nbits == 0 { return vec![]; }
379
380 let bytes = bits.bytes();
381 let bytes_len = bytes.len();
382 let mut packed = Vec::with_capacity(((bytes_len - 1) >> 2) + 1);
383 let remaining_byte_len = bytes_len & 7;
384 let max_byte = bytes_len - remaining_byte_len;
385
386 for i in (0..max_byte).step_by(8) {
387 packed.push(f64::from_bits(pack_bytes!(8; bytes, i)));
388 }
389
390 if max_byte < bytes_len {
391 let remaining_bytes = &bytes[max_byte..];
392 let remaining_bit_len = remaining_byte_len << 3;
393
394 packed.push(f64::from_bits(
395 pack_to_int!(u64; remaining_bytes; remaining_bit_len; 64))
396 );
397 }
398
399 packed
400 }
401
402 /// Converts a bit string to a vector of 8 bit signed integers.
403 ///
404 /// If the length of the the bit string is not divisible by 8, it is
405 /// sign-extended to the next length that is, then it is converted.
406 ///
407 /// # Example
408 /// ```
409 /// # use bit_byte_bit::{bits_as, Bits};
410 /// let bits = Bits::new([0x10, 0xFE]);
411 /// let ibytes = bits_as::vec_i8(&bits);
412 ///
413 /// assert_eq!(ibytes.len(), 2);
414 /// assert_eq!(ibytes, vec![0x10, 0xFEu8 as i8]);
415 ///
416 /// let bits = Bits::from([0x10, 0x5E]);
417 /// let ibytes = bits_as::vec_i8(&bits);
418 ///
419 /// assert_eq!(ibytes.len(), 2);
420 /// assert_eq!(ibytes, vec![0x10, 0xDEu8 as i8]);
421 /// ```
422 pub fn vec_i8(bits: &Bits) -> Vec<i8> {
423 if bits.padding == 0 {
424 bits.bytes().iter().map(|b| *b as i8).collect()
425 } else {
426 let bytes = bits.bytes();
427
428 let mut packed = bytes[..(bytes.len() - 1)].iter()
429 .map(|b| *b as i8)
430 .collect::<Vec<_>>();
431
432 let overflow = 8 - bits.padding;
433 let last_byte = bytes[bytes.len() - 1];
434
435 packed.push(sign_extend!(last_byte, overflow) as i8);
436
437 packed
438 }
439 }
440
441 /// Converts a bit string to a vector of 16 bit signed integers.
442 ///
443 /// If the length of the the bit string is not divisible by 16 it is
444 /// sign-extended to the next length that is, then it is converted.
445 ///
446 /// # Example
447 /// ```
448 /// # use bit_byte_bit::{bits_as, Bits};
449 /// let bits = Bits::new([0x10, 0xFE]);
450 /// let ishorts = bits_as::vec_i16(&bits);
451 ///
452 /// assert_eq!(ishorts.len(), 1);
453 /// assert_eq!(ishorts, vec![0xFE10u16 as i16]);
454 ///
455 /// let bits = Bits::from([0x10, 0x5E]);
456 /// let ishorts = bits_as::vec_i16(&bits);
457 ///
458 /// assert_eq!(ishorts.len(), 1);
459 /// assert_eq!(ishorts, vec![0xDE10u16 as i16]);
460 /// ```
461 pub fn vec_i16(bits: &Bits) -> Vec<i16> {
462 if bits.nbits == 0 { return vec![]; }
463
464 let bytes = bits.bytes();
465 let bytes_len = bytes.len();
466 let mut packed = Vec::with_capacity(((bytes_len - 1) >> 1) + 1);
467 let remaining = bytes_len & 1;
468
469 for i in (0..(bytes_len - remaining)).step_by(2) {
470 packed.push(pack_to_int!(u16; bytes[i], bytes[i + 1]) as i16);
471 }
472
473 let overflow = 8 - bits.padding;
474
475 if remaining == 1 {
476 let last_byte = bytes[bytes.len() - 1] as u16;
477
478 packed.push(sign_extend!(last_byte, overflow) as i16);
479 } else if bits.padding != 0 {
480 let last_byte = packed.pop().unwrap() as u16;
481
482 packed.push(sign_extend!(last_byte, 8 + overflow) as i16);
483 }
484
485 packed
486 }
487
488 /// Converts a bit string to a vector of 32 bit signed integers.
489 ///
490 /// If the length of the the bit string is not divisible by 32 it is
491 /// sign-extended to the next length that is, then it is converted.
492 ///
493 /// # Example
494 /// ```
495 /// # use bit_byte_bit::{bits_as, Bits};
496 /// let bits = Bits::new([0x10, 0x32, 0x54, 0x76]);
497 /// let ints = bits_as::vec_i32(&bits);
498 ///
499 /// assert_eq!(ints.len(), 1);
500 /// assert_eq!(ints, vec![0x76543210]);
501 ///
502 /// let bits = Bits::from([0x10, 0x32, 0x54, 0x76]);
503 /// let ints = bits_as::vec_i32(&bits);
504 ///
505 /// assert_eq!(ints.len(), 1);
506 /// assert_eq!(ints, vec![0xF6543210u32 as i32]);
507 /// ```
508 pub fn vec_i32(bits: &Bits) -> Vec<i32> {
509 if bits.nbits == 0 { return vec![]; }
510
511 let bytes = bits.bytes();
512 let bytes_len = bytes.len();
513 let mut packed = Vec::with_capacity(((bytes_len - 1) >> 2) + 1);
514 let remaining = bytes_len & 3;
515
516 for i in (0..(bytes_len - remaining)).step_by(4) {
517 packed.push(
518 pack_to_int!(u32; bytes[i], bytes[i + 1], bytes[i + 2], bytes[i + 3]) as i32
519 );
520 }
521
522 if remaining == 0 && bits.padding == 0 { return packed; }
523
524 let overflow = 8 - bits.padding;
525
526 let (packed_bytes, byte_len) = match remaining {
527 0 => (packed.pop().unwrap() as u32, 24),
528 1 => (bytes[bytes.len() - 1] as u32, 0),
529 2 => (pack_to_int!(u32; bytes[bytes_len - 2], bytes[bytes_len - 1]), 8),
530 _ => (
531 pack_to_int!(u32; bytes[bytes_len - 3], bytes[bytes_len - 2], bytes[bytes_len - 1]),
532 16
533 )
534 };
535
536 let length = byte_len + overflow;
537
538 packed.push(sign_extend!(packed_bytes, length) as i32);
539
540 packed
541 }
542
543 /// Converts a bit string to a vector of 64 bit signed integers.
544 ///
545 /// If the length of the the bit string is not divisible by 64 it is
546 /// sign-extended to the next length that is, then it is converted.
547 ///
548 /// # Example
549 /// ```
550 /// # use bit_byte_bit::{bits_as, Bits};
551 /// let bits = Bits::new([0x10, 0x32, 0x54, 0x76]);
552 /// let longs = bits_as::vec_i64(&bits);
553 ///
554 /// assert_eq!(longs.len(), 1);
555 /// assert_eq!(longs, vec![0x0000000076543210]);
556 ///
557 /// let bits = Bits::from([0x10, 0x32, 0x54, 0x76]);
558 /// let longs = bits_as::vec_i64(&bits);
559 ///
560 /// assert_eq!(longs.len(), 1);
561 /// assert_eq!(longs, vec![0xFFFFFFFFF6543210u64 as i64]);
562 /// ```
563 pub fn vec_i64(bits: &Bits) -> Vec<i64> {
564 if bits.nbits == 0 { return vec![]; }
565
566 let bytes = bits.bytes();
567 let bytes_len = bytes.len();
568 let mut packed = Vec::with_capacity(((bytes_len - 1) >> 2) + 1);
569 let remaining_byte_len = bytes_len & 7;
570 let max_byte = bytes_len - remaining_byte_len;
571
572 for i in (0..max_byte).step_by(8) {
573 packed.push(pack_bytes!(8; bytes, i) as i64);
574 }
575
576 if remaining_byte_len == 0 && bits.padding == 0 { return packed; }
577
578 let overflow = 8 - bits.padding;
579
580 let (last_bytes, length) = if remaining_byte_len == 0 {
581 (packed.pop().unwrap() as u64, 56 + overflow)
582 } else {
583 let remaining_bytes = &bytes[max_byte..];
584 let remaining_bit_len = remaining_byte_len << 3;
585
586 (
587 pack_to_int!(u64; remaining_bytes; remaining_bit_len; 64),
588 ((remaining_byte_len - 1) << 3) + overflow
589 )
590 };
591
592 packed.push(sign_extend!(last_bytes, length) as i64);
593
594 packed
595 }
596
597 /// Converts a bit string to a vector of signed integers.
598 ///
599 /// If the length of the the bit string is not divisible by the length of `isize`, it is
600 /// sign-extended to the next length that is, then it is converted.
601 ///
602 /// # Example
603 /// ```
604 /// # use bit_byte_bit::{bits_as, Bits};
605 /// let bits = Bits::new([0x10, 0x32, 0x54, 0x76]);
606 /// let signed_ints = bits_as::vec_isize(&bits);
607 ///
608 /// assert_eq!(signed_ints.len(), 1);
609 /// assert_eq!(signed_ints, vec![0x0000000076543210]);
610 ///
611 /// let bits = Bits::from([0x10, 0x32, 0x54, 0x76]);
612 /// let signed_ints = bits_as::vec_i64(&bits);
613 ///
614 /// assert_eq!(signed_ints.len(), 1);
615 /// assert_eq!(signed_ints, vec![0xFFFFFFFFF6543210u64 as i64]);
616 /// ```
617 pub fn vec_isize(bits: &Bits) -> Vec<isize> {
618 match isize::BITS {
619 32 => pack_bytes!(isize, u32, 32, 4, 2; bits),
620 _ => pack_bytes!(isize, u64, 64, 8, 3; bits),
621 }
622 }
623
624 /// Converts a bit string to a vector of 8 bit unsigned integers.
625 ///
626 /// # Example
627 /// ```
628 /// # use bit_byte_bit::{bits_as, Bits};
629 /// let bits = Bits::new([0x10, 0xFE]);
630 /// let bytes = bits_as::vec_u8(&bits);
631 ///
632 /// assert_eq!(bytes.len(), 2);
633 /// assert_eq!(bytes, vec![0x10, 0xFE]);
634 ///
635 /// let bits = Bits::from([0x10, 0x5E]);
636 /// let bytes = bits_as::vec_u8(&bits);
637 ///
638 /// assert_eq!(bytes.len(), 2);
639 /// assert_eq!(bytes, vec![0x10, 0x5E]);
640 /// ```
641 pub fn vec_u8(bits: &Bits) -> Vec<u8> { bits.bytes().to_vec() }
642
643 /// Converts a bit string to a vector of 16 bit unsigned integers.
644 ///
645 /// # Example
646 /// ```
647 /// # use bit_byte_bit::{bits_as, Bits};
648 /// let bits = Bits::new([0x10, 0xFE]);
649 /// let shorts = bits_as::vec_u16(&bits);
650 ///
651 /// assert_eq!(shorts.len(), 1);
652 /// assert_eq!(shorts, vec![0xFE10]);
653 ///
654 /// let bits = Bits::from([0x10, 0x5E]);
655 /// let shorts = bits_as::vec_u16(&bits);
656 ///
657 /// assert_eq!(shorts.len(), 1);
658 /// assert_eq!(shorts, vec![0x5E10])
659 /// ```
660 pub fn vec_u16(bits: &Bits) -> Vec<u16> {
661 if bits.nbits == 0 { return vec![]; }
662
663 let bytes = bits.bytes();
664 let bytes_len = bytes.len();
665 let mut packed = Vec::with_capacity(((bytes_len - 1) >> 1) + 1);
666
667 for i in (0..(bytes_len - (bytes_len & 1))).step_by(2) {
668 packed.push(pack_to_int!(u16; bytes[i], bytes[i + 1]));
669 }
670
671 if (bytes_len & 1) == 1 {
672 packed.push(bytes[bytes_len - 1] as u16);
673 }
674
675 packed
676 }
677
678 /// Converts a bit string to a vector of 32 bit unsigned integers.
679 ///
680 /// # Example
681 /// ```
682 /// # use bit_byte_bit::{bits_as, Bits};
683 /// let bits = Bits::new([0x10, 0x32, 0x54, 0x76]);
684 /// let uints = bits_as::vec_u32(&bits);
685 ///
686 /// assert_eq!(uints.len(), 1);
687 /// assert_eq!(uints, vec![0x76543210]);
688 ///
689 /// let bits = Bits::from([0x10, 0x32, 0x54, 0x76]);
690 /// let uints = bits_as::vec_u32(&bits);
691 ///
692 /// assert_eq!(uints.len(), 1);
693 /// assert_eq!(uints, vec![0x76543210]);
694 /// ```
695 pub fn vec_u32(bits: &Bits) -> Vec<u32> {
696 if bits.nbits == 0 { return vec![]; }
697
698 let bytes = bits.bytes();
699 let bytes_len = bytes.len();
700 let mut packed = Vec::with_capacity(((bytes_len - 1) >> 2) + 1);
701
702 for i in (0..(bytes_len - (bytes_len & 3))).step_by(4) {
703 packed.push(
704 pack_to_int!(u32; bytes[i], bytes[i + 1], bytes[i + 2], bytes[i + 3])
705 );
706 }
707
708 match bytes_len & 3 {
709 1 => packed.push(bytes[bytes_len - 1] as u32),
710 2 => packed.push(pack_to_int!(u32; bytes[bytes_len - 2], bytes[bytes_len - 1])),
711 3 => packed.push(
712 pack_to_int!(u32;
713 bytes[bytes_len - 3],bytes[bytes_len - 2],bytes[bytes_len - 1]
714 )
715 ),
716 _ => ()
717 }
718
719 packed
720 }
721
722 /// Converts a bit string to a vector of 64 bit unsigned integers.
723 ///
724 /// If the length of the the bit string is not divisible by 64 it is
725 /// sign-extended to the next length that is, then it is converted.
726 ///
727 /// # Example
728 /// ```
729 /// # use bit_byte_bit::{bits_as, Bits};
730 /// let bits = Bits::new([0x10, 0x32, 0x54, 0x76]);
731 /// let ulongs = bits_as::vec_u64(&bits);
732 ///
733 /// assert_eq!(ulongs.len(), 1);
734 /// assert_eq!(ulongs, vec![0x0000000076543210]);
735 ///
736 /// let bits = Bits::from([0x10, 0x32, 0x54, 0x76]);
737 /// let ulongs = bits_as::vec_u64(&bits);
738 ///
739 /// assert_eq!(ulongs.len(), 1);
740 /// assert_eq!(ulongs, vec![0x0000000076543210]);
741 /// ```
742 pub fn vec_u64(bits: &Bits) -> Vec<u64> {
743 if bits.nbits == 0 { return vec![]; }
744
745 let bytes = bits.bytes();
746 let bytes_len = bytes.len();
747 let mut packed = Vec::with_capacity(((bytes_len - 1) >> 2) + 1);
748 let remaining_byte_len = bytes_len & 7;
749 let max_byte = bytes_len - remaining_byte_len;
750
751 for i in (0..max_byte).step_by(8) {
752 packed.push(pack_bytes!(8; bytes, i));
753 }
754
755 if max_byte < bytes_len {
756 let remaining_bytes = &bytes[max_byte..];
757 let remaining_bit_len = remaining_byte_len << 3;
758
759 packed.push(pack_to_int!(u64; remaining_bytes; remaining_bit_len; 64));
760 }
761
762 packed
763 }
764
765 /// Converts a bit string to a vector of unsigned integers.
766 ///
767 /// # Example
768 /// ```
769 /// # use bit_byte_bit::{bits_as, Bits};
770 /// let bits = Bits::new([0x10, 0x32, 0x54, 0x76]);
771 /// let unsigned_ints = bits_as::vec_usize(&bits);
772 ///
773 /// assert_eq!(unsigned_ints.len(), 1);
774 /// assert_eq!(unsigned_ints, vec![0x0000000076543210]);
775 ///
776 /// let bits = Bits::from([0x10, 0x32, 0x54, 0x76]);
777 /// let unsigned_ints = bits_as::vec_usize(&bits);
778 ///
779 /// assert_eq!(unsigned_ints.len(), 1);
780 /// assert_eq!(unsigned_ints, vec![0x0000000076543210]);
781 /// ```
782 pub fn vec_usize(bits: &Bits) -> Vec<usize> {
783 match usize::BITS {
784 32 => pack_bytes!(usize, 32, 4, 2; bits),
785 _ => pack_bytes!(usize, 64, 8, 3; bits),
786 }
787 }
788
789 /// Converts up to the first 32 bits of a bit string to a 32 bit float
790 ///
791 /// # Example
792 /// ```
793 /// # use bit_byte_bit::{bits_as, Bits};
794 /// let bits = Bits::new([0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE]);
795 /// let float = bits_as::float32(&bits);
796 ///
797 /// assert_eq!(float, f32::from_bits(0x76543210));
798 ///
799 /// let bits = Bits::new([0x10, 0x32, 0x54]);
800 /// let float = bits_as::float32(&bits);
801 ///
802 /// assert_eq!(float, f32::from_bits(0x00543210));
803 /// ```
804 pub fn float32(bits: &Bits) -> f32 {
805 let bytes = bits.bytes();
806
807 match bytes.len() {
808 0 => 0.0,
809 1 => f32::from_bits(bytes[0] as u32),
810 2 => f32::from_bits(pack_to_int!(u32; bytes[0], bytes[1])),
811 3 => f32::from_bits(pack_to_int!(u32; bytes[0], bytes[1], bytes[2])),
812 _ => f32::from_bits(pack_to_int!(u32; bytes[0], bytes[1], bytes[2], bytes[3])),
813 }
814 }
815
816 /// Converts up to the first 64 bits of a bit string to a 64 bit float
817 ///
818 /// # Example
819 /// ```
820 /// # use bit_byte_bit::{bits_as, Bits};
821 /// let bits = Bits::new([0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE]);
822 /// let float = bits_as::float64(&bits);
823 ///
824 /// assert_eq!(float, f64::from_bits(0xFEDCBA9876543210));
825 ///
826 /// let bits = Bits::new([0x10, 0x32, 0x54]);
827 /// let float = bits_as::float64(&bits);
828 ///
829 /// assert_eq!(float, f64::from_bits(0x0000000000543210));
830 /// ```
831 pub fn float64(bits: &Bits) -> f64 {
832 let bytes = bits.bytes();
833
834 match bytes.len() {
835 0 => 0.0,
836 1 => f64::from_bits(bytes[0] as u64),
837 2 => f64::from_bits(pack_to_int!(u64; bytes[0], bytes[1])),
838 3 => f64::from_bits(pack_to_int!(u64; bytes[0], bytes[1], bytes[2])),
839 4 => f64::from_bits(pack_to_int!(u64; bytes[0], bytes[1], bytes[2], bytes[3])),
840 5 => f64::from_bits(pack_to_int!(u64; bytes[0], bytes[1], bytes[2], bytes[3], bytes[4])),
841 6 => f64::from_bits(pack_to_int!(u64;
842 bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5]
843 )),
844 7 => f64::from_bits(pack_to_int!(u64;
845 bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5], bytes[6]
846 )),
847 _ => f64::from_bits(pack_to_int!(u64;
848 bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5], bytes[6], bytes[7]
849 ))
850 }
851 }
852
853 /// Converts up to the first 8 bits of a bit string to 8 bit signed integer.
854 ///
855 /// If the length of the the bit string is less than 8, the result is sign-extended to 8 bits.
856 ///
857 /// # Example
858 /// ```
859 /// # use bit_byte_bit::{bits_as, Bits};
860 /// let bits = Bits::new([0xFE]);
861 /// let ibyte = bits_as::int8(&bits);
862 ///
863 /// assert_eq!(ibyte, 0xFEu8 as i8);
864 ///
865 /// let bits = Bits::from([0x5E]);
866 /// let ibyte = bits_as::int8(&bits);
867 ///
868 /// assert_eq!(ibyte, 0xDEu8 as i8);
869 /// ```
870 pub fn int8(bits: &Bits) -> i8 {
871 match bits.words.nbytes {
872 0 => 0,
873 1 => {
874 let byte = bits.words[0];
875
876 if bits.padding > 0 {
877 let overflow = 8 - bits.padding;
878
879 sign_extend!(byte, overflow) as i8
880 } else {
881 byte as i8
882 }
883 },
884 _ => bits.words[0] as i8
885 }
886 }
887
888 /// Converts up the first 16 bits of a bit string to a 16 bit signed integer.
889 ///
890 /// If the length of the the bit string is less than 16, the result is sign-extended to 16 bits.
891 ///
892 /// # Example
893 /// ```
894 /// # use bit_byte_bit::{bits_as, Bits};
895 /// let bits = Bits::new([0x10, 0xFE]);
896 /// let ishort = bits_as::int16(&bits);
897 ///
898 /// assert_eq!(ishort, 0xFE10u16 as i16);
899 ///
900 /// let bits = Bits::from([0x10, 0x5E]);
901 /// let ishort = bits_as::int16(&bits);
902 ///
903 /// assert_eq!(ishort, 0xDE10u16 as i16);
904 /// ```
905 pub fn int16(bits: &Bits) -> i16 {
906 let bytes = bits.bytes();
907 let overflow = 8 - bits.padding;
908
909 match bytes.len() {
910 0 => 0,
911 1 => {
912 let byte = bits.words[0] as u16;
913
914 sign_extend!(byte, overflow) as i16
915 },
916 2 if bits.padding > 0 => {
917 let bytes = pack_to_int!(u16; bytes[0], bytes[1]);
918
919 sign_extend!(bytes, overflow + 8) as i16
920 },
921 _ => pack_to_int!(u16; bytes[0], bytes[1]) as i16
922 }
923 }
924
925 /// Converts up to the first 32 bits of a bit string to a 32 bit signed integer.
926 ///
927 /// If the length of the the bit string is less than 32, the result is sign-extended to 32 bits.
928 ///
929 /// # Example
930 /// ```
931 /// # use bit_byte_bit::{bits_as, Bits};
932 /// let bits = Bits::new([0x10, 0x32, 0x54, 0x76]);
933 /// let int = bits_as::int32(&bits);
934 ///
935 /// assert_eq!(int, 0x76543210);
936 ///
937 /// let bits = Bits::from([0x10, 0x32, 0x54, 0x76]);
938 /// let int = bits_as::int32(&bits);
939 ///
940 /// assert_eq!(int, 0xF6543210u32 as i32);
941 /// ```
942 pub fn int32(bits: &Bits) -> i32 {
943 let bytes = bits.bytes();
944 let overflow = 8 - bits.padding;
945
946 match bytes.len() {
947 0 => 0,
948 1 => {
949 let byte = bits.words[0] as u32;
950
951 sign_extend!(byte, overflow) as i32
952 },
953 2 => {
954 let packed_bytes = pack_to_int!(u32; bytes[0], bytes[1]);
955
956 sign_extend!(packed_bytes, overflow + 8) as i32
957 }
958 3 => {
959 let packed_bytes = pack_to_int!(u32; bytes[0], bytes[1], bytes[2]);
960
961 sign_extend!(packed_bytes, overflow + 16) as i32
962 }
963 4 if bits.padding > 0 => {
964 let packed_bytes = pack_to_int!(u32; bytes[0], bytes[1], bytes[2], bytes[3]);
965
966 sign_extend!(packed_bytes, overflow + 24) as i32
967 }
968 _ => pack_to_int!(u32; bytes[0], bytes[1], bytes[2], bytes[3]) as i32,
969 }
970 }
971
972 /// Converts up to the first 64 bits of a bit string to a 64 bit signed integer.
973 ///
974 /// If the length of the the bit string is less than 64, the result is sign-extended to 64 bits.
975 ///
976 /// # Example
977 /// ```
978 /// # use bit_byte_bit::{bits_as, Bits};
979 /// let bits = Bits::new([0x10, 0x32, 0x54, 0x76]);
980 /// let long = bits_as::int64(&bits);
981 ///
982 /// assert_eq!(long, 0x0000000076543210);
983 ///
984 /// let bits = Bits::from([0x10, 0x32, 0x54, 0x76]);
985 /// let long = bits_as::int64(&bits);
986 ///
987 /// assert_eq!(long, 0xFFFFFFFFF6543210u64 as i64);
988 /// ```
989 pub fn int64(bits: &Bits) -> i64 {
990 let bytes = bits.bytes();
991 let overflow = 8 - bits.padding;
992
993 match bytes.len() {
994 0 => 0,
995 1 => {
996 let byte = bits.words[0] as u64;
997
998 sign_extend!(byte, overflow) as i64
999 },
1000 2 => {
1001 let packed_bytes = pack_to_int!(u64; bytes[0], bytes[1]);
1002
1003 sign_extend!(packed_bytes, overflow + 8) as i64
1004 },
1005 3 => {
1006 let packed_bytes = pack_to_int!(u64; bytes[0], bytes[1], bytes[2]);
1007
1008 sign_extend!(packed_bytes, overflow + 16) as i64
1009 },
1010 4 => {
1011 let packed_bytes = pack_to_int!(u64; bytes[0], bytes[1], bytes[2], bytes[3]);
1012
1013 sign_extend!(packed_bytes, overflow + 24) as i64
1014 },
1015 5 => {
1016 let packed_bytes = pack_to_int!(u64;
1017 bytes[0], bytes[1], bytes[2], bytes[3], bytes[4]
1018 );
1019
1020 sign_extend!(packed_bytes, overflow + 32) as i64
1021 },
1022 6 => {
1023 let packed_bytes = pack_to_int!(u64;
1024 bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5]
1025 );
1026
1027 sign_extend!(packed_bytes, overflow + 40) as i64
1028 },
1029 7 => {
1030 let packed_bytes = pack_to_int!(u64;
1031 bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5], bytes[6]
1032 );
1033
1034 sign_extend!(packed_bytes, overflow + 48) as i64
1035 },
1036 8 if bits.padding > 0 => {
1037 let packed_bytes = pack_to_int!(u64;
1038 bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5], bytes[6], bytes[7]
1039 );
1040
1041 sign_extend!(packed_bytes, overflow + 56) as i64
1042 },
1043 _ => pack_to_int!(u64;
1044 bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5], bytes[6], bytes[7]
1045 ) as i64
1046 }
1047 }
1048
1049 /// Converts up to the first 64 bits of a bit string to a signed integer.
1050 ///
1051 /// If the length of the the bit string is less than the length of `isize`, the result is
1052 /// sign-extended to 64 bits.
1053 ///
1054 /// # Example
1055 /// ```
1056 /// # use bit_byte_bit::{bits_as, Bits};
1057 /// let bits = Bits::new([0x10, 0x32, 0x54, 0x76]);
1058 /// let signed = bits_as::signed(&bits);
1059 ///
1060 /// assert_eq!(signed, 0x0000000076543210);
1061 ///
1062 /// let bits = Bits::from([0x10, 0x32, 0x54, 0x76]);
1063 /// let signed = bits_as::signed(&bits);
1064 ///
1065 /// assert_eq!(signed, 0xFFFFFFFFF6543210u64 as isize);
1066 /// ```
1067 pub fn signed(bits: &Bits) -> isize {
1068 let bytes = bits.bytes();
1069 let bytes_len = bytes.len();
1070 let packed_bytes = pack_bytes!(usize; bytes);
1071 let overflow = 8 - bits.padding;
1072
1073 if (isize::BITS == 32 && bytes_len < 4) || (isize::BITS == 64 && bytes_len < 8) {
1074 sign_extend!(packed_bytes, overflow + ((bytes_len - 1) << 3)) as isize
1075 } else {
1076 packed_bytes as isize
1077 }
1078 }
1079
1080 /// Converts up to the first 8 bits of a bit string to a 8 bit unsigned integer.
1081 ///
1082 /// # Example
1083 /// ```
1084 /// # use bit_byte_bit::{bits_as, Bits};
1085 /// let bits = Bits::new([0xFE]);
1086 /// let byte = bits_as::uint8(&bits);
1087 ///
1088 /// assert_eq!(byte, 0xFE);
1089 ///
1090 /// let bits = Bits::from([0x5E]);
1091 /// let byte = bits_as::uint8(&bits);
1092 ///
1093 /// assert_eq!(byte, 0x5E);
1094 /// ```
1095 pub fn uint8(bits: &Bits) -> u8 { *bits.bytes().first().unwrap_or(&0) }
1096
1097 /// Converts up the first 16 bits of a bit string to a 16 bit unsigned integer.
1098 ///
1099 /// # Example
1100 /// ```
1101 /// # use bit_byte_bit::{bits_as, Bits};
1102 /// let bits = Bits::new([0x10, 0xFE]);
1103 /// let ushort = bits_as::uint16(&bits);
1104 ///
1105 /// assert_eq!(ushort, 0xFE10);
1106 ///
1107 /// let bits = Bits::from([0x10, 0x5E]);
1108 /// let ushort = bits_as::uint16(&bits);
1109 ///
1110 /// assert_eq!(ushort, 0x5E10);
1111 /// ```
1112 pub fn uint16(bits: &Bits) -> u16 {
1113 let bytes = bits.bytes();
1114
1115 match bytes.len() {
1116 0 => 0,
1117 1 => bytes[0] as u16,
1118 _ => pack_to_int!(u16; bytes[0], bytes[1])
1119 }
1120 }
1121
1122 /// Converts up to the first 32 bits of a bit string to a 32 bit unsigned integer.
1123 ///
1124 /// # Example
1125 /// ```
1126 /// # use bit_byte_bit::{bits_as, Bits};
1127 /// let bits = Bits::new([0x10, 0x32, 0x54, 0x76]);
1128 /// let uint = bits_as::uint32(&bits);
1129 ///
1130 /// assert_eq!(uint, 0x76543210);
1131 ///
1132 /// let bits = Bits::from([0x10, 0x32, 0x54, 0x76]);
1133 /// let uint = bits_as::uint32(&bits);
1134 ///
1135 /// assert_eq!(uint, 0x76543210);
1136 /// ```
1137 pub fn uint32(bits: &Bits) -> u32 {
1138 let bytes = bits.bytes();
1139
1140 match bytes.len() {
1141 0 => 0,
1142 1 => bytes[0] as u32,
1143 2 => pack_to_int!(u32; bytes[0], bytes[1]),
1144 3 => pack_to_int!(u32; bytes[0], bytes[1], bytes[2]),
1145 _ => pack_to_int!(u32; bytes[0], bytes[1], bytes[2], bytes[3]),
1146 }
1147 }
1148
1149 /// Converts up to the first 64 bits of a bit string to a 64 bit unsigned integer.
1150 ///
1151 /// # Example
1152 /// ```
1153 /// # use bit_byte_bit::{bits_as, Bits};
1154 /// let bits = Bits::new([0x10, 0x32, 0x54, 0x76]);
1155 /// let ulong = bits_as::uint64(&bits);
1156 ///
1157 /// assert_eq!(ulong, 0x0000000076543210);
1158 ///
1159 /// let bits = Bits::from([0x10, 0x32, 0x54, 0x76]);
1160 /// let ulong = bits_as::uint64(&bits);
1161 ///
1162 /// assert_eq!(ulong, 0x0000000076543210);
1163 /// ```
1164 pub fn uint64(bits: &Bits) -> u64 {
1165 let bytes = bits.bytes();
1166
1167 match bytes.len() {
1168 0 => 0,
1169 1 => bytes[0] as u64,
1170 2 => pack_to_int!(u64; bytes[0], bytes[1]),
1171 3 => pack_to_int!(u64; bytes[0], bytes[1], bytes[2]),
1172 4 => pack_to_int!(u64; bytes[0], bytes[1], bytes[2], bytes[3]),
1173 5 => pack_to_int!(u64; bytes[0], bytes[1], bytes[2], bytes[3], bytes[4]),
1174 6 => pack_to_int!(u64; bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5]),
1175 7 => pack_to_int!(u64;
1176 bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5], bytes[6]
1177 ),
1178 _ => pack_to_int!(u64;
1179 bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5], bytes[6], bytes[7]
1180 )
1181 }
1182 }
1183
1184 /// Converts up to the first 64 bits of a bit string to an unsigned integer.
1185 ///
1186 /// # Example
1187 /// ```
1188 /// # use bit_byte_bit::{bits_as, Bits};
1189 /// let bits = Bits::new([0x10, 0x32, 0x54, 0x76]);
1190 /// let unsigned = bits_as::unsigned(&bits);
1191 ///
1192 /// assert_eq!(unsigned, 0x0000000076543210);
1193 ///
1194 /// let bits = Bits::from([0x10, 0x32, 0x54, 0x76]);
1195 /// let unsigned = bits_as::unsigned(&bits);
1196 ///
1197 /// assert_eq!(unsigned, 0x0000000076543210);
1198 /// ```
1199 pub fn unsigned(bits: &Bits) -> usize {
1200 let bytes = bits.bytes();
1201
1202 pack_bytes!(usize; bytes)
1203 }
1204}
1205
1206impl From<Bits> for Vec<bool> {
1207 /// Converts a bit string to a vector of booleans
1208 ///
1209 /// # Example
1210 /// ```
1211 /// # use bit_byte_bit::Bits;
1212 /// let bits = Bits::new([0x10, 0x32]);
1213 /// let bools = Vec::<bool>::from(bits);
1214 ///
1215 /// assert_eq!(bools.len(), 16);
1216 ///
1217 /// assert_eq!(
1218 /// bools,
1219 /// vec![
1220 /// false, false, false, false, true, false, false, false,
1221 /// false, true, false, false, true, true, false, false
1222 /// ]
1223 /// );
1224 /// ```
1225 fn from(bits: Bits) -> Self { bits_as::vec_bool(&bits) }
1226}
1227
1228impl From<Bits> for Vec<f32> {
1229 /// Converts a bit string to a vector of 32 bit floats
1230 ///
1231 /// # Example
1232 /// ```
1233 /// # use bit_byte_bit::Bits;
1234 /// let bits = Bits::new([0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE]);
1235 /// let floats = Vec::<f32>::from(bits);
1236 ///
1237 /// assert_eq!(floats.len(), 2);
1238 /// assert_eq!(floats, vec![f32::from_bits(0x76543210), f32::from_bits(0xFEDCBA98)]);
1239 ///
1240 /// let bits = Bits::new([0x10, 0x32, 0x54]);
1241 /// let floats = Vec::<f32>::from(bits);
1242 ///
1243 /// assert_eq!(floats.len(), 1);
1244 /// assert_eq!(floats, vec![f32::from_bits(0x00543210)]);
1245 /// ```
1246 fn from(bits: Bits) -> Self { bits_as::vec_f32(&bits) }
1247}
1248
1249impl From<Bits> for Vec<f64> {
1250 /// Converts a bit string to a vector of 64 bit floats
1251 ///
1252 /// # Example
1253 /// ```
1254 /// # use bit_byte_bit::Bits;
1255 /// let bits = Bits::new([0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE]);
1256 /// let floats = Vec::<f64>::from(bits);
1257 ///
1258 /// assert_eq!(floats.len(), 1);
1259 /// assert_eq!(floats, vec![f64::from_bits(0xFEDCBA9876543210)]);
1260 ///
1261 /// let bits = Bits::new([0x10, 0x32, 0x54]);
1262 /// let floats = Vec::<f64>::from(bits);
1263 ///
1264 /// assert_eq!(floats.len(), 1);
1265 /// assert_eq!(floats, vec![f64::from_bits(0x0000000000543210)]);
1266 /// ```
1267 fn from(bits: Bits) -> Self { bits_as::vec_f64(&bits) }
1268}
1269
1270impl From<Bits> for Vec<i8> {
1271 /// Converts a bit string to a vector of 8 bit signed integers.
1272 ///
1273 /// If the length of the the bit string is not divisible by 8, it is
1274 /// sign-extended to the next length that is, then it is converted.
1275 ///
1276 /// # Example
1277 /// ```
1278 /// # use bit_byte_bit::Bits;
1279 /// let bits = Bits::new([0x10, 0xFE]);
1280 /// let ibytes = Vec::<i8>::from(bits);
1281 ///
1282 /// assert_eq!(ibytes.len(), 2);
1283 /// assert_eq!(ibytes, vec![0x10, 0xFEu8 as i8]);
1284 ///
1285 /// let bits = Bits::from([0x10, 0x5E]);
1286 /// let ibytes = Vec::<i8>::from(bits);
1287 ///
1288 /// assert_eq!(ibytes.len(), 2);
1289 /// assert_eq!(ibytes, vec![0x10, 0xDEu8 as i8]);
1290 /// ```
1291 fn from(bits: Bits) -> Self { bits_as::vec_i8(&bits) }
1292}
1293
1294impl From<Bits> for Vec<i16> {
1295 /// Converts a bit string to a vector of 16 bit signed integers.
1296 ///
1297 /// If the length of the the bit string is not divisible by 16, it is
1298 /// sign-extended to the next length that is, then it is converted.
1299 ///
1300 /// # Example
1301 /// ```
1302 /// # use bit_byte_bit::Bits;
1303 /// let bits = Bits::new([0x10, 0xFE]);
1304 /// let ishorts = Vec::<i16>::from(bits);
1305 ///
1306 /// assert_eq!(ishorts.len(), 1);
1307 /// assert_eq!(ishorts, vec![0xFE10u16 as i16]);
1308 ///
1309 /// let bits = Bits::from([0x10, 0x5E]);
1310 /// let ishorts = Vec::<i16>::from(bits);
1311 ///
1312 /// assert_eq!(ishorts.len(), 1);
1313 /// assert_eq!(ishorts, vec![0xDE10u16 as i16]);
1314 /// ```
1315 fn from(bits: Bits) -> Self { bits_as::vec_i16(&bits) }
1316}
1317
1318impl From<Bits> for Vec<i32> {
1319 /// Converts a bit string to a vector of 32 bit signed integers.
1320 ///
1321 /// If the length of the the bit string is not divisible by 32, it is
1322 /// sign-extended to the next length that is, then it is converted.
1323 ///
1324 /// # Example
1325 /// ```
1326 /// # use bit_byte_bit::Bits;
1327 /// let bits = Bits::new([0x10, 0x32, 0x54, 0x76]);
1328 /// let ints = Vec::<i32>::from(bits);
1329 ///
1330 /// assert_eq!(ints.len(), 1);
1331 /// assert_eq!(ints, vec![0x76543210]);
1332 ///
1333 /// let bits = Bits::from([0x10, 0x32, 0x54, 0x76]);
1334 /// let ints = Vec::<i32>::from(bits);
1335 ///
1336 /// assert_eq!(ints.len(), 1);
1337 /// assert_eq!(ints, vec![0xF6543210u32 as i32]);
1338 /// ```
1339 fn from(bits: Bits) -> Self { bits_as::vec_i32(&bits) }
1340}
1341
1342impl From<Bits> for Vec<i64> {
1343 /// Converts a bit string to a vector of 64 bit signed integers.
1344 ///
1345 /// If the length of the the bit string is not divisible by 64, it is
1346 /// sign-extended to the next length that is, then it is converted.
1347 ///
1348 /// # Example
1349 /// ```
1350 /// # use bit_byte_bit::Bits;
1351 /// let bits = Bits::new([0x10, 0x32, 0x54, 0x76]);
1352 /// let longs = Vec::<i64>::from(bits);
1353 ///
1354 /// assert_eq!(longs.len(), 1);
1355 /// assert_eq!(longs, vec![0x0000000076543210]);
1356 ///
1357 /// let bits = Bits::from([0x10, 0x32, 0x54, 0x76]);
1358 /// let longs = Vec::<i64>::from(bits);
1359 ///
1360 /// assert_eq!(longs.len(), 1);
1361 /// assert_eq!(longs, vec![0xFFFFFFFFF6543210u64 as i64]);
1362 /// ```
1363 fn from(bits: Bits) -> Self { bits_as::vec_i64(&bits) }
1364}
1365
1366impl From<Bits> for Vec<isize> {
1367 /// Converts a bit string to a vector of signed integers.
1368 ///
1369 /// If the length of the the bit string is not divisible by the length of `isize`, it is
1370 /// sign-extended to the next length that is, then it is converted.
1371 ///
1372 /// # Example
1373 /// ```
1374 /// # use bit_byte_bit::Bits;
1375 /// let bits = Bits::new([0x10, 0x32, 0x54, 0x76]);
1376 /// let signed_ints = Vec::<isize>::from(bits);
1377 ///
1378 /// assert_eq!(signed_ints.len(), 1);
1379 /// assert_eq!(signed_ints, vec![0x0000000076543210]);
1380 ///
1381 /// let bits = Bits::from([0x10, 0x32, 0x54, 0x76]);
1382 /// let signed_ints = Vec::<isize>::from(bits);
1383 ///
1384 /// assert_eq!(signed_ints.len(), 1);
1385 /// assert_eq!(signed_ints, vec![0xFFFFFFFFF6543210u64 as isize]);
1386 /// ```
1387 fn from(bits: Bits) -> Self { bits_as::vec_isize(&bits) }
1388}
1389
1390impl From<Bits> for Vec<u8> {
1391 /// Converts a bit string to a vector of 8 bit unsigned integers.
1392 ///
1393 /// # Example
1394 /// ```
1395 /// # use bit_byte_bit::Bits;
1396 /// let bits = Bits::new([0x10, 0xFE]);
1397 /// let bytes = Vec::<u8>::from(bits);
1398 ///
1399 /// assert_eq!(bytes.len(), 2);
1400 /// assert_eq!(bytes, vec![0x10, 0xFE]);
1401 ///
1402 /// let bits = Bits::from([0x10, 0x5E]);
1403 /// let bytes = Vec::<u8>::from(bits);
1404 ///
1405 /// assert_eq!(bytes.len(), 2);
1406 /// assert_eq!(bytes, vec![0x10, 0x5E]);
1407 /// ```
1408 fn from(bits: Bits) -> Self { bits.into_bytes().collect() }
1409}
1410
1411impl From<Bits> for Vec<u16> {
1412 /// Converts a bit string to a vector of 16 bit unsigned integers.
1413 ///
1414 /// # Example
1415 /// ```
1416 /// # use bit_byte_bit::Bits;
1417 /// let bits = Bits::new([0x10, 0xFE]);
1418 /// let shorts = Vec::<u16>::from(bits);
1419 ///
1420 /// assert_eq!(shorts.len(), 1);
1421 /// assert_eq!(shorts, vec![0xFE10]);
1422 ///
1423 /// let bits = Bits::from([0x10, 0x5E]);
1424 /// let shorts = Vec::<u16>::from(bits);
1425 ///
1426 /// assert_eq!(shorts.len(), 1);
1427 /// assert_eq!(shorts, vec![0x5E10])
1428 /// ```
1429 fn from(bits: Bits) -> Self { bits_as::vec_u16(&bits) }
1430}
1431
1432impl From<Bits> for Vec<u32> {
1433 /// Converts a bit string to a vector of 32 bit unsigned integers.
1434 ///
1435 /// # Example
1436 /// ```
1437 /// # use bit_byte_bit::Bits;
1438 /// let bits = Bits::new([0x10, 0x32, 0x54, 0x76]);
1439 /// let uints = Vec::<u32>::from(bits);
1440 ///
1441 /// assert_eq!(uints.len(), 1);
1442 /// assert_eq!(uints, vec![0x76543210]);
1443 ///
1444 /// let bits = Bits::from([0x10, 0x32, 0x54, 0x76]);
1445 /// let uints = Vec::<u32>::from(bits);
1446 ///
1447 /// assert_eq!(uints.len(), 1);
1448 /// assert_eq!(uints, vec![0x76543210]);
1449 /// ```
1450 fn from(bits: Bits) -> Self { bits_as::vec_u32(&bits) }
1451}
1452
1453impl From<Bits> for Vec<u64> {
1454 /// Converts a bit string to a vector of 64 bit unsigned integers.
1455 ///
1456 /// # Example
1457 /// ```
1458 /// # use bit_byte_bit::Bits;
1459 /// let bits = Bits::new([0x10, 0x32, 0x54, 0x76]);
1460 /// let ulongs = Vec::<u64>::from(bits);
1461 ///
1462 /// assert_eq!(ulongs.len(), 1);
1463 /// assert_eq!(ulongs, vec![0x0000000076543210]);
1464 ///
1465 /// let bits = Bits::from([0x10, 0x32, 0x54, 0x76]);
1466 /// let ulongs = Vec::<u64>::from(bits);
1467 ///
1468 /// assert_eq!(ulongs.len(), 1);
1469 /// assert_eq!(ulongs, vec![0x0000000076543210]);
1470 /// ```
1471 fn from(bits: Bits) -> Self { bits_as::vec_u64(&bits) }
1472}
1473
1474impl From<Bits> for Vec<usize> {
1475 /// Converts a bit string to a vector of unsigned integers.
1476 ///
1477 /// # Example
1478 /// ```
1479 /// # use bit_byte_bit::Bits;
1480 /// let bits = Bits::new([0x10, 0x32, 0x54, 0x76]);
1481 /// let unsigned_ints = Vec::<u64>::from(bits);
1482 ///
1483 /// assert_eq!(unsigned_ints.len(), 1);
1484 /// assert_eq!(unsigned_ints, vec![0x0000000076543210]);
1485 ///
1486 /// let bits = Bits::from([0x10, 0x32, 0x54, 0x76]);
1487 /// let unsigned_ints = Vec::<u64>::from(bits);
1488 ///
1489 /// assert_eq!(unsigned_ints.len(), 1);
1490 /// assert_eq!(unsigned_ints, vec![0x0000000076543210]);
1491 /// ```
1492 fn from(bits: Bits) -> Self { bits_as::vec_usize(&bits) }
1493}
1494
1495impl From<Bits> for f32 {
1496 /// Converts up to the first 32 bits of a bit string to a 32 bit float
1497 ///
1498 /// # Example
1499 /// ```
1500 /// # use bit_byte_bit::Bits;
1501 /// let bits = Bits::new([0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE]);
1502 /// let float = f32::from(bits);
1503 ///
1504 /// assert_eq!(float, f32::from_bits(0x76543210));
1505 ///
1506 /// let bits = Bits::new([0x10, 0x32, 0x54]);
1507 /// let float = f32::from(bits);
1508 ///
1509 /// assert_eq!(float, f32::from_bits(0x00543210));
1510 /// ```
1511 fn from(bits: Bits) -> Self { bits_as::float32(&bits) }
1512}
1513
1514impl From<Bits> for f64 {
1515 /// Converts up to the first 64 bits of a bit string to a 64 bit float
1516 ///
1517 /// # Example
1518 /// ```
1519 /// # use bit_byte_bit::Bits;
1520 /// let bits = Bits::new([0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE]);
1521 /// let float = f64::from(bits);
1522 ///
1523 /// assert_eq!(float, f64::from_bits(0xFEDCBA9876543210));
1524 ///
1525 /// let bits = Bits::new([0x10, 0x32, 0x54]);
1526 /// let float = f64::from(bits);
1527 ///
1528 /// assert_eq!(float, f64::from_bits(0x0000000000543210));
1529 /// ```
1530 fn from(bits: Bits) -> Self { bits_as::float64(&bits) }
1531}
1532
1533impl From<Bits> for i8 {
1534 /// Converts up to the first 8 bits of a bit string to 8 bit signed integer.
1535 ///
1536 /// If the length of the the bit string is less than 8, the result is sign-extended to 8 bits.
1537 ///
1538 /// # Example
1539 /// ```
1540 /// # use bit_byte_bit::Bits;
1541 /// let bits = Bits::new([0xFE]);
1542 /// let ibyte = i8::from(bits);
1543 ///
1544 /// assert_eq!(ibyte, 0xFEu8 as i8);
1545 ///
1546 /// let bits = Bits::from([0x5E]);
1547 /// let ibyte = i8::from(bits);
1548 ///
1549 /// assert_eq!(ibyte, 0xDEu8 as i8);
1550 /// ```
1551 fn from(bits: Bits) -> Self { bits_as::int8(&bits) }
1552}
1553
1554impl From<Bits> for i16 {
1555 /// Converts up the first 16 bits of a bit string to a 16 bit signed integer.
1556 ///
1557 /// If the length of the the bit string is less than 16, the result is sign-extended to 16 bits.
1558 ///
1559 /// # Example
1560 /// ```
1561 /// # use bit_byte_bit::Bits;
1562 /// let bits = Bits::new([0x10, 0xFE]);
1563 /// let ishort = i16::from(bits);
1564 ///
1565 /// assert_eq!(ishort, 0xFE10u16 as i16);
1566 ///
1567 /// let bits = Bits::from([0x10, 0x5E]);
1568 /// let ishort = i16::from(bits);
1569 ///
1570 /// assert_eq!(ishort, 0xDE10u16 as i16);
1571 /// ```
1572 fn from(bits: Bits) -> Self { bits_as::int16(&bits) }
1573}
1574
1575impl From<Bits> for i32 {
1576 /// Converts up to the first 32 bits of a bit string to a 32 bit signed integer.
1577 ///
1578 /// If the length of the the bit string is less than 32, the result is sign-extended to 32 bits.
1579 ///
1580 /// # Example
1581 /// ```
1582 /// # use bit_byte_bit::Bits;
1583 /// let bits = Bits::new([0x10, 0x32, 0x54, 0x76]);
1584 /// let int = i32::from(bits);
1585 ///
1586 /// assert_eq!(int, 0x76543210);
1587 ///
1588 /// let bits = Bits::from([0x10, 0x32, 0x54, 0x76]);
1589 /// let int = i32::from(bits);
1590 ///
1591 /// assert_eq!(int, 0xF6543210u32 as i32);
1592 /// ```
1593 fn from(bits: Bits) -> Self { bits_as::int32(&bits) }
1594}
1595
1596impl From<Bits> for i64 {
1597 /// Converts up to the first 64 bits of a bit string to a 64 bit signed integer.
1598 ///
1599 /// If the length of the the bit string is less than 64, the result is sign-extended to 64 bits.
1600 ///
1601 /// # Example
1602 /// ```
1603 /// # use bit_byte_bit::Bits;
1604 /// let bits = Bits::new([0x10, 0x32, 0x54, 0x76]);
1605 /// let long = i64::from(bits);
1606 ///
1607 /// assert_eq!(long, 0x0000000076543210);
1608 ///
1609 /// let bits = Bits::from([0x10, 0x32, 0x54, 0x76]);
1610 /// let long = i64::from(bits);
1611 ///
1612 /// assert_eq!(long, 0xFFFFFFFFF6543210u64 as i64);
1613 /// ```
1614 fn from(bits: Bits) -> Self { bits_as::int64(&bits) }
1615}
1616
1617impl From<Bits> for isize {
1618 /// Converts up to the first 64 bits of a bit string to a 64 bit signed integer.
1619 ///
1620 /// If the length of the the bit string is less than the length of `isize`, the result is
1621 /// sign-extended to 64 bits.
1622 ///
1623 /// # Example
1624 /// ```
1625 /// # use bit_byte_bit::Bits;
1626 /// let bits = Bits::new([0x10, 0x32, 0x54, 0x76]);
1627 /// let signed = isize::from(bits);
1628 ///
1629 /// assert_eq!(signed, 0x0000000076543210);
1630 ///
1631 /// let bits = Bits::from([0x10, 0x32, 0x54, 0x76]);
1632 /// let signed = isize::from(bits);
1633 ///
1634 /// assert_eq!(signed, 0xFFFFFFFFF6543210u64 as isize);
1635 /// ```
1636 fn from(bits: Bits) -> Self { bits_as::signed(&bits) }
1637}
1638
1639impl From<Bits> for u8 {
1640 /// Converts up to the first 8 bits of a bit string to a 8 bit unsigned integer.
1641 ///
1642 /// # Example
1643 /// ```
1644 /// # use bit_byte_bit::Bits;
1645 /// let bits = Bits::new([0xFE]);
1646 /// let byte = u8::from(bits);
1647 ///
1648 /// assert_eq!(byte, 0xFE);
1649 ///
1650 /// let bits = Bits::from([0x5E]);
1651 /// let byte = u8::from(bits);
1652 ///
1653 /// assert_eq!(byte, 0x5E);
1654 /// ```
1655 fn from(bits: Bits) -> Self { bits.into_bytes().next().unwrap_or(0) }
1656}
1657
1658impl From<Bits> for u16 {
1659 /// Converts up the first 16 bits of a bit string to a 16 bit unsigned integer.
1660 ///
1661 /// # Example
1662 /// ```
1663 /// # use bit_byte_bit::Bits;
1664 /// let bits = Bits::new([0x10, 0xFE]);
1665 /// let ushort = u16::from(bits);
1666 ///
1667 /// assert_eq!(ushort, 0xFE10);
1668 ///
1669 /// let bits = Bits::from([0x10, 0x5E]);
1670 /// let ushort = u16::from(bits);
1671 ///
1672 /// assert_eq!(ushort, 0x5E10);
1673 /// ```
1674 fn from(bits: Bits) -> Self { bits_as::uint16(&bits) }
1675}
1676
1677impl From<Bits> for u32 {
1678 /// Converts up to the first 32 bits of a bit string to a 32 bit unsigned integer.
1679 ///
1680 /// # Example
1681 /// ```
1682 /// # use bit_byte_bit::Bits;
1683 /// let bits = Bits::new([0x10, 0x32, 0x54, 0x76]);
1684 /// let uint = u32::from(bits);
1685 ///
1686 /// assert_eq!(uint, 0x76543210);
1687 ///
1688 /// let bits = Bits::from([0x10, 0x32, 0x54, 0x76]);
1689 /// let uint = u32::from(bits);
1690 ///
1691 /// assert_eq!(uint, 0x76543210);
1692 /// ```
1693 fn from(bits: Bits) -> Self { bits_as::uint32(&bits) }
1694}
1695
1696impl From<Bits> for u64 {
1697 /// Converts up to the first 64 bits of a bit string to a 64 bit unsigned integer.
1698 ///
1699 /// # Example
1700 /// ```
1701 /// # use bit_byte_bit::Bits;
1702 /// let bits = Bits::new([0x10, 0x32, 0x54, 0x76]);
1703 /// let ulong = u64::from(bits);
1704 ///
1705 /// assert_eq!(ulong, 0x0000000076543210);
1706 ///
1707 /// let bits = Bits::from([0x10, 0x32, 0x54, 0x76]);
1708 /// let ulong = u64::from(bits);
1709 ///
1710 /// assert_eq!(ulong, 0x0000000076543210);
1711 /// ```
1712 fn from(bits: Bits) -> Self { bits_as::uint64(&bits) }
1713}
1714
1715impl From<Bits> for usize {
1716 /// Converts up to the first 64 bits of a bit string to an unsigned integer.
1717 ///
1718 /// # Example
1719 /// ```
1720 /// # use bit_byte_bit::Bits;
1721 /// let bits = Bits::new([0x10, 0x32, 0x54, 0x76]);
1722 /// let unsigned = usize::from(bits);
1723 ///
1724 /// assert_eq!(unsigned, 0x0000000076543210);
1725 ///
1726 /// let bits = Bits::from([0x10, 0x32, 0x54, 0x76]);
1727 /// let unsigned = usize::from(bits);
1728 ///
1729 /// assert_eq!(unsigned, 0x0000000076543210);
1730 /// ```
1731 fn from(bits: Bits) -> Self { bits_as::unsigned(&bits) }
1732}