Struct ActorRef 

pub struct ActorRef<M>
where
    M: MessageBounds,
{ /* private fields */ }

A reference to an actor with type Message = M;

Use tell to send messages to the referenced actor.

This kind of actor reference is similar to a Weak in that it doesn’t prevent deallocation of the referenced actor. If deallocation must be prevented for some reason, consider upgrading this to an ActorRefStrong using hold. Note that a component can still enter the destroyed (or other non-active) state, while a strong reference is held. Holding a strong reference only prevent memory deallocation, but does not guarantee messag handling.

Upgrading this to an ActorRefStrong also improves performance somewhat, and is recommended when using the same actor reference over and over again in a loop, for example.

Implementations

impl<M> ActorRef<M>

where M: MessageBounds,

pub fn enqueue(&self, env: MsgEnvelope<M>)

Enqueue a fully prepared message envelope directly into the actor mailbox.

This bypasses the Into<M> conversion used by tell and is primarily intended for advanced integrations that already operate on MsgEnvelope values.

pub fn hold(&self) -> Option<ActorRefStrong<M>>

Upgrade this reference to a strong reference

This is only possible if the target actor has not already been deallocated. If it has, None will be returned.

pub fn tell<I>(&self, v: I)

where I: Into<M>,

Send message v to the actor instance referenced by this actor reference

pub fn ask_with<R, F>(&self, f: F) -> KFuture<R>

where R: Send, F: FnOnce(KPromise<R>) -> M,

Helper to create messages that expect a response via a future instead of a message

Example

use kompact::prelude::*;
use std::time::Duration;

#[derive(ComponentDefinition)]
struct AskComponent {
    ctx: ComponentContext<Self>
}



impl Actor for AskComponent {
    type Message = Ask<u64, String>;

    fn receive_local(&mut self, msg: Self::Message) -> HandlerResult {
        msg.complete(|num| {
            format!("{}", num)
        })
        .expect("completion");
        Handled::OK
    }

}

let system = KompactConfig::default().build().wait().expect("system");
let c = system.create(AskComponent::new);
let actor_ref = c.actor_ref();

let start_f = system.start_notify(&c);
start_f
    .wait_timeout(Duration::from_millis(1000))
    .expect("component start");

let response_f = actor_ref.ask_with(Ask::of(42u64));
let response = response_f
    .wait_timeout(Duration::from_millis(1000))
    .expect("response");
assert_eq!("42".to_string(), response);

pub fn recipient<T>(&self) -> Recipient<T>

where T: Into<M> + Debug + 'static,

Returns a version of this actor ref that can only be used to send T, which is then auto-wrapped into M

Use this expose a narrower interface to another actor.

Note

The indirection provided by Recipient has some performance impact. Use benchmarking to establish whether or not the better encapsulation is worth the performance loss in your scenario.

pub fn recipient_with<T>(&self, convert: fn(T) -> M) -> Recipient<T>

where T: Debug + 'static,

Returns a version of this actor ref that can only be used to send T, which is then auto-wrapped into M using convert

Use this expose a narrower interface to another actor.

Note

The indirection provided by Recipient has some performance impact. Use benchmarking to establish whether or not the better encapsulation is worth the performance loss in your scenario.

impl<Request, Response> ActorRef<Ask<Request, Response>>

where Request: MessageBounds, Response: Send + Debug + 'static,

pub fn ask(&self, request: Request) -> KFuture<Response>

Helper to create messages that expect a response via a future instead of a message

Example

use kompact::prelude::*;
use std::time::Duration;

#[derive(ComponentDefinition)]
struct AskComponent {
    ctx: ComponentContext<Self>
}



impl Actor for AskComponent {
    type Message = Ask<u64, String>;

    fn receive_local(&mut self, msg: Self::Message) -> HandlerResult {
        msg.complete(|num| {
            format!("{}", num)
        })
        .expect("completion");
        Handled::OK
    }

}

let system = KompactConfig::default().build().wait().expect("system");
let c = system.create(AskComponent::new);
let actor_ref = c.actor_ref();

let start_f = system.start_notify(&c);
start_f
    .wait_timeout(Duration::from_millis(1000))
    .expect("component start");

let response_f = actor_ref.ask(42u64);
let response = response_f
    .wait_timeout(Duration::from_millis(1000))
    .expect("response");
assert_eq!("42".to_string(), response);

Trait Implementations

impl<M> ActorRefFactory for ActorRef<M>

where M: MessageBounds,

type Message = M

The type of messages carried by references produced by this factory

fn actor_ref(&self) -> ActorRef<M>

Returns the associated actor reference

impl<M> Clone for ActorRef<M>

where M: MessageBounds,

fn clone(&self) -> ActorRef<M>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<M> Debug for ActorRef<M>

where M: MessageBounds,

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

Formats the value using the given formatter.

impl<M> Display for ActorRef<M>

where M: MessageBounds,

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

Formats the value using the given formatter.

impl<M> DynActorRefFactory for ActorRef<M>

where M: MessageBounds,

Available on crate feature distributed only.

fn dyn_ref(&self) -> DynActorRef

Returns a version of an actor ref that can only be used for network messages, but not for typed messages.

impl<M> PartialEq for ActorRef<M>

where M: MessageBounds,

fn eq(&self, other: &ActorRef<M>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.