Struct Writer

pub struct Writer<W, D> {
    operation: D,
    writer: W,
    offset: usize,
    buffer: Vec<u8>,
    finished: bool,
    finished_frame: bool,
}

Implements the Write API around an Operation.

This can be used to wrap a raw in-memory operation in a write-focused API.

It can be used with either compression or decompression, and forwards the output to a wrapped Write.

Fields

operation: D

Either an encoder or a decoder.

writer: W

Where we send the output of the operation.

offset: usize

Offset into the buffer

Only things after this matter. Things before have already been sent to the writer.

buffer: Vec<u8>

Output buffer

Where the operation writes, before it gets flushed to the writer

finished: bool

finished_frame: bool

When true, the operation just finished a frame.

Only happens when decompressing. The context needs to be re-initialized to process the next frame.

Implementations

impl<W, D> Writer<W, D>

where W: Write, D: Operation,

pub fn new(writer: W, operation: D) -> Self

Creates a new Writer with a fixed buffer capacity of 32KB

All output from the given operation will be forwarded to writer.

pub fn new_with_capacity(writer: W, operation: D, capacity: usize) -> Self

Creates a new Writer with user defined capacity.

All output from the given operation will be forwarded to writer.

pub fn with_output_buffer( output_buffer: Vec<u8>, writer: W, operation: D, ) -> Self

Creates a new Writer using the given output buffer.

The output buffer must have pre-allocated capacity (its capacity will not be changed after).

Usually you would use Vec::with_capacity(desired_buffer_size).

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

Ends the stream.

This must be called after all data has been written to finish the stream.

If you forget to call this and just drop the Writer, you will have an incomplete output.

Keep calling it until it returns Ok(()), then don’t call it again.

fn with_buffer<F, T>(&mut self, f: F) -> T

where F: FnOnce(&mut OutBuffer<'_, Vec<u8>>, &mut D) -> T,

Run the given closure on self.buffer.

The buffer will be cleared, and made available wrapped in an OutBuffer.

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

Attempt to write self.buffer to the wrapped writer.

Returns Ok(()) once all the buffer has been written.

pub fn into_inner(self) -> (W, D)

Return the wrapped Writer and Operation.

Careful: if you call this before calling Writer::finish(), the output may be incomplete.

pub fn writer(&self) -> &W

Gives a reference to the inner writer.

pub fn writer_mut(&mut self) -> &mut W

Gives a mutable reference to the inner writer.

pub fn operation(&self) -> &D

Gives a reference to the inner operation.

pub fn operation_mut(&mut self) -> &mut D

Gives a mutable reference to the inner operation.

Trait Implementations

impl<W, D> Write for Writer<W, D>

where W: Write, D: Operation,

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

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

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

Flushes 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, args: Arguments<'_>) -> Result<(), Error>

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

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

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