libzbase32 2.0.1

An implementation of the z-base-32 format for Rust. This implementation is no_std compatible.
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
154
155
156
157
158
159
160
161
162
163
164
165
166

use core::fmt::{Debug, Display, Formatter};

enum InputErrorType {
    InvalidCharacter,
    InvalidQuintet,
    TrailingNonZeroBits,
}

pub struct InputErrorCause {
    typ: InputErrorType,
}

impl Debug for InputErrorCause {
    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
        match self.typ {
            InputErrorType::InvalidCharacter => write!(f, "Invalid character found in input."),
            InputErrorType::InvalidQuintet => write!(f, "Invalid quintet value found in input."),
            InputErrorType::TrailingNonZeroBits => {
                write!(f, "Trailing non-zero bits found in input.")
            }
        }
    }
}

impl Display for InputErrorCause {
    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
        Debug::fmt(self, f)
    }
}

enum UsageErrorType {
    InputBufferDoesntMatchBits,
    OutputBufferDoesntMatchBits,
    BitsOverflow,
}

pub struct UsageErrorCause {
    typ: UsageErrorType,
}

impl Debug for UsageErrorCause {
    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
        match self.typ {
            UsageErrorType::InputBufferDoesntMatchBits => {
                write!(
                    f,
                    "The input buffer size doesn't agree with the provided bits value"
                )
            }
            UsageErrorType::OutputBufferDoesntMatchBits => {
                write!(
                    f,
                    "The output buffer size doesn't agree with the provided bits value"
                )
            }
            UsageErrorType::BitsOverflow => {
                write!(f, "The value for bits was too large for the platform usize")
            }
        }
    }
}

impl Display for UsageErrorCause {
    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
        Debug::fmt(self, f)
    }
}

/// Common error type used by all fallible operations where bad input could be the cause
///
/// By design, this type is mostly opaque - with the exception
/// that its possible to differentiate between errors with input
/// data and other types of errors. The [`Debug`] or [`Display`]
/// implementations can be used to format a more specific error
/// message.
pub enum ZBase32Error {
    /// An InputError indicates that an input array contained an invalid
    /// value. For example, a non-zbase32 character being passed to one of
    /// the decode methods.
    InputError(InputErrorCause),

    /// A UsageError indicates an error outside of an invalid input value.
    UsageError(UsageErrorCause),
}

impl Debug for ZBase32Error {
    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
        match self {
            ZBase32Error::InputError(cause) => write!(f, "Input Error: {}", cause),
            ZBase32Error::UsageError(cause) => write!(f, "Usage Error: {}", cause),
        }
    }
}

impl Display for ZBase32Error {
    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
        Debug::fmt(self, f)
    }
}

#[cfg(feature = "std")]
impl std::error::Error for ZBase32Error {}

impl From<UsageError> for ZBase32Error {
    fn from(err: UsageError) -> Self {
        ZBase32Error::UsageError(err.0)
    }
}

/// A UsageError indicates an error outside of an invalid input value.
///
/// By design, this type is mostly opaque. The [`Debug`] or [`Display`]
/// implementations can be used to format a more specific error
/// message.
pub struct UsageError(pub UsageErrorCause);

impl Debug for UsageError {
    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
        write!(f, "Usage Error: {}", self.0)
    }
}

impl Display for UsageError {
    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
        Debug::fmt(self, f)
    }
}

#[cfg(feature = "std")]
impl std::error::Error for UsageError {}

pub const fn invalid_character() -> ZBase32Error {
    ZBase32Error::InputError(InputErrorCause {
        typ: InputErrorType::InvalidCharacter,
    })
}

pub const fn invalid_quintet() -> ZBase32Error {
    ZBase32Error::InputError(InputErrorCause {
        typ: InputErrorType::InvalidQuintet,
    })
}

pub const fn trailing_nonzero_bits() -> ZBase32Error {
    ZBase32Error::InputError(InputErrorCause {
        typ: InputErrorType::TrailingNonZeroBits,
    })
}

pub const fn input_buffer_doesnt_match_bits() -> UsageError {
    UsageError(UsageErrorCause {
        typ: UsageErrorType::InputBufferDoesntMatchBits,
    })
}

pub const fn output_buffer_doesnt_match_bits() -> UsageError {
    UsageError(UsageErrorCause {
        typ: UsageErrorType::OutputBufferDoesntMatchBits,
    })
}

pub const fn bits_overflow() -> UsageError {
    UsageError(UsageErrorCause {
        typ: UsageErrorType::BitsOverflow,
    })
}