use std::collections::VecDeque;
use std::sync::{Arc, Mutex, Condvar};
use crate::actor::ActorId;
use crate::error::RuntimeError;
#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum BackpressurePolicy {
Reject,
Block,
DropLowPriority,
}
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct MailboxConfig {
pub capacity: usize,
pub backpressure: BackpressurePolicy,
}
impl Default for MailboxConfig {
fn default() -> Self {
Self {
capacity: 1000,
backpressure: BackpressurePolicy::Reject,
}
}
}
#[allow(dead_code)]
pub struct Mailbox<T> {
inner: Arc<(Mutex<VecDeque<T>>, Condvar)>,
config: MailboxConfig,
}
#[allow(dead_code)]
impl<T> Mailbox<T> {
pub fn new(config: MailboxConfig) -> Self {
Self {
inner: Arc::new((Mutex::new(VecDeque::with_capacity(config.capacity)), Condvar::new())),
config,
}
}
pub fn send(&self, message: T) -> Result<(), RuntimeError> {
let (lock, cvar) = &*self.inner;
let mut queue = lock.lock().map_err(|_| RuntimeError::RuntimeStopped)?;
if queue.len() >= self.config.capacity {
match self.config.backpressure {
BackpressurePolicy::Reject => {
return Err(RuntimeError::MailboxFull(ActorId::new(0)));
}
BackpressurePolicy::Block => {
while queue.len() >= self.config.capacity {
queue = cvar.wait(queue).map_err(|_| RuntimeError::RuntimeStopped)?;
}
}
BackpressurePolicy::DropLowPriority => {
queue.pop_front();
}
}
}
queue.push_back(message);
cvar.notify_one();
Ok(())
}
pub fn receive(&self) -> Option<T> {
let (lock, cvar) = &*self.inner;
let mut queue = lock.lock().ok()?;
loop {
if let Some(message) = queue.pop_front() {
return Some(message);
}
queue = cvar.wait(queue).ok()?;
}
}
pub fn try_receive(&self) -> Option<T> {
let (lock, _) = &*self.inner;
let mut queue = lock.lock().ok()?;
queue.pop_front()
}
pub fn len(&self) -> usize {
let (lock, _) = &*self.inner;
lock.lock().map(|q| q.len()).unwrap_or(0)
}
pub fn is_empty(&self) -> bool {
let (lock, _) = &*self.inner;
lock.lock().map(|q| q.is_empty()).unwrap_or(true)
}
}
impl<T> Clone for Mailbox<T> {
fn clone(&self) -> Self {
Self {
inner: self.inner.clone(),
config: self.config.clone(),
}
}
}