pub fn new(io: T, codec: U) -> Framed<T, U> {
        Framed {
            io,
            codec,
            eof: false,
            is_readable: false,
            read_buf: BytesMut::with_capacity(INITIAL_CAPACITY),
            write_buf: BytesMut::with_capacity(HW),
            write_lw: LW,
            write_hw: HW,
        }
    }
/// Provides a `Stream` and `Sink` interface for reading and writing to this
/// `Io` object, using `Decode` and `Encode` 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.


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.
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 new(io: T, codec: U) -> Framed<T, U> {
        Framed {
            io,
            codec,
            eof: false,
            is_readable: false,
            read_buf: BytesMut::with_capacity(INITIAL_CAPACITY),
            write_buf: BytesMut::with_capacity(HW),
            write_lw: LW,
            write_hw: HW,
        }
    }
pub fn new ( io : T , codec : U ) -> Framed < T , U > { Framed { io , codec , eof : false , is_readable : false , read_buf : BytesMut :: with_capacity ( INITIAL_CAPACITY ) , write_buf : BytesMut :: with_capacity ( HW ) , write_lw : LW , write_hw : HW , } }
Provides a `Stream` and `Sink` interface for reading and writing to this
`Io` object, using `Decode` and `Encode` to read and write the raw data.
Provides a ` Stream ` and ` Sink ` interface for reading and writing to this ` Io ` object using ` Decode ` and ` Encode ` to read and write the raw data .
io
T
codec
U