Struct base64::read::decoder::DecoderReader

pub struct DecoderReader<'e, E: Engine, R: Read> {
    engine: &'e E,
    inner: R,
    b64_buffer: [u8; 1024],
    b64_offset: usize,
    b64_len: usize,
    decoded_chunk_buffer: [u8; 3],
    decoded_offset: usize,
    decoded_len: usize,
    input_consumed_len: usize,
    padding_offset: Option<usize>,
}

A Read implementation that decodes base64 data read from an underlying reader.

Examples

use std::io::Read;
use std::io::Cursor;
use base64::engine::general_purpose;

// use a cursor as the simplest possible `Read` -- in real code this is probably a file, etc.
let mut wrapped_reader = Cursor::new(b"YXNkZg==");
let mut decoder = base64::read::DecoderReader::new(
    &mut wrapped_reader,
    &general_purpose::STANDARD);

// handle errors as you normally would
let mut result = Vec::new();
decoder.read_to_end(&mut result).unwrap();

assert_eq!(b"asdf", &result[..]);

Fields

engine: &'e E

inner: R

Where b64 data is read from

b64_buffer: [u8; 1024]

Holds b64 data read from the delegate reader.

b64_offset: usize

The start of the pending buffered data in b64_buffer.

b64_len: usize

The amount of buffered b64 data after b64_offset in b64_len.

decoded_chunk_buffer: [u8; 3]

Since the caller may provide us with a buffer of size 1 or 2 that’s too small to copy a decoded chunk in to, we have to be able to hang on to a few decoded bytes. Technically we only need to hold 2 bytes, but then we’d need a separate temporary buffer to decode 3 bytes into and then juggle copying one byte into the provided read buf and the rest into here, which seems like a lot of complexity for 1 extra byte of storage.

decoded_offset: usize

Index of start of decoded data in decoded_chunk_buffer

decoded_len: usize

Length of decoded data after decoded_offset in decoded_chunk_buffer

input_consumed_len: usize

Input length consumed so far. Used to provide accurate offsets in errors

padding_offset: Option<usize>

offset of previously seen padding, if any

Implementations

impl<'e, E: Engine, R: Read> DecoderReader<'e, E, R>

pub fn new(reader: R, engine: &'e E) -> Self

Create a new decoder that will read from the provided reader r.

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

Write as much as possible of the decoded buffer into the target buffer. Must only be called when there is something to write and space to write into. Returns a Result with the number of (decoded) bytes copied.

fn read_from_delegate(&mut self) -> Result<usize>

Read into the remaining space in the buffer after the current contents. Must only be called when there is space to read into in the buffer. Returns the number of bytes read.

fn decode_to_buf( &mut self, b64_len_to_decode: usize, buf: &mut [u8], ) -> Result<usize>

Decode the requested number of bytes from the b64 buffer into the provided buffer. It’s the caller’s responsibility to choose the number of b64 bytes to decode correctly.

Returns a Result with the number of decoded bytes written to buf.

Panics

panics if buf is too small

pub fn into_inner(self) -> R

Unwraps this DecoderReader, returning the base reader which it reads base64 encoded input from.

Because DecoderReader performs internal buffering, the state of the inner reader is unspecified. This function is mainly provided because the inner reader type may provide additional functionality beyond the Read implementation which may still be useful.

Trait Implementations

impl<'e, E: Engine, R: Read> Debug for DecoderReader<'e, E, R>

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

Formats the value using the given formatter.

impl<'e, E: Engine, R: Read> Read for DecoderReader<'e, E, R>

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

Decode input from the wrapped reader.

Under non-error circumstances, this returns Ok with the value being the number of bytes written in buf.

Where possible, this function buffers base64 to minimize the number of read() calls to the delegate reader.

Errors

Any errors emitted by the delegate reader are returned. Decoding errors due to invalid base64 are also possible, and will have io::ErrorKind::InvalidData.

fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>

Like read, except that it reads into a slice of buffers.

fn is_read_vectored(&self) -> bool

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

Determines if this Reader has an efficient read_vectored implementation.

fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>

Reads all bytes until EOF in this source, placing them into buf.

fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>

Reads all bytes until EOF in this source, appending them to buf.

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

Reads the exact number of bytes required to fill buf.

fn read_buf(&mut self, buf: BorrowedCursor<'_>) -> Result<(), Error>

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

Pull some bytes from this source into the specified buffer.

fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>

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

Reads the exact number of bytes required to fill cursor.

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

where Self: Sized,

Creates a “by reference” adaptor for this instance of Read.

fn bytes(self) -> Bytes<Self>

where Self: Sized,

Transforms this Read instance to an Iterator over its bytes.

fn chain<R>(self, next: R) -> Chain<Self, R>

where R: Read, Self: Sized,

Creates an adapter which will chain this stream with another.

fn take(self, limit: u64) -> Take<Self>

where Self: Sized,

Creates an adapter which will read at most limit bytes from it.