sprite-core 0.1.0

use std::sync::atomic::{AtomicUsize, Ordering};
use crate::engine::{Engine, Handle};
use crate::actor::Context;
use crate::message::Message;

/// A round-robin pool of identical actors.
pub struct Pool {
    handles: Vec<Handle>,
    idx: AtomicUsize,
}

impl Pool {
    /// Create a pool of `count` actors, all running the same setup.
    pub fn new<F>(engine: &Engine, name: &str, count: usize, setup: F) -> Self
    where
        F: Fn(&mut Context) + Clone + Send + Sync + 'static,
    {
        let mut handles = Vec::with_capacity(count);
        for i in 0..count {
            let handle = engine.spawn(&format!("{}-{}", name, i), setup.clone());
            handles.push(handle);
        }
        Self { handles, idx: AtomicUsize::new(0) }
    }

    /// Send a message to the next actor in round-robin order.
    pub fn send(&self, msg: Message) {
        let idx = self.idx.fetch_add(1, Ordering::Relaxed) % self.handles.len();
        self.handles[idx].send(msg);
    }

    /// Broadcast a message to every actor in the pool.
    pub fn broadcast(&self, msg: Message) {
        for h in &self.handles {
            h.send(msg.clone());
        }
    }

    /// Get a handle by index.
    pub fn get(&self, idx: usize) -> Option<&Handle> {
        self.handles.get(idx)
    }

    pub fn len(&self) -> usize { self.handles.len() }
    pub fn is_empty(&self) -> bool { self.handles.is_empty() }
}