Struct base64::read::DecoderReader

pub struct DecoderReader<'a, R: 'a + Read> { /* private fields */ }

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

Examples

use std::io::Read;
use std::io::Cursor;

// 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, base64::STANDARD);

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

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

Implementations

impl<'a, R: Read> DecoderReader<'a, R>

pub fn new(r: &'a mut R, config: Config) -> Self

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

Trait Implementations

impl<'a, R: Read> Debug for DecoderReader<'a, R>

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

Formats the value using the given formatter.

impl<'a, R: Read> Read for DecoderReader<'a, 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

Determines if this Reader has an efficient read_vectored implementation.

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

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

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

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

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

Read the exact number of bytes required to fill buf.

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

Pull some bytes from this source into the specified buffer.

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

Read the exact number of bytes required to fill cursor.

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

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

fn bytes(self) -> Bytes<Self>

Transforms this Read instance to an [Iterator] over its bytes.

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

Creates an adapter which will chain this stream with another.

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

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