use core::num::NonZeroUsize;
use bornera_core::{ConnectionLimits, RetainedBytes};
use calandria::{EventBatchLimits, TimerLimits};
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct ConnectionSlotLimits {
connection: ConnectionLimits,
decoder: DecoderLimits,
io: IoLimits,
transport: TransportLimits,
publication: PublicationLimits,
outcome_bytes: RetainedBytes,
operation_capacity: NonZeroUsize,
}
impl ConnectionSlotLimits {
pub fn new(
connection: ConnectionLimits,
decoder: DecoderLimits,
io: IoLimits,
transport: TransportLimits,
publication: PublicationLimits,
) -> Result<Self, ConnectionSlotLimitsError> {
let operations = u64::try_from(connection.max_operations())
.map_err(|_| ConnectionSlotLimitsError::OutcomeRetainedOverflow)?;
let operation_capacity = NonZeroUsize::new(connection.max_operations())
.ok_or(ConnectionSlotLimitsError::ZeroOperationCapacity)?;
let outcome_bytes = decoder
.reply_bytes
.get()
.checked_mul(operations)
.map(RetainedBytes::new)
.ok_or(ConnectionSlotLimitsError::OutcomeRetainedOverflow)?;
Ok(Self {
connection,
decoder,
io,
transport,
publication,
outcome_bytes,
operation_capacity,
})
}
pub(crate) const fn connection(self) -> ConnectionLimits {
self.connection
}
pub(crate) const fn decoder_bytes(self) -> RetainedBytes {
self.decoder.buffered_bytes
}
pub const fn decoder_retained_bytes(self) -> RetainedBytes {
self.decoder.buffered_bytes
}
pub(crate) const fn reply_bytes(self) -> RetainedBytes {
self.decoder.reply_bytes
}
pub const fn reply_retained_bytes(self) -> RetainedBytes {
self.decoder.reply_bytes
}
pub(crate) const fn io_operations(self) -> NonZeroUsize {
self.io.operations
}
pub(crate) const fn io_chunk_bytes(self) -> NonZeroUsize {
self.io.chunk_bytes
}
pub const fn transport_retained_bytes(self) -> RetainedBytes {
self.transport.retained_bytes
}
pub const fn transport_limits(self) -> TransportLimits {
self.transport
}
pub(crate) const fn timers(self) -> TimerLimits {
TimerLimits::new(self.operation_capacity, RetainedBytes::ZERO)
}
pub(crate) const fn outcomes(self) -> EventBatchLimits {
EventBatchLimits::new(self.operation_capacity, self.outcome_bytes)
}
pub(crate) const fn lifecycle(self) -> EventBatchLimits {
EventBatchLimits::new(self.publication.lifecycle_events, RetainedBytes::ZERO)
}
pub(crate) fn recovery_lifecycle(self) -> EventBatchLimits {
const FIXED_EPOCH_EDGES: NonZeroUsize = NonZeroUsize::MIN.saturating_add(3);
EventBatchLimits::new(
self.publication.lifecycle_events.max(FIXED_EPOCH_EDGES),
RetainedBytes::ZERO,
)
}
pub(crate) const fn operation_capacity(self) -> NonZeroUsize {
self.operation_capacity
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct DecoderLimits {
buffered_bytes: RetainedBytes,
reply_bytes: RetainedBytes,
}
impl DecoderLimits {
pub const fn new(buffered_bytes: RetainedBytes, reply_bytes: RetainedBytes) -> Self {
Self {
buffered_bytes,
reply_bytes,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct IoLimits {
operations: NonZeroUsize,
chunk_bytes: NonZeroUsize,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct TransportLimits {
retained_bytes: RetainedBytes,
}
impl TransportLimits {
pub const fn new(retained_bytes: RetainedBytes) -> Self {
Self { retained_bytes }
}
pub const fn retained_bytes(self) -> RetainedBytes {
self.retained_bytes
}
}
impl IoLimits {
pub const fn new(operations: NonZeroUsize, chunk_bytes: NonZeroUsize) -> Self {
Self {
operations,
chunk_bytes,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct PublicationLimits {
lifecycle_events: NonZeroUsize,
}
impl PublicationLimits {
pub const fn new(lifecycle_events: NonZeroUsize) -> Self {
Self { lifecycle_events }
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[non_exhaustive]
pub enum ConnectionSlotLimitsError {
ZeroOperationCapacity,
OutcomeRetainedOverflow,
}
impl core::fmt::Display for ConnectionSlotLimitsError {
fn fmt(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str(match self {
Self::ZeroOperationCapacity => "operation capacity must be nonzero",
Self::OutcomeRetainedOverflow => {
"maximum retained outcome bytes overflow the accounting domain"
}
})
}
}
impl core::error::Error for ConnectionSlotLimitsError {}