Struct actix::Arbiter

pub struct Arbiter { /* fields omitted */ }

An event loop controller.

An arbiter controls the event loop in its thread. Each arbiter runs in a separate thread and provides several methods for event loop access. Each arbiter can belong to a specific System actor.

By default, a panic in an arbiter does not stop the rest of the system, unless the panic is in the system actor. Users of an arbiter can opt into shutting down the system on panic by using Arbiter::builder() and enabling stop_system_on_panic.

Methods

impl Arbiter

pub fn builder() -> ArbiterBuilder

Returns a builder object for customized arbiter creation.

pub fn new<T: Into<String>>(name: T) -> Addr<Arbiter>

Spawns a new thread and runs the event loop in the spawned thread.

Returns the address of the newly created arbiter. Does not stop the system on panic.

pub fn name() -> String

Returns current arbiter's name

pub fn current() -> Addr<Arbiter>

Returns the current arbiter's address.

pub fn registry() -> Registry

Returns the arbiter's registry,

pub fn spawn<F>(future: F) where     F: Future<Item = (), Error = ()> + 'static,

Executes a future on the current thread.

pub fn spawn_fn<F, R>(f: F) where     F: FnOnce() -> R + 'static,     R: IntoFuture<Item = (), Error = ()> + 'static,

Executes a lazily constructed future on the current thread.

The provided closure is run as part of future execution. After it returns, execution will continue with the future created by the closure.

pub fn start<A, F>(f: F) -> Addr<A> where     A: Actor<Context = Context<A>>,     F: FnOnce(&mut A::Context) -> A + Send + 'static,

Starts an actor inside a newly created arbiter.

Returns the address of the actor created.

Trait Implementations

impl Actor for Arbiter

type Context = Context<Self>

Actor execution context type

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

Called when an actor gets polled the first time.

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

Called after an actor is in Actor::Stopping state.

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

Called after an actor is stopped.

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

Start a new asynchronous actor, returning its address.

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

Construct and start a new asynchronous actor, returning its address.

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

Start a new asynchronous actor given a Context.

impl Handler<StopArbiter> for Arbiter

type Result = ()

The type of value that this handler will return.

fn handle(&mut self, msg: StopArbiter, _: &mut Context<Self>)

This method is called for every message received by this actor.

impl<A> Handler<StartActor<A>> for Arbiter where     A: Actor<Context = Context<A>>,

type Result = Addr<A>

The type of value that this handler will return.

fn handle(&mut self, msg: StartActor<A>, _: &mut Context<Self>) -> Addr<A>

This method is called for every message received by this actor.

impl<I: Send, E: Send> Handler<Execute<I, E>> for Arbiter

type Result = Result<I, E>

The type of value that this handler will return.

fn handle(&mut self, msg: Execute<I, E>, _: &mut Context<Self>) -> Result<I, E>

This method is called for every message received by this actor.

impl Drop for Arbiter

fn drop(&mut self)

Executes the destructor for this type.

impl Debug for Arbiter

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.