Struct bs58::alphabet::Alphabet

source ·
pub struct Alphabet { /* private fields */ }
Expand description

Implementations§

source§

impl Alphabet

source

pub const BITCOIN: &'static Self = _

Bitcoin’s alphabet as defined in their Base58Check encoding.

See https://en.bitcoin.it/wiki/Base58Check_encoding#Base58_symbol_chart

source

pub const MONERO: &'static Self = _

source

pub const RIPPLE: &'static Self = _

Ripple’s alphabet as defined in their wiki.

See https://wiki.ripple.com/Encodings

source

pub const FLICKR: &'static Self = _

Flickr’s alphabet for creating short urls from photo ids.

See https://www.flickr.com/groups/api/discuss/72157616713786392/

source

pub const DEFAULT: &'static Self = Self::BITCOIN

The default alphabet used if none is given. Currently is the BITCOIN alphabet.

source

pub const fn new(base: &[u8; 58]) -> Result<Self, Error>

Create prepared alphabet, checks that the alphabet is pure ASCII and that there are no duplicate characters, which would result in inconsistent encoding/decoding

let alpha = bs58::Alphabet::new(
    b" !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXY"
)?;

let decoded = bs58::decode("he11owor1d")
    .with_alphabet(bs58::Alphabet::RIPPLE)
    .into_vec()?;
let encoded = bs58::encode(decoded)
    .with_alphabet(&alpha)
    .into_string();

assert_eq!("#ERRN)N RD", encoded);
§Errors
§Duplicate Character
let alpha = b"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
assert_eq!(
    bs58::alphabet::Error::DuplicateCharacter { character: 'a', first: 0, second: 1 },
    bs58::Alphabet::new(alpha).unwrap_err());
§Non-ASCII Character
let mut alpha = *b"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
alpha[1] = 255;
assert_eq!(
    bs58::alphabet::Error::NonAsciiCharacter { index: 1 },
    bs58::Alphabet::new(&alpha).unwrap_err());
source

pub const fn new_unwrap(base: &[u8; 58]) -> Self

Same as Self::new, but gives a panic instead of an Err on bad input.

Intended to support usage in const context until Result::unwrap is able to be called.

const ALPHA: &'static bs58::Alphabet = &bs58::Alphabet::new_unwrap(
    b" !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXY"
);

let decoded = bs58::decode("he11owor1d")
    .with_alphabet(bs58::Alphabet::RIPPLE)
    .into_vec()?;
let encoded = bs58::encode(decoded)
    .with_alphabet(ALPHA)
    .into_string();

assert_eq!("#ERRN)N RD", encoded);

If your alphabet is inconsistent then this will fail to compile in a const context:

const _: &'static bs58::Alphabet = &bs58::Alphabet::new_unwrap(
    b"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
);

Trait Implementations§

source§

impl Clone for Alphabet

source§

fn clone(&self) -> Alphabet

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
source§

impl Debug for Alphabet

source§

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

Formats the value using the given formatter. Read more
source§

impl Copy for Alphabet

Auto Trait Implementations§

Blanket Implementations§

source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

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

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

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

source§

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

Mutably borrows from an owned value. Read more
source§

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

source§

default unsafe fn clone_to_uninit(&self, dst: *mut T)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. Read more
source§

impl<T> CloneToUninit for T
where T: Copy,

source§

unsafe fn clone_to_uninit(&self, dst: *mut T)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

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

source§

fn into(self) -> U

Calls U::from(self).

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

source§

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

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

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

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

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

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.