hydrate_pipeline/
pipeline_error.rs

1use hydrate_data::DataSetError;
2use hydrate_schema::DataSetErrorWithBacktrace;
3use std::sync::Arc;
4
5#[derive(Debug, Clone)]
6pub enum PipelineError {
7    StringError(String),
8    DataSetError(DataSetError),
9    DataSetErrorWithBacktrace(DataSetErrorWithBacktrace),
10    IoError(Arc<std::io::Error>),
11    BincodeError(Arc<bincode::Error>),
12    JsonError(Arc<serde_json::Error>),
13    UuidError(uuid::Error),
14    ThumbnailUnavailable,
15}
16
17impl std::error::Error for PipelineError {
18    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
19        match *self {
20            PipelineError::StringError(_) => None,
21            PipelineError::DataSetError(_) => None,
22            PipelineError::DataSetErrorWithBacktrace(_) => None,
23            PipelineError::IoError(ref e) => Some(&**e),
24            PipelineError::BincodeError(ref e) => Some(&**e),
25            PipelineError::JsonError(ref e) => Some(&**e),
26            PipelineError::UuidError(ref e) => Some(e),
27            PipelineError::ThumbnailUnavailable => None,
28        }
29    }
30}
31
32impl core::fmt::Display for PipelineError {
33    fn fmt(
34        &self,
35        fmt: &mut core::fmt::Formatter,
36    ) -> core::fmt::Result {
37        match *self {
38            PipelineError::StringError(ref e) => e.fmt(fmt),
39            PipelineError::DataSetError(ref e) => {
40                use std::fmt::Debug;
41                e.fmt(fmt)
42            }
43            PipelineError::DataSetErrorWithBacktrace(ref e) => {
44                use std::fmt::Debug;
45                e.fmt(fmt)
46            }
47            PipelineError::IoError(ref e) => e.fmt(fmt),
48            PipelineError::BincodeError(ref e) => e.fmt(fmt),
49            PipelineError::JsonError(ref e) => e.fmt(fmt),
50            PipelineError::UuidError(ref e) => e.fmt(fmt),
51            PipelineError::ThumbnailUnavailable => "ThumbnailUnavailable".fmt(fmt),
52        }
53    }
54}
55
56impl From<&str> for PipelineError {
57    fn from(str: &str) -> Self {
58        PipelineError::StringError(str.to_string())
59    }
60}
61
62impl From<String> for PipelineError {
63    fn from(string: String) -> Self {
64        PipelineError::StringError(string)
65    }
66}
67
68impl From<DataSetError> for PipelineError {
69    fn from(error: DataSetError) -> Self {
70        PipelineError::DataSetError(error)
71    }
72}
73
74impl From<DataSetErrorWithBacktrace> for PipelineError {
75    fn from(error: DataSetErrorWithBacktrace) -> Self {
76        PipelineError::DataSetErrorWithBacktrace(error)
77    }
78}
79
80impl From<std::io::Error> for PipelineError {
81    fn from(error: std::io::Error) -> Self {
82        PipelineError::IoError(Arc::new(error))
83    }
84}
85
86impl From<bincode::Error> for PipelineError {
87    fn from(error: bincode::Error) -> Self {
88        PipelineError::BincodeError(Arc::new(error))
89    }
90}
91
92impl From<serde_json::Error> for PipelineError {
93    fn from(error: serde_json::Error) -> Self {
94        PipelineError::JsonError(Arc::new(error))
95    }
96}
97
98impl From<uuid::Error> for PipelineError {
99    fn from(error: uuid::Error) -> Self {
100        PipelineError::UuidError(error)
101    }
102}
103
104#[derive(Clone)]
105pub struct PipelineErrorWithBacktrace {
106    pub error: PipelineError,
107    #[cfg(all(backtrace, debug_assertions))]
108    backtrace: Arc<backtrace::Backtrace>,
109}
110
111impl std::error::Error for PipelineErrorWithBacktrace {
112    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
113        self.error.source()
114    }
115}
116
117impl core::fmt::Display for PipelineErrorWithBacktrace {
118    fn fmt(
119        &self,
120        fmt: &mut core::fmt::Formatter,
121    ) -> core::fmt::Result {
122        self.error.fmt(fmt)
123    }
124}
125
126impl<T: Into<PipelineError>> From<T> for PipelineErrorWithBacktrace {
127    fn from(error: T) -> Self {
128        PipelineErrorWithBacktrace {
129            error: error.into(),
130            #[cfg(all(backtrace, debug_assertions))]
131            backtrace: Arc::new(backtrace::Backtrace::new()),
132        }
133    }
134}
135
136impl std::fmt::Debug for PipelineErrorWithBacktrace {
137    #[cfg(not(all(backtrace, debug_assertions)))]
138    fn fmt(
139        &self,
140        f: &mut std::fmt::Formatter<'_>,
141    ) -> std::fmt::Result {
142        write!(f, "{:?}", self.error)
143    }
144
145    #[cfg(all(backtrace, debug_assertions))]
146    fn fmt(
147        &self,
148        f: &mut std::fmt::Formatter<'_>,
149    ) -> std::fmt::Result {
150        let backtrace = match &self.error {
151            PipelineError::DataSetErrorWithBacktrace(e) => &e.backtrace,
152            _ => &*self.backtrace,
153        };
154        write!(f, "{:?}:\n{:?}", self.error, backtrace)
155    }
156}
157
158pub type PipelineResult<T> = Result<T, PipelineErrorWithBacktrace>;
hydrate_pipeline/pipeline_error.rs

hydrate_pipeline/
pipeline_error.rs
