time/error/
invalid_format_description.rs

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
//! Invalid format description

use alloc::string::String;
use core::fmt;

use crate::error;

/// The format description provided was not valid.
#[non_exhaustive]
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum InvalidFormatDescription {
    /// There was a bracket pair that was opened but not closed.
    #[non_exhaustive]
    UnclosedOpeningBracket {
        /// The zero-based index of the opening bracket.
        index: usize,
    },
    /// A component name is not valid.
    #[non_exhaustive]
    InvalidComponentName {
        /// The name of the invalid component name.
        name: String,
        /// The zero-based index the component name starts at.
        index: usize,
    },
    /// A modifier is not valid.
    #[non_exhaustive]
    InvalidModifier {
        /// The value of the invalid modifier.
        value: String,
        /// The zero-based index the modifier starts at.
        index: usize,
    },
    /// A component name is missing.
    #[non_exhaustive]
    MissingComponentName {
        /// The zero-based index where the component name should start.
        index: usize,
    },
    /// A required modifier is missing.
    #[non_exhaustive]
    MissingRequiredModifier {
        /// The name of the modifier that is missing.
        name: &'static str,
        /// The zero-based index of the component.
        index: usize,
    },
    /// Something was expected, but not found.
    #[non_exhaustive]
    Expected {
        /// What was expected to be present, but wasn't.
        what: &'static str,
        /// The zero-based index the item was expected to be found at.
        index: usize,
    },
    /// Certain behavior is not supported in the given context.
    #[non_exhaustive]
    NotSupported {
        /// The behavior that is not supported.
        what: &'static str,
        /// The context in which the behavior is not supported.
        context: &'static str,
        /// The zero-based index the error occurred at.
        index: usize,
    },
}

impl From<InvalidFormatDescription> for crate::Error {
    fn from(original: InvalidFormatDescription) -> Self {
        Self::InvalidFormatDescription(original)
    }
}

impl TryFrom<crate::Error> for InvalidFormatDescription {
    type Error = error::DifferentVariant;

    fn try_from(err: crate::Error) -> Result<Self, Self::Error> {
        match err {
            crate::Error::InvalidFormatDescription(err) => Ok(err),
            _ => Err(error::DifferentVariant),
        }
    }
}

impl fmt::Display for InvalidFormatDescription {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        use InvalidFormatDescription::*;
        match self {
            UnclosedOpeningBracket { index } => {
                write!(f, "unclosed opening bracket at byte index {index}")
            }
            InvalidComponentName { name, index } => {
                write!(f, "invalid component name `{name}` at byte index {index}")
            }
            InvalidModifier { value, index } => {
                write!(f, "invalid modifier `{value}` at byte index {index}")
            }
            MissingComponentName { index } => {
                write!(f, "missing component name at byte index {index}")
            }
            MissingRequiredModifier { name, index } => {
                write!(
                    f,
                    "missing required modifier `{name}` for component at byte index {index}"
                )
            }
            Expected {
                what: expected,
                index,
            } => {
                write!(f, "expected {expected} at byte index {index}")
            }
            NotSupported {
                what,
                context,
                index,
            } => {
                if context.is_empty() {
                    write!(f, "{what} is not supported at byte index {index}")
                } else {
                    write!(
                        f,
                        "{what} is not supported in {context} at byte index {index}"
                    )
                }
            }
        }
    }
}

#[cfg(feature = "std")]
#[allow(clippy::std_instead_of_core)]
impl std::error::Error for InvalidFormatDescription {}