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