[][src]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>[src]

Important traits for EncoderWriter<'a, W>
pub fn new(w: &'a mut W, config: Config) -> EncoderWriter<'a, W>[src]

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

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

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.

Trait Implementations

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

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

impl<'a, W: Write> Write for EncoderWriter<'a, W>[src]

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

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.

fn flush(&mut self) -> Result<()>[src]

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_vectored(&mut self, bufs: &[IoSlice]) -> Result<usize, Error>1.36.0[src]

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

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

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

fn write_fmt(&mut self, fmt: Arguments) -> Result<(), Error>1.0.0[src]

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

fn by_ref(&mut self) -> &mut Self1.0.0[src]

Creates a "by reference" adaptor for this instance of Write. Read more

Auto Trait Implementations

impl<'a, W> Unpin for EncoderWriter<'a, W>

impl<'a, W> Sync for EncoderWriter<'a, W> where
    W: Sync

impl<'a, W> Send for EncoderWriter<'a, W> where
    W: Send

impl<'a, W> !UnwindSafe for EncoderWriter<'a, W>

impl<'a, W> RefUnwindSafe for EncoderWriter<'a, W> where
    W: RefUnwindSafe

Blanket Implementations

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<W> WriteBytesExt for W where
    W: Write + ?Sized
[src]

fn write_u8(&mut self, n: u8) -> Result<(), Error>[src]

Writes an unsigned 8 bit integer to the underlying writer. Read more

fn write_i8(&mut self, n: i8) -> Result<(), Error>[src]

Writes a signed 8 bit integer to the underlying writer. Read more

fn write_u16<T>(&mut self, n: u16) -> Result<(), Error> where
    T: ByteOrder
[src]

Writes an unsigned 16 bit integer to the underlying writer. Read more

fn write_i16<T>(&mut self, n: i16) -> Result<(), Error> where
    T: ByteOrder
[src]

Writes a signed 16 bit integer to the underlying writer. Read more

fn write_u24<T>(&mut self, n: u32) -> Result<(), Error> where
    T: ByteOrder
[src]

Writes an unsigned 24 bit integer to the underlying writer. Read more

fn write_i24<T>(&mut self, n: i32) -> Result<(), Error> where
    T: ByteOrder
[src]

Writes a signed 24 bit integer to the underlying writer. Read more

fn write_u32<T>(&mut self, n: u32) -> Result<(), Error> where
    T: ByteOrder
[src]

Writes an unsigned 32 bit integer to the underlying writer. Read more

fn write_i32<T>(&mut self, n: i32) -> Result<(), Error> where
    T: ByteOrder
[src]

Writes a signed 32 bit integer to the underlying writer. Read more

fn write_u48<T>(&mut self, n: u64) -> Result<(), Error> where
    T: ByteOrder
[src]

Writes an unsigned 48 bit integer to the underlying writer. Read more

fn write_i48<T>(&mut self, n: i64) -> Result<(), Error> where
    T: ByteOrder
[src]

Writes a signed 48 bit integer to the underlying writer. Read more

fn write_u64<T>(&mut self, n: u64) -> Result<(), Error> where
    T: ByteOrder
[src]

Writes an unsigned 64 bit integer to the underlying writer. Read more

fn write_i64<T>(&mut self, n: i64) -> Result<(), Error> where
    T: ByteOrder
[src]

Writes a signed 64 bit integer to the underlying writer. Read more

fn write_u128<T>(&mut self, n: u128) -> Result<(), Error> where
    T: ByteOrder
[src]

Writes an unsigned 128 bit integer to the underlying writer.

fn write_i128<T>(&mut self, n: i128) -> Result<(), Error> where
    T: ByteOrder
[src]

Writes a signed 128 bit integer to the underlying writer.

fn write_uint<T>(&mut self, n: u64, nbytes: usize) -> Result<(), Error> where
    T: ByteOrder
[src]

Writes an unsigned n-bytes integer to the underlying writer. Read more

fn write_int<T>(&mut self, n: i64, nbytes: usize) -> Result<(), Error> where
    T: ByteOrder
[src]

Writes a signed n-bytes integer to the underlying writer. Read more

fn write_uint128<T>(&mut self, n: u128, nbytes: usize) -> Result<(), Error> where
    T: ByteOrder
[src]

Writes an unsigned n-bytes integer to the underlying writer. Read more

fn write_int128<T>(&mut self, n: i128, nbytes: usize) -> Result<(), Error> where
    T: ByteOrder
[src]

Writes a signed n-bytes integer to the underlying writer. Read more

fn write_f32<T>(&mut self, n: f32) -> Result<(), Error> where
    T: ByteOrder
[src]

Writes a IEEE754 single-precision (4 bytes) floating point number to the underlying writer. Read more

fn write_f64<T>(&mut self, n: f64) -> Result<(), Error> where
    T: ByteOrder
[src]

Writes a IEEE754 double-precision (8 bytes) floating point number to the underlying writer. Read more