Skip to main content

datex_core/serde/
error.rs

1#[cfg(feature = "compiler")]
2use crate::compiler::error::{CompilerError, SpannedCompilerError};
3use crate::runtime::execution::ExecutionError;
4
5use crate::prelude::*;
6use core::{fmt, fmt::Display, prelude::rust_2024::*};
7use serde::{
8    de::Error,
9    ser::{
10        StdError, {self},
11    },
12};
13
14#[derive(Debug)]
15pub enum SerializationError {
16    Custom(String),
17    CanNotSerialize(String),
18    #[cfg(feature = "compiler")]
19    CompilerError(CompilerError),
20}
21impl ser::Error for SerializationError {
22    fn custom<T: fmt::Display>(msg: T) -> Self {
23        SerializationError::Custom(msg.to_string())
24    }
25}
26impl Error for SerializationError {
27    fn custom<T: fmt::Display>(msg: T) -> Self {
28        SerializationError::Custom(msg.to_string())
29    }
30}
31
32impl From<String> for SerializationError {
33    fn from(e: String) -> Self {
34        SerializationError::Custom(e)
35    }
36}
37
38#[cfg(feature = "compiler")]
39impl From<CompilerError> for SerializationError {
40    fn from(e: CompilerError) -> Self {
41        SerializationError::CompilerError(e)
42    }
43}
44impl StdError for SerializationError {}
45impl Display for SerializationError {
46    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
47        match self {
48            SerializationError::Custom(msg) => {
49                core::write!(f, "Serialization error: {}", msg)
50            }
51            SerializationError::CanNotSerialize(msg) => {
52                core::write!(f, "Can not serialize value: {}", msg)
53            }
54            #[cfg(feature = "compiler")]
55            SerializationError::CompilerError(err) => {
56                core::write!(f, "Compiler error: {}", err)
57            }
58        }
59    }
60}
61
62#[derive(Debug)]
63pub enum DeserializationError {
64    Custom(String),
65    CanNotDeserialize(String),
66    ExecutionError(ExecutionError),
67    CanNotReadFile(String),
68    #[cfg(feature = "compiler")]
69    CompilerError(SpannedCompilerError),
70    NoStaticValueFound,
71}
72impl ser::Error for DeserializationError {
73    fn custom<T: fmt::Display>(msg: T) -> Self {
74        DeserializationError::Custom(msg.to_string())
75    }
76}
77impl Error for DeserializationError {
78    fn custom<T: fmt::Display>(msg: T) -> Self {
79        DeserializationError::Custom(msg.to_string())
80    }
81}
82
83impl From<String> for DeserializationError {
84    fn from(e: String) -> Self {
85        DeserializationError::Custom(e.to_string())
86    }
87}
88impl From<ExecutionError> for DeserializationError {
89    fn from(e: ExecutionError) -> Self {
90        DeserializationError::ExecutionError(e)
91    }
92}
93
94impl StdError for DeserializationError {}
95impl Display for DeserializationError {
96    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
97        match self {
98            DeserializationError::Custom(msg) => {
99                core::write!(f, "Deserialization error: {}", msg)
100            }
101            DeserializationError::CanNotDeserialize(msg) => {
102                core::write!(f, "Can not deserialize value: {}", msg)
103            }
104            DeserializationError::ExecutionError(err) => {
105                core::write!(f, "Execution error: {}", err)
106            }
107            DeserializationError::CanNotReadFile(msg) => {
108                core::write!(f, "Can not read file: {}", msg)
109            }
110            #[cfg(feature = "compiler")]
111            DeserializationError::CompilerError(err) => {
112                core::write!(f, "Compiler error: {}", err)
113            }
114            DeserializationError::NoStaticValueFound => {
115                core::write!(f, "No static value found in script")
116            }
117        }
118    }
119}