use std::fmt;
#[derive(Debug, PartialEq, Eq)]
pub enum RenderError {
UnknownRule(String),
UnknownProcessor(String),
ProcessorError { processor: String, message: String },
InvalidExpression(String),
EmptyChoice,
InvalidWeightedChoice(String),
CircularRuleReference(Vec<String>),
UnsupportedValue(String),
InvalidConfigRoot,
UnsupportedStructuredTarget(String),
JsonSerialization(String),
}
impl fmt::Display for RenderError {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
RenderError::UnknownRule(rule) => write!(formatter, "unknown rule: {rule}"),
RenderError::UnknownProcessor(processor) => {
write!(formatter, "unknown processor: {processor}")
}
RenderError::ProcessorError { processor, message } => {
write!(formatter, "processor {processor} failed: {message}")
}
RenderError::InvalidExpression(expression) => {
write!(formatter, "invalid template expression: {expression}")
}
RenderError::EmptyChoice => write!(formatter, "cannot render an empty choice"),
RenderError::InvalidWeightedChoice(message) => {
write!(formatter, "invalid weighted choice: {message}")
}
RenderError::CircularRuleReference(cycle) => {
write!(formatter, "circular rule reference: {}", cycle.join(" -> "))
}
RenderError::UnsupportedValue(value_type) => {
write!(formatter, "unsupported value type: {value_type}")
}
RenderError::InvalidConfigRoot => write!(formatter, "config root must be an object"),
RenderError::UnsupportedStructuredTarget(rule) => {
write!(
formatter,
"structured render target must be an object: {rule}"
)
}
RenderError::JsonSerialization(message) => {
write!(
formatter,
"failed to serialize structured value as JSON: {message}"
)
}
}
}
}
impl std::error::Error for RenderError {}