oxwm

https://git.tonybtw.com/oxwm.git git://git.tonybtw.com/oxwm.git
oxwm / src / errors.rs
4,379 bytes raw
1 
#[derive(Debug)]
2 
pub enum WmError {
3 
    X11(X11Error),
4 
    Io(std::io::Error),
5 
    Anyhow(anyhow::Error),
6 
    Config(ConfigError),
7 
}
8
9 
#[derive(Debug)]
10 
pub enum X11Error {
11 
    ConnectError(x11rb::errors::ConnectError),
12 
    ConnectionError(x11rb::errors::ConnectionError),
13 
    ReplyError(x11rb::errors::ReplyError),
14 
    ReplyOrIdError(x11rb::errors::ReplyOrIdError),
15 
    DisplayOpenFailed,
16 
    FontLoadFailed(String),
17 
    DrawCreateFailed,
18 
}
19
20 
#[derive(Debug)]
21 
pub enum ConfigError {
22 
    ParseError(ron::error::SpannedError),
23 
    InvalidModkey(String),
24 
    UnknownKey(String),
25 
    UnknownAction(String),
26 
    UnknownBlockCommand(String),
27 
    MissingCommandArg { command: String, field: String },
28 
    InvalidVariableName(String),
29 
    InvalidDefine(String),
30 
    UndefinedVariable(String),
31 
}
32
33 
impl std::fmt::Display for WmError {
34 
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
35 
        match self {
36 
            Self::X11(error) => write!(f, "{}", error),
37 
            Self::Io(error) => write!(f, "{}", error),
38 
            Self::Anyhow(error) => write!(f, "{}", error),
39 
            Self::Config(error) => write!(f, "{}", error),
40 
        }
41 
    }
42 
}
43
44 
impl std::error::Error for WmError {}
45
46 
impl std::fmt::Display for X11Error {
47 
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
48 
        match self {
49 
            Self::ConnectError(err) => write!(f, "{}", err),
50 
            Self::ConnectionError(err) => write!(f, "{}", err),
51 
            Self::ReplyError(err) => write!(f, "{}", err),
52 
            Self::ReplyOrIdError(err) => write!(f, "{}", err),
53 
            Self::DisplayOpenFailed => write!(f, "failed to open X11 display"),
54 
            Self::FontLoadFailed(font_name) => write!(f, "failed to load Xft font: {}", font_name),
55 
            Self::DrawCreateFailed => write!(f, "failed to create XftDraw"),
56 
        }
57 
    }
58 
}
59
60 
impl std::error::Error for X11Error {}
61
62 
impl std::fmt::Display for ConfigError {
63 
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
64 
        match self {
65 
            Self::ParseError(err) => write!(f, "Failed to parse RON config: {}", err),
66 
            Self::InvalidModkey(key) => write!(f, "Invalid modkey: {}", key),
67 
            Self::UnknownKey(key) => write!(f, "Unknown key: {}", key),
68 
            Self::UnknownAction(action) => write!(f, "Unknown action: {}", action),
69 
            Self::UnknownBlockCommand(cmd) => write!(f, "Unknown block command: {}", cmd),
70 
            Self::MissingCommandArg { command, field } => {
71 
                write!(f, "{} command requires {}", command, field)
72 
            }
73 
            Self::InvalidVariableName(name) => {
74 
                write!(f, "Invalid variable name '{}': must start with $", name)
75 
            }
76 
            Self::InvalidDefine(line) => {
77 
                write!(f, "Invalid #DEFINE syntax: '{}'. Expected: #DEFINE $var_name = value", line)
78 
            }
79 
            Self::UndefinedVariable(var) => {
80 
                write!(f, "Undefined variable '{}': define it with #DEFINE before use", var)
81 
            }
82 
        }
83 
    }
84 
}
85
86 
impl std::error::Error for ConfigError {}
87
88 
impl<T: Into<X11Error>> From<T> for WmError {
89 
    fn from(value: T) -> Self {
90 
        Self::X11(value.into())
91 
    }
92 
}
93
94 
impl From<std::io::Error> for WmError {
95 
    fn from(value: std::io::Error) -> Self {
96 
        Self::Io(value)
97 
    }
98 
}
99
100 
impl From<anyhow::Error> for WmError {
101 
    fn from(value: anyhow::Error) -> Self {
102 
        Self::Anyhow(value)
103 
    }
104 
}
105
106 
impl From<ConfigError> for WmError {
107 
    fn from(value: ConfigError) -> Self {
108 
        Self::Config(value)
109 
    }
110 
}
111
112 
impl From<ron::error::SpannedError> for ConfigError {
113 
    fn from(value: ron::error::SpannedError) -> Self {
114 
        ConfigError::ParseError(value)
115 
    }
116 
}
117
118 
impl From<x11rb::errors::ConnectError> for X11Error {
119 
    fn from(value: x11rb::errors::ConnectError) -> Self {
120 
        X11Error::ConnectError(value)
121 
    }
122 
}
123
124 
impl From<x11rb::errors::ConnectionError> for X11Error {
125 
    fn from(value: x11rb::errors::ConnectionError) -> Self {
126 
        X11Error::ConnectionError(value)
127 
    }
128 
}
129
130 
impl From<x11rb::errors::ReplyError> for X11Error {
131 
    fn from(value: x11rb::errors::ReplyError) -> Self {
132 
        X11Error::ReplyError(value)
133 
    }
134 
}
135
136 
impl From<x11rb::errors::ReplyOrIdError> for X11Error {
137 
    fn from(value: x11rb::errors::ReplyOrIdError) -> Self {
138 
        X11Error::ReplyOrIdError(value)
139 
    }
140 
}