1 /*!
2 This crate provides convenience methods for encoding and decoding numbers in
3 either [big-endian or little-endian order].
4
5 The organization of the crate is pretty simple. A trait, [`ByteOrder`], specifies
6 byte conversion methods for each type of number in Rust (sans numbers that have
7 a platform dependent size like `usize` and `isize`). Two types, [`BigEndian`]
8 and [`LittleEndian`] implement these methods. Finally, [`ReadBytesExt`] and
9 [`WriteBytesExt`] provide convenience methods available to all types that
10 implement [`Read`] and [`Write`].
11
12 An alias, [`NetworkEndian`], for [`BigEndian`] is provided to help improve
13 code clarity.
14
15 An additional alias, [`NativeEndian`], is provided for the endianness of the
16 local platform. This is convenient when serializing data for use and
17 conversions are not desired.
18
19 # Examples
20
21 Read unsigned 16 bit big-endian integers from a [`Read`] type:
22
23 ```rust
24 use std::io::Cursor;
25 use byteorder::{BigEndian, ReadBytesExt};
26
27 let mut rdr = Cursor::new(vec![2, 5, 3, 0]);
28 // Note that we use type parameters to indicate which kind of byte order
29 // we want!
30 assert_eq!(517, rdr.read_u16::<BigEndian>().unwrap());
31 assert_eq!(768, rdr.read_u16::<BigEndian>().unwrap());
32 ```
33
34 Write unsigned 16 bit little-endian integers to a [`Write`] type:
35
36 ```rust
37 use byteorder::{LittleEndian, WriteBytesExt};
38
39 let mut wtr = vec![];
40 wtr.write_u16::<LittleEndian>(517).unwrap();
41 wtr.write_u16::<LittleEndian>(768).unwrap();
42 assert_eq!(wtr, vec![5, 2, 0, 3]);
43 ```
44
45 # Optional Features
46
47 This crate optionally provides support for 128 bit values (`i128` and `u128`)
48 when built with the `i128` feature enabled.
49
50 This crate can also be used without the standard library.
51
52 # Alternatives
53
54 Note that as of Rust 1.32, the standard numeric types provide built-in methods
55 like `to_le_bytes` and `from_le_bytes`, which support some of the same use
56 cases.
57
58 [big-endian or little-endian order]: https://en.wikipedia.org/wiki/Endianness
59 [`ByteOrder`]: trait.ByteOrder.html
60 [`BigEndian`]: enum.BigEndian.html
61 [`LittleEndian`]: enum.LittleEndian.html
62 [`ReadBytesExt`]: trait.ReadBytesExt.html
63 [`WriteBytesExt`]: trait.WriteBytesExt.html
64 [`NetworkEndian`]: type.NetworkEndian.html
65 [`NativeEndian`]: type.NativeEndian.html
66 [`Read`]: https://doc.rust-lang.org/std/io/trait.Read.html
67 [`Write`]: https://doc.rust-lang.org/std/io/trait.Write.html
68 */
69
70 #![deny(missing_docs)]
71 #![cfg_attr(not(feature = "std"), no_std)]
72 // When testing under miri, we disable tests that take too long. But this
73 // provokes lots of dead code warnings. So we just squash them.
74 #![cfg_attr(miri, allow(dead_code, unused_macros))]
75
76 use core::{
77 convert::TryInto, fmt::Debug, hash::Hash, mem::align_of,
78 ptr::copy_nonoverlapping, slice,
79 };
80
81 #[cfg(feature = "std")]
82 pub use crate::io::{ReadBytesExt, WriteBytesExt};
83
84 #[cfg(feature = "std")]
85 mod io;
86
87 #[inline]
extend_sign(val: u64, nbytes: usize) -> i6488 fn extend_sign(val: u64, nbytes: usize) -> i64 {
89 let shift = (8 - nbytes) * 8;
90 (val << shift) as i64 >> shift
91 }
92
93 #[inline]
extend_sign128(val: u128, nbytes: usize) -> i12894 fn extend_sign128(val: u128, nbytes: usize) -> i128 {
95 let shift = (16 - nbytes) * 8;
96 (val << shift) as i128 >> shift
97 }
98
99 #[inline]
unextend_sign(val: i64, nbytes: usize) -> u64100 fn unextend_sign(val: i64, nbytes: usize) -> u64 {
101 let shift = (8 - nbytes) * 8;
102 (val << shift) as u64 >> shift
103 }
104
105 #[inline]
unextend_sign128(val: i128, nbytes: usize) -> u128106 fn unextend_sign128(val: i128, nbytes: usize) -> u128 {
107 let shift = (16 - nbytes) * 8;
108 (val << shift) as u128 >> shift
109 }
110
111 #[inline]
pack_size(n: u64) -> usize112 fn pack_size(n: u64) -> usize {
113 if n < 1 << 8 {
114 1
115 } else if n < 1 << 16 {
116 2
117 } else if n < 1 << 24 {
118 3
119 } else if n < 1 << 32 {
120 4
121 } else if n < 1 << 40 {
122 5
123 } else if n < 1 << 48 {
124 6
125 } else if n < 1 << 56 {
126 7
127 } else {
128 8
129 }
130 }
131
132 #[inline]
pack_size128(n: u128) -> usize133 fn pack_size128(n: u128) -> usize {
134 if n < 1 << 8 {
135 1
136 } else if n < 1 << 16 {
137 2
138 } else if n < 1 << 24 {
139 3
140 } else if n < 1 << 32 {
141 4
142 } else if n < 1 << 40 {
143 5
144 } else if n < 1 << 48 {
145 6
146 } else if n < 1 << 56 {
147 7
148 } else if n < 1 << 64 {
149 8
150 } else if n < 1 << 72 {
151 9
152 } else if n < 1 << 80 {
153 10
154 } else if n < 1 << 88 {
155 11
156 } else if n < 1 << 96 {
157 12
158 } else if n < 1 << 104 {
159 13
160 } else if n < 1 << 112 {
161 14
162 } else if n < 1 << 120 {
163 15
164 } else {
165 16
166 }
167 }
168
169 mod private {
170 /// Sealed stops crates other than byteorder from implementing any traits
171 /// that use it.
172 pub trait Sealed {}
173 impl Sealed for super::LittleEndian {}
174 impl Sealed for super::BigEndian {}
175 }
176
177 /// `ByteOrder` describes types that can serialize integers as bytes.
178 ///
179 /// Note that `Self` does not appear anywhere in this trait's definition!
180 /// Therefore, in order to use it, you'll need to use syntax like
181 /// `T::read_u16(&[0, 1])` where `T` implements `ByteOrder`.
182 ///
183 /// This crate provides two types that implement `ByteOrder`: [`BigEndian`]
184 /// and [`LittleEndian`].
185 /// This trait is sealed and cannot be implemented for callers to avoid
186 /// breaking backwards compatibility when adding new derived traits.
187 ///
188 /// # Examples
189 ///
190 /// Write and read `u32` numbers in little endian order:
191 ///
192 /// ```rust
193 /// use byteorder::{ByteOrder, LittleEndian};
194 ///
195 /// let mut buf = [0; 4];
196 /// LittleEndian::write_u32(&mut buf, 1_000_000);
197 /// assert_eq!(1_000_000, LittleEndian::read_u32(&buf));
198 /// ```
199 ///
200 /// Write and read `i16` numbers in big endian order:
201 ///
202 /// ```rust
203 /// use byteorder::{ByteOrder, BigEndian};
204 ///
205 /// let mut buf = [0; 2];
206 /// BigEndian::write_i16(&mut buf, -5_000);
207 /// assert_eq!(-5_000, BigEndian::read_i16(&buf));
208 /// ```
209 ///
210 /// [`BigEndian`]: enum.BigEndian.html
211 /// [`LittleEndian`]: enum.LittleEndian.html
212 pub trait ByteOrder:
213 Clone
214 + Copy
215 + Debug
216 + Default
217 + Eq
218 + Hash
219 + Ord
220 + PartialEq
221 + PartialOrd
222 + private::Sealed
223 {
224 /// Reads an unsigned 16 bit integer from `buf`.
225 ///
226 /// # Panics
227 ///
228 /// Panics when `buf.len() < 2`.
read_u16(buf: &[u8]) -> u16229 fn read_u16(buf: &[u8]) -> u16;
230
231 /// Reads an unsigned 24 bit integer from `buf`, stored in u32.
232 ///
233 /// # Panics
234 ///
235 /// Panics when `buf.len() < 3`.
236 ///
237 /// # Examples
238 ///
239 /// Write and read 24 bit `u32` numbers in little endian order:
240 ///
241 /// ```rust
242 /// use byteorder::{ByteOrder, LittleEndian};
243 ///
244 /// let mut buf = [0; 3];
245 /// LittleEndian::write_u24(&mut buf, 1_000_000);
246 /// assert_eq!(1_000_000, LittleEndian::read_u24(&buf));
247 /// ```
read_u24(buf: &[u8]) -> u32248 fn read_u24(buf: &[u8]) -> u32 {
249 Self::read_uint(buf, 3) as u32
250 }
251
252 /// Reads an unsigned 32 bit integer from `buf`.
253 ///
254 /// # Panics
255 ///
256 /// Panics when `buf.len() < 4`.
257 ///
258 /// # Examples
259 ///
260 /// Write and read `u32` numbers in little endian order:
261 ///
262 /// ```rust
263 /// use byteorder::{ByteOrder, LittleEndian};
264 ///
265 /// let mut buf = [0; 4];
266 /// LittleEndian::write_u32(&mut buf, 1_000_000);
267 /// assert_eq!(1_000_000, LittleEndian::read_u32(&buf));
268 /// ```
read_u32(buf: &[u8]) -> u32269 fn read_u32(buf: &[u8]) -> u32;
270
271 /// Reads an unsigned 48 bit integer from `buf`, stored in u64.
272 ///
273 /// # Panics
274 ///
275 /// Panics when `buf.len() < 6`.
276 ///
277 /// # Examples
278 ///
279 /// Write and read 48 bit `u64` numbers in little endian order:
280 ///
281 /// ```rust
282 /// use byteorder::{ByteOrder, LittleEndian};
283 ///
284 /// let mut buf = [0; 6];
285 /// LittleEndian::write_u48(&mut buf, 1_000_000_000_000);
286 /// assert_eq!(1_000_000_000_000, LittleEndian::read_u48(&buf));
287 /// ```
read_u48(buf: &[u8]) -> u64288 fn read_u48(buf: &[u8]) -> u64 {
289 Self::read_uint(buf, 6) as u64
290 }
291
292 /// Reads an unsigned 64 bit integer from `buf`.
293 ///
294 /// # Panics
295 ///
296 /// Panics when `buf.len() < 8`.
297 ///
298 /// # Examples
299 ///
300 /// Write and read `u64` numbers in little endian order:
301 ///
302 /// ```rust
303 /// use byteorder::{ByteOrder, LittleEndian};
304 ///
305 /// let mut buf = [0; 8];
306 /// LittleEndian::write_u64(&mut buf, 1_000_000);
307 /// assert_eq!(1_000_000, LittleEndian::read_u64(&buf));
308 /// ```
read_u64(buf: &[u8]) -> u64309 fn read_u64(buf: &[u8]) -> u64;
310
311 /// Reads an unsigned 128 bit integer from `buf`.
312 ///
313 /// # Panics
314 ///
315 /// Panics when `buf.len() < 16`.
316 ///
317 /// # Examples
318 ///
319 /// Write and read `u128` numbers in little endian order:
320 ///
321 /// ```rust
322 /// use byteorder::{ByteOrder, LittleEndian};
323 ///
324 /// let mut buf = [0; 16];
325 /// LittleEndian::write_u128(&mut buf, 1_000_000);
326 /// assert_eq!(1_000_000, LittleEndian::read_u128(&buf));
327 /// ```
read_u128(buf: &[u8]) -> u128328 fn read_u128(buf: &[u8]) -> u128;
329
330 /// Reads an unsigned n-bytes integer from `buf`.
331 ///
332 /// # Panics
333 ///
334 /// Panics when `nbytes < 1` or `nbytes > 8` or
335 /// `buf.len() < nbytes`
336 ///
337 /// # Examples
338 ///
339 /// Write and read an n-byte number in little endian order:
340 ///
341 /// ```rust
342 /// use byteorder::{ByteOrder, LittleEndian};
343 ///
344 /// let mut buf = [0; 3];
345 /// LittleEndian::write_uint(&mut buf, 1_000_000, 3);
346 /// assert_eq!(1_000_000, LittleEndian::read_uint(&buf, 3));
347 /// ```
read_uint(buf: &[u8], nbytes: usize) -> u64348 fn read_uint(buf: &[u8], nbytes: usize) -> u64;
349
350 /// Reads an unsigned n-bytes integer from `buf`.
351 ///
352 /// # Panics
353 ///
354 /// Panics when `nbytes < 1` or `nbytes > 16` or
355 /// `buf.len() < nbytes`
356 ///
357 /// # Examples
358 ///
359 /// Write and read an n-byte number in little endian order:
360 ///
361 /// ```rust
362 /// use byteorder::{ByteOrder, LittleEndian};
363 ///
364 /// let mut buf = [0; 3];
365 /// LittleEndian::write_uint128(&mut buf, 1_000_000, 3);
366 /// assert_eq!(1_000_000, LittleEndian::read_uint128(&buf, 3));
367 /// ```
read_uint128(buf: &[u8], nbytes: usize) -> u128368 fn read_uint128(buf: &[u8], nbytes: usize) -> u128;
369
370 /// Writes an unsigned 16 bit integer `n` to `buf`.
371 ///
372 /// # Panics
373 ///
374 /// Panics when `buf.len() < 2`.
375 ///
376 /// # Examples
377 ///
378 /// Write and read `u16` numbers in little endian order:
379 ///
380 /// ```rust
381 /// use byteorder::{ByteOrder, LittleEndian};
382 ///
383 /// let mut buf = [0; 2];
384 /// LittleEndian::write_u16(&mut buf, 1_000);
385 /// assert_eq!(1_000, LittleEndian::read_u16(&buf));
386 /// ```
write_u16(buf: &mut [u8], n: u16)387 fn write_u16(buf: &mut [u8], n: u16);
388
389 /// Writes an unsigned 24 bit integer `n` to `buf`, stored in u32.
390 ///
391 /// # Panics
392 ///
393 /// Panics when `buf.len() < 3`.
394 ///
395 /// # Examples
396 ///
397 /// Write and read 24 bit `u32` numbers in little endian order:
398 ///
399 /// ```rust
400 /// use byteorder::{ByteOrder, LittleEndian};
401 ///
402 /// let mut buf = [0; 3];
403 /// LittleEndian::write_u24(&mut buf, 1_000_000);
404 /// assert_eq!(1_000_000, LittleEndian::read_u24(&buf));
405 /// ```
write_u24(buf: &mut [u8], n: u32)406 fn write_u24(buf: &mut [u8], n: u32) {
407 Self::write_uint(buf, n as u64, 3)
408 }
409
410 /// Writes an unsigned 32 bit integer `n` to `buf`.
411 ///
412 /// # Panics
413 ///
414 /// Panics when `buf.len() < 4`.
415 ///
416 /// # Examples
417 ///
418 /// Write and read `u32` numbers in little endian order:
419 ///
420 /// ```rust
421 /// use byteorder::{ByteOrder, LittleEndian};
422 ///
423 /// let mut buf = [0; 4];
424 /// LittleEndian::write_u32(&mut buf, 1_000_000);
425 /// assert_eq!(1_000_000, LittleEndian::read_u32(&buf));
426 /// ```
write_u32(buf: &mut [u8], n: u32)427 fn write_u32(buf: &mut [u8], n: u32);
428
429 /// Writes an unsigned 48 bit integer `n` to `buf`, stored in u64.
430 ///
431 /// # Panics
432 ///
433 /// Panics when `buf.len() < 6`.
434 ///
435 /// # Examples
436 ///
437 /// Write and read 48 bit `u64` numbers in little endian order:
438 ///
439 /// ```rust
440 /// use byteorder::{ByteOrder, LittleEndian};
441 ///
442 /// let mut buf = [0; 6];
443 /// LittleEndian::write_u48(&mut buf, 1_000_000_000_000);
444 /// assert_eq!(1_000_000_000_000, LittleEndian::read_u48(&buf));
445 /// ```
write_u48(buf: &mut [u8], n: u64)446 fn write_u48(buf: &mut [u8], n: u64) {
447 Self::write_uint(buf, n as u64, 6)
448 }
449
450 /// Writes an unsigned 64 bit integer `n` to `buf`.
451 ///
452 /// # Panics
453 ///
454 /// Panics when `buf.len() < 8`.
455 ///
456 /// # Examples
457 ///
458 /// Write and read `u64` numbers in little endian order:
459 ///
460 /// ```rust
461 /// use byteorder::{ByteOrder, LittleEndian};
462 ///
463 /// let mut buf = [0; 8];
464 /// LittleEndian::write_u64(&mut buf, 1_000_000);
465 /// assert_eq!(1_000_000, LittleEndian::read_u64(&buf));
466 /// ```
write_u64(buf: &mut [u8], n: u64)467 fn write_u64(buf: &mut [u8], n: u64);
468
469 /// Writes an unsigned 128 bit integer `n` to `buf`.
470 ///
471 /// # Panics
472 ///
473 /// Panics when `buf.len() < 16`.
474 ///
475 /// # Examples
476 ///
477 /// Write and read `u128` numbers in little endian order:
478 ///
479 /// ```rust
480 /// use byteorder::{ByteOrder, LittleEndian};
481 ///
482 /// let mut buf = [0; 16];
483 /// LittleEndian::write_u128(&mut buf, 1_000_000);
484 /// assert_eq!(1_000_000, LittleEndian::read_u128(&buf));
485 /// ```
write_u128(buf: &mut [u8], n: u128)486 fn write_u128(buf: &mut [u8], n: u128);
487
488 /// Writes an unsigned integer `n` to `buf` using only `nbytes`.
489 ///
490 /// # Panics
491 ///
492 /// If `n` is not representable in `nbytes`, or if `nbytes` is `> 8`, then
493 /// this method panics.
494 ///
495 /// # Examples
496 ///
497 /// Write and read an n-byte number in little endian order:
498 ///
499 /// ```rust
500 /// use byteorder::{ByteOrder, LittleEndian};
501 ///
502 /// let mut buf = [0; 3];
503 /// LittleEndian::write_uint(&mut buf, 1_000_000, 3);
504 /// assert_eq!(1_000_000, LittleEndian::read_uint(&buf, 3));
505 /// ```
write_uint(buf: &mut [u8], n: u64, nbytes: usize)506 fn write_uint(buf: &mut [u8], n: u64, nbytes: usize);
507
508 /// Writes an unsigned integer `n` to `buf` using only `nbytes`.
509 ///
510 /// # Panics
511 ///
512 /// If `n` is not representable in `nbytes`, or if `nbytes` is `> 16`, then
513 /// this method panics.
514 ///
515 /// # Examples
516 ///
517 /// Write and read an n-byte number in little endian order:
518 ///
519 /// ```rust
520 /// use byteorder::{ByteOrder, LittleEndian};
521 ///
522 /// let mut buf = [0; 3];
523 /// LittleEndian::write_uint128(&mut buf, 1_000_000, 3);
524 /// assert_eq!(1_000_000, LittleEndian::read_uint128(&buf, 3));
525 /// ```
write_uint128(buf: &mut [u8], n: u128, nbytes: usize)526 fn write_uint128(buf: &mut [u8], n: u128, nbytes: usize);
527
528 /// Reads a signed 16 bit integer from `buf`.
529 ///
530 /// # Panics
531 ///
532 /// Panics when `buf.len() < 2`.
533 ///
534 /// # Examples
535 ///
536 /// Write and read `i16` numbers in little endian order:
537 ///
538 /// ```rust
539 /// use byteorder::{ByteOrder, LittleEndian};
540 ///
541 /// let mut buf = [0; 2];
542 /// LittleEndian::write_i16(&mut buf, -1_000);
543 /// assert_eq!(-1_000, LittleEndian::read_i16(&buf));
544 /// ```
545 #[inline]
read_i16(buf: &[u8]) -> i16546 fn read_i16(buf: &[u8]) -> i16 {
547 Self::read_u16(buf) as i16
548 }
549
550 /// Reads a signed 24 bit integer from `buf`, stored in i32.
551 ///
552 /// # Panics
553 ///
554 /// Panics when `buf.len() < 3`.
555 ///
556 /// # Examples
557 ///
558 /// Write and read 24 bit `i32` numbers in little endian order:
559 ///
560 /// ```rust
561 /// use byteorder::{ByteOrder, LittleEndian};
562 ///
563 /// let mut buf = [0; 3];
564 /// LittleEndian::write_i24(&mut buf, -1_000_000);
565 /// assert_eq!(-1_000_000, LittleEndian::read_i24(&buf));
566 /// ```
567 #[inline]
read_i24(buf: &[u8]) -> i32568 fn read_i24(buf: &[u8]) -> i32 {
569 Self::read_int(buf, 3) as i32
570 }
571
572 /// Reads a signed 32 bit integer from `buf`.
573 ///
574 /// # Panics
575 ///
576 /// Panics when `buf.len() < 4`.
577 ///
578 /// # Examples
579 ///
580 /// Write and read `i32` numbers in little endian order:
581 ///
582 /// ```rust
583 /// use byteorder::{ByteOrder, LittleEndian};
584 ///
585 /// let mut buf = [0; 4];
586 /// LittleEndian::write_i32(&mut buf, -1_000_000);
587 /// assert_eq!(-1_000_000, LittleEndian::read_i32(&buf));
588 /// ```
589 #[inline]
read_i32(buf: &[u8]) -> i32590 fn read_i32(buf: &[u8]) -> i32 {
591 Self::read_u32(buf) as i32
592 }
593
594 /// Reads a signed 48 bit integer from `buf`, stored in i64.
595 ///
596 /// # Panics
597 ///
598 /// Panics when `buf.len() < 6`.
599 ///
600 /// # Examples
601 ///
602 /// Write and read 48 bit `i64` numbers in little endian order:
603 ///
604 /// ```rust
605 /// use byteorder::{ByteOrder, LittleEndian};
606 ///
607 /// let mut buf = [0; 6];
608 /// LittleEndian::write_i48(&mut buf, -1_000_000_000_000);
609 /// assert_eq!(-1_000_000_000_000, LittleEndian::read_i48(&buf));
610 /// ```
611 #[inline]
read_i48(buf: &[u8]) -> i64612 fn read_i48(buf: &[u8]) -> i64 {
613 Self::read_int(buf, 6) as i64
614 }
615
616 /// Reads a signed 64 bit integer from `buf`.
617 ///
618 /// # Panics
619 ///
620 /// Panics when `buf.len() < 8`.
621 ///
622 /// # Examples
623 ///
624 /// Write and read `i64` numbers in little endian order:
625 ///
626 /// ```rust
627 /// use byteorder::{ByteOrder, LittleEndian};
628 ///
629 /// let mut buf = [0; 8];
630 /// LittleEndian::write_i64(&mut buf, -1_000_000_000);
631 /// assert_eq!(-1_000_000_000, LittleEndian::read_i64(&buf));
632 /// ```
633 #[inline]
read_i64(buf: &[u8]) -> i64634 fn read_i64(buf: &[u8]) -> i64 {
635 Self::read_u64(buf) as i64
636 }
637
638 /// Reads a signed 128 bit integer from `buf`.
639 ///
640 /// # Panics
641 ///
642 /// Panics when `buf.len() < 16`.
643 ///
644 /// # Examples
645 ///
646 /// Write and read `i128` numbers in little endian order:
647 ///
648 /// ```rust
649 /// use byteorder::{ByteOrder, LittleEndian};
650 ///
651 /// let mut buf = [0; 16];
652 /// LittleEndian::write_i128(&mut buf, -1_000_000_000);
653 /// assert_eq!(-1_000_000_000, LittleEndian::read_i128(&buf));
654 /// ```
655 #[inline]
read_i128(buf: &[u8]) -> i128656 fn read_i128(buf: &[u8]) -> i128 {
657 Self::read_u128(buf) as i128
658 }
659
660 /// Reads a signed n-bytes integer from `buf`.
661 ///
662 /// # Panics
663 ///
664 /// Panics when `nbytes < 1` or `nbytes > 8` or
665 /// `buf.len() < nbytes`
666 ///
667 /// # Examples
668 ///
669 /// Write and read n-length signed numbers in little endian order:
670 ///
671 /// ```rust
672 /// use byteorder::{ByteOrder, LittleEndian};
673 ///
674 /// let mut buf = [0; 3];
675 /// LittleEndian::write_int(&mut buf, -1_000, 3);
676 /// assert_eq!(-1_000, LittleEndian::read_int(&buf, 3));
677 /// ```
678 #[inline]
read_int(buf: &[u8], nbytes: usize) -> i64679 fn read_int(buf: &[u8], nbytes: usize) -> i64 {
680 extend_sign(Self::read_uint(buf, nbytes), nbytes)
681 }
682
683 /// Reads a signed n-bytes integer from `buf`.
684 ///
685 /// # Panics
686 ///
687 /// Panics when `nbytes < 1` or `nbytes > 16` or
688 /// `buf.len() < nbytes`
689 ///
690 /// # Examples
691 ///
692 /// Write and read n-length signed numbers in little endian order:
693 ///
694 /// ```rust
695 /// use byteorder::{ByteOrder, LittleEndian};
696 ///
697 /// let mut buf = [0; 3];
698 /// LittleEndian::write_int128(&mut buf, -1_000, 3);
699 /// assert_eq!(-1_000, LittleEndian::read_int128(&buf, 3));
700 /// ```
701 #[inline]
read_int128(buf: &[u8], nbytes: usize) -> i128702 fn read_int128(buf: &[u8], nbytes: usize) -> i128 {
703 extend_sign128(Self::read_uint128(buf, nbytes), nbytes)
704 }
705
706 /// Reads a IEEE754 single-precision (4 bytes) floating point number.
707 ///
708 /// # Panics
709 ///
710 /// Panics when `buf.len() < 4`.
711 ///
712 /// # Examples
713 ///
714 /// Write and read `f32` numbers in little endian order:
715 ///
716 /// ```rust
717 /// use byteorder::{ByteOrder, LittleEndian};
718 ///
719 /// let e = 2.71828;
720 /// let mut buf = [0; 4];
721 /// LittleEndian::write_f32(&mut buf, e);
722 /// assert_eq!(e, LittleEndian::read_f32(&buf));
723 /// ```
724 #[inline]
read_f32(buf: &[u8]) -> f32725 fn read_f32(buf: &[u8]) -> f32 {
726 f32::from_bits(Self::read_u32(buf))
727 }
728
729 /// Reads a IEEE754 double-precision (8 bytes) floating point number.
730 ///
731 /// # Panics
732 ///
733 /// Panics when `buf.len() < 8`.
734 ///
735 /// # Examples
736 ///
737 /// Write and read `f64` numbers in little endian order:
738 ///
739 /// ```rust
740 /// use byteorder::{ByteOrder, LittleEndian};
741 ///
742 /// let phi = 1.6180339887;
743 /// let mut buf = [0; 8];
744 /// LittleEndian::write_f64(&mut buf, phi);
745 /// assert_eq!(phi, LittleEndian::read_f64(&buf));
746 /// ```
747 #[inline]
read_f64(buf: &[u8]) -> f64748 fn read_f64(buf: &[u8]) -> f64 {
749 f64::from_bits(Self::read_u64(buf))
750 }
751
752 /// Writes a signed 16 bit integer `n` to `buf`.
753 ///
754 /// # Panics
755 ///
756 /// Panics when `buf.len() < 2`.
757 ///
758 /// # Examples
759 ///
760 /// Write and read `i16` numbers in little endian order:
761 ///
762 /// ```rust
763 /// use byteorder::{ByteOrder, LittleEndian};
764 ///
765 /// let mut buf = [0; 2];
766 /// LittleEndian::write_i16(&mut buf, -1_000);
767 /// assert_eq!(-1_000, LittleEndian::read_i16(&buf));
768 /// ```
769 #[inline]
write_i16(buf: &mut [u8], n: i16)770 fn write_i16(buf: &mut [u8], n: i16) {
771 Self::write_u16(buf, n as u16)
772 }
773
774 /// Writes a signed 24 bit integer `n` to `buf`, stored in i32.
775 ///
776 /// # Panics
777 ///
778 /// Panics when `buf.len() < 3`.
779 ///
780 /// # Examples
781 ///
782 /// Write and read 24 bit `i32` numbers in little endian order:
783 ///
784 /// ```rust
785 /// use byteorder::{ByteOrder, LittleEndian};
786 ///
787 /// let mut buf = [0; 3];
788 /// LittleEndian::write_i24(&mut buf, -1_000_000);
789 /// assert_eq!(-1_000_000, LittleEndian::read_i24(&buf));
790 /// ```
791 #[inline]
write_i24(buf: &mut [u8], n: i32)792 fn write_i24(buf: &mut [u8], n: i32) {
793 Self::write_int(buf, n as i64, 3)
794 }
795
796 /// Writes a signed 32 bit integer `n` to `buf`.
797 ///
798 /// # Panics
799 ///
800 /// Panics when `buf.len() < 4`.
801 ///
802 /// # Examples
803 ///
804 /// Write and read `i32` numbers in little endian order:
805 ///
806 /// ```rust
807 /// use byteorder::{ByteOrder, LittleEndian};
808 ///
809 /// let mut buf = [0; 4];
810 /// LittleEndian::write_i32(&mut buf, -1_000_000);
811 /// assert_eq!(-1_000_000, LittleEndian::read_i32(&buf));
812 /// ```
813 #[inline]
write_i32(buf: &mut [u8], n: i32)814 fn write_i32(buf: &mut [u8], n: i32) {
815 Self::write_u32(buf, n as u32)
816 }
817
818 /// Writes a signed 48 bit integer `n` to `buf`, stored in i64.
819 ///
820 /// # Panics
821 ///
822 /// Panics when `buf.len() < 6`.
823 ///
824 /// # Examples
825 ///
826 /// Write and read 48 bit `i64` numbers in little endian order:
827 ///
828 /// ```rust
829 /// use byteorder::{ByteOrder, LittleEndian};
830 ///
831 /// let mut buf = [0; 6];
832 /// LittleEndian::write_i48(&mut buf, -1_000_000_000_000);
833 /// assert_eq!(-1_000_000_000_000, LittleEndian::read_i48(&buf));
834 /// ```
835 #[inline]
write_i48(buf: &mut [u8], n: i64)836 fn write_i48(buf: &mut [u8], n: i64) {
837 Self::write_int(buf, n as i64, 6)
838 }
839
840 /// Writes a signed 64 bit integer `n` to `buf`.
841 ///
842 /// # Panics
843 ///
844 /// Panics when `buf.len() < 8`.
845 ///
846 /// # Examples
847 ///
848 /// Write and read `i64` numbers in little endian order:
849 ///
850 /// ```rust
851 /// use byteorder::{ByteOrder, LittleEndian};
852 ///
853 /// let mut buf = [0; 8];
854 /// LittleEndian::write_i64(&mut buf, -1_000_000_000);
855 /// assert_eq!(-1_000_000_000, LittleEndian::read_i64(&buf));
856 /// ```
857 #[inline]
write_i64(buf: &mut [u8], n: i64)858 fn write_i64(buf: &mut [u8], n: i64) {
859 Self::write_u64(buf, n as u64)
860 }
861
862 /// Writes a signed 128 bit integer `n` to `buf`.
863 ///
864 /// # Panics
865 ///
866 /// Panics when `buf.len() < 16`.
867 ///
868 /// # Examples
869 ///
870 /// Write and read n-byte `i128` numbers in little endian order:
871 ///
872 /// ```rust
873 /// use byteorder::{ByteOrder, LittleEndian};
874 ///
875 /// let mut buf = [0; 16];
876 /// LittleEndian::write_i128(&mut buf, -1_000_000_000);
877 /// assert_eq!(-1_000_000_000, LittleEndian::read_i128(&buf));
878 /// ```
879 #[inline]
write_i128(buf: &mut [u8], n: i128)880 fn write_i128(buf: &mut [u8], n: i128) {
881 Self::write_u128(buf, n as u128)
882 }
883
884 /// Writes a signed integer `n` to `buf` using only `nbytes`.
885 ///
886 /// # Panics
887 ///
888 /// If `n` is not representable in `nbytes`, or if `nbytes` is `> 8`, then
889 /// this method panics.
890 ///
891 /// # Examples
892 ///
893 /// Write and read an n-byte number in little endian order:
894 ///
895 /// ```rust
896 /// use byteorder::{ByteOrder, LittleEndian};
897 ///
898 /// let mut buf = [0; 3];
899 /// LittleEndian::write_int(&mut buf, -1_000, 3);
900 /// assert_eq!(-1_000, LittleEndian::read_int(&buf, 3));
901 /// ```
902 #[inline]
write_int(buf: &mut [u8], n: i64, nbytes: usize)903 fn write_int(buf: &mut [u8], n: i64, nbytes: usize) {
904 Self::write_uint(buf, unextend_sign(n, nbytes), nbytes)
905 }
906
907 /// Writes a signed integer `n` to `buf` using only `nbytes`.
908 ///
909 /// # Panics
910 ///
911 /// If `n` is not representable in `nbytes`, or if `nbytes` is `> 16`, then
912 /// this method panics.
913 ///
914 /// # Examples
915 ///
916 /// Write and read n-length signed numbers in little endian order:
917 ///
918 /// ```rust
919 /// use byteorder::{ByteOrder, LittleEndian};
920 ///
921 /// let mut buf = [0; 3];
922 /// LittleEndian::write_int128(&mut buf, -1_000, 3);
923 /// assert_eq!(-1_000, LittleEndian::read_int128(&buf, 3));
924 /// ```
925 #[inline]
write_int128(buf: &mut [u8], n: i128, nbytes: usize)926 fn write_int128(buf: &mut [u8], n: i128, nbytes: usize) {
927 Self::write_uint128(buf, unextend_sign128(n, nbytes), nbytes)
928 }
929
930 /// Writes a IEEE754 single-precision (4 bytes) floating point number.
931 ///
932 /// # Panics
933 ///
934 /// Panics when `buf.len() < 4`.
935 ///
936 /// # Examples
937 ///
938 /// Write and read `f32` numbers in little endian order:
939 ///
940 /// ```rust
941 /// use byteorder::{ByteOrder, LittleEndian};
942 ///
943 /// let e = 2.71828;
944 /// let mut buf = [0; 4];
945 /// LittleEndian::write_f32(&mut buf, e);
946 /// assert_eq!(e, LittleEndian::read_f32(&buf));
947 /// ```
948 #[inline]
write_f32(buf: &mut [u8], n: f32)949 fn write_f32(buf: &mut [u8], n: f32) {
950 Self::write_u32(buf, n.to_bits())
951 }
952
953 /// Writes a IEEE754 double-precision (8 bytes) floating point number.
954 ///
955 /// # Panics
956 ///
957 /// Panics when `buf.len() < 8`.
958 ///
959 /// # Examples
960 ///
961 /// Write and read `f64` numbers in little endian order:
962 ///
963 /// ```rust
964 /// use byteorder::{ByteOrder, LittleEndian};
965 ///
966 /// let phi = 1.6180339887;
967 /// let mut buf = [0; 8];
968 /// LittleEndian::write_f64(&mut buf, phi);
969 /// assert_eq!(phi, LittleEndian::read_f64(&buf));
970 /// ```
971 #[inline]
write_f64(buf: &mut [u8], n: f64)972 fn write_f64(buf: &mut [u8], n: f64) {
973 Self::write_u64(buf, n.to_bits())
974 }
975
976 /// Reads unsigned 16 bit integers from `src` into `dst`.
977 ///
978 /// # Panics
979 ///
980 /// Panics when `src.len() != 2*dst.len()`.
981 ///
982 /// # Examples
983 ///
984 /// Write and read `u16` numbers in little endian order:
985 ///
986 /// ```rust
987 /// use byteorder::{ByteOrder, LittleEndian};
988 ///
989 /// let mut bytes = [0; 8];
990 /// let numbers_given = [1, 2, 0xf00f, 0xffee];
991 /// LittleEndian::write_u16_into(&numbers_given, &mut bytes);
992 ///
993 /// let mut numbers_got = [0; 4];
994 /// LittleEndian::read_u16_into(&bytes, &mut numbers_got);
995 /// assert_eq!(numbers_given, numbers_got);
996 /// ```
read_u16_into(src: &[u8], dst: &mut [u16])997 fn read_u16_into(src: &[u8], dst: &mut [u16]);
998
999 /// Reads unsigned 32 bit integers from `src` into `dst`.
1000 ///
1001 /// # Panics
1002 ///
1003 /// Panics when `src.len() != 4*dst.len()`.
1004 ///
1005 /// # Examples
1006 ///
1007 /// Write and read `u32` numbers in little endian order:
1008 ///
1009 /// ```rust
1010 /// use byteorder::{ByteOrder, LittleEndian};
1011 ///
1012 /// let mut bytes = [0; 16];
1013 /// let numbers_given = [1, 2, 0xf00f, 0xffee];
1014 /// LittleEndian::write_u32_into(&numbers_given, &mut bytes);
1015 ///
1016 /// let mut numbers_got = [0; 4];
1017 /// LittleEndian::read_u32_into(&bytes, &mut numbers_got);
1018 /// assert_eq!(numbers_given, numbers_got);
1019 /// ```
read_u32_into(src: &[u8], dst: &mut [u32])1020 fn read_u32_into(src: &[u8], dst: &mut [u32]);
1021
1022 /// Reads unsigned 64 bit integers from `src` into `dst`.
1023 ///
1024 /// # Panics
1025 ///
1026 /// Panics when `src.len() != 8*dst.len()`.
1027 ///
1028 /// # Examples
1029 ///
1030 /// Write and read `u64` numbers in little endian order:
1031 ///
1032 /// ```rust
1033 /// use byteorder::{ByteOrder, LittleEndian};
1034 ///
1035 /// let mut bytes = [0; 32];
1036 /// let numbers_given = [1, 2, 0xf00f, 0xffee];
1037 /// LittleEndian::write_u64_into(&numbers_given, &mut bytes);
1038 ///
1039 /// let mut numbers_got = [0; 4];
1040 /// LittleEndian::read_u64_into(&bytes, &mut numbers_got);
1041 /// assert_eq!(numbers_given, numbers_got);
1042 /// ```
read_u64_into(src: &[u8], dst: &mut [u64])1043 fn read_u64_into(src: &[u8], dst: &mut [u64]);
1044
1045 /// Reads unsigned 128 bit integers from `src` into `dst`.
1046 ///
1047 /// # Panics
1048 ///
1049 /// Panics when `src.len() != 16*dst.len()`.
1050 ///
1051 /// # Examples
1052 ///
1053 /// Write and read `u128` numbers in little endian order:
1054 ///
1055 /// ```rust
1056 /// use byteorder::{ByteOrder, LittleEndian};
1057 ///
1058 /// let mut bytes = [0; 64];
1059 /// let numbers_given = [1, 2, 0xf00f, 0xffee];
1060 /// LittleEndian::write_u128_into(&numbers_given, &mut bytes);
1061 ///
1062 /// let mut numbers_got = [0; 4];
1063 /// LittleEndian::read_u128_into(&bytes, &mut numbers_got);
1064 /// assert_eq!(numbers_given, numbers_got);
1065 /// ```
read_u128_into(src: &[u8], dst: &mut [u128])1066 fn read_u128_into(src: &[u8], dst: &mut [u128]);
1067
1068 /// Reads signed 16 bit integers from `src` to `dst`.
1069 ///
1070 /// # Panics
1071 ///
1072 /// Panics when `buf.len() != 2*dst.len()`.
1073 ///
1074 /// # Examples
1075 ///
1076 /// Write and read `i16` numbers in little endian order:
1077 ///
1078 /// ```rust
1079 /// use byteorder::{ByteOrder, LittleEndian};
1080 ///
1081 /// let mut bytes = [0; 8];
1082 /// let numbers_given = [1, 2, 0x0f, 0xee];
1083 /// LittleEndian::write_i16_into(&numbers_given, &mut bytes);
1084 ///
1085 /// let mut numbers_got = [0; 4];
1086 /// LittleEndian::read_i16_into(&bytes, &mut numbers_got);
1087 /// assert_eq!(numbers_given, numbers_got);
1088 /// ```
1089 #[inline]
read_i16_into(src: &[u8], dst: &mut [i16])1090 fn read_i16_into(src: &[u8], dst: &mut [i16]) {
1091 let dst = unsafe {
1092 slice::from_raw_parts_mut(dst.as_mut_ptr() as *mut u16, dst.len())
1093 };
1094 Self::read_u16_into(src, dst)
1095 }
1096
1097 /// Reads signed 32 bit integers from `src` into `dst`.
1098 ///
1099 /// # Panics
1100 ///
1101 /// Panics when `src.len() != 4*dst.len()`.
1102 ///
1103 /// # Examples
1104 ///
1105 /// Write and read `i32` numbers in little endian order:
1106 ///
1107 /// ```rust
1108 /// use byteorder::{ByteOrder, LittleEndian};
1109 ///
1110 /// let mut bytes = [0; 16];
1111 /// let numbers_given = [1, 2, 0xf00f, 0xffee];
1112 /// LittleEndian::write_i32_into(&numbers_given, &mut bytes);
1113 ///
1114 /// let mut numbers_got = [0; 4];
1115 /// LittleEndian::read_i32_into(&bytes, &mut numbers_got);
1116 /// assert_eq!(numbers_given, numbers_got);
1117 /// ```
1118 #[inline]
read_i32_into(src: &[u8], dst: &mut [i32])1119 fn read_i32_into(src: &[u8], dst: &mut [i32]) {
1120 let dst = unsafe {
1121 slice::from_raw_parts_mut(dst.as_mut_ptr() as *mut u32, dst.len())
1122 };
1123 Self::read_u32_into(src, dst);
1124 }
1125
1126 /// Reads signed 64 bit integers from `src` into `dst`.
1127 ///
1128 /// # Panics
1129 ///
1130 /// Panics when `src.len() != 8*dst.len()`.
1131 ///
1132 /// # Examples
1133 ///
1134 /// Write and read `i64` numbers in little endian order:
1135 ///
1136 /// ```rust
1137 /// use byteorder::{ByteOrder, LittleEndian};
1138 ///
1139 /// let mut bytes = [0; 32];
1140 /// let numbers_given = [1, 2, 0xf00f, 0xffee];
1141 /// LittleEndian::write_i64_into(&numbers_given, &mut bytes);
1142 ///
1143 /// let mut numbers_got = [0; 4];
1144 /// LittleEndian::read_i64_into(&bytes, &mut numbers_got);
1145 /// assert_eq!(numbers_given, numbers_got);
1146 /// ```
1147 #[inline]
read_i64_into(src: &[u8], dst: &mut [i64])1148 fn read_i64_into(src: &[u8], dst: &mut [i64]) {
1149 let dst = unsafe {
1150 slice::from_raw_parts_mut(dst.as_mut_ptr() as *mut u64, dst.len())
1151 };
1152 Self::read_u64_into(src, dst);
1153 }
1154
1155 /// Reads signed 128 bit integers from `src` into `dst`.
1156 ///
1157 /// # Panics
1158 ///
1159 /// Panics when `src.len() != 16*dst.len()`.
1160 ///
1161 /// # Examples
1162 ///
1163 /// Write and read `i128` numbers in little endian order:
1164 ///
1165 /// ```rust
1166 /// use byteorder::{ByteOrder, LittleEndian};
1167 ///
1168 /// let mut bytes = [0; 64];
1169 /// let numbers_given = [1, 2, 0xf00f, 0xffee];
1170 /// LittleEndian::write_i128_into(&numbers_given, &mut bytes);
1171 ///
1172 /// let mut numbers_got = [0; 4];
1173 /// LittleEndian::read_i128_into(&bytes, &mut numbers_got);
1174 /// assert_eq!(numbers_given, numbers_got);
1175 /// ```
1176 #[inline]
read_i128_into(src: &[u8], dst: &mut [i128])1177 fn read_i128_into(src: &[u8], dst: &mut [i128]) {
1178 let dst = unsafe {
1179 slice::from_raw_parts_mut(dst.as_mut_ptr() as *mut u128, dst.len())
1180 };
1181 Self::read_u128_into(src, dst);
1182 }
1183
1184 /// Reads IEEE754 single-precision (4 bytes) floating point numbers from
1185 /// `src` into `dst`.
1186 ///
1187 /// # Panics
1188 ///
1189 /// Panics when `src.len() != 4*dst.len()`.
1190 ///
1191 /// # Examples
1192 ///
1193 /// Write and read `f32` numbers in little endian order:
1194 ///
1195 /// ```rust
1196 /// use byteorder::{ByteOrder, LittleEndian};
1197 ///
1198 /// let mut bytes = [0; 16];
1199 /// let numbers_given = [1.0, 2.0, 31.312e31, -11.32e19];
1200 /// LittleEndian::write_f32_into(&numbers_given, &mut bytes);
1201 ///
1202 /// let mut numbers_got = [0.0; 4];
1203 /// LittleEndian::read_f32_into(&bytes, &mut numbers_got);
1204 /// assert_eq!(numbers_given, numbers_got);
1205 /// ```
1206 #[inline]
read_f32_into(src: &[u8], dst: &mut [f32])1207 fn read_f32_into(src: &[u8], dst: &mut [f32]) {
1208 let dst = unsafe {
1209 const _: () = assert!(align_of::<u32>() <= align_of::<f32>());
1210 slice::from_raw_parts_mut(dst.as_mut_ptr() as *mut u32, dst.len())
1211 };
1212 Self::read_u32_into(src, dst);
1213 }
1214
1215 /// **DEPRECATED**.
1216 ///
1217 /// This method is deprecated. Use `read_f32_into` instead.
1218 /// Reads IEEE754 single-precision (4 bytes) floating point numbers from
1219 /// `src` into `dst`.
1220 ///
1221 /// # Panics
1222 ///
1223 /// Panics when `src.len() != 4*dst.len()`.
1224 ///
1225 /// # Examples
1226 ///
1227 /// Write and read `f32` numbers in little endian order:
1228 ///
1229 /// ```rust
1230 /// use byteorder::{ByteOrder, LittleEndian};
1231 ///
1232 /// let mut bytes = [0; 16];
1233 /// let numbers_given = [1.0, 2.0, 31.312e31, -11.32e19];
1234 /// LittleEndian::write_f32_into(&numbers_given, &mut bytes);
1235 ///
1236 /// let mut numbers_got = [0.0; 4];
1237 /// LittleEndian::read_f32_into_unchecked(&bytes, &mut numbers_got);
1238 /// assert_eq!(numbers_given, numbers_got);
1239 /// ```
1240 #[inline]
1241 #[deprecated(since = "1.3.0", note = "please use `read_f32_into` instead")]
read_f32_into_unchecked(src: &[u8], dst: &mut [f32])1242 fn read_f32_into_unchecked(src: &[u8], dst: &mut [f32]) {
1243 Self::read_f32_into(src, dst);
1244 }
1245
1246 /// Reads IEEE754 single-precision (4 bytes) floating point numbers from
1247 /// `src` into `dst`.
1248 ///
1249 /// # Panics
1250 ///
1251 /// Panics when `src.len() != 8*dst.len()`.
1252 ///
1253 /// # Examples
1254 ///
1255 /// Write and read `f64` numbers in little endian order:
1256 ///
1257 /// ```rust
1258 /// use byteorder::{ByteOrder, LittleEndian};
1259 ///
1260 /// let mut bytes = [0; 32];
1261 /// let numbers_given = [1.0, 2.0, 31.312e211, -11.32e91];
1262 /// LittleEndian::write_f64_into(&numbers_given, &mut bytes);
1263 ///
1264 /// let mut numbers_got = [0.0; 4];
1265 /// LittleEndian::read_f64_into(&bytes, &mut numbers_got);
1266 /// assert_eq!(numbers_given, numbers_got);
1267 /// ```
1268 #[inline]
read_f64_into(src: &[u8], dst: &mut [f64])1269 fn read_f64_into(src: &[u8], dst: &mut [f64]) {
1270 let dst = unsafe {
1271 const _: () = assert!(align_of::<u64>() <= align_of::<f64>());
1272 slice::from_raw_parts_mut(dst.as_mut_ptr() as *mut u64, dst.len())
1273 };
1274 Self::read_u64_into(src, dst);
1275 }
1276
1277 /// **DEPRECATED**.
1278 ///
1279 /// This method is deprecated. Use `read_f64_into` instead.
1280 ///
1281 /// Reads IEEE754 single-precision (4 bytes) floating point numbers from
1282 /// `src` into `dst`.
1283 ///
1284 /// # Panics
1285 ///
1286 /// Panics when `src.len() != 8*dst.len()`.
1287 ///
1288 /// # Examples
1289 ///
1290 /// Write and read `f64` numbers in little endian order:
1291 ///
1292 /// ```rust
1293 /// use byteorder::{ByteOrder, LittleEndian};
1294 ///
1295 /// let mut bytes = [0; 32];
1296 /// let numbers_given = [1.0, 2.0, 31.312e211, -11.32e91];
1297 /// LittleEndian::write_f64_into(&numbers_given, &mut bytes);
1298 ///
1299 /// let mut numbers_got = [0.0; 4];
1300 /// LittleEndian::read_f64_into_unchecked(&bytes, &mut numbers_got);
1301 /// assert_eq!(numbers_given, numbers_got);
1302 /// ```
1303 #[inline]
1304 #[deprecated(since = "1.3.0", note = "please use `read_f64_into` instead")]
read_f64_into_unchecked(src: &[u8], dst: &mut [f64])1305 fn read_f64_into_unchecked(src: &[u8], dst: &mut [f64]) {
1306 Self::read_f64_into(src, dst);
1307 }
1308
1309 /// Writes unsigned 16 bit integers from `src` into `dst`.
1310 ///
1311 /// # Panics
1312 ///
1313 /// Panics when `dst.len() != 2*src.len()`.
1314 ///
1315 /// # Examples
1316 ///
1317 /// Write and read `u16` numbers in little endian order:
1318 ///
1319 /// ```rust
1320 /// use byteorder::{ByteOrder, LittleEndian};
1321 ///
1322 /// let mut bytes = [0; 8];
1323 /// let numbers_given = [1, 2, 0xf00f, 0xffee];
1324 /// LittleEndian::write_u16_into(&numbers_given, &mut bytes);
1325 ///
1326 /// let mut numbers_got = [0; 4];
1327 /// LittleEndian::read_u16_into(&bytes, &mut numbers_got);
1328 /// assert_eq!(numbers_given, numbers_got);
1329 /// ```
write_u16_into(src: &[u16], dst: &mut [u8])1330 fn write_u16_into(src: &[u16], dst: &mut [u8]);
1331
1332 /// Writes unsigned 32 bit integers from `src` into `dst`.
1333 ///
1334 /// # Panics
1335 ///
1336 /// Panics when `dst.len() != 4*src.len()`.
1337 ///
1338 /// # Examples
1339 ///
1340 /// Write and read `u32` numbers in little endian order:
1341 ///
1342 /// ```rust
1343 /// use byteorder::{ByteOrder, LittleEndian};
1344 ///
1345 /// let mut bytes = [0; 16];
1346 /// let numbers_given = [1, 2, 0xf00f, 0xffee];
1347 /// LittleEndian::write_u32_into(&numbers_given, &mut bytes);
1348 ///
1349 /// let mut numbers_got = [0; 4];
1350 /// LittleEndian::read_u32_into(&bytes, &mut numbers_got);
1351 /// assert_eq!(numbers_given, numbers_got);
1352 /// ```
write_u32_into(src: &[u32], dst: &mut [u8])1353 fn write_u32_into(src: &[u32], dst: &mut [u8]);
1354
1355 /// Writes unsigned 64 bit integers from `src` into `dst`.
1356 ///
1357 /// # Panics
1358 ///
1359 /// Panics when `dst.len() != 8*src.len()`.
1360 ///
1361 /// # Examples
1362 ///
1363 /// Write and read `u64` numbers in little endian order:
1364 ///
1365 /// ```rust
1366 /// use byteorder::{ByteOrder, LittleEndian};
1367 ///
1368 /// let mut bytes = [0; 32];
1369 /// let numbers_given = [1, 2, 0xf00f, 0xffee];
1370 /// LittleEndian::write_u64_into(&numbers_given, &mut bytes);
1371 ///
1372 /// let mut numbers_got = [0; 4];
1373 /// LittleEndian::read_u64_into(&bytes, &mut numbers_got);
1374 /// assert_eq!(numbers_given, numbers_got);
1375 /// ```
write_u64_into(src: &[u64], dst: &mut [u8])1376 fn write_u64_into(src: &[u64], dst: &mut [u8]);
1377
1378 /// Writes unsigned 128 bit integers from `src` into `dst`.
1379 ///
1380 /// # Panics
1381 ///
1382 /// Panics when `dst.len() != 16*src.len()`.
1383 ///
1384 /// # Examples
1385 ///
1386 /// Write and read `u128` numbers in little endian order:
1387 ///
1388 /// ```rust
1389 /// use byteorder::{ByteOrder, LittleEndian};
1390 ///
1391 /// let mut bytes = [0; 64];
1392 /// let numbers_given = [1, 2, 0xf00f, 0xffee];
1393 /// LittleEndian::write_u128_into(&numbers_given, &mut bytes);
1394 ///
1395 /// let mut numbers_got = [0; 4];
1396 /// LittleEndian::read_u128_into(&bytes, &mut numbers_got);
1397 /// assert_eq!(numbers_given, numbers_got);
1398 /// ```
write_u128_into(src: &[u128], dst: &mut [u8])1399 fn write_u128_into(src: &[u128], dst: &mut [u8]);
1400
1401 /// Writes signed 8 bit integers from `src` into `dst`.
1402 ///
1403 /// Note that since each `i8` is a single byte, no byte order conversions
1404 /// are used. This method is included because it provides a safe, simple
1405 /// way for the caller to write from a `&[i8]` buffer. (Without this
1406 /// method, the caller would have to either use `unsafe` code or convert
1407 /// each byte to `u8` individually.)
1408 ///
1409 /// # Panics
1410 ///
1411 /// Panics when `buf.len() != src.len()`.
1412 ///
1413 /// # Examples
1414 ///
1415 /// Write and read `i8` numbers in little endian order:
1416 ///
1417 /// ```rust
1418 /// use byteorder::{ByteOrder, LittleEndian, ReadBytesExt};
1419 ///
1420 /// let mut bytes = [0; 4];
1421 /// let numbers_given = [1, 2, 0xf, 0xe];
1422 /// LittleEndian::write_i8_into(&numbers_given, &mut bytes);
1423 ///
1424 /// let mut numbers_got = [0; 4];
1425 /// bytes.as_ref().read_i8_into(&mut numbers_got);
1426 /// assert_eq!(numbers_given, numbers_got);
1427 /// ```
write_i8_into(src: &[i8], dst: &mut [u8])1428 fn write_i8_into(src: &[i8], dst: &mut [u8]) {
1429 let src = unsafe {
1430 slice::from_raw_parts(src.as_ptr() as *const u8, src.len())
1431 };
1432 dst.copy_from_slice(src);
1433 }
1434
1435 /// Writes signed 16 bit integers from `src` into `dst`.
1436 ///
1437 /// # Panics
1438 ///
1439 /// Panics when `buf.len() != 2*src.len()`.
1440 ///
1441 /// # Examples
1442 ///
1443 /// Write and read `i16` numbers in little endian order:
1444 ///
1445 /// ```rust
1446 /// use byteorder::{ByteOrder, LittleEndian};
1447 ///
1448 /// let mut bytes = [0; 8];
1449 /// let numbers_given = [1, 2, 0x0f, 0xee];
1450 /// LittleEndian::write_i16_into(&numbers_given, &mut bytes);
1451 ///
1452 /// let mut numbers_got = [0; 4];
1453 /// LittleEndian::read_i16_into(&bytes, &mut numbers_got);
1454 /// assert_eq!(numbers_given, numbers_got);
1455 /// ```
write_i16_into(src: &[i16], dst: &mut [u8])1456 fn write_i16_into(src: &[i16], dst: &mut [u8]) {
1457 let src = unsafe {
1458 slice::from_raw_parts(src.as_ptr() as *const u16, src.len())
1459 };
1460 Self::write_u16_into(src, dst);
1461 }
1462
1463 /// Writes signed 32 bit integers from `src` into `dst`.
1464 ///
1465 /// # Panics
1466 ///
1467 /// Panics when `dst.len() != 4*src.len()`.
1468 ///
1469 /// # Examples
1470 ///
1471 /// Write and read `i32` numbers in little endian order:
1472 ///
1473 /// ```rust
1474 /// use byteorder::{ByteOrder, LittleEndian};
1475 ///
1476 /// let mut bytes = [0; 16];
1477 /// let numbers_given = [1, 2, 0xf00f, 0xffee];
1478 /// LittleEndian::write_i32_into(&numbers_given, &mut bytes);
1479 ///
1480 /// let mut numbers_got = [0; 4];
1481 /// LittleEndian::read_i32_into(&bytes, &mut numbers_got);
1482 /// assert_eq!(numbers_given, numbers_got);
1483 /// ```
write_i32_into(src: &[i32], dst: &mut [u8])1484 fn write_i32_into(src: &[i32], dst: &mut [u8]) {
1485 let src = unsafe {
1486 slice::from_raw_parts(src.as_ptr() as *const u32, src.len())
1487 };
1488 Self::write_u32_into(src, dst);
1489 }
1490
1491 /// Writes signed 64 bit integers from `src` into `dst`.
1492 ///
1493 /// # Panics
1494 ///
1495 /// Panics when `dst.len() != 8*src.len()`.
1496 ///
1497 /// # Examples
1498 ///
1499 /// Write and read `i64` numbers in little endian order:
1500 ///
1501 /// ```rust
1502 /// use byteorder::{ByteOrder, LittleEndian};
1503 ///
1504 /// let mut bytes = [0; 32];
1505 /// let numbers_given = [1, 2, 0xf00f, 0xffee];
1506 /// LittleEndian::write_i64_into(&numbers_given, &mut bytes);
1507 ///
1508 /// let mut numbers_got = [0; 4];
1509 /// LittleEndian::read_i64_into(&bytes, &mut numbers_got);
1510 /// assert_eq!(numbers_given, numbers_got);
1511 /// ```
write_i64_into(src: &[i64], dst: &mut [u8])1512 fn write_i64_into(src: &[i64], dst: &mut [u8]) {
1513 let src = unsafe {
1514 slice::from_raw_parts(src.as_ptr() as *const u64, src.len())
1515 };
1516 Self::write_u64_into(src, dst);
1517 }
1518
1519 /// Writes signed 128 bit integers from `src` into `dst`.
1520 ///
1521 /// # Panics
1522 ///
1523 /// Panics when `dst.len() != 16*src.len()`.
1524 ///
1525 /// # Examples
1526 ///
1527 /// Write and read `i128` numbers in little endian order:
1528 ///
1529 /// ```rust
1530 /// use byteorder::{ByteOrder, LittleEndian};
1531 ///
1532 /// let mut bytes = [0; 64];
1533 /// let numbers_given = [1, 2, 0xf00f, 0xffee];
1534 /// LittleEndian::write_i128_into(&numbers_given, &mut bytes);
1535 ///
1536 /// let mut numbers_got = [0; 4];
1537 /// LittleEndian::read_i128_into(&bytes, &mut numbers_got);
1538 /// assert_eq!(numbers_given, numbers_got);
1539 /// ```
write_i128_into(src: &[i128], dst: &mut [u8])1540 fn write_i128_into(src: &[i128], dst: &mut [u8]) {
1541 let src = unsafe {
1542 slice::from_raw_parts(src.as_ptr() as *const u128, src.len())
1543 };
1544 Self::write_u128_into(src, dst);
1545 }
1546
1547 /// Writes IEEE754 single-precision (4 bytes) floating point numbers from
1548 /// `src` into `dst`.
1549 ///
1550 /// # Panics
1551 ///
1552 /// Panics when `src.len() != 4*dst.len()`.
1553 ///
1554 /// # Examples
1555 ///
1556 /// Write and read `f32` numbers in little endian order:
1557 ///
1558 /// ```rust
1559 /// use byteorder::{ByteOrder, LittleEndian};
1560 ///
1561 /// let mut bytes = [0; 16];
1562 /// let numbers_given = [1.0, 2.0, 31.312e31, -11.32e19];
1563 /// LittleEndian::write_f32_into(&numbers_given, &mut bytes);
1564 ///
1565 /// let mut numbers_got = [0.0; 4];
1566 /// LittleEndian::read_f32_into(&bytes, &mut numbers_got);
1567 /// assert_eq!(numbers_given, numbers_got);
1568 /// ```
write_f32_into(src: &[f32], dst: &mut [u8])1569 fn write_f32_into(src: &[f32], dst: &mut [u8]) {
1570 let src = unsafe {
1571 slice::from_raw_parts(src.as_ptr() as *const u32, src.len())
1572 };
1573 Self::write_u32_into(src, dst);
1574 }
1575
1576 /// Writes IEEE754 double-precision (8 bytes) floating point numbers from
1577 /// `src` into `dst`.
1578 ///
1579 /// # Panics
1580 ///
1581 /// Panics when `src.len() != 8*dst.len()`.
1582 ///
1583 /// # Examples
1584 ///
1585 /// Write and read `f64` numbers in little endian order:
1586 ///
1587 /// ```rust
1588 /// use byteorder::{ByteOrder, LittleEndian};
1589 ///
1590 /// let mut bytes = [0; 32];
1591 /// let numbers_given = [1.0, 2.0, 31.312e211, -11.32e91];
1592 /// LittleEndian::write_f64_into(&numbers_given, &mut bytes);
1593 ///
1594 /// let mut numbers_got = [0.0; 4];
1595 /// LittleEndian::read_f64_into(&bytes, &mut numbers_got);
1596 /// assert_eq!(numbers_given, numbers_got);
1597 /// ```
write_f64_into(src: &[f64], dst: &mut [u8])1598 fn write_f64_into(src: &[f64], dst: &mut [u8]) {
1599 let src = unsafe {
1600 slice::from_raw_parts(src.as_ptr() as *const u64, src.len())
1601 };
1602 Self::write_u64_into(src, dst);
1603 }
1604
1605 /// Converts the given slice of unsigned 16 bit integers to a particular
1606 /// endianness.
1607 ///
1608 /// If the endianness matches the endianness of the host platform, then
1609 /// this is a no-op.
1610 ///
1611 /// # Examples
1612 ///
1613 /// Convert the host platform's endianness to big-endian:
1614 ///
1615 /// ```rust
1616 /// use byteorder::{ByteOrder, BigEndian};
1617 ///
1618 /// let mut numbers = [5, 65000];
1619 /// BigEndian::from_slice_u16(&mut numbers);
1620 /// assert_eq!(numbers, [5u16.to_be(), 65000u16.to_be()]);
1621 /// ```
from_slice_u16(numbers: &mut [u16])1622 fn from_slice_u16(numbers: &mut [u16]);
1623
1624 /// Converts the given slice of unsigned 32 bit integers to a particular
1625 /// endianness.
1626 ///
1627 /// If the endianness matches the endianness of the host platform, then
1628 /// this is a no-op.
1629 ///
1630 /// # Examples
1631 ///
1632 /// Convert the host platform's endianness to big-endian:
1633 ///
1634 /// ```rust
1635 /// use byteorder::{ByteOrder, BigEndian};
1636 ///
1637 /// let mut numbers = [5, 65000];
1638 /// BigEndian::from_slice_u32(&mut numbers);
1639 /// assert_eq!(numbers, [5u32.to_be(), 65000u32.to_be()]);
1640 /// ```
from_slice_u32(numbers: &mut [u32])1641 fn from_slice_u32(numbers: &mut [u32]);
1642
1643 /// Converts the given slice of unsigned 64 bit integers to a particular
1644 /// endianness.
1645 ///
1646 /// If the endianness matches the endianness of the host platform, then
1647 /// this is a no-op.
1648 ///
1649 /// # Examples
1650 ///
1651 /// Convert the host platform's endianness to big-endian:
1652 ///
1653 /// ```rust
1654 /// use byteorder::{ByteOrder, BigEndian};
1655 ///
1656 /// let mut numbers = [5, 65000];
1657 /// BigEndian::from_slice_u64(&mut numbers);
1658 /// assert_eq!(numbers, [5u64.to_be(), 65000u64.to_be()]);
1659 /// ```
from_slice_u64(numbers: &mut [u64])1660 fn from_slice_u64(numbers: &mut [u64]);
1661
1662 /// Converts the given slice of unsigned 128 bit integers to a particular
1663 /// endianness.
1664 ///
1665 /// If the endianness matches the endianness of the host platform, then
1666 /// this is a no-op.
1667 ///
1668 /// # Examples
1669 ///
1670 /// Convert the host platform's endianness to big-endian:
1671 ///
1672 /// ```rust
1673 /// use byteorder::{ByteOrder, BigEndian};
1674 ///
1675 /// let mut numbers = [5, 65000];
1676 /// BigEndian::from_slice_u128(&mut numbers);
1677 /// assert_eq!(numbers, [5u128.to_be(), 65000u128.to_be()]);
1678 /// ```
from_slice_u128(numbers: &mut [u128])1679 fn from_slice_u128(numbers: &mut [u128]);
1680
1681 /// Converts the given slice of signed 16 bit integers to a particular
1682 /// endianness.
1683 ///
1684 /// If the endianness matches the endianness of the host platform, then
1685 /// this is a no-op.
1686 ///
1687 /// # Examples
1688 ///
1689 /// Convert the host platform's endianness to big-endian:
1690 ///
1691 /// ```rust
1692 /// use byteorder::{ByteOrder, BigEndian};
1693 ///
1694 /// let mut numbers = [5, 6500];
1695 /// BigEndian::from_slice_i16(&mut numbers);
1696 /// assert_eq!(numbers, [5i16.to_be(), 6500i16.to_be()]);
1697 /// ```
1698 #[inline]
from_slice_i16(src: &mut [i16])1699 fn from_slice_i16(src: &mut [i16]) {
1700 let src = unsafe {
1701 slice::from_raw_parts_mut(src.as_mut_ptr() as *mut u16, src.len())
1702 };
1703 Self::from_slice_u16(src);
1704 }
1705
1706 /// Converts the given slice of signed 32 bit integers to a particular
1707 /// endianness.
1708 ///
1709 /// If the endianness matches the endianness of the host platform, then
1710 /// this is a no-op.
1711 ///
1712 /// # Examples
1713 ///
1714 /// Convert the host platform's endianness to big-endian:
1715 ///
1716 /// ```rust
1717 /// use byteorder::{ByteOrder, BigEndian};
1718 ///
1719 /// let mut numbers = [5, 65000];
1720 /// BigEndian::from_slice_i32(&mut numbers);
1721 /// assert_eq!(numbers, [5i32.to_be(), 65000i32.to_be()]);
1722 /// ```
1723 #[inline]
from_slice_i32(src: &mut [i32])1724 fn from_slice_i32(src: &mut [i32]) {
1725 let src = unsafe {
1726 slice::from_raw_parts_mut(src.as_mut_ptr() as *mut u32, src.len())
1727 };
1728 Self::from_slice_u32(src);
1729 }
1730
1731 /// Converts the given slice of signed 64 bit integers to a particular
1732 /// endianness.
1733 ///
1734 /// If the endianness matches the endianness of the host platform, then
1735 /// this is a no-op.
1736 ///
1737 /// # Examples
1738 ///
1739 /// Convert the host platform's endianness to big-endian:
1740 ///
1741 /// ```rust
1742 /// use byteorder::{ByteOrder, BigEndian};
1743 ///
1744 /// let mut numbers = [5, 65000];
1745 /// BigEndian::from_slice_i64(&mut numbers);
1746 /// assert_eq!(numbers, [5i64.to_be(), 65000i64.to_be()]);
1747 /// ```
1748 #[inline]
from_slice_i64(src: &mut [i64])1749 fn from_slice_i64(src: &mut [i64]) {
1750 let src = unsafe {
1751 slice::from_raw_parts_mut(src.as_mut_ptr() as *mut u64, src.len())
1752 };
1753 Self::from_slice_u64(src);
1754 }
1755
1756 /// Converts the given slice of signed 128 bit integers to a particular
1757 /// endianness.
1758 ///
1759 /// If the endianness matches the endianness of the host platform, then
1760 /// this is a no-op.
1761 ///
1762 /// # Examples
1763 ///
1764 /// Convert the host platform's endianness to big-endian:
1765 ///
1766 /// ```rust
1767 /// use byteorder::{ByteOrder, BigEndian};
1768 ///
1769 /// let mut numbers = [5, 65000];
1770 /// BigEndian::from_slice_i128(&mut numbers);
1771 /// assert_eq!(numbers, [5i128.to_be(), 65000i128.to_be()]);
1772 /// ```
1773 #[inline]
from_slice_i128(src: &mut [i128])1774 fn from_slice_i128(src: &mut [i128]) {
1775 let src = unsafe {
1776 slice::from_raw_parts_mut(src.as_mut_ptr() as *mut u128, src.len())
1777 };
1778 Self::from_slice_u128(src);
1779 }
1780
1781 /// Converts the given slice of IEEE754 single-precision (4 bytes) floating
1782 /// point numbers to a particular endianness.
1783 ///
1784 /// If the endianness matches the endianness of the host platform, then
1785 /// this is a no-op.
from_slice_f32(numbers: &mut [f32])1786 fn from_slice_f32(numbers: &mut [f32]);
1787
1788 /// Converts the given slice of IEEE754 double-precision (8 bytes) floating
1789 /// point numbers to a particular endianness.
1790 ///
1791 /// If the endianness matches the endianness of the host platform, then
1792 /// this is a no-op.
from_slice_f64(numbers: &mut [f64])1793 fn from_slice_f64(numbers: &mut [f64]);
1794 }
1795
1796 /// Defines big-endian serialization.
1797 ///
1798 /// Note that this type has no value constructor. It is used purely at the
1799 /// type level.
1800 ///
1801 /// # Examples
1802 ///
1803 /// Write and read `u32` numbers in big endian order:
1804 ///
1805 /// ```rust
1806 /// use byteorder::{ByteOrder, BigEndian};
1807 ///
1808 /// let mut buf = [0; 4];
1809 /// BigEndian::write_u32(&mut buf, 1_000_000);
1810 /// assert_eq!(1_000_000, BigEndian::read_u32(&buf));
1811 /// ```
1812 #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1813 pub enum BigEndian {}
1814
1815 impl Default for BigEndian {
default() -> BigEndian1816 fn default() -> BigEndian {
1817 panic!("BigEndian default")
1818 }
1819 }
1820
1821 /// A type alias for [`BigEndian`].
1822 ///
1823 /// [`BigEndian`]: enum.BigEndian.html
1824 pub type BE = BigEndian;
1825
1826 /// Defines little-endian serialization.
1827 ///
1828 /// Note that this type has no value constructor. It is used purely at the
1829 /// type level.
1830 ///
1831 /// # Examples
1832 ///
1833 /// Write and read `u32` numbers in little endian order:
1834 ///
1835 /// ```rust
1836 /// use byteorder::{ByteOrder, LittleEndian};
1837 ///
1838 /// let mut buf = [0; 4];
1839 /// LittleEndian::write_u32(&mut buf, 1_000_000);
1840 /// assert_eq!(1_000_000, LittleEndian::read_u32(&buf));
1841 /// ```
1842 #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1843 pub enum LittleEndian {}
1844
1845 impl Default for LittleEndian {
default() -> LittleEndian1846 fn default() -> LittleEndian {
1847 panic!("LittleEndian default")
1848 }
1849 }
1850
1851 /// A type alias for [`LittleEndian`].
1852 ///
1853 /// [`LittleEndian`]: enum.LittleEndian.html
1854 pub type LE = LittleEndian;
1855
1856 /// Defines network byte order serialization.
1857 ///
1858 /// Network byte order is defined by [RFC 1700][1] to be big-endian, and is
1859 /// referred to in several protocol specifications. This type is an alias of
1860 /// [`BigEndian`].
1861 ///
1862 /// [1]: https://tools.ietf.org/html/rfc1700
1863 ///
1864 /// Note that this type has no value constructor. It is used purely at the
1865 /// type level.
1866 ///
1867 /// # Examples
1868 ///
1869 /// Write and read `i16` numbers in big endian order:
1870 ///
1871 /// ```rust
1872 /// use byteorder::{ByteOrder, NetworkEndian, BigEndian};
1873 ///
1874 /// let mut buf = [0; 2];
1875 /// BigEndian::write_i16(&mut buf, -5_000);
1876 /// assert_eq!(-5_000, NetworkEndian::read_i16(&buf));
1877 /// ```
1878 ///
1879 /// [`BigEndian`]: enum.BigEndian.html
1880 pub type NetworkEndian = BigEndian;
1881
1882 /// Defines system native-endian serialization.
1883 ///
1884 /// Note that this type has no value constructor. It is used purely at the
1885 /// type level.
1886 ///
1887 /// On this platform, this is an alias for [`LittleEndian`].
1888 ///
1889 /// [`LittleEndian`]: enum.LittleEndian.html
1890 #[cfg(target_endian = "little")]
1891 pub type NativeEndian = LittleEndian;
1892
1893 /// Defines system native-endian serialization.
1894 ///
1895 /// Note that this type has no value constructor. It is used purely at the
1896 /// type level.
1897 ///
1898 /// On this platform, this is an alias for [`BigEndian`].
1899 ///
1900 /// [`BigEndian`]: enum.BigEndian.html
1901 #[cfg(target_endian = "big")]
1902 pub type NativeEndian = BigEndian;
1903
1904 /// Copies a &[u8] $src into a &mut [$ty] $dst for the endianness given by
1905 /// $from_bytes (must be either from_be_bytes or from_le_bytes).
1906 ///
1907 /// Panics if $src.len() != $dst.len() * size_of::<$ty>().
1908 macro_rules! read_slice {
1909 ($src:expr, $dst:expr, $ty:ty, $from_bytes:ident) => {{
1910 const SIZE: usize = core::mem::size_of::<$ty>();
1911 // Check types:
1912 let src: &[u8] = $src;
1913 let dst: &mut [$ty] = $dst;
1914 assert_eq!(src.len(), dst.len() * SIZE);
1915 for (src, dst) in src.chunks_exact(SIZE).zip(dst.iter_mut()) {
1916 *dst = <$ty>::$from_bytes(src.try_into().unwrap());
1917 }
1918 }};
1919 }
1920
1921 /// Copies a &[$ty] $src into a &mut [u8] $dst for the endianness given by
1922 /// $from_bytes (must be either from_be_bytes or from_le_bytes).
1923 ///
1924 /// Panics if $src.len() * size_of::<$ty>() != $dst.len().
1925 macro_rules! write_slice {
1926 ($src:expr, $dst:expr, $ty:ty, $to_bytes:ident) => {{
1927 const SIZE: usize = core::mem::size_of::<$ty>();
1928 // Check types:
1929 let src: &[$ty] = $src;
1930 let dst: &mut [u8] = $dst;
1931 assert_eq!(src.len() * SIZE, dst.len());
1932 for (src, dst) in src.iter().zip(dst.chunks_exact_mut(SIZE)) {
1933 dst.copy_from_slice(&src.$to_bytes());
1934 }
1935 }};
1936 }
1937
1938 impl ByteOrder for BigEndian {
1939 #[inline]
read_u16(buf: &[u8]) -> u161940 fn read_u16(buf: &[u8]) -> u16 {
1941 u16::from_be_bytes(buf[..2].try_into().unwrap())
1942 }
1943
1944 #[inline]
read_u32(buf: &[u8]) -> u321945 fn read_u32(buf: &[u8]) -> u32 {
1946 u32::from_be_bytes(buf[..4].try_into().unwrap())
1947 }
1948
1949 #[inline]
read_u64(buf: &[u8]) -> u641950 fn read_u64(buf: &[u8]) -> u64 {
1951 u64::from_be_bytes(buf[..8].try_into().unwrap())
1952 }
1953
1954 #[inline]
read_u128(buf: &[u8]) -> u1281955 fn read_u128(buf: &[u8]) -> u128 {
1956 u128::from_be_bytes(buf[..16].try_into().unwrap())
1957 }
1958
1959 #[inline]
read_uint(buf: &[u8], nbytes: usize) -> u641960 fn read_uint(buf: &[u8], nbytes: usize) -> u64 {
1961 let mut out = [0; 8];
1962 assert!(1 <= nbytes && nbytes <= out.len() && nbytes <= buf.len());
1963 let start = out.len() - nbytes;
1964 out[start..].copy_from_slice(&buf[..nbytes]);
1965 u64::from_be_bytes(out)
1966 }
1967
1968 #[inline]
read_uint128(buf: &[u8], nbytes: usize) -> u1281969 fn read_uint128(buf: &[u8], nbytes: usize) -> u128 {
1970 let mut out = [0; 16];
1971 assert!(1 <= nbytes && nbytes <= out.len() && nbytes <= buf.len());
1972 let start = out.len() - nbytes;
1973 out[start..].copy_from_slice(&buf[..nbytes]);
1974 u128::from_be_bytes(out)
1975 }
1976
1977 #[inline]
write_u16(buf: &mut [u8], n: u16)1978 fn write_u16(buf: &mut [u8], n: u16) {
1979 buf[..2].copy_from_slice(&n.to_be_bytes());
1980 }
1981
1982 #[inline]
write_u32(buf: &mut [u8], n: u32)1983 fn write_u32(buf: &mut [u8], n: u32) {
1984 buf[..4].copy_from_slice(&n.to_be_bytes());
1985 }
1986
1987 #[inline]
write_u64(buf: &mut [u8], n: u64)1988 fn write_u64(buf: &mut [u8], n: u64) {
1989 buf[..8].copy_from_slice(&n.to_be_bytes());
1990 }
1991
1992 #[inline]
write_u128(buf: &mut [u8], n: u128)1993 fn write_u128(buf: &mut [u8], n: u128) {
1994 buf[..16].copy_from_slice(&n.to_be_bytes());
1995 }
1996
1997 #[inline]
write_uint(buf: &mut [u8], n: u64, nbytes: usize)1998 fn write_uint(buf: &mut [u8], n: u64, nbytes: usize) {
1999 assert!(pack_size(n) <= nbytes && nbytes <= 8);
2000 assert!(nbytes <= buf.len());
2001 unsafe {
2002 let bytes = *(&n.to_be() as *const u64 as *const [u8; 8]);
2003 copy_nonoverlapping(
2004 bytes.as_ptr().offset((8 - nbytes) as isize),
2005 buf.as_mut_ptr(),
2006 nbytes,
2007 );
2008 }
2009 }
2010
2011 #[inline]
write_uint128(buf: &mut [u8], n: u128, nbytes: usize)2012 fn write_uint128(buf: &mut [u8], n: u128, nbytes: usize) {
2013 assert!(pack_size128(n) <= nbytes && nbytes <= 16);
2014 assert!(nbytes <= buf.len());
2015 unsafe {
2016 let bytes = *(&n.to_be() as *const u128 as *const [u8; 16]);
2017 copy_nonoverlapping(
2018 bytes.as_ptr().offset((16 - nbytes) as isize),
2019 buf.as_mut_ptr(),
2020 nbytes,
2021 );
2022 }
2023 }
2024
2025 #[inline]
read_u16_into(src: &[u8], dst: &mut [u16])2026 fn read_u16_into(src: &[u8], dst: &mut [u16]) {
2027 read_slice!(src, dst, u16, from_be_bytes);
2028 }
2029
2030 #[inline]
read_u32_into(src: &[u8], dst: &mut [u32])2031 fn read_u32_into(src: &[u8], dst: &mut [u32]) {
2032 read_slice!(src, dst, u32, from_be_bytes);
2033 }
2034
2035 #[inline]
read_u64_into(src: &[u8], dst: &mut [u64])2036 fn read_u64_into(src: &[u8], dst: &mut [u64]) {
2037 read_slice!(src, dst, u64, from_be_bytes);
2038 }
2039
2040 #[inline]
read_u128_into(src: &[u8], dst: &mut [u128])2041 fn read_u128_into(src: &[u8], dst: &mut [u128]) {
2042 read_slice!(src, dst, u128, from_be_bytes);
2043 }
2044
2045 #[inline]
write_u16_into(src: &[u16], dst: &mut [u8])2046 fn write_u16_into(src: &[u16], dst: &mut [u8]) {
2047 write_slice!(src, dst, u16, to_be_bytes);
2048 }
2049
2050 #[inline]
write_u32_into(src: &[u32], dst: &mut [u8])2051 fn write_u32_into(src: &[u32], dst: &mut [u8]) {
2052 write_slice!(src, dst, u32, to_be_bytes);
2053 }
2054
2055 #[inline]
write_u64_into(src: &[u64], dst: &mut [u8])2056 fn write_u64_into(src: &[u64], dst: &mut [u8]) {
2057 write_slice!(src, dst, u64, to_be_bytes);
2058 }
2059
2060 #[inline]
write_u128_into(src: &[u128], dst: &mut [u8])2061 fn write_u128_into(src: &[u128], dst: &mut [u8]) {
2062 write_slice!(src, dst, u128, to_be_bytes);
2063 }
2064
2065 #[inline]
from_slice_u16(numbers: &mut [u16])2066 fn from_slice_u16(numbers: &mut [u16]) {
2067 if cfg!(target_endian = "little") {
2068 for n in numbers {
2069 *n = n.to_be();
2070 }
2071 }
2072 }
2073
2074 #[inline]
from_slice_u32(numbers: &mut [u32])2075 fn from_slice_u32(numbers: &mut [u32]) {
2076 if cfg!(target_endian = "little") {
2077 for n in numbers {
2078 *n = n.to_be();
2079 }
2080 }
2081 }
2082
2083 #[inline]
from_slice_u64(numbers: &mut [u64])2084 fn from_slice_u64(numbers: &mut [u64]) {
2085 if cfg!(target_endian = "little") {
2086 for n in numbers {
2087 *n = n.to_be();
2088 }
2089 }
2090 }
2091
2092 #[inline]
from_slice_u128(numbers: &mut [u128])2093 fn from_slice_u128(numbers: &mut [u128]) {
2094 if cfg!(target_endian = "little") {
2095 for n in numbers {
2096 *n = n.to_be();
2097 }
2098 }
2099 }
2100
2101 #[inline]
from_slice_f32(numbers: &mut [f32])2102 fn from_slice_f32(numbers: &mut [f32]) {
2103 if cfg!(target_endian = "little") {
2104 for n in numbers {
2105 unsafe {
2106 let int = *(n as *const f32 as *const u32);
2107 *n = *(&int.to_be() as *const u32 as *const f32);
2108 }
2109 }
2110 }
2111 }
2112
2113 #[inline]
from_slice_f64(numbers: &mut [f64])2114 fn from_slice_f64(numbers: &mut [f64]) {
2115 if cfg!(target_endian = "little") {
2116 for n in numbers {
2117 unsafe {
2118 let int = *(n as *const f64 as *const u64);
2119 *n = *(&int.to_be() as *const u64 as *const f64);
2120 }
2121 }
2122 }
2123 }
2124 }
2125
2126 impl ByteOrder for LittleEndian {
2127 #[inline]
read_u16(buf: &[u8]) -> u162128 fn read_u16(buf: &[u8]) -> u16 {
2129 u16::from_le_bytes(buf[..2].try_into().unwrap())
2130 }
2131
2132 #[inline]
read_u32(buf: &[u8]) -> u322133 fn read_u32(buf: &[u8]) -> u32 {
2134 u32::from_le_bytes(buf[..4].try_into().unwrap())
2135 }
2136
2137 #[inline]
read_u64(buf: &[u8]) -> u642138 fn read_u64(buf: &[u8]) -> u64 {
2139 u64::from_le_bytes(buf[..8].try_into().unwrap())
2140 }
2141
2142 #[inline]
read_u128(buf: &[u8]) -> u1282143 fn read_u128(buf: &[u8]) -> u128 {
2144 u128::from_le_bytes(buf[..16].try_into().unwrap())
2145 }
2146
2147 #[inline]
read_uint(buf: &[u8], nbytes: usize) -> u642148 fn read_uint(buf: &[u8], nbytes: usize) -> u64 {
2149 let mut out = [0; 8];
2150 assert!(1 <= nbytes && nbytes <= out.len() && nbytes <= buf.len());
2151 out[..nbytes].copy_from_slice(&buf[..nbytes]);
2152 u64::from_le_bytes(out)
2153 }
2154
2155 #[inline]
read_uint128(buf: &[u8], nbytes: usize) -> u1282156 fn read_uint128(buf: &[u8], nbytes: usize) -> u128 {
2157 let mut out = [0; 16];
2158 assert!(1 <= nbytes && nbytes <= out.len() && nbytes <= buf.len());
2159 out[..nbytes].copy_from_slice(&buf[..nbytes]);
2160 u128::from_le_bytes(out)
2161 }
2162
2163 #[inline]
write_u16(buf: &mut [u8], n: u16)2164 fn write_u16(buf: &mut [u8], n: u16) {
2165 buf[..2].copy_from_slice(&n.to_le_bytes());
2166 }
2167
2168 #[inline]
write_u32(buf: &mut [u8], n: u32)2169 fn write_u32(buf: &mut [u8], n: u32) {
2170 buf[..4].copy_from_slice(&n.to_le_bytes());
2171 }
2172
2173 #[inline]
write_u64(buf: &mut [u8], n: u64)2174 fn write_u64(buf: &mut [u8], n: u64) {
2175 buf[..8].copy_from_slice(&n.to_le_bytes());
2176 }
2177
2178 #[inline]
write_u128(buf: &mut [u8], n: u128)2179 fn write_u128(buf: &mut [u8], n: u128) {
2180 buf[..16].copy_from_slice(&n.to_le_bytes());
2181 }
2182
2183 #[inline]
write_uint(buf: &mut [u8], n: u64, nbytes: usize)2184 fn write_uint(buf: &mut [u8], n: u64, nbytes: usize) {
2185 assert!(pack_size(n as u64) <= nbytes && nbytes <= 8);
2186 assert!(nbytes <= buf.len());
2187 unsafe {
2188 let bytes = *(&n.to_le() as *const u64 as *const [u8; 8]);
2189 copy_nonoverlapping(bytes.as_ptr(), buf.as_mut_ptr(), nbytes);
2190 }
2191 }
2192
2193 #[inline]
write_uint128(buf: &mut [u8], n: u128, nbytes: usize)2194 fn write_uint128(buf: &mut [u8], n: u128, nbytes: usize) {
2195 assert!(pack_size128(n as u128) <= nbytes && nbytes <= 16);
2196 assert!(nbytes <= buf.len());
2197 unsafe {
2198 let bytes = *(&n.to_le() as *const u128 as *const [u8; 16]);
2199 copy_nonoverlapping(bytes.as_ptr(), buf.as_mut_ptr(), nbytes);
2200 }
2201 }
2202
2203 #[inline]
read_u16_into(src: &[u8], dst: &mut [u16])2204 fn read_u16_into(src: &[u8], dst: &mut [u16]) {
2205 read_slice!(src, dst, u16, from_le_bytes);
2206 }
2207
2208 #[inline]
read_u32_into(src: &[u8], dst: &mut [u32])2209 fn read_u32_into(src: &[u8], dst: &mut [u32]) {
2210 read_slice!(src, dst, u32, from_le_bytes);
2211 }
2212
2213 #[inline]
read_u64_into(src: &[u8], dst: &mut [u64])2214 fn read_u64_into(src: &[u8], dst: &mut [u64]) {
2215 read_slice!(src, dst, u64, from_le_bytes);
2216 }
2217
2218 #[inline]
read_u128_into(src: &[u8], dst: &mut [u128])2219 fn read_u128_into(src: &[u8], dst: &mut [u128]) {
2220 read_slice!(src, dst, u128, from_le_bytes);
2221 }
2222
2223 #[inline]
write_u16_into(src: &[u16], dst: &mut [u8])2224 fn write_u16_into(src: &[u16], dst: &mut [u8]) {
2225 write_slice!(src, dst, u16, to_le_bytes);
2226 }
2227
2228 #[inline]
write_u32_into(src: &[u32], dst: &mut [u8])2229 fn write_u32_into(src: &[u32], dst: &mut [u8]) {
2230 write_slice!(src, dst, u32, to_le_bytes);
2231 }
2232
2233 #[inline]
write_u64_into(src: &[u64], dst: &mut [u8])2234 fn write_u64_into(src: &[u64], dst: &mut [u8]) {
2235 write_slice!(src, dst, u64, to_le_bytes);
2236 }
2237
2238 #[inline]
write_u128_into(src: &[u128], dst: &mut [u8])2239 fn write_u128_into(src: &[u128], dst: &mut [u8]) {
2240 write_slice!(src, dst, u128, to_le_bytes);
2241 }
2242
2243 #[inline]
from_slice_u16(numbers: &mut [u16])2244 fn from_slice_u16(numbers: &mut [u16]) {
2245 if cfg!(target_endian = "big") {
2246 for n in numbers {
2247 *n = n.to_le();
2248 }
2249 }
2250 }
2251
2252 #[inline]
from_slice_u32(numbers: &mut [u32])2253 fn from_slice_u32(numbers: &mut [u32]) {
2254 if cfg!(target_endian = "big") {
2255 for n in numbers {
2256 *n = n.to_le();
2257 }
2258 }
2259 }
2260
2261 #[inline]
from_slice_u64(numbers: &mut [u64])2262 fn from_slice_u64(numbers: &mut [u64]) {
2263 if cfg!(target_endian = "big") {
2264 for n in numbers {
2265 *n = n.to_le();
2266 }
2267 }
2268 }
2269
2270 #[inline]
from_slice_u128(numbers: &mut [u128])2271 fn from_slice_u128(numbers: &mut [u128]) {
2272 if cfg!(target_endian = "big") {
2273 for n in numbers {
2274 *n = n.to_le();
2275 }
2276 }
2277 }
2278
2279 #[inline]
from_slice_f32(numbers: &mut [f32])2280 fn from_slice_f32(numbers: &mut [f32]) {
2281 if cfg!(target_endian = "big") {
2282 for n in numbers {
2283 unsafe {
2284 let int = *(n as *const f32 as *const u32);
2285 *n = *(&int.to_le() as *const u32 as *const f32);
2286 }
2287 }
2288 }
2289 }
2290
2291 #[inline]
from_slice_f64(numbers: &mut [f64])2292 fn from_slice_f64(numbers: &mut [f64]) {
2293 if cfg!(target_endian = "big") {
2294 for n in numbers {
2295 unsafe {
2296 let int = *(n as *const f64 as *const u64);
2297 *n = *(&int.to_le() as *const u64 as *const f64);
2298 }
2299 }
2300 }
2301 }
2302 }
2303
2304 #[cfg(test)]
2305 mod test {
2306 use quickcheck::{Arbitrary, Gen, QuickCheck, StdGen, Testable};
2307 use rand::{thread_rng, Rng};
2308
2309 pub const U24_MAX: u32 = 16_777_215;
2310 pub const I24_MAX: i32 = 8_388_607;
2311 pub const U48_MAX: u64 = 281_474_976_710_655;
2312 pub const I48_MAX: i64 = 140_737_488_355_327;
2313
2314 pub const U64_MAX: u64 = ::core::u64::MAX;
2315 pub const I64_MAX: u64 = ::core::i64::MAX as u64;
2316
2317 macro_rules! calc_max {
2318 ($max:expr, $bytes:expr) => {
2319 calc_max!($max, $bytes, 8)
2320 };
2321 ($max:expr, $bytes:expr, $maxbytes:expr) => {
2322 ($max - 1) >> (8 * ($maxbytes - $bytes))
2323 };
2324 }
2325
2326 #[derive(Clone, Debug)]
2327 pub struct Wi128<T>(pub T);
2328
2329 impl<T: Clone> Wi128<T> {
clone(&self) -> T2330 pub fn clone(&self) -> T {
2331 self.0.clone()
2332 }
2333 }
2334
2335 impl<T: PartialEq> PartialEq<T> for Wi128<T> {
eq(&self, other: &T) -> bool2336 fn eq(&self, other: &T) -> bool {
2337 self.0.eq(other)
2338 }
2339 }
2340
2341 impl Arbitrary for Wi128<u128> {
arbitrary<G: Gen>(gen: &mut G) -> Wi128<u128>2342 fn arbitrary<G: Gen>(gen: &mut G) -> Wi128<u128> {
2343 let max = calc_max!(::core::u128::MAX, gen.size(), 16);
2344 let output = (gen.gen::<u64>() as u128)
2345 | ((gen.gen::<u64>() as u128) << 64);
2346 Wi128(output & (max - 1))
2347 }
2348 }
2349
2350 impl Arbitrary for Wi128<i128> {
arbitrary<G: Gen>(gen: &mut G) -> Wi128<i128>2351 fn arbitrary<G: Gen>(gen: &mut G) -> Wi128<i128> {
2352 let max = calc_max!(::core::i128::MAX, gen.size(), 16);
2353 let output = (gen.gen::<i64>() as i128)
2354 | ((gen.gen::<i64>() as i128) << 64);
2355 Wi128(output & (max - 1))
2356 }
2357 }
2358
qc_sized<A: Testable>(f: A, size: u64)2359 pub fn qc_sized<A: Testable>(f: A, size: u64) {
2360 QuickCheck::new()
2361 .gen(StdGen::new(thread_rng(), size as usize))
2362 .tests(1_00)
2363 .max_tests(10_000)
2364 .quickcheck(f);
2365 }
2366
2367 macro_rules! qc_byte_order {
2368 ($name:ident, $ty_int:ty, $max:expr,
2369 $bytes:expr, $read:ident, $write:ident) => {
2370 #[cfg(not(miri))]
2371 mod $name {
2372 #[allow(unused_imports)]
2373 use super::{qc_sized, Wi128};
2374 use crate::{
2375 BigEndian, ByteOrder, LittleEndian, NativeEndian,
2376 };
2377
2378 #[test]
2379 fn big_endian() {
2380 fn prop(n: $ty_int) -> bool {
2381 let mut buf = [0; 16];
2382 BigEndian::$write(&mut buf, n.clone(), $bytes);
2383 n == BigEndian::$read(&buf[..$bytes], $bytes)
2384 }
2385 qc_sized(prop as fn($ty_int) -> bool, $max);
2386 }
2387
2388 #[test]
2389 fn little_endian() {
2390 fn prop(n: $ty_int) -> bool {
2391 let mut buf = [0; 16];
2392 LittleEndian::$write(&mut buf, n.clone(), $bytes);
2393 n == LittleEndian::$read(&buf[..$bytes], $bytes)
2394 }
2395 qc_sized(prop as fn($ty_int) -> bool, $max);
2396 }
2397
2398 #[test]
2399 fn native_endian() {
2400 fn prop(n: $ty_int) -> bool {
2401 let mut buf = [0; 16];
2402 NativeEndian::$write(&mut buf, n.clone(), $bytes);
2403 n == NativeEndian::$read(&buf[..$bytes], $bytes)
2404 }
2405 qc_sized(prop as fn($ty_int) -> bool, $max);
2406 }
2407 }
2408 };
2409 ($name:ident, $ty_int:ty, $max:expr,
2410 $read:ident, $write:ident) => {
2411 #[cfg(not(miri))]
2412 mod $name {
2413 #[allow(unused_imports)]
2414 use super::{qc_sized, Wi128};
2415 use crate::{
2416 BigEndian, ByteOrder, LittleEndian, NativeEndian,
2417 };
2418 use core::mem::size_of;
2419
2420 #[test]
2421 fn big_endian() {
2422 fn prop(n: $ty_int) -> bool {
2423 let bytes = size_of::<$ty_int>();
2424 let mut buf = [0; 16];
2425 BigEndian::$write(&mut buf[16 - bytes..], n.clone());
2426 n == BigEndian::$read(&buf[16 - bytes..])
2427 }
2428 qc_sized(prop as fn($ty_int) -> bool, $max - 1);
2429 }
2430
2431 #[test]
2432 fn little_endian() {
2433 fn prop(n: $ty_int) -> bool {
2434 let bytes = size_of::<$ty_int>();
2435 let mut buf = [0; 16];
2436 LittleEndian::$write(&mut buf[..bytes], n.clone());
2437 n == LittleEndian::$read(&buf[..bytes])
2438 }
2439 qc_sized(prop as fn($ty_int) -> bool, $max - 1);
2440 }
2441
2442 #[test]
2443 fn native_endian() {
2444 fn prop(n: $ty_int) -> bool {
2445 let bytes = size_of::<$ty_int>();
2446 let mut buf = [0; 16];
2447 NativeEndian::$write(&mut buf[..bytes], n.clone());
2448 n == NativeEndian::$read(&buf[..bytes])
2449 }
2450 qc_sized(prop as fn($ty_int) -> bool, $max - 1);
2451 }
2452 }
2453 };
2454 }
2455
2456 qc_byte_order!(
2457 prop_u16,
2458 u16,
2459 ::core::u16::MAX as u64,
2460 read_u16,
2461 write_u16
2462 );
2463 qc_byte_order!(
2464 prop_i16,
2465 i16,
2466 ::core::i16::MAX as u64,
2467 read_i16,
2468 write_i16
2469 );
2470 qc_byte_order!(
2471 prop_u24,
2472 u32,
2473 crate::test::U24_MAX as u64,
2474 read_u24,
2475 write_u24
2476 );
2477 qc_byte_order!(
2478 prop_i24,
2479 i32,
2480 crate::test::I24_MAX as u64,
2481 read_i24,
2482 write_i24
2483 );
2484 qc_byte_order!(
2485 prop_u32,
2486 u32,
2487 ::core::u32::MAX as u64,
2488 read_u32,
2489 write_u32
2490 );
2491 qc_byte_order!(
2492 prop_i32,
2493 i32,
2494 ::core::i32::MAX as u64,
2495 read_i32,
2496 write_i32
2497 );
2498 qc_byte_order!(
2499 prop_u48,
2500 u64,
2501 crate::test::U48_MAX as u64,
2502 read_u48,
2503 write_u48
2504 );
2505 qc_byte_order!(
2506 prop_i48,
2507 i64,
2508 crate::test::I48_MAX as u64,
2509 read_i48,
2510 write_i48
2511 );
2512 qc_byte_order!(
2513 prop_u64,
2514 u64,
2515 ::core::u64::MAX as u64,
2516 read_u64,
2517 write_u64
2518 );
2519 qc_byte_order!(
2520 prop_i64,
2521 i64,
2522 ::core::i64::MAX as u64,
2523 read_i64,
2524 write_i64
2525 );
2526 qc_byte_order!(
2527 prop_f32,
2528 f32,
2529 ::core::u64::MAX as u64,
2530 read_f32,
2531 write_f32
2532 );
2533 qc_byte_order!(
2534 prop_f64,
2535 f64,
2536 ::core::i64::MAX as u64,
2537 read_f64,
2538 write_f64
2539 );
2540
2541 qc_byte_order!(prop_u128, Wi128<u128>, 16 + 1, read_u128, write_u128);
2542 qc_byte_order!(prop_i128, Wi128<i128>, 16 + 1, read_i128, write_i128);
2543
2544 qc_byte_order!(
2545 prop_uint_1,
2546 u64,
2547 calc_max!(super::U64_MAX, 1),
2548 1,
2549 read_uint,
2550 write_uint
2551 );
2552 qc_byte_order!(
2553 prop_uint_2,
2554 u64,
2555 calc_max!(super::U64_MAX, 2),
2556 2,
2557 read_uint,
2558 write_uint
2559 );
2560 qc_byte_order!(
2561 prop_uint_3,
2562 u64,
2563 calc_max!(super::U64_MAX, 3),
2564 3,
2565 read_uint,
2566 write_uint
2567 );
2568 qc_byte_order!(
2569 prop_uint_4,
2570 u64,
2571 calc_max!(super::U64_MAX, 4),
2572 4,
2573 read_uint,
2574 write_uint
2575 );
2576 qc_byte_order!(
2577 prop_uint_5,
2578 u64,
2579 calc_max!(super::U64_MAX, 5),
2580 5,
2581 read_uint,
2582 write_uint
2583 );
2584 qc_byte_order!(
2585 prop_uint_6,
2586 u64,
2587 calc_max!(super::U64_MAX, 6),
2588 6,
2589 read_uint,
2590 write_uint
2591 );
2592 qc_byte_order!(
2593 prop_uint_7,
2594 u64,
2595 calc_max!(super::U64_MAX, 7),
2596 7,
2597 read_uint,
2598 write_uint
2599 );
2600 qc_byte_order!(
2601 prop_uint_8,
2602 u64,
2603 calc_max!(super::U64_MAX, 8),
2604 8,
2605 read_uint,
2606 write_uint
2607 );
2608
2609 qc_byte_order!(
2610 prop_uint128_1,
2611 Wi128<u128>,
2612 1,
2613 1,
2614 read_uint128,
2615 write_uint128
2616 );
2617 qc_byte_order!(
2618 prop_uint128_2,
2619 Wi128<u128>,
2620 2,
2621 2,
2622 read_uint128,
2623 write_uint128
2624 );
2625 qc_byte_order!(
2626 prop_uint128_3,
2627 Wi128<u128>,
2628 3,
2629 3,
2630 read_uint128,
2631 write_uint128
2632 );
2633 qc_byte_order!(
2634 prop_uint128_4,
2635 Wi128<u128>,
2636 4,
2637 4,
2638 read_uint128,
2639 write_uint128
2640 );
2641 qc_byte_order!(
2642 prop_uint128_5,
2643 Wi128<u128>,
2644 5,
2645 5,
2646 read_uint128,
2647 write_uint128
2648 );
2649 qc_byte_order!(
2650 prop_uint128_6,
2651 Wi128<u128>,
2652 6,
2653 6,
2654 read_uint128,
2655 write_uint128
2656 );
2657 qc_byte_order!(
2658 prop_uint128_7,
2659 Wi128<u128>,
2660 7,
2661 7,
2662 read_uint128,
2663 write_uint128
2664 );
2665 qc_byte_order!(
2666 prop_uint128_8,
2667 Wi128<u128>,
2668 8,
2669 8,
2670 read_uint128,
2671 write_uint128
2672 );
2673 qc_byte_order!(
2674 prop_uint128_9,
2675 Wi128<u128>,
2676 9,
2677 9,
2678 read_uint128,
2679 write_uint128
2680 );
2681 qc_byte_order!(
2682 prop_uint128_10,
2683 Wi128<u128>,
2684 10,
2685 10,
2686 read_uint128,
2687 write_uint128
2688 );
2689 qc_byte_order!(
2690 prop_uint128_11,
2691 Wi128<u128>,
2692 11,
2693 11,
2694 read_uint128,
2695 write_uint128
2696 );
2697 qc_byte_order!(
2698 prop_uint128_12,
2699 Wi128<u128>,
2700 12,
2701 12,
2702 read_uint128,
2703 write_uint128
2704 );
2705 qc_byte_order!(
2706 prop_uint128_13,
2707 Wi128<u128>,
2708 13,
2709 13,
2710 read_uint128,
2711 write_uint128
2712 );
2713 qc_byte_order!(
2714 prop_uint128_14,
2715 Wi128<u128>,
2716 14,
2717 14,
2718 read_uint128,
2719 write_uint128
2720 );
2721 qc_byte_order!(
2722 prop_uint128_15,
2723 Wi128<u128>,
2724 15,
2725 15,
2726 read_uint128,
2727 write_uint128
2728 );
2729 qc_byte_order!(
2730 prop_uint128_16,
2731 Wi128<u128>,
2732 16,
2733 16,
2734 read_uint128,
2735 write_uint128
2736 );
2737
2738 qc_byte_order!(
2739 prop_int_1,
2740 i64,
2741 calc_max!(super::I64_MAX, 1),
2742 1,
2743 read_int,
2744 write_int
2745 );
2746 qc_byte_order!(
2747 prop_int_2,
2748 i64,
2749 calc_max!(super::I64_MAX, 2),
2750 2,
2751 read_int,
2752 write_int
2753 );
2754 qc_byte_order!(
2755 prop_int_3,
2756 i64,
2757 calc_max!(super::I64_MAX, 3),
2758 3,
2759 read_int,
2760 write_int
2761 );
2762 qc_byte_order!(
2763 prop_int_4,
2764 i64,
2765 calc_max!(super::I64_MAX, 4),
2766 4,
2767 read_int,
2768 write_int
2769 );
2770 qc_byte_order!(
2771 prop_int_5,
2772 i64,
2773 calc_max!(super::I64_MAX, 5),
2774 5,
2775 read_int,
2776 write_int
2777 );
2778 qc_byte_order!(
2779 prop_int_6,
2780 i64,
2781 calc_max!(super::I64_MAX, 6),
2782 6,
2783 read_int,
2784 write_int
2785 );
2786 qc_byte_order!(
2787 prop_int_7,
2788 i64,
2789 calc_max!(super::I64_MAX, 7),
2790 7,
2791 read_int,
2792 write_int
2793 );
2794 qc_byte_order!(
2795 prop_int_8,
2796 i64,
2797 calc_max!(super::I64_MAX, 8),
2798 8,
2799 read_int,
2800 write_int
2801 );
2802
2803 qc_byte_order!(
2804 prop_int128_1,
2805 Wi128<i128>,
2806 1,
2807 1,
2808 read_int128,
2809 write_int128
2810 );
2811 qc_byte_order!(
2812 prop_int128_2,
2813 Wi128<i128>,
2814 2,
2815 2,
2816 read_int128,
2817 write_int128
2818 );
2819 qc_byte_order!(
2820 prop_int128_3,
2821 Wi128<i128>,
2822 3,
2823 3,
2824 read_int128,
2825 write_int128
2826 );
2827 qc_byte_order!(
2828 prop_int128_4,
2829 Wi128<i128>,
2830 4,
2831 4,
2832 read_int128,
2833 write_int128
2834 );
2835 qc_byte_order!(
2836 prop_int128_5,
2837 Wi128<i128>,
2838 5,
2839 5,
2840 read_int128,
2841 write_int128
2842 );
2843 qc_byte_order!(
2844 prop_int128_6,
2845 Wi128<i128>,
2846 6,
2847 6,
2848 read_int128,
2849 write_int128
2850 );
2851 qc_byte_order!(
2852 prop_int128_7,
2853 Wi128<i128>,
2854 7,
2855 7,
2856 read_int128,
2857 write_int128
2858 );
2859 qc_byte_order!(
2860 prop_int128_8,
2861 Wi128<i128>,
2862 8,
2863 8,
2864 read_int128,
2865 write_int128
2866 );
2867 qc_byte_order!(
2868 prop_int128_9,
2869 Wi128<i128>,
2870 9,
2871 9,
2872 read_int128,
2873 write_int128
2874 );
2875 qc_byte_order!(
2876 prop_int128_10,
2877 Wi128<i128>,
2878 10,
2879 10,
2880 read_int128,
2881 write_int128
2882 );
2883 qc_byte_order!(
2884 prop_int128_11,
2885 Wi128<i128>,
2886 11,
2887 11,
2888 read_int128,
2889 write_int128
2890 );
2891 qc_byte_order!(
2892 prop_int128_12,
2893 Wi128<i128>,
2894 12,
2895 12,
2896 read_int128,
2897 write_int128
2898 );
2899 qc_byte_order!(
2900 prop_int128_13,
2901 Wi128<i128>,
2902 13,
2903 13,
2904 read_int128,
2905 write_int128
2906 );
2907 qc_byte_order!(
2908 prop_int128_14,
2909 Wi128<i128>,
2910 14,
2911 14,
2912 read_int128,
2913 write_int128
2914 );
2915 qc_byte_order!(
2916 prop_int128_15,
2917 Wi128<i128>,
2918 15,
2919 15,
2920 read_int128,
2921 write_int128
2922 );
2923 qc_byte_order!(
2924 prop_int128_16,
2925 Wi128<i128>,
2926 16,
2927 16,
2928 read_int128,
2929 write_int128
2930 );
2931
2932 // Test that all of the byte conversion functions panic when given a
2933 // buffer that is too small.
2934 //
2935 // These tests are critical to ensure safety, otherwise we might end up
2936 // with a buffer overflow.
2937 macro_rules! too_small {
2938 ($name:ident, $maximally_small:expr, $zero:expr,
2939 $read:ident, $write:ident) => {
2940 mod $name {
2941 use crate::{
2942 BigEndian, ByteOrder, LittleEndian, NativeEndian,
2943 };
2944
2945 #[test]
2946 #[should_panic]
2947 fn read_big_endian() {
2948 let buf = [0; $maximally_small];
2949 BigEndian::$read(&buf);
2950 }
2951
2952 #[test]
2953 #[should_panic]
2954 fn read_little_endian() {
2955 let buf = [0; $maximally_small];
2956 LittleEndian::$read(&buf);
2957 }
2958
2959 #[test]
2960 #[should_panic]
2961 fn read_native_endian() {
2962 let buf = [0; $maximally_small];
2963 NativeEndian::$read(&buf);
2964 }
2965
2966 #[test]
2967 #[should_panic]
2968 fn write_big_endian() {
2969 let mut buf = [0; $maximally_small];
2970 BigEndian::$write(&mut buf, $zero);
2971 }
2972
2973 #[test]
2974 #[should_panic]
2975 fn write_little_endian() {
2976 let mut buf = [0; $maximally_small];
2977 LittleEndian::$write(&mut buf, $zero);
2978 }
2979
2980 #[test]
2981 #[should_panic]
2982 fn write_native_endian() {
2983 let mut buf = [0; $maximally_small];
2984 NativeEndian::$write(&mut buf, $zero);
2985 }
2986 }
2987 };
2988 ($name:ident, $maximally_small:expr, $read:ident) => {
2989 mod $name {
2990 use crate::{
2991 BigEndian, ByteOrder, LittleEndian, NativeEndian,
2992 };
2993
2994 #[test]
2995 #[should_panic]
2996 fn read_big_endian() {
2997 let buf = [0; $maximally_small];
2998 BigEndian::$read(&buf, $maximally_small + 1);
2999 }
3000
3001 #[test]
3002 #[should_panic]
3003 fn read_little_endian() {
3004 let buf = [0; $maximally_small];
3005 LittleEndian::$read(&buf, $maximally_small + 1);
3006 }
3007
3008 #[test]
3009 #[should_panic]
3010 fn read_native_endian() {
3011 let buf = [0; $maximally_small];
3012 NativeEndian::$read(&buf, $maximally_small + 1);
3013 }
3014 }
3015 };
3016 }
3017
3018 too_small!(small_u16, 1, 0, read_u16, write_u16);
3019 too_small!(small_i16, 1, 0, read_i16, write_i16);
3020 too_small!(small_u32, 3, 0, read_u32, write_u32);
3021 too_small!(small_i32, 3, 0, read_i32, write_i32);
3022 too_small!(small_u64, 7, 0, read_u64, write_u64);
3023 too_small!(small_i64, 7, 0, read_i64, write_i64);
3024 too_small!(small_f32, 3, 0.0, read_f32, write_f32);
3025 too_small!(small_f64, 7, 0.0, read_f64, write_f64);
3026 too_small!(small_u128, 15, 0, read_u128, write_u128);
3027 too_small!(small_i128, 15, 0, read_i128, write_i128);
3028
3029 too_small!(small_uint_1, 1, read_uint);
3030 too_small!(small_uint_2, 2, read_uint);
3031 too_small!(small_uint_3, 3, read_uint);
3032 too_small!(small_uint_4, 4, read_uint);
3033 too_small!(small_uint_5, 5, read_uint);
3034 too_small!(small_uint_6, 6, read_uint);
3035 too_small!(small_uint_7, 7, read_uint);
3036
3037 too_small!(small_uint128_1, 1, read_uint128);
3038 too_small!(small_uint128_2, 2, read_uint128);
3039 too_small!(small_uint128_3, 3, read_uint128);
3040 too_small!(small_uint128_4, 4, read_uint128);
3041 too_small!(small_uint128_5, 5, read_uint128);
3042 too_small!(small_uint128_6, 6, read_uint128);
3043 too_small!(small_uint128_7, 7, read_uint128);
3044 too_small!(small_uint128_8, 8, read_uint128);
3045 too_small!(small_uint128_9, 9, read_uint128);
3046 too_small!(small_uint128_10, 10, read_uint128);
3047 too_small!(small_uint128_11, 11, read_uint128);
3048 too_small!(small_uint128_12, 12, read_uint128);
3049 too_small!(small_uint128_13, 13, read_uint128);
3050 too_small!(small_uint128_14, 14, read_uint128);
3051 too_small!(small_uint128_15, 15, read_uint128);
3052
3053 too_small!(small_int_1, 1, read_int);
3054 too_small!(small_int_2, 2, read_int);
3055 too_small!(small_int_3, 3, read_int);
3056 too_small!(small_int_4, 4, read_int);
3057 too_small!(small_int_5, 5, read_int);
3058 too_small!(small_int_6, 6, read_int);
3059 too_small!(small_int_7, 7, read_int);
3060
3061 too_small!(small_int128_1, 1, read_int128);
3062 too_small!(small_int128_2, 2, read_int128);
3063 too_small!(small_int128_3, 3, read_int128);
3064 too_small!(small_int128_4, 4, read_int128);
3065 too_small!(small_int128_5, 5, read_int128);
3066 too_small!(small_int128_6, 6, read_int128);
3067 too_small!(small_int128_7, 7, read_int128);
3068 too_small!(small_int128_8, 8, read_int128);
3069 too_small!(small_int128_9, 9, read_int128);
3070 too_small!(small_int128_10, 10, read_int128);
3071 too_small!(small_int128_11, 11, read_int128);
3072 too_small!(small_int128_12, 12, read_int128);
3073 too_small!(small_int128_13, 13, read_int128);
3074 too_small!(small_int128_14, 14, read_int128);
3075 too_small!(small_int128_15, 15, read_int128);
3076
3077 // Test that reading/writing slices enforces the correct lengths.
3078 macro_rules! slice_lengths {
3079 ($name:ident, $read:ident, $write:ident,
3080 $num_bytes:expr, $numbers:expr) => {
3081 mod $name {
3082 use crate::{
3083 BigEndian, ByteOrder, LittleEndian, NativeEndian,
3084 };
3085
3086 #[test]
3087 #[should_panic]
3088 fn read_big_endian() {
3089 let bytes = [0; $num_bytes];
3090 let mut numbers = $numbers;
3091 BigEndian::$read(&bytes, &mut numbers);
3092 }
3093
3094 #[test]
3095 #[should_panic]
3096 fn read_little_endian() {
3097 let bytes = [0; $num_bytes];
3098 let mut numbers = $numbers;
3099 LittleEndian::$read(&bytes, &mut numbers);
3100 }
3101
3102 #[test]
3103 #[should_panic]
3104 fn read_native_endian() {
3105 let bytes = [0; $num_bytes];
3106 let mut numbers = $numbers;
3107 NativeEndian::$read(&bytes, &mut numbers);
3108 }
3109
3110 #[test]
3111 #[should_panic]
3112 fn write_big_endian() {
3113 let mut bytes = [0; $num_bytes];
3114 let numbers = $numbers;
3115 BigEndian::$write(&numbers, &mut bytes);
3116 }
3117
3118 #[test]
3119 #[should_panic]
3120 fn write_little_endian() {
3121 let mut bytes = [0; $num_bytes];
3122 let numbers = $numbers;
3123 LittleEndian::$write(&numbers, &mut bytes);
3124 }
3125
3126 #[test]
3127 #[should_panic]
3128 fn write_native_endian() {
3129 let mut bytes = [0; $num_bytes];
3130 let numbers = $numbers;
3131 NativeEndian::$write(&numbers, &mut bytes);
3132 }
3133 }
3134 };
3135 }
3136
3137 slice_lengths!(
3138 slice_len_too_small_u16,
3139 read_u16_into,
3140 write_u16_into,
3141 3,
3142 [0, 0]
3143 );
3144 slice_lengths!(
3145 slice_len_too_big_u16,
3146 read_u16_into,
3147 write_u16_into,
3148 5,
3149 [0, 0]
3150 );
3151 slice_lengths!(
3152 slice_len_too_small_i16,
3153 read_i16_into,
3154 write_i16_into,
3155 3,
3156 [0, 0]
3157 );
3158 slice_lengths!(
3159 slice_len_too_big_i16,
3160 read_i16_into,
3161 write_i16_into,
3162 5,
3163 [0, 0]
3164 );
3165
3166 slice_lengths!(
3167 slice_len_too_small_u32,
3168 read_u32_into,
3169 write_u32_into,
3170 7,
3171 [0, 0]
3172 );
3173 slice_lengths!(
3174 slice_len_too_big_u32,
3175 read_u32_into,
3176 write_u32_into,
3177 9,
3178 [0, 0]
3179 );
3180 slice_lengths!(
3181 slice_len_too_small_i32,
3182 read_i32_into,
3183 write_i32_into,
3184 7,
3185 [0, 0]
3186 );
3187 slice_lengths!(
3188 slice_len_too_big_i32,
3189 read_i32_into,
3190 write_i32_into,
3191 9,
3192 [0, 0]
3193 );
3194
3195 slice_lengths!(
3196 slice_len_too_small_u64,
3197 read_u64_into,
3198 write_u64_into,
3199 15,
3200 [0, 0]
3201 );
3202 slice_lengths!(
3203 slice_len_too_big_u64,
3204 read_u64_into,
3205 write_u64_into,
3206 17,
3207 [0, 0]
3208 );
3209 slice_lengths!(
3210 slice_len_too_small_i64,
3211 read_i64_into,
3212 write_i64_into,
3213 15,
3214 [0, 0]
3215 );
3216 slice_lengths!(
3217 slice_len_too_big_i64,
3218 read_i64_into,
3219 write_i64_into,
3220 17,
3221 [0, 0]
3222 );
3223
3224 slice_lengths!(
3225 slice_len_too_small_u128,
3226 read_u128_into,
3227 write_u128_into,
3228 31,
3229 [0, 0]
3230 );
3231 slice_lengths!(
3232 slice_len_too_big_u128,
3233 read_u128_into,
3234 write_u128_into,
3235 33,
3236 [0, 0]
3237 );
3238 slice_lengths!(
3239 slice_len_too_small_i128,
3240 read_i128_into,
3241 write_i128_into,
3242 31,
3243 [0, 0]
3244 );
3245 slice_lengths!(
3246 slice_len_too_big_i128,
3247 read_i128_into,
3248 write_i128_into,
3249 33,
3250 [0, 0]
3251 );
3252
3253 #[test]
uint_bigger_buffer()3254 fn uint_bigger_buffer() {
3255 use crate::{ByteOrder, LittleEndian};
3256 let n = LittleEndian::read_uint(&[1, 2, 3, 4, 5, 6, 7, 8], 5);
3257 assert_eq!(n, 0x05_0403_0201);
3258 }
3259
3260 #[test]
regression173_array_impl()3261 fn regression173_array_impl() {
3262 use crate::{BigEndian, ByteOrder, LittleEndian};
3263
3264 let xs = [0; 100];
3265
3266 let x = BigEndian::read_u16(&xs);
3267 assert_eq!(x, 0);
3268 let x = BigEndian::read_u32(&xs);
3269 assert_eq!(x, 0);
3270 let x = BigEndian::read_u64(&xs);
3271 assert_eq!(x, 0);
3272 let x = BigEndian::read_u128(&xs);
3273 assert_eq!(x, 0);
3274 let x = BigEndian::read_i16(&xs);
3275 assert_eq!(x, 0);
3276 let x = BigEndian::read_i32(&xs);
3277 assert_eq!(x, 0);
3278 let x = BigEndian::read_i64(&xs);
3279 assert_eq!(x, 0);
3280 let x = BigEndian::read_i128(&xs);
3281 assert_eq!(x, 0);
3282
3283 let x = LittleEndian::read_u16(&xs);
3284 assert_eq!(x, 0);
3285 let x = LittleEndian::read_u32(&xs);
3286 assert_eq!(x, 0);
3287 let x = LittleEndian::read_u64(&xs);
3288 assert_eq!(x, 0);
3289 let x = LittleEndian::read_u128(&xs);
3290 assert_eq!(x, 0);
3291 let x = LittleEndian::read_i16(&xs);
3292 assert_eq!(x, 0);
3293 let x = LittleEndian::read_i32(&xs);
3294 assert_eq!(x, 0);
3295 let x = LittleEndian::read_i64(&xs);
3296 assert_eq!(x, 0);
3297 let x = LittleEndian::read_i128(&xs);
3298 assert_eq!(x, 0);
3299 }
3300 }
3301
3302 #[cfg(test)]
3303 #[cfg(feature = "std")]
3304 mod stdtests {
3305 extern crate quickcheck;
3306 extern crate rand;
3307
3308 use self::quickcheck::{QuickCheck, StdGen, Testable};
3309 use self::rand::thread_rng;
3310
qc_unsized<A: Testable>(f: A)3311 fn qc_unsized<A: Testable>(f: A) {
3312 QuickCheck::new()
3313 .gen(StdGen::new(thread_rng(), 16))
3314 .tests(1_00)
3315 .max_tests(10_000)
3316 .quickcheck(f);
3317 }
3318
3319 macro_rules! calc_max {
3320 ($max:expr, $bytes:expr) => {
3321 ($max - 1) >> (8 * (8 - $bytes))
3322 };
3323 }
3324
3325 macro_rules! qc_bytes_ext {
3326 ($name:ident, $ty_int:ty, $max:expr,
3327 $bytes:expr, $read:ident, $write:ident) => {
3328 #[cfg(not(miri))]
3329 mod $name {
3330 #[allow(unused_imports)]
3331 use crate::test::{qc_sized, Wi128};
3332 use crate::{
3333 BigEndian, LittleEndian, NativeEndian, ReadBytesExt,
3334 WriteBytesExt,
3335 };
3336 use std::io::Cursor;
3337
3338 #[test]
3339 fn big_endian() {
3340 fn prop(n: $ty_int) -> bool {
3341 let mut wtr = vec![];
3342 wtr.$write::<BigEndian>(n.clone()).unwrap();
3343 let offset = wtr.len() - $bytes;
3344 let mut rdr = Cursor::new(&mut wtr[offset..]);
3345 n == rdr.$read::<BigEndian>($bytes).unwrap()
3346 }
3347 qc_sized(prop as fn($ty_int) -> bool, $max);
3348 }
3349
3350 #[test]
3351 fn little_endian() {
3352 fn prop(n: $ty_int) -> bool {
3353 let mut wtr = vec![];
3354 wtr.$write::<LittleEndian>(n.clone()).unwrap();
3355 let mut rdr = Cursor::new(wtr);
3356 n == rdr.$read::<LittleEndian>($bytes).unwrap()
3357 }
3358 qc_sized(prop as fn($ty_int) -> bool, $max);
3359 }
3360
3361 #[test]
3362 fn native_endian() {
3363 fn prop(n: $ty_int) -> bool {
3364 let mut wtr = vec![];
3365 wtr.$write::<NativeEndian>(n.clone()).unwrap();
3366 let offset = if cfg!(target_endian = "big") {
3367 wtr.len() - $bytes
3368 } else {
3369 0
3370 };
3371 let mut rdr = Cursor::new(&mut wtr[offset..]);
3372 n == rdr.$read::<NativeEndian>($bytes).unwrap()
3373 }
3374 qc_sized(prop as fn($ty_int) -> bool, $max);
3375 }
3376 }
3377 };
3378 ($name:ident, $ty_int:ty, $max:expr, $read:ident, $write:ident) => {
3379 #[cfg(not(miri))]
3380 mod $name {
3381 #[allow(unused_imports)]
3382 use crate::test::{qc_sized, Wi128};
3383 use crate::{
3384 BigEndian, LittleEndian, NativeEndian, ReadBytesExt,
3385 WriteBytesExt,
3386 };
3387 use std::io::Cursor;
3388
3389 #[test]
3390 fn big_endian() {
3391 fn prop(n: $ty_int) -> bool {
3392 let mut wtr = vec![];
3393 wtr.$write::<BigEndian>(n.clone()).unwrap();
3394 let mut rdr = Cursor::new(wtr);
3395 n == rdr.$read::<BigEndian>().unwrap()
3396 }
3397 qc_sized(prop as fn($ty_int) -> bool, $max - 1);
3398 }
3399
3400 #[test]
3401 fn little_endian() {
3402 fn prop(n: $ty_int) -> bool {
3403 let mut wtr = vec![];
3404 wtr.$write::<LittleEndian>(n.clone()).unwrap();
3405 let mut rdr = Cursor::new(wtr);
3406 n == rdr.$read::<LittleEndian>().unwrap()
3407 }
3408 qc_sized(prop as fn($ty_int) -> bool, $max - 1);
3409 }
3410
3411 #[test]
3412 fn native_endian() {
3413 fn prop(n: $ty_int) -> bool {
3414 let mut wtr = vec![];
3415 wtr.$write::<NativeEndian>(n.clone()).unwrap();
3416 let mut rdr = Cursor::new(wtr);
3417 n == rdr.$read::<NativeEndian>().unwrap()
3418 }
3419 qc_sized(prop as fn($ty_int) -> bool, $max - 1);
3420 }
3421 }
3422 };
3423 }
3424
3425 qc_bytes_ext!(
3426 prop_ext_u16,
3427 u16,
3428 ::std::u16::MAX as u64,
3429 read_u16,
3430 write_u16
3431 );
3432 qc_bytes_ext!(
3433 prop_ext_i16,
3434 i16,
3435 ::std::i16::MAX as u64,
3436 read_i16,
3437 write_i16
3438 );
3439 qc_bytes_ext!(
3440 prop_ext_u32,
3441 u32,
3442 ::std::u32::MAX as u64,
3443 read_u32,
3444 write_u32
3445 );
3446 qc_bytes_ext!(
3447 prop_ext_i32,
3448 i32,
3449 ::std::i32::MAX as u64,
3450 read_i32,
3451 write_i32
3452 );
3453 qc_bytes_ext!(
3454 prop_ext_u64,
3455 u64,
3456 ::std::u64::MAX as u64,
3457 read_u64,
3458 write_u64
3459 );
3460 qc_bytes_ext!(
3461 prop_ext_i64,
3462 i64,
3463 ::std::i64::MAX as u64,
3464 read_i64,
3465 write_i64
3466 );
3467 qc_bytes_ext!(
3468 prop_ext_f32,
3469 f32,
3470 ::std::u64::MAX as u64,
3471 read_f32,
3472 write_f32
3473 );
3474 qc_bytes_ext!(
3475 prop_ext_f64,
3476 f64,
3477 ::std::i64::MAX as u64,
3478 read_f64,
3479 write_f64
3480 );
3481
3482 qc_bytes_ext!(prop_ext_u128, Wi128<u128>, 16 + 1, read_u128, write_u128);
3483 qc_bytes_ext!(prop_ext_i128, Wi128<i128>, 16 + 1, read_i128, write_i128);
3484
3485 qc_bytes_ext!(
3486 prop_ext_uint_1,
3487 u64,
3488 calc_max!(crate::test::U64_MAX, 1),
3489 1,
3490 read_uint,
3491 write_u64
3492 );
3493 qc_bytes_ext!(
3494 prop_ext_uint_2,
3495 u64,
3496 calc_max!(crate::test::U64_MAX, 2),
3497 2,
3498 read_uint,
3499 write_u64
3500 );
3501 qc_bytes_ext!(
3502 prop_ext_uint_3,
3503 u64,
3504 calc_max!(crate::test::U64_MAX, 3),
3505 3,
3506 read_uint,
3507 write_u64
3508 );
3509 qc_bytes_ext!(
3510 prop_ext_uint_4,
3511 u64,
3512 calc_max!(crate::test::U64_MAX, 4),
3513 4,
3514 read_uint,
3515 write_u64
3516 );
3517 qc_bytes_ext!(
3518 prop_ext_uint_5,
3519 u64,
3520 calc_max!(crate::test::U64_MAX, 5),
3521 5,
3522 read_uint,
3523 write_u64
3524 );
3525 qc_bytes_ext!(
3526 prop_ext_uint_6,
3527 u64,
3528 calc_max!(crate::test::U64_MAX, 6),
3529 6,
3530 read_uint,
3531 write_u64
3532 );
3533 qc_bytes_ext!(
3534 prop_ext_uint_7,
3535 u64,
3536 calc_max!(crate::test::U64_MAX, 7),
3537 7,
3538 read_uint,
3539 write_u64
3540 );
3541 qc_bytes_ext!(
3542 prop_ext_uint_8,
3543 u64,
3544 calc_max!(crate::test::U64_MAX, 8),
3545 8,
3546 read_uint,
3547 write_u64
3548 );
3549
3550 qc_bytes_ext!(
3551 prop_ext_uint128_1,
3552 Wi128<u128>,
3553 1,
3554 1,
3555 read_uint128,
3556 write_u128
3557 );
3558 qc_bytes_ext!(
3559 prop_ext_uint128_2,
3560 Wi128<u128>,
3561 2,
3562 2,
3563 read_uint128,
3564 write_u128
3565 );
3566 qc_bytes_ext!(
3567 prop_ext_uint128_3,
3568 Wi128<u128>,
3569 3,
3570 3,
3571 read_uint128,
3572 write_u128
3573 );
3574 qc_bytes_ext!(
3575 prop_ext_uint128_4,
3576 Wi128<u128>,
3577 4,
3578 4,
3579 read_uint128,
3580 write_u128
3581 );
3582 qc_bytes_ext!(
3583 prop_ext_uint128_5,
3584 Wi128<u128>,
3585 5,
3586 5,
3587 read_uint128,
3588 write_u128
3589 );
3590 qc_bytes_ext!(
3591 prop_ext_uint128_6,
3592 Wi128<u128>,
3593 6,
3594 6,
3595 read_uint128,
3596 write_u128
3597 );
3598 qc_bytes_ext!(
3599 prop_ext_uint128_7,
3600 Wi128<u128>,
3601 7,
3602 7,
3603 read_uint128,
3604 write_u128
3605 );
3606 qc_bytes_ext!(
3607 prop_ext_uint128_8,
3608 Wi128<u128>,
3609 8,
3610 8,
3611 read_uint128,
3612 write_u128
3613 );
3614 qc_bytes_ext!(
3615 prop_ext_uint128_9,
3616 Wi128<u128>,
3617 9,
3618 9,
3619 read_uint128,
3620 write_u128
3621 );
3622 qc_bytes_ext!(
3623 prop_ext_uint128_10,
3624 Wi128<u128>,
3625 10,
3626 10,
3627 read_uint128,
3628 write_u128
3629 );
3630 qc_bytes_ext!(
3631 prop_ext_uint128_11,
3632 Wi128<u128>,
3633 11,
3634 11,
3635 read_uint128,
3636 write_u128
3637 );
3638 qc_bytes_ext!(
3639 prop_ext_uint128_12,
3640 Wi128<u128>,
3641 12,
3642 12,
3643 read_uint128,
3644 write_u128
3645 );
3646 qc_bytes_ext!(
3647 prop_ext_uint128_13,
3648 Wi128<u128>,
3649 13,
3650 13,
3651 read_uint128,
3652 write_u128
3653 );
3654 qc_bytes_ext!(
3655 prop_ext_uint128_14,
3656 Wi128<u128>,
3657 14,
3658 14,
3659 read_uint128,
3660 write_u128
3661 );
3662 qc_bytes_ext!(
3663 prop_ext_uint128_15,
3664 Wi128<u128>,
3665 15,
3666 15,
3667 read_uint128,
3668 write_u128
3669 );
3670 qc_bytes_ext!(
3671 prop_ext_uint128_16,
3672 Wi128<u128>,
3673 16,
3674 16,
3675 read_uint128,
3676 write_u128
3677 );
3678
3679 qc_bytes_ext!(
3680 prop_ext_int_1,
3681 i64,
3682 calc_max!(crate::test::I64_MAX, 1),
3683 1,
3684 read_int,
3685 write_i64
3686 );
3687 qc_bytes_ext!(
3688 prop_ext_int_2,
3689 i64,
3690 calc_max!(crate::test::I64_MAX, 2),
3691 2,
3692 read_int,
3693 write_i64
3694 );
3695 qc_bytes_ext!(
3696 prop_ext_int_3,
3697 i64,
3698 calc_max!(crate::test::I64_MAX, 3),
3699 3,
3700 read_int,
3701 write_i64
3702 );
3703 qc_bytes_ext!(
3704 prop_ext_int_4,
3705 i64,
3706 calc_max!(crate::test::I64_MAX, 4),
3707 4,
3708 read_int,
3709 write_i64
3710 );
3711 qc_bytes_ext!(
3712 prop_ext_int_5,
3713 i64,
3714 calc_max!(crate::test::I64_MAX, 5),
3715 5,
3716 read_int,
3717 write_i64
3718 );
3719 qc_bytes_ext!(
3720 prop_ext_int_6,
3721 i64,
3722 calc_max!(crate::test::I64_MAX, 6),
3723 6,
3724 read_int,
3725 write_i64
3726 );
3727 qc_bytes_ext!(
3728 prop_ext_int_7,
3729 i64,
3730 calc_max!(crate::test::I64_MAX, 1),
3731 7,
3732 read_int,
3733 write_i64
3734 );
3735 qc_bytes_ext!(
3736 prop_ext_int_8,
3737 i64,
3738 calc_max!(crate::test::I64_MAX, 8),
3739 8,
3740 read_int,
3741 write_i64
3742 );
3743
3744 qc_bytes_ext!(
3745 prop_ext_int128_1,
3746 Wi128<i128>,
3747 1,
3748 1,
3749 read_int128,
3750 write_i128
3751 );
3752 qc_bytes_ext!(
3753 prop_ext_int128_2,
3754 Wi128<i128>,
3755 2,
3756 2,
3757 read_int128,
3758 write_i128
3759 );
3760 qc_bytes_ext!(
3761 prop_ext_int128_3,
3762 Wi128<i128>,
3763 3,
3764 3,
3765 read_int128,
3766 write_i128
3767 );
3768 qc_bytes_ext!(
3769 prop_ext_int128_4,
3770 Wi128<i128>,
3771 4,
3772 4,
3773 read_int128,
3774 write_i128
3775 );
3776 qc_bytes_ext!(
3777 prop_ext_int128_5,
3778 Wi128<i128>,
3779 5,
3780 5,
3781 read_int128,
3782 write_i128
3783 );
3784 qc_bytes_ext!(
3785 prop_ext_int128_6,
3786 Wi128<i128>,
3787 6,
3788 6,
3789 read_int128,
3790 write_i128
3791 );
3792 qc_bytes_ext!(
3793 prop_ext_int128_7,
3794 Wi128<i128>,
3795 7,
3796 7,
3797 read_int128,
3798 write_i128
3799 );
3800 qc_bytes_ext!(
3801 prop_ext_int128_8,
3802 Wi128<i128>,
3803 8,
3804 8,
3805 read_int128,
3806 write_i128
3807 );
3808 qc_bytes_ext!(
3809 prop_ext_int128_9,
3810 Wi128<i128>,
3811 9,
3812 9,
3813 read_int128,
3814 write_i128
3815 );
3816 qc_bytes_ext!(
3817 prop_ext_int128_10,
3818 Wi128<i128>,
3819 10,
3820 10,
3821 read_int128,
3822 write_i128
3823 );
3824 qc_bytes_ext!(
3825 prop_ext_int128_11,
3826 Wi128<i128>,
3827 11,
3828 11,
3829 read_int128,
3830 write_i128
3831 );
3832 qc_bytes_ext!(
3833 prop_ext_int128_12,
3834 Wi128<i128>,
3835 12,
3836 12,
3837 read_int128,
3838 write_i128
3839 );
3840 qc_bytes_ext!(
3841 prop_ext_int128_13,
3842 Wi128<i128>,
3843 13,
3844 13,
3845 read_int128,
3846 write_i128
3847 );
3848 qc_bytes_ext!(
3849 prop_ext_int128_14,
3850 Wi128<i128>,
3851 14,
3852 14,
3853 read_int128,
3854 write_i128
3855 );
3856 qc_bytes_ext!(
3857 prop_ext_int128_15,
3858 Wi128<i128>,
3859 15,
3860 15,
3861 read_int128,
3862 write_i128
3863 );
3864 qc_bytes_ext!(
3865 prop_ext_int128_16,
3866 Wi128<i128>,
3867 16,
3868 16,
3869 read_int128,
3870 write_i128
3871 );
3872
3873 // Test slice serialization/deserialization.
3874 macro_rules! qc_slice {
3875 ($name:ident, $ty_int:ty, $read:ident, $write:ident, $zero:expr) => {
3876 #[cfg(not(miri))]
3877 mod $name {
3878 use super::qc_unsized;
3879 #[allow(unused_imports)]
3880 use crate::test::Wi128;
3881 use crate::{
3882 BigEndian, ByteOrder, LittleEndian, NativeEndian,
3883 };
3884 use core::mem::size_of;
3885
3886 #[test]
3887 fn big_endian() {
3888 #[allow(unused_unsafe)]
3889 fn prop(numbers: Vec<$ty_int>) -> bool {
3890 let numbers: Vec<_> =
3891 numbers.into_iter().map(|x| x.clone()).collect();
3892 let num_bytes = size_of::<$ty_int>() * numbers.len();
3893 let mut bytes = vec![0; num_bytes];
3894
3895 BigEndian::$write(&numbers, &mut bytes);
3896
3897 let mut got = vec![$zero; numbers.len()];
3898 unsafe {
3899 BigEndian::$read(&bytes, &mut got);
3900 }
3901
3902 numbers == got
3903 }
3904 qc_unsized(prop as fn(_) -> bool);
3905 }
3906
3907 #[test]
3908 fn little_endian() {
3909 #[allow(unused_unsafe)]
3910 fn prop(numbers: Vec<$ty_int>) -> bool {
3911 let numbers: Vec<_> =
3912 numbers.into_iter().map(|x| x.clone()).collect();
3913 let num_bytes = size_of::<$ty_int>() * numbers.len();
3914 let mut bytes = vec![0; num_bytes];
3915
3916 LittleEndian::$write(&numbers, &mut bytes);
3917
3918 let mut got = vec![$zero; numbers.len()];
3919 unsafe {
3920 LittleEndian::$read(&bytes, &mut got);
3921 }
3922
3923 numbers == got
3924 }
3925 qc_unsized(prop as fn(_) -> bool);
3926 }
3927
3928 #[test]
3929 fn native_endian() {
3930 #[allow(unused_unsafe)]
3931 fn prop(numbers: Vec<$ty_int>) -> bool {
3932 let numbers: Vec<_> =
3933 numbers.into_iter().map(|x| x.clone()).collect();
3934 let num_bytes = size_of::<$ty_int>() * numbers.len();
3935 let mut bytes = vec![0; num_bytes];
3936
3937 NativeEndian::$write(&numbers, &mut bytes);
3938
3939 let mut got = vec![$zero; numbers.len()];
3940 unsafe {
3941 NativeEndian::$read(&bytes, &mut got);
3942 }
3943
3944 numbers == got
3945 }
3946 qc_unsized(prop as fn(_) -> bool);
3947 }
3948 }
3949 };
3950 }
3951
3952 qc_slice!(prop_slice_u16, u16, read_u16_into, write_u16_into, 0);
3953 qc_slice!(prop_slice_i16, i16, read_i16_into, write_i16_into, 0);
3954 qc_slice!(prop_slice_u32, u32, read_u32_into, write_u32_into, 0);
3955 qc_slice!(prop_slice_i32, i32, read_i32_into, write_i32_into, 0);
3956 qc_slice!(prop_slice_u64, u64, read_u64_into, write_u64_into, 0);
3957 qc_slice!(prop_slice_i64, i64, read_i64_into, write_i64_into, 0);
3958 qc_slice!(
3959 prop_slice_u128,
3960 Wi128<u128>,
3961 read_u128_into,
3962 write_u128_into,
3963 0
3964 );
3965 qc_slice!(
3966 prop_slice_i128,
3967 Wi128<i128>,
3968 read_i128_into,
3969 write_i128_into,
3970 0
3971 );
3972
3973 qc_slice!(prop_slice_f32, f32, read_f32_into, write_f32_into, 0.0);
3974 qc_slice!(prop_slice_f64, f64, read_f64_into, write_f64_into, 0.0);
3975 }
3976