2 This crate provides convenience methods for encoding and decoding numbers in
3 either [big-endian or little-endian order].
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`].
12 An alias, [`NetworkEndian`], for [`BigEndian`] is provided to help improve
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.
21 Read unsigned 16 bit big-endian integers from a [`Read`] type:
25 use byteorder::{BigEndian, ReadBytesExt};
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
30 assert_eq!(517, rdr.read_u16::<BigEndian>().unwrap());
31 assert_eq!(768, rdr.read_u16::<BigEndian>().unwrap());
34 Write unsigned 16 bit little-endian integers to a [`Write`] type:
37 use byteorder::{LittleEndian, WriteBytesExt};
40 wtr.write_u16::<LittleEndian>(517).unwrap();
41 wtr.write_u16::<LittleEndian>(768).unwrap();
42 assert_eq!(wtr, vec![5, 2, 0, 3]);
47 This crate optionally provides support for 128 bit values (`i128` and `u128`)
48 when built with the `i128` feature enabled.
50 This crate can also be used without the standard library.
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
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
70 #![deny(missing_docs)]
71 #![cfg_attr(not(feature = "std"), no_std)]
74 convert
::TryInto
, fmt
::Debug
, hash
::Hash
, ptr
::copy_nonoverlapping
, slice
,
77 #[cfg(feature = "std")]
78 pub use crate::io
::{ReadBytesExt, WriteBytesExt}
;
80 #[cfg(feature = "std")]
84 fn extend_sign(val
: u64, nbytes
: usize) -> i64 {
85 let shift
= (8 - nbytes
) * 8;
86 (val
<< shift
) as i64 >> shift
90 fn extend_sign128(val
: u128
, nbytes
: usize) -> i128
{
91 let shift
= (16 - nbytes
) * 8;
92 (val
<< shift
) as i128
>> shift
96 fn unextend_sign(val
: i64, nbytes
: usize) -> u64 {
97 let shift
= (8 - nbytes
) * 8;
98 (val
<< shift
) as u64 >> shift
102 fn unextend_sign128(val
: i128
, nbytes
: usize) -> u128
{
103 let shift
= (16 - nbytes
) * 8;
104 (val
<< shift
) as u128
>> shift
108 fn pack_size(n
: u64) -> usize {
111 } else if n
< 1 << 16 {
113 } else if n
< 1 << 24 {
115 } else if n
< 1 << 32 {
117 } else if n
< 1 << 40 {
119 } else if n
< 1 << 48 {
121 } else if n
< 1 << 56 {
129 fn pack_size128(n
: u128
) -> usize {
132 } else if n
< 1 << 16 {
134 } else if n
< 1 << 24 {
136 } else if n
< 1 << 32 {
138 } else if n
< 1 << 40 {
140 } else if n
< 1 << 48 {
142 } else if n
< 1 << 56 {
144 } else if n
< 1 << 64 {
146 } else if n
< 1 << 72 {
148 } else if n
< 1 << 80 {
150 } else if n
< 1 << 88 {
152 } else if n
< 1 << 96 {
154 } else if n
< 1 << 104 {
156 } else if n
< 1 << 112 {
158 } else if n
< 1 << 120 {
166 /// Sealed stops crates other than byteorder from implementing any traits
169 impl Sealed
for super::LittleEndian {}
170 impl Sealed
for super::BigEndian {}
173 /// `ByteOrder` describes types that can serialize integers as bytes.
175 /// Note that `Self` does not appear anywhere in this trait's definition!
176 /// Therefore, in order to use it, you'll need to use syntax like
177 /// `T::read_u16(&[0, 1])` where `T` implements `ByteOrder`.
179 /// This crate provides two types that implement `ByteOrder`: [`BigEndian`]
180 /// and [`LittleEndian`].
181 /// This trait is sealed and cannot be implemented for callers to avoid
182 /// breaking backwards compatibility when adding new derived traits.
186 /// Write and read `u32` numbers in little endian order:
189 /// use byteorder::{ByteOrder, LittleEndian};
191 /// let mut buf = [0; 4];
192 /// LittleEndian::write_u32(&mut buf, 1_000_000);
193 /// assert_eq!(1_000_000, LittleEndian::read_u32(&buf));
196 /// Write and read `i16` numbers in big endian order:
199 /// use byteorder::{ByteOrder, BigEndian};
201 /// let mut buf = [0; 2];
202 /// BigEndian::write_i16(&mut buf, -5_000);
203 /// assert_eq!(-5_000, BigEndian::read_i16(&buf));
206 /// [`BigEndian`]: enum.BigEndian.html
207 /// [`LittleEndian`]: enum.LittleEndian.html
220 /// Reads an unsigned 16 bit integer from `buf`.
224 /// Panics when `buf.len() < 2`.
225 fn read_u16(buf
: &[u8]) -> u16;
227 /// Reads an unsigned 24 bit integer from `buf`, stored in u32.
231 /// Panics when `buf.len() < 3`.
235 /// Write and read 24 bit `u32` numbers in little endian order:
238 /// use byteorder::{ByteOrder, LittleEndian};
240 /// let mut buf = [0; 3];
241 /// LittleEndian::write_u24(&mut buf, 1_000_000);
242 /// assert_eq!(1_000_000, LittleEndian::read_u24(&buf));
244 fn read_u24(buf
: &[u8]) -> u32 {
245 Self::read_uint(buf
, 3) as u32
248 /// Reads an unsigned 32 bit integer from `buf`.
252 /// Panics when `buf.len() < 4`.
256 /// Write and read `u32` numbers in little endian order:
259 /// use byteorder::{ByteOrder, LittleEndian};
261 /// let mut buf = [0; 4];
262 /// LittleEndian::write_u32(&mut buf, 1_000_000);
263 /// assert_eq!(1_000_000, LittleEndian::read_u32(&buf));
265 fn read_u32(buf
: &[u8]) -> u32;
267 /// Reads an unsigned 48 bit integer from `buf`, stored in u64.
271 /// Panics when `buf.len() < 6`.
275 /// Write and read 48 bit `u64` numbers in little endian order:
278 /// use byteorder::{ByteOrder, LittleEndian};
280 /// let mut buf = [0; 6];
281 /// LittleEndian::write_u48(&mut buf, 1_000_000_000_000);
282 /// assert_eq!(1_000_000_000_000, LittleEndian::read_u48(&buf));
284 fn read_u48(buf
: &[u8]) -> u64 {
285 Self::read_uint(buf
, 6) as u64
288 /// Reads an unsigned 64 bit integer from `buf`.
292 /// Panics when `buf.len() < 8`.
296 /// Write and read `u64` numbers in little endian order:
299 /// use byteorder::{ByteOrder, LittleEndian};
301 /// let mut buf = [0; 8];
302 /// LittleEndian::write_u64(&mut buf, 1_000_000);
303 /// assert_eq!(1_000_000, LittleEndian::read_u64(&buf));
305 fn read_u64(buf
: &[u8]) -> u64;
307 /// Reads an unsigned 128 bit integer from `buf`.
311 /// Panics when `buf.len() < 16`.
315 /// Write and read `u128` numbers in little endian order:
318 /// use byteorder::{ByteOrder, LittleEndian};
320 /// let mut buf = [0; 16];
321 /// LittleEndian::write_u128(&mut buf, 1_000_000);
322 /// assert_eq!(1_000_000, LittleEndian::read_u128(&buf));
324 fn read_u128(buf
: &[u8]) -> u128
;
326 /// Reads an unsigned n-bytes integer from `buf`.
330 /// Panics when `nbytes < 1` or `nbytes > 8` or
331 /// `buf.len() < nbytes`
335 /// Write and read an n-byte number in little endian order:
338 /// use byteorder::{ByteOrder, LittleEndian};
340 /// let mut buf = [0; 3];
341 /// LittleEndian::write_uint(&mut buf, 1_000_000, 3);
342 /// assert_eq!(1_000_000, LittleEndian::read_uint(&buf, 3));
344 fn read_uint(buf
: &[u8], nbytes
: usize) -> u64;
346 /// Reads an unsigned n-bytes integer from `buf`.
350 /// Panics when `nbytes < 1` or `nbytes > 16` or
351 /// `buf.len() < nbytes`
355 /// Write and read an n-byte number in little endian order:
358 /// use byteorder::{ByteOrder, LittleEndian};
360 /// let mut buf = [0; 3];
361 /// LittleEndian::write_uint128(&mut buf, 1_000_000, 3);
362 /// assert_eq!(1_000_000, LittleEndian::read_uint128(&buf, 3));
364 fn read_uint128(buf
: &[u8], nbytes
: usize) -> u128
;
366 /// Writes an unsigned 16 bit integer `n` to `buf`.
370 /// Panics when `buf.len() < 2`.
374 /// Write and read `u16` numbers in little endian order:
377 /// use byteorder::{ByteOrder, LittleEndian};
379 /// let mut buf = [0; 2];
380 /// LittleEndian::write_u16(&mut buf, 1_000);
381 /// assert_eq!(1_000, LittleEndian::read_u16(&buf));
383 fn write_u16(buf
: &mut [u8], n
: u16);
385 /// Writes an unsigned 24 bit integer `n` to `buf`, stored in u32.
389 /// Panics when `buf.len() < 3`.
393 /// Write and read 24 bit `u32` numbers in little endian order:
396 /// use byteorder::{ByteOrder, LittleEndian};
398 /// let mut buf = [0; 3];
399 /// LittleEndian::write_u24(&mut buf, 1_000_000);
400 /// assert_eq!(1_000_000, LittleEndian::read_u24(&buf));
402 fn write_u24(buf
: &mut [u8], n
: u32) {
403 Self::write_uint(buf
, n
as u64, 3)
406 /// Writes an unsigned 32 bit integer `n` to `buf`.
410 /// Panics when `buf.len() < 4`.
414 /// Write and read `u32` numbers in little endian order:
417 /// use byteorder::{ByteOrder, LittleEndian};
419 /// let mut buf = [0; 4];
420 /// LittleEndian::write_u32(&mut buf, 1_000_000);
421 /// assert_eq!(1_000_000, LittleEndian::read_u32(&buf));
423 fn write_u32(buf
: &mut [u8], n
: u32);
425 /// Writes an unsigned 48 bit integer `n` to `buf`, stored in u64.
429 /// Panics when `buf.len() < 6`.
433 /// Write and read 48 bit `u64` numbers in little endian order:
436 /// use byteorder::{ByteOrder, LittleEndian};
438 /// let mut buf = [0; 6];
439 /// LittleEndian::write_u48(&mut buf, 1_000_000_000_000);
440 /// assert_eq!(1_000_000_000_000, LittleEndian::read_u48(&buf));
442 fn write_u48(buf
: &mut [u8], n
: u64) {
443 Self::write_uint(buf
, n
as u64, 6)
446 /// Writes an unsigned 64 bit integer `n` to `buf`.
450 /// Panics when `buf.len() < 8`.
454 /// Write and read `u64` numbers in little endian order:
457 /// use byteorder::{ByteOrder, LittleEndian};
459 /// let mut buf = [0; 8];
460 /// LittleEndian::write_u64(&mut buf, 1_000_000);
461 /// assert_eq!(1_000_000, LittleEndian::read_u64(&buf));
463 fn write_u64(buf
: &mut [u8], n
: u64);
465 /// Writes an unsigned 128 bit integer `n` to `buf`.
469 /// Panics when `buf.len() < 16`.
473 /// Write and read `u128` numbers in little endian order:
476 /// use byteorder::{ByteOrder, LittleEndian};
478 /// let mut buf = [0; 16];
479 /// LittleEndian::write_u128(&mut buf, 1_000_000);
480 /// assert_eq!(1_000_000, LittleEndian::read_u128(&buf));
482 fn write_u128(buf
: &mut [u8], n
: u128
);
484 /// Writes an unsigned integer `n` to `buf` using only `nbytes`.
488 /// If `n` is not representable in `nbytes`, or if `nbytes` is `> 8`, then
489 /// this method panics.
493 /// Write and read an n-byte number in little endian order:
496 /// use byteorder::{ByteOrder, LittleEndian};
498 /// let mut buf = [0; 3];
499 /// LittleEndian::write_uint(&mut buf, 1_000_000, 3);
500 /// assert_eq!(1_000_000, LittleEndian::read_uint(&buf, 3));
502 fn write_uint(buf
: &mut [u8], n
: u64, nbytes
: usize);
504 /// Writes an unsigned integer `n` to `buf` using only `nbytes`.
508 /// If `n` is not representable in `nbytes`, or if `nbytes` is `> 16`, then
509 /// this method panics.
513 /// Write and read an n-byte number in little endian order:
516 /// use byteorder::{ByteOrder, LittleEndian};
518 /// let mut buf = [0; 3];
519 /// LittleEndian::write_uint128(&mut buf, 1_000_000, 3);
520 /// assert_eq!(1_000_000, LittleEndian::read_uint128(&buf, 3));
522 fn write_uint128(buf
: &mut [u8], n
: u128
, nbytes
: usize);
524 /// Reads a signed 16 bit integer from `buf`.
528 /// Panics when `buf.len() < 2`.
532 /// Write and read `i16` numbers in little endian order:
535 /// use byteorder::{ByteOrder, LittleEndian};
537 /// let mut buf = [0; 2];
538 /// LittleEndian::write_i16(&mut buf, -1_000);
539 /// assert_eq!(-1_000, LittleEndian::read_i16(&buf));
542 fn read_i16(buf
: &[u8]) -> i16 {
543 Self::read_u16(buf
) as i16
546 /// Reads a signed 24 bit integer from `buf`, stored in i32.
550 /// Panics when `buf.len() < 3`.
554 /// Write and read 24 bit `i32` numbers in little endian order:
557 /// use byteorder::{ByteOrder, LittleEndian};
559 /// let mut buf = [0; 3];
560 /// LittleEndian::write_i24(&mut buf, -1_000_000);
561 /// assert_eq!(-1_000_000, LittleEndian::read_i24(&buf));
564 fn read_i24(buf
: &[u8]) -> i32 {
565 Self::read_int(buf
, 3) as i32
568 /// Reads a signed 32 bit integer from `buf`.
572 /// Panics when `buf.len() < 4`.
576 /// Write and read `i32` numbers in little endian order:
579 /// use byteorder::{ByteOrder, LittleEndian};
581 /// let mut buf = [0; 4];
582 /// LittleEndian::write_i32(&mut buf, -1_000_000);
583 /// assert_eq!(-1_000_000, LittleEndian::read_i32(&buf));
586 fn read_i32(buf
: &[u8]) -> i32 {
587 Self::read_u32(buf
) as i32
590 /// Reads a signed 48 bit integer from `buf`, stored in i64.
594 /// Panics when `buf.len() < 6`.
598 /// Write and read 48 bit `i64` numbers in little endian order:
601 /// use byteorder::{ByteOrder, LittleEndian};
603 /// let mut buf = [0; 6];
604 /// LittleEndian::write_i48(&mut buf, -1_000_000_000_000);
605 /// assert_eq!(-1_000_000_000_000, LittleEndian::read_i48(&buf));
608 fn read_i48(buf
: &[u8]) -> i64 {
609 Self::read_int(buf
, 6) as i64
612 /// Reads a signed 64 bit integer from `buf`.
616 /// Panics when `buf.len() < 8`.
620 /// Write and read `i64` numbers in little endian order:
623 /// use byteorder::{ByteOrder, LittleEndian};
625 /// let mut buf = [0; 8];
626 /// LittleEndian::write_i64(&mut buf, -1_000_000_000);
627 /// assert_eq!(-1_000_000_000, LittleEndian::read_i64(&buf));
630 fn read_i64(buf
: &[u8]) -> i64 {
631 Self::read_u64(buf
) as i64
634 /// Reads a signed 128 bit integer from `buf`.
638 /// Panics when `buf.len() < 16`.
642 /// Write and read `i128` numbers in little endian order:
645 /// use byteorder::{ByteOrder, LittleEndian};
647 /// let mut buf = [0; 16];
648 /// LittleEndian::write_i128(&mut buf, -1_000_000_000);
649 /// assert_eq!(-1_000_000_000, LittleEndian::read_i128(&buf));
652 fn read_i128(buf
: &[u8]) -> i128
{
653 Self::read_u128(buf
) as i128
656 /// Reads a signed n-bytes integer from `buf`.
660 /// Panics when `nbytes < 1` or `nbytes > 8` or
661 /// `buf.len() < nbytes`
665 /// Write and read n-length signed numbers in little endian order:
668 /// use byteorder::{ByteOrder, LittleEndian};
670 /// let mut buf = [0; 3];
671 /// LittleEndian::write_int(&mut buf, -1_000, 3);
672 /// assert_eq!(-1_000, LittleEndian::read_int(&buf, 3));
675 fn read_int(buf
: &[u8], nbytes
: usize) -> i64 {
676 extend_sign(Self::read_uint(buf
, nbytes
), nbytes
)
679 /// Reads a signed n-bytes integer from `buf`.
683 /// Panics when `nbytes < 1` or `nbytes > 16` or
684 /// `buf.len() < nbytes`
688 /// Write and read n-length signed numbers in little endian order:
691 /// use byteorder::{ByteOrder, LittleEndian};
693 /// let mut buf = [0; 3];
694 /// LittleEndian::write_int128(&mut buf, -1_000, 3);
695 /// assert_eq!(-1_000, LittleEndian::read_int128(&buf, 3));
698 fn read_int128(buf
: &[u8], nbytes
: usize) -> i128
{
699 extend_sign128(Self::read_uint128(buf
, nbytes
), nbytes
)
702 /// Reads a IEEE754 single-precision (4 bytes) floating point number.
706 /// Panics when `buf.len() < 4`.
710 /// Write and read `f32` numbers in little endian order:
713 /// use byteorder::{ByteOrder, LittleEndian};
716 /// let mut buf = [0; 4];
717 /// LittleEndian::write_f32(&mut buf, e);
718 /// assert_eq!(e, LittleEndian::read_f32(&buf));
721 fn read_f32(buf
: &[u8]) -> f32 {
722 f32::from_bits(Self::read_u32(buf
))
725 /// Reads a IEEE754 double-precision (8 bytes) floating point number.
729 /// Panics when `buf.len() < 8`.
733 /// Write and read `f64` numbers in little endian order:
736 /// use byteorder::{ByteOrder, LittleEndian};
738 /// let phi = 1.6180339887;
739 /// let mut buf = [0; 8];
740 /// LittleEndian::write_f64(&mut buf, phi);
741 /// assert_eq!(phi, LittleEndian::read_f64(&buf));
744 fn read_f64(buf
: &[u8]) -> f64 {
745 f64::from_bits(Self::read_u64(buf
))
748 /// Writes a signed 16 bit integer `n` to `buf`.
752 /// Panics when `buf.len() < 2`.
756 /// Write and read `i16` numbers in little endian order:
759 /// use byteorder::{ByteOrder, LittleEndian};
761 /// let mut buf = [0; 2];
762 /// LittleEndian::write_i16(&mut buf, -1_000);
763 /// assert_eq!(-1_000, LittleEndian::read_i16(&buf));
766 fn write_i16(buf
: &mut [u8], n
: i16) {
767 Self::write_u16(buf
, n
as u16)
770 /// Writes a signed 24 bit integer `n` to `buf`, stored in i32.
774 /// Panics when `buf.len() < 3`.
778 /// Write and read 24 bit `i32` numbers in little endian order:
781 /// use byteorder::{ByteOrder, LittleEndian};
783 /// let mut buf = [0; 3];
784 /// LittleEndian::write_i24(&mut buf, -1_000_000);
785 /// assert_eq!(-1_000_000, LittleEndian::read_i24(&buf));
788 fn write_i24(buf
: &mut [u8], n
: i32) {
789 Self::write_int(buf
, n
as i64, 3)
792 /// Writes a signed 32 bit integer `n` to `buf`.
796 /// Panics when `buf.len() < 4`.
800 /// Write and read `i32` numbers in little endian order:
803 /// use byteorder::{ByteOrder, LittleEndian};
805 /// let mut buf = [0; 4];
806 /// LittleEndian::write_i32(&mut buf, -1_000_000);
807 /// assert_eq!(-1_000_000, LittleEndian::read_i32(&buf));
810 fn write_i32(buf
: &mut [u8], n
: i32) {
811 Self::write_u32(buf
, n
as u32)
814 /// Writes a signed 48 bit integer `n` to `buf`, stored in i64.
818 /// Panics when `buf.len() < 6`.
822 /// Write and read 48 bit `i64` numbers in little endian order:
825 /// use byteorder::{ByteOrder, LittleEndian};
827 /// let mut buf = [0; 6];
828 /// LittleEndian::write_i48(&mut buf, -1_000_000_000_000);
829 /// assert_eq!(-1_000_000_000_000, LittleEndian::read_i48(&buf));
832 fn write_i48(buf
: &mut [u8], n
: i64) {
833 Self::write_int(buf
, n
as i64, 6)
836 /// Writes a signed 64 bit integer `n` to `buf`.
840 /// Panics when `buf.len() < 8`.
844 /// Write and read `i64` numbers in little endian order:
847 /// use byteorder::{ByteOrder, LittleEndian};
849 /// let mut buf = [0; 8];
850 /// LittleEndian::write_i64(&mut buf, -1_000_000_000);
851 /// assert_eq!(-1_000_000_000, LittleEndian::read_i64(&buf));
854 fn write_i64(buf
: &mut [u8], n
: i64) {
855 Self::write_u64(buf
, n
as u64)
858 /// Writes a signed 128 bit integer `n` to `buf`.
862 /// Panics when `buf.len() < 16`.
866 /// Write and read n-byte `i128` numbers in little endian order:
869 /// use byteorder::{ByteOrder, LittleEndian};
871 /// let mut buf = [0; 16];
872 /// LittleEndian::write_i128(&mut buf, -1_000_000_000);
873 /// assert_eq!(-1_000_000_000, LittleEndian::read_i128(&buf));
876 fn write_i128(buf
: &mut [u8], n
: i128
) {
877 Self::write_u128(buf
, n
as u128
)
880 /// Writes a signed integer `n` to `buf` using only `nbytes`.
884 /// If `n` is not representable in `nbytes`, or if `nbytes` is `> 8`, then
885 /// this method panics.
889 /// Write and read an n-byte number in little endian order:
892 /// use byteorder::{ByteOrder, LittleEndian};
894 /// let mut buf = [0; 3];
895 /// LittleEndian::write_int(&mut buf, -1_000, 3);
896 /// assert_eq!(-1_000, LittleEndian::read_int(&buf, 3));
899 fn write_int(buf
: &mut [u8], n
: i64, nbytes
: usize) {
900 Self::write_uint(buf
, unextend_sign(n
, nbytes
), nbytes
)
903 /// Writes a signed integer `n` to `buf` using only `nbytes`.
907 /// If `n` is not representable in `nbytes`, or if `nbytes` is `> 16`, then
908 /// this method panics.
912 /// Write and read n-length signed numbers in little endian order:
915 /// use byteorder::{ByteOrder, LittleEndian};
917 /// let mut buf = [0; 3];
918 /// LittleEndian::write_int128(&mut buf, -1_000, 3);
919 /// assert_eq!(-1_000, LittleEndian::read_int128(&buf, 3));
922 fn write_int128(buf
: &mut [u8], n
: i128
, nbytes
: usize) {
923 Self::write_uint128(buf
, unextend_sign128(n
, nbytes
), nbytes
)
926 /// Writes a IEEE754 single-precision (4 bytes) floating point number.
930 /// Panics when `buf.len() < 4`.
934 /// Write and read `f32` numbers in little endian order:
937 /// use byteorder::{ByteOrder, LittleEndian};
940 /// let mut buf = [0; 4];
941 /// LittleEndian::write_f32(&mut buf, e);
942 /// assert_eq!(e, LittleEndian::read_f32(&buf));
945 fn write_f32(buf
: &mut [u8], n
: f32) {
946 Self::write_u32(buf
, n
.to_bits())
949 /// Writes a IEEE754 double-precision (8 bytes) floating point number.
953 /// Panics when `buf.len() < 8`.
957 /// Write and read `f64` numbers in little endian order:
960 /// use byteorder::{ByteOrder, LittleEndian};
962 /// let phi = 1.6180339887;
963 /// let mut buf = [0; 8];
964 /// LittleEndian::write_f64(&mut buf, phi);
965 /// assert_eq!(phi, LittleEndian::read_f64(&buf));
968 fn write_f64(buf
: &mut [u8], n
: f64) {
969 Self::write_u64(buf
, n
.to_bits())
972 /// Reads unsigned 16 bit integers from `src` into `dst`.
976 /// Panics when `src.len() != 2*dst.len()`.
980 /// Write and read `u16` numbers in little endian order:
983 /// use byteorder::{ByteOrder, LittleEndian};
985 /// let mut bytes = [0; 8];
986 /// let numbers_given = [1, 2, 0xf00f, 0xffee];
987 /// LittleEndian::write_u16_into(&numbers_given, &mut bytes);
989 /// let mut numbers_got = [0; 4];
990 /// LittleEndian::read_u16_into(&bytes, &mut numbers_got);
991 /// assert_eq!(numbers_given, numbers_got);
993 fn read_u16_into(src
: &[u8], dst
: &mut [u16]);
995 /// Reads unsigned 32 bit integers from `src` into `dst`.
999 /// Panics when `src.len() != 4*dst.len()`.
1003 /// Write and read `u32` numbers in little endian order:
1006 /// use byteorder::{ByteOrder, LittleEndian};
1008 /// let mut bytes = [0; 16];
1009 /// let numbers_given = [1, 2, 0xf00f, 0xffee];
1010 /// LittleEndian::write_u32_into(&numbers_given, &mut bytes);
1012 /// let mut numbers_got = [0; 4];
1013 /// LittleEndian::read_u32_into(&bytes, &mut numbers_got);
1014 /// assert_eq!(numbers_given, numbers_got);
1016 fn read_u32_into(src
: &[u8], dst
: &mut [u32]);
1018 /// Reads unsigned 64 bit integers from `src` into `dst`.
1022 /// Panics when `src.len() != 8*dst.len()`.
1026 /// Write and read `u64` numbers in little endian order:
1029 /// use byteorder::{ByteOrder, LittleEndian};
1031 /// let mut bytes = [0; 32];
1032 /// let numbers_given = [1, 2, 0xf00f, 0xffee];
1033 /// LittleEndian::write_u64_into(&numbers_given, &mut bytes);
1035 /// let mut numbers_got = [0; 4];
1036 /// LittleEndian::read_u64_into(&bytes, &mut numbers_got);
1037 /// assert_eq!(numbers_given, numbers_got);
1039 fn read_u64_into(src
: &[u8], dst
: &mut [u64]);
1041 /// Reads unsigned 128 bit integers from `src` into `dst`.
1045 /// Panics when `src.len() != 16*dst.len()`.
1049 /// Write and read `u128` numbers in little endian order:
1052 /// use byteorder::{ByteOrder, LittleEndian};
1054 /// let mut bytes = [0; 64];
1055 /// let numbers_given = [1, 2, 0xf00f, 0xffee];
1056 /// LittleEndian::write_u128_into(&numbers_given, &mut bytes);
1058 /// let mut numbers_got = [0; 4];
1059 /// LittleEndian::read_u128_into(&bytes, &mut numbers_got);
1060 /// assert_eq!(numbers_given, numbers_got);
1062 fn read_u128_into(src
: &[u8], dst
: &mut [u128
]);
1064 /// Reads signed 16 bit integers from `src` to `dst`.
1068 /// Panics when `buf.len() != 2*dst.len()`.
1072 /// Write and read `i16` numbers in little endian order:
1075 /// use byteorder::{ByteOrder, LittleEndian};
1077 /// let mut bytes = [0; 8];
1078 /// let numbers_given = [1, 2, 0x0f, 0xee];
1079 /// LittleEndian::write_i16_into(&numbers_given, &mut bytes);
1081 /// let mut numbers_got = [0; 4];
1082 /// LittleEndian::read_i16_into(&bytes, &mut numbers_got);
1083 /// assert_eq!(numbers_given, numbers_got);
1086 fn read_i16_into(src
: &[u8], dst
: &mut [i16]) {
1088 slice
::from_raw_parts_mut(dst
.as_mut_ptr() as *mut u16, dst
.len())
1090 Self::read_u16_into(src
, dst
)
1093 /// Reads signed 32 bit integers from `src` into `dst`.
1097 /// Panics when `src.len() != 4*dst.len()`.
1101 /// Write and read `i32` numbers in little endian order:
1104 /// use byteorder::{ByteOrder, LittleEndian};
1106 /// let mut bytes = [0; 16];
1107 /// let numbers_given = [1, 2, 0xf00f, 0xffee];
1108 /// LittleEndian::write_i32_into(&numbers_given, &mut bytes);
1110 /// let mut numbers_got = [0; 4];
1111 /// LittleEndian::read_i32_into(&bytes, &mut numbers_got);
1112 /// assert_eq!(numbers_given, numbers_got);
1115 fn read_i32_into(src
: &[u8], dst
: &mut [i32]) {
1117 slice
::from_raw_parts_mut(dst
.as_mut_ptr() as *mut u32, dst
.len())
1119 Self::read_u32_into(src
, dst
);
1122 /// Reads signed 64 bit integers from `src` into `dst`.
1126 /// Panics when `src.len() != 8*dst.len()`.
1130 /// Write and read `i64` numbers in little endian order:
1133 /// use byteorder::{ByteOrder, LittleEndian};
1135 /// let mut bytes = [0; 32];
1136 /// let numbers_given = [1, 2, 0xf00f, 0xffee];
1137 /// LittleEndian::write_i64_into(&numbers_given, &mut bytes);
1139 /// let mut numbers_got = [0; 4];
1140 /// LittleEndian::read_i64_into(&bytes, &mut numbers_got);
1141 /// assert_eq!(numbers_given, numbers_got);
1144 fn read_i64_into(src
: &[u8], dst
: &mut [i64]) {
1146 slice
::from_raw_parts_mut(dst
.as_mut_ptr() as *mut u64, dst
.len())
1148 Self::read_u64_into(src
, dst
);
1151 /// Reads signed 128 bit integers from `src` into `dst`.
1155 /// Panics when `src.len() != 16*dst.len()`.
1159 /// Write and read `i128` numbers in little endian order:
1162 /// use byteorder::{ByteOrder, LittleEndian};
1164 /// let mut bytes = [0; 64];
1165 /// let numbers_given = [1, 2, 0xf00f, 0xffee];
1166 /// LittleEndian::write_i128_into(&numbers_given, &mut bytes);
1168 /// let mut numbers_got = [0; 4];
1169 /// LittleEndian::read_i128_into(&bytes, &mut numbers_got);
1170 /// assert_eq!(numbers_given, numbers_got);
1173 fn read_i128_into(src
: &[u8], dst
: &mut [i128
]) {
1175 slice
::from_raw_parts_mut(dst
.as_mut_ptr() as *mut u128
, dst
.len())
1177 Self::read_u128_into(src
, dst
);
1180 /// Reads IEEE754 single-precision (4 bytes) floating point numbers from
1181 /// `src` into `dst`.
1185 /// Panics when `src.len() != 4*dst.len()`.
1189 /// Write and read `f32` numbers in little endian order:
1192 /// use byteorder::{ByteOrder, LittleEndian};
1194 /// let mut bytes = [0; 16];
1195 /// let numbers_given = [1.0, 2.0, 31.312e31, -11.32e19];
1196 /// LittleEndian::write_f32_into(&numbers_given, &mut bytes);
1198 /// let mut numbers_got = [0.0; 4];
1199 /// LittleEndian::read_f32_into(&bytes, &mut numbers_got);
1200 /// assert_eq!(numbers_given, numbers_got);
1203 fn read_f32_into(src
: &[u8], dst
: &mut [f32]) {
1205 slice
::from_raw_parts_mut(dst
.as_mut_ptr() as *mut u32, dst
.len())
1207 Self::read_u32_into(src
, dst
);
1212 /// This method is deprecated. Use `read_f32_into` instead.
1213 /// Reads IEEE754 single-precision (4 bytes) floating point numbers from
1214 /// `src` into `dst`.
1218 /// Panics when `src.len() != 4*dst.len()`.
1222 /// Write and read `f32` numbers in little endian order:
1225 /// use byteorder::{ByteOrder, LittleEndian};
1227 /// let mut bytes = [0; 16];
1228 /// let numbers_given = [1.0, 2.0, 31.312e31, -11.32e19];
1229 /// LittleEndian::write_f32_into(&numbers_given, &mut bytes);
1231 /// let mut numbers_got = [0.0; 4];
1232 /// LittleEndian::read_f32_into_unchecked(&bytes, &mut numbers_got);
1233 /// assert_eq!(numbers_given, numbers_got);
1236 #[deprecated(since = "1.3.0", note = "please use `read_f32_into` instead")]
1237 fn read_f32_into_unchecked(src
: &[u8], dst
: &mut [f32]) {
1238 Self::read_f32_into(src
, dst
);
1241 /// Reads IEEE754 single-precision (4 bytes) floating point numbers from
1242 /// `src` into `dst`.
1246 /// Panics when `src.len() != 8*dst.len()`.
1250 /// Write and read `f64` numbers in little endian order:
1253 /// use byteorder::{ByteOrder, LittleEndian};
1255 /// let mut bytes = [0; 32];
1256 /// let numbers_given = [1.0, 2.0, 31.312e211, -11.32e91];
1257 /// LittleEndian::write_f64_into(&numbers_given, &mut bytes);
1259 /// let mut numbers_got = [0.0; 4];
1260 /// LittleEndian::read_f64_into(&bytes, &mut numbers_got);
1261 /// assert_eq!(numbers_given, numbers_got);
1264 fn read_f64_into(src
: &[u8], dst
: &mut [f64]) {
1266 slice
::from_raw_parts_mut(dst
.as_mut_ptr() as *mut u64, dst
.len())
1268 Self::read_u64_into(src
, dst
);
1273 /// This method is deprecated. Use `read_f64_into` instead.
1275 /// Reads IEEE754 single-precision (4 bytes) floating point numbers from
1276 /// `src` into `dst`.
1280 /// Panics when `src.len() != 8*dst.len()`.
1284 /// Write and read `f64` numbers in little endian order:
1287 /// use byteorder::{ByteOrder, LittleEndian};
1289 /// let mut bytes = [0; 32];
1290 /// let numbers_given = [1.0, 2.0, 31.312e211, -11.32e91];
1291 /// LittleEndian::write_f64_into(&numbers_given, &mut bytes);
1293 /// let mut numbers_got = [0.0; 4];
1294 /// LittleEndian::read_f64_into_unchecked(&bytes, &mut numbers_got);
1295 /// assert_eq!(numbers_given, numbers_got);
1298 #[deprecated(since = "1.3.0", note = "please use `read_f64_into` instead")]
1299 fn read_f64_into_unchecked(src
: &[u8], dst
: &mut [f64]) {
1300 Self::read_f64_into(src
, dst
);
1303 /// Writes unsigned 16 bit integers from `src` into `dst`.
1307 /// Panics when `dst.len() != 2*src.len()`.
1311 /// Write and read `u16` numbers in little endian order:
1314 /// use byteorder::{ByteOrder, LittleEndian};
1316 /// let mut bytes = [0; 8];
1317 /// let numbers_given = [1, 2, 0xf00f, 0xffee];
1318 /// LittleEndian::write_u16_into(&numbers_given, &mut bytes);
1320 /// let mut numbers_got = [0; 4];
1321 /// LittleEndian::read_u16_into(&bytes, &mut numbers_got);
1322 /// assert_eq!(numbers_given, numbers_got);
1324 fn write_u16_into(src
: &[u16], dst
: &mut [u8]);
1326 /// Writes unsigned 32 bit integers from `src` into `dst`.
1330 /// Panics when `dst.len() != 4*src.len()`.
1334 /// Write and read `u32` numbers in little endian order:
1337 /// use byteorder::{ByteOrder, LittleEndian};
1339 /// let mut bytes = [0; 16];
1340 /// let numbers_given = [1, 2, 0xf00f, 0xffee];
1341 /// LittleEndian::write_u32_into(&numbers_given, &mut bytes);
1343 /// let mut numbers_got = [0; 4];
1344 /// LittleEndian::read_u32_into(&bytes, &mut numbers_got);
1345 /// assert_eq!(numbers_given, numbers_got);
1347 fn write_u32_into(src
: &[u32], dst
: &mut [u8]);
1349 /// Writes unsigned 64 bit integers from `src` into `dst`.
1353 /// Panics when `dst.len() != 8*src.len()`.
1357 /// Write and read `u64` numbers in little endian order:
1360 /// use byteorder::{ByteOrder, LittleEndian};
1362 /// let mut bytes = [0; 32];
1363 /// let numbers_given = [1, 2, 0xf00f, 0xffee];
1364 /// LittleEndian::write_u64_into(&numbers_given, &mut bytes);
1366 /// let mut numbers_got = [0; 4];
1367 /// LittleEndian::read_u64_into(&bytes, &mut numbers_got);
1368 /// assert_eq!(numbers_given, numbers_got);
1370 fn write_u64_into(src
: &[u64], dst
: &mut [u8]);
1372 /// Writes unsigned 128 bit integers from `src` into `dst`.
1376 /// Panics when `dst.len() != 16*src.len()`.
1380 /// Write and read `u128` numbers in little endian order:
1383 /// use byteorder::{ByteOrder, LittleEndian};
1385 /// let mut bytes = [0; 64];
1386 /// let numbers_given = [1, 2, 0xf00f, 0xffee];
1387 /// LittleEndian::write_u128_into(&numbers_given, &mut bytes);
1389 /// let mut numbers_got = [0; 4];
1390 /// LittleEndian::read_u128_into(&bytes, &mut numbers_got);
1391 /// assert_eq!(numbers_given, numbers_got);
1393 fn write_u128_into(src
: &[u128
], dst
: &mut [u8]);
1395 /// Writes signed 8 bit integers from `src` into `dst`.
1397 /// Note that since each `i8` is a single byte, no byte order conversions
1398 /// are used. This method is included because it provides a safe, simple
1399 /// way for the caller to write from a `&[i8]` buffer. (Without this
1400 /// method, the caller would have to either use `unsafe` code or convert
1401 /// each byte to `u8` individually.)
1405 /// Panics when `buf.len() != src.len()`.
1409 /// Write and read `i8` numbers in little endian order:
1412 /// use byteorder::{ByteOrder, LittleEndian, ReadBytesExt};
1414 /// let mut bytes = [0; 4];
1415 /// let numbers_given = [1, 2, 0xf, 0xe];
1416 /// LittleEndian::write_i8_into(&numbers_given, &mut bytes);
1418 /// let mut numbers_got = [0; 4];
1419 /// bytes.as_ref().read_i8_into(&mut numbers_got);
1420 /// assert_eq!(numbers_given, numbers_got);
1422 fn write_i8_into(src
: &[i8], dst
: &mut [u8]) {
1424 slice
::from_raw_parts(src
.as_ptr() as *const u8, src
.len())
1426 dst
.copy_from_slice(src
);
1429 /// Writes signed 16 bit integers from `src` into `dst`.
1433 /// Panics when `buf.len() != 2*src.len()`.
1437 /// Write and read `i16` numbers in little endian order:
1440 /// use byteorder::{ByteOrder, LittleEndian};
1442 /// let mut bytes = [0; 8];
1443 /// let numbers_given = [1, 2, 0x0f, 0xee];
1444 /// LittleEndian::write_i16_into(&numbers_given, &mut bytes);
1446 /// let mut numbers_got = [0; 4];
1447 /// LittleEndian::read_i16_into(&bytes, &mut numbers_got);
1448 /// assert_eq!(numbers_given, numbers_got);
1450 fn write_i16_into(src
: &[i16], dst
: &mut [u8]) {
1452 slice
::from_raw_parts(src
.as_ptr() as *const u16, src
.len())
1454 Self::write_u16_into(src
, dst
);
1457 /// Writes signed 32 bit integers from `src` into `dst`.
1461 /// Panics when `dst.len() != 4*src.len()`.
1465 /// Write and read `i32` numbers in little endian order:
1468 /// use byteorder::{ByteOrder, LittleEndian};
1470 /// let mut bytes = [0; 16];
1471 /// let numbers_given = [1, 2, 0xf00f, 0xffee];
1472 /// LittleEndian::write_i32_into(&numbers_given, &mut bytes);
1474 /// let mut numbers_got = [0; 4];
1475 /// LittleEndian::read_i32_into(&bytes, &mut numbers_got);
1476 /// assert_eq!(numbers_given, numbers_got);
1478 fn write_i32_into(src
: &[i32], dst
: &mut [u8]) {
1480 slice
::from_raw_parts(src
.as_ptr() as *const u32, src
.len())
1482 Self::write_u32_into(src
, dst
);
1485 /// Writes signed 64 bit integers from `src` into `dst`.
1489 /// Panics when `dst.len() != 8*src.len()`.
1493 /// Write and read `i64` numbers in little endian order:
1496 /// use byteorder::{ByteOrder, LittleEndian};
1498 /// let mut bytes = [0; 32];
1499 /// let numbers_given = [1, 2, 0xf00f, 0xffee];
1500 /// LittleEndian::write_i64_into(&numbers_given, &mut bytes);
1502 /// let mut numbers_got = [0; 4];
1503 /// LittleEndian::read_i64_into(&bytes, &mut numbers_got);
1504 /// assert_eq!(numbers_given, numbers_got);
1506 fn write_i64_into(src
: &[i64], dst
: &mut [u8]) {
1508 slice
::from_raw_parts(src
.as_ptr() as *const u64, src
.len())
1510 Self::write_u64_into(src
, dst
);
1513 /// Writes signed 128 bit integers from `src` into `dst`.
1517 /// Panics when `dst.len() != 16*src.len()`.
1521 /// Write and read `i128` numbers in little endian order:
1524 /// use byteorder::{ByteOrder, LittleEndian};
1526 /// let mut bytes = [0; 64];
1527 /// let numbers_given = [1, 2, 0xf00f, 0xffee];
1528 /// LittleEndian::write_i128_into(&numbers_given, &mut bytes);
1530 /// let mut numbers_got = [0; 4];
1531 /// LittleEndian::read_i128_into(&bytes, &mut numbers_got);
1532 /// assert_eq!(numbers_given, numbers_got);
1534 fn write_i128_into(src
: &[i128
], dst
: &mut [u8]) {
1536 slice
::from_raw_parts(src
.as_ptr() as *const u128
, src
.len())
1538 Self::write_u128_into(src
, dst
);
1541 /// Writes IEEE754 single-precision (4 bytes) floating point numbers from
1542 /// `src` into `dst`.
1546 /// Panics when `src.len() != 4*dst.len()`.
1550 /// Write and read `f32` numbers in little endian order:
1553 /// use byteorder::{ByteOrder, LittleEndian};
1555 /// let mut bytes = [0; 16];
1556 /// let numbers_given = [1.0, 2.0, 31.312e31, -11.32e19];
1557 /// LittleEndian::write_f32_into(&numbers_given, &mut bytes);
1559 /// let mut numbers_got = [0.0; 4];
1560 /// LittleEndian::read_f32_into(&bytes, &mut numbers_got);
1561 /// assert_eq!(numbers_given, numbers_got);
1563 fn write_f32_into(src
: &[f32], dst
: &mut [u8]) {
1565 slice
::from_raw_parts(src
.as_ptr() as *const u32, src
.len())
1567 Self::write_u32_into(src
, dst
);
1570 /// Writes IEEE754 double-precision (8 bytes) floating point numbers from
1571 /// `src` into `dst`.
1575 /// Panics when `src.len() != 8*dst.len()`.
1579 /// Write and read `f64` numbers in little endian order:
1582 /// use byteorder::{ByteOrder, LittleEndian};
1584 /// let mut bytes = [0; 32];
1585 /// let numbers_given = [1.0, 2.0, 31.312e211, -11.32e91];
1586 /// LittleEndian::write_f64_into(&numbers_given, &mut bytes);
1588 /// let mut numbers_got = [0.0; 4];
1589 /// LittleEndian::read_f64_into(&bytes, &mut numbers_got);
1590 /// assert_eq!(numbers_given, numbers_got);
1592 fn write_f64_into(src
: &[f64], dst
: &mut [u8]) {
1594 slice
::from_raw_parts(src
.as_ptr() as *const u64, src
.len())
1596 Self::write_u64_into(src
, dst
);
1599 /// Converts the given slice of unsigned 16 bit integers to a particular
1602 /// If the endianness matches the endianness of the host platform, then
1603 /// this is a no-op.
1607 /// Convert the host platform's endianness to big-endian:
1610 /// use byteorder::{ByteOrder, BigEndian};
1612 /// let mut numbers = [5, 65000];
1613 /// BigEndian::from_slice_u16(&mut numbers);
1614 /// assert_eq!(numbers, [5u16.to_be(), 65000u16.to_be()]);
1616 fn from_slice_u16(numbers
: &mut [u16]);
1618 /// Converts the given slice of unsigned 32 bit integers to a particular
1621 /// If the endianness matches the endianness of the host platform, then
1622 /// this is a no-op.
1626 /// Convert the host platform's endianness to big-endian:
1629 /// use byteorder::{ByteOrder, BigEndian};
1631 /// let mut numbers = [5, 65000];
1632 /// BigEndian::from_slice_u32(&mut numbers);
1633 /// assert_eq!(numbers, [5u32.to_be(), 65000u32.to_be()]);
1635 fn from_slice_u32(numbers
: &mut [u32]);
1637 /// Converts the given slice of unsigned 64 bit integers to a particular
1640 /// If the endianness matches the endianness of the host platform, then
1641 /// this is a no-op.
1645 /// Convert the host platform's endianness to big-endian:
1648 /// use byteorder::{ByteOrder, BigEndian};
1650 /// let mut numbers = [5, 65000];
1651 /// BigEndian::from_slice_u64(&mut numbers);
1652 /// assert_eq!(numbers, [5u64.to_be(), 65000u64.to_be()]);
1654 fn from_slice_u64(numbers
: &mut [u64]);
1656 /// Converts the given slice of unsigned 128 bit integers to a particular
1659 /// If the endianness matches the endianness of the host platform, then
1660 /// this is a no-op.
1664 /// Convert the host platform's endianness to big-endian:
1667 /// use byteorder::{ByteOrder, BigEndian};
1669 /// let mut numbers = [5, 65000];
1670 /// BigEndian::from_slice_u128(&mut numbers);
1671 /// assert_eq!(numbers, [5u128.to_be(), 65000u128.to_be()]);
1673 fn from_slice_u128(numbers
: &mut [u128
]);
1675 /// Converts the given slice of signed 16 bit integers to a particular
1678 /// If the endianness matches the endianness of the host platform, then
1679 /// this is a no-op.
1683 /// Convert the host platform's endianness to big-endian:
1686 /// use byteorder::{ByteOrder, BigEndian};
1688 /// let mut numbers = [5, 6500];
1689 /// BigEndian::from_slice_i16(&mut numbers);
1690 /// assert_eq!(numbers, [5i16.to_be(), 6500i16.to_be()]);
1693 fn from_slice_i16(src
: &mut [i16]) {
1695 slice
::from_raw_parts_mut(src
.as_mut_ptr() as *mut u16, src
.len())
1697 Self::from_slice_u16(src
);
1700 /// Converts the given slice of signed 32 bit integers to a particular
1703 /// If the endianness matches the endianness of the host platform, then
1704 /// this is a no-op.
1708 /// Convert the host platform's endianness to big-endian:
1711 /// use byteorder::{ByteOrder, BigEndian};
1713 /// let mut numbers = [5, 65000];
1714 /// BigEndian::from_slice_i32(&mut numbers);
1715 /// assert_eq!(numbers, [5i32.to_be(), 65000i32.to_be()]);
1718 fn from_slice_i32(src
: &mut [i32]) {
1720 slice
::from_raw_parts_mut(src
.as_mut_ptr() as *mut u32, src
.len())
1722 Self::from_slice_u32(src
);
1725 /// Converts the given slice of signed 64 bit integers to a particular
1728 /// If the endianness matches the endianness of the host platform, then
1729 /// this is a no-op.
1733 /// Convert the host platform's endianness to big-endian:
1736 /// use byteorder::{ByteOrder, BigEndian};
1738 /// let mut numbers = [5, 65000];
1739 /// BigEndian::from_slice_i64(&mut numbers);
1740 /// assert_eq!(numbers, [5i64.to_be(), 65000i64.to_be()]);
1743 fn from_slice_i64(src
: &mut [i64]) {
1745 slice
::from_raw_parts_mut(src
.as_mut_ptr() as *mut u64, src
.len())
1747 Self::from_slice_u64(src
);
1750 /// Converts the given slice of signed 128 bit integers to a particular
1753 /// If the endianness matches the endianness of the host platform, then
1754 /// this is a no-op.
1758 /// Convert the host platform's endianness to big-endian:
1761 /// use byteorder::{ByteOrder, BigEndian};
1763 /// let mut numbers = [5, 65000];
1764 /// BigEndian::from_slice_i128(&mut numbers);
1765 /// assert_eq!(numbers, [5i128.to_be(), 65000i128.to_be()]);
1768 fn from_slice_i128(src
: &mut [i128
]) {
1770 slice
::from_raw_parts_mut(src
.as_mut_ptr() as *mut u128
, src
.len())
1772 Self::from_slice_u128(src
);
1775 /// Converts the given slice of IEEE754 single-precision (4 bytes) floating
1776 /// point numbers to a particular endianness.
1778 /// If the endianness matches the endianness of the host platform, then
1779 /// this is a no-op.
1780 fn from_slice_f32(numbers
: &mut [f32]);
1782 /// Converts the given slice of IEEE754 double-precision (8 bytes) floating
1783 /// point numbers to a particular endianness.
1785 /// If the endianness matches the endianness of the host platform, then
1786 /// this is a no-op.
1787 fn from_slice_f64(numbers
: &mut [f64]);
1790 /// Defines big-endian serialization.
1792 /// Note that this type has no value constructor. It is used purely at the
1797 /// Write and read `u32` numbers in big endian order:
1800 /// use byteorder::{ByteOrder, BigEndian};
1802 /// let mut buf = [0; 4];
1803 /// BigEndian::write_u32(&mut buf, 1_000_000);
1804 /// assert_eq!(1_000_000, BigEndian::read_u32(&buf));
1806 #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1807 pub enum BigEndian {}
1809 impl Default
for BigEndian
{
1810 fn default() -> BigEndian
{
1811 panic
!("BigEndian default")
1815 /// A type alias for [`BigEndian`].
1817 /// [`BigEndian`]: enum.BigEndian.html
1818 pub type BE
= BigEndian
;
1820 /// Defines little-endian serialization.
1822 /// Note that this type has no value constructor. It is used purely at the
1827 /// Write and read `u32` numbers in little endian order:
1830 /// use byteorder::{ByteOrder, LittleEndian};
1832 /// let mut buf = [0; 4];
1833 /// LittleEndian::write_u32(&mut buf, 1_000_000);
1834 /// assert_eq!(1_000_000, LittleEndian::read_u32(&buf));
1836 #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1837 pub enum LittleEndian {}
1839 impl Default
for LittleEndian
{
1840 fn default() -> LittleEndian
{
1841 panic
!("LittleEndian default")
1845 /// A type alias for [`LittleEndian`].
1847 /// [`LittleEndian`]: enum.LittleEndian.html
1848 pub type LE
= LittleEndian
;
1850 /// Defines network byte order serialization.
1852 /// Network byte order is defined by [RFC 1700][1] to be big-endian, and is
1853 /// referred to in several protocol specifications. This type is an alias of
1856 /// [1]: https://tools.ietf.org/html/rfc1700
1858 /// Note that this type has no value constructor. It is used purely at the
1863 /// Write and read `i16` numbers in big endian order:
1866 /// use byteorder::{ByteOrder, NetworkEndian, BigEndian};
1868 /// let mut buf = [0; 2];
1869 /// BigEndian::write_i16(&mut buf, -5_000);
1870 /// assert_eq!(-5_000, NetworkEndian::read_i16(&buf));
1873 /// [`BigEndian`]: enum.BigEndian.html
1874 pub type NetworkEndian
= BigEndian
;
1876 /// Defines system native-endian serialization.
1878 /// Note that this type has no value constructor. It is used purely at the
1881 /// On this platform, this is an alias for [`LittleEndian`].
1883 /// [`LittleEndian`]: enum.LittleEndian.html
1884 #[cfg(target_endian = "little")]
1885 pub type NativeEndian
= LittleEndian
;
1887 /// Defines system native-endian serialization.
1889 /// Note that this type has no value constructor. It is used purely at the
1892 /// On this platform, this is an alias for [`BigEndian`].
1894 /// [`BigEndian`]: enum.BigEndian.html
1895 #[cfg(target_endian = "big")]
1896 pub type NativeEndian
= BigEndian
;
1898 /// Copies $size bytes from a number $n to a &mut [u8] $dst. $ty represents the
1899 /// numeric type of $n and $which must be either to_be or to_le, depending on
1900 /// which endianness one wants to use when writing to $dst.
1902 /// This macro is only safe to call when $ty is a numeric type and $size ==
1903 /// size_of::<$ty>() and where $dst is a &mut [u8].
1904 macro_rules
! unsafe_write_num_bytes
{
1905 ($ty
:ty
, $size
:expr
, $n
:expr
, $dst
:expr
, $which
:ident
) => {{
1906 assert
!($size
<= $dst
.len());
1908 // N.B. https://github.com/rust-lang/rust/issues/22776
1909 let bytes
= *(&$n
.$
which() as *const _
as *const [u8; $size
]);
1910 copy_nonoverlapping((&bytes
).as_ptr(), $dst
.as_mut_ptr(), $size
);
1915 /// Copies a &[u8] $src into a &mut [<numeric>] $dst for the endianness given
1916 /// by $which (must be either to_be or to_le).
1918 /// This macro is only safe to call when $src and $dst are &[u8] and &mut [u8],
1919 /// respectively. The macro will panic if $src.len() != $size * $dst.len(),
1920 /// where $size represents the size of the integers encoded in $src.
1921 macro_rules
! unsafe_read_slice
{
1922 ($src
:expr
, $dst
:expr
, $size
:expr
, $which
:ident
) => {{
1923 assert_eq
!($src
.len(), $size
* $dst
.len());
1926 copy_nonoverlapping(
1928 $dst
.as_mut_ptr() as *mut u8,
1932 for v
in $dst
.iter_mut() {
1938 /// Copies a &[$ty] $src into a &mut [u8] $dst, where $ty must be a numeric
1939 /// type. This panics if size_of::<$ty>() * $src.len() != $dst.len().
1941 /// This macro is only safe to call when $src is a slice of numeric types and
1942 /// $dst is a &mut [u8] and where $ty represents the type of the integers in
1944 macro_rules
! unsafe_write_slice_native
{
1945 ($src
:expr
, $dst
:expr
, $ty
:ty
) => {{
1946 let size
= core
::mem
::size_of
::<$ty
>();
1947 assert_eq
!(size
* $src
.len(), $dst
.len());
1950 copy_nonoverlapping(
1951 $src
.as_ptr() as *const u8,
1959 macro_rules
! write_slice
{
1960 ($src
:expr
, $dst
:expr
, $ty
:ty
, $size
:expr
, $write
:expr
) => {{
1961 assert
!($size
== ::core
::mem
::size_of
::<$ty
>());
1962 assert_eq
!($size
* $src
.len(), $dst
.len());
1964 for (&n
, chunk
) in $src
.iter().zip($dst
.chunks_mut($size
)) {
1970 impl ByteOrder
for BigEndian
{
1972 fn read_u16(buf
: &[u8]) -> u16 {
1973 u16::from_be_bytes(buf
[..2].try_into().unwrap())
1977 fn read_u32(buf
: &[u8]) -> u32 {
1978 u32::from_be_bytes(buf
[..4].try_into().unwrap())
1982 fn read_u64(buf
: &[u8]) -> u64 {
1983 u64::from_be_bytes(buf
[..8].try_into().unwrap())
1987 fn read_u128(buf
: &[u8]) -> u128
{
1988 u128
::from_be_bytes(buf
[..16].try_into().unwrap())
1992 fn read_uint(buf
: &[u8], nbytes
: usize) -> u64 {
1993 assert
!(1 <= nbytes
&& nbytes
<= 8 && nbytes
<= buf
.len());
1995 let ptr_out
= &mut out
as *mut u64 as *mut u8;
1997 copy_nonoverlapping(
1999 ptr_out
.offset((8 - nbytes
) as isize),
2007 fn read_uint128(buf
: &[u8], nbytes
: usize) -> u128
{
2008 assert
!(1 <= nbytes
&& nbytes
<= 16 && nbytes
<= buf
.len());
2009 let mut out
: u128
= 0;
2010 let ptr_out
= &mut out
as *mut u128
as *mut u8;
2012 copy_nonoverlapping(
2014 ptr_out
.offset((16 - nbytes
) as isize),
2022 fn write_u16(buf
: &mut [u8], n
: u16) {
2023 unsafe_write_num_bytes
!(u16, 2, n
, buf
, to_be
);
2027 fn write_u32(buf
: &mut [u8], n
: u32) {
2028 unsafe_write_num_bytes
!(u32, 4, n
, buf
, to_be
);
2032 fn write_u64(buf
: &mut [u8], n
: u64) {
2033 unsafe_write_num_bytes
!(u64, 8, n
, buf
, to_be
);
2037 fn write_u128(buf
: &mut [u8], n
: u128
) {
2038 unsafe_write_num_bytes
!(u128
, 16, n
, buf
, to_be
);
2042 fn write_uint(buf
: &mut [u8], n
: u64, nbytes
: usize) {
2043 assert
!(pack_size(n
) <= nbytes
&& nbytes
<= 8);
2044 assert
!(nbytes
<= buf
.len());
2046 let bytes
= *(&n
.to_be() as *const u64 as *const [u8; 8]);
2047 copy_nonoverlapping(
2048 bytes
.as_ptr().offset((8 - nbytes
) as isize),
2056 fn write_uint128(buf
: &mut [u8], n
: u128
, nbytes
: usize) {
2057 assert
!(pack_size128(n
) <= nbytes
&& nbytes
<= 16);
2058 assert
!(nbytes
<= buf
.len());
2060 let bytes
= *(&n
.to_be() as *const u128
as *const [u8; 16]);
2061 copy_nonoverlapping(
2062 bytes
.as_ptr().offset((16 - nbytes
) as isize),
2070 fn read_u16_into(src
: &[u8], dst
: &mut [u16]) {
2071 unsafe_read_slice
!(src
, dst
, 2, to_be
);
2075 fn read_u32_into(src
: &[u8], dst
: &mut [u32]) {
2076 unsafe_read_slice
!(src
, dst
, 4, to_be
);
2080 fn read_u64_into(src
: &[u8], dst
: &mut [u64]) {
2081 unsafe_read_slice
!(src
, dst
, 8, to_be
);
2085 fn read_u128_into(src
: &[u8], dst
: &mut [u128
]) {
2086 unsafe_read_slice
!(src
, dst
, 16, to_be
);
2090 fn write_u16_into(src
: &[u16], dst
: &mut [u8]) {
2091 if cfg
!(target_endian
= "big") {
2092 unsafe_write_slice_native
!(src
, dst
, u16);
2094 write_slice
!(src
, dst
, u16, 2, Self::write_u16
);
2099 fn write_u32_into(src
: &[u32], dst
: &mut [u8]) {
2100 if cfg
!(target_endian
= "big") {
2101 unsafe_write_slice_native
!(src
, dst
, u32);
2103 write_slice
!(src
, dst
, u32, 4, Self::write_u32
);
2108 fn write_u64_into(src
: &[u64], dst
: &mut [u8]) {
2109 if cfg
!(target_endian
= "big") {
2110 unsafe_write_slice_native
!(src
, dst
, u64);
2112 write_slice
!(src
, dst
, u64, 8, Self::write_u64
);
2117 fn write_u128_into(src
: &[u128
], dst
: &mut [u8]) {
2118 if cfg
!(target_endian
= "big") {
2119 unsafe_write_slice_native
!(src
, dst
, u128
);
2121 write_slice
!(src
, dst
, u128
, 16, Self::write_u128
);
2126 fn from_slice_u16(numbers
: &mut [u16]) {
2127 if cfg
!(target_endian
= "little") {
2135 fn from_slice_u32(numbers
: &mut [u32]) {
2136 if cfg
!(target_endian
= "little") {
2144 fn from_slice_u64(numbers
: &mut [u64]) {
2145 if cfg
!(target_endian
= "little") {
2153 fn from_slice_u128(numbers
: &mut [u128
]) {
2154 if cfg
!(target_endian
= "little") {
2162 fn from_slice_f32(numbers
: &mut [f32]) {
2163 if cfg
!(target_endian
= "little") {
2166 let int
= *(n
as *const f32 as *const u32);
2167 *n
= *(&int
.to_be() as *const u32 as *const f32);
2174 fn from_slice_f64(numbers
: &mut [f64]) {
2175 if cfg
!(target_endian
= "little") {
2178 let int
= *(n
as *const f64 as *const u64);
2179 *n
= *(&int
.to_be() as *const u64 as *const f64);
2186 impl ByteOrder
for LittleEndian
{
2188 fn read_u16(buf
: &[u8]) -> u16 {
2189 u16::from_le_bytes(buf
[..2].try_into().unwrap())
2193 fn read_u32(buf
: &[u8]) -> u32 {
2194 u32::from_le_bytes(buf
[..4].try_into().unwrap())
2198 fn read_u64(buf
: &[u8]) -> u64 {
2199 u64::from_le_bytes(buf
[..8].try_into().unwrap())
2203 fn read_u128(buf
: &[u8]) -> u128
{
2204 u128
::from_le_bytes(buf
[..16].try_into().unwrap())
2208 fn read_uint(buf
: &[u8], nbytes
: usize) -> u64 {
2209 assert
!(1 <= nbytes
&& nbytes
<= 8 && nbytes
<= buf
.len());
2211 let ptr_out
= &mut out
as *mut u64 as *mut u8;
2213 copy_nonoverlapping(buf
.as_ptr(), ptr_out
, nbytes
);
2219 fn read_uint128(buf
: &[u8], nbytes
: usize) -> u128
{
2220 assert
!(1 <= nbytes
&& nbytes
<= 16 && nbytes
<= buf
.len());
2221 let mut out
: u128
= 0;
2222 let ptr_out
= &mut out
as *mut u128
as *mut u8;
2224 copy_nonoverlapping(buf
.as_ptr(), ptr_out
, nbytes
);
2230 fn write_u16(buf
: &mut [u8], n
: u16) {
2231 unsafe_write_num_bytes
!(u16, 2, n
, buf
, to_le
);
2235 fn write_u32(buf
: &mut [u8], n
: u32) {
2236 unsafe_write_num_bytes
!(u32, 4, n
, buf
, to_le
);
2240 fn write_u64(buf
: &mut [u8], n
: u64) {
2241 unsafe_write_num_bytes
!(u64, 8, n
, buf
, to_le
);
2245 fn write_u128(buf
: &mut [u8], n
: u128
) {
2246 unsafe_write_num_bytes
!(u128
, 16, n
, buf
, to_le
);
2250 fn write_uint(buf
: &mut [u8], n
: u64, nbytes
: usize) {
2251 assert
!(pack_size(n
as u64) <= nbytes
&& nbytes
<= 8);
2252 assert
!(nbytes
<= buf
.len());
2254 let bytes
= *(&n
.to_le() as *const u64 as *const [u8; 8]);
2255 copy_nonoverlapping(bytes
.as_ptr(), buf
.as_mut_ptr(), nbytes
);
2260 fn write_uint128(buf
: &mut [u8], n
: u128
, nbytes
: usize) {
2261 assert
!(pack_size128(n
as u128
) <= nbytes
&& nbytes
<= 16);
2262 assert
!(nbytes
<= buf
.len());
2264 let bytes
= *(&n
.to_le() as *const u128
as *const [u8; 16]);
2265 copy_nonoverlapping(bytes
.as_ptr(), buf
.as_mut_ptr(), nbytes
);
2270 fn read_u16_into(src
: &[u8], dst
: &mut [u16]) {
2271 unsafe_read_slice
!(src
, dst
, 2, to_le
);
2275 fn read_u32_into(src
: &[u8], dst
: &mut [u32]) {
2276 unsafe_read_slice
!(src
, dst
, 4, to_le
);
2280 fn read_u64_into(src
: &[u8], dst
: &mut [u64]) {
2281 unsafe_read_slice
!(src
, dst
, 8, to_le
);
2285 fn read_u128_into(src
: &[u8], dst
: &mut [u128
]) {
2286 unsafe_read_slice
!(src
, dst
, 16, to_le
);
2290 fn write_u16_into(src
: &[u16], dst
: &mut [u8]) {
2291 if cfg
!(target_endian
= "little") {
2292 unsafe_write_slice_native
!(src
, dst
, u16);
2294 write_slice
!(src
, dst
, u16, 2, Self::write_u16
);
2299 fn write_u32_into(src
: &[u32], dst
: &mut [u8]) {
2300 if cfg
!(target_endian
= "little") {
2301 unsafe_write_slice_native
!(src
, dst
, u32);
2303 write_slice
!(src
, dst
, u32, 4, Self::write_u32
);
2308 fn write_u64_into(src
: &[u64], dst
: &mut [u8]) {
2309 if cfg
!(target_endian
= "little") {
2310 unsafe_write_slice_native
!(src
, dst
, u64);
2312 write_slice
!(src
, dst
, u64, 8, Self::write_u64
);
2317 fn write_u128_into(src
: &[u128
], dst
: &mut [u8]) {
2318 if cfg
!(target_endian
= "little") {
2319 unsafe_write_slice_native
!(src
, dst
, u128
);
2321 write_slice
!(src
, dst
, u128
, 16, Self::write_u128
);
2326 fn from_slice_u16(numbers
: &mut [u16]) {
2327 if cfg
!(target_endian
= "big") {
2335 fn from_slice_u32(numbers
: &mut [u32]) {
2336 if cfg
!(target_endian
= "big") {
2344 fn from_slice_u64(numbers
: &mut [u64]) {
2345 if cfg
!(target_endian
= "big") {
2353 fn from_slice_u128(numbers
: &mut [u128
]) {
2354 if cfg
!(target_endian
= "big") {
2362 fn from_slice_f32(numbers
: &mut [f32]) {
2363 if cfg
!(target_endian
= "big") {
2366 let int
= *(n
as *const f32 as *const u32);
2367 *n
= *(&int
.to_le() as *const u32 as *const f32);
2374 fn from_slice_f64(numbers
: &mut [f64]) {
2375 if cfg
!(target_endian
= "big") {
2378 let int
= *(n
as *const f64 as *const u64);
2379 *n
= *(&int
.to_le() as *const u64 as *const f64);
2388 use quickcheck
::{Arbitrary, Gen, QuickCheck, StdGen, Testable}
;
2389 use rand
::{thread_rng, Rng}
;
2391 pub const U24_MAX
: u32 = 16_777_215;
2392 pub const I24_MAX
: i32 = 8_388_607;
2393 pub const U48_MAX
: u64 = 281_474_976_710_655;
2394 pub const I48_MAX
: i64 = 140_737_488_355_327;
2396 pub const U64_MAX
: u64 = ::core
::u64::MAX
;
2397 pub const I64_MAX
: u64 = ::core
::i64::MAX
as u64;
2399 macro_rules
! calc_max
{
2400 ($max
:expr
, $bytes
:expr
) => {
2401 calc_max
!($max
, $bytes
, 8)
2403 ($max
:expr
, $bytes
:expr
, $maxbytes
:expr
) => {
2404 ($max
- 1) >> (8 * ($maxbytes
- $bytes
))
2408 #[derive(Clone, Debug)]
2409 pub struct Wi128
<T
>(pub T
);
2411 impl<T
: Clone
> Wi128
<T
> {
2412 pub fn clone(&self) -> T
{
2417 impl<T
: PartialEq
> PartialEq
<T
> for Wi128
<T
> {
2418 fn eq(&self, other
: &T
) -> bool
{
2423 impl Arbitrary
for Wi128
<u128
> {
2424 fn arbitrary
<G
: Gen
>(gen
: &mut G
) -> Wi128
<u128
> {
2425 let max
= calc_max
!(::core
::u128
::MAX
, gen
.size(), 16);
2426 let output
= (gen
.gen
::<u64>() as u128
)
2427 | ((gen
.gen
::<u64>() as u128
) << 64);
2428 Wi128(output
& (max
- 1))
2432 impl Arbitrary
for Wi128
<i128
> {
2433 fn arbitrary
<G
: Gen
>(gen
: &mut G
) -> Wi128
<i128
> {
2434 let max
= calc_max
!(::core
::i128
::MAX
, gen
.size(), 16);
2435 let output
= (gen
.gen
::<i64>() as i128
)
2436 | ((gen
.gen
::<i64>() as i128
) << 64);
2437 Wi128(output
& (max
- 1))
2441 pub fn qc_sized
<A
: Testable
>(f
: A
, size
: u64) {
2443 .gen(StdGen
::new(thread_rng(), size
as usize))
2449 macro_rules
! qc_byte_order
{
2450 ($name
:ident
, $ty_int
:ty
, $max
:expr
,
2451 $bytes
:expr
, $read
:ident
, $write
:ident
) => {
2453 #[allow(unused_imports)]
2454 use super::{qc_sized, Wi128}
;
2456 BigEndian
, ByteOrder
, LittleEndian
, NativeEndian
,
2461 fn prop(n
: $ty_int
) -> bool
{
2462 let mut buf
= [0; 16];
2463 BigEndian
::$
write(&mut buf
, n
.clone(), $bytes
);
2464 n
== BigEndian
::$
read(&buf
[..$bytes
], $bytes
)
2466 qc_sized(prop
as fn($ty_int
) -> bool
, $max
);
2470 fn little_endian() {
2471 fn prop(n
: $ty_int
) -> bool
{
2472 let mut buf
= [0; 16];
2473 LittleEndian
::$
write(&mut buf
, n
.clone(), $bytes
);
2474 n
== LittleEndian
::$
read(&buf
[..$bytes
], $bytes
)
2476 qc_sized(prop
as fn($ty_int
) -> bool
, $max
);
2480 fn native_endian() {
2481 fn prop(n
: $ty_int
) -> bool
{
2482 let mut buf
= [0; 16];
2483 NativeEndian
::$
write(&mut buf
, n
.clone(), $bytes
);
2484 n
== NativeEndian
::$
read(&buf
[..$bytes
], $bytes
)
2486 qc_sized(prop
as fn($ty_int
) -> bool
, $max
);
2490 ($name
:ident
, $ty_int
:ty
, $max
:expr
,
2491 $read
:ident
, $write
:ident
) => {
2493 #[allow(unused_imports)]
2494 use super::{qc_sized, Wi128}
;
2496 BigEndian
, ByteOrder
, LittleEndian
, NativeEndian
,
2498 use core
::mem
::size_of
;
2502 fn prop(n
: $ty_int
) -> bool
{
2503 let bytes
= size_of
::<$ty_int
>();
2504 let mut buf
= [0; 16];
2505 BigEndian
::$
write(&mut buf
[16 - bytes
..], n
.clone());
2506 n
== BigEndian
::$
read(&buf
[16 - bytes
..])
2508 qc_sized(prop
as fn($ty_int
) -> bool
, $max
- 1);
2512 fn little_endian() {
2513 fn prop(n
: $ty_int
) -> bool
{
2514 let bytes
= size_of
::<$ty_int
>();
2515 let mut buf
= [0; 16];
2516 LittleEndian
::$
write(&mut buf
[..bytes
], n
.clone());
2517 n
== LittleEndian
::$
read(&buf
[..bytes
])
2519 qc_sized(prop
as fn($ty_int
) -> bool
, $max
- 1);
2523 fn native_endian() {
2524 fn prop(n
: $ty_int
) -> bool
{
2525 let bytes
= size_of
::<$ty_int
>();
2526 let mut buf
= [0; 16];
2527 NativeEndian
::$
write(&mut buf
[..bytes
], n
.clone());
2528 n
== NativeEndian
::$
read(&buf
[..bytes
])
2530 qc_sized(prop
as fn($ty_int
) -> bool
, $max
- 1);
2539 ::core
::u16::MAX
as u64,
2546 ::core
::i16::MAX
as u64,
2553 crate::test
::U24_MAX
as u64,
2560 crate::test
::I24_MAX
as u64,
2567 ::core
::u32::MAX
as u64,
2574 ::core
::i32::MAX
as u64,
2581 crate::test
::U48_MAX
as u64,
2588 crate::test
::I48_MAX
as u64,
2595 ::core
::u64::MAX
as u64,
2602 ::core
::i64::MAX
as u64,
2609 ::core
::u64::MAX
as u64,
2616 ::core
::i64::MAX
as u64,
2621 qc_byte_order
!(prop_u128
, Wi128
<u128
>, 16 + 1, read_u128
, write_u128
);
2622 qc_byte_order
!(prop_i128
, Wi128
<i128
>, 16 + 1, read_i128
, write_i128
);
2627 calc_max
!(super::U64_MAX
, 1),
2635 calc_max
!(super::U64_MAX
, 2),
2643 calc_max
!(super::U64_MAX
, 3),
2651 calc_max
!(super::U64_MAX
, 4),
2659 calc_max
!(super::U64_MAX
, 5),
2667 calc_max
!(super::U64_MAX
, 6),
2675 calc_max
!(super::U64_MAX
, 7),
2683 calc_max
!(super::U64_MAX
, 8),
2821 calc_max
!(super::I64_MAX
, 1),
2829 calc_max
!(super::I64_MAX
, 2),
2837 calc_max
!(super::I64_MAX
, 3),
2845 calc_max
!(super::I64_MAX
, 4),
2853 calc_max
!(super::I64_MAX
, 5),
2861 calc_max
!(super::I64_MAX
, 6),
2869 calc_max
!(super::I64_MAX
, 7),
2877 calc_max
!(super::I64_MAX
, 8),
3012 // Test that all of the byte conversion functions panic when given a
3013 // buffer that is too small.
3015 // These tests are critical to ensure safety, otherwise we might end up
3016 // with a buffer overflow.
3017 macro_rules
! too_small
{
3018 ($name
:ident
, $maximally_small
:expr
, $zero
:expr
,
3019 $read
:ident
, $write
:ident
) => {
3022 BigEndian
, ByteOrder
, LittleEndian
, NativeEndian
,
3027 fn read_big_endian() {
3028 let buf
= [0; $maximally_small
];
3029 BigEndian
::$
read(&buf
);
3034 fn read_little_endian() {
3035 let buf
= [0; $maximally_small
];
3036 LittleEndian
::$
read(&buf
);
3041 fn read_native_endian() {
3042 let buf
= [0; $maximally_small
];
3043 NativeEndian
::$
read(&buf
);
3048 fn write_big_endian() {
3049 let mut buf
= [0; $maximally_small
];
3050 BigEndian
::$
write(&mut buf
, $zero
);
3055 fn write_little_endian() {
3056 let mut buf
= [0; $maximally_small
];
3057 LittleEndian
::$
write(&mut buf
, $zero
);
3062 fn write_native_endian() {
3063 let mut buf
= [0; $maximally_small
];
3064 NativeEndian
::$
write(&mut buf
, $zero
);
3068 ($name
:ident
, $maximally_small
:expr
, $read
:ident
) => {
3071 BigEndian
, ByteOrder
, LittleEndian
, NativeEndian
,
3076 fn read_big_endian() {
3077 let buf
= [0; $maximally_small
];
3078 BigEndian
::$
read(&buf
, $maximally_small
+ 1);
3083 fn read_little_endian() {
3084 let buf
= [0; $maximally_small
];
3085 LittleEndian
::$
read(&buf
, $maximally_small
+ 1);
3090 fn read_native_endian() {
3091 let buf
= [0; $maximally_small
];
3092 NativeEndian
::$
read(&buf
, $maximally_small
+ 1);
3098 too_small
!(small_u16
, 1, 0, read_u16
, write_u16
);
3099 too_small
!(small_i16
, 1, 0, read_i16
, write_i16
);
3100 too_small
!(small_u32
, 3, 0, read_u32
, write_u32
);
3101 too_small
!(small_i32
, 3, 0, read_i32
, write_i32
);
3102 too_small
!(small_u64
, 7, 0, read_u64
, write_u64
);
3103 too_small
!(small_i64
, 7, 0, read_i64
, write_i64
);
3104 too_small
!(small_f32
, 3, 0.0, read_f32
, write_f32
);
3105 too_small
!(small_f64
, 7, 0.0, read_f64
, write_f64
);
3106 too_small
!(small_u128
, 15, 0, read_u128
, write_u128
);
3107 too_small
!(small_i128
, 15, 0, read_i128
, write_i128
);
3109 too_small
!(small_uint_1
, 1, read_uint
);
3110 too_small
!(small_uint_2
, 2, read_uint
);
3111 too_small
!(small_uint_3
, 3, read_uint
);
3112 too_small
!(small_uint_4
, 4, read_uint
);
3113 too_small
!(small_uint_5
, 5, read_uint
);
3114 too_small
!(small_uint_6
, 6, read_uint
);
3115 too_small
!(small_uint_7
, 7, read_uint
);
3117 too_small
!(small_uint128_1
, 1, read_uint128
);
3118 too_small
!(small_uint128_2
, 2, read_uint128
);
3119 too_small
!(small_uint128_3
, 3, read_uint128
);
3120 too_small
!(small_uint128_4
, 4, read_uint128
);
3121 too_small
!(small_uint128_5
, 5, read_uint128
);
3122 too_small
!(small_uint128_6
, 6, read_uint128
);
3123 too_small
!(small_uint128_7
, 7, read_uint128
);
3124 too_small
!(small_uint128_8
, 8, read_uint128
);
3125 too_small
!(small_uint128_9
, 9, read_uint128
);
3126 too_small
!(small_uint128_10
, 10, read_uint128
);
3127 too_small
!(small_uint128_11
, 11, read_uint128
);
3128 too_small
!(small_uint128_12
, 12, read_uint128
);
3129 too_small
!(small_uint128_13
, 13, read_uint128
);
3130 too_small
!(small_uint128_14
, 14, read_uint128
);
3131 too_small
!(small_uint128_15
, 15, read_uint128
);
3133 too_small
!(small_int_1
, 1, read_int
);
3134 too_small
!(small_int_2
, 2, read_int
);
3135 too_small
!(small_int_3
, 3, read_int
);
3136 too_small
!(small_int_4
, 4, read_int
);
3137 too_small
!(small_int_5
, 5, read_int
);
3138 too_small
!(small_int_6
, 6, read_int
);
3139 too_small
!(small_int_7
, 7, read_int
);
3141 too_small
!(small_int128_1
, 1, read_int128
);
3142 too_small
!(small_int128_2
, 2, read_int128
);
3143 too_small
!(small_int128_3
, 3, read_int128
);
3144 too_small
!(small_int128_4
, 4, read_int128
);
3145 too_small
!(small_int128_5
, 5, read_int128
);
3146 too_small
!(small_int128_6
, 6, read_int128
);
3147 too_small
!(small_int128_7
, 7, read_int128
);
3148 too_small
!(small_int128_8
, 8, read_int128
);
3149 too_small
!(small_int128_9
, 9, read_int128
);
3150 too_small
!(small_int128_10
, 10, read_int128
);
3151 too_small
!(small_int128_11
, 11, read_int128
);
3152 too_small
!(small_int128_12
, 12, read_int128
);
3153 too_small
!(small_int128_13
, 13, read_int128
);
3154 too_small
!(small_int128_14
, 14, read_int128
);
3155 too_small
!(small_int128_15
, 15, read_int128
);
3157 // Test that reading/writing slices enforces the correct lengths.
3158 macro_rules
! slice_lengths
{
3159 ($name
:ident
, $read
:ident
, $write
:ident
,
3160 $num_bytes
:expr
, $numbers
:expr
) => {
3163 BigEndian
, ByteOrder
, LittleEndian
, NativeEndian
,
3168 fn read_big_endian() {
3169 let bytes
= [0; $num_bytes
];
3170 let mut numbers
= $numbers
;
3171 BigEndian
::$
read(&bytes
, &mut numbers
);
3176 fn read_little_endian() {
3177 let bytes
= [0; $num_bytes
];
3178 let mut numbers
= $numbers
;
3179 LittleEndian
::$
read(&bytes
, &mut numbers
);
3184 fn read_native_endian() {
3185 let bytes
= [0; $num_bytes
];
3186 let mut numbers
= $numbers
;
3187 NativeEndian
::$
read(&bytes
, &mut numbers
);
3192 fn write_big_endian() {
3193 let mut bytes
= [0; $num_bytes
];
3194 let numbers
= $numbers
;
3195 BigEndian
::$
write(&numbers
, &mut bytes
);
3200 fn write_little_endian() {
3201 let mut bytes
= [0; $num_bytes
];
3202 let numbers
= $numbers
;
3203 LittleEndian
::$
write(&numbers
, &mut bytes
);
3208 fn write_native_endian() {
3209 let mut bytes
= [0; $num_bytes
];
3210 let numbers
= $numbers
;
3211 NativeEndian
::$
write(&numbers
, &mut bytes
);
3218 slice_len_too_small_u16
,
3225 slice_len_too_big_u16
,
3232 slice_len_too_small_i16
,
3239 slice_len_too_big_i16
,
3247 slice_len_too_small_u32
,
3254 slice_len_too_big_u32
,
3261 slice_len_too_small_i32
,
3268 slice_len_too_big_i32
,
3276 slice_len_too_small_u64
,
3283 slice_len_too_big_u64
,
3290 slice_len_too_small_i64
,
3297 slice_len_too_big_i64
,
3305 slice_len_too_small_u128
,
3312 slice_len_too_big_u128
,
3319 slice_len_too_small_i128
,
3326 slice_len_too_big_i128
,
3334 fn uint_bigger_buffer() {
3335 use crate::{ByteOrder, LittleEndian}
;
3336 let n
= LittleEndian
::read_uint(&[1, 2, 3, 4, 5, 6, 7, 8], 5);
3337 assert_eq
!(n
, 0x05_0403_0201);
3341 fn regression173_array_impl() {
3342 use crate::{BigEndian, ByteOrder, LittleEndian}
;
3346 let x
= BigEndian
::read_u16(&xs
);
3348 let x
= BigEndian
::read_u32(&xs
);
3350 let x
= BigEndian
::read_u64(&xs
);
3352 let x
= BigEndian
::read_u128(&xs
);
3354 let x
= BigEndian
::read_i16(&xs
);
3356 let x
= BigEndian
::read_i32(&xs
);
3358 let x
= BigEndian
::read_i64(&xs
);
3360 let x
= BigEndian
::read_i128(&xs
);
3363 let x
= LittleEndian
::read_u16(&xs
);
3365 let x
= LittleEndian
::read_u32(&xs
);
3367 let x
= LittleEndian
::read_u64(&xs
);
3369 let x
= LittleEndian
::read_u128(&xs
);
3371 let x
= LittleEndian
::read_i16(&xs
);
3373 let x
= LittleEndian
::read_i32(&xs
);
3375 let x
= LittleEndian
::read_i64(&xs
);
3377 let x
= LittleEndian
::read_i128(&xs
);
3383 #[cfg(feature = "std")]
3385 extern crate quickcheck
;
3388 use self::quickcheck
::{QuickCheck, StdGen, Testable}
;
3389 use self::rand
::thread_rng
;
3391 fn qc_unsized
<A
: Testable
>(f
: A
) {
3393 .gen(StdGen
::new(thread_rng(), 16))
3399 macro_rules
! calc_max
{
3400 ($max
:expr
, $bytes
:expr
) => {
3401 ($max
- 1) >> (8 * (8 - $bytes
))
3405 macro_rules
! qc_bytes_ext
{
3406 ($name
:ident
, $ty_int
:ty
, $max
:expr
,
3407 $bytes
:expr
, $read
:ident
, $write
:ident
) => {
3409 #[allow(unused_imports)]
3410 use crate::test
::{qc_sized, Wi128}
;
3412 BigEndian
, LittleEndian
, NativeEndian
, ReadBytesExt
,
3415 use std
::io
::Cursor
;
3419 fn prop(n
: $ty_int
) -> bool
{
3420 let mut wtr
= vec
![];
3421 wtr
.$write
::<BigEndian
>(n
.clone()).unwrap();
3422 let offset
= wtr
.len() - $bytes
;
3423 let mut rdr
= Cursor
::new(&mut wtr
[offset
..]);
3424 n
== rdr
.$read
::<BigEndian
>($bytes
).unwrap()
3426 qc_sized(prop
as fn($ty_int
) -> bool
, $max
);
3430 fn little_endian() {
3431 fn prop(n
: $ty_int
) -> bool
{
3432 let mut wtr
= vec
![];
3433 wtr
.$write
::<LittleEndian
>(n
.clone()).unwrap();
3434 let mut rdr
= Cursor
::new(wtr
);
3435 n
== rdr
.$read
::<LittleEndian
>($bytes
).unwrap()
3437 qc_sized(prop
as fn($ty_int
) -> bool
, $max
);
3441 fn native_endian() {
3442 fn prop(n
: $ty_int
) -> bool
{
3443 let mut wtr
= vec
![];
3444 wtr
.$write
::<NativeEndian
>(n
.clone()).unwrap();
3445 let offset
= if cfg
!(target_endian
= "big") {
3450 let mut rdr
= Cursor
::new(&mut wtr
[offset
..]);
3451 n
== rdr
.$read
::<NativeEndian
>($bytes
).unwrap()
3453 qc_sized(prop
as fn($ty_int
) -> bool
, $max
);
3457 ($name
:ident
, $ty_int
:ty
, $max
:expr
, $read
:ident
, $write
:ident
) => {
3459 #[allow(unused_imports)]
3460 use crate::test
::{qc_sized, Wi128}
;
3462 BigEndian
, LittleEndian
, NativeEndian
, ReadBytesExt
,
3465 use std
::io
::Cursor
;
3469 fn prop(n
: $ty_int
) -> bool
{
3470 let mut wtr
= vec
![];
3471 wtr
.$write
::<BigEndian
>(n
.clone()).unwrap();
3472 let mut rdr
= Cursor
::new(wtr
);
3473 n
== rdr
.$read
::<BigEndian
>().unwrap()
3475 qc_sized(prop
as fn($ty_int
) -> bool
, $max
- 1);
3479 fn little_endian() {
3480 fn prop(n
: $ty_int
) -> bool
{
3481 let mut wtr
= vec
![];
3482 wtr
.$write
::<LittleEndian
>(n
.clone()).unwrap();
3483 let mut rdr
= Cursor
::new(wtr
);
3484 n
== rdr
.$read
::<LittleEndian
>().unwrap()
3486 qc_sized(prop
as fn($ty_int
) -> bool
, $max
- 1);
3490 fn native_endian() {
3491 fn prop(n
: $ty_int
) -> bool
{
3492 let mut wtr
= vec
![];
3493 wtr
.$write
::<NativeEndian
>(n
.clone()).unwrap();
3494 let mut rdr
= Cursor
::new(wtr
);
3495 n
== rdr
.$read
::<NativeEndian
>().unwrap()
3497 qc_sized(prop
as fn($ty_int
) -> bool
, $max
- 1);
3506 ::std
::u16::MAX
as u64,
3513 ::std
::i16::MAX
as u64,
3520 ::std
::u32::MAX
as u64,
3527 ::std
::i32::MAX
as u64,
3534 ::std
::u64::MAX
as u64,
3541 ::std
::i64::MAX
as u64,
3548 ::std
::u64::MAX
as u64,
3555 ::std
::i64::MAX
as u64,
3560 qc_bytes_ext
!(prop_ext_u128
, Wi128
<u128
>, 16 + 1, read_u128
, write_u128
);
3561 qc_bytes_ext
!(prop_ext_i128
, Wi128
<i128
>, 16 + 1, read_i128
, write_i128
);
3566 calc_max
!(crate::test
::U64_MAX
, 1),
3574 calc_max
!(crate::test
::U64_MAX
, 2),
3582 calc_max
!(crate::test
::U64_MAX
, 3),
3590 calc_max
!(crate::test
::U64_MAX
, 4),
3598 calc_max
!(crate::test
::U64_MAX
, 5),
3606 calc_max
!(crate::test
::U64_MAX
, 6),
3614 calc_max
!(crate::test
::U64_MAX
, 7),
3622 calc_max
!(crate::test
::U64_MAX
, 8),
3701 prop_ext_uint128_10
,
3709 prop_ext_uint128_11
,
3717 prop_ext_uint128_12
,
3725 prop_ext_uint128_13
,
3733 prop_ext_uint128_14
,
3741 prop_ext_uint128_15
,
3749 prop_ext_uint128_16
,
3760 calc_max
!(crate::test
::I64_MAX
, 1),
3768 calc_max
!(crate::test
::I64_MAX
, 2),
3776 calc_max
!(crate::test
::I64_MAX
, 3),
3784 calc_max
!(crate::test
::I64_MAX
, 4),
3792 calc_max
!(crate::test
::I64_MAX
, 5),
3800 calc_max
!(crate::test
::I64_MAX
, 6),
3808 calc_max
!(crate::test
::I64_MAX
, 1),
3816 calc_max
!(crate::test
::I64_MAX
, 8),
3951 // Test slice serialization/deserialization.
3952 macro_rules
! qc_slice
{
3953 ($name
:ident
, $ty_int
:ty
, $read
:ident
, $write
:ident
, $zero
:expr
) => {
3955 use super::qc_unsized
;
3956 #[allow(unused_imports)]
3957 use crate::test
::Wi128
;
3959 BigEndian
, ByteOrder
, LittleEndian
, NativeEndian
,
3961 use core
::mem
::size_of
;
3965 #[allow(unused_unsafe)]
3966 fn prop(numbers
: Vec
<$ty_int
>) -> bool
{
3967 let numbers
: Vec
<_
> =
3968 numbers
.into_iter().map(|x
| x
.clone()).collect();
3969 let num_bytes
= size_of
::<$ty_int
>() * numbers
.len();
3970 let mut bytes
= vec
![0; num_bytes
];
3972 BigEndian
::$
write(&numbers
, &mut bytes
);
3974 let mut got
= vec
![$zero
; numbers
.len()];
3976 BigEndian
::$
read(&bytes
, &mut got
);
3981 qc_unsized(prop
as fn(_
) -> bool
);
3985 fn little_endian() {
3986 #[allow(unused_unsafe)]
3987 fn prop(numbers
: Vec
<$ty_int
>) -> bool
{
3988 let numbers
: Vec
<_
> =
3989 numbers
.into_iter().map(|x
| x
.clone()).collect();
3990 let num_bytes
= size_of
::<$ty_int
>() * numbers
.len();
3991 let mut bytes
= vec
![0; num_bytes
];
3993 LittleEndian
::$
write(&numbers
, &mut bytes
);
3995 let mut got
= vec
![$zero
; numbers
.len()];
3997 LittleEndian
::$
read(&bytes
, &mut got
);
4002 qc_unsized(prop
as fn(_
) -> bool
);
4006 fn native_endian() {
4007 #[allow(unused_unsafe)]
4008 fn prop(numbers
: Vec
<$ty_int
>) -> bool
{
4009 let numbers
: Vec
<_
> =
4010 numbers
.into_iter().map(|x
| x
.clone()).collect();
4011 let num_bytes
= size_of
::<$ty_int
>() * numbers
.len();
4012 let mut bytes
= vec
![0; num_bytes
];
4014 NativeEndian
::$
write(&numbers
, &mut bytes
);
4016 let mut got
= vec
![$zero
; numbers
.len()];
4018 NativeEndian
::$
read(&bytes
, &mut got
);
4023 qc_unsized(prop
as fn(_
) -> bool
);
4029 qc_slice
!(prop_slice_u16
, u16, read_u16_into
, write_u16_into
, 0);
4030 qc_slice
!(prop_slice_i16
, i16, read_i16_into
, write_i16_into
, 0);
4031 qc_slice
!(prop_slice_u32
, u32, read_u32_into
, write_u32_into
, 0);
4032 qc_slice
!(prop_slice_i32
, i32, read_i32_into
, write_i32_into
, 0);
4033 qc_slice
!(prop_slice_u64
, u64, read_u64_into
, write_u64_into
, 0);
4034 qc_slice
!(prop_slice_i64
, i64, read_i64_into
, write_i64_into
, 0);
4050 qc_slice
!(prop_slice_f32
, f32, read_f32_into
, write_f32_into
, 0.0);
4051 qc_slice
!(prop_slice_f64
, f64, read_f64_into
, write_f64_into
, 0.0);