Struct bao::encode::Encoder

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

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

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

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::Encoder::new(encoded_cursor);
encoder.write_all(b"some input")?;
encoder.finalize()?;

Implementations

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

pub fn new(inner: T) -> Self

Create a new Encoder 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 Encoder 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 finalize(&mut self) -> Result<Hash>

Finalize the encoding, after all the input has been written. You can’t keep using this Encoder again after calling finalize, and writing or finalizing again will panic.

The underlying strategy of the Encoder 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 finalize is a relatively expensive step.

pub fn into_inner(self) -> T

Return the underlying writer.

Trait Implementations

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

fn clone(&self) -> Encoder<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 Encoder<T>

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

Formats the value using the given formatter.

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

fn write(&mut self, input: &[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 Self

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