Crate manual_serializer

Expand description

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.