Struct base64::write::encoder::EncoderWriter[][src]

pub struct EncoderWriter<'a, W: 'a + Write> {
    config: Config,
    w: &'a mut W,
    extra_input: [u8; 3],
    extra_input_occupied_len: usize,
    output: [u8; 1024],
    output_occupied_len: usize,
    finished: bool,
    panicked: bool,
}
Expand description

A Write implementation that base64 encodes data before delegating to the wrapped writer.

Because base64 has special handling for the end of the input data (padding, etc), there’s a finish() method on this type that encodes any leftover input bytes and adds padding if appropriate. It’s called automatically when deallocated (see the Drop implementation), but any error that occurs when invoking the underlying writer will be suppressed. If you want to handle such errors, call finish() yourself.

Examples

use std::io::Write;

// use a vec as the simplest possible `Write` -- in real code this is probably a file, etc.
let mut wrapped_writer = Vec::new();
{
    let mut enc = base64::write::EncoderWriter::new(
        &mut wrapped_writer, base64::STANDARD);

    // handle errors as you normally would
    enc.write_all(b"asdf").unwrap();
    // could leave this out to be called by Drop, if you don't care
    // about handling errors
    enc.finish().unwrap();

}

// base64 was written to the writer
assert_eq!(b"YXNkZg==", &wrapped_writer[..]);

Panics

Calling write() after finish() is invalid and will panic.

Errors

Base64 encoding itself does not generate errors, but errors from the wrapped writer will be returned as per the contract of Write.

Performance

It has some minor performance loss compared to encoding slices (a couple percent). It does not do any heap allocation.

Fields

config: Configw: &'a mut W

Where encoded data is written to

extra_input: [u8; 3]

Holds a partial chunk, if any, after the last write(), so that we may then fill the chunk with the next write(), encode it, then proceed with the rest of the input normally.

extra_input_occupied_len: usize

How much of extra is occupied, in [0, MIN_ENCODE_CHUNK_SIZE].

output: [u8; 1024]

Buffer to encode into. May hold leftover encoded bytes from a previous write call that the underlying writer did not write last time.

output_occupied_len: usize

How much of output is occupied with encoded data that couldn’t be written last time

finished: bool

True iff padding / partial last chunk has been written.

panicked: bool

panic safety: don’t write again in destructor if writer panicked while we were writing to it

Implementations

Create a new encoder that will write to the provided delegate writer w.

Encode all remaining buffered data and write it, including any trailing incomplete input triples and associated padding.

Once this succeeds, no further writes can be performed, as that would produce invalid base64.

This may write to the delegate writer multiple times if the delegate writer does not accept all input provided to its write each invocation.

Errors

The first error that is not of ErrorKind::Interrupted will be returned.

Write as much of the encoded output to the delegate writer as it will accept, and store the leftovers to be attempted at the next write() call. Updates self.output_occupied_len.

Errors

Errors from the delegate writer are returned. In the case of an error, self.output_occupied_len will not be updated, as errors from write are specified to mean that no write took place.

Write all buffered encoded output. If this returns Ok, self.output_occupied_len is 0.

This is basically write_all for the remaining buffered data but without the undesirable abort-on-Ok(0) behavior.

Errors

Any error emitted by the delegate writer abort the write loop and is returned, unless it’s Interrupted, in which case the error is ignored and writes will continue.

Trait Implementations

Formats the value using the given formatter. Read more

Executes the destructor for this type. Read more

Encode input and then write to the delegate writer.

Under non-error circumstances, this returns Ok with the value being the number of bytes of input consumed. The value may be 0, which interacts poorly with write_all, which interprets Ok(0) as an error, despite it being allowed by the contract of write. See https://github.com/rust-lang/rust/issues/56889 for more on that.

If the previous call to write provided more (encoded) data than the delegate writer could accept in a single call to its write, the remaining data is buffered. As long as buffered data is present, subsequent calls to write will try to write the remaining buffered data to the delegate and return either Ok(0) – and therefore not consume any of input – or an error.

Errors

Any errors emitted by the delegate writer are returned.

Because this is usually treated as OK to call multiple times, it will not flush any incomplete chunks of input or write padding.

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

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

Determines if this Writer has an efficient write_vectored implementation. Read more

Attempts to write an entire buffer into this writer. Read more

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

Attempts to write multiple buffers into this writer. Read more

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

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

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

Immutably borrows from an owned value. Read more

Mutably borrows from an owned value. Read more

Performs the conversion.

Performs the conversion.

The type returned in the event of a conversion error.

Performs the conversion.

The type returned in the event of a conversion error.

Performs the conversion.