enc 0.19.0

This library aids in processing encoded data.
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
144
145
146
147
148
149
150
151
152
153

use crate::base_64::Base64Encoder;
use std::cmp::Ordering;
use std::hash::{Hash, Hasher};
use std::sync::Arc;

/// A base-64 encoding table.
///
/// This implementation supports static and atomic reference counted tables. This strategy avoids
/// all allocation for the standard encoding table configurations and also avoids allocation when
/// cloning reference counted tables. The only allocation needed is when creating a new,
/// non-standard encoding table.
#[derive(Clone, Debug)]
pub enum EncodingTable {
    /// A static encoding table.
    Static(&'static [u8; 64]),

    /// An atomic reference counted encoding table.
    Reference(Arc<[u8; 64]>),
}

impl PartialEq for EncodingTable {
    fn eq(&self, other: &Self) -> bool {
        self.encoding_table() == other.encoding_table()
    }
}

impl Eq for EncodingTable {}

impl Hash for EncodingTable {
    fn hash<H: Hasher>(&self, state: &mut H) {
        self.encoding_table().hash(state)
    }
}

impl Ord for EncodingTable {
    fn cmp(&self, other: &Self) -> Ordering {
        self.encoding_table().cmp(other.encoding_table())
    }
}

impl PartialOrd for EncodingTable {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        Some(self.cmp(other))
    }
}

impl EncodingTable {
    //! Special Tables

    /// The standard encoding table.
    const STANDARD: Self = Self::Static(&Self::create_custom_encoding_table(
        Base64Encoder::DEFAULT_V63,
        Base64Encoder::DEFAULT_V64,
    ));

    /// The URL-safe encoding table.
    const URL_SAFE: Self = Self::Static(&Self::create_custom_encoding_table(
        Base64Encoder::URL_SAFE_V63,
        Base64Encoder::URL_SAFE_V64,
    ));
}

impl EncodingTable {
    //! Construction

    /// Creates a custom encoding table. Returns the static table if available.
    pub fn get_encoding_table(v63: u8, v64: u8) -> Self {
        match (v63, v64) {
            (Base64Encoder::DEFAULT_V63, Base64Encoder::DEFAULT_V64) => Self::STANDARD,
            (Base64Encoder::URL_SAFE_V63, Base64Encoder::URL_SAFE_V64) => Self::URL_SAFE,
            (v63, v64) => Self::Reference(Arc::new(Self::create_custom_encoding_table(v63, v64))),
        }
    }

    /// Creates a custom encoding table.
    const fn create_custom_encoding_table(v63: u8, v64: u8) -> [u8; 64] {
        let mut t: [u8; 64] = [0xFF; 64];

        let mut i: usize = 0;
        while i < 26 {
            t[i] = b'A' + i as u8;
            i += 1;
        }
        while i < 52 {
            t[i] = b'a' + (i - 26) as u8;
            i += 1;
        }
        while i < 62 {
            t[i] = b'0' + (i - 52) as u8;
            i += 1;
        }
        t[62] = v63;
        t[63] = v64;

        t
    }
}

impl Default for EncodingTable {
    fn default() -> Self {
        Self::STANDARD
    }
}

impl EncodingTable {
    //! Properties

    /// Gets the raw encoding table.
    pub fn encoding_table(&self) -> &[u8; 64] {
        match self {
            Self::Static(table) => table,
            Self::Reference(table) => table.as_ref(),
        }
    }
}

#[cfg(test)]
mod tests {
    use crate::base_64::Base64Encoder;
    use crate::base_64::encode::encoding_table::EncodingTable;

    #[test]
    fn fn_get_encoding_table() {
        let standard: EncodingTable = EncodingTable::get_encoding_table(
            Base64Encoder::DEFAULT_V63,
            Base64Encoder::DEFAULT_V64,
        );
        assert!(matches!(standard, EncodingTable::Static(_)));

        let url_safe: EncodingTable = EncodingTable::get_encoding_table(
            Base64Encoder::URL_SAFE_V63,
            Base64Encoder::URL_SAFE_V64,
        );
        assert!(matches!(url_safe, EncodingTable::Static(_)));

        let custom: EncodingTable = EncodingTable::get_encoding_table(b'!', b'@');
        assert!(matches!(custom, EncodingTable::Reference(_)));
    }

    #[test]
    fn fn_encoding_table() {
        let table: EncodingTable = EncodingTable::default();
        let t: &[u8; 64] = table.encoding_table();
        assert_eq!(t[0], b'A');
        assert_eq!(t[25], b'Z');
        assert_eq!(t[26], b'a');
        assert_eq!(t[51], b'z');
        assert_eq!(t[52], b'0');
        assert_eq!(t[61], b'9');
        assert_eq!(t[62], Base64Encoder::DEFAULT_V63);
        assert_eq!(t[63], Base64Encoder::DEFAULT_V64);
    }
}