Struct IoBuf

pub struct IoBuf<S> {
    pub in_buf: Buf,
    pub out_buf: Buf,
    /* private fields */
}

A wrapper for full-duplex stream

Fields

in_buf: Buf

out_buf: Buf

Implementations

impl<S> IoBuf<S>

Main trait of a stream (meaning socket) with input and output buffers

This is ought to be similar to tokio_core::Io but with buffers

pub fn new(sock: S) -> IoBuf<S>

Create a new IoBuf object with empty buffers

pub fn read(&mut self) -> Result<usize, Error>

where S: AsyncRead,

Read a chunk of data into a buffer

The data just read can then be found in self.in_buf.

This method does just one read. Because you are ought to try parse request after every read rather than reading a lot of the data in memory.

This method returns 0 when no bytes are read, both when WouldBlock occurred and when connection has been closed. You may then use self.done() to distinguish from these conditions.

pub fn flush(&mut self) -> Result<(), Error>

where S: AsyncWrite,

Write data in the output buffer to actual stream

You should put the data to be sent into self.out_buf before flush

pub fn done(&self) -> bool

Returns true when connection is closed by peer

pub fn flushed(self) -> Flushed<S>

where S: AsyncWrite,

Returns a future which resolves to this stream when output buffer is flushed

pub fn framed<C: Encode + Decode>(self, codec: C) -> Framed<S, C>

where Self: Sized, S: AsyncRead + AsyncWrite,

Provides a Stream and Sink interface for reading and writing to this IoBuf 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 Encode and Decode traits:

• Encode interprets frames we want to send into bytes;
• Decode interprets incoming bytes into a stream of 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 split(self) -> (WriteBuf<S>, ReadBuf<S>)

where S: AsyncRead + AsyncWrite,

Trait Implementations

impl<S: AsRawFd> AsRawFd for IoBuf<S>

fn as_raw_fd(&self) -> RawFd

Extracts the raw file descriptor.

impl<S> Debug for IoBuf<S>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<S: AsyncWrite> Write for IoBuf<S>

fn write(&mut self, buf: &[u8]) -> Result<usize, Error>

Writes a buffer into this writer, returning how many bytes were written.

fn flush(&mut self) -> Result<(), Error>

Flushes this output stream, ensuring that all intermediately buffered contents reach their destination.

fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>

Like write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Writer has an efficient write_vectored implementation.

fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>

Attempts to write an entire buffer into this writer.

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>

🔬This is a nightly-only experimental API. (write_all_vectored)

Attempts to write multiple buffers into this writer.

fn write_fmt(&mut self, args: Arguments<'_>) -> Result<(), Error>

Writes a formatted string into this writer, returning any error encountered.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adapter for this instance of Write.