122 lines
3.6 KiB
Rust
122 lines
3.6 KiB
Rust
use std::{backtrace::Backtrace, fmt::Debug};
|
|
|
|
use crate::middleware::{BackendError, Statement, StatementTmpl, Value};
|
|
|
|
pub type Result<T, E = Error> = core::result::Result<T, E>;
|
|
|
|
fn display_wc_map(wc_map: &[Option<Value>]) -> String {
|
|
let mut out = String::new();
|
|
use std::fmt::Write;
|
|
for (i, v) in wc_map.iter().enumerate() {
|
|
write!(out, "- {}: ", i).unwrap();
|
|
if let Some(v) = v {
|
|
writeln!(out, "{}", v).unwrap();
|
|
} else {
|
|
writeln!(out, "none").unwrap();
|
|
}
|
|
}
|
|
out
|
|
}
|
|
|
|
#[derive(thiserror::Error, Debug)]
|
|
pub enum InnerError {
|
|
#[error("{0} {1} is over the limit {2}")]
|
|
MaxLength(String, usize, usize),
|
|
#[error("{0} doesn't match {1:#}.\nWildcard map:\n{map}\nInternal error: {3}", map=display_wc_map(.2))]
|
|
StatementsDontMatch(
|
|
Statement,
|
|
StatementTmpl,
|
|
Vec<Option<Value>>,
|
|
crate::middleware::Error,
|
|
),
|
|
#[error("invalid arguments to {0} operation")]
|
|
OpInvalidArgs(String),
|
|
#[error("Podlang parse error: {0}")]
|
|
PodlangParse(String),
|
|
#[error("POD Request validation error: {0}")]
|
|
PodRequestValidation(String),
|
|
#[error("Too many input PODs provided: {0} were provided, but the maximum is {1}")]
|
|
TooManyInputPods(usize, usize),
|
|
#[error("Too many public statements provided: {0} were provided, but the maximum is {1}")]
|
|
TooManyPublicStatements(usize, usize),
|
|
#[error("Too many statements provided: {0} were provided, but the maximum is {1}")]
|
|
TooManyStatements(usize, usize),
|
|
// Other
|
|
#[error("{0}")]
|
|
Custom(String),
|
|
}
|
|
|
|
#[derive(thiserror::Error)]
|
|
pub enum Error {
|
|
#[error("Inner: {inner}\n{backtrace}")]
|
|
Inner {
|
|
inner: Box<InnerError>,
|
|
backtrace: Box<Backtrace>,
|
|
},
|
|
#[error(transparent)]
|
|
Backend(#[from] BackendError),
|
|
#[error(transparent)]
|
|
Middleware(#[from] crate::middleware::Error),
|
|
}
|
|
|
|
impl From<std::convert::Infallible> for Error {
|
|
fn from(value: std::convert::Infallible) -> Self {
|
|
match value {}
|
|
}
|
|
}
|
|
|
|
impl From<crate::lang::LangError> for Error {
|
|
fn from(value: crate::lang::LangError) -> Self {
|
|
Error::podlang_parse(value)
|
|
}
|
|
}
|
|
|
|
impl Debug for Error {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
std::fmt::Display::fmt(self, f)
|
|
}
|
|
}
|
|
|
|
macro_rules! new {
|
|
($inner:expr) => {
|
|
Error::Inner {
|
|
inner: Box::new($inner),
|
|
backtrace: Box::new(Backtrace::capture()),
|
|
}
|
|
};
|
|
}
|
|
use InnerError::*;
|
|
impl Error {
|
|
pub(crate) fn custom(s: impl Into<String>) -> Self {
|
|
new!(Custom(s.into()))
|
|
}
|
|
pub(crate) fn op_invalid_args(s: String) -> Self {
|
|
new!(OpInvalidArgs(s))
|
|
}
|
|
pub(crate) fn statements_dont_match(
|
|
s0: Statement,
|
|
s1: StatementTmpl,
|
|
wc_map: Vec<Option<Value>>,
|
|
mid_error: crate::middleware::Error,
|
|
) -> Self {
|
|
new!(StatementsDontMatch(s0, s1, wc_map, mid_error))
|
|
}
|
|
pub(crate) fn max_length(obj: String, found: usize, expect: usize) -> Self {
|
|
new!(MaxLength(obj, found, expect))
|
|
}
|
|
pub(crate) fn podlang_parse(e: crate::lang::LangError) -> Self {
|
|
new!(PodlangParse(e.to_string()))
|
|
}
|
|
pub(crate) fn pod_request_validation(e: String) -> Self {
|
|
new!(PodRequestValidation(e))
|
|
}
|
|
pub(crate) fn too_many_input_pods(found: usize, max: usize) -> Self {
|
|
new!(TooManyInputPods(found, max))
|
|
}
|
|
pub(crate) fn too_many_public_statements(found: usize, max: usize) -> Self {
|
|
new!(TooManyPublicStatements(found, max))
|
|
}
|
|
pub(crate) fn too_many_statements(found: usize, max: usize) -> Self {
|
|
new!(TooManyStatements(found, max))
|
|
}
|
|
}
|