use std::{
error::Error,
fmt::{self, Display, Formatter},
};
use crate::catalog::Code;
use crate::wire::WireLimitError;
use super::super::PolicyError;
#[derive(Debug)]
#[non_exhaustive]
pub enum ProblemBuildError {
DiagnosticNotRegistered {
diagnostic: &'static str,
},
InvalidPolicyStatus {
status: u16,
},
CatalogPolicyMismatch {
code: Code,
catalog_status: u16,
policy_status: u16,
},
Policy(PolicyError),
MissingPolicyHeader {
name: &'static str,
},
ValidatorMissing {
code: Code,
},
}
impl Display for ProblemBuildError {
fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
match self {
Self::DiagnosticNotRegistered { diagnostic } => {
write!(formatter, "diagnostic {diagnostic} is not registered")
}
Self::InvalidPolicyStatus { status } => write!(formatter, "invalid status {status}"),
Self::CatalogPolicyMismatch {
code,
catalog_status,
policy_status,
} => write!(
formatter,
"{code} catalog status {catalog_status} disagrees with policy {policy_status}"
),
Self::Policy(error) => write!(formatter, "invalid policy input: {error}"),
Self::MissingPolicyHeader { name } => {
write!(formatter, "policy did not construct required header {name}")
}
Self::ValidatorMissing { code } => {
write!(formatter, "{code} has no compiled evidence validator")
}
}
}
}
impl Error for ProblemBuildError {
fn source(&self) -> Option<&(dyn Error + 'static)> {
match self {
Self::Policy(error) => Some(error),
_ => None,
}
}
}
#[derive(Debug)]
#[non_exhaustive]
pub enum ProblemEncodeError {
EvidenceSerialization(serde_json::Error),
EvidenceNotObject,
EvidenceSchemaMismatch {
path: String,
reason: String,
},
WireLimit(WireLimitError),
BodySerialization(serde_json::Error),
}
impl Display for ProblemEncodeError {
fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
match self {
Self::EvidenceSerialization(error) => write!(formatter, "serialize evidence: {error}"),
Self::EvidenceNotObject => formatter.write_str("public evidence must encode as object"),
Self::EvidenceSchemaMismatch { path, reason } => {
write!(
formatter,
"public evidence violates its schema at {path}: {reason}"
)
}
Self::WireLimit(error) => Display::fmt(error, formatter),
Self::BodySerialization(error) => write!(formatter, "serialize Problem body: {error}"),
}
}
}
impl Error for ProblemEncodeError {
fn source(&self) -> Option<&(dyn Error + 'static)> {
match self {
Self::EvidenceSerialization(error) | Self::BodySerialization(error) => Some(error),
Self::WireLimit(error) => Some(error),
Self::EvidenceNotObject | Self::EvidenceSchemaMismatch { .. } => None,
}
}
}