use core::{num::NonZeroUsize, time::Duration};
use std::time::Instant;
#[cfg(test)]
mod tests;
#[derive(Debug, PartialEq, Eq)]
#[must_use = "a dropped answer can leave a full batch unflushed, or lose the item it handed back"]
pub enum Push<T> {
Queued,
Full,
Refused(T),
}
#[derive(Debug)]
pub struct Batcher<T> {
max_items: NonZeroUsize,
max_wait: Duration,
opened_at: Option<Instant>,
items: Vec<T>,
}
impl<T> Batcher<T> {
#[must_use]
pub const fn new(max_items: NonZeroUsize, max_wait: Duration) -> Self {
Self {
max_items,
max_wait,
opened_at: None,
items: Vec::new(),
}
}
#[must_use]
pub const fn max_items(&self) -> NonZeroUsize {
self.max_items
}
#[must_use]
pub const fn max_wait(&self) -> Duration {
self.max_wait
}
#[must_use]
pub fn len(&self) -> usize {
self.items.len()
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.items.is_empty()
}
pub fn push(&mut self, item: T, now: Instant) -> Push<T> {
if self.items.len() >= self.max_items.get() {
return Push::Refused(item);
}
if self.items.is_empty() {
self.opened_at = Some(now);
}
self.items.push(item);
if self.items.len() >= self.max_items.get() {
Push::Full
} else {
Push::Queued
}
}
#[must_use]
pub fn deadline(&self) -> Option<Instant> {
self
.opened_at
.map(|opened_at| opened_at.checked_add(self.max_wait).unwrap_or(opened_at))
}
#[must_use]
pub fn ready(&self, now: Instant) -> bool {
self.items.len() >= self.max_items.get()
|| self.deadline().is_some_and(|deadline| now >= deadline)
}
#[must_use = "the drained batch is the only copy — dropping it drops the items"]
pub fn drain(&mut self) -> Vec<T> {
self.opened_at = None;
core::mem::take(&mut self.items)
}
}