kal 0.5.0

Command Abstraction Layer
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

use core::fmt;

/// An error made while parsing command from [`CommandFragment`](`super::CommandFragment`).
#[derive(Debug, PartialEq, Eq)]
pub enum CommandParseError<'a> {
    /// The command name cannot be matched.
    UnknownCommand(&'a String),

    /// There are missing arguments
    MissingArguments(Vec<&'a str>),

    /// The command fragments are incomplete for parsing.
    IncompleteCommand,

    /// Tried to execute too early.
    ExecuteTooEarly,

    /// The error happen while transforming tokens
    #[cfg(feature = "lex")]
    TokenTransformError(crate::lex::TokenTransformError<'a>),

    /// The error happen while transforming tokens
    #[cfg(feature = "lex")]
    TokenTransformErrorRef(&'a crate::lex::TokenTransformError<'a>),
}

impl fmt::Display for CommandParseError<'_> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            CommandParseError::UnknownCommand(command) => {
                write!(f, "Unknown command: {}", command)
            }
            CommandParseError::MissingArguments(missing) => {
                write!(f, "Missing arguments: {}", missing.join(", "))
            }
            CommandParseError::IncompleteCommand => write!(f, "Incomplete command"),
            CommandParseError::ExecuteTooEarly => write!(f, "Execute too early"),
            #[cfg(feature = "lex")]
            CommandParseError::TokenTransformError(error) => {
                write!(f, "Token transform error: {}", error)
            }
            #[cfg(feature = "lex")]
            CommandParseError::TokenTransformErrorRef(error) => {
                write!(f, "Token transform error: {}", error)
            }
        }
    }
}

impl std::error::Error for CommandParseError<'_> {}

#[cfg(feature = "lex")]
impl<'a> From<crate::lex::TokenTransformError<'a>> for CommandParseError<'a> {
    fn from(err: crate::lex::TokenTransformError<'a>) -> Self {
        Self::TokenTransformError(err)
    }
}

#[cfg(feature = "lex")]
impl<'a> From<&'a crate::lex::TokenTransformError<'a>> for CommandParseError<'a> {
    fn from(err: &'a crate::lex::TokenTransformError<'a>) -> Self {
        Self::TokenTransformErrorRef(err)
    }
}