use std::{fmt, io};
use super::Lane;
#[derive(Debug)]
pub enum AdmissionFailure {
MessageCapacity,
ByteCapacity,
Closed,
Wake(io::Error),
}
impl AdmissionFailure {
pub fn wake_error(&self) -> Option<&io::Error> {
match self {
Self::Wake(error) => Some(error),
Self::MessageCapacity | Self::ByteCapacity | Self::Closed => None,
}
}
}
impl fmt::Display for AdmissionFailure {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::MessageCapacity => formatter.write_str("mailbox message capacity reached"),
Self::ByteCapacity => formatter.write_str("mailbox retained-byte capacity reached"),
Self::Closed => formatter.write_str("mailbox receiver is closed"),
Self::Wake(error) => write!(formatter, "mailbox wake failed: {error}"),
}
}
}
impl std::error::Error for AdmissionFailure {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
self.wake_error()
.map(|error| error as &(dyn std::error::Error + 'static))
}
}
#[derive(Debug)]
pub struct TrySendError<T> {
item: T,
lane: Lane,
failure: AdmissionFailure,
}
impl<T> TrySendError<T> {
pub(super) const fn new(item: T, lane: Lane, failure: AdmissionFailure) -> Self {
Self {
item,
lane,
failure,
}
}
pub const fn lane(&self) -> Lane {
self.lane
}
pub const fn failure(&self) -> &AdmissionFailure {
&self.failure
}
pub fn into_item(self) -> T {
self.item
}
pub fn into_parts(self) -> (T, Lane, AdmissionFailure) {
(self.item, self.lane, self.failure)
}
}
impl<T> fmt::Display for TrySendError<T> {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(formatter, "{} in {:?} lane", self.failure, self.lane)
}
}
impl<T: fmt::Debug> std::error::Error for TrySendError<T> {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
Some(&self.failure)
}
}