Struct bdk_chain::bitcoin::base64::alphabet::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,
    engine::{general_purpose::GeneralPurpose, GeneralPurposeConfig},
};
use once_cell::sync::Lazy;

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

Implementations

impl Alphabet

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

Create an Alphabet from a string of 64 unique printable ASCII bytes.

The = byte is not allowed as it is used for padding.

pub fn as_str(&self) -> &str

Create a &str from the symbols in the Alphabet

Trait Implementations

impl Clone for Alphabet

fn clone(&self) -> Alphabet

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Alphabet

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

Formats the value using the given formatter.

impl PartialEq for Alphabet

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl TryFrom<&str> for Alphabet

type Error = ParseAlphabetError

The type returned in the event of a conversion error.

fn try_from(value: &str) -> Result<Alphabet, <Alphabet as TryFrom<&str>>::Error>

Performs the conversion.

impl Eq for Alphabet

impl StructuralPartialEq for Alphabet