use std::{
error::Error,
fmt::{self, Display, Formatter},
};
use crate::catalog::{Code, CodeNumber};
use super::super::{CompatibilityReport, LockState, retirement::ReasonViolation};
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum ReservationError {
AlreadyUsed {
number: CodeNumber,
},
NumberSpaceExhausted,
InvalidLockPrefix,
TypeNamespaceTooLong {
maximum: usize,
actual: usize,
},
InvalidGeneratedLock {
reason: String,
},
}
impl Display for ReservationError {
fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
match self {
Self::TypeNamespaceTooLong { maximum, actual } => write!(
formatter,
"catalog type namespace requires {actual} bytes; maximum is {maximum}"
),
Self::InvalidGeneratedLock { reason } => {
write!(formatter, "generated catalog lock is invalid: {reason}")
}
Self::AlreadyUsed { number } => write!(formatter, "diagnostic number {number} is used"),
Self::NumberSpaceExhausted => formatter.write_str("diagnostic number space exhausted"),
Self::InvalidLockPrefix => formatter.write_str("catalog lock prefix is invalid"),
}
}
}
impl Error for ReservationError {}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum AcceptanceError {
Forbidden(CompatibilityReport),
BreakingRequiresAcknowledgement(CompatibilityReport),
InvalidGeneratedLock {
reason: String,
},
}
impl Display for AcceptanceError {
fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
match self {
Self::InvalidGeneratedLock { reason } => {
write!(formatter, "generated catalog lock is invalid: {reason}")
}
Self::Forbidden(report) => write!(
formatter,
"catalog has {} forbidden compatibility change(s)",
report.changes().len()
),
Self::BreakingRequiresAcknowledgement(report) => write!(
formatter,
"catalog has {} change(s), including unacknowledged breaks",
report.changes().len()
),
}
}
}
impl Error for AcceptanceError {}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum RetirementError {
UnknownCode {
code: Code,
},
NotActive {
code: Code,
state: LockState,
},
EmptyReason,
InvalidReplacement {
code: Code,
},
ReplacementCycle {
code: Code,
},
ReasonTooLong {
actual_chars: usize,
maximum: usize,
},
ReasonControlCharacter {
character_index: usize,
},
InvalidGeneratedLock {
reason: String,
},
}
impl Display for RetirementError {
fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
match self {
Self::InvalidGeneratedLock { reason } => {
write!(formatter, "generated catalog lock is invalid: {reason}")
}
Self::UnknownCode { code } => write!(formatter, "diagnostic {code} is not locked"),
Self::NotActive { code, state } => {
write!(formatter, "diagnostic {code} cannot retire from {state:?}")
}
Self::EmptyReason => formatter.write_str("retirement reason must not be empty"),
Self::ReasonTooLong {
actual_chars,
maximum,
} => write!(
formatter,
"retirement reason is {actual_chars} characters; maximum is {maximum}"
),
Self::ReasonControlCharacter { character_index } => write!(
formatter,
"retirement reason contains a control character at index {character_index}"
),
Self::InvalidReplacement { code } => write!(
formatter,
"replacement {code} is not another active or retired diagnostic"
),
Self::ReplacementCycle { code } => {
write!(formatter, "replacement chain containing {code} would cycle")
}
}
}
}
impl Error for RetirementError {}
impl From<ReasonViolation> for RetirementError {
fn from(violation: ReasonViolation) -> Self {
match violation {
ReasonViolation::Empty => Self::EmptyReason,
ReasonViolation::TooLong {
actual_chars,
maximum,
} => Self::ReasonTooLong {
actual_chars,
maximum,
},
ReasonViolation::ControlCharacter { character_index } => {
Self::ReasonControlCharacter { character_index }
}
}
}
}