Trait ntex::Sink [−][src]
pub trait Sink<Item> {
type Error;
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>>;
}
Expand description
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.
Associated Types
Required methods
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.
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.
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.
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
pub fn poll_ready(
self: Pin<&mut &'_ mut S>,
cx: &mut Context<'_>
) -> Poll<Result<(), <&'_ mut S as Sink<Item>>::Error>>
pub fn start_send(
self: Pin<&mut &'_ mut S>,
item: Item
) -> Result<(), <&'_ mut S as Sink<Item>>::Error>
pub fn poll_ready(
self: Pin<&mut Pin<P>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <Pin<P> as Sink<Item>>::Error>>
type Error = Infallible
pub fn poll_ready(
self: Pin<&mut Vec<T, Global>>,
&mut Context<'_>
) -> Poll<Result<(), <Vec<T, Global> as Sink<T>>::Error>>
pub fn start_send(
self: Pin<&mut Vec<T, Global>>,
item: T
) -> Result<(), <Vec<T, Global> as Sink<T>>::Error>
type Error = Infallible
pub fn poll_ready(
self: Pin<&mut VecDeque<T, Global>>,
&mut Context<'_>
) -> Poll<Result<(), <VecDeque<T, Global> as Sink<T>>::Error>>
pub fn start_send(
self: Pin<&mut VecDeque<T, Global>>,
item: T
) -> Result<(), <VecDeque<T, Global> as Sink<T>>::Error>
pub fn poll_ready(
self: Pin<&mut Box<S, Global>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <Box<S, Global> as Sink<Item>>::Error>>
pub fn start_send(
self: Pin<&mut Box<S, Global>>,
item: Item
) -> Result<(), <Box<S, Global> as Sink<Item>>::Error>
pub fn poll_ready(
self: Pin<&mut IntoSink<W, Item>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <IntoSink<W, Item> as Sink<Item>>::Error>>
pub fn start_send(
self: Pin<&mut IntoSink<W, Item>>,
item: Item
) -> Result<(), <IntoSink<W, Item> as Sink<Item>>::Error>
pub fn poll_ready(
self: Pin<&mut SkipWhile<S, Fut, F>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <SkipWhile<S, Fut, F> as Sink<Item>>::Error>>
pub fn start_send(
self: Pin<&mut SkipWhile<S, Fut, F>>,
item: Item
) -> Result<(), <SkipWhile<S, Fut, F> as Sink<Item>>::Error>
pub fn poll_ready(
self: Pin<&mut Fuse<S>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <Fuse<S> as Sink<Item>>::Error>>
pub fn start_send(
self: Pin<&mut Fuse<S>>,
item: Item
) -> Result<(), <Fuse<S> as Sink<Item>>::Error>
pub fn poll_ready(
self: Pin<&mut Skip<S>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <Skip<S> as Sink<Item>>::Error>>
pub fn start_send(
self: Pin<&mut Skip<S>>,
item: Item
) -> Result<(), <Skip<S> as Sink<Item>>::Error>
pub fn poll_ready(
self: Pin<&mut Flatten<St>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <Flatten<St> as Sink<_Item>>::Error>>
pub fn start_send(
self: Pin<&mut Flatten<St>>,
item: _Item
) -> Result<(), <Flatten<St> as Sink<_Item>>::Error>
pub fn poll_ready(
self: Pin<&mut Then<S, Fut, F>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <Then<S, Fut, F> as Sink<Item>>::Error>>
pub fn start_send(
self: Pin<&mut Then<S, Fut, F>>,
item: Item
) -> Result<(), <Then<S, Fut, F> as Sink<Item>>::Error>
pub fn poll_ready(
self: Pin<&mut Buffer<Si, Item>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <Buffer<Si, Item> as Sink<Item>>::Error>>
pub fn start_send(
self: Pin<&mut Buffer<Si, Item>>,
item: Item
) -> Result<(), <Buffer<Si, Item> as Sink<Item>>::Error>
pub fn poll_ready(
self: Pin<&mut Enumerate<S>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <Enumerate<S> as Sink<Item>>::Error>>
pub fn start_send(
self: Pin<&mut Enumerate<S>>,
item: Item
) -> Result<(), <Enumerate<S> as Sink<Item>>::Error>
pub fn poll_ready(
self: Pin<&mut TakeUntil<S, Fut>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <TakeUntil<S, Fut> as Sink<Item>>::Error>>
pub fn start_send(
self: Pin<&mut TakeUntil<S, Fut>>,
item: Item
) -> Result<(), <TakeUntil<S, Fut> as Sink<Item>>::Error>
type Error = E
pub fn poll_ready(
self: Pin<&mut SinkMapErr<Si, F>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <SinkMapErr<Si, F> as Sink<Item>>::Error>>
pub fn start_send(
self: Pin<&mut SinkMapErr<Si, F>>,
item: Item
) -> Result<(), <SinkMapErr<Si, F> as Sink<Item>>::Error>
pub fn poll_ready(
self: Pin<&mut FilterMap<S, Fut, F>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <FilterMap<S, Fut, F> as Sink<Item>>::Error>>
pub fn start_send(
self: Pin<&mut FilterMap<S, Fut, F>>,
item: Item
) -> Result<(), <FilterMap<S, Fut, F> as Sink<Item>>::Error>
type Error = E
pub fn poll_ready(
self: Pin<&mut TryBufferUnordered<S>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <TryBufferUnordered<S> as Sink<Item>>::Error>>
pub fn start_send(
self: Pin<&mut TryBufferUnordered<S>>,
item: Item
) -> Result<(), <TryBufferUnordered<S> as Sink<Item>>::Error>
pub fn poll_ready(
self: Pin<&mut ReadyChunks<S>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <ReadyChunks<S> as Sink<Item>>::Error>>
pub fn start_send(
self: Pin<&mut ReadyChunks<S>>,
item: Item
) -> Result<(), <ReadyChunks<S> as Sink<Item>>::Error>
pub fn poll_ready(
self: Pin<&mut Chunks<S>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <Chunks<S> as Sink<Item>>::Error>>
pub fn start_send(
self: Pin<&mut Chunks<S>>,
item: Item
) -> Result<(), <Chunks<S> as Sink<Item>>::Error>
pub fn poll_ready(
self: Pin<&mut ErrInto<St, E>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <ErrInto<St, E> as Sink<_Item>>::Error>>
pub fn start_send(
self: Pin<&mut ErrInto<St, E>>,
item: _Item
) -> Result<(), <ErrInto<St, E> as Sink<_Item>>::Error>
type Error = E
pub fn poll_ready(
self: Pin<&mut SinkErrInto<Si, Item, E>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <SinkErrInto<Si, Item, E> as Sink<Item>>::Error>>
pub fn start_send(
self: Pin<&mut SinkErrInto<Si, Item, E>>,
item: Item
) -> Result<(), <SinkErrInto<Si, Item, E> as Sink<Item>>::Error>
pub fn poll_ready(
self: Pin<&mut OrElse<S, Fut, F>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <OrElse<S, Fut, F> as Sink<Item>>::Error>>
pub fn start_send(
self: Pin<&mut OrElse<S, Fut, F>>,
item: Item
) -> Result<(), <OrElse<S, Fut, F> as Sink<Item>>::Error>
pub fn poll_ready(
self: Pin<&mut AndThen<S, Fut, F>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <AndThen<S, Fut, F> as Sink<Item>>::Error>>
pub fn start_send(
self: Pin<&mut AndThen<S, Fut, F>>,
item: Item
) -> Result<(), <AndThen<S, Fut, F> as Sink<Item>>::Error>
pub fn poll_ready(
self: Pin<&mut MapErr<St, F>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <MapErr<St, F> as Sink<_Item>>::Error>>
pub fn start_send(
self: Pin<&mut MapErr<St, F>>,
item: _Item
) -> Result<(), <MapErr<St, F> as Sink<_Item>>::Error>
pub fn poll_ready(
self: Pin<&mut TakeWhile<S, Fut, F>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <TakeWhile<S, Fut, F> as Sink<Item>>::Error>>
pub fn start_send(
self: Pin<&mut TakeWhile<S, Fut, F>>,
item: Item
) -> Result<(), <TakeWhile<S, Fut, F> as Sink<Item>>::Error>
pub fn poll_ready(
self: Pin<&mut Either<A, B>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <Either<A, B> as Sink<Item>>::Error>>
pub fn start_send(
self: Pin<&mut Either<A, B>>,
item: Item
) -> Result<(), <Either<A, B> as Sink<Item>>::Error>
pub fn poll_ready(
self: Pin<&mut InspectErr<St, F>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <InspectErr<St, F> as Sink<_Item>>::Error>>
pub fn start_send(
self: Pin<&mut InspectErr<St, F>>,
item: _Item
) -> Result<(), <InspectErr<St, F> as Sink<_Item>>::Error>
pub fn poll_ready(
self: Pin<&mut TryFilterMap<S, Fut, F>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <TryFilterMap<S, Fut, F> as Sink<Item>>::Error>>
pub fn start_send(
self: Pin<&mut TryFilterMap<S, Fut, F>>,
item: Item
) -> Result<(), <TryFilterMap<S, Fut, F> as Sink<Item>>::Error>
pub fn poll_ready(
self: Pin<&mut IntoStream<S>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <IntoStream<S> as Sink<Item>>::Error>>
pub fn start_send(
self: Pin<&mut IntoStream<S>>,
item: Item
) -> Result<(), <IntoStream<S> as Sink<Item>>::Error>
impl<T> Sink<T> for Drain<T>
impl<T> Sink<T> for Drain<T>
pub fn poll_ready(
self: Pin<&mut FlattenStream<F>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <FlattenStream<F> as Sink<_Item>>::Error>>
pub fn start_send(
self: Pin<&mut FlattenStream<F>>,
item: _Item
) -> Result<(), <FlattenStream<F> as Sink<_Item>>::Error>
pub fn poll_ready(
self: Pin<&mut TryFlattenStream<Fut>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <TryFlattenStream<Fut> as Sink<_Item>>::Error>>
pub fn start_send(
self: Pin<&mut TryFlattenStream<Fut>>,
item: _Item
) -> Result<(), <TryFlattenStream<Fut> as Sink<_Item>>::Error>
type Error = E
pub fn poll_ready(
self: Pin<&mut TryBuffered<S>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <TryBuffered<S> as Sink<Item>>::Error>>
pub fn start_send(
self: Pin<&mut TryBuffered<S>>,
item: Item
) -> Result<(), <TryBuffered<S> as Sink<Item>>::Error>
pub fn poll_ready(
self: Pin<&mut Peekable<S>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <Peekable<S> as Sink<Item>>::Error>>
pub fn start_send(
self: Pin<&mut Peekable<S>>,
item: Item
) -> Result<(), <Peekable<S> as Sink<Item>>::Error>
type Error = E
pub fn poll_ready(
self: Pin<&mut Unfold<T, F, R>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <Unfold<T, F, R> as Sink<Item>>::Error>>
pub fn start_send(
self: Pin<&mut Unfold<T, F, R>>,
item: Item
) -> Result<(), <Unfold<T, F, R> as Sink<Item>>::Error>
pub fn poll_ready(
self: Pin<&mut MapOk<St, F>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <MapOk<St, F> as Sink<_Item>>::Error>>
pub fn start_send(
self: Pin<&mut MapOk<St, F>>,
item: _Item
) -> Result<(), <MapOk<St, F> as Sink<_Item>>::Error>
pub fn poll_ready(
self: Pin<&mut TryFlatten<S>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <TryFlatten<S> as Sink<Item>>::Error>>
pub fn start_send(
self: Pin<&mut TryFlatten<S>>,
item: Item
) -> Result<(), <TryFlatten<S> as Sink<Item>>::Error>
type Error = E
pub 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>>
pub 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>
pub 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>>
pub 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>
pub fn poll_ready(
self: Pin<&mut Take<S>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <Take<S> as Sink<Item>>::Error>>
pub fn start_send(
self: Pin<&mut Take<S>>,
item: Item
) -> Result<(), <Take<S> as Sink<Item>>::Error>
pub fn poll_ready(
self: Pin<&mut Fanout<Si1, Si2>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <Fanout<Si1, Si2> as Sink<Item>>::Error>>
pub fn start_send(
self: Pin<&mut Fanout<Si1, Si2>>,
item: Item
) -> Result<(), <Fanout<Si1, Si2> as Sink<Item>>::Error>
pub fn poll_ready(
self: Pin<&mut Buffered<S>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <Buffered<S> as Sink<Item>>::Error>>
pub fn start_send(
self: Pin<&mut Buffered<S>>,
item: Item
) -> Result<(), <Buffered<S> as Sink<Item>>::Error>
pub fn poll_ready(
self: Pin<&mut Filter<S, Fut, F>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <Filter<S, Fut, F> as Sink<Item>>::Error>>
pub fn start_send(
self: Pin<&mut Filter<S, Fut, F>>,
item: Item
) -> Result<(), <Filter<S, Fut, F> as Sink<Item>>::Error>
pub fn poll_ready(
self: Pin<&mut BufferUnordered<S>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <BufferUnordered<S> as Sink<Item>>::Error>>
pub fn start_send(
self: Pin<&mut BufferUnordered<S>>,
item: Item
) -> Result<(), <BufferUnordered<S> as Sink<Item>>::Error>
pub fn poll_ready(
self: Pin<&mut Inspect<St, F>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <Inspect<St, F> as Sink<_Item>>::Error>>
pub fn start_send(
self: Pin<&mut Inspect<St, F>>,
item: _Item
) -> Result<(), <Inspect<St, F> as Sink<_Item>>::Error>
type Error = E
pub fn poll_ready(
self: Pin<&mut TryFilter<S, Fut, F>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <TryFilter<S, Fut, F> as Sink<Item>>::Error>>
pub fn start_send(
self: Pin<&mut TryFilter<S, Fut, F>>,
item: Item
) -> Result<(), <TryFilter<S, Fut, F> as Sink<Item>>::Error>
pub fn poll_ready(
self: Pin<&mut FlattenSink<Fut, Si>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <FlattenSink<Fut, Si> as Sink<_Item>>::Error>>
pub fn start_send(
self: Pin<&mut FlattenSink<Fut, Si>>,
item: _Item
) -> Result<(), <FlattenSink<Fut, Si> as Sink<_Item>>::Error>
pub fn poll_ready(
self: Pin<&mut FlatMap<St, U, F>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <FlatMap<St, U, F> as Sink<_Item>>::Error>>
pub fn start_send(
self: Pin<&mut FlatMap<St, U, F>>,
item: _Item
) -> Result<(), <FlatMap<St, U, F> as Sink<_Item>>::Error>
pub fn poll_ready(
self: Pin<&mut InspectOk<St, F>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <InspectOk<St, F> as Sink<_Item>>::Error>>
pub fn start_send(
self: Pin<&mut InspectOk<St, F>>,
item: _Item
) -> Result<(), <InspectOk<St, F> as Sink<_Item>>::Error>
pub fn poll_ready(
self: Pin<&mut Scan<S, S, Fut, F>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <Scan<S, S, Fut, F> as Sink<Item>>::Error>>
pub fn start_send(
self: Pin<&mut Scan<S, S, Fut, F>>,
item: Item
) -> Result<(), <Scan<S, S, Fut, F> as Sink<Item>>::Error>
type Error = E
pub fn poll_ready(
self: Pin<&mut TryTakeWhile<S, Fut, F>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <TryTakeWhile<S, Fut, F> as Sink<Item>>::Error>>
pub fn start_send(
self: Pin<&mut TryTakeWhile<S, Fut, F>>,
item: Item
) -> Result<(), <TryTakeWhile<S, Fut, F> as Sink<Item>>::Error>
type Error = E
pub fn poll_ready(
self: Pin<&mut TrySkipWhile<S, Fut, F>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <TrySkipWhile<S, Fut, F> as Sink<Item>>::Error>>
pub fn start_send(
self: Pin<&mut TrySkipWhile<S, Fut, F>>,
item: Item
) -> Result<(), <TrySkipWhile<S, Fut, F> as Sink<Item>>::Error>
pub fn poll_ready(
self: Pin<&mut Map<St, F>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <Map<St, F> as Sink<Item>>::Error>>
pub fn start_send(
self: Pin<&mut Map<St, F>>,
item: Item
) -> Result<(), <Map<St, F> as Sink<Item>>::Error>
pub fn poll_ready(
self: Pin<&mut SplitSink<S, Item>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <S as Sink<Item>>::Error>>
pub fn start_send(
self: Pin<&mut SplitSink<S, Item>>,
item: Item
) -> Result<(), <S as Sink<Item>>::Error>
pub fn poll_ready(
self: Pin<&mut TryChunks<S>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <TryChunks<S> as Sink<Item>>::Error>>
pub fn start_send(
self: Pin<&mut TryChunks<S>>,
item: Item
) -> Result<(), <TryChunks<S> as Sink<Item>>::Error>
impl<T> Sink<T> for Sender<T>
impl<T> Sink<T> for Sender<T>
impl<'_, T> Sink<T> for &'_ UnboundedSender<T>
impl<'_, T> Sink<T> for &'_ UnboundedSender<T>
type Error = SendError
pub fn poll_ready(
self: Pin<&mut &'_ UnboundedSender<T>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <&'_ UnboundedSender<T> as Sink<T>>::Error>>
pub fn start_send(
self: Pin<&mut &'_ UnboundedSender<T>>,
msg: T
) -> Result<(), <&'_ UnboundedSender<T> as Sink<T>>::Error>
impl<T> Sink<T> for UnboundedSender<T>
impl<T> Sink<T> for UnboundedSender<T>
type Error = SendError
pub fn poll_ready(
self: Pin<&mut UnboundedSender<T>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <UnboundedSender<T> as Sink<T>>::Error>>
pub fn start_send(
self: Pin<&mut UnboundedSender<T>>,
msg: T
) -> Result<(), <UnboundedSender<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>,
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
pub fn poll_ready(
self: Pin<&mut Framed<T, U>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <Framed<T, U> as Sink<I>>::Error>>
pub fn start_send(
self: Pin<&mut Framed<T, U>>,
item: I
) -> Result<(), <Framed<T, U> as Sink<I>>::Error>
pub fn poll_ready(
self: Pin<&mut FramedRead<T, D>>,
cx: &mut Context<'_>
) -> Poll<Result<(), <FramedRead<T, D> as Sink<I>>::Error>>
pub fn start_send(
self: Pin<&mut FramedRead<T, D>>,
item: I
) -> Result<(), <FramedRead<T, D> as Sink<I>>::Error>
This is equivalent to calling poll_send_done
.
This is equivalent to calling poll_send_done
.
This is equivalent to calling start_send
.
This method will first flush the PollSender
, and then close it by
calling close_this_sender
.
If a send fails while flushing because the Receiver
has gone away,
then this function returns an error. The channel is still successfully
closed in this situation.