peak_can/
error.rs

1//! Module provides two error type: [CanError] and [CanOkError].
2//!
3//! [CanError] models failure codes only whereas [CanOkError] also models the possibility of
4//! success stated by the [Ok](CanOkError::Ok) variant.
5
6use std::error::Error;
7use std::fmt;
8use std::sync::Arc;
9
10use crate::peak_can;
11
12///
13#[derive(Debug, Clone)]
14pub enum CanError {
15    ///
16    Libloading(Arc<libloading::Error>),
17    ///
18    XmtFull,
19    ///
20    Overrun,
21    ///
22    BusLight,
23    ///
24    BusHeavy,
25    ///
26    BusPassive,
27    ///
28    BusOff,
29    ///
30    AnyBusErr,
31    ///
32    QrcvEmpty,
33    ///
34    QOverrun,
35    ///
36    QxmtFull,
37    ///
38    RegTest,
39    ///
40    NoDriver,
41    ///
42    HwInUse,
43    ///
44    NetInUse,
45    ///
46    IllHw,
47    ///
48    IllNet,
49    ///
50    IllClient,
51    ///
52    Resource,
53    ///
54    IllParamType,
55    ///
56    IllParamVal,
57    ///
58    Unknown,
59    ///
60    IllData,
61    ///
62    IllMode,
63    ///
64    Caution,
65    ///
66    Initialize,
67    ///
68    IllOperation,
69}
70
71/// Type modeling all possible states of an operation as exposed by [PEAK_basic_sys].
72#[derive(Debug)]
73pub enum CanOkError {
74    /// Models the success of an operation.
75    Ok,
76    /// Models the failure. Similar to [CanError].
77    Err(CanError),
78}
79
80impl From<CanError> for u32 {
81    fn from(value: CanError) -> u32 {
82        match value {
83            CanError::Libloading(_) => peak_can::PEAK_ERROR_UNKNOWN,
84            CanError::XmtFull => peak_can::PEAK_ERROR_XMTFULL,
85            CanError::Overrun => peak_can::PEAK_ERROR_OVERRUN,
86            CanError::BusLight => peak_can::PEAK_ERROR_BUSLIGHT,
87            CanError::BusHeavy => peak_can::PEAK_ERROR_BUSHEAVY,
88            CanError::BusPassive => peak_can::PEAK_ERROR_BUSPASSIVE,
89            CanError::BusOff => peak_can::PEAK_ERROR_BUSOFF,
90            CanError::AnyBusErr => {
91                let mut value = peak_can::PEAK_ERROR_BUSWARNING;
92                value |= peak_can::PEAK_ERROR_BUSLIGHT;
93                value |= peak_can::PEAK_ERROR_BUSHEAVY;
94                value |= peak_can::PEAK_ERROR_BUSOFF;
95                value |= peak_can::PEAK_ERROR_BUSPASSIVE;
96                value
97            }
98            CanError::QrcvEmpty => peak_can::PEAK_ERROR_QRCVEMPTY,
99            CanError::QOverrun => peak_can::PEAK_ERROR_QOVERRUN,
100            CanError::QxmtFull => peak_can::PEAK_ERROR_QXMTFULL,
101            CanError::RegTest => peak_can::PEAK_ERROR_REGTEST,
102            CanError::NoDriver => peak_can::PEAK_ERROR_NODRIVER,
103            CanError::HwInUse => peak_can::PEAK_ERROR_HWINUSE,
104            CanError::NetInUse => peak_can::PEAK_ERROR_NETINUSE,
105            CanError::IllHw => peak_can::PEAK_ERROR_ILLHW,
106            CanError::IllNet => peak_can::PEAK_ERROR_ILLNET,
107            CanError::IllClient => peak_can::PEAK_ERROR_ILLCLIENT,
108            CanError::Resource => peak_can::PEAK_ERROR_RESOURCE,
109            CanError::IllParamType => peak_can::PEAK_ERROR_ILLPARAMTYPE,
110            CanError::IllParamVal => peak_can::PEAK_ERROR_ILLPARAMVAL,
111            CanError::Unknown => peak_can::PEAK_ERROR_UNKNOWN,
112            CanError::IllData => peak_can::PEAK_ERROR_ILLDATA,
113            CanError::IllMode => peak_can::PEAK_ERROR_ILLMODE,
114            CanError::Caution => peak_can::PEAK_ERROR_CAUTION,
115            CanError::Initialize => peak_can::PEAK_ERROR_INITIALIZE,
116            CanError::IllOperation => peak_can::PEAK_ERROR_ILLOPERATION,
117        }
118    }
119}
120
121impl From<CanOkError> for u32 {
122    fn from(value: CanOkError) -> u32 {
123        match value {
124            CanOkError::Ok => peak_can::PEAK_ERROR_OK,
125            CanOkError::Err(error) => u32::from(error),
126        }
127    }
128}
129
130impl TryFrom<u32> for CanError {
131    type Error = ();
132
133    fn try_from(value: u32) -> Result<Self, Self::Error> {
134        match value {
135            peak_can::PEAK_ERROR_XMTFULL => Ok(CanError::XmtFull),
136            peak_can::PEAK_ERROR_OVERRUN => Ok(CanError::Overrun),
137            peak_can::PEAK_ERROR_BUSLIGHT => Ok(CanError::BusLight),
138            peak_can::PEAK_ERROR_BUSHEAVY => Ok(CanError::BusHeavy),
139            peak_can::PEAK_ERROR_BUSPASSIVE => Ok(CanError::BusPassive),
140            peak_can::PEAK_ERROR_BUSOFF => Ok(CanError::BusOff),
141            peak_can::PEAK_ERROR_ANYBUSERR => Ok(CanError::AnyBusErr),
142            peak_can::PEAK_ERROR_QRCVEMPTY => Ok(CanError::QrcvEmpty),
143            peak_can::PEAK_ERROR_QOVERRUN => Ok(CanError::QOverrun),
144            peak_can::PEAK_ERROR_QXMTFULL => Ok(CanError::QxmtFull),
145            peak_can::PEAK_ERROR_REGTEST => Ok(CanError::RegTest),
146            peak_can::PEAK_ERROR_NODRIVER => Ok(CanError::NoDriver),
147            peak_can::PEAK_ERROR_HWINUSE => Ok(CanError::HwInUse),
148            peak_can::PEAK_ERROR_NETINUSE => Ok(CanError::NetInUse),
149            peak_can::PEAK_ERROR_ILLHW => Ok(CanError::IllHw),
150            peak_can::PEAK_ERROR_ILLNET => Ok(CanError::IllNet),
151            peak_can::PEAK_ERROR_ILLCLIENT => Ok(CanError::IllClient),
152            peak_can::PEAK_ERROR_RESOURCE => Ok(CanError::Resource),
153            peak_can::PEAK_ERROR_ILLPARAMTYPE => Ok(CanError::IllParamType),
154            peak_can::PEAK_ERROR_ILLPARAMVAL => Ok(CanError::IllParamVal),
155            peak_can::PEAK_ERROR_UNKNOWN => Ok(CanError::Unknown),
156            peak_can::PEAK_ERROR_ILLDATA => Ok(CanError::IllData),
157            peak_can::PEAK_ERROR_ILLMODE => Ok(CanError::IllMode),
158            peak_can::PEAK_ERROR_CAUTION => Ok(CanError::Caution),
159            peak_can::PEAK_ERROR_INITIALIZE => Ok(CanError::Initialize),
160            peak_can::PEAK_ERROR_ILLOPERATION => Ok(CanError::IllOperation),
161            _ => Err(()),
162        }
163    }
164}
165
166impl TryFrom<u32> for CanOkError {
167    type Error = ();
168
169    fn try_from(value: u32) -> Result<Self, Self::Error> {
170        match value {
171            peak_can::PEAK_ERROR_OK => Ok(CanOkError::Ok),
172            _ => {
173                let err = CanError::try_from(value)?;
174                Ok(CanOkError::Err(err))
175            }
176        }
177    }
178}
179
180impl From<libloading::Error> for CanError {
181    fn from(value: libloading::Error) -> Self {
182        Self::Libloading(Arc::new(value))
183    }
184}
185
186impl fmt::Display for CanError {
187    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
188        match self {
189            CanError::Libloading(e) => write!(f, "{e}"),
190            CanError::XmtFull => write!(f, "xmt full"),
191            CanError::Overrun => write!(f, "overrun"),
192            CanError::BusLight => write!(f, "bus light"),
193            CanError::BusHeavy => write!(f, "bus heavy"),
194            CanError::BusPassive => write!(f, "bus passive"),
195            CanError::BusOff => write!(f, "bus off"),
196            CanError::AnyBusErr => write!(f, "any bus error"),
197            CanError::QrcvEmpty => write!(f, "qrcv empty"),
198            CanError::QOverrun => write!(f, "q overrun"),
199            CanError::QxmtFull => write!(f, "qxmt full"),
200            CanError::RegTest => write!(f, "reg test"),
201            CanError::NoDriver => write!(f, "no driver"),
202            CanError::HwInUse => write!(f, "hardware in use"),
203            CanError::NetInUse => write!(f, "network in use"),
204            CanError::IllHw => write!(f, "illegal hardware"),
205            CanError::IllNet => write!(f, "illegal network"),
206            CanError::IllClient => write!(f, "illegal client"),
207            CanError::Resource => write!(f, "resource"),
208            CanError::IllParamType => write!(f, "illegal parameter type"),
209            CanError::IllParamVal => write!(f, "illegal parameter value"),
210            CanError::Unknown => write!(f, "unknown"),
211            CanError::IllData => write!(f, "illegal data"),
212            CanError::IllMode => write!(f, "illegal mode"),
213            CanError::Caution => write!(f, "caution"),
214            CanError::Initialize => write!(f, "initialize"),
215            CanError::IllOperation => write!(f, "illegal operation"),
216        }
217    }
218}
219
220impl Error for CanError {}
peak_can/error.rs

peak_can/
error.rs
