multi-util 1.0.2

Multiformat utility functions and types
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

// SPDX-License-Identifier: Apache-2.0
use crate::prelude::Base;

/// convert a multibase Base to its string equivalent
pub fn base_name(b: Base) -> String {
    use Base::*;
    match b {
        Identity => "Identity",
        Base2 => "Base2",
        Base8 => "Base8",
        Base10 => "Base10",
        Base16Lower => "Base16Lower",
        Base16Upper => "Base16Upper",
        Base32Lower => "Base32Lower",
        Base32Upper => "Base32Upper",
        Base32PadLower => "Base32PadLower",
        Base32PadUpper => "Base32PadUpper",
        Base32HexLower => "Base32HexLower",
        Base32HexUpper => "Base32HexUpper",
        Base32HexPadLower => "Base32HexPadLower",
        Base32HexPadUpper => "Base32HexPadUpper",
        Base32Z => "Base32Z",
        Base36Lower => "Base36Lower",
        Base36Upper => "Base36Upper",
        Base58Flickr => "Base58Flickr",
        Base58Btc => "Base58Btc",
        Base64 => "Base64",
        Base64Pad => "Base64Pad",
        Base64Url => "Base64Url",
        Base64UrlPad => "Base64UrlPad",
        Base256Emoji => "Base256Emoji",
    }
    .to_string()
}

/// Iterator over the Base enum values
pub struct BaseIter(Option<Base>);

impl Default for BaseIter {
    fn default() -> Self {
        Self::new()
    }
}

impl BaseIter {
    /// create a new BaseIter
    pub fn new() -> Self {
        Self(None)
    }
}

impl From<Base> for BaseIter {
    fn from(b: Base) -> Self {
        Self(Some(b))
    }
}

impl Iterator for BaseIter {
    type Item = Base;

    fn next(&mut self) -> Option<Self::Item> {
        use Base::*;
        let result = match self.0 {
            None => Identity,
            Some(b) => match b {
                Identity => Base2,
                Base2 => Base8,
                Base8 => Base10,
                Base10 => Base16Lower,
                Base16Lower => Base16Upper,
                Base16Upper => Base32Lower,
                Base32Lower => Base32Upper,
                Base32Upper => Base32PadLower,
                Base32PadLower => Base32PadUpper,
                Base32PadUpper => Base32HexLower,
                Base32HexLower => Base32HexUpper,
                Base32HexUpper => Base32HexPadLower,
                Base32HexPadLower => Base32HexPadUpper,
                Base32HexPadUpper => Base32Z,
                Base32Z => Base36Lower,
                Base36Lower => Base36Upper,
                Base36Upper => Base58Flickr,
                Base58Flickr => Base58Btc,
                Base58Btc => Base64,
                Base64 => Base64Pad,
                Base64Pad => Base64Url,
                Base64Url => Base64UrlPad,
                Base64UrlPad => Base256Emoji,
                Base256Emoji => return None,
            },
        };
        self.0 = Some(result);
        Some(result)
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_new_iter() {
        assert_eq!(BaseIter::new().next(), Some(Base::Identity));
    }

    #[test]
    fn test_last_iter() {
        let mut iter: BaseIter = Base::Base256Emoji.into();
        assert_eq!(iter.next(), None)
    }

    #[test]
    fn test_all_iter() {
        let iter = BaseIter::new();
        for b in iter {
            println!("{}", base_name(b));
        }
    }
}