Struct near_async::test_loop::delay_sender::DelaySender

pub struct DelaySender<Event>(/* private fields */);

Interface to send an event with a delay (in virtual time). It can be converted to a Sender for any message type that can be converted into the event type, so that a DelaySender given by the test loop may be passed to production code that expects a Sender.

Implementations

impl<Event> DelaySender<Event>

pub fn new(inner: impl Fn(Event, Duration) + Send + Sync + 'static) -> Self

pub fn send_with_delay(&self, event: Event, delay: Duration)

pub fn with_additional_delay(&self, delay: Duration) -> DelaySender<Event>

where Event: 'static,

pub fn narrow<InnerEvent>(self) -> DelaySender<InnerEvent>

where Event: From<InnerEvent> + 'static,

pub fn into_wrapped_multi_sender<M: 'static, S: 'static>(self) -> S

where Self: IntoSender<M>, BreakApart<M>: IntoMultiSender<S>,

A shortcut for a common use case, where we use an enum message to represent all the possible messages that a multisender may be used to send.

This assumes that S is a multisender with the derive #[derive(MultiSendMessage, ...)], which creates the enum MyMultiSenderMessage (where MyMultiSender is the name of the struct being derived from).

To use, first include in the test loop event enum a case for MyMultiSenderMessage. Then, call this function to get a multisender, like builder.wrapped_multi_sender<MyMultiSenderMessage, MyMultiSender>().

pub fn into_delayed_action_runner<InnerData>( self, shutting_down: Arc<AtomicBool>, ) -> TestLoopDelayedActionRunner<InnerData>

where Event: From<TestLoopDelayedActionEvent<InnerData>> + 'static,

pub fn into_future_spawner(self) -> TestLoopFutureSpawner

where Event: From<Arc<TestLoopTask>> + 'static,

Returns a FutureSpawner that can be used to spawn futures into the loop.

pub fn into_async_computation_spawner( self, artificial_delay: impl Fn(&str) -> Duration + Send + Sync + 'static, ) -> TestLoopAsyncComputationSpawner

where Event: From<TestLoopAsyncComputationEvent> + 'static,

Returns an AsyncComputationSpawner that can be used to spawn async computation into the loop. The artificial_delay allows the test to determine an artificial delay that the computation should take, based on the name of the computation.

impl<Event: 'static> DelaySender<(usize, Event)>

pub fn for_index(self, index: usize) -> DelaySender<Event>

Converts a multi-instance sender to a single-instance sender.

Trait Implementations

impl<Data: 'static, Event: From<AdhocEvent<Data>> + 'static> AdhocEventSender<Data> for DelaySender<Event>

fn send_adhoc_event( &self, description: &str, f: impl FnOnce(&mut Data) + Send + 'static, )

fn schedule_adhoc_event( &self, description: &str, f: impl FnOnce(&mut Data) + Send + 'static, delay: Duration, )

impl<Message, Event: From<Message> + 'static> CanSend<Message> for DelaySender<Event>

fn send(&self, message: Message)

impl<Event> Clone for DelaySender<Event>

Custom implementation because #derive wouldn’t work if Event does not Clone.

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.