Struct tokio_serde::FramedWrite

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

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.

Implementations

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

pub 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>

pub 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.

pub 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.

pub 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 = Bytes>,
    S: Serializer<U>,
    S::Error: Into<T::SinkError>,

type SinkItem = U

The type of value that the sink accepts.

type SinkError = <T as Sink>::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>where
    Self: Sized,

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>,
    Self: Sized,

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>,
    Self: Sized,

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,
    Self: Sized,

Transforms the error returned by the sink.

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

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>where
    Self: Sized,

Adds a fixed-size buffer to the current sink.

fn flush(self) -> Flush<Self>where
    Self: Sized,

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

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

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>,
    Self: Sized,

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