base-x 0.3.0

Encode/decode any base
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

#[cfg(not(feature = "std"))]
use alloc::{string::String, vec::Vec};
use crate::DecodeError;

use crate::decoder::*;
use crate::encoder;

pub trait Alphabet {
    fn encode(self, input: &[u8]) -> String;

    fn decode(self, input: &str) -> Result<Vec<u8>, DecodeError>;
}

/// Check that every byte value in `alphabet` is unique.
fn assert_unique_bytes(alphabet: &[u8]) {
    let mut seen = [false; 256];
    for &b in alphabet {
        assert!(!seen[b as usize], "Alphabet must not contain duplicate characters");
        seen[b as usize] = true;
    }
}

/// Check that every char in `alphabet` is unique.
fn assert_unique_chars(alphabet: &[char]) {
    // For small alphabets a simple O(n²) scan avoids allocation.
    for (i, a) in alphabet.iter().enumerate() {
        for b in alphabet[i + 1..].iter() {
            assert!(a != b, "Alphabet must not contain duplicate characters");
        }
    }
}

impl<'a> Alphabet for &[u8] {
    #[inline(always)]
    fn encode(self, input: &[u8]) -> String {
        if !self.is_ascii() {
            panic!("Alphabet must be ASCII");
        }
        assert_unique_bytes(self);

        let mut out = encoder::encode(self, input);
        out.reverse();
        unsafe { String::from_utf8_unchecked(out) }
    }

    #[inline(always)]
    fn decode(self, input: &str) -> Result<Vec<u8>, DecodeError> {
        if !self.is_ascii() {
            return Err(DecodeError);
        }
        assert_unique_bytes(self);
        U8Decoder::new(self).decode(input)
    }
}

impl<'a> Alphabet for &str {
    #[inline(always)]
    fn encode(self, input: &[u8]) -> String {
        if self.is_ascii() {
            assert_unique_bytes(self.as_bytes());
            let mut out = encoder::encode(self.as_bytes(), input);
            out.reverse();
            unsafe { String::from_utf8_unchecked(out) }
        } else {
            let alphabet: Vec<char> = self.chars().collect();
            assert_unique_chars(&alphabet);
            let out = encoder::encode(&alphabet, input);
            out.iter().rev().collect()
        }
    }

    #[inline(always)]
    fn decode(self, input: &str) -> Result<Vec<u8>, DecodeError> {
        if self.is_ascii() {
            assert_unique_bytes(self.as_bytes());
            U8Decoder::new(self.as_bytes()).decode(input)
        } else {
            let alphabet: Vec<char> = self.chars().collect();
            assert_unique_chars(&alphabet);
            CharDecoder(&alphabet).decode(input)
        }
    }
}