Struct `Alphabet`

pub struct Alphabet { /* private fields */ }

An alphabet defines the 64 ASCII characters (symbols) used for base64.

Common alphabets are provided as constants, and custom alphabets can be made via from_str or the TryFrom<str> implementation.

Examples

Building and using a custom Alphabet:

let custom = base64::alphabet::Alphabet::new("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/").unwrap();

let engine = base64::engine::GeneralPurpose::new(
    &custom,
    base64::engine::general_purpose::PAD);

Building a const:

use base64::alphabet::Alphabet;

static CUSTOM: Alphabet = {
    // Result::unwrap() isn't const yet, but panic!() is OK
    match Alphabet::new("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/") {
        Ok(x) => x,
        Err(_) => panic!("creation of alphabet failed"),
    }
};

Building lazily:

use base64::alphabet::Alphabet;
use std::sync::LazyLock;

static CUSTOM: LazyLock<Alphabet> = LazyLock::new(||
    Alphabet::new("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/").unwrap()
);

Implementations

`impl Alphabet`

const fn new(alphabet: &str) -> Result<Self, ParseAlphabetError>

Create an Alphabet from a string of 64 unique printable ASCII bytes with = as the padding symbol.

The padding symbol = is not allowed in the alphabet.

See Self::new_with_padding if a non-default padding symbol is needed.

const fn new_with_padding(alphabet: &str, padding: Symbol) -> Result<Self, ParseAlphabetError>

Create an Alphabet from a string of 64 unique printable ASCII bytes, with a custom padding symbol.

The padding symbol must not appear in the alphabet.

This is meant for strange alphabets that don't use = as the padding symbol.

fn as_str(&self) -> &str

A &str containing the symbols in the Alphabet (excluding padding)

fn symbols(&self) -> [Symbol; 64]

The 64 symbols of the alphabet (excluding padding).

fn padding(&self) -> Symbol

The symbol used for padding.

Trait Implementations

`impl Clone for Alphabet`

fn clone(&self) -> Alphabet

`impl Debug for Alphabet`

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

`impl Eq for Alphabet`

`impl PartialEq for Alphabet`

fn eq(&self, other: &Alphabet) -> bool

`impl StructuralPartialEq for Alphabet`

`impl TryFrom<&str> for Alphabet`

type Error = ParseAlphabetError;
fn try_from(value: &str) -> Result<Self, Self::Error>

Auto Trait Implementations

`impl Freeze for Alphabet`

`impl RefUnwindSafe for Alphabet`

`impl Send for Alphabet`

`impl Sync for Alphabet`

`impl Unpin for Alphabet`

`impl UnsafeUnpin for Alphabet`

`impl UnwindSafe for Alphabet`

Blanket Implementations

`impl<T> Any for Alphabet where T: 'static + ?Sized,`

fn type_id(&self) -> TypeId

`impl<T> Borrow<T> for Alphabet where T: ?Sized,`

fn borrow(&self) -> &T

`impl<T> BorrowMut<T> for Alphabet where T: ?Sized,`

fn borrow_mut(&mut self) -> &mut T

`impl<T> CloneToUninit for Alphabet where T: Clone,`

unsafe fn clone_to_uninit(&self, dest: *mut u8)

`impl<T> From<T> for Alphabet`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T> ToOwned for Alphabet where T: Clone,`

type Owned = T;
fn to_owned(&self) -> T
fn clone_into(&self, target: &mut T)

`impl<T, U> Into for Alphabet where U: From<T>,`

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

`impl<T, U> TryFrom for Alphabet where U: Into<T>,`

type Error = never;
fn try_from(value: U) -> Result<T, never>

`impl<T, U> TryInto for Alphabet where U: TryFrom<T>,`

type Error = >::Error;
fn try_into(self) -> Result<U, >::Error>