Trait kvarn::websocket::Sink

pub trait Sink<Item> {
    type Error;

    // Required methods
    fn poll_ready(
        self: Pin<&mut Self>,
        cx: &mut Context<'_>
    ) -> Poll<Result<(), Self::Error>>;
    fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>;
    fn poll_flush(
        self: Pin<&mut Self>,
        cx: &mut Context<'_>
    ) -> Poll<Result<(), Self::Error>>;
    fn poll_close(
        self: Pin<&mut Self>,
        cx: &mut Context<'_>
    ) -> Poll<Result<(), Self::Error>>;
}

Available on crate feature websocket only.

A Sink is a value into which other values can be sent, asynchronously.

Basic examples of sinks include the sending side of:

• Channels
• Sockets
• Pipes

In addition to such “primitive” sinks, it’s typical to layer additional functionality, such as buffering, on top of an existing sink.

Sending to a sink is “asynchronous” in the sense that the value may not be sent in its entirety immediately. Instead, values are sent in a two-phase way: first by initiating a send, and then by polling for completion. This two-phase setup is analogous to buffered writing in synchronous code, where writes often succeed immediately, but internally are buffered and are actually written only upon flushing.

In addition, the Sink may be full, in which case it is not even possible to start the sending process.

As with Future and Stream, the Sink trait is built from a few core required methods, and a host of default methods for working in a higher-level way. The Sink::send_all combinator is of particular importance: you can use it to send an entire stream to a sink, which is the simplest way to ultimately consume a stream.

Required Associated Types

type Error

The type of value produced by the sink when an error occurs.

Required Methods

fn poll_ready( self: Pin<&mut Self>, cx: &mut Context<'_> ) -> Poll<Result<(), Self::Error>>

Attempts to prepare the Sink to receive a value.

This method must be called and return Poll::Ready(Ok(())) prior to each call to start_send.

This method returns Poll::Ready once the underlying sink is ready to receive data. If this method returns Poll::Pending, the current task is registered to be notified (via cx.waker().wake_by_ref()) when poll_ready should be called again.

In most cases, if the sink encounters an error, the sink will permanently be unable to receive items.

fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error>

Begin the process of sending a value to the sink. Each call to this function must be preceded by a successful call to poll_ready which returned Poll::Ready(Ok(())).

As the name suggests, this method only begins the process of sending the item. If the sink employs buffering, the item isn’t fully processed until the buffer is fully flushed. Since sinks are designed to work with asynchronous I/O, the process of actually writing out the data to an underlying object takes place asynchronously. You must use poll_flush or poll_close in order to guarantee completion of a send.

Implementations of poll_ready and start_send will usually involve flushing behind the scenes in order to make room for new messages. It is only necessary to call poll_flush if you need to guarantee that all of the items placed into the Sink have been sent.

In most cases, if the sink encounters an error, the sink will permanently be unable to receive items.

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

Flush any remaining output from this sink.

Returns Poll::Ready(Ok(())) when no buffered items remain. If this value is returned then it is guaranteed that all previous values sent via start_send have been flushed.

Returns Poll::Pending if there is more work left to do, in which case the current task is scheduled (via cx.waker().wake_by_ref()) to wake up when poll_flush should be called again.

In most cases, if the sink encounters an error, the sink will permanently be unable to receive items.

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

Flush any remaining output and close this sink, if necessary.

Returns Poll::Ready(Ok(())) when no buffered items remain and the sink has been successfully closed.

Returns Poll::Pending if there is more work left to do, in which case the current task is scheduled (via cx.waker().wake_by_ref()) to wake up when poll_close should be called again.

If this function encounters an error, the sink should be considered to have failed permanently, and no more Sink methods should be called.

Implementations on Foreign Types

impl<S, Item> Sink<Item> for Skip<S>where S: Stream + Sink<Item>,

Available on crate feature sink only.

type Error = <S as Sink<Item>>::Error

fn poll_ready( self: Pin<&mut Skip<S>>, cx: &mut Context<'_> ) -> Poll<Result<(), <Skip<S> as Sink<Item>>::Error>>

fn start_send( self: Pin<&mut Skip<S>>, item: Item ) -> Result<(), <Skip<S> as Sink<Item>>::Error>

fn poll_flush( self: Pin<&mut Skip<S>>, cx: &mut Context<'_> ) -> Poll<Result<(), <Skip<S> as Sink<Item>>::Error>>

fn poll_close( self: Pin<&mut Skip<S>>, cx: &mut Context<'_> ) -> Poll<Result<(), <Skip<S> as Sink<Item>>::Error>>

impl<_Item, St, U, F> Sink<_Item> for FlatMap<St, U, F>where Flatten<Map<St, F>, U>: Sink<_Item>,

Available on crate feature sink only.

type Error = <Flatten<Map<St, F>, U> as Sink<_Item>>::Error

fn poll_ready( self: Pin<&mut FlatMap<St, U, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <FlatMap<St, U, F> as Sink<_Item>>::Error>>

fn start_send( self: Pin<&mut FlatMap<St, U, F>>, item: _Item ) -> Result<(), <FlatMap<St, U, F> as Sink<_Item>>::Error>

fn poll_flush( self: Pin<&mut FlatMap<St, U, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <FlatMap<St, U, F> as Sink<_Item>>::Error>>

fn poll_close( self: Pin<&mut FlatMap<St, U, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <FlatMap<St, U, F> as Sink<_Item>>::Error>>

impl<_Item, F> Sink<_Item> for FlattenStream<F>where Flatten<F, <F as Future>::Output>: Sink<_Item>, F: Future,

Available on crate feature sink only.

type Error = <Flatten<F, <F as Future>::Output> as Sink<_Item>>::Error

fn poll_ready( self: Pin<&mut FlattenStream<F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <FlattenStream<F> as Sink<_Item>>::Error>>

fn start_send( self: Pin<&mut FlattenStream<F>>, item: _Item ) -> Result<(), <FlattenStream<F> as Sink<_Item>>::Error>

fn poll_flush( self: Pin<&mut FlattenStream<F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <FlattenStream<F> as Sink<_Item>>::Error>>

fn poll_close( self: Pin<&mut FlattenStream<F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <FlattenStream<F> as Sink<_Item>>::Error>>

impl<_Item, St, F> Sink<_Item> for MapOk<St, F>where Map<IntoStream<St>, MapOkFn<F>>: Sink<_Item>,

Available on crate feature sink only.

type Error = <Map<IntoStream<St>, MapOkFn<F>> as Sink<_Item>>::Error

fn poll_ready( self: Pin<&mut MapOk<St, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <MapOk<St, F> as Sink<_Item>>::Error>>

fn start_send( self: Pin<&mut MapOk<St, F>>, item: _Item ) -> Result<(), <MapOk<St, F> as Sink<_Item>>::Error>

fn poll_flush( self: Pin<&mut MapOk<St, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <MapOk<St, F> as Sink<_Item>>::Error>>

fn poll_close( self: Pin<&mut MapOk<St, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <MapOk<St, F> as Sink<_Item>>::Error>>

impl<S, Fut, F, Item> Sink<Item> for FilterMap<S, Fut, F>where S: Stream + Sink<Item>, F: FnMut1<<S as Stream>::Item, Output = Fut>, Fut: Future,

Available on crate feature sink only.

type Error = <S as Sink<Item>>::Error

fn poll_ready( self: Pin<&mut FilterMap<S, Fut, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <FilterMap<S, Fut, F> as Sink<Item>>::Error>>

fn start_send( self: Pin<&mut FilterMap<S, Fut, F>>, item: Item ) -> Result<(), <FilterMap<S, Fut, F> as Sink<Item>>::Error>

fn poll_flush( self: Pin<&mut FilterMap<S, Fut, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <FilterMap<S, Fut, F> as Sink<Item>>::Error>>

fn poll_close( self: Pin<&mut FilterMap<S, Fut, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <FilterMap<S, Fut, F> as Sink<Item>>::Error>>

impl<T> Sink<T> for Drain<T>

type Error = Infallible

fn poll_ready( self: Pin<&mut Drain<T>>, _cx: &mut Context<'_> ) -> Poll<Result<(), <Drain<T> as Sink<T>>::Error>>

fn start_send( self: Pin<&mut Drain<T>>, _item: T ) -> Result<(), <Drain<T> as Sink<T>>::Error>

fn poll_flush( self: Pin<&mut Drain<T>>, _cx: &mut Context<'_> ) -> Poll<Result<(), <Drain<T> as Sink<T>>::Error>>

fn poll_close( self: Pin<&mut Drain<T>>, _cx: &mut Context<'_> ) -> Poll<Result<(), <Drain<T> as Sink<T>>::Error>>

impl<S, Item> Sink<Item> for Take<S>where S: Stream + Sink<Item>,

Available on crate feature sink only.

type Error = <S as Sink<Item>>::Error

fn poll_ready( self: Pin<&mut Take<S>>, cx: &mut Context<'_> ) -> Poll<Result<(), <Take<S> as Sink<Item>>::Error>>

fn start_send( self: Pin<&mut Take<S>>, item: Item ) -> Result<(), <Take<S> as Sink<Item>>::Error>

fn poll_flush( self: Pin<&mut Take<S>>, cx: &mut Context<'_> ) -> Poll<Result<(), <Take<S> as Sink<Item>>::Error>>

fn poll_close( self: Pin<&mut Take<S>>, cx: &mut Context<'_> ) -> Poll<Result<(), <Take<S> as Sink<Item>>::Error>>

impl<Si, Item, U, Fut, F, E> Sink<U> for With<Si, Item, U, Fut, F>where Si: Sink<Item>, F: FnMut(U) -> Fut, Fut: Future<Output = Result<Item, E>>, E: From<<Si as Sink<Item>>::Error>,

type Error = E

fn poll_ready( self: Pin<&mut With<Si, Item, U, Fut, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <With<Si, Item, U, Fut, F> as Sink<U>>::Error>>

fn start_send( self: Pin<&mut With<Si, Item, U, Fut, F>>, item: U ) -> Result<(), <With<Si, Item, U, Fut, F> as Sink<U>>::Error>

fn poll_flush( self: Pin<&mut With<Si, Item, U, Fut, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <With<Si, Item, U, Fut, F> as Sink<U>>::Error>>

fn poll_close( self: Pin<&mut With<Si, Item, U, Fut, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <With<Si, Item, U, Fut, F> as Sink<U>>::Error>>

impl<St, F, Item> Sink<Item> for Map<St, F>where St: Stream + Sink<Item>, F: FnMut1<<St as Stream>::Item>,

Available on crate feature sink only.

type Error = <St as Sink<Item>>::Error

fn poll_ready( self: Pin<&mut Map<St, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <Map<St, F> as Sink<Item>>::Error>>

fn start_send( self: Pin<&mut Map<St, F>>, item: Item ) -> Result<(), <Map<St, F> as Sink<Item>>::Error>

fn poll_flush( self: Pin<&mut Map<St, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <Map<St, F> as Sink<Item>>::Error>>

fn poll_close( self: Pin<&mut Map<St, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <Map<St, F> as Sink<Item>>::Error>>

impl<_Item, St> Sink<_Item> for Flatten<St>where Flatten<St, <St as Stream>::Item>: Sink<_Item>, St: Stream,

Available on crate feature sink only.

type Error = <Flatten<St, <St as Stream>::Item> as Sink<_Item>>::Error

fn poll_ready( self: Pin<&mut Flatten<St>>, cx: &mut Context<'_> ) -> Poll<Result<(), <Flatten<St> as Sink<_Item>>::Error>>

fn start_send( self: Pin<&mut Flatten<St>>, item: _Item ) -> Result<(), <Flatten<St> as Sink<_Item>>::Error>

fn poll_flush( self: Pin<&mut Flatten<St>>, cx: &mut Context<'_> ) -> Poll<Result<(), <Flatten<St> as Sink<_Item>>::Error>>

fn poll_close( self: Pin<&mut Flatten<St>>, cx: &mut Context<'_> ) -> Poll<Result<(), <Flatten<St> as Sink<_Item>>::Error>>

impl<S, Item, E> Sink<Item> for TryBuffered<S>where S: TryStream + Sink<Item, Error = E>, <S as TryStream>::Ok: TryFuture<Error = E>,

Available on crate feature sink only.

type Error = E

fn poll_ready( self: Pin<&mut TryBuffered<S>>, cx: &mut Context<'_> ) -> Poll<Result<(), <TryBuffered<S> as Sink<Item>>::Error>>

fn start_send( self: Pin<&mut TryBuffered<S>>, item: Item ) -> Result<(), <TryBuffered<S> as Sink<Item>>::Error>

fn poll_flush( self: Pin<&mut TryBuffered<S>>, cx: &mut Context<'_> ) -> Poll<Result<(), <TryBuffered<S> as Sink<Item>>::Error>>

fn poll_close( self: Pin<&mut TryBuffered<S>>, cx: &mut Context<'_> ) -> Poll<Result<(), <TryBuffered<S> as Sink<Item>>::Error>>

impl<S, Item> Sink<Item> for Chunks<S>where S: Stream + Sink<Item>,

Available on crate feature sink only.

type Error = <S as Sink<Item>>::Error

fn poll_ready( self: Pin<&mut Chunks<S>>, cx: &mut Context<'_> ) -> Poll<Result<(), <Chunks<S> as Sink<Item>>::Error>>

fn start_send( self: Pin<&mut Chunks<S>>, item: Item ) -> Result<(), <Chunks<S> as Sink<Item>>::Error>

fn poll_flush( self: Pin<&mut Chunks<S>>, cx: &mut Context<'_> ) -> Poll<Result<(), <Chunks<S> as Sink<Item>>::Error>>

fn poll_close( self: Pin<&mut Chunks<S>>, cx: &mut Context<'_> ) -> Poll<Result<(), <Chunks<S> as Sink<Item>>::Error>>

impl<A, B, Item> Sink<Item> for Either<A, B>where A: Sink<Item>, B: Sink<Item, Error = <A as Sink<Item>>::Error>,

Available on crate feature sink only.

type Error = <A as Sink<Item>>::Error

fn poll_ready( self: Pin<&mut Either<A, B>>, cx: &mut Context<'_> ) -> Poll<Result<(), <Either<A, B> as Sink<Item>>::Error>>

fn start_send( self: Pin<&mut Either<A, B>>, item: Item ) -> Result<(), <Either<A, B> as Sink<Item>>::Error>

fn poll_flush( self: Pin<&mut Either<A, B>>, cx: &mut Context<'_> ) -> Poll<Result<(), <Either<A, B> as Sink<Item>>::Error>>

fn poll_close( self: Pin<&mut Either<A, B>>, cx: &mut Context<'_> ) -> Poll<Result<(), <Either<A, B> as Sink<Item>>::Error>>

impl<Si, F, E, Item> Sink<Item> for SinkMapErr<Si, F>where Si: Sink<Item>, F: FnOnce(<Si as Sink<Item>>::Error) -> E,

type Error = E

fn poll_ready( self: Pin<&mut SinkMapErr<Si, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <SinkMapErr<Si, F> as Sink<Item>>::Error>>

fn start_send( self: Pin<&mut SinkMapErr<Si, F>>, item: Item ) -> Result<(), <SinkMapErr<Si, F> as Sink<Item>>::Error>

fn poll_flush( self: Pin<&mut SinkMapErr<Si, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <SinkMapErr<Si, F> as Sink<Item>>::Error>>

fn poll_close( self: Pin<&mut SinkMapErr<Si, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <SinkMapErr<Si, F> as Sink<Item>>::Error>>

impl<_Item, St, F> Sink<_Item> for MapErr<St, F>where Map<IntoStream<St>, MapErrFn<F>>: Sink<_Item>,

Available on crate feature sink only.

type Error = <Map<IntoStream<St>, MapErrFn<F>> as Sink<_Item>>::Error

fn poll_ready( self: Pin<&mut MapErr<St, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <MapErr<St, F> as Sink<_Item>>::Error>>

fn start_send( self: Pin<&mut MapErr<St, F>>, item: _Item ) -> Result<(), <MapErr<St, F> as Sink<_Item>>::Error>

fn poll_flush( self: Pin<&mut MapErr<St, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <MapErr<St, F> as Sink<_Item>>::Error>>

fn poll_close( self: Pin<&mut MapErr<St, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <MapErr<St, F> as Sink<_Item>>::Error>>

impl<S, Fut, F, Item> Sink<Item> for OrElse<S, Fut, F>where S: Sink<Item>,

Available on crate feature sink only.

type Error = <S as Sink<Item>>::Error

fn poll_ready( self: Pin<&mut OrElse<S, Fut, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <OrElse<S, Fut, F> as Sink<Item>>::Error>>

fn start_send( self: Pin<&mut OrElse<S, Fut, F>>, item: Item ) -> Result<(), <OrElse<S, Fut, F> as Sink<Item>>::Error>

fn poll_flush( self: Pin<&mut OrElse<S, Fut, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <OrElse<S, Fut, F> as Sink<Item>>::Error>>

fn poll_close( self: Pin<&mut OrElse<S, Fut, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <OrElse<S, Fut, F> as Sink<Item>>::Error>>

impl<_Item, St, F> Sink<_Item> for InspectErr<St, F>where Inspect<IntoStream<St>, InspectErrFn<F>>: Sink<_Item>,

Available on crate feature sink only.

type Error = <Inspect<IntoStream<St>, InspectErrFn<F>> as Sink<_Item>>::Error

fn poll_ready( self: Pin<&mut InspectErr<St, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <InspectErr<St, F> as Sink<_Item>>::Error>>

fn start_send( self: Pin<&mut InspectErr<St, F>>, item: _Item ) -> Result<(), <InspectErr<St, F> as Sink<_Item>>::Error>

fn poll_flush( self: Pin<&mut InspectErr<St, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <InspectErr<St, F> as Sink<_Item>>::Error>>

fn poll_close( self: Pin<&mut InspectErr<St, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <InspectErr<St, F> as Sink<_Item>>::Error>>

impl<Si, Item> Sink<Item> for Buffer<Si, Item>where Si: Sink<Item>,

type Error = <Si as Sink<Item>>::Error

fn poll_ready( self: Pin<&mut Buffer<Si, Item>>, cx: &mut Context<'_> ) -> Poll<Result<(), <Buffer<Si, Item> as Sink<Item>>::Error>>

fn start_send( self: Pin<&mut Buffer<Si, Item>>, item: Item ) -> Result<(), <Buffer<Si, Item> as Sink<Item>>::Error>

fn poll_flush( self: Pin<&mut Buffer<Si, Item>>, cx: &mut Context<'_> ) -> Poll<Result<(), <Buffer<Si, Item> as Sink<Item>>::Error>>

fn poll_close( self: Pin<&mut Buffer<Si, Item>>, cx: &mut Context<'_> ) -> Poll<Result<(), <Buffer<Si, Item> as Sink<Item>>::Error>>

impl<_Item, St> Sink<_Item> for TryFlattenUnordered<St>where FlattenUnorderedWithFlowController<NestedTryStreamIntoEitherTryStream<St>, PropagateBaseStreamError<St>>: Sink<_Item>, St: TryStream, <St as TryStream>::Ok: TryStream + Unpin, <<St as TryStream>::Ok as TryStream>::Error: From<<St as TryStream>::Error>,

Available on crate feature sink only.

type Error = <FlattenUnorderedWithFlowController<NestedTryStreamIntoEitherTryStream<St>, PropagateBaseStreamError<St>> as Sink<_Item>>::Error

fn poll_ready( self: Pin<&mut TryFlattenUnordered<St>>, cx: &mut Context<'_> ) -> Poll<Result<(), <TryFlattenUnordered<St> as Sink<_Item>>::Error>>

fn start_send( self: Pin<&mut TryFlattenUnordered<St>>, item: _Item ) -> Result<(), <TryFlattenUnordered<St> as Sink<_Item>>::Error>

fn poll_flush( self: Pin<&mut TryFlattenUnordered<St>>, cx: &mut Context<'_> ) -> Poll<Result<(), <TryFlattenUnordered<St> as Sink<_Item>>::Error>>

fn poll_close( self: Pin<&mut TryFlattenUnordered<St>>, cx: &mut Context<'_> ) -> Poll<Result<(), <TryFlattenUnordered<St> as Sink<_Item>>::Error>>

impl<S, Item> Sink<Item> for TryChunks<S>where S: TryStream + Sink<Item>,

Available on crate feature sink only.

type Error = <S as Sink<Item>>::Error

fn poll_ready( self: Pin<&mut TryChunks<S>>, cx: &mut Context<'_> ) -> Poll<Result<(), <TryChunks<S> as Sink<Item>>::Error>>

fn start_send( self: Pin<&mut TryChunks<S>>, item: Item ) -> Result<(), <TryChunks<S> as Sink<Item>>::Error>

fn poll_flush( self: Pin<&mut TryChunks<S>>, cx: &mut Context<'_> ) -> Poll<Result<(), <TryChunks<S> as Sink<Item>>::Error>>

fn poll_close( self: Pin<&mut TryChunks<S>>, cx: &mut Context<'_> ) -> Poll<Result<(), <TryChunks<S> as Sink<Item>>::Error>>

impl<_Item, Fut> Sink<_Item> for TryFlattenStream<Fut>where TryFlatten<Fut, <Fut as TryFuture>::Ok>: Sink<_Item>, Fut: TryFuture,

Available on crate feature sink only.

type Error = <TryFlatten<Fut, <Fut as TryFuture>::Ok> as Sink<_Item>>::Error

fn poll_ready( self: Pin<&mut TryFlattenStream<Fut>>, cx: &mut Context<'_> ) -> Poll<Result<(), <TryFlattenStream<Fut> as Sink<_Item>>::Error>>

fn start_send( self: Pin<&mut TryFlattenStream<Fut>>, item: _Item ) -> Result<(), <TryFlattenStream<Fut> as Sink<_Item>>::Error>

fn poll_flush( self: Pin<&mut TryFlattenStream<Fut>>, cx: &mut Context<'_> ) -> Poll<Result<(), <TryFlattenStream<Fut> as Sink<_Item>>::Error>>

fn poll_close( self: Pin<&mut TryFlattenStream<Fut>>, cx: &mut Context<'_> ) -> Poll<Result<(), <TryFlattenStream<Fut> as Sink<_Item>>::Error>>

impl<_Item, Fut, Si> Sink<_Item> for FlattenSink<Fut, Si>where TryFlatten<Fut, Si>: Sink<_Item>,

Available on crate feature sink only.

type Error = <TryFlatten<Fut, Si> as Sink<_Item>>::Error

fn poll_ready( self: Pin<&mut FlattenSink<Fut, Si>>, cx: &mut Context<'_> ) -> Poll<Result<(), <FlattenSink<Fut, Si> as Sink<_Item>>::Error>>

fn start_send( self: Pin<&mut FlattenSink<Fut, Si>>, item: _Item ) -> Result<(), <FlattenSink<Fut, Si> as Sink<_Item>>::Error>

fn poll_flush( self: Pin<&mut FlattenSink<Fut, Si>>, cx: &mut Context<'_> ) -> Poll<Result<(), <FlattenSink<Fut, Si> as Sink<_Item>>::Error>>

fn poll_close( self: Pin<&mut FlattenSink<Fut, Si>>, cx: &mut Context<'_> ) -> Poll<Result<(), <FlattenSink<Fut, Si> as Sink<_Item>>::Error>>

impl<_Item, St, F> Sink<_Item> for Inspect<St, F>where Map<St, InspectFn<F>>: Sink<_Item>,

Available on crate feature sink only.

type Error = <Map<St, InspectFn<F>> as Sink<_Item>>::Error

fn poll_ready( self: Pin<&mut Inspect<St, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <Inspect<St, F> as Sink<_Item>>::Error>>

fn start_send( self: Pin<&mut Inspect<St, F>>, item: _Item ) -> Result<(), <Inspect<St, F> as Sink<_Item>>::Error>

fn poll_flush( self: Pin<&mut Inspect<St, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <Inspect<St, F> as Sink<_Item>>::Error>>

fn poll_close( self: Pin<&mut Inspect<St, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <Inspect<St, F> as Sink<_Item>>::Error>>

impl<S, Item> Sink<Item> for ReadyChunks<S>where S: Stream + Sink<Item>,

Available on crate feature sink only.

type Error = <S as Sink<Item>>::Error

fn poll_ready( self: Pin<&mut ReadyChunks<S>>, cx: &mut Context<'_> ) -> Poll<Result<(), <ReadyChunks<S> as Sink<Item>>::Error>>

fn start_send( self: Pin<&mut ReadyChunks<S>>, item: Item ) -> Result<(), <ReadyChunks<S> as Sink<Item>>::Error>

fn poll_flush( self: Pin<&mut ReadyChunks<S>>, cx: &mut Context<'_> ) -> Poll<Result<(), <ReadyChunks<S> as Sink<Item>>::Error>>

fn poll_close( self: Pin<&mut ReadyChunks<S>>, cx: &mut Context<'_> ) -> Poll<Result<(), <ReadyChunks<S> as Sink<Item>>::Error>>

impl<S, Item> Sink<Item> for Peekable<S>where S: Sink<Item> + Stream,

Available on crate feature sink only.

type Error = <S as Sink<Item>>::Error

fn poll_ready( self: Pin<&mut Peekable<S>>, cx: &mut Context<'_> ) -> Poll<Result<(), <Peekable<S> as Sink<Item>>::Error>>

fn start_send( self: Pin<&mut Peekable<S>>, item: Item ) -> Result<(), <Peekable<S> as Sink<Item>>::Error>

fn poll_flush( self: Pin<&mut Peekable<S>>, cx: &mut Context<'_> ) -> Poll<Result<(), <Peekable<S> as Sink<Item>>::Error>>

fn poll_close( self: Pin<&mut Peekable<S>>, cx: &mut Context<'_> ) -> Poll<Result<(), <Peekable<S> as Sink<Item>>::Error>>

impl<S, Item> Sink<Item> for IntoStream<S>where S: Sink<Item>,

Available on crate feature sink only.

type Error = <S as Sink<Item>>::Error

fn poll_ready( self: Pin<&mut IntoStream<S>>, cx: &mut Context<'_> ) -> Poll<Result<(), <IntoStream<S> as Sink<Item>>::Error>>

fn start_send( self: Pin<&mut IntoStream<S>>, item: Item ) -> Result<(), <IntoStream<S> as Sink<Item>>::Error>

fn poll_flush( self: Pin<&mut IntoStream<S>>, cx: &mut Context<'_> ) -> Poll<Result<(), <IntoStream<S> as Sink<Item>>::Error>>

fn poll_close( self: Pin<&mut IntoStream<S>>, cx: &mut Context<'_> ) -> Poll<Result<(), <IntoStream<S> as Sink<Item>>::Error>>

impl<S, Fut, F, Item, E> Sink<Item> for TryFilter<S, Fut, F>where S: TryStream + Sink<Item, Error = E>,

Available on crate feature sink only.

type Error = E

fn poll_ready( self: Pin<&mut TryFilter<S, Fut, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <TryFilter<S, Fut, F> as Sink<Item>>::Error>>

fn start_send( self: Pin<&mut TryFilter<S, Fut, F>>, item: Item ) -> Result<(), <TryFilter<S, Fut, F> as Sink<Item>>::Error>

fn poll_flush( self: Pin<&mut TryFilter<S, Fut, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <TryFilter<S, Fut, F> as Sink<Item>>::Error>>

fn poll_close( self: Pin<&mut TryFilter<S, Fut, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <TryFilter<S, Fut, F> as Sink<Item>>::Error>>

impl<S, Fut, F, Item> Sink<Item> for SkipWhile<S, Fut, F>where S: Stream + Sink<Item>, F: FnMut(&<S as Stream>::Item) -> Fut, Fut: Future<Output = bool>,

Available on crate feature sink only.

type Error = <S as Sink<Item>>::Error

fn poll_ready( self: Pin<&mut SkipWhile<S, Fut, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <SkipWhile<S, Fut, F> as Sink<Item>>::Error>>

fn start_send( self: Pin<&mut SkipWhile<S, Fut, F>>, item: Item ) -> Result<(), <SkipWhile<S, Fut, F> as Sink<Item>>::Error>

fn poll_flush( self: Pin<&mut SkipWhile<S, Fut, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <SkipWhile<S, Fut, F> as Sink<Item>>::Error>>

fn poll_close( self: Pin<&mut SkipWhile<S, Fut, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <SkipWhile<S, Fut, F> as Sink<Item>>::Error>>

impl<S, Item> Sink<Item> for TryFlatten<S>where S: TryStream + Sink<Item>,

Available on crate feature sink only.

type Error = <S as Sink<Item>>::Error

fn poll_ready( self: Pin<&mut TryFlatten<S>>, cx: &mut Context<'_> ) -> Poll<Result<(), <TryFlatten<S> as Sink<Item>>::Error>>

fn start_send( self: Pin<&mut TryFlatten<S>>, item: Item ) -> Result<(), <TryFlatten<S> as Sink<Item>>::Error>

fn poll_flush( self: Pin<&mut TryFlatten<S>>, cx: &mut Context<'_> ) -> Poll<Result<(), <TryFlatten<S> as Sink<Item>>::Error>>

fn poll_close( self: Pin<&mut TryFlatten<S>>, cx: &mut Context<'_> ) -> Poll<Result<(), <TryFlatten<S> as Sink<Item>>::Error>>

impl<S, Fut, F, Item> Sink<Item> for TakeWhile<S, Fut, F>where S: Stream + Sink<Item>,

Available on crate feature sink only.

type Error = <S as Sink<Item>>::Error

fn poll_ready( self: Pin<&mut TakeWhile<S, Fut, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <TakeWhile<S, Fut, F> as Sink<Item>>::Error>>

fn start_send( self: Pin<&mut TakeWhile<S, Fut, F>>, item: Item ) -> Result<(), <TakeWhile<S, Fut, F> as Sink<Item>>::Error>

fn poll_flush( self: Pin<&mut TakeWhile<S, Fut, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <TakeWhile<S, Fut, F> as Sink<Item>>::Error>>

fn poll_close( self: Pin<&mut TakeWhile<S, Fut, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <TakeWhile<S, Fut, F> as Sink<Item>>::Error>>

impl<S, Item> Sink<Item> for Buffered<S>where S: Stream + Sink<Item>, <S as Stream>::Item: Future,

Available on crate feature sink only.

type Error = <S as Sink<Item>>::Error

fn poll_ready( self: Pin<&mut Buffered<S>>, cx: &mut Context<'_> ) -> Poll<Result<(), <Buffered<S> as Sink<Item>>::Error>>

fn start_send( self: Pin<&mut Buffered<S>>, item: Item ) -> Result<(), <Buffered<S> as Sink<Item>>::Error>

fn poll_flush( self: Pin<&mut Buffered<S>>, cx: &mut Context<'_> ) -> Poll<Result<(), <Buffered<S> as Sink<Item>>::Error>>

fn poll_close( self: Pin<&mut Buffered<S>>, cx: &mut Context<'_> ) -> Poll<Result<(), <Buffered<S> as Sink<Item>>::Error>>

impl<T, F, R, Item, E> Sink<Item> for Unfold<T, F, R>where F: FnMut(T, Item) -> R, R: Future<Output = Result<T, E>>,

type Error = E

fn poll_ready( self: Pin<&mut Unfold<T, F, R>>, cx: &mut Context<'_> ) -> Poll<Result<(), <Unfold<T, F, R> as Sink<Item>>::Error>>

fn start_send( self: Pin<&mut Unfold<T, F, R>>, item: Item ) -> Result<(), <Unfold<T, F, R> as Sink<Item>>::Error>

fn poll_flush( self: Pin<&mut Unfold<T, F, R>>, cx: &mut Context<'_> ) -> Poll<Result<(), <Unfold<T, F, R> as Sink<Item>>::Error>>

fn poll_close( self: Pin<&mut Unfold<T, F, R>>, cx: &mut Context<'_> ) -> Poll<Result<(), <Unfold<T, F, R> as Sink<Item>>::Error>>

impl<W, Item> Sink<Item> for IntoSink<W, Item>where W: AsyncWrite, Item: AsRef<[u8]>,

type Error = Error

fn poll_ready( self: Pin<&mut IntoSink<W, Item>>, cx: &mut Context<'_> ) -> Poll<Result<(), <IntoSink<W, Item> as Sink<Item>>::Error>>

fn start_send( self: Pin<&mut IntoSink<W, Item>>, item: Item ) -> Result<(), <IntoSink<W, Item> as Sink<Item>>::Error>

fn poll_flush( self: Pin<&mut IntoSink<W, Item>>, cx: &mut Context<'_> ) -> Poll<Result<(), <IntoSink<W, Item> as Sink<Item>>::Error>>

fn poll_close( self: Pin<&mut IntoSink<W, Item>>, cx: &mut Context<'_> ) -> Poll<Result<(), <IntoSink<W, Item> as Sink<Item>>::Error>>

impl<S, Fut, F, Item, E> Sink<Item> for TrySkipWhile<S, Fut, F>where S: TryStream + Sink<Item, Error = E>,

Available on crate feature sink only.

type Error = E

fn poll_ready( self: Pin<&mut TrySkipWhile<S, Fut, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <TrySkipWhile<S, Fut, F> as Sink<Item>>::Error>>

fn start_send( self: Pin<&mut TrySkipWhile<S, Fut, F>>, item: Item ) -> Result<(), <TrySkipWhile<S, Fut, F> as Sink<Item>>::Error>

fn poll_flush( self: Pin<&mut TrySkipWhile<S, Fut, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <TrySkipWhile<S, Fut, F> as Sink<Item>>::Error>>

fn poll_close( self: Pin<&mut TrySkipWhile<S, Fut, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <TrySkipWhile<S, Fut, F> as Sink<Item>>::Error>>

impl<S, Fut, F, Item> Sink<Item> for AndThen<S, Fut, F>where S: Sink<Item>,

Available on crate feature sink only.

type Error = <S as Sink<Item>>::Error

fn poll_ready( self: Pin<&mut AndThen<S, Fut, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <AndThen<S, Fut, F> as Sink<Item>>::Error>>

fn start_send( self: Pin<&mut AndThen<S, Fut, F>>, item: Item ) -> Result<(), <AndThen<S, Fut, F> as Sink<Item>>::Error>

fn poll_flush( self: Pin<&mut AndThen<S, Fut, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <AndThen<S, Fut, F> as Sink<Item>>::Error>>

fn poll_close( self: Pin<&mut AndThen<S, Fut, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <AndThen<S, Fut, F> as Sink<Item>>::Error>>

impl<S, Item, E> Sink<Item> for TryBufferUnordered<S>where S: TryStream + Sink<Item, Error = E>, <S as TryStream>::Ok: TryFuture<Error = E>,

Available on crate feature sink only.

type Error = E

fn poll_ready( self: Pin<&mut TryBufferUnordered<S>>, cx: &mut Context<'_> ) -> Poll<Result<(), <TryBufferUnordered<S> as Sink<Item>>::Error>>

fn start_send( self: Pin<&mut TryBufferUnordered<S>>, item: Item ) -> Result<(), <TryBufferUnordered<S> as Sink<Item>>::Error>

fn poll_flush( self: Pin<&mut TryBufferUnordered<S>>, cx: &mut Context<'_> ) -> Poll<Result<(), <TryBufferUnordered<S> as Sink<Item>>::Error>>

fn poll_close( self: Pin<&mut TryBufferUnordered<S>>, cx: &mut Context<'_> ) -> Poll<Result<(), <TryBufferUnordered<S> as Sink<Item>>::Error>>

impl<S, Fut, Item> Sink<Item> for TakeUntil<S, Fut>where S: Stream + Sink<Item>, Fut: Future,

Available on crate feature sink only.

type Error = <S as Sink<Item>>::Error

fn poll_ready( self: Pin<&mut TakeUntil<S, Fut>>, cx: &mut Context<'_> ) -> Poll<Result<(), <TakeUntil<S, Fut> as Sink<Item>>::Error>>

fn start_send( self: Pin<&mut TakeUntil<S, Fut>>, item: Item ) -> Result<(), <TakeUntil<S, Fut> as Sink<Item>>::Error>

fn poll_flush( self: Pin<&mut TakeUntil<S, Fut>>, cx: &mut Context<'_> ) -> Poll<Result<(), <TakeUntil<S, Fut> as Sink<Item>>::Error>>

fn poll_close( self: Pin<&mut TakeUntil<S, Fut>>, cx: &mut Context<'_> ) -> Poll<Result<(), <TakeUntil<S, Fut> as Sink<Item>>::Error>>

impl<_Item, St, E> Sink<_Item> for ErrInto<St, E>where MapErr<St, IntoFn<E>>: Sink<_Item>,

Available on crate feature sink only.

type Error = <MapErr<St, IntoFn<E>> as Sink<_Item>>::Error

fn poll_ready( self: Pin<&mut ErrInto<St, E>>, cx: &mut Context<'_> ) -> Poll<Result<(), <ErrInto<St, E> as Sink<_Item>>::Error>>

fn start_send( self: Pin<&mut ErrInto<St, E>>, item: _Item ) -> Result<(), <ErrInto<St, E> as Sink<_Item>>::Error>

fn poll_flush( self: Pin<&mut ErrInto<St, E>>, cx: &mut Context<'_> ) -> Poll<Result<(), <ErrInto<St, E> as Sink<_Item>>::Error>>

fn poll_close( self: Pin<&mut ErrInto<St, E>>, cx: &mut Context<'_> ) -> Poll<Result<(), <ErrInto<St, E> as Sink<_Item>>::Error>>

impl<S, Fut, F, Item, E> Sink<Item> for TryTakeWhile<S, Fut, F>where S: TryStream + Sink<Item, Error = E>,

Available on crate feature sink only.

type Error = E

fn poll_ready( self: Pin<&mut TryTakeWhile<S, Fut, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <TryTakeWhile<S, Fut, F> as Sink<Item>>::Error>>

fn start_send( self: Pin<&mut TryTakeWhile<S, Fut, F>>, item: Item ) -> Result<(), <TryTakeWhile<S, Fut, F> as Sink<Item>>::Error>

fn poll_flush( self: Pin<&mut TryTakeWhile<S, Fut, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <TryTakeWhile<S, Fut, F> as Sink<Item>>::Error>>

fn poll_close( self: Pin<&mut TryTakeWhile<S, Fut, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <TryTakeWhile<S, Fut, F> as Sink<Item>>::Error>>

impl<S, Fut, F, Item> Sink<Item> for TryFilterMap<S, Fut, F>where S: Sink<Item>,

Available on crate feature sink only.

type Error = <S as Sink<Item>>::Error

fn poll_ready( self: Pin<&mut TryFilterMap<S, Fut, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <TryFilterMap<S, Fut, F> as Sink<Item>>::Error>>

fn start_send( self: Pin<&mut TryFilterMap<S, Fut, F>>, item: Item ) -> Result<(), <TryFilterMap<S, Fut, F> as Sink<Item>>::Error>

fn poll_flush( self: Pin<&mut TryFilterMap<S, Fut, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <TryFilterMap<S, Fut, F> as Sink<Item>>::Error>>

fn poll_close( self: Pin<&mut TryFilterMap<S, Fut, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <TryFilterMap<S, Fut, F> as Sink<Item>>::Error>>

impl<Si, Item, U, St, F> Sink<U> for WithFlatMap<Si, Item, U, St, F>where Si: Sink<Item>, F: FnMut(U) -> St, St: Stream<Item = Result<Item, <Si as Sink<Item>>::Error>>,

type Error = <Si as Sink<Item>>::Error

fn poll_ready( self: Pin<&mut WithFlatMap<Si, Item, U, St, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <WithFlatMap<Si, Item, U, St, F> as Sink<U>>::Error>>

fn start_send( self: Pin<&mut WithFlatMap<Si, Item, U, St, F>>, item: U ) -> Result<(), <WithFlatMap<Si, Item, U, St, F> as Sink<U>>::Error>

fn poll_flush( self: Pin<&mut WithFlatMap<Si, Item, U, St, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <WithFlatMap<Si, Item, U, St, F> as Sink<U>>::Error>>

fn poll_close( self: Pin<&mut WithFlatMap<Si, Item, U, St, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <WithFlatMap<Si, Item, U, St, F> as Sink<U>>::Error>>

impl<S, Item> Sink<Item> for SplitSink<S, Item>where S: Sink<Item>,

type Error = <S as Sink<Item>>::Error

fn poll_ready( self: Pin<&mut SplitSink<S, Item>>, cx: &mut Context<'_> ) -> Poll<Result<(), <S as Sink<Item>>::Error>>

fn start_send( self: Pin<&mut SplitSink<S, Item>>, item: Item ) -> Result<(), <S as Sink<Item>>::Error>

fn poll_flush( self: Pin<&mut SplitSink<S, Item>>, cx: &mut Context<'_> ) -> Poll<Result<(), <S as Sink<Item>>::Error>>

fn poll_close( self: Pin<&mut SplitSink<S, Item>>, cx: &mut Context<'_> ) -> Poll<Result<(), <S as Sink<Item>>::Error>>

impl<S, Fut, F, Item> Sink<Item> for Filter<S, Fut, F>where S: Stream + Sink<Item>, F: FnMut(&<S as Stream>::Item) -> Fut, Fut: Future<Output = bool>,

Available on crate feature sink only.

type Error = <S as Sink<Item>>::Error

fn poll_ready( self: Pin<&mut Filter<S, Fut, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <Filter<S, Fut, F> as Sink<Item>>::Error>>

fn start_send( self: Pin<&mut Filter<S, Fut, F>>, item: Item ) -> Result<(), <Filter<S, Fut, F> as Sink<Item>>::Error>

fn poll_flush( self: Pin<&mut Filter<S, Fut, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <Filter<S, Fut, F> as Sink<Item>>::Error>>

fn poll_close( self: Pin<&mut Filter<S, Fut, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <Filter<S, Fut, F> as Sink<Item>>::Error>>

impl<S, Item> Sink<Item> for Enumerate<S>where S: Stream + Sink<Item>,

Available on crate feature sink only.

type Error = <S as Sink<Item>>::Error

fn poll_ready( self: Pin<&mut Enumerate<S>>, cx: &mut Context<'_> ) -> Poll<Result<(), <Enumerate<S> as Sink<Item>>::Error>>

fn start_send( self: Pin<&mut Enumerate<S>>, item: Item ) -> Result<(), <Enumerate<S> as Sink<Item>>::Error>

fn poll_flush( self: Pin<&mut Enumerate<S>>, cx: &mut Context<'_> ) -> Poll<Result<(), <Enumerate<S> as Sink<Item>>::Error>>

fn poll_close( self: Pin<&mut Enumerate<S>>, cx: &mut Context<'_> ) -> Poll<Result<(), <Enumerate<S> as Sink<Item>>::Error>>

impl<Si1, Si2, Item> Sink<Item> for Fanout<Si1, Si2>where Si1: Sink<Item>, Item: Clone, Si2: Sink<Item, Error = <Si1 as Sink<Item>>::Error>,

type Error = <Si1 as Sink<Item>>::Error

fn poll_ready( self: Pin<&mut Fanout<Si1, Si2>>, cx: &mut Context<'_> ) -> Poll<Result<(), <Fanout<Si1, Si2> as Sink<Item>>::Error>>

fn start_send( self: Pin<&mut Fanout<Si1, Si2>>, item: Item ) -> Result<(), <Fanout<Si1, Si2> as Sink<Item>>::Error>

fn poll_flush( self: Pin<&mut Fanout<Si1, Si2>>, cx: &mut Context<'_> ) -> Poll<Result<(), <Fanout<Si1, Si2> as Sink<Item>>::Error>>

fn poll_close( self: Pin<&mut Fanout<Si1, Si2>>, cx: &mut Context<'_> ) -> Poll<Result<(), <Fanout<Si1, Si2> as Sink<Item>>::Error>>

impl<S, Item> Sink<Item> for BufferUnordered<S>where S: Stream + Sink<Item>, <S as Stream>::Item: Future,

Available on crate feature sink only.

type Error = <S as Sink<Item>>::Error

fn poll_ready( self: Pin<&mut BufferUnordered<S>>, cx: &mut Context<'_> ) -> Poll<Result<(), <BufferUnordered<S> as Sink<Item>>::Error>>

fn start_send( self: Pin<&mut BufferUnordered<S>>, item: Item ) -> Result<(), <BufferUnordered<S> as Sink<Item>>::Error>

fn poll_flush( self: Pin<&mut BufferUnordered<S>>, cx: &mut Context<'_> ) -> Poll<Result<(), <BufferUnordered<S> as Sink<Item>>::Error>>

fn poll_close( self: Pin<&mut BufferUnordered<S>>, cx: &mut Context<'_> ) -> Poll<Result<(), <BufferUnordered<S> as Sink<Item>>::Error>>

impl<_Item, St, U, F> Sink<_Item> for FlatMapUnordered<St, U, F>where FlattenUnorderedWithFlowController<Map<St, F>, ()>: Sink<_Item>, St: Stream, U: Stream + Unpin, F: FnMut(<St as Stream>::Item) -> U,

Available on crate feature sink only.

type Error = <FlattenUnorderedWithFlowController<Map<St, F>, ()> as Sink<_Item>>::Error

fn poll_ready( self: Pin<&mut FlatMapUnordered<St, U, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <FlatMapUnordered<St, U, F> as Sink<_Item>>::Error>>

fn start_send( self: Pin<&mut FlatMapUnordered<St, U, F>>, item: _Item ) -> Result<(), <FlatMapUnordered<St, U, F> as Sink<_Item>>::Error>

fn poll_flush( self: Pin<&mut FlatMapUnordered<St, U, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <FlatMapUnordered<St, U, F> as Sink<_Item>>::Error>>

fn poll_close( self: Pin<&mut FlatMapUnordered<St, U, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <FlatMapUnordered<St, U, F> as Sink<_Item>>::Error>>

impl<_Item, St, F> Sink<_Item> for InspectOk<St, F>where Inspect<IntoStream<St>, InspectOkFn<F>>: Sink<_Item>,

Available on crate feature sink only.

type Error = <Inspect<IntoStream<St>, InspectOkFn<F>> as Sink<_Item>>::Error

fn poll_ready( self: Pin<&mut InspectOk<St, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <InspectOk<St, F> as Sink<_Item>>::Error>>

fn start_send( self: Pin<&mut InspectOk<St, F>>, item: _Item ) -> Result<(), <InspectOk<St, F> as Sink<_Item>>::Error>

fn poll_flush( self: Pin<&mut InspectOk<St, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <InspectOk<St, F> as Sink<_Item>>::Error>>

fn poll_close( self: Pin<&mut InspectOk<St, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <InspectOk<St, F> as Sink<_Item>>::Error>>

impl<Si, Item, E> Sink<Item> for SinkErrInto<Si, Item, E>where Si: Sink<Item>, <Si as Sink<Item>>::Error: Into<E>,

type Error = E

fn poll_ready( self: Pin<&mut SinkErrInto<Si, Item, E>>, cx: &mut Context<'_> ) -> Poll<Result<(), <SinkErrInto<Si, Item, E> as Sink<Item>>::Error>>

fn start_send( self: Pin<&mut SinkErrInto<Si, Item, E>>, item: Item ) -> Result<(), <SinkErrInto<Si, Item, E> as Sink<Item>>::Error>

fn poll_flush( self: Pin<&mut SinkErrInto<Si, Item, E>>, cx: &mut Context<'_> ) -> Poll<Result<(), <SinkErrInto<Si, Item, E> as Sink<Item>>::Error>>

fn poll_close( self: Pin<&mut SinkErrInto<Si, Item, E>>, cx: &mut Context<'_> ) -> Poll<Result<(), <SinkErrInto<Si, Item, E> as Sink<Item>>::Error>>

impl<St, S, Fut, F, Item> Sink<Item> for Scan<St, S, Fut, F>where St: Stream + Sink<Item>,

Available on crate feature sink only.

type Error = <St as Sink<Item>>::Error

fn poll_ready( self: Pin<&mut Scan<St, S, Fut, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <Scan<St, S, Fut, F> as Sink<Item>>::Error>>

fn start_send( self: Pin<&mut Scan<St, S, Fut, F>>, item: Item ) -> Result<(), <Scan<St, S, Fut, F> as Sink<Item>>::Error>

fn poll_flush( self: Pin<&mut Scan<St, S, Fut, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <Scan<St, S, Fut, F> as Sink<Item>>::Error>>

fn poll_close( self: Pin<&mut Scan<St, S, Fut, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <Scan<St, S, Fut, F> as Sink<Item>>::Error>>

impl<S, Item> Sink<Item> for Fuse<S>where S: Stream + Sink<Item>,

Available on crate feature sink only.

type Error = <S as Sink<Item>>::Error

fn poll_ready( self: Pin<&mut Fuse<S>>, cx: &mut Context<'_> ) -> Poll<Result<(), <Fuse<S> as Sink<Item>>::Error>>

fn start_send( self: Pin<&mut Fuse<S>>, item: Item ) -> Result<(), <Fuse<S> as Sink<Item>>::Error>

fn poll_flush( self: Pin<&mut Fuse<S>>, cx: &mut Context<'_> ) -> Poll<Result<(), <Fuse<S> as Sink<Item>>::Error>>

fn poll_close( self: Pin<&mut Fuse<S>>, cx: &mut Context<'_> ) -> Poll<Result<(), <Fuse<S> as Sink<Item>>::Error>>

impl<S, Fut, F, Item> Sink<Item> for Then<S, Fut, F>where S: Sink<Item>,

Available on crate feature sink only.

type Error = <S as Sink<Item>>::Error

fn poll_ready( self: Pin<&mut Then<S, Fut, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <Then<S, Fut, F> as Sink<Item>>::Error>>

fn start_send( self: Pin<&mut Then<S, Fut, F>>, item: Item ) -> Result<(), <Then<S, Fut, F> as Sink<Item>>::Error>

fn poll_flush( self: Pin<&mut Then<S, Fut, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <Then<S, Fut, F> as Sink<Item>>::Error>>

fn poll_close( self: Pin<&mut Then<S, Fut, F>>, cx: &mut Context<'_> ) -> Poll<Result<(), <Then<S, Fut, F> as Sink<Item>>::Error>>

impl<T> Sink<T> for VecDeque<T, Global>

type Error = Infallible

fn poll_ready( self: Pin<&mut VecDeque<T, Global>>, _: &mut Context<'_> ) -> Poll<Result<(), <VecDeque<T, Global> as Sink<T>>::Error>>

fn start_send( self: Pin<&mut VecDeque<T, Global>>, item: T ) -> Result<(), <VecDeque<T, Global> as Sink<T>>::Error>

fn poll_flush( self: Pin<&mut VecDeque<T, Global>>, _: &mut Context<'_> ) -> Poll<Result<(), <VecDeque<T, Global> as Sink<T>>::Error>>

fn poll_close( self: Pin<&mut VecDeque<T, Global>>, _: &mut Context<'_> ) -> Poll<Result<(), <VecDeque<T, Global> as Sink<T>>::Error>>

impl<S, Item> Sink<Item> for &mut Swhere S: Sink<Item> + Unpin + ?Sized,

type Error = <S as Sink<Item>>::Error

fn poll_ready( self: Pin<&mut &mut S>, cx: &mut Context<'_> ) -> Poll<Result<(), <&mut S as Sink<Item>>::Error>>

fn start_send( self: Pin<&mut &mut S>, item: Item ) -> Result<(), <&mut S as Sink<Item>>::Error>

fn poll_flush( self: Pin<&mut &mut S>, cx: &mut Context<'_> ) -> Poll<Result<(), <&mut S as Sink<Item>>::Error>>

fn poll_close( self: Pin<&mut &mut S>, cx: &mut Context<'_> ) -> Poll<Result<(), <&mut S as Sink<Item>>::Error>>

impl<T> Sink<T> for Vec<T, Global>

type Error = Infallible

fn poll_ready( self: Pin<&mut Vec<T, Global>>, _: &mut Context<'_> ) -> Poll<Result<(), <Vec<T, Global> as Sink<T>>::Error>>

fn start_send( self: Pin<&mut Vec<T, Global>>, item: T ) -> Result<(), <Vec<T, Global> as Sink<T>>::Error>

fn poll_flush( self: Pin<&mut Vec<T, Global>>, _: &mut Context<'_> ) -> Poll<Result<(), <Vec<T, Global> as Sink<T>>::Error>>

fn poll_close( self: Pin<&mut Vec<T, Global>>, _: &mut Context<'_> ) -> Poll<Result<(), <Vec<T, Global> as Sink<T>>::Error>>

impl<S, Item> Sink<Item> for Box<S, Global>where S: Sink<Item> + Unpin + ?Sized,

type Error = <S as Sink<Item>>::Error

fn poll_ready( self: Pin<&mut Box<S, Global>>, cx: &mut Context<'_> ) -> Poll<Result<(), <Box<S, Global> as Sink<Item>>::Error>>

fn start_send( self: Pin<&mut Box<S, Global>>, item: Item ) -> Result<(), <Box<S, Global> as Sink<Item>>::Error>

fn poll_flush( self: Pin<&mut Box<S, Global>>, cx: &mut Context<'_> ) -> Poll<Result<(), <Box<S, Global> as Sink<Item>>::Error>>

fn poll_close( self: Pin<&mut Box<S, Global>>, cx: &mut Context<'_> ) -> Poll<Result<(), <Box<S, Global> as Sink<Item>>::Error>>

impl<T> Sink<T> for &UnboundedSender<T>

type Error = SendError

fn poll_ready( self: Pin<&mut &UnboundedSender<T>>, cx: &mut Context<'_> ) -> Poll<Result<(), <&UnboundedSender<T> as Sink<T>>::Error>>

fn start_send( self: Pin<&mut &UnboundedSender<T>>, msg: T ) -> Result<(), <&UnboundedSender<T> as Sink<T>>::Error>

fn poll_flush( self: Pin<&mut &UnboundedSender<T>>, _: &mut Context<'_> ) -> Poll<Result<(), <&UnboundedSender<T> as Sink<T>>::Error>>

fn poll_close( self: Pin<&mut &UnboundedSender<T>>, _: &mut Context<'_> ) -> Poll<Result<(), <&UnboundedSender<T> as Sink<T>>::Error>>

impl<T> Sink<T> for UnboundedSender<T>

type Error = SendError

fn poll_ready( self: Pin<&mut UnboundedSender<T>>, cx: &mut Context<'_> ) -> Poll<Result<(), <UnboundedSender<T> as Sink<T>>::Error>>

fn start_send( self: Pin<&mut UnboundedSender<T>>, msg: T ) -> Result<(), <UnboundedSender<T> as Sink<T>>::Error>

fn poll_flush( self: Pin<&mut UnboundedSender<T>>, _: &mut Context<'_> ) -> Poll<Result<(), <UnboundedSender<T> as Sink<T>>::Error>>

fn poll_close( self: Pin<&mut UnboundedSender<T>>, _: &mut Context<'_> ) -> Poll<Result<(), <UnboundedSender<T> as Sink<T>>::Error>>

impl<T> Sink<T> for Sender<T>

type Error = SendError

fn poll_ready( self: Pin<&mut Sender<T>>, cx: &mut Context<'_> ) -> Poll<Result<(), <Sender<T> as Sink<T>>::Error>>

fn start_send( self: Pin<&mut Sender<T>>, msg: T ) -> Result<(), <Sender<T> as Sink<T>>::Error>

fn poll_flush( self: Pin<&mut Sender<T>>, cx: &mut Context<'_> ) -> Poll<Result<(), <Sender<T> as Sink<T>>::Error>>

fn poll_close( self: Pin<&mut Sender<T>>, _: &mut Context<'_> ) -> Poll<Result<(), <Sender<T> as Sink<T>>::Error>>

impl<T> Sink<Message> for WebSocketStream<T>where T: AsyncRead + AsyncWrite + Unpin,

type Error = Error

fn poll_ready( self: Pin<&mut WebSocketStream<T>>, cx: &mut Context<'_> ) -> Poll<Result<(), <WebSocketStream<T> as Sink<Message>>::Error>>

fn start_send( self: Pin<&mut WebSocketStream<T>>, item: Message ) -> Result<(), <WebSocketStream<T> as Sink<Message>>::Error>

fn poll_flush( self: Pin<&mut WebSocketStream<T>>, cx: &mut Context<'_> ) -> Poll<Result<(), <WebSocketStream<T> as Sink<Message>>::Error>>

fn poll_close( self: Pin<&mut WebSocketStream<T>>, cx: &mut Context<'_> ) -> Poll<Result<(), <WebSocketStream<T> as Sink<Message>>::Error>>

impl<T, I, E> Sink<I> for FramedWrite<T, E>where T: AsyncWrite, E: Encoder<I>, <E as Encoder<I>>::Error: From<Error>,

type Error = <E as Encoder<I>>::Error

fn poll_ready( self: Pin<&mut FramedWrite<T, E>>, cx: &mut Context<'_> ) -> Poll<Result<(), <FramedWrite<T, E> as Sink<I>>::Error>>

fn start_send( self: Pin<&mut FramedWrite<T, E>>, item: I ) -> Result<(), <FramedWrite<T, E> as Sink<I>>::Error>

fn poll_flush( self: Pin<&mut FramedWrite<T, E>>, cx: &mut Context<'_> ) -> Poll<Result<(), <FramedWrite<T, E> as Sink<I>>::Error>>

fn poll_close( self: Pin<&mut FramedWrite<T, E>>, cx: &mut Context<'_> ) -> Poll<Result<(), <FramedWrite<T, E> as Sink<I>>::Error>>

impl<T, I, D> Sink<I> for FramedRead<T, D>where T: Sink<I>,

type Error = <T as Sink<I>>::Error

fn poll_ready( self: Pin<&mut FramedRead<T, D>>, cx: &mut Context<'_> ) -> Poll<Result<(), <FramedRead<T, D> as Sink<I>>::Error>>

fn start_send( self: Pin<&mut FramedRead<T, D>>, item: I ) -> Result<(), <FramedRead<T, D> as Sink<I>>::Error>

fn poll_flush( self: Pin<&mut FramedRead<T, D>>, cx: &mut Context<'_> ) -> Poll<Result<(), <FramedRead<T, D> as Sink<I>>::Error>>

fn poll_close( self: Pin<&mut FramedRead<T, D>>, cx: &mut Context<'_> ) -> Poll<Result<(), <FramedRead<T, D> as Sink<I>>::Error>>

impl<T> Sink<T> for PollSender<T>where T: Send + 'static,

type Error = PollSendError<T>

fn poll_ready( self: Pin<&mut PollSender<T>>, cx: &mut Context<'_> ) -> Poll<Result<(), <PollSender<T> as Sink<T>>::Error>>

fn poll_flush( self: Pin<&mut PollSender<T>>, _cx: &mut Context<'_> ) -> Poll<Result<(), <PollSender<T> as Sink<T>>::Error>>

fn start_send( self: Pin<&mut PollSender<T>>, item: T ) -> Result<(), <PollSender<T> as Sink<T>>::Error>

fn poll_close( self: Pin<&mut PollSender<T>>, _cx: &mut Context<'_> ) -> Poll<Result<(), <PollSender<T> as Sink<T>>::Error>>

impl<T, I, U> Sink<I> for Framed<T, U>where T: AsyncWrite, U: Encoder<I>, <U as Encoder<I>>::Error: From<Error>,

type Error = <U as Encoder<I>>::Error

fn poll_ready( self: Pin<&mut Framed<T, U>>, cx: &mut Context<'_> ) -> Poll<Result<(), <Framed<T, U> as Sink<I>>::Error>>

fn start_send( self: Pin<&mut Framed<T, U>>, item: I ) -> Result<(), <Framed<T, U> as Sink<I>>::Error>

fn poll_flush( self: Pin<&mut Framed<T, U>>, cx: &mut Context<'_> ) -> Poll<Result<(), <Framed<T, U> as Sink<I>>::Error>>

fn poll_close( self: Pin<&mut Framed<T, U>>, cx: &mut Context<'_> ) -> Poll<Result<(), <Framed<T, U> as Sink<I>>::Error>>

Implementors

impl<P, Item> Sink<Item> for Pin<P>where P: DerefMut + Unpin, <P as Deref>::Target: Sink<Item>,

type Error = <<P as Deref>::Target as Sink<Item>>::Error