Struct base64::write::EncoderWriter

pub struct EncoderWriter<'a, W: 'a + Write> { /* fields omitted */ }

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.

Methods

impl<'a, W: Write> EncoderWriter<'a, W>

Important traits for EncoderWriter<'a, W>

impl<'a, W: Write> Write for EncoderWriter<'a, W>

pub fn new(w: &'a mut W, config: Config) -> EncoderWriter<'a, W>

Create a new encoder around an existing writer.

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

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.

Errors

Assuming the wrapped writer obeys the Write contract, if this returns Err, no data was written, and finish() may be retried if appropriate for the type of error, etc.

Trait Implementations

impl<'a, W: Write> Debug for EncoderWriter<'a, W>

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

Formats the value using the given formatter.

impl<'a, W: Write> Write for EncoderWriter<'a, W>

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

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

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

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

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

Attempts to write an entire buffer into this write.

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" adaptor for this instance of Write.

impl<'a, W: Write> Drop for EncoderWriter<'a, W>

fn drop(&mut self)

Executes the destructor for this type.