use std::fmt;
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Error {
pub kind: Kind,
pub message: String,
pub detail: Option<String>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum Kind {
MissingSignature,
MissingSignatureInput,
MissingSignatureLabel,
MissingKey,
MissingComponent,
UnknownKey,
UnsupportedSigner,
Unauthenticated,
MalformedSignature,
MalformedSignatureInput,
MalformedSignatureLabel,
MalformedSignatureValue,
MalformedKey,
MalformedDigest,
UnsupportedComponent,
UnsupportedAlgorithm,
DuplicateComponent,
InsufficientCoverage,
UncoveredBody,
SignatureExpired,
SignatureTooOld,
DigestMismatch,
SignatureMismatch,
InvalidArgument,
}
impl fmt::Display for Kind {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let name = match self {
Kind::MissingSignature => "MissingSignature",
Kind::MissingSignatureInput => "MissingSignatureInput",
Kind::MissingSignatureLabel => "MissingSignatureLabel",
Kind::MissingKey => "MissingKey",
Kind::MissingComponent => "MissingComponent",
Kind::MalformedSignature => "MalformedSignature",
Kind::MalformedSignatureInput => "MalformedSignatureInput",
Kind::MalformedSignatureLabel => "MalformedSignatureLabel",
Kind::MalformedSignatureValue => "MalformedSignatureValue",
Kind::MalformedKey => "MalformedKey",
Kind::MalformedDigest => "MalformedDigest",
Kind::UnsupportedComponent => "UnsupportedComponent",
Kind::UnsupportedAlgorithm => "UnsupportedAlgorithm",
Kind::UncoveredBody => "UncoveredBody",
Kind::SignatureExpired => "SignatureExpired",
Kind::SignatureTooOld => "SignatureTooOld",
Kind::DigestMismatch => "DigestMismatch",
Kind::SignatureMismatch => "SignatureMismatch",
Kind::UnknownKey => "UnknownKey",
Kind::UnsupportedSigner => "UnsupportedSigner",
Kind::Unauthenticated => "Unauthenticated",
Kind::DuplicateComponent => "DuplicateComponent",
Kind::InsufficientCoverage => "InsufficientCoverage",
Kind::InvalidArgument => "InvalidArgument",
};
f.write_str(name)
}
}
impl fmt::Display for Error {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(&self.message)
}
}
impl std::error::Error for Error {}
impl Error {
pub fn new(kind: Kind, message: impl Into<String>) -> Self {
Error {
kind,
message: message.into(),
detail: None,
}
}
pub fn detailed(kind: Kind, message: impl Into<String>, detail: impl Into<String>) -> Self {
Error {
kind,
message: message.into(),
detail: Some(detail.into()),
}
}
}
pub type Result<T> = std::result::Result<T, Error>;