1use std::convert::From;
2use std::fmt::{Debug, Display, Formatter, Result as FmtResult};
3
4#[derive(Debug)]
5pub enum Error {
6 LibLoadingError(libloading::Error),
7 FormatError(std::fmt::Error),
8 FromUtf8Error(std::string::FromUtf8Error),
9 CubeProgrammerError(CubeProgrammerError),
10 IoError(std::io::Error),
11 WideStringError(widestring::error::ContainsNul<crate::wchar>),
12 SliceConversionError(std::array::TryFromSliceError),
13 IntConversionError(std::num::TryFromIntError),
14 FloatConversionError(std::num::ParseFloatError),
15 UnsupportedPlatform,
16}
17
18impl Display for Error {
19 fn fmt(&self, f: &mut Formatter) -> FmtResult {
20 match self {
21 self::Error::LibLoadingError(e) => write!(f, "Lib loading error: {}", e),
22 self::Error::FormatError(e) => write!(f, "Format error: {}", e),
23 self::Error::FromUtf8Error(e) => write!(f, "UTF-8 conversion error: {}", e),
24 self::Error::UnsupportedPlatform => {
25 write!(f, "The target system is not supported")
26 }
27 self::Error::CubeProgrammerError(e) => write!(f, "Cube Programmer error: {}", e),
28 self::Error::IoError(e) => write!(f, "IO error: {}", e),
29 self::Error::WideStringError(e) => write!(f, "Wide string error: {}", e),
30 self::Error::SliceConversionError(e) => write!(f, "Slice conversion error: {}", e),
31 self::Error::IntConversionError(e) => write!(f, "Int conversion error: {}", e),
32 self::Error::FloatConversionError(e) => write!(f, "Float conversion error: {}", e),
33 }
34 }
35}
36
37impl From<libloading::Error> for Error {
38 fn from(err: libloading::Error) -> Error {
39 Error::LibLoadingError(err)
40 }
41}
42
43impl From<std::fmt::Error> for Error {
44 fn from(err: std::fmt::Error) -> Error {
45 Error::FormatError(err)
46 }
47}
48
49impl From<std::string::FromUtf8Error> for Error {
50 fn from(err: std::string::FromUtf8Error) -> Error {
51 Error::FromUtf8Error(err)
52 }
53}
54
55impl From<CubeProgrammerError> for Error {
56 fn from(err: CubeProgrammerError) -> Error {
57 Error::CubeProgrammerError(err)
58 }
59}
60
61impl From<std::io::Error> for Error {
62 fn from(err: std::io::Error) -> Error {
63 Error::IoError(err)
64 }
65}
66
67impl From<widestring::error::ContainsNul<crate::wchar>> for Error {
68 fn from(err: widestring::error::ContainsNul<crate::wchar>) -> Error {
69 Error::WideStringError(err)
70 }
71}
72
73impl From<std::array::TryFromSliceError> for Error {
74 fn from(err: std::array::TryFromSliceError) -> Error {
75 Error::SliceConversionError(err)
76 }
77}
78
79impl From<std::num::TryFromIntError> for Error {
80 fn from(err: std::num::TryFromIntError) -> Error {
81 Error::IntConversionError(err)
82 }
83}
84
85impl From<std::num::ParseFloatError> for Error {
86 fn from(err: std::num::ParseFloatError) -> Error {
87 Error::FloatConversionError(err)
88 }
89}
90
91impl std::error::Error for Error {}
92
93#[derive(Debug, Copy, Clone)]
94pub enum CubeProgrammerError {
95 DeviceNotConnected = -1,
96 NoDeviceFound = -2,
97 ConnectionError = -3,
98 FileNotFound = -4,
99 UnsupportedOperation = -5,
100 UnsupportedInterface = -6,
101 InsufficientMemory = -7,
102 UnknownParameters = -8,
103 MemoryReadError = -9,
104 MemoryWriteError = -10,
105 MemoryEraseError = -11,
106 UnsupportedFileFormat = -12,
107 RefreshRequired = -13,
108 SecurityError = -14,
109 FrequencyError = -15,
110 RdpEnabledError = -16,
111 UnknownError = -17,
112}
113
114impl Display for CubeProgrammerError {
115 fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
116 match self {
117 CubeProgrammerError::DeviceNotConnected => write!(f, "Device not connected"),
118 CubeProgrammerError::NoDeviceFound => write!(f, "Device not found"),
119 CubeProgrammerError::ConnectionError => write!(f, "Device connection error"),
120 CubeProgrammerError::FileNotFound => write!(f, "No such file"),
121 CubeProgrammerError::UnsupportedOperation => write!(
122 f,
123 "Operation not supported or unimplemented on this interface"
124 ),
125 CubeProgrammerError::UnsupportedInterface => write!(
126 f,
127 "Interface not supported or unimplemented on this plateform"
128 ),
129 CubeProgrammerError::InsufficientMemory => write!(f, "Insufficient memory"),
130 CubeProgrammerError::UnknownParameters => write!(f, "Wrong parameters"),
131 CubeProgrammerError::MemoryReadError => write!(f, "Memory read failure"),
132 CubeProgrammerError::MemoryWriteError => write!(f, "Memory write failure"),
133 CubeProgrammerError::MemoryEraseError => write!(f, "Memory erase failure"),
134 CubeProgrammerError::UnsupportedFileFormat => {
135 write!(f, "File format not supported for this kind of device")
136 }
137 CubeProgrammerError::RefreshRequired => write!(f, "Refresh required"),
138 CubeProgrammerError::SecurityError => write!(f, "Security error"),
139 CubeProgrammerError::FrequencyError => write!(f, "Frequency error"),
140 CubeProgrammerError::RdpEnabledError => write!(f, "RDP Enabled error"),
141 CubeProgrammerError::UnknownError => write!(f, "Unknown error"),
142 }
143 }
144}
145
146impl From<i32> for CubeProgrammerError {
147 fn from(value: i32) -> CubeProgrammerError {
148 match value {
149 -1 => CubeProgrammerError::DeviceNotConnected,
150 -2 => CubeProgrammerError::NoDeviceFound,
151 -3 => CubeProgrammerError::ConnectionError,
152 -4 => CubeProgrammerError::FileNotFound,
153 -5 => CubeProgrammerError::UnsupportedOperation,
154 -6 => CubeProgrammerError::UnsupportedInterface,
155 -7 => CubeProgrammerError::InsufficientMemory,
156 -8 => CubeProgrammerError::UnknownParameters,
157 -9 => CubeProgrammerError::MemoryReadError,
158 -10 => CubeProgrammerError::MemoryWriteError,
159 -11 => CubeProgrammerError::MemoryEraseError,
160 -12 => CubeProgrammerError::UnsupportedFileFormat,
161 -13 => CubeProgrammerError::RefreshRequired,
162 -14 => CubeProgrammerError::SecurityError,
163 -15 => CubeProgrammerError::FrequencyError,
164 -16 => CubeProgrammerError::RdpEnabledError,
165 _ => CubeProgrammerError::UnknownError,
166 }
167 }
168}
169
170impl std::error::Error for CubeProgrammerError {}