Struct heph_rt::access::ThreadLocal

pub struct ThreadLocal { /* private fields */ }

Provides access to the thread-local runtime.

This implements the Access trait, which is required by various APIs to get access to the runtime. Furthermore this gives access to a RuntimeRef for users.

This is usually a part of the actor::Context, see it for more information.

This is an optimised version of ThreadSafe, but doesn’t allow the actor to move between threads.

Methods from Deref<Target = 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 ThreadLocal

fn clone(&self) -> ThreadLocal

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ThreadLocal

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

Formats the value using the given formatter.

impl Deref for ThreadLocal

type Target = RuntimeRef

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for ThreadLocal

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<S, NA> Spawn<S, NA, ThreadLocal> for RuntimeRefwhere
    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.

impl<S, NA> Spawn<S, NA, ThreadLocal> for ThreadLocalwhere
    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.

impl<S, NA> Spawn<S, NA, ThreadSafe> for ThreadLocalwhere
    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.

impl Access for ThreadLocal