onedrop_engine/
error.rs

1//! Error types for the onedrop-engine crate.
2
3use std::fmt;
4
5/// Result type alias for onedrop-engine operations.
6pub type Result<T> = std::result::Result<T, EngineError>;
7
8/// Errors that can occur in the engine.
9#[derive(Debug)]
10pub enum EngineError {
11    /// Preset loading failed
12    PresetLoadFailed(String),
13
14    /// Preset parsing failed
15    PresetParseFailed(onedrop_parser::ParseError),
16
17    /// Expression evaluation failed
18    EvalFailed(onedrop_eval::EvalError),
19
20    /// Rendering failed
21    RenderFailed(onedrop_renderer::RenderError),
22
23    /// No preset loaded
24    NoPresetLoaded,
25
26    /// Invalid audio data
27    InvalidAudioData(String),
28
29    /// Generic error
30    Other(String),
31}
32
33impl fmt::Display for EngineError {
34    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
35        match self {
36            EngineError::PresetLoadFailed(msg) => {
37                write!(f, "Failed to load preset: {}", msg)
38            }
39            EngineError::PresetParseFailed(err) => {
40                write!(f, "Failed to parse preset: {}", err)
41            }
42            EngineError::EvalFailed(err) => {
43                write!(f, "Expression evaluation failed: {}", err)
44            }
45            EngineError::RenderFailed(err) => {
46                write!(f, "Rendering failed: {}", err)
47            }
48            EngineError::NoPresetLoaded => {
49                write!(f, "No preset loaded")
50            }
51            EngineError::InvalidAudioData(msg) => {
52                write!(f, "Invalid audio data: {}", msg)
53            }
54            EngineError::Other(msg) => {
55                write!(f, "Error: {}", msg)
56            }
57        }
58    }
59}
60
61impl std::error::Error for EngineError {}
62
63impl From<onedrop_parser::ParseError> for EngineError {
64    fn from(err: onedrop_parser::ParseError) -> Self {
65        EngineError::PresetParseFailed(err)
66    }
67}
68
69impl From<onedrop_eval::EvalError> for EngineError {
70    fn from(err: onedrop_eval::EvalError) -> Self {
71        EngineError::EvalFailed(err)
72    }
73}
74
75impl From<onedrop_renderer::RenderError> for EngineError {
76    fn from(err: onedrop_renderer::RenderError) -> Self {
77        EngineError::RenderFailed(err)
78    }
79}
80
81impl From<std::io::Error> for EngineError {
82    fn from(err: std::io::Error) -> Self {
83        EngineError::PresetLoadFailed(err.to_string())
84    }
85}