Struct ActorRefStrong 

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

A version of ActorRef that prevents the target from being deallocated

Holding this kind of reference increases performance slightly, compared to the normal ActorRef. However, one must be careful not to leave strong references lying around when not needed anymore, as they prevent the target component from being deallocated, potentially causing memory creep.

Should be created via hold.

It is recommended to upgrade a normal actor reference to this variant, if many messages will be sent in a loop to it. After the loop, the strong reference can be dropped again.

Implementations

impl<M> ActorRefStrong<M>

where M: MessageBounds,

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 strong_ref = c.actor_ref().hold().expect("live ref");

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

let response_f = strong_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 weak_ref(&self) -> ActorRef<M>

Downgrade this strong reference to a “normal” actor reference

impl<Request, Response> ActorRefStrong<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 strong_ref = c.actor_ref().hold().expect("live ref");

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

let response_f = strong_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 ActorRefStrong<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 ActorRefStrong<M>

where M: MessageBounds,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<M> Debug for ActorRefStrong<M>

where M: MessageBounds,

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

Formats the value using the given formatter.

impl<M> Display for ActorRefStrong<M>

where M: MessageBounds,

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

Formats the value using the given formatter.

impl<M> DynActorRefFactory for ActorRefStrong<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 ActorRefStrong<M>

where M: MessageBounds,

fn eq(&self, other: &ActorRefStrong<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.