use core::fmt;
use calandria::RetainedBytes;
use crate::{ConnectionEpoch, EffectId};
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[non_exhaustive]
pub enum WriteIdentityKind {
Operation,
Effect,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[non_exhaustive]
pub enum WriteAdmissionFailure {
StaleEpoch {
expected: ConnectionEpoch,
received: ConnectionEpoch,
},
IdentityInUse(WriteIdentityKind),
FrameCapacityReached {
limit: usize,
},
RetainedByteCapacity {
retained: RetainedBytes,
incoming: RetainedBytes,
limit: RetainedBytes,
},
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) struct WriteAdmissionError<F> {
failure: WriteAdmissionFailure,
frame: F,
}
impl<F> WriteAdmissionError<F> {
pub(crate) const fn new(failure: WriteAdmissionFailure, frame: F) -> Self {
Self { failure, frame }
}
pub(crate) const fn failure(&self) -> WriteAdmissionFailure {
self.failure
}
pub(crate) fn into_frame(self) -> F {
self.frame
}
}
impl<F> fmt::Display for WriteAdmissionError<F> {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
self.failure.fmt(formatter)
}
}
impl<F: fmt::Debug> core::error::Error for WriteAdmissionError<F> {}
impl fmt::Display for WriteAdmissionFailure {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(match self {
Self::StaleEpoch { .. } => "frame belongs to another connection epoch",
Self::IdentityInUse(_) => "operation or effect identity is already queued",
Self::FrameCapacityReached { .. } => "write-frame capacity is exhausted",
Self::RetainedByteCapacity { .. } => "write retained-byte capacity is exhausted",
})
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[non_exhaustive]
pub enum WriteProgressError {
StaleEpoch {
expected: ConnectionEpoch,
received: ConnectionEpoch,
},
NoPendingWrite,
OutOfOrderEffect {
expected: EffectId,
received: EffectId,
},
ExceedsRemaining {
written: usize,
remaining: usize,
},
ProgressAccountingOverflow {
measured: usize,
written: usize,
},
RetainedAccountingUnderflow {
retained: RetainedBytes,
released: RetainedBytes,
},
}
impl fmt::Display for WriteProgressError {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(match self {
Self::StaleEpoch { .. } => "write progress belongs to another epoch",
Self::NoPendingWrite => "no ordered write is pending",
Self::OutOfOrderEffect { .. } => "write progress does not name the FIFO front",
Self::ExceedsRemaining { .. } => "write progress exceeds remaining frame bytes",
Self::ProgressAccountingOverflow { .. } => {
"write progress exceeded the committed frame measurement"
}
Self::RetainedAccountingUnderflow { .. } => {
"write retained-byte accounting underflowed"
}
})
}
}
impl core::error::Error for WriteProgressError {}