Struct heph::rt::RuntimeRef

pub struct RuntimeRef { /* fields omitted */ }

A reference to a Runtime.

This reference refers to the thread-local runtime, and thus can’t be shared across thread bounds. To share this reference (within the same thread) it can be cloned.

Implementations

impl RuntimeRef

pub fn try_spawn_local<S, NA>(
    &mut self,
    supervisor: S,
    new_actor: NA,
    arg: NA::Argument,
    options: ActorOptions
) -> Result<ActorRef<NA::Message>, NA::Error> where
    S: Supervisor<NA> + 'static,
    NA: NewActor<RuntimeAccess = ThreadLocal> + 'static,
    NA::Actor: 'static, 

Attempt to spawn a new thread-local actor.

See the Spawn trait for more information.

pub fn spawn_local<S, NA>(
    &mut self,
    supervisor: S,
    new_actor: NA,
    arg: NA::Argument,
    options: ActorOptions
) -> ActorRef<NA::Message> where
    S: Supervisor<NA> + 'static,
    NA: NewActor<Error = !, RuntimeAccess = ThreadLocal> + 'static,
    NA::Actor: 'static, 

Spawn a new thread-local actor.

See the Spawn trait for more information.

pub fn try_spawn<S, NA>(
    &mut self,
    supervisor: S,
    new_actor: NA,
    arg: NA::Argument,
    options: ActorOptions
) -> Result<ActorRef<NA::Message>, NA::Error> where
    S: Supervisor<NA> + Send + Sync + 'static,
    NA: NewActor<RuntimeAccess = ThreadSafe> + Sync + Send + 'static,
    NA::Actor: Send + Sync + 'static,
    NA::Message: Send, 

Attempt to spawn a new thread-safe actor.

See the Spawn trait for more information.

pub fn spawn<S, NA>(
    &mut self,
    supervisor: S,
    new_actor: NA,
    arg: NA::Argument,
    options: ActorOptions
) -> ActorRef<NA::Message> where
    S: Supervisor<NA> + Send + Sync + 'static,
    NA: NewActor<Error = !, RuntimeAccess = ThreadSafe> + Sync + Send + 'static,
    NA::Actor: Send + Sync + 'static,
    NA::Message: Send, 

Spawn a new thread-safe actor.

See the Spawn trait for more information.

pub fn spawn_local_future<Fut>(&mut self, future: Fut, options: FutureOptions) where
    Fut: Future<Output = ()> + 'static, 

Spawn a thread-local Future.

Similar to thread-local actors this will only run on a single thread. See the discussion of thread-local vs. thread-safe actors in the actor module for additional information.

pub fn spawn_future<Fut>(&mut self, future: Fut, options: FutureOptions) where
    Fut: Future<Output = ()> + Send + Sync + 'static, 

Spawn a thread-safe Future.

Similar to thread-safe actors this can run on any of the workers threads. See the discussion of thread-local vs. thread-safe actors in the actor module for additional information.

pub fn receive_signals(&mut self, actor_ref: ActorRef<Signal>)

Receive process signals as messages.

This adds the actor_ref to the list of actor references that will receive a process signal.

Trait Implementations

impl Clone for RuntimeRef

fn clone(&self) -> RuntimeRef

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RuntimeRef

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

Formats the value using the given formatter.

impl<S, NA> Spawn<S, NA, ThreadLocal> for RuntimeRef where
    S: Supervisor<NA> + 'static,
    NA: NewActor<RuntimeAccess = ThreadLocal> + 'static,
    NA::Actor: 'static, 

fn try_spawn(
    &mut self,
    supervisor: S,
    new_actor: NA,
    arg: NA::Argument,
    options: ActorOptions
) -> Result<ActorRef<NA::Message>, NA::Error> where
    S: Supervisor<NA>,
    NA: NewActor<RuntimeAccess = RT>, 

Attempts to spawn an actor.

fn spawn(
    &mut self,
    supervisor: S,
    new_actor: NA,
    arg: NA::Argument,
    options: ActorOptions
) -> ActorRef<NA::Message> where
    S: Supervisor<NA>,
    NA: NewActor<Error = !, RuntimeAccess = RT>, 

Spawn an actor.

impl<S, NA> Spawn<S, NA, ThreadSafe> for RuntimeRef where
    S: Supervisor<NA> + Send + Sync + 'static,
    NA: NewActor<RuntimeAccess = ThreadSafe> + Send + Sync + 'static,
    NA::Actor: Send + Sync + 'static,
    NA::Message: Send, 

fn try_spawn(
    &mut self,
    supervisor: S,
    new_actor: NA,
    arg: NA::Argument,
    options: ActorOptions
) -> Result<ActorRef<NA::Message>, NA::Error> where
    S: Supervisor<NA>,
    NA: NewActor<RuntimeAccess = RT>, 

Attempts to spawn an actor.

fn spawn(
    &mut self,
    supervisor: S,
    new_actor: NA,
    arg: NA::Argument,
    options: ActorOptions
) -> ActorRef<NA::Message> where
    S: Supervisor<NA>,
    NA: NewActor<Error = !, RuntimeAccess = RT>, 

Spawn an actor.