byte_unit/
errors.rs

1use core::fmt::{self, Display, Formatter};
2#[cfg(any(feature = "byte", feature = "bit"))]
3pub use core::num::TryFromIntError;
4#[cfg(feature = "std")]
5use std::error::Error;
6
7#[cfg(any(feature = "byte", feature = "bit"))]
8use rust_decimal::Decimal;
9
10#[cfg(any(feature = "byte", feature = "bit"))]
11/// The error type returned when it exceeds representation range.
12#[derive(Debug, Copy, Clone, PartialEq, Eq)]
13pub struct ExceededBoundsError;
14
15#[cfg(any(feature = "byte", feature = "bit"))]
16impl Display for ExceededBoundsError {
17    #[inline]
18    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
19        f.write_str("value exceeds the valid range")
20    }
21}
22
23#[cfg(any(feature = "byte", feature = "bit"))]
24#[cfg(feature = "std")]
25impl Error for ExceededBoundsError {}
26
27#[cfg(any(feature = "byte", feature = "bit"))]
28/// The error type returned when parsing values.
29#[derive(Debug, Clone)]
30pub enum ValueParseError {
31    ExceededBounds(Decimal),
32    NotNumber(char),
33    NoValue,
34    NumberTooLong,
35}
36
37#[cfg(any(feature = "byte", feature = "bit"))]
38impl Display for ValueParseError {
39    #[inline]
40    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
41        match self {
42            Self::ExceededBounds(value) => {
43                f.write_fmt(format_args!("the value {value:?} exceeds the valid range"))
44            },
45            Self::NotNumber(c) => f.write_fmt(format_args!("the character {c:?} is not a number")),
46            Self::NoValue => f.write_str("no value can be found"),
47            Self::NumberTooLong => f.write_str("value number is too long"),
48        }
49    }
50}
51
52#[cfg(any(feature = "byte", feature = "bit"))]
53#[cfg(feature = "std")]
54impl Error for ValueParseError {}
55
56/// The error type returned when parsing units.
57#[derive(Debug, Clone)]
58pub struct UnitParseError {
59    pub character:                char,
60    pub expected_characters:      &'static [char],
61    pub also_expect_no_character: bool,
62}
63
64impl Display for UnitParseError {
65    #[inline]
66    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
67        let Self {
68            character,
69            expected_characters,
70            also_expect_no_character,
71        } = self;
72
73        let expected_characters_length = expected_characters.len();
74
75        f.write_fmt(format_args!("the character {character:?} is incorrect",))?;
76
77        if expected_characters_length == 0 {
78            f.write_str(" (no character is expected)")
79        } else {
80            f.write_fmt(format_args!(
81                " ({expected_character:?}",
82                expected_character = expected_characters[0]
83            ))?;
84
85            if expected_characters_length > 1 {
86                for expected_character in
87                    expected_characters[1..].iter().take(expected_characters_length - 2)
88                {
89                    f.write_fmt(format_args!(", {expected_character:?}"))?;
90                }
91
92                if *also_expect_no_character {
93                    f.write_fmt(format_args!(
94                        ", {expected_character:?} or no character",
95                        expected_character = expected_characters[expected_characters_length - 1]
96                    ))?;
97                } else {
98                    f.write_fmt(format_args!(
99                        " or {expected_character:?} is expected)",
100                        expected_character = expected_characters[expected_characters_length - 1]
101                    ))?;
102                }
103            }
104
105            if *also_expect_no_character {
106                f.write_str(" or no character")?;
107            }
108
109            f.write_str(" is expected)")
110        }
111    }
112}
113
114#[cfg(feature = "std")]
115impl Error for UnitParseError {}
116
117#[cfg(any(feature = "byte", feature = "bit"))]
118/// The error type returned when parsing values with a unit.
119#[derive(Debug, Clone)]
120pub enum ParseError {
121    Value(ValueParseError),
122    Unit(UnitParseError),
123}
124
125#[cfg(any(feature = "byte", feature = "bit"))]
126impl From<ValueParseError> for ParseError {
127    #[inline]
128    fn from(error: ValueParseError) -> Self {
129        Self::Value(error)
130    }
131}
132
133#[cfg(any(feature = "byte", feature = "bit"))]
134impl From<UnitParseError> for ParseError {
135    #[inline]
136    fn from(error: UnitParseError) -> Self {
137        Self::Unit(error)
138    }
139}
140
141#[cfg(any(feature = "byte", feature = "bit"))]
142impl Display for ParseError {
143    #[inline]
144    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
145        match self {
146            ParseError::Value(error) => Display::fmt(error, f),
147            ParseError::Unit(error) => Display::fmt(error, f),
148        }
149    }
150}
151
152#[cfg(any(feature = "byte", feature = "bit"))]
153#[cfg(feature = "std")]
154impl Error for ParseError {}
byte_unit/errors.rs

byte_unit/
errors.rs
