const_base 0.2.0

Decoding/encoding base 64/32/16 strings at compile-time
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

use crate::{decoded_len, encoded_len, Config};

macro_rules! pass_types {
    ($length_fn:expr, $ty:ident) => {
        pass_types_inner! {
            $length_fn,
            for[const N: usize] $ty<&'static [u8; N]>,
            |self| self.0
        }
        pass_types_inner! {
            $length_fn,
            for[] $ty<&'static [u8]>,
            |self| self.0
        }

        pass_types_inner! {
            $length_fn,
            for[] $ty<&'static str>,
            |self| self.0.as_bytes()
        }
    };
}

macro_rules! pass_types_inner {
    (
        $length_fn:expr,
        for[$($gens:tt)*] $ty_const:ident<$ty:ty>,
        |$self:ident| $as_bytes:expr
    ) => {
        impl<$($gens)*> $ty_const<$ty> {
            pub const fn conv($self) -> CodecArgs {
                let input = $as_bytes;
                let cfg = $self.1;
                CodecArgs {
                    input,
                    cfg,
                    out_len: $length_fn(input, cfg),
                }
            }
        }
    };
}

pub struct DecodeArgsFrom<T>(pub T, pub Config);

pub struct EncodeArgsFrom<T>(pub T, pub Config);

pub struct CodecArgs {
    pub input: &'static [u8],
    pub cfg: Config,
    pub out_len: usize,
}

pass_types! {decoded_len, DecodeArgsFrom}
pass_types! {_encoded_len, EncodeArgsFrom}

#[inline(always)]
const fn _encoded_len(bytes: &[u8], cfg: Config) -> usize {
    encoded_len(bytes.len(), cfg)
}