Trait NetStreamProvider 

pub trait NetStreamProvider<ADDR = SocketAddr>:
    Clone
    + Send
    + Sync
    + 'static {
    type Stream: AsyncRead + AsyncWrite + StreamOps + Send + Sync + Unpin + 'static;
    type Listener: NetStreamListener<ADDR, Stream = Self::Stream> + Send + Sync + Unpin + 'static;

    // Required methods
    fn connect<'life0, 'life1, 'async_trait>(
        &'life0 self,
        addr: &'life1 ADDR,
    ) -> Pin<Box<dyn Future<Output = IoResult<Self::Stream>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn listen<'life0, 'life1, 'async_trait>(
        &'life0 self,
        addr: &'life1 ADDR,
    ) -> Pin<Box<dyn Future<Output = IoResult<Self::Listener>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
}

Trait for a runtime that can create and accept connections over network sockets.

(In Arti we use the AsyncRead and AsyncWrite traits from futures::io as more standard, even though the ones from Tokio can be a bit more efficient. Let’s hope that they converge in the future.)

Required Associated Types

type Stream: AsyncRead + AsyncWrite + StreamOps + Send + Sync + Unpin + 'static

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

type Listener: NetStreamListener<ADDR, Stream = Self::Stream> + Send + Sync + Unpin + 'static

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

Required Methods

fn connect<'life0, 'life1, 'async_trait>( &'life0 self, addr: &'life1 ADDR, ) -> 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.

Note that unlike std::net:TcpStream::connect, we do not accept any types other than a single ADDR. We do this because we must be absolutely sure not to perform unnecessary DNS lookups.

fn listen<'life0, 'life1, 'async_trait>( &'life0 self, addr: &'life1 ADDR, ) -> 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.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl NetStreamProvider for PreferredRuntime

type Stream = <TokioNativeTlsRuntime as NetStreamProvider>::Stream

type Listener = <TokioNativeTlsRuntime as NetStreamProvider>::Listener

impl NetStreamProvider for TokioNativeTlsRuntime

Available on (crate features native-tls or rustls) and crate feature tokio only.

type Stream = <CompoundRuntime<TokioRuntimeHandle, TokioRuntimeHandle, RealCoarseTimeProvider, TokioRuntimeHandle, TokioRuntimeHandle, NativeTlsProvider, TokioRuntimeHandle> as NetStreamProvider>::Stream

type Listener = <CompoundRuntime<TokioRuntimeHandle, TokioRuntimeHandle, RealCoarseTimeProvider, TokioRuntimeHandle, TokioRuntimeHandle, NativeTlsProvider, TokioRuntimeHandle> as NetStreamProvider>::Listener

impl NetStreamProvider<SocketAddr> for PreferredRuntime

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

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

impl NetStreamProvider<SocketAddr> for TokioNativeTlsRuntime

Available on (crate features native-tls or rustls) and crate feature tokio only.

type Stream = <CompoundRuntime<TokioRuntimeHandle, TokioRuntimeHandle, RealCoarseTimeProvider, TokioRuntimeHandle, TokioRuntimeHandle, NativeTlsProvider, TokioRuntimeHandle> as NetStreamProvider<SocketAddr>>::Stream

type Listener = <CompoundRuntime<TokioRuntimeHandle, TokioRuntimeHandle, RealCoarseTimeProvider, TokioRuntimeHandle, TokioRuntimeHandle, NativeTlsProvider, TokioRuntimeHandle> as NetStreamProvider<SocketAddr>>::Listener

impl<T> NetStreamProvider<SocketAddr> for T

where T: NetStreamProvider<SocketAddr> + NetStreamProvider<SocketAddr>,

type Stream = Stream

type Listener = Listener

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

type Listener = <TcpR as NetStreamProvider>::Listener

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

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