## byte-io: a simple crate for read/write numbers to/from binary.
This crate only contains 4 functions:
* `write_be`: write number to big-endian slice.
* `read_be`: read number from big-endian slice.
* `write_le`: write number to little-endian slice.
* `read_le`: read number from little-endian slice.
Please notice that byte-io does __NOT__ focus on efficiency, which means that it may be slow
while handling big streams (e.g. hundreds of Mbytes or more).
## How to use
Add the following line to your `[dependencies]` section in `Cargo.toml`
```toml
byte-io = { git = "https://github.com/zhaihj/byte-io-rust", branch= "master" }
```
or you can also download it from [crates.io](http://crates.io):
```toml
byte-io = "0.1"
```
## Examples:
Read from a slice is simple:
```rust
use byte_io::*;
fn main() {
let data = [0x00, 0x00, 0x01, 0x01, 0xAB, 0xCD, 0xEF, 0x89];
assert_eq!(read_be::<u32>(&data), 0x0101);
assert_eq!(read_be::<u16>(&data[4..]), 0xABCD);
assert_eq!(read_le::<u16>(&data[4..]), 0xCDAB);
assert_eq!(read_le::<u8>(&data[4..]), 0xAB);
}
```
Write is also easy:
```rust
use byte_io::*;
fn main() {
let mut buf = [0u8;8];
write_be(&0xABCDEFu32, &mut buf);
assert_eq!(buf, [0x00, 0xAB, 0xCD, 0xEF, 0x00, 0x00, 0x00, 0x00]);
write_le(&0xABCDEFu32, &mut buf[4..]);
assert_eq!(buf, [0x00, 0xAB, 0xCD, 0xEF, 0xEF, 0xCD, 0xAB, 0x00]);
}
```
Moreover, you can even read/write `Vec<T>`:
```rust
use byte_io::*;
fn main() {
let mut buf = [0u8;8];
let data = vec![0x1234u16,0x5678u16];
write_le(&data, &mut buf);
assert_eq!(buf, [0x34, 0x12, 0x78, 0x56, 0x00, 0x00, 0x00, 0x00]);
assert_eq!(data, read_le::<Vec<u16>>(&buf[0..4]));
let u32_vec = read_be::<Vec<u32>>(&buf[4..]);
assert_eq!(u32_vec.len(), 1);
assert_eq!(u32_vec.first(), Some(&0));
}
```
The following code also works:
```rust
use byte_io::*;
fn main() {
let buf = [0xAA, 0xBB, 0xCC, 0xDD];
assert_eq!(u32::from_u8_be(&buf), 0xAABBCCDD);
}
```