Trait async_transmit::Transmit

pub trait Transmit {
    type Item;
    type Error;
    fn transmit<'life0, 'async_trait>(
        &'life0 mut self, 
        item: Self::Item
    ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>
    where
        Self::Item: 'async_trait,
        'life0: 'async_trait,
        Self: 'async_trait;
}

The Transmit trait allows for transmitting item to a peer.

Implementors of the Transmit trait are called ‘transmitters’.

Transmitters are defined by one required method, [transmit()]. The method will attempt to transmit some data to a peer asynchronously, returning if the transmission has succeeded.

Associated Types

type Item

type Error

Required methods

fn transmit<'life0, 'async_trait>(
    &'life0 mut self,
    item: Self::Item
) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>> where
    Self::Item: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

Attempts to transmit a value to the peer asynchronously.

Implementations on Foreign Types

impl<'impl0, T> Transmit for &'impl0 mut T where
    T: Transmit + Send + ?Sized,
    T::Item: Send, 

type Item = T::Item

type Error = T::Error

fn transmit<'life0, 'async_trait>(
    &'life0 mut self,
    item: Self::Item
) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>> where
    Self::Item: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<I> Transmit for Sender<I> where
    I: Send, 

type Item = I

type Error = SendError<I>

fn transmit<'life0, 'async_trait>(
    &'life0 mut self,
    item: Self::Item
) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<I> Transmit for Sender<I> where
    I: Send, 

type Item = I

type Error = SendError<I>

fn transmit<'life0, 'async_trait>(
    &'life0 mut self,
    item: Self::Item
) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<I> Transmit for UnboundedSender<I> where
    I: Send, 

type Item = I

type Error = SendError<I>

fn transmit<'life0, 'async_trait>(
    &'life0 mut self,
    item: Self::Item
) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Implementors

impl<S, I> Transmit for FromSink<S, I> where
    I: Send,
    S: Sink<I> + Unpin + Send,
    S::Error: Send, 

type Item = I

type Error = S::Error

impl<T, F, E> Transmit for TransmitMapErr<T, F> where
    T: Transmit + Send,
    T::Item: Send,
    F: FnOnce(T::Error) -> E + Send, 

type Item = T::Item

type Error = E

impl<T, F, I, U, E> Transmit for With<T, F, I, U, E> where
    T: Transmit<Item = I, Error = E> + Send,
    F: FnMut(U) -> I + Send,
    I: Send,
    U: Send,
    E: Send, 

type Item = U

type Error = E