1use thiserror::Error;
2
3use crate::{
4 fdb_err_t, fdb_err_t_FDB_ERASE_ERR, fdb_err_t_FDB_INIT_FAILED, fdb_err_t_FDB_KV_NAME_ERR,
5 fdb_err_t_FDB_KV_NAME_EXIST, fdb_err_t_FDB_NO_ERR, fdb_err_t_FDB_PART_NOT_FOUND,
6 fdb_err_t_FDB_READ_ERR, fdb_err_t_FDB_SAVED_FULL, fdb_err_t_FDB_WRITE_ERR,
7};
8
9type Result<T> = core::result::Result<T, Error>;
10
11#[derive(Error, Debug)]
12pub enum Error {
13 #[error("Ok")]
14 Ok,
15 #[error("Erase operation failed")]
16 EraseError,
17 #[error("Read operation failed")]
18 ReadError,
19 #[error("Write operation failed")]
20 WriteError,
21 #[error("Partition not found")]
22 PartNotFound,
23 #[error("Invalid KV name")]
24 KvNameError,
25 #[error("KV name already exists")]
26 KvNameExist,
27 #[error("Storage full")]
28 SavedFull,
29 #[error("Initialization failed")]
30 InitFailed,
31 #[error("Unknown error")]
32 UnknownError,
33 #[error("Invalid argument")]
34 InvalidArgument,
35 #[error("Key not found")]
36 KeyNotFound,
37 #[cfg(feature = "std")]
40 #[error("IO error: {0}")]
41 IO(std::io::Error),
42}
43
44impl Error {
45 pub fn convert(error: fdb_err_t) -> Result<()> {
46 if error == fdb_err_t_FDB_NO_ERR {
47 Ok(())
48 } else {
49 Err(error.into())
50 }
51 }
52
53 pub fn check_and_return<T>(error: fdb_err_t, value: T) -> Result<T> {
54 if error == fdb_err_t_FDB_NO_ERR {
55 Ok(value)
56 } else {
57 Err(error.into())
58 }
59 }
60}
61
62impl From<fdb_err_t> for Error {
64 fn from(err: fdb_err_t) -> Self {
65 match err {
66 fdb_err_t_FDB_NO_ERR => Error::Ok,
67 fdb_err_t_FDB_ERASE_ERR => Error::EraseError,
68 fdb_err_t_FDB_READ_ERR => Error::ReadError,
69 fdb_err_t_FDB_WRITE_ERR => Error::WriteError,
70 fdb_err_t_FDB_PART_NOT_FOUND => Error::PartNotFound,
71 fdb_err_t_FDB_KV_NAME_ERR => Error::KvNameError,
72 fdb_err_t_FDB_KV_NAME_EXIST => Error::KvNameExist,
73 fdb_err_t_FDB_SAVED_FULL => Error::SavedFull,
74 fdb_err_t_FDB_INIT_FAILED => Error::InitFailed,
75 _ => Error::UnknownError,
76 }
77 }
78}
79
80#[cfg(feature = "std")]
81impl From<std::io::Error> for Error {
82 fn from(err: std::io::Error) -> Self {
83 Self::IO(err)
84 }
85}
86
87impl embedded_io::Error for Error {
88 fn kind(&self) -> embedded_io::ErrorKind {
89 match self {
90 Error::ReadError => embedded_io::ErrorKind::Other,
91 Error::WriteError => embedded_io::ErrorKind::Other,
92 Error::EraseError => embedded_io::ErrorKind::Other,
93 Error::InitFailed => embedded_io::ErrorKind::Other,
94 Error::PartNotFound => embedded_io::ErrorKind::NotFound,
95 Error::KeyNotFound => embedded_io::ErrorKind::NotFound,
96 Error::KvNameError => embedded_io::ErrorKind::InvalidInput,
97 Error::KvNameExist => embedded_io::ErrorKind::AlreadyExists,
98 Error::SavedFull => embedded_io::ErrorKind::OutOfMemory,
99 Error::InvalidArgument => embedded_io::ErrorKind::InvalidInput,
100 Error::UnknownError => embedded_io::ErrorKind::Other,
101 Error::Ok => embedded_io::ErrorKind::Other, #[cfg(feature = "std")]
103 Error::IO(err) => err.kind().into(),
104 }
105 }
106}
107
108impl embedded_storage::nor_flash::NorFlashError for Error {
109 fn kind(&self) -> embedded_storage::nor_flash::NorFlashErrorKind {
110 match self {
111 Error::InvalidArgument => embedded_storage::nor_flash::NorFlashErrorKind::NotAligned,
113 _ => embedded_storage::nor_flash::NorFlashErrorKind::Other,
115 }
116 }
117}