This crate is purely for marshalling and unmarshalling a data to send over a network, main deal is ByteBuff witch is used for serilizing and deserilizing. There is also Marshal trait that can be derivated on structs.

example

extern crate bytebuff;
use bytebuff::marshall_derive::Marshall;
use bytebuff::Marshall;
use bytebuff::ByteBuff;

#[derive(Marshall)]
struct Point {
    x: f32,
    y: f32,
}

#[derive(Marshall)]
struct Dummy {
    #[marshall(nested)]
    position: Point,
    name: String,
    #[marshall(ignore)]
    useless_stuff: i128,
}

fn main() {
    let mut buff = ByteBuff::new();

    let dummy = Dummy {
        useless_stuff: 10,
        position: Point { x: 10.0, y: 70.0 },
        name: String::from("Mlokogrgel"),
    };

    //dummy can write it self to ByteBuff
    dummy.marshall(&mut buff);

    //now imagine we sent buffer with dummy over the network
    let mut buff = ByteBuff::from_bytes(buff.data());

    //and dummy can also read its self from buffer
    let de_dummy = Dummy::unmarshall(&mut buff).unwrap();

    //ignored data don't ewen get written to buffer in first place and is replaced
    //by default, in any case you can always implement Default trait to your types
    assert_eq!(de_dummy.useless_stuff, Default::default());

    //you can nest how match you want as long as you annotate so
    assert_eq!(10.0, de_dummy.position.x);
    assert_eq!(70.0, de_dummy.position.y);

    // other then all numbers, strings, booleans and bite vectors are supported
    assert_eq!(String::from("Mlokogrgel"), de_dummy.name);
}