base64 0.5.0

encodes and decodes base64 as bytes or utf8
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

use std::collections::HashMap;
use std::iter::Iterator;

fn main() {
    println!("pub const INVALID_VALUE: u8 = 255;");

    // A-Z
    let standard_alphabet: Vec<u8> = (0x41..0x5B)
        // a-z
        .chain(0x61..0x7B)
        // 0-9
        .chain(0x30..0x3A)
        // +
        .chain(0x2B..0x2C)
        // /
        .chain(0x2F..0x30)
        .collect();
    print_encode_table(&standard_alphabet, "STANDARD_ENCODE", 0);
    print_decode_table(&standard_alphabet, "STANDARD_DECODE", 0);

    // A-Z
    let url_alphabet: Vec<u8> = (0x41..0x5B)
        // a-z
        .chain(0x61..0x7B)
        // 0-9
        .chain(0x30..0x3A)
        // -
        .chain(0x2D..0x2E)
        // _s
        .chain(0x5F..0x60)
        .collect();
    print_encode_table(&url_alphabet, "URL_SAFE_ENCODE", 0);
    print_decode_table(&url_alphabet, "URL_SAFE_DECODE", 0);

}

fn print_encode_table(alphabet: &[u8], const_name: &str, indent_depth: usize) {
    println!("{:width$}pub const {}: &'static [u8; 64] = &[", "", const_name, width=indent_depth);

    for (i, b) in alphabet.iter().enumerate() {
        println!("{:width$}{}, // input {} (0x{:X}) => '{}' (0x{:X})", "",
                 b, i, i, String::from_utf8(vec!(*b as u8)).unwrap(), b, width=indent_depth + 4);
    }

    println!("{:width$}];", "", width=indent_depth);
}

fn print_decode_table(alphabet: &[u8], const_name: &str, indent_depth: usize) {
    // map of alphabet bytes to 6-bit morsels
    let mut input_to_morsel = HashMap::<u8, u8>::new();

    // standard base64 alphabet bytes, in order
    for (morsel, ascii_byte) in alphabet.iter().enumerate() {
        // truncation cast is fine here
        let _ = input_to_morsel.insert(*ascii_byte, morsel as u8);
    }

    println!("{:width$}pub const {}: &'static [u8; 256] = &[", "", const_name, width=indent_depth);
    for ascii_byte in 0..256 {
        let (value, comment) = match input_to_morsel.get(&(ascii_byte as u8)) {
            None => ("INVALID_VALUE".to_string(),
                    format!("input {} (0x{:X})", ascii_byte, ascii_byte)),
            Some(v) => (format!("{}", *v),
                        format!("input {} (0x{:X} char '{}') => {} (0x{:X})",
                                ascii_byte,
                                ascii_byte,
                                String::from_utf8(vec!(ascii_byte as u8)).unwrap(), *v, *v))
        };

        println!("{:width$}{}, // {}", "", value, comment, width=indent_depth + 4);
    }
    println!("{:width$}];", "", width=indent_depth);
}