Struct CompoundRuntime 

pub struct CompoundRuntime<TaskR, SleepR, CoarseTimeR, TcpR, UnixR, TlsR, UdpR> { /* private fields */ }

A runtime made of several parts, each of which implements one trait-group.

The TaskR component should implement Spawn, Blocking and maybe ToplevelBlockOn; the SleepR component should implement SleepProvider; the CoarseTimeR component should implement CoarseTimeProvider; the TcpR component should implement NetStreamProvider for net::SocketAddr; the UnixR component should implement NetStreamProvider for unix::SocketAddr; and the TlsR component should implement TlsProvider.

You can use this structure to create new runtimes in two ways: either by overriding a single part of an existing runtime, or by building an entirely new runtime from pieces.

Implementations

impl<TaskR, SleepR, CoarseTimeR, TcpR, UnixR, TlsR, UdpR> CompoundRuntime<TaskR, SleepR, CoarseTimeR, TcpR, UnixR, TlsR, UdpR>

pub fn new( spawn: TaskR, sleep: SleepR, coarse_time: CoarseTimeR, tcp: TcpR, unix: UnixR, tls: TlsR, udp: UdpR, ) -> Self

Construct a new CompoundRuntime from its components.

Trait Implementations

impl<TaskR, SleepR, CoarseTimeR, TcpR, UnixR, TlsR, UdpR> Blocking for CompoundRuntime<TaskR, SleepR, CoarseTimeR, TcpR, UnixR, TlsR, UdpR>

where TaskR: Blocking, SleepR: Clone + Send + Sync + 'static, CoarseTimeR: Clone + Send + Sync + 'static, TcpR: Clone + Send + Sync + 'static, UnixR: Clone + Send + Sync + 'static, TlsR: Clone + Send + Sync + 'static, UdpR: Clone + Send + Sync + 'static,

type ThreadHandle<T: Send + 'static> = <TaskR as Blocking>::ThreadHandle<T>

Future from spawn_blocking

fn spawn_blocking<F, T>(&self, f: F) -> TaskR::ThreadHandle<T>

where F: FnOnce() -> T + Send + 'static, T: Send + 'static,

Spawn a thread for blocking IO or CPU-bound work.

fn reenter_block_on<F>(&self, future: F) -> F::Output

where F: Future, F::Output: Send + 'static,

Block on a future, from within Blocking::spawn_blocking

fn blocking_io<F, T>(&self, f: F) -> impl Future<Output = T>

where F: FnOnce() -> T + Send + 'static, T: Send + 'static,

Perform some blocking IO from an async future

impl<TaskR, SleepR, CoarseTimeR, TcpR, UnixR, TlsR, UdpR> Clone for CompoundRuntime<TaskR, SleepR, CoarseTimeR, TcpR, UnixR, TlsR, UdpR>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<TaskR, SleepR, CoarseTimeR, TcpR, UnixR, TlsR, UdpR> CoarseTimeProvider for CompoundRuntime<TaskR, SleepR, CoarseTimeR, TcpR, UnixR, TlsR, UdpR>

where CoarseTimeR: CoarseTimeProvider + Clone + Send + Sync + 'static, SleepR: Clone + Send + Sync + 'static, TaskR: Clone + Send + Sync + 'static, TcpR: Clone + Send + Sync + 'static, UnixR: Clone + Send + Sync + 'static, TlsR: Clone + Send + Sync + 'static, UdpR: Clone + Send + Sync + 'static,

fn now_coarse(&self) -> CoarseInstant

Return the CoarseTimeProvider’s view of the current instant.

impl<TaskR, SleepR, CoarseTimeR, TcpR, UnixR, TlsR, UdpR> Debug for CompoundRuntime<TaskR, SleepR, CoarseTimeR, TcpR, UnixR, TlsR, UdpR>

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

Formats the value using the given formatter.

impl<TaskR, SleepR, CoarseTimeR, TcpR, UnixR, TlsR, UdpR> NetStreamProvider<SocketAddr> for CompoundRuntime<TaskR, SleepR, CoarseTimeR, TcpR, UnixR, TlsR, UdpR>

where UnixR: NetStreamProvider<SocketAddr> + Clone + Send + Sync + 'static, TaskR: Send + Sync + 'static, SleepR: Send + Sync + 'static, CoarseTimeR: Send + Sync + 'static, TcpR: Send + Sync + 'static, TlsR: Send + Sync + 'static, UdpR: Send + Sync + 'static,

type Stream = <UnixR as NetStreamProvider<SocketAddr>>::Stream

The type for the connections returned by Self::connect().

type Listener = <UnixR as NetStreamProvider<SocketAddr>>::Listener

The type for the listeners returned by Self::listen().

fn connect<'life0, 'life1, 'async_trait>( &'life0 self, addr: &'life1 SocketAddr, ) -> Pin<Box<dyn Future<Output = IoResult<Self::Stream>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Launch a connection connection to a given socket address.

fn listen<'life0, 'life1, 'async_trait>( &'life0 self, addr: &'life1 SocketAddr, ) -> Pin<Box<dyn Future<Output = IoResult<Self::Listener>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Open a listener on a given socket address.

impl<TaskR, SleepR, CoarseTimeR, TcpR, UnixR, TlsR, UdpR> NetStreamProvider for CompoundRuntime<TaskR, SleepR, CoarseTimeR, TcpR, UnixR, TlsR, UdpR>

where TcpR: NetStreamProvider<SocketAddr> + Send + Sync + 'static, TaskR: Send + Sync + 'static, SleepR: Send + Sync + 'static, CoarseTimeR: Send + Sync + 'static, UnixR: Clone + Send + Sync + 'static, TlsR: Send + Sync + 'static, UdpR: Send + Sync + 'static,

type Stream = <TcpR as NetStreamProvider>::Stream

The type for the connections returned by Self::connect().

type Listener = <TcpR as NetStreamProvider>::Listener

The type for the listeners returned by Self::listen().

fn connect<'life0, 'life1, 'async_trait>( &'life0 self, addr: &'life1 SocketAddr, ) -> Pin<Box<dyn Future<Output = IoResult<Self::Stream>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Launch a connection connection to a given socket address.

fn listen<'life0, 'life1, 'async_trait>( &'life0 self, addr: &'life1 SocketAddr, ) -> Pin<Box<dyn Future<Output = IoResult<Self::Listener>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Open a listener on a given socket address.

impl<TaskR, SleepR, CoarseTimeR, TcpR, UnixR, TlsR, UdpR> SleepProvider for CompoundRuntime<TaskR, SleepR, CoarseTimeR, TcpR, UnixR, TlsR, UdpR>

where SleepR: SleepProvider, TaskR: Clone + Send + Sync + 'static, CoarseTimeR: Clone + Send + Sync + 'static, TcpR: Clone + Send + Sync + 'static, UnixR: Clone + Send + Sync + 'static, TlsR: Clone + Send + Sync + 'static, UdpR: Clone + Send + Sync + 'static,

type SleepFuture = <SleepR as SleepProvider>::SleepFuture

A future returned by SleepProvider::sleep()

fn sleep(&self, duration: Duration) -> Self::SleepFuture

Return a future that will be ready after duration has elapsed.

fn now(&self) -> Instant

Return the SleepProvider’s view of the current instant.

fn wallclock(&self) -> SystemTime

Return the SleepProvider’s view of the current wall-clock time.

fn block_advance<T: Into<String>>(&self, _reason: T)

Signify that a test running under mock time shouldn’t advance time yet, with a given unique reason string. This is useful for making sure (mock) time doesn’t advance while things that might require some (real-world) time to complete do so, such as spawning a task on another thread.

fn release_advance<T: Into<String>>(&self, _reason: T)

Signify that the reason to withhold time advancing provided in a call to block_advance no longer exists, and it’s fine to move time forward if nothing else is blocking advances.

fn allow_one_advance(&self, _dur: Duration)

Allow a test running under mock time to advance time by the provided duration, even if the above block_advance API has been used.

impl<TaskR, SleepR, CoarseTimeR, TcpR, UnixR, TlsR, UdpR> Spawn for CompoundRuntime<TaskR, SleepR, CoarseTimeR, TcpR, UnixR, TlsR, UdpR>

where TaskR: Spawn,

fn spawn_obj(&self, future: FutureObj<'static, ()>) -> Result<(), SpawnError>

Spawns a future that will be run to completion.

fn status(&self) -> Result<(), SpawnError>

Determines whether the executor is able to spawn new tasks.

impl<TaskR, SleepR, CoarseTimeR, TcpR, UnixR, TlsR, UdpR, S> TlsProvider<S> for CompoundRuntime<TaskR, SleepR, CoarseTimeR, TcpR, UnixR, TlsR, UdpR>

where TcpR: NetStreamProvider, TlsR: TlsProvider<S>, UnixR: Clone + Send + Sync + 'static, SleepR: Clone + Send + Sync + 'static, CoarseTimeR: Clone + Send + Sync + 'static, TaskR: Clone + Send + Sync + 'static, UdpR: Clone + Send + Sync + 'static, S: StreamOps,

type Connector = <TlsR as TlsProvider<S>>::Connector

The Connector object that this provider can return.

type TlsStream = <TlsR as TlsProvider<S>>::TlsStream

The type of the stream returned by that connector.

fn tls_connector(&self) -> Self::Connector

Return a TLS connector for use with this runtime.

fn supports_keying_material_export(&self) -> bool

Return true iff the keying material exporters (RFC 5705) is supported.

impl<TaskR, SleepR, CoarseTimeR, TcpR, UnixR, TlsR, UdpR> ToplevelBlockOn for CompoundRuntime<TaskR, SleepR, CoarseTimeR, TcpR, UnixR, TlsR, UdpR>

where TaskR: ToplevelBlockOn, SleepR: Clone + Send + Sync + 'static, CoarseTimeR: Clone + Send + Sync + 'static, TcpR: Clone + Send + Sync + 'static, UnixR: Clone + Send + Sync + 'static, TlsR: Clone + Send + Sync + 'static, UdpR: Clone + Send + Sync + 'static,

fn block_on<F: Future>(&self, future: F) -> F::Output

Run future until it is ready, and return its output.

impl<TaskR, SleepR, CoarseTimeR, TcpR, UnixR, TlsR, UdpR> UdpProvider for CompoundRuntime<TaskR, SleepR, CoarseTimeR, TcpR, UnixR, TlsR, UdpR>

where UdpR: UdpProvider + Send + Sync + 'static, TaskR: Send + Sync + 'static, SleepR: Send + Sync + 'static, CoarseTimeR: Send + Sync + 'static, TcpR: Send + Sync + 'static, UnixR: Clone + Send + Sync + 'static, TlsR: Send + Sync + 'static,

type UdpSocket = <UdpR as UdpProvider>::UdpSocket

The type of Udp Socket returned by Self::bind()

fn bind<'life0, 'life1, 'async_trait>( &'life0 self, addr: &'life1 SocketAddr, ) -> Pin<Box<dyn Future<Output = IoResult<Self::UdpSocket>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Bind a local port to send and receive packets from

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 8 bytes