# Struct base64::write::EncoderWriter

source · [−]

    pub struct EncoderWriter<W: Write> { /* private fields */ }

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 enc = base64::write::EncoderWriter::new(Vec::new(), 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 or getting the delegate writer back
    let delegate = enc.finish().unwrap();

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

## Panics

Calling `write()` (or related methods) or `finish()` after `finish()` has completed without error 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.

## Implementations

source

### impl<W: Write> EncoderWriter<W>

source

#### pub fn new(w: W, config: Config) -> EncoderWriter<W>ⓘNotable traits for EncoderWriter<W>`impl<W: Write> Write for EncoderWriter<W>`

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

source

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

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

Once this succeeds, no further writes or calls to this method are allowed.

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

If you don’t care about error handling, it is not necessary to call this function, as the equivalent finalization is done by the Drop impl.

Returns the writer that this was constructed around.

##### Errors

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

## Trait Implementations

source

### impl<W: Write> Debug for EncoderWriter<W>

source

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

Formats the value using the given formatter. Read more

source

### impl<W: Write> Drop for EncoderWriter<W>

source

#### fn drop(&mut self)

Executes the destructor for this type. Read more

source

### impl<W: Write> Write for EncoderWriter<W>

source

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

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.

source

#### 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.

##### Errors

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

1.36.0 · source

#### fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>

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

source

#### fn is_write_vectored(&self) -> bool

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

Determines if this `Write`r has an efficient `write_vectored` implementation. Read more

1.0.0 · source

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

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

source

#### 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. Read more

1.0.0 · source

#### fn write_fmt(&mut self, fmt: Arguments<'_>) -> Result<(), Error>

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

1.0.0 · source

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

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

## Auto Trait Implementations

### impl<W> RefUnwindSafe for EncoderWriter<W> where
W: RefUnwindSafe,

### impl<W> Send for EncoderWriter<W> where
W: Send,

### impl<W> Sync for EncoderWriter<W> where
W: Sync,

### impl<W> Unpin for EncoderWriter<W> where
W: Unpin,

### impl<W> UnwindSafe for EncoderWriter<W> where
W: UnwindSafe,

## Blanket Implementations

source

### impl<T> Any for T where
T: 'static + ?Sized,

source

#### fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`. Read more

source

### impl<T> Borrow<T> for T where
T: ?Sized,

const: unstable · source

#### fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

source

### impl<T> BorrowMut<T> for T where
T: ?Sized,

const: unstable · source

#### fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

source

### impl<T> From<T> for T

const: unstable · source

#### fn from(t: T) -> T

Returns the argument unchanged.

source

### impl<T, U> Into<U> for T where
U: From<T>,

const: unstable · source

#### fn into(self) -> U

Calls `U::from(self)`.

That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

source

### impl<T, U> TryFrom<U> for T where
U: Into<T>,

#### type Error = Infallible

The type returned in the event of a conversion error.

const: unstable · source

#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.

source

### impl<T, U> TryInto<U> for T where
U: TryFrom<T>,

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

The type returned in the event of a conversion error.

const: unstable · source

#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.