Struct Decoder 

pub struct Decoder<W, A, const PAD: bool>
where
    A: Alphabet,
{ /* private fields */ }

A streaming Base64 decoder for std::io::Write.

Like any Write implementation, Write::write may accept only part of the provided input. Accepted input may be held as decoded output until Write::flush, Self::try_finish, Self::finish, or a later write drains the wrapped writer. Use Write::write_all when the whole input slice must be consumed.

Implementations

impl<W, A, const PAD: bool> Decoder<W, A, PAD>

where A: Alphabet,

pub const fn new(inner: W, engine: Engine<A, PAD>) -> Self

Creates a new streaming decoder.

pub fn get_ref(&self) -> &W

Returns a shared reference to the wrapped writer.

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

Returns a mutable reference to the wrapped writer.

pub const fn engine(&self) -> Engine<A, PAD>

Returns the Base64 engine used by this adapter.

pub const fn is_padded(&self) -> bool

Returns whether this adapter uses padded Base64.

pub const fn pending_len(&self) -> usize

Returns the number of encoded input bytes currently buffered until a complete 4-byte Base64 decode quantum is available.

pub const fn has_pending_input(&self) -> bool

Returns whether this decoder currently holds a partial input quantum.

pub const fn pending_input_needed_len(&self) -> usize

Returns how many additional input bytes are needed to complete the currently buffered decode quantum.

Returns 0 when no partial input quantum is buffered.

pub const fn buffered_output_len(&self) -> usize

Returns the number of decoded bytes buffered for the wrapped writer after a previous write or flush could not fully drain them.

pub const fn buffered_output_capacity(&self) -> usize

Returns the maximum number of decoded bytes this adapter can buffer before returning bytes to the caller.

pub const fn buffered_output_remaining_capacity(&self) -> usize

Returns how many more decoded bytes can be buffered before this adapter must drain the wrapped writer.

pub const fn has_buffered_output(&self) -> bool

Returns whether this decoder has decoded output waiting to be written to the wrapped writer.

pub const fn has_terminal_padding(&self) -> bool

Returns whether this decoder has processed a terminal padded block.

Once this returns true, later calls to Write::write with additional input return an error because strict Base64 does not permit trailing payload bytes after padding.

pub const fn is_finalized(&self) -> bool

Returns whether this decoder has been finalized.

Once this returns true, later non-empty writes return an error.

pub const fn is_failed(&self) -> bool

Returns whether this decoder has rejected malformed Base64 input.

Once this returns true, later writes, flushes, and finalization attempts return an error. The unchecked Self::into_inner method can still be used for explicit recovery of the wrapped writer.

pub const fn can_into_inner(&self) -> bool

Returns whether Self::try_into_inner can recover the wrapped writer without discarding pending encoded input.

pub fn into_inner(self) -> W

Consumes the decoder without flushing pending input.

Prefer Self::finish when the decoded output must be complete.

pub fn try_into_inner(self) -> Result<W, Self>

Consumes the decoder only when no partial input quantum is buffered.

This does not flush or finalize the wrapped writer. It is a checked alternative to Self::into_inner for callers that want to avoid accidentally discarding pending encoded input bytes.

impl<W, A, const PAD: bool> Decoder<W, A, PAD>

where W: Write, A: Alphabet,

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

Validates any final pending input and flushes the wrapped writer without consuming this decoder.

After this succeeds, Self::pending_len returns 0, later writes are rejected, and Self::finish can still be used to recover the wrapped writer. If the final buffered input is malformed, an error is returned and the caller still owns the decoder for diagnostics or explicit recovery.

pub fn finish(self) -> Result<W>

Validates final pending input, flushes the wrapped writer, and returns it.

Trait Implementations

impl<W, A, const PAD: bool> Debug for Decoder<W, A, PAD>

where A: Alphabet,

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

Formats the value using the given formatter.

impl<W, A, const PAD: bool> Drop for Decoder<W, A, PAD>

where A: Alphabet,

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

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

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl<W, A, const PAD: bool> Write for Decoder<W, A, PAD>

where W: Write, A: Alphabet,

fn write(&mut self, input: &[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.