Crate manual_serializer

Source
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.

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