Struct actix_lua::LuaActor

pub struct LuaActor {
    pub recipients: HashMap<String, Recipient<LuaMessage>>,
    // some fields omitted
}

Top level struct which holds a lua state for itself.

It provides most of the actix context API to the lua enviroment.

You can create new LuaActor with LuaActorBuilder.

ctx.msg

The message sent to Lua actor.

ctx.notify(msg)

Send message msg to self.

ctx.notify_later(msg, seconds)

Send message msg to self after specified period of time.

local result = ctx.send(recipient, msg)

Send message msg to `recipient asynchronously and wait for response.

Calling ctx.send yield the current coroutine and returns a ThreadYield(thread_id) message. LuaActor will wait for the response and resume the yielded coroutine once the response is returned.

Equivalent to actix::Recipient.send.

ctx.do_send(recipient, msg)

Send message msg to recipient.

Equivalent to actix::Recipient.do_send.

ctx.terminate()

Terminate actor execution.

Fields

recipients: HashMap<String, Recipient<LuaMessage>>

Methods

impl LuaActor

pub fn new_with_vm(
    vm: Lua,
    started: Option<String>,
    handle: Option<String>,
    stopped: Option<String>
) -> Result<LuaActor, LuaError>

pub fn new(
    started: Option<String>,
    handle: Option<String>,
    stopped: Option<String>
) -> Result<LuaActor, LuaError>

pub fn add_recipients(
    &mut self,
    name: &str,
    rec: Recipient<LuaMessage>
) -> Option<Recipient<LuaMessage>>

Add a recipient to the actor's recipient list. You can send message to the recipient via name with the context API ctx.send(name, message)

Trait Implementations

impl Actor for LuaActor

type Context = Context<Self>

Actor execution context type

fn started(&mut self, ctx: &mut Context<Self>)

Method is called when actor get polled first time.

fn stopped(&mut self, ctx: &mut Context<Self>)

Method is called after an actor is stopped, it can be used to perform any needed cleanup work or spawning more actors. This is final state, after this call actor get dropped.

fn stopping(&mut self, ctx: &mut Self::Context) -> Running

Method is called after an actor is in Actor::Stopping state. There could be several reasons for stopping. Context::stop get called by the actor itself. All addresses to current actor get dropped and no more evented objects left in the context.

fn start(self) -> Addr<Self> where
    Self: Actor<Context = Context<Self>>, 

Start new asynchronous actor, returns address of newly created actor.

fn start_default() -> Addr<Self> where
    Self: Actor<Context = Context<Self>> + Default, 

Start new asynchronous actor, returns address of newly created actor.

fn create<F>(f: F) -> Addr<Self> where
    F: FnOnce(&mut Context<Self>) -> Self + 'static,
    Self: Actor<Context = Context<Self>>, 

Use create method, if you need Context object during actor initialization.

impl Handler<LuaMessage> for LuaActor

type Result = LuaMessage

The type of value that this handle will return

fn handle(&mut self, msg: LuaMessage, ctx: &mut Context<Self>) -> Self::Result

Method is called for every message received by this Actor