use core::fmt;
use crate::{Delivery, WriteAdmissionFailure};
use super::OperationPermit;
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[non_exhaustive]
pub enum ReserveError {
AdmissionClosed,
DeadlineElapsed,
OperationCapacity,
RetainedByteCapacity,
WriteCapacity,
MatchKeyExhausted,
IdentityExhausted,
OwnerPoisoned,
}
impl fmt::Display for ReserveError {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(match self {
Self::AdmissionClosed => "connection admission is closed",
Self::DeadlineElapsed => "operation deadline is already elapsed",
Self::OperationCapacity => "operation count capacity is exhausted",
Self::RetainedByteCapacity => "retained byte capacity is exhausted",
Self::WriteCapacity => "write-frame count or retained-memory capacity is exhausted",
Self::MatchKeyExhausted => "match key space is exhausted",
Self::IdentityExhausted => "operation or effect identity is exhausted",
Self::OwnerPoisoned => "connection owner is poisoned",
})
}
}
impl core::error::Error for ReserveError {}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[non_exhaustive]
pub enum CommitErrorKind {
ForeignPermit,
AdmissionClosed,
FrameTooLarge,
OwnerPoisoned,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[non_exhaustive]
pub enum FrameCommitFailure {
Policy(CommitErrorKind),
Writer(WriteAdmissionFailure),
}
pub struct FrameCommitError<F> {
failure: FrameCommitFailure,
permit: OperationPermit,
frame: F,
}
impl<F> FrameCommitError<F> {
pub(crate) const fn new(
failure: FrameCommitFailure,
permit: OperationPermit,
frame: F,
) -> Self {
Self {
failure,
permit,
frame,
}
}
pub const fn failure(&self) -> FrameCommitFailure {
self.failure
}
pub const fn delivery(&self) -> Delivery {
Delivery::NotSent
}
pub fn into_parts(self) -> (OperationPermit, F) {
(self.permit, self.frame)
}
}
impl<F> fmt::Debug for FrameCommitError<F>
where
F: fmt::Debug,
{
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("FrameCommitError")
.field("failure", &self.failure)
.field("permit", &self.permit)
.field("frame", &self.frame)
.finish()
}
}
impl<F> fmt::Display for FrameCommitError<F> {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
self.failure.fmt(formatter)
}
}
impl<F: fmt::Debug> core::error::Error for FrameCommitError<F> {}
impl fmt::Display for FrameCommitFailure {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Policy(kind) => formatter.write_str(match kind {
CommitErrorKind::ForeignPermit => "operation permit belongs to another epoch",
CommitErrorKind::AdmissionClosed => "admission closed before operation commit",
CommitErrorKind::FrameTooLarge => {
"frame retained footprint exceeds reserved write memory"
}
CommitErrorKind::OwnerPoisoned => "connection owner is poisoned",
}),
Self::Writer(failure) => failure.fmt(formatter),
}
}
}