bytestream

This crate provides a convenient way of reading and writing bytes to a buffer that implements the standard [Read] or [Write] traits.

Supported std types include [u8], [u16], [u32], [u64], [i8], [i16], [i32], [i64], [String], [Vec<T>] and [HashMap<T, V>].

Reading and writing of these types is done using the [byteorder] crate as big endian. The reason for reading and writing as big endian is that this crate was written with sending data over the network in mind. It should be fairly easy to add support for little endian if anyone would have use for it, but for now it's big endian only.

Installation

Add the following to your Cargo.toml file:

toml [dependencies] bytestream = "0.*"

Documentation

You can find the documentation at: https://docs.rs/bytestream

Examples

```rust use std::io::{Cursor, Read, Result, Write}; use bytestream::Streamable;

[derive(Debug, PartialEq)]

pub struct Foo { bar: String, baz: u32, }

impl Streamable for Foo { fn readfrom(buffer: &mut R) -> Result { Ok(Self { bar: String::readfrom(buffer)?, baz: u32::read_from(buffer)?, }) }

fn write_to<W: Write>(&self, buffer: &mut W) -> Result<()> {
    self.bar.write_to(buffer)?;
    self.baz.write_to(buffer)?;
    Ok(())
}

}

// Create a new instance of Foo let foo = Foo { bar: "corgi".to_owned(), baz: 37 };

// Write it to a buffer that implements the Write trait let mut buffer = Vec::::new(); foo.write_to(&mut buffer).unwrap();

// Read it back from the buffer // We wrap the buffer in a Cursor:: that implements the Read trait let mut cursor = Cursor::new(buffer); let other = Foo::read_from(&mut cursor).unwrap();

assert_eq!(foo, other); ```

Exclude Streamable support for std types

If you do not wish to include out-of-the-box support for std types, you can exclude the default batteries-included feature in your Cargo.toml file:

toml [dependencies] bytestream = { Version = "0.*", default-features = false }

Credits

The inspiration from this crate came from the [Stevenarella] Minecraft client.