Struct Base64

pub struct Base64<F, E = GeneralPurpose> {
    pub format: F,
    pub engine: E,
}

Available on crate feature base64 only.

Takes a FileFormat, encoding any the contents emitted by the format in Base64 before writing to disk, and decoding contents emitted by the format from Base64 before parsing.

Fields

format: F

The FileFormat to be used.

engine: E

The Engine to be used.

Implementations

impl<F, E> Base64<F, E>

where E: Engine,

pub const fn new(format: F, engine: E) -> Self

Creates a new Base64, given an engine to encode and decode with.

impl<F> Base64<F, GeneralPurpose>

pub const fn with_standard(format: F) -> Self

Creates a Base64 using the STANDARD engine.

pub const fn with_standard_no_pad(format: F) -> Self

Creates a Base64 using the STANDARD_NO_PAD engine.

pub const fn with_url_safe(format: F) -> Self

Creates a Base64 using the URL_SAFE engine.

pub const fn with_url_safe_no_pad(format: F) -> Self

Creates a Base64 using the URL_SAFE_NO_PAD engine.

Trait Implementations

impl<F: Clone, E: Clone> Clone for Base64<F, E>

fn clone(&self) -> Base64<F, E>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<F: Debug, E: Debug> Debug for Base64<F, E>

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

Formats the value using the given formatter.

impl<F, E> Default for Base64<F, E>

where F: Default, E: Default,

fn default() -> Self

Returns the “default value” for a type.

impl<F, E, T> FileFormat<T> for Base64<F, E>

where F: FileFormat<T>, E: Engine,

type FormatError = <F as FileFormat<T>>::FormatError

The type of error to return from to_writer and from_reader.

fn from_reader<R: Read>(&self, reader: R) -> Result<T, Self::FormatError>

Deserialize a value from a Read stream.

fn to_writer<W: Write>( &self, writer: W, value: &T, ) -> Result<(), Self::FormatError>

Serialize a value into a Write stream.

fn from_reader_buffered<R>(&self, reader: R) -> Result<T, Self::FormatError>

where R: Read,

Identical to FileFormat::from_reader, however the provided reader is buffered with BufReader.

fn from_buffer(&self, buf: &[u8]) -> Result<T, Self::FormatError>

Deserialize a value from a byte vec.

fn to_writer_buffered<W>( &self, writer: W, value: &T, ) -> Result<(), Self::FormatError>

where W: Write,

Identical to FileFormat::to_writer, however the provided writer is buffered with BufWriter.

fn to_buffer(&self, value: &T) -> Result<Vec<u8>, Self::FormatError>

Serialize a value into a byte vec.

impl<F, E, T> FileFormatUtf8<T> for Base64<F, E>

where F: FileFormat<T>, E: Engine,

fn from_string_buffer(&self, buf: &str) -> Result<T, Self::FormatError>

Deserialize a buffer from a string slice.

fn to_string_buffer(&self, value: &T) -> Result<String, Self::FormatError>

Serialize a value into a string buffer.

impl<F: PartialEq, E: PartialEq> PartialEq for Base64<F, E>

fn eq(&self, other: &Base64<F, E>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<F: Copy, E: Copy> Copy for Base64<F, E>

impl<F: Eq, E: Eq> Eq for Base64<F, E>

impl<F, E> StructuralPartialEq for Base64<F, E>