use core::{fmt, num::NonZeroUsize};
use crate::RetainedBytes;
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum EventBatchFailure {
EventCapacity {
limit: NonZeroUsize,
},
RetainedByteOverflow {
current: RetainedBytes,
event: RetainedBytes,
},
RetainedByteCapacity {
limit: RetainedBytes,
current: RetainedBytes,
event: RetainedBytes,
},
}
impl fmt::Display for EventBatchFailure {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::EventCapacity { limit } => {
write!(formatter, "event batch capacity of {limit} was reached")
}
Self::RetainedByteOverflow { current, event } => write!(
formatter,
"adding {} retained bytes to {} would overflow event-batch accounting",
event.get(),
current.get()
),
Self::RetainedByteCapacity {
limit,
current,
event,
} => write!(
formatter,
"adding {} retained bytes to {} would exceed event-batch limit {}",
event.get(),
current.get(),
limit.get()
),
}
}
}
impl core::error::Error for EventBatchFailure {}
#[derive(Debug)]
pub struct EventBatchError<E> {
event: E,
failure: EventBatchFailure,
}
impl<E> EventBatchError<E> {
pub(super) const fn new(event: E, failure: EventBatchFailure) -> Self {
Self { event, failure }
}
pub const fn failure(&self) -> EventBatchFailure {
self.failure
}
pub fn into_event(self) -> E {
self.event
}
pub fn into_parts(self) -> (E, EventBatchFailure) {
(self.event, self.failure)
}
}
impl<E> fmt::Display for EventBatchError<E> {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
self.failure.fmt(formatter)
}
}
impl<E: fmt::Debug> core::error::Error for EventBatchError<E> {
fn source(&self) -> Option<&(dyn core::error::Error + 'static)> {
Some(&self.failure)
}
}