basenc 0.2.3

Encoding and decoding hex, base64 and base32 with support for #[no_std].
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

use super::*;

const RATIO: Ratio = Ratio { decoded: 5, encoded: 8 };
const PAD_CHAR: u8 = b'=';

/// Base32 alphabet.
#[derive(Clone, Debug)]
pub struct Base32 {
	charset: [u8; 32],
	lut: [u8; 128],
}

impl Base32 {
	/// Creates a new Base32 alphabet.
	///
	/// # Panics
	///
	/// Panics if the alphabet contains `=`, duplicate or non-ASCII characters.
	pub const fn new(&charset: &[u8; 32]) -> Self {
		let mut lut = [255; 128];
		let mut i = 0;
		while i < charset.len() {
			if charset[i] == PAD_CHAR {
				panic!("padding character in Base32 charset");
			}
			if charset[i] as usize >= lut.len() {
				panic!("non-ASCII character in Base32 charset");
			}
			if lut[charset[i] as usize] != 255 {
				panic!("duplicate character in Base32 charset");
			}
			lut[charset[i] as usize] = i as u8;
			i += 1;
		}
		Base32 { charset, lut }
	}

	/// With explicit padding policy.
	pub const fn pad(&self, pad: Padding) -> WithPad<'_, Self> {
		WithPad { encoding: self, pad }
	}
}

impl Encoding for Base32 {
	const RATIO: Ratio = RATIO;

	#[inline]
	fn encode_into<B: EncodeBuf>(&self, bytes: &[u8], buffer: B) -> B::Output {
		encode(bytes, self, Padding::Optional, buffer)
	}

	#[inline]
	fn decode_into<B: DecodeBuf>(&self, string: &[u8], buffer: B) -> Result<B::Output, Error> {
		decode(string, self, Padding::Optional, buffer)
	}
}

impl Encoding for WithPad<'_, Base32> {
	const RATIO: Ratio = RATIO;

	#[inline]
	fn encode_into<B: EncodeBuf>(&self, bytes: &[u8], buffer: B) -> B::Output {
		encode(bytes, self.encoding, self.pad, buffer)
	}

	#[inline]
	fn decode_into<B: DecodeBuf>(&self, string: &[u8], buffer: B) -> Result<B::Output, Error> {
		decode(string, self.encoding, self.pad, buffer)
	}
}

impl_encoding!(Base32);

//----------------------------------------------------------------

/// Base32 RFC 4648 alphabet.
///
/// The alphabet is `A-Z2-7`.
#[allow(non_upper_case_globals)]
pub static Base32Std: Base32 = Base32::new(b"ABCDEFGHIJKLMNOPQRSTUVWXYZ234567");

/// Base32 Extended Hex alphabet.
///
/// The alphabet is `0-9A-V`.
#[allow(non_upper_case_globals)]
pub static Base32Hex: Base32 = Base32::new(b"0123456789ABCDEFGHIJKLMNOPQRSTUV");

/// z-base-32 alphabet.
///
/// The alphabet is `ybndrfg8ejkmcpqxot1uwisza345h769`.
#[allow(non_upper_case_globals)]
pub static Base32Z: Base32 = Base32::new(b"ybndrfg8ejkmcpqxot1uwisza345h769");

//----------------------------------------------------------------
// Encoding

mod encode;

#[inline(never)]
fn encode<B: EncodeBuf>(bytes: &[u8], base: &Base32, pad: Padding, mut buffer: B) -> B::Output {
	let dest_len = RATIO.estimate_encoded_len(bytes.len());

	unsafe {
		let dest = buffer.allocate(dest_len);
		let end = encode::encode(bytes, base, pad, dest);
		let len = end.offset_from(dest) as usize;
		buffer.commit(len)
	}
}

//----------------------------------------------------------------
// Decoding

mod decode;

#[inline(never)]
fn decode<B: DecodeBuf>(string: &[u8], base: &Base32, pad: Padding, mut buffer: B) -> Result<B::Output, Error> {
	let dest_len = RATIO.estimate_decoded_len(string.len());

	unsafe {
		let dest = buffer.allocate(dest_len);
		let end = decode::decode(string, base, pad, dest)?;
		let len = end.offset_from(dest) as usize;
		Ok(buffer.commit(len))
	}
}