use saturnus_core::Halt;
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum Error {
Halted(Halt),
Machine(saturnus_core::Error),
Objects(saturnus_objects::Error),
Message(String),
}
pub type Result<T, E = Error> = std::result::Result<T, E>;
impl std::fmt::Display for Error {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Error::Halted(h) => write!(f, "CPU halted: {h}"),
Error::Machine(e) => e.fmt(f),
Error::Objects(e) => write!(f, "{e:#}"),
Error::Message(m) => f.write_str(m),
}
}
}
impl std::error::Error for Error {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match self {
Error::Machine(e) => Some(e),
Error::Halted(_) | Error::Objects(_) | Error::Message(_) => None,
}
}
}
impl From<Halt> for Error {
fn from(h: Halt) -> Self {
Self::Halted(h)
}
}
impl From<saturnus_core::Error> for Error {
fn from(e: saturnus_core::Error) -> Self {
Self::Machine(e)
}
}
impl From<saturnus_objects::Error> for Error {
fn from(e: saturnus_objects::Error) -> Self {
Self::Objects(e)
}
}
impl From<saturnus_objects::DecodeError> for Error {
fn from(e: saturnus_objects::DecodeError) -> Self {
Self::Objects(e.into())
}
}
impl From<String> for Error {
fn from(message: String) -> Self {
Self::Message(message)
}
}
impl From<&str> for Error {
fn from(message: &str) -> Self {
Self::Message(message.to_string())
}
}