Struct bao::encode::Writer

pub struct Writer<T: Read + Write + Seek> { /* private fields */ }

An incremental encoder. Note that you must call finish after you’re done writing.

Writer supports both combined and outboard encoding, depending on which constructor you use.

Writer is currently only available when std is enabled, because std::io::Write is a required part of its interface. However, it could be extended to support no_std-compatible traits outside of the standard library too. Please reach out to me if you need that.

This implementation is single-threaded.

Example

use std::io::prelude::*;

let mut encoded_incrementally = Vec::new();
let encoded_cursor = std::io::Cursor::new(&mut encoded_incrementally);
let mut encoder = bao::encode::Writer::new(encoded_cursor);
encoder.write_all(b"some input")?;
encoder.finish()?;

Implementations

impl<T: Read + Write + Seek> Writer<T>

pub fn new(inner: T) -> Self

Create a new Writer that will produce a combined encoding.The encoding will contain all the input bytes, so that it can be decoded without the original input file. This is what you get from bao encode.

pub fn new_outboard(inner: T) -> Self

Create a new Writer for making an outboard encoding. That means that the encoding won’t include any input bytes. Instead, the input will need to be supplied as a separate argument when the outboard encoding is later decoded. This is what you get from bao encode --outboard.

pub fn finish(&mut self) -> Result<Hash>

Finalize the encoding, after all the input has been written. You can’t use this type again after calling finish.

The underlying strategy of the Writer is to first store the tree in a post-order layout, and then to go back and flip the entire thing into pre-order. That makes it possible to stream input without knowing its length in advance, which is a core requirement of the std::io::Write interface. The downside is that finish is a relatively expensive step.

Trait Implementations

impl<T: Clone + Read + Write + Seek> Clone for Writer<T>

fn clone(&self) -> Writer<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Read + Write + Seek> Debug for Writer<T>

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

Formats the value using the given formatter.

impl<T: Read + Write + Seek> Write for Writer<T>

fn write(&mut self, buf: &[u8]) -> Result<usize>

Write a buffer into this writer, returning how many bytes were written.

fn flush(&mut self) -> Result<()>

Flush this output stream, ensuring that all intermediately buffered contents reach their destination.

fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>

Like write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Writer has an efficient write_vectored implementation.

fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>

Attempts to write an entire buffer into this writer.

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>

🔬This is a nightly-only experimental API. (write_all_vectored)

Attempts to write multiple buffers into this writer.

fn write_fmt(&mut self, fmt: Arguments<'_>) -> Result<(), Error>

Writes a formatted string into this writer, returning any error encountered.

fn by_ref(&mut self) -> &mut Selfwhere
    Self: Sized,

Creates a “by reference” adapter for this instance of Write.