use core::{fmt, num::NonZeroUsize};
use super::{ResourceGeneration, ResourceOwnerId, ResourceSlotId};
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum ResourceAdmissionFailure {
IdentityInUse,
CapacityReached {
limit: NonZeroUsize,
},
TokenSpaceExhausted,
}
impl fmt::Display for ResourceAdmissionFailure {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::IdentityInUse => formatter.write_str("resource identity is already admitted"),
Self::CapacityReached { limit } => {
write!(formatter, "resource capacity of {limit} was reached")
}
Self::TokenSpaceExhausted => {
formatter.write_str("resource token generations are exhausted")
}
}
}
}
impl core::error::Error for ResourceAdmissionFailure {}
#[derive(Debug)]
pub struct ResourceAdmissionError<K, R> {
identity: K,
resource: R,
failure: ResourceAdmissionFailure,
}
impl<K, R> ResourceAdmissionError<K, R> {
pub(super) const fn new(identity: K, resource: R, failure: ResourceAdmissionFailure) -> Self {
Self {
identity,
resource,
failure,
}
}
pub const fn failure(&self) -> ResourceAdmissionFailure {
self.failure
}
pub fn into_values(self) -> (K, R) {
(self.identity, self.resource)
}
pub fn into_parts(self) -> (K, R, ResourceAdmissionFailure) {
(self.identity, self.resource, self.failure)
}
}
impl<K, R> fmt::Display for ResourceAdmissionError<K, R> {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
self.failure.fmt(formatter)
}
}
impl<K: fmt::Debug, R: fmt::Debug> core::error::Error for ResourceAdmissionError<K, R> {
fn source(&self) -> Option<&(dyn core::error::Error + 'static)> {
Some(&self.failure)
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum ResourceTokenFailure {
OwnerMismatch {
expected: ResourceOwnerId,
actual: ResourceOwnerId,
},
SlotOutOfBounds {
slot: ResourceSlotId,
capacity: NonZeroUsize,
},
Vacant {
slot: ResourceSlotId,
generation: ResourceGeneration,
},
GenerationMismatch {
slot: ResourceSlotId,
current: ResourceGeneration,
supplied: ResourceGeneration,
},
Exhausted {
slot: ResourceSlotId,
},
}
impl fmt::Display for ResourceTokenFailure {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::OwnerMismatch { expected, actual } => write!(
formatter,
"resource token owner {} does not match owner {}",
actual.get(),
expected.get()
),
Self::SlotOutOfBounds { slot, capacity } => write!(
formatter,
"resource token slot {} exceeds capacity {capacity}",
slot.get()
),
Self::Vacant { slot, generation } => write!(
formatter,
"resource slot {} is vacant at generation {}",
slot.get(),
generation.get()
),
Self::GenerationMismatch {
slot,
current,
supplied,
} => write!(
formatter,
"resource slot {} is at generation {}, not {}",
slot.get(),
current.get(),
supplied.get()
),
Self::Exhausted { slot } => {
write!(formatter, "resource slot {} is exhausted", slot.get())
}
}
}
}
impl core::error::Error for ResourceTokenFailure {}