Struct kompact::prelude::ActorRefStrong

pub struct ActorRefStrong<M: MessageBounds> { /* fields omitted */ }

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.

Methods

impl<M: MessageBounds> ActorRefStrong<M>

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<R, F>(&self, f: F) -> Future<R> where
    R: Send + Sized,
    F: FnOnce(Promise<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) -> () {
        msg.complete(|num| {
            format!("{}", num)
        })
        .expect("completion");
    }

}

let system = KompactConfig::default().build().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(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

Trait Implementations

impl<M: MessageBounds> ActorRefFactory for ActorRefStrong<M>

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: MessageBounds> Clone for ActorRefStrong<M>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<M: MessageBounds> Debug for ActorRefStrong<M>

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

Formats the value using the given formatter.

impl<M: MessageBounds> Display for ActorRefStrong<M>

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

Formats the value using the given formatter.

impl<M: MessageBounds> PartialEq<ActorRefStrong<M>> for ActorRefStrong<M>

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl Sink for ActorRefStrong<DispatchEnvelope>

Helper for forwarding MsgEnvelopes to actor references

type SinkError = ()

The type of value produced by the sink when an error occurs.

type SinkItem = DispatchEnvelope

The type of value that the sink accepts.

fn start_send(
    &mut self,
    item: Self::SinkItem
) -> StartSend<Self::SinkItem, Self::SinkError>

Begin the process of sending a value to the sink.

fn poll_complete(&mut self) -> Poll<(), Self::SinkError>

Flush all output from this sink, if necessary.

fn close(&mut self) -> Poll<(), Self::SinkError>

A method to indicate that no more values will ever be pushed into this sink.

fn wait(self) -> Wait<Self>

Creates a new object which will produce a synchronous sink.

fn with<U, F, Fut>(self, f: F) -> With<Self, U, F, Fut> where
    F: FnMut(U) -> Fut,
    Fut: IntoFuture<Item = Self::SinkItem>,
    <Fut as IntoFuture>::Error: From<Self::SinkError>, 

Composes a function in front of the sink.

fn with_flat_map<U, F, St>(self, f: F) -> WithFlatMap<Self, U, F, St> where
    F: FnMut(U) -> St,
    St: Stream<Item = Self::SinkItem, Error = Self::SinkError>, 

Composes a function in front of the sink.

fn sink_map_err<F, E>(self, f: F) -> SinkMapErr<Self, F> where
    F: FnOnce(Self::SinkError) -> E, 

Transforms the error returned by the sink.

fn sink_from_err<E>(self) -> SinkFromErr<Self, E> where
    E: From<Self::SinkError>, 

Map this sink's error to any error implementing From for this sink's Error, returning a new sink.

fn buffer(self, amt: usize) -> Buffer<Self>

Adds a fixed-size buffer to the current sink.

fn fanout<S>(self, other: S) -> Fanout<Self, S> where
    S: Sink<SinkItem = Self::SinkItem, SinkError = Self::SinkError>,
    Self::SinkItem: Clone, 

Fanout items to multiple sinks.

fn flush(self) -> Flush<Self>

A future that completes when the sink has finished processing all pending requests.

fn send(self, item: Self::SinkItem) -> Send<Self>

A future that completes after the given item has been fully processed into the sink, including flushing.

fn send_all<S>(self, stream: S) -> SendAll<Self, S> where
    S: Stream<Item = Self::SinkItem>,
    Self::SinkError: From<<S as Stream>::Error>, 

A future that completes after the given stream has been fully processed into the sink, including flushing.