Struct resol_vbus::BlobReader

pub struct BlobReader<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;
            }
        }
    }
}

Implementations

impl<R: Read> BlobReader<R>

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

Constructs a new BlobReader<T>.

pub fn get_ref(&self) -> &R

Get a reference to the underlying reader.

pub fn get_mut(&mut self) -> &mut R

Get a mutable reference to the underlying reader.

pub fn into_inner(self) -> R

Consumes this BlobReader, returning its inner Read value.

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

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 + Read> Debug for BlobReader<R>

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

Formats the value using the given formatter.

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

type Target = BlobBuffer

The resulting type after dereferencing.

fn deref(&self) -> &BlobBuffer

Dereferences the value.

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

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

Mutably dereferences the value.