Struct tokio_serde::FramedWrite

pub struct FramedWrite<T, U, S> where
    T: Sink,  { /* fields omitted */ }

Adapts a buffer sink to a value sink by serializing the values.

The provided buffer sink will received buffer values containing the serialized value. Each buffer contains exactly one value. This sink will be responsible for writing these buffers to an AsyncWrite using some sort of framing strategy. The specific framing strategy is left up to the implementor. One option would be to use length_delimited provided by tokio-io.

Methods

impl<T, U, S> FramedWrite<T, U, S> where
    T: Sink<SinkItem = BytesMut>,
    S: Serializer<U>,
    S::Error: Into<T::SinkError>, 

fn new(inner: T, serializer: S) -> Self

Creates a new FramedWrite with the given buffer sink and serializer.

impl<T: Sink, U, S> FramedWrite<T, U, S>

fn get_ref(&self) -> &T

Returns a reference to the underlying sink wrapped by FramedWrite.

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

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

Returns a mutable reference to the underlying sink wrapped by FramedWrite.

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

fn into_inner(self) -> T

Consumes the FramedWrite, returning its underlying sink.

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

Trait Implementations

impl<T, U, S> Sink for FramedWrite<T, U, S> where
    T: Sink<SinkItem = BytesMut>,
    S: Serializer<U>,
    S::Error: Into<T::SinkError>, 

type SinkItem = U

The type of value that the sink accepts.

type SinkError = T::SinkError

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

fn start_send(
    &mut self,
    item: Self::SinkItem
) -> StartSend<Self::SinkItem, Self::SinkError>

Begin the process of sending a value to the sink.

fn poll_complete(&mut self) -> Poll<(), Self::SinkError>

Flush all output from this sink, if necessary.

fn close(&mut self) -> Poll<(), Self::SinkError>

A method to indicate that no more values will ever be pushed into this sink.

fn wait(self) -> Wait<Self>

Creates a new object which will produce a synchronous sink.

fn with<U, F, Fut>(self, f: F) -> With<Self, U, F, Fut> where
    F: FnMut(U) -> Fut,
    Fut: IntoFuture<Item = Self::SinkItem>,
    <Fut as IntoFuture>::Error: From<Self::SinkError>, 

Composes a function in front of the sink.

fn with_flat_map<U, F, St>(self, f: F) -> WithFlatMap<Self, U, F, St> where
    F: FnMut(U) -> St,
    St: Stream<Item = Self::SinkItem, Error = Self::SinkError>, 

Composes a function in front of the sink.

fn sink_map_err<F, E>(self, f: F) -> SinkMapErr<Self, F> where
    F: FnOnce(Self::SinkError) -> E, 

Transforms the error returned by the sink.

fn sink_from_err<E>(self) -> SinkFromErr<Self, E> where
    E: From<Self::SinkError>, 

Map this sink's error to any error implementing From for this sink's Error, returning a new sink.

fn buffer(self, amt: usize) -> Buffer<Self>

Adds a fixed-size buffer to the current sink.

fn fanout<S>(self, other: S) -> Fanout<Self, S> where
    S: Sink<SinkItem = Self::SinkItem, SinkError = Self::SinkError>,
    Self::SinkItem: Clone, 

Fanout items to multiple sinks.

fn flush(self) -> Flush<Self>

A future that completes when the sink has finished processing all pending requests.

fn send(self, item: Self::SinkItem) -> Send<Self>

A future that completes after the given item has been fully processed into the sink, including flushing.

fn send_all<S>(self, stream: S) -> SendAll<Self, S> where
    S: Stream<Item = Self::SinkItem>,
    Self::SinkError: From<<S as Stream>::Error>, 

A future that completes after the given stream has been fully processed into the sink, including flushing.