Struct const_base::Config

pub struct Config { /* private fields */ }

For configuring how a string is encoded/decoded.

Config has these values by default:

• end_padding = true

Implementations

impl Config

pub const fn new(encoding: Encoding) -> Self

Constructs a Config from an Encoding

You can use the associated constants for a more concise way to get a Config

Example

use const_base::{B64CharSet, Config, Encoding, encode};

// The same as `Config::B64`
const CFG: Config = Config::new(Encoding::Base64(B64CharSet::Standard));

assert_eq!(encode!("Rust", CFG), "UnVzdA==")

pub const fn end_padding(self, have: bool) -> Self

Determines whether the string has padding at the end. This is true by default.

For each encoding, the strings are padded to a multiple:

• Base64: pads to be a multiple of 4 long, with =.
• Base32: pads to be a multiple of 8 long, with =.
• Hexadecimal: requires no padding

Examples

Base 64

use const_base::{Config, encode};

assert_eq!(encode!("Rust", Config::B64), "UnVzdA==");

assert_eq!(encode!("Rust", Config::B64.end_padding(true)), "UnVzdA==");

assert_eq!(encode!("Rust", Config::B64.end_padding(false)), "UnVzdA");

Base 32

use const_base::{Config, encode};

assert_eq!(encode!("Rustic", Config::B32), "KJ2XG5DJMM======");

assert_eq!(encode!("Rustic", Config::B32.end_padding(true)), "KJ2XG5DJMM======");

assert_eq!(encode!("Rustic", Config::B32.end_padding(false)), "KJ2XG5DJMM");

pub const fn encode<const OUT: usize>(
    self,
    input: &[u8]
) -> Result<ArrayStr<OUT>, WrongOutputLength>

A different way to call encode.

Example

use const_base::{Config, encode};

assert_eq!(Config::B64.encode::<8>(b"Rust").unwrap(), "UnVzdA==");

pub const fn decode<const OUT: usize>(
    self,
    input: &[u8]
) -> Result<[u8; OUT], DecodeError>

A different way to call decode.

Example

use const_base::{Config, decode};

assert_eq!(Config::B64.decode::<4>(b"UnVzdA=="), Ok(*b"Rust"));

impl Config

pub const B64: Self = _

Configuration with the Base64 encoding, using the Standard character set.

Example

use const_base::{Config, encode};

assert_eq!(encode!(&[23, 239, 192], Config::B64), "F+/A");

pub const B64_URL_SAFE: Self = _

Configuration with the Base64 encoding, using the UrlSafe character set.

Example

use const_base::{Config, encode};

assert_eq!(encode!(&[23, 239, 192], Config::B64_URL_SAFE), "F-_A");

pub const B32: Self = _

Configuration with the Base32 encoding, using the Standard character set.

Example

use const_base::{Config, encode};

assert_eq!(encode!(b"neat", Config::B32), "NZSWC5A=");

pub const HEX: Self = _

Configuration with the Hex (hexadecimal) encoding, using the Uppercase character set.

Example

use const_base::{Config, decode, encode};

assert_eq!(encode!(&[0xF1, 0x00, 0x0f], Config::HEX), "F1000F");

// Hexademical decoding allows mixing uppercase and lowercase
assert_eq!(decode!(b"beefBEEF", Config::HEX), &[0xBE, 0xEF, 0xBE, 0xEF]);

pub const HEX_LOWER: Self = _

Configuration with the Hex (hexadecimal) encoding, using the Lowercase character set.

Example

use const_base::{Config, decode, encode};

assert_eq!(encode!(&[0xf1, 0x00, 0x0f], Config::HEX_LOWER), "f1000f");

// Hexademical decoding allows mixing uppercase and lowercase
assert_eq!(decode!(b"beefBEEF", Config::HEX_LOWER), &[0xBE, 0xEF, 0xBE, 0xEF]);

Trait Implementations

impl Clone for Config

fn clone(&self) -> Config

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Config

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

Formats the value using the given formatter.

impl Copy for Config