Struct TestLoopSender 

pub struct TestLoopSender<A>
where
    A: 'static,
{ /* private fields */ }

TestLoopSender implements the CanSend methods for an actor that can Handle them. This is similar to our pattern of having an ActixWrapper around an actor to send messages to it.

let actor = TestActor::new();
let adapter = LateBoundSender::new();

let sender: TestLoopSender<TestActor> = data.register_actor(actor, Some(adapter));

// We can now send messages to the actor using the sender and adapter.
sender.send(TestMessage {});
adapter.send(TestMessage {});

For the purposes of testloop, we keep a copy of the delay sender that is used to schedule callbacks on the testloop to execute either the actor.handle() function or the DelayedActionRunner.run_later_boxed() function.

Implementations

impl<A> TestLoopSender<A>

where A: Actor + 'static,

pub fn with_delay(self, delay: Duration) -> Self

Returns a new TestLoopSender which sends messages with the given delay.

pub fn actor_handle(&self) -> TestLoopDataHandle<A>

Trait Implementations

impl<M, A> CanSend<M> for TestLoopSender<A>

where M: Message + Debug + Send + 'static, A: Actor + HandlerWithContext<M> + 'static, M::Result: Send,

fn send(&self, msg: M)

impl<M, R, A> CanSend<MessageWithCallback<M, R>> for TestLoopSender<A>

where M: Message<Result = R> + Debug + Send + 'static, A: Actor + HandlerWithContext<M> + 'static, R: 'static + Send,

fn send(&self, msg: MessageWithCallback<M, R>)

impl<A> Clone for TestLoopSender<A>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A> DelayedActionRunner<A> for TestLoopSender<A>

where A: 'static,

DelayedActionRunner that schedules the action to be run later by the TestLoop event loop.

fn run_later_boxed( &mut self, name: &str, dur: Duration, f: Box<dyn FnOnce(&mut A, &mut dyn DelayedActionRunner<A>) + Send + 'static>, )