Struct arti_testing::rt::count::Counting

pub(crate) struct Counting<R> {
    inner: R,
    count: Arc<Mutex<TcpCount>>,
}

A “Counting” wrapper around various objects, keeping running counts of TCP events.

This can wrap most Tcp-related Runtime types.

Fields

inner: R

The inner object that we’re instrumenting

count: Arc<Mutex<TcpCount>>

A shared mutable set of counts.

Implementations

impl<R> Counting<R>

pub(crate) fn project<'pin>( self: Pin<&'pin mut Self> ) -> __CountingProjection<'pin, R>

pub(crate) fn project_ref<'pin>( self: Pin<&'pin Self> ) -> __CountingProjectionRef<'pin, R>

impl<R> Counting<R>

pub(crate) fn new_zeroed(inner: R) -> Self

where R: TcpProvider,

Return a new wrapper around a TcpProvider with a new set of statistics

pub(crate) fn counts(&self) -> TcpCount

Return a copy of our current statistics

Trait Implementations

impl<S: AsyncRead> AsyncRead for Counting<S>

fn poll_read( self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &mut [u8] ) -> Poll<IoResult<usize>>

Attempt to read from the AsyncRead into buf.

fn poll_read_vectored( self: Pin<&mut Self>, cx: &mut Context<'_>, bufs: &mut [IoSliceMut<'_>] ) -> Poll<Result<usize, Error>>

Attempt to read from the AsyncRead into bufs using vectored IO operations.

impl<S: AsyncWrite> AsyncWrite for Counting<S>

fn poll_write( self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &[u8] ) -> Poll<IoResult<usize>>

Attempt to write bytes from buf into the object.

fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<IoResult<()>>

Attempt to flush the object, ensuring that any buffered data reach their destination.

fn poll_close(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<IoResult<()>>

Attempt to close the object.

fn poll_write_vectored( self: Pin<&mut Self>, cx: &mut Context<'_>, bufs: &[IoSlice<'_>] ) -> Poll<Result<usize, Error>>

Attempt to write bytes from bufs into the object using vectored IO operations.

impl<R> Clone for Counting<R>

where R: Clone,

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S, T> Stream for Counting<S>

where S: Stream<Item = Result<(T, SocketAddr)>>,

type Item = Result<(Counting<T>, SocketAddr), Error>

Values yielded by the stream.

fn poll_next( self: Pin<&mut Self>, cx: &mut Context<'_> ) -> Poll<Option<Self::Item>>

Attempt to pull out the next value of this stream, registering the current task for wakeup if the value is not yet available, and returning None if the stream is exhausted.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the stream.

impl<S: TcpListener + Send + Sync> TcpListener for Counting<S>

type TcpStream = Counting<<S as TcpListener>::TcpStream>

The type of TCP connections returned by Self::accept().

type Incoming = Counting<<S as TcpListener>::Incoming>

The type of [stream::Stream] returned by Self::incoming().

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

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

Wait for an incoming stream; return it along with its address.

fn incoming(self) -> Self::Incoming

Wrap this listener into a new [stream::Stream] that yields TCP streams and addresses.

fn local_addr(&self) -> IoResult<SocketAddr>

Return the local address that this listener is bound to.

impl<R: TcpProvider + Send + Sync> TcpProvider for Counting<R>

type TcpStream = Counting<<R as TcpProvider>::TcpStream>

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

type TcpListener = Counting<<R as TcpProvider>::TcpListener>

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

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

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

Launch a TCP connection to a given socket address.

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

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

Open a TCP listener on a given socket address.

impl<'pin, R> Unpin for Counting<R>

where __Counting<'pin, R>: Unpin,