Struct async_bincode::tokio::AsyncBincodeWriter

pub struct AsyncBincodeWriter<W, T, D> { /* private fields */ }

A wrapper around an asynchronous sink that accepts, serializes, and sends bincode-encoded values.

To use, provide a reader that implements tokio::io::AsyncWrite, and then use futures_sink::Sink to send values.

Note that an AsyncBincodeWriter must be of the type AsyncDestination in order to be compatible with an AsyncBincodeReader on the remote end (recall that it requires the serialized size prefixed to the serialized data). The default is SyncDestination, but these can be easily toggled between using AsyncBincodeWriter::for_async.

Implementations

impl<W, T, D> AsyncBincodeWriter<W, T, D>

pub fn get_ref(&self) -> &W

Gets a reference to the underlying writer.

It is inadvisable to directly write to the underlying writer.

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

Gets a mutable reference to the underlying writer.

It is inadvisable to directly write to the underlying writer.

pub fn into_inner(self) -> W

Unwraps this AsyncBincodeWriter, returning the underlying writer.

Note that any leftover serialized data that has not yet been sent is lost.

impl<W, T> AsyncBincodeWriter<W, T, SyncDestination>

pub fn for_async(self) -> AsyncBincodeWriter<W, T, AsyncDestination>

Make this writer include the serialized data’s size before each serialized value.

This is necessary for compatibility with AsyncBincodeReader.

impl<W, T> AsyncBincodeWriter<W, T, AsyncDestination>

pub fn for_sync(self) -> AsyncBincodeWriter<W, T, SyncDestination>

Make this writer only send bincode-encoded values.

This is necessary for compatibility with stock bincode receivers.

Trait Implementations

impl<W: Debug, T: Debug, D: Debug> Debug for AsyncBincodeWriter<W, T, D>

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

Formats the value using the given formatter.

impl<W, T> Default for AsyncBincodeWriter<W, T, SyncDestination> where
    W: Default, 

fn default() -> Self

Returns the “default value” for a type.

impl<W, T> From<W> for AsyncBincodeWriter<W, T, SyncDestination>

fn from(writer: W) -> Self

Converts to this type from the input type.

impl<W, T, D> Sink<T> for AsyncBincodeWriter<W, T, D> where
    T: Serialize,
    W: AsyncWrite + Unpin,
    Self: BincodeWriterFor<T>, 

type Error = Box<ErrorKind, Global>

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

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

Attempts to prepare the Sink to receive a value.

fn start_send(self: Pin<&mut Self>, item: T) -> 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(())).

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

Flush any remaining output from this sink.

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

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

impl<W, T, D> Unpin for AsyncBincodeWriter<W, T, D> where
    W: Unpin,