Struct ConcurrentActor 

pub struct ConcurrentActor {
    pub id: String,
    pub actor_type: String,
    pub state: Arc<RwLock<HashMap<String, ActorFieldValue>>>,
    pub lifecycle_state: Arc<RwLock<ActorState>>,
    pub mailbox_sender: Sender<Envelope>,
    pub thread_handle: Option<JoinHandle<()>>,
    pub children: Arc<RwLock<Vec<String>>>,
    pub supervisor: Option<String>,
    pub supervision_strategy: SupervisionStrategy,
    pub restart_count: Arc<Mutex<u32>>,
    pub last_restart: Arc<Mutex<Instant>>,
}

Concurrent actor instance with its own thread

Fields

id: String

actor_type: String

state: Arc<RwLock<HashMap<String, ActorFieldValue>>>

lifecycle_state: Arc<RwLock<ActorState>>

mailbox_sender: Sender<Envelope>

thread_handle: Option<JoinHandle<()>>

children: Arc<RwLock<Vec<String>>>

supervisor: Option<String>

supervision_strategy: SupervisionStrategy

restart_count: Arc<Mutex<u32>>

last_restart: Arc<Mutex<Instant>>

Implementations

impl ConcurrentActor

pub fn new( id: String, actor_type: String, initial_state: HashMap<String, ActorFieldValue>, supervisor: Option<String>, ) -> Self

Create a new concurrent actor

pub fn start( &mut self, receive_handlers: HashMap<String, String>, ) -> Result<(), InterpreterError>

Start the actor’s execution thread

pub fn stop(&mut self) -> Result<(), InterpreterError>

Stop the actor

pub fn send( &self, message: ActorMessage, from: Option<String>, ) -> Result<(), InterpreterError>

Send a message to this actor

pub fn should_restart(&self) -> bool

Check if actor should be restarted based on supervision strategy

pub fn restart( &mut self, receive_handlers: HashMap<String, String>, ) -> Result<(), InterpreterError>

Restart the actor