basenc 1.0.0-alpha.1

High-performance SIMD-accelerated Base64, Base32, and hex encoding and decoding with no_std support.
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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

use super::*;

const RATIO: Ratio = Ratio::new(1, 2);

/// Hex charset using lower-case letters.
///
/// Decoding accepts both lower- and upper-case letters.
#[derive(Clone, Debug)]
pub struct LowerHex;

impl Sealed for LowerHex {}

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

	#[inline]
	fn encode_bytes_into<B: EncodeBuf>(&self, bytes: &[u8], buffer: B) -> B::Output {
		encode(bytes, b'a', buffer)
	}

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

impl LowerHex {
	impl_encoding!(
		encode: [
			/// ```
			/// let encoded = basenc::LowerHex.encode(b"\x00\x80\xFF\xDC");
			/// assert_eq!(encoded, "0080ffdc");
			/// ```
		],
		decode: [
			/// ```
			/// let decoded = basenc::LowerHex.decode("0080FFdc").unwrap();
			/// assert_eq!(decoded, b"\x00\x80\xFF\xDC");
			/// ```
		],
		encode_into: [
			/// ```
			/// let mut stack_buf = [0u8; 16];
			/// let encoded = basenc::LowerHex.encode_into(b"\x00\x80\xFF\xDC", &mut stack_buf);
			/// assert_eq!(encoded, "0080ffdc");
			/// ```
		],
		decode_into: [
			/// ```
			/// let decoded = basenc::LowerHex.decode_into("0080FFdc", Vec::new()).unwrap();
			/// assert_eq!(decoded, b"\x00\x80\xFF\xDC");
			/// ```
		],
	);
}

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

/// Hex charset using upper-case letters.
///
/// Decoding accepts both lower- and upper-case letters.
#[derive(Clone, Debug)]
pub struct UpperHex;

impl Sealed for UpperHex {}

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

	#[inline]
	fn encode_bytes_into<B: EncodeBuf>(&self, bytes: &[u8], buffer: B) -> B::Output {
		encode(bytes, b'A', buffer)
	}

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

impl UpperHex {
	impl_encoding!(
		encode: [
			/// ```
			/// let encoded = basenc::UpperHex.encode(b"\x00\x80\xFF\xDC");
			/// assert_eq!(encoded, "0080FFDC");
			/// ```
		],
		decode: [
			/// ```
			/// let decoded = basenc::UpperHex.decode("0080ffDC").unwrap();
			/// assert_eq!(decoded, b"\x00\x80\xFF\xDC");
			/// ```
		],
		encode_into: [
			/// ```
			/// let mut stack_buf = [0u8; 16];
			/// let encoded = basenc::UpperHex.encode_into(b"\x00\x80\xFF\xDC", &mut stack_buf);
			/// assert_eq!(encoded, "0080FFDC");
			/// ```
		],
		decode_into: [
			/// ```
			/// let decoded = basenc::UpperHex.decode_into("0080ffDC", Vec::new()).unwrap();
			/// assert_eq!(decoded, b"\x00\x80\xFF\xDC");
			/// ```
		],
	);
}

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

mod encode;

#[inline(never)]
fn encode<B: EncodeBuf>(bytes: &[u8], base: u8, 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_fn()(bytes, dest, base);
		let len = end.offset_from(dest) as usize;
		buffer.commit(len)
	}
}

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

mod decode;

#[inline(never)]
fn decode<B: DecodeBuf>(string: &[u8], 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_fn()(string, dest)?;
		let len = end.offset_from(dest) as usize;
		Ok(buffer.commit(len))
	}
}