pub fn from_parts(parts: FramedParts<T, U>) -> Framed<T, U> {
        Framed {
            inner: framed_read2_with_buffer(
                framed_write2_with_buffer(
                    Fuse {
                        io: parts.io,
                        codec: parts.codec,
                    },
                    parts.write_buf,
                ),
                parts.read_buf,
            ),
        }
    }
/// 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.
///
/// [`Stream`]: tokio::stream::Stream
/// [`Sink`]: futures_sink::Sink
/// [`Decoder`]: crate::codec::Decoder
/// [`Encoder`]: crate::codec::Encoder
/// [`into_parts`]: crate::codec::Framed::into_parts()
/// [`split`]: https://docs.rs/futures/0.3/futures/stream/trait.StreamExt.html#method.split


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.


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 from_parts(parts: FramedParts<T, U>) -> Framed<T, U> {
        Framed {
            inner: framed_read2_with_buffer(
                framed_write2_with_buffer(
                    Fuse {
                        io: parts.io,
                        codec: parts.codec,
                    },
                    parts.write_buf,
                ),
                parts.read_buf,
            ),
        }
    }
pub fn from_parts ( parts : FramedParts < T , U > ) -> Framed < T , U > { Framed { inner : framed_read2_with_buffer ( framed_write2_with_buffer ( Fuse { io : parts . io , codec : parts . codec , } , parts . write_buf , ) , parts . read_buf , ) , } }
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.
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 .
parts
FramedParts<T, U>
parts
FramedParts<T, U>