Crate manual_serializer

This crate provides functionality for manual serialization and deserialization of data from u8 buffers. If you are looking for proper serialization libraries please consider using serde. This crate is useful for direct value extraction from memory buffers where you need to quickly extract values from structured data that may not be aligned.

NOTE: Current implementation support extraction only for primitives encoded with little-endian encoding.

Example

 
#[derive(Debug)]
pub struct Header {
    pub magic : usize,
    pub version : u16,
    pub payload : Vec<u8>,
}
 
impl TrySerialize for Header {
    type Error = Error;
    fn try_serialize(&self, dest: &mut Serializer) -> Result<()> {
        dest.try_align_u32()?;
        dest.try_store_u16le(self.magic as u16)?;
        dest.try_store_u16le(self.version)?;
        dest.try_store_u32le(self.payload.len() as u32)?;
        dest.try_store_u8_slice(&self.payload)?;
        Ok(())
    }
}
 
fn store() {
    let mut dest = Serializer::new(4096);
    let header = Header::default();
    dest.try_store(&header)?;
}
 
impl TryDeserialize for Header {
    type Error = Error;
 
    fn try_deserialize(src: &mut Deserializer) -> Result<Header> {
        src.try_align_u32()?;
 
        let magic = src.try_load_u16le()? as usize;
        let version = src.try_load_u16le()?;
        let payload_length = src.try_load_u32le()? as usize;
        let payload = src.try_load_u8_vec(payload_length)?.to_vec()?;
 
        Ok(Header{magic, version, payload})
    }
}
 
fn load(data: &[u8], offset: usize) -> Result<(u32,Header)>{
    let mut src = Deserializer::new(data);
    src.offset(offset)?;
    let signature = src.try_load_u32le()?;
    let header: Header = src.try_load()?;
    Ok((signature,header))
}

Re-exports

pub use error::Error;

pub use result::Result;

Modules

error

result

Structs

Deserializer

Deserializer referring an existing u8 buffer

Serializer

Serializer struct containing a serialization buffer. Please note that this struct expects to have a sufficiently large buffer to perform the ongoing serialization.

Traits

Deserialize

Deserialize trait accepted by Deserializer::load

Serialize

Serialize trait accepted by the Serializer::store

TryDeserialize

TryDeserialize trait accepted by Deserializer::try_load

TrySerialize

TrySerialize trait accepted by the Serializer::try_store

Functions

load_u8

load u8 value from the supplied buffer

load_u16le

load u16 little-endian value from the supplied buffer

load_u32le

load u32 little-endian value from the supplied buffer

load_u64le

load u64 little-endian value from the supplied buffer

store_u8

store u8 value in the supplied buffer, returning the number of bytes written

store_u16le

store u16 little-endian value in the supplied buffer, returning the number of bytes written

store_u32le

store u32 little-endian value in the supplied buffer, returning the number of bytes written

store_u64le

store u64 little-endian value in the supplied buffer, returning the number of bytes written