steeloxide 0.1.0

A rust library for interacting with SteelSeries devices.
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
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

#[derive(Debug)]
pub enum KeyboardError {
    ZoneOutOfRange,
}

impl std::fmt::Display for KeyboardError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            KeyboardError::ZoneOutOfRange => write!(f, "steeloxide::keyboard error, colouring out of range")
        }
    }
}

impl std::error::Error for KeyboardError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match self {
            KeyboardError::ZoneOutOfRange => None,
        }
    }
}

#[derive(Debug)]
pub enum MouseError {
    InvalidPollingRate,
    ZoneOutOfRange,
}

impl std::fmt::Display for MouseError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            MouseError::InvalidPollingRate => write!(f, "steeloxide::mouse error, polling rate out of range"),
            MouseError::ZoneOutOfRange => write!(f, "steeloxide::mouse error, colouring out of range")
        }
    }
}

impl std::error::Error for MouseError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match self {
            MouseError::InvalidPollingRate => None,
            MouseError::ZoneOutOfRange => None,
        }
    }
}

#[derive(Debug)]
pub enum DeviceError {
    NotFound,
    Mouse(MouseError),
    Keyboard(KeyboardError),
}

impl std::fmt::Display for DeviceError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            DeviceError::NotFound => write!(f, "steeloxide device not found"),
            DeviceError::Mouse(err) => write!(f, "{err}"),
            DeviceError::Keyboard(err) => write!(f, "{err}")
        }
    }
}

impl std::error::Error for DeviceError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match self {
            DeviceError::NotFound => None,
            DeviceError::Mouse(err) => err.source(),
            DeviceError::Keyboard(err) => err.source(),
        }
    }
}


#[derive(Debug)]
pub enum Error {
    IO(std::io::Error),
    HidApi(hidapi::HidError),
    DeviceError(DeviceError)
}

impl std::fmt::Display for Error {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Error::IO(err) => write!(f, "steeloxide I/O error: {err}"),
            Error::HidApi(err) => write!(f, "steeloxide hidapi error: {err}"),
            Error::DeviceError(err) => write!(f, "{err}")
        }
    }
}

impl std::error::Error for Error {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match self {
            Error::IO(err) => err.source(),
            Error::HidApi(err) => err.source(),
            Error::DeviceError(err) => err.source()
        }
    }
}

impl From<std::io::Error> for Error {
    fn from(value: std::io::Error) -> Self {
        Self::IO(value)
    }
}

impl From<hidapi::HidError> for Error {
    fn from(value: hidapi::HidError) -> Self {
        Self::HidApi(value)
    }
}

impl From<MouseError> for Error {
    fn from(value: MouseError) -> Self {
        Self::DeviceError(DeviceError::Mouse(value))
    }
}

impl From<DeviceError> for Error {
    fn from(value: DeviceError) -> Self {
        Self::DeviceError(value)
    }
}

pub type Result<T> = std::result::Result<T, Error>;