# tokio_util::codec::Framed - Rust
API documentation for the Rust `Framed` struct in crate `tokio_util`.
Keywords: rust, rustlang, rust-lang, Framed

# Struct tokio_util::codec::Framed [−] [src]

    pub struct Framed<T, U> { /* fields omitted */ }

A unified `Stream` and `Sink` interface to an underlying I/O object, using the `Encoder` and `Decoder` traits to encode and decode frames.

You can create a `Framed` instance by using the `Decoder::framed` adapter, or by using the `new` function seen below.

## Implementations

### `impl<T, U> Framed<T, U> where
T: AsyncRead + AsyncWrite,` [src]

#### `pub fn new(inner: T, codec: U) -> Framed<T, U>` [src]

Provides a `Stream` and `Sink` interface for reading and writing to this I/O object, using `Decoder` and `Encoder` to read and write the raw data.

Raw I/O objects work with byte sequences, but higher-level code usually wants to batch these into meaningful chunks, called "frames". This method layers framing on top of an I/O object, by using the codec traits to handle encoding and decoding of messages frames. Note that the incoming and outgoing frame types may be distinct.

This function returns a single object that is both `Stream` and `Sink`; grouping this into a single object is often useful for layering things like gzip or TLS, which require both read and write access to the underlying object.

If you want to work more directly with the streams and sink, consider calling `split` on the `Framed` returned by this method, which will break them into separate objects, allowing them to interact more easily.

#### `pub fn with_capacity(inner: T, codec: U, capacity: usize) -> Framed<T, U>` [src]

Provides a `Stream` and `Sink` interface for reading and writing to this I/O object, using `Decoder` and `Encoder` to read and write the raw data, with a specific read buffer initial capacity.

Raw I/O objects work with byte sequences, but higher-level code usually wants to batch these into meaningful chunks, called "frames". This method layers framing on top of an I/O object, by using the codec traits to handle encoding and decoding of messages frames. Note that the incoming and outgoing frame types may be distinct.

This function returns a single object that is both `Stream` and `Sink`; grouping this into a single object is often useful for layering things like gzip or TLS, which require both read and write access to the underlying object.

If you want to work more directly with the streams and sink, consider calling `split` on the `Framed` returned by this method, which will break them into separate objects, allowing them to interact more easily.

### `impl<T, U> Framed<T, U>` [src]

#### `pub fn from_parts(parts: FramedParts<T, U>) -> Framed<T, U>` [src]

Provides a `Stream` and `Sink` interface for reading and writing to this I/O object, using `Decoder` and `Encoder` to read and write the raw data.

Raw I/O objects work with byte sequences, but higher-level code usually wants to batch these into meaningful chunks, called "frames". This method layers framing on top of an I/O object, by using the `Codec` traits to handle encoding and decoding of messages frames. Note that the incoming and outgoing frame types may be distinct.

This function returns a single object that is both `Stream` and `Sink`; grouping this into a single object is often useful for layering things like gzip or TLS, which require both read and write access to the underlying object.

This objects takes a stream and a readbuffer and a writebuffer. These field can be obtained from an existing `Framed` with the `into_parts` method.

If you want to work more directly with the streams and sink, consider calling `split` on the `Framed` returned by this method, which will break them into separate objects, allowing them to interact more easily.

#### `pub fn get_ref(&self) -> &T` [src]

Returns a reference to the underlying I/O stream wrapped by `Framed`.

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

#### `pub fn get_mut(&mut self) -> &mut T` [src]

Returns a mutable reference to the underlying I/O stream wrapped by `Framed`.

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

#### `pub fn get_pin_mut(self: Pin<&mut Self>) -> Pin<&mut T>` [src]

Returns a pinned mutable reference to the underlying I/O stream wrapped by `Framed`.

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

#### `pub fn codec(&self) -> &U` [src]

Returns a reference to the underlying codec wrapped by `Framed`.

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

#### `pub fn codec_mut(&mut self) -> &mut U` [src]

Returns a mutable reference to the underlying codec wrapped by `Framed`.

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

#### `pub fn read_buffer(&self) -> &BytesMut` [src]

Returns a reference to the read buffer.

#### `pub fn read_buffer_mut(&mut self) -> &mut BytesMut` [src]

Returns a mutable reference to the read buffer.

#### `pub fn write_buffer(&self) -> &BytesMut` [src]

Returns a reference to the write buffer.

#### `pub fn write_buffer_mut(&mut self) -> &mut BytesMut` [src]

Returns a mutable reference to the write buffer.

#### `pub fn into_inner(self) -> T` [src]

Consumes the `Framed`, returning its underlying I/O stream.

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

#### `pub fn into_parts(self) -> FramedParts<T, U>` [src]

Consumes the `Framed`, returning its underlying I/O stream, the buffer with unprocessed data, and the codec.

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

## Trait Implementations

### `impl<T, U> Debug for Framed<T, U> where
T: Debug,
U: Debug,` [src]

#### `fn fmt(&self, f: &mut Formatter<'_>) -> Result` [src]

Formats the value using the given formatter. Read more

### `impl<T, I, U> Sink<I> for Framed<T, U> where
T: AsyncWrite,
U: Encoder<I>,
U::Error: From<Error>,` [src]

#### `type Error = U::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>>` [src]

Attempts to prepare the `Sink` to receive a value. Read more

#### `fn start_send(self: Pin<&mut Self>, item: I) -> Result<(), Self::Error>` [src]

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(()))`. Read more

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

Flush any remaining output from this sink. Read more

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

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

### `impl<T, U> Stream for Framed<T, U> where
T: AsyncRead,
U: Decoder,` [src]

#### `type Item = Result<U::Item, U::Error>`

Values yielded by the stream.

#### `fn poll_next(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Option<Self::Item>>` [src]

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. Read more

#### `pub fn size_hint(&self) -> (usize, Option<usize>)` [src]

Returns the bounds on the remaining length of the stream. Read more

### `impl<'__pin, T, U> Unpin for Framed<T, U> where
__Origin<'__pin, T, U>: Unpin,` [src]

## Auto Trait Implementations

### `impl<T, U> RefUnwindSafe for Framed<T, U> where
T: RefUnwindSafe,
U: RefUnwindSafe,` [src]

### `impl<T, U> Send for Framed<T, U> where
T: Send,
U: Send,` [src]

### `impl<T, U> Sync for Framed<T, U> where
T: Sync,
U: Sync,` [src]

### `impl<T, U> UnwindSafe for Framed<T, U> where
T: UnwindSafe,
U: UnwindSafe,` [src]

## Blanket Implementations

### `impl<T> Any for T where
T: 'static + ?Sized,` [src]

#### `pub fn type_id(&self) -> TypeId` [src]

Gets the `TypeId` of `self`. Read more

### `impl<T> Borrow<T> for T where
T: ?Sized,` [src]

#### `pub fn borrow(&self) -> &T` [src]

Immutably borrows from an owned value. Read more

### `impl<T> BorrowMut<T> for T where
T: ?Sized,` [src]

#### `pub fn borrow_mut(&mut self) -> &mut T` [src]

Mutably borrows from an owned value. Read more

### `impl<T> From<T> for T` [src]

#### `pub fn from(t: T) -> T` [src]

Performs the conversion.

### `impl<T, U> Into<U> for T where
U: From<T>,` [src]

#### `pub fn into(self) -> U` [src]

Performs the conversion.

### `impl<T, U> TryFrom<U> for T where
U: Into<T>,` [src]

#### `type Error = Infallible`

The type returned in the event of a conversion error.

#### `pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>` [src]

Performs the conversion.

### `impl<T, U> TryInto<U> for T where
U: TryFrom<T>,` [src]

#### `type Error = <U as TryFrom<T>>::Error`

The type returned in the event of a conversion error.

#### `pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>` [src]

Performs the conversion.

### `impl<S, T, E> TryStream for S where
S: Stream<Item = Result<T, E>> + ?Sized,` [src]

#### `type Ok = T`

The type of successful values yielded by this future

#### `type Error = E`

The type of failures yielded by this future

#### `pub fn try_poll_next(
self: Pin<&mut S>,
cx: &mut Context<'_>
) -> Poll<Option<Result<<S as TryStream>::Ok, <S as TryStream>::Error>>>` [src]

Poll this `TryStream` as if it were a `Stream`. Read more