Struct asynchronous_codec::FramedWrite

pub struct FramedWrite<T, E> { /* private fields */ }

A Sink of frames encoded to an AsyncWrite.

Example

use bytes::Bytes;
use asynchronous_codec::{FramedWrite, BytesCodec};
use futures::SinkExt;

let mut buf = Vec::new();
let mut framed = FramedWrite::new(&mut buf, BytesCodec {});

let bytes = Bytes::from("Hello World!");
framed.send(bytes.clone()).await?;

assert_eq!(&buf[..], &bytes[..]);

Implementations

impl<T, E> FramedWrite<T, E> where
    T: AsyncWrite,
    E: Encoder, 

pub fn new(inner: T, encoder: E) -> Self

Creates a new FramedWrite transport with the given Encoder.

pub fn from_parts(_: FramedWriteParts<T, E>) -> Self

Creates a new FramedWrite from FramedWriteParts.

See also FramedWrite::into_parts.

pub fn send_high_water_mark(&self) -> usize

High-water mark for writes, in bytes

The send high-water mark prevents the FramedWrite from accepting additional messages to send when its buffer exceeds this length, in bytes. Attempts to enqueue additional messages will be deferred until progress is made on the underlying AsyncWrite. This applies back-pressure on fast senders and prevents unbounded buffer growth.

See set_send_high_water_mark().

pub fn set_send_high_water_mark(&mut self, hwm: usize)

Sets high-water mark for writes, in bytes

The send high-water mark prevents the FramedWrite from accepting additional messages to send when its buffer exceeds this length, in bytes. Attempts to enqueue additional messages will be deferred until progress is made on the underlying AsyncWrite. This applies back-pressure on fast senders and prevents unbounded buffer growth.

The default high-water mark is 2^17 bytes. Applications which desire low latency may wish to reduce this value. There is little point to increasing this value beyond your socket’s SO_SNDBUF size. On linux, this defaults to 212992 bytes but is user-adjustable.

pub fn into_parts(self) -> FramedWriteParts<T, E>

Consumes the FramedWrite, returning its parts such that a new FramedWrite may be constructed, possibly with a different encoder.

See also FramedWrite::from_parts.

pub fn into_inner(self) -> T

Consumes the FramedWrite, returning its underlying I/O stream.

Note that data that has already been written but not yet flushed is dropped. To retain any such potentially buffered data, use FramedWrite::into_parts().

pub fn encoder(&self) -> &E

Returns a reference to the underlying encoder.

Note that care should be taken to not tamper with the underlying encoder as it may corrupt the stream of frames otherwise being worked with.

pub fn encoder_mut(&mut self) -> &mut E

Returns a mutable reference to the underlying encoder.

Note that care should be taken to not tamper with the underlying encoder as it may corrupt the stream of frames otherwise being worked with.

Trait Implementations

impl<T: Debug, E: Debug> Debug for FramedWrite<T, E>

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

Formats the value using the given formatter.

impl<T, E> Deref for FramedWrite<T, E>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<T, E> DerefMut for FramedWrite<T, E>

fn deref_mut(&mut self) -> &mut T

Mutably dereferences the value.

impl<T, E> Sink<<E as Encoder>::Item> for FramedWrite<T, E> where
    T: AsyncWrite + Unpin,
    E: Encoder, 

type Error = E::Error

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

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

Attempts to prepare the Sink to receive a value.

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

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<'__pin, T, E> Unpin for FramedWrite<T, E> where
    __Origin<'__pin, T, E>: Unpin,