Struct base64::engine::general_purpose::GeneralPurpose

pub struct GeneralPurpose {
    encode_table: [u8; 64],
    decode_table: [u8; 256],
    config: GeneralPurposeConfig,
}

A general-purpose base64 engine.

• It uses no vector CPU instructions, so it will work on any system.
• It is reasonably fast (~2-3GiB/s).
• It is not constant-time, though, so it is vulnerable to timing side-channel attacks. For loading cryptographic keys, etc, it is suggested to use the forthcoming constant-time implementation.

Fields

encode_table: [u8; 64]

decode_table: [u8; 256]

config: GeneralPurposeConfig

Implementations

impl GeneralPurpose

pub const fn new(alphabet: &Alphabet, config: GeneralPurposeConfig) -> Self

Create a GeneralPurpose engine from an Alphabet.

While not very expensive to initialize, ideally these should be cached if the engine will be used repeatedly.

Trait Implementations

impl Clone for GeneralPurpose

fn clone(&self) -> GeneralPurpose

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for GeneralPurpose

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

Formats the value using the given formatter.

impl Engine for GeneralPurpose

type Config = GeneralPurposeConfig

The config type used by this engine

type DecodeEstimate = GeneralPurposeEstimate

The decode estimate used by this engine

fn config(&self) -> &Self::Config

Returns the config for this engine.

fn encode<T: AsRef<[u8]>>(&self, input: T) -> String

Encode arbitrary octets as base64 using the provided Engine. Returns a String.

fn encode_string<T: AsRef<[u8]>>(&self, input: T, output_buf: &mut String)

Encode arbitrary octets as base64 into a supplied String. Writes into the supplied String, which may allocate if its internal buffer isn’t big enough.

fn encode_slice<T: AsRef<[u8]>>( &self, input: T, output_buf: &mut [u8], ) -> Result<usize, EncodeSliceError>

Encode arbitrary octets as base64 into a supplied slice. Writes into the supplied output buffer.

fn decode<T: AsRef<[u8]>>(&self, input: T) -> Result<Vec<u8>, DecodeError>

Decode the input into a new Vec.

fn decode_vec<T: AsRef<[u8]>>( &self, input: T, buffer: &mut Vec<u8>, ) -> Result<(), DecodeError>

Decode the input into the supplied buffer.

fn decode_slice<T: AsRef<[u8]>>( &self, input: T, output: &mut [u8], ) -> Result<usize, DecodeSliceError>

Decode the input into the provided output slice.

fn decode_slice_unchecked<T: AsRef<[u8]>>( &self, input: T, output: &mut [u8], ) -> Result<usize, DecodeError>

Decode the input into the provided output slice.