oxwm

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