Struct async_resol_vbus::BlobReader

pub struct BlobReader<R> where
    R: Read,  { /* fields omitted */ }

A buffering reader that allows to borrow the internal buffer.

The BlobReader behaves like a std::io::BufReader with the addition that the internal buffer grows if necessary.

Examples

use std::fs::File;

use resol_vbus::{BlobReader, StreamBlobLength};
use resol_vbus::recording_decoder::{length_from_bytes};

let file = File::open("20161202_packets.vbus").unwrap();
let mut br = BlobReader::new(file);

loop {
    match length_from_bytes(&br) {
        StreamBlobLength::BlobLength(size) => {
            // do something with the data

            // afterwards consume it
            br.consume(size);
        }
        StreamBlobLength::Malformed => {
            // just consume the current starting byte, perhaps a valid blob is hidden behind it
            br.consume(1);
        }
        StreamBlobLength::Partial => {
            // internal buffer is either empty or contains the valid start of a blob, read more
            // data
            if br.read().unwrap() == 0 {
                break;
            }
        }
    }
}

Methods

impl<R> BlobReader<R> where
    R: Read, 

pub fn new(reader: R) -> BlobReader<R>

Constructs a new BlobReader<T>.

pub fn into_inner(self) -> R

Consumes this BlobReader, returning its inner Read value.

pub fn read(&mut self) -> Result<usize, Error>

Reads additional data to the internal buffer.

Methods from Deref<Target = BlobBuffer>

pub fn extend_from_slice(&mut self, data: &[u8])

Provide additional data to the internal buffer.

pub fn consume(&mut self, length: usize)

Consume the given amount of data from the internal buffer.

pub fn len(&self) -> usize

Returns the unconsumed byte length of the internal buffer.

pub fn is_empty(&self) -> bool

Returns whether the internal buffer is empty.

pub fn offset(&self) -> usize

Get amount of already consumed bytes.

Trait Implementations

impl<R> Debug for BlobReader<R> where
    R: Read + Debug, 

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

Formats the value using the given formatter.

impl<R> Deref for BlobReader<R> where
    R: Read, 

type Target = BlobBuffer

The resulting type after dereferencing.

fn deref(&self) -> &BlobBuffer

Dereferences the value.

impl<R> DerefMut for BlobReader<R> where
    R: Read, 

fn deref_mut(&mut self) -> &mut BlobBuffer

Mutably dereferences the value.