Struct manual_serializer::Deserializer

pub struct Deserializer<'data> { /* private fields */ }

Deserializer referring an existing u8 buffer

Implementations

impl<'data> Deserializer<'data>

pub fn new(data: &'data [u8]) -> Deserializer<'data>

Create a new Deserializer referring the supplied u8 buffer

pub fn cursor(&self) -> usize

Get current byte position of the reader

pub fn remaining(&self) -> usize

Get amount of bytes remaining for consumption

pub fn try_offset(&mut self, offset: usize) -> Result<()>

Advance the reader by offset bytes

Examples found in repository

src/lib.rs (line 122)

    pub fn try_align(&mut self, align: usize) -> Result<()> {
        let offset = self.cursor % align;
        self.try_offset(offset)?;
        Ok(())
    }

pub fn try_align_u32(&mut self) -> Result<()>

Advance the cursor to ensure that current cursor position is 32-bit aligned

pub fn try_align_u64(&mut self) -> Result<()>

Advance the cursor to ensure that current cursor position is 64-bit aligned

pub fn try_align(&mut self, align: usize) -> Result<()>

Advance the cursor to ensure its alignment is on the align byte boundary. The following ensures that the cursor is on a 128-bit alignment:

deser.try_align(16)?;

Examples found in repository

src/lib.rs (line 105)

    pub fn try_align_u32(&mut self) -> Result<()> {
        self.try_align(4)?;
        Ok(())
    }
    
    /// Advance the cursor to ensure that current cursor position is 64-bit aligned
    pub fn try_align_u64(&mut self) -> Result<()> {
        self.try_align(8)?;
        Ok(())
    }

pub fn try_set_cursor(&mut self, cursor: usize) -> Result<()>

Set the cursor byte position to the given cursor value

pub fn try_load_u8_vec(&mut self, len: usize) -> Result<Vec<u8>>

Try reading Vec<u8> buffer of the supplied len byte length.

pub fn try_load_u16le_vec(&mut self, len: usize) -> Result<Vec<u16>>

Try reading Vec<u16> array of the supplied len elements. The u16 values are read as little-endian values.

pub fn try_load_utf16le_sz(&mut self) -> Result<String>

Try reading an array of u16 little-endian values from a zero-terminated u16 array and return it as a Rust String.
This function is useful for reading windows PCWSTR zero-terminated strings into Rust strings.

pub fn load_u8(&mut self) -> u8

Load a u8 value

pub fn try_load_u8(&mut self) -> Result<u8>

Try load a u8 value

pub fn load_u16le(&mut self) -> u16

Load a u16 little-endian value

pub fn try_load_u16le(&mut self) -> Result<u16>

Try load a u16 little-endian value

Examples found in repository

src/lib.rs (line 152)

    pub fn try_load_u16le_vec(&mut self, len: usize) -> Result<Vec<u16>> {
        let mut vec: Vec<u16> = Vec::with_capacity(len);
        for _ in 0..len {
            vec.push(self.try_load_u16le()?)
        }
        Ok(vec)
    }

    /// Try reading an array of `u16` little-endian values from a 
    /// zero-terminated `u16` array and return it as a Rust `String`.  
    /// This function is useful for reading windows `PCWSTR` zero-terminated 
    /// strings into Rust strings.
    pub fn try_load_utf16le_sz(&mut self) -> Result<String> {
        let mut vec: Vec<u16> = Vec::new();
        loop {
            let v = self.try_load_u16le()?;
            if v == 0 {
                break;
            }
            vec.push(v);
        }
        Ok(String::from_utf16(&vec)?)
    }

pub fn load_u32le(&mut self) -> u32

Load a u32 little-endian value

pub fn try_load_u32le(&mut self) -> Result<u32>

Try load a u32 little-endian value

pub fn load_u64le(&mut self) -> u64

Load a u64 little-endian value

pub fn try_load_u64le(&mut self) -> Result<u64>

Try load a u64 little-endian value

pub fn load<S: Deserialize>(&mut self) -> S

Load a primitive implementing a Deserialize trait

pub fn try_load<S: TryDeserialize>(&mut self) -> Result<S, S::Error>

Try load a primitive implementing a Deserialize trait