frago9876543210 / endiannezz

Zero dependencies library for I/O endianness on high-level

endiannezz

Zero dependencies library for I/O endianness on high-level

Installing

[dependencies]
endiannezz = "0.6"

Using #[derive(Io)]

use endiannezz::Io;
use std::io::Result;

#[derive(Io)]
#[endian(big)]
struct ParseMe {
    works: bool,
    data: u32,
    #[endian(little)]
    extra: i16,
}

fn main() -> Result<()> {
    let s1 = ParseMe {
        works: true,
        data: 10,
        extra: 20,
    };

    //writing struct as bytes into vec
    let mut vec = Vec::new();
    s1.write(&mut vec)?;

    let mut slice = vec.as_slice();
    #[rustfmt::skip]
    assert_eq!(slice, &[
        1, //bool as byte
        0, 0, 0, 10, //u32 in big-endian (because big-endian is set on top place struct as default)
        20, 0, //i16 in little-endian (overriding default)
    ]);

    //reading struct from bytes
    let _s2 = ParseMe::read(&mut slice)?;

    Ok(())
}

Simple example

use endiannezz::ext::{EndianReader, EndianWriter};
use endiannezz::{BigEndian, LittleEndian, NativeEndian};
use std::io::Result;

fn main() -> Result<()> {
    let mut vec = Vec::new();

    vec.try_write::<LittleEndian, i32>(1)?;
    vec.try_write::<BigEndian, _>(2)?;
    vec.try_write::<NativeEndian, _>(3_u16)?;

    let mut slice = vec.as_slice();

    slice.try_read::<LittleEndian, i32>()?;
    let _num32: i32 = slice.try_read::<BigEndian, _>()?;
    let _num16: u16 = slice.try_read::<NativeEndian, _>()?;

    Ok(())
}

endiannezz's Issues

Wrong parsing of attributes

error: please specify default endian
  --> src/main.rs:5:1
   |
5  | / #[repr(C, packed)]
6  | | #[endian(big)]
7  | | struct ParseMe {
8  | |     works: bool,
...  |
11 | |     extra: i16,
12 | | }
   | |_^

Use const generics to implement Io trait for [T; N]

Also can be used for slice and together with #11

#[endian(_)] no longer valid

Use read_initializer for reading into uninit memory

Lack of tests

Better type level checks

trait X {
    type T;
}

//*impl*

//derived method
<... as X>::T::write(...);

Stable way to decl enums tag

stable rust:

#[derive(Io)]
#[endian(default_endian)] //only for Prim
#[repr(Prim)] //u32, i32, ...
enum Packet {
    #[tag(0xdeadbeef)]
    Foo(type: Io),
}

nightly rust: (WIP: enums branch)

#[derive(Io)]
#[endian(default_endian)] //only for Prim
#[repr(Prim)] //u32, i32, ...
enum Packet {
    Foo(type: Io, type1: Prim, ...) = 0xdeadbeef,
}