Struct base64::engine::general_purpose::GeneralPurpose

pub struct GeneralPurpose { /* private fields */ }

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.

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 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.