Struct BytesReader

pub struct BytesReader { /* private fields */ }

A struct to read protocol binary files

Examples

// FooBar is a message generated from a proto file
// in parcicular it contains a `from_reader` function
use foo_bar::FooBar;
use quick_protobuf::{MessageRead, BytesReader};

fn main() {
    // bytes is a buffer on the data we want to deserialize
    // typically bytes is read from a `Read`:
    // r.read_to_end(&mut bytes).expect("cannot read bytes");
    let mut bytes: Vec<u8>;

    // we can build a bytes reader directly out of the bytes
    let mut reader = BytesReader::from_bytes(&bytes);

    // now using the generated module decoding is as easy as:
    let foobar = FooBar::from_reader(&mut reader, &bytes).expect("Cannot read FooBar");

    // if instead the buffer contains a length delimited stream of message we could use:
    // while !r.is_eof() {
    //     let foobar: FooBar = r.read_message(&bytes).expect(...);
    //     ...
    // }
    println!("Found {} foos and {} bars", foobar.foos.len(), foobar.bars.len());
}

Implementations

impl BytesReader

pub fn from_bytes(bytes: &[u8]) -> BytesReader

Creates a new reader from chunks of data

pub fn next_tag(&mut self, bytes: &[u8]) -> Result<u32>

Reads next tag, None if all bytes have been read

pub fn read_u8(&mut self, bytes: &[u8]) -> Result<u8>

Reads the next byte

pub fn read_varint32(&mut self, bytes: &[u8]) -> Result<u32>

Reads the next varint encoded u64

pub fn read_varint64(&mut self, bytes: &[u8]) -> Result<u64>

Reads the next varint encoded u64

pub fn read_int32(&mut self, bytes: &[u8]) -> Result<i32>

Reads int32 (varint)

pub fn read_int64(&mut self, bytes: &[u8]) -> Result<i64>

Reads int64 (varint)

pub fn read_uint32(&mut self, bytes: &[u8]) -> Result<u32>

Reads uint32 (varint)

pub fn read_uint64(&mut self, bytes: &[u8]) -> Result<u64>

Reads uint64 (varint)

pub fn read_sint32(&mut self, bytes: &[u8]) -> Result<i32>

Reads sint32 (varint)

pub fn read_sint64(&mut self, bytes: &[u8]) -> Result<i64>

Reads sint64 (varint)

pub fn read_fixed64(&mut self, bytes: &[u8]) -> Result<u64>

Reads fixed64 (little endian u64)

pub fn read_fixed32(&mut self, bytes: &[u8]) -> Result<u32>

Reads fixed32 (little endian u32)

pub fn read_sfixed64(&mut self, bytes: &[u8]) -> Result<i64>

Reads sfixed64 (little endian i64)

pub fn read_sfixed32(&mut self, bytes: &[u8]) -> Result<i32>

Reads sfixed32 (little endian i32)

pub fn read_float(&mut self, bytes: &[u8]) -> Result<f32>

Reads float (little endian f32)

pub fn read_double(&mut self, bytes: &[u8]) -> Result<f64>

Reads double (little endian f64)

pub fn read_bool(&mut self, bytes: &[u8]) -> Result<bool>

Reads bool (varint, check if == 0)

pub fn read_enum<E: From<i32>>(&mut self, bytes: &[u8]) -> Result<E>

Reads enum, encoded as i32

pub fn read_bytes<'a>(&mut self, bytes: &'a [u8]) -> Result<&'a [u8]>

Reads bytes (Vec)

pub fn read_string<'a>(&mut self, bytes: &'a [u8]) -> Result<&'a str>

Reads string (String)

pub fn read_packed<'a, M, F>( &mut self, bytes: &'a [u8], read: F, ) -> Result<Vec<M>>

where F: FnMut(&mut BytesReader, &'a [u8]) -> Result<M>,

Reads packed repeated field (Vec)

Note: packed field are stored as a variable length chunk of data, while regular repeated fields behaves like an iterator, yielding their tag everytime

pub fn read_packed_fixed<'a, M>(&mut self, bytes: &'a [u8]) -> Result<&'a [M]>

Reads packed repeated field where M can directly be transmutted from raw bytes

Note: packed field are stored as a variable length chunk of data, while regular repeated fields behaves like an iterator, yielding their tag everytime

pub fn read_message<'a, M>(&mut self, bytes: &'a [u8]) -> Result<M>

where M: MessageRead<'a>,

Reads a nested message

First reads a varint and interprets it as the length of the message

pub fn read_message_by_len<'a, M>( &mut self, bytes: &'a [u8], len: usize, ) -> Result<M>

where M: MessageRead<'a>,

Reads a nested message

Reads just the message and does not try to read it’s size first.

• ‘len’ - The length of the message to be read.

pub fn read_map<'a, K, V, F, G>( &mut self, bytes: &'a [u8], read_key: F, read_val: G, ) -> Result<(K, V)>

where F: FnMut(&mut BytesReader, &'a [u8]) -> Result<K>, G: FnMut(&mut BytesReader, &'a [u8]) -> Result<V>, K: Debug + Default, V: Debug + Default,

Reads a map item: (key, value)

pub fn read_unknown(&mut self, bytes: &[u8], tag_value: u32) -> Result<()>

Reads unknown data, based on its tag value (which itself gives us the wire_type value)

pub fn len(&self) -> usize

Gets the remaining length of bytes not read yet

pub fn is_eof(&self) -> bool

Checks if self.len == 0

pub fn read_to_end(&mut self)

Advance inner cursor to the end

Trait Implementations

impl Clone for BytesReader

fn clone(&self) -> BytesReader

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for BytesReader

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for BytesReader

fn eq(&self, other: &BytesReader) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for BytesReader