Read and write numbers in big-endian and little-endian.
Add the following to your Cargo manifest.
toml
[dependencies]
eio = "0.1"
And bring the ReadExt and/or WriteExt traits into scope.
rust
use eio::{ReadExt, WriteExt};
The most common usage is parsing numbers from a source. You can do this using
the read_le() and read_be() methods on anything that implements Read.
```rust use eio::ReadExt;
// Cursor implements Read
let mut rdr = std::io::Cursor::new([
0x37, 0x13,
0x12, 0x34, 0x56, 0x78,
0x00, 0x09, 0x10,
]);
// Read a two byte u16 in little-endian order
let i: u16 = rdr.readle()?;
asserteq!(i, 0x1337);
// Read a four byte i32 in big-endian order
let i: i32 = rdr.readbe()?;
asserteq!(i, 0x12345678);
// Read a three byte array let a: [u8; 3] = rdr.readarray()?; asserteq!(a, [0x00, 0x09, 0x10]); ```
Serialization of numbers can be done using the write_le() and write_be().
This can be done on anything that implements Write.
```rust use eio::WriteExt;
// &mut [u8] implements Write.
let mut wtr = Vec::new();
// Write a four byte f32 in little-endian order
wtr.writele(1f32)?;
// Write a one byte u8
wtr.writebe(7u8)?;
assert_eq!(wtr, &[0, 0, 0x80, 0x3f, 0x07]); ```
In no_std contexts the FromBytes and ToBytes traits can be used directly.
```rust
use eio::{FromBytes, ToBytes};
let x: u32 = FromBytes::frombebytes([0, 0, 0, 7]); assert_eq!(x, 7);
let data = ToBytes::tolebytes(x); assert_eq!(data, [7, 0, 0, 0]); ```
eio provides the same capabilities as the popular [byteorder] crate but with
a very different API. The advantages of eio are the following:
FromBytes or ToBytes for their own
integer types.{from,to}_{le,be}_bytes functions to do the conversion for
floats and integers. [byteorder] reimplements these.rust
// byteorder
let i = rdr.read_u16::<BigEndian>()?;
// eio
let i: u16 = rdr.read_be()?;
Licensed under either of
at your option.