Struct SinkWriter

pub struct SinkWriter<S> { /* private fields */ }

Convert a Sink of byte chunks into an AsyncWrite.

Whenever you write to this SinkWriter, the supplied bytes are forwarded to the inner Sink. When shutdown is called on this SinkWriter, the inner sink is closed.

This adapter takes a Sink<&[u8]> and provides an AsyncWrite impl for it. Because of the lifetime, this trait is relatively rarely implemented. The main ways to get a Sink<&[u8]> that you can use with this type are:

• With the codec module by implementing the Encoder<&[u8]> trait.
• By wrapping a Sink<Bytes> in a CopyToBytes.
• Manually implementing Sink<&[u8]> directly.

The opposite conversion of implementing Sink<_> for an AsyncWrite is done using the codec module.

Example

use bytes::Bytes;
use futures_util::SinkExt;
use std::io::{Error, ErrorKind};
use tokio::io::AsyncWriteExt;
use tokio_util::io::{SinkWriter, CopyToBytes};
use tokio_util::sync::PollSender;

// We use an mpsc channel as an example of a `Sink<Bytes>`.
let (tx, mut rx) = tokio::sync::mpsc::channel::<Bytes>(1);
let sink = PollSender::new(tx).sink_map_err(|_| Error::from(ErrorKind::BrokenPipe));

// Wrap it in `CopyToBytes` to get a `Sink<&[u8]>`.
let mut writer = SinkWriter::new(CopyToBytes::new(sink));

// Write data to our interface...
let data: [u8; 4] = [1, 2, 3, 4];
let _ = writer.write(&data).await?;

// ... and receive it.
assert_eq!(data.as_slice(), &*rx.recv().await.unwrap());

Implementations

impl<S> SinkWriter<S>

pub fn new(sink: S) -> SinkWriter<S>

Creates a new SinkWriter.

pub fn get_ref(&self) -> &S

Gets a reference to the underlying sink.

pub fn get_mut(&mut self) -> &mut S

Gets a mutable reference to the underlying sink.

pub fn into_inner(self) -> S

Consumes this SinkWriter, returning the underlying sink.

Trait Implementations

impl<S> AsyncRead for SinkWriter<S>

where S: AsyncRead,

fn poll_read( self: Pin<&mut SinkWriter<S>>, cx: &mut Context<'_>, buf: &mut ReadBuf<'_>, ) -> Poll<Result<(), Error>>

Attempts to read from the AsyncRead into buf.

impl<S, E> AsyncWrite for SinkWriter<S>

where S: for<'a> Sink<&'a [u8], Error = E>, E: Into<Error>,

fn poll_write( self: Pin<&mut SinkWriter<S>>, cx: &mut Context<'_>, buf: &[u8], ) -> Poll<Result<usize, Error>>

Attempt to write bytes from buf into the object.

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

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

fn poll_shutdown( self: Pin<&mut SinkWriter<S>>, cx: &mut Context<'_>, ) -> Poll<Result<(), Error>>

Initiates or attempts to shut down this writer, returning success when the I/O connection has completely shut down.

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

Like poll_write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

Determines if this writer has an efficient poll_write_vectored implementation.

impl<S> Debug for SinkWriter<S>

where S: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<S> Stream for SinkWriter<S>

where S: Stream,

type Item = <S as Stream>::Item

Values yielded by the stream.

fn poll_next( self: Pin<&mut SinkWriter<S>>, cx: &mut Context<'_>, ) -> Poll<Option<<SinkWriter<S> as Stream>::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<'__pin, S> Unpin for SinkWriter<S>

where <PinnedFieldsOfHelperStruct<__Origin<'__pin, S>> as PinnedFieldsOfHelperTrait>::Actual: Unpin,