Struct atm_io_utils::Duplex

pub struct Duplex<R, W> { /* fields omitted */ }

Implements both (Async)Read and (Async)Write by delegating to an (Async)Read and an (Async)Write, taking ownership of both.

Methods

impl<R, W> Duplex<R, W>

fn new(r: R, w: W) -> Duplex<R, W>

Takes ownership of a Read and a Write and creates a new Duplex.

fn get_reader_ref(&self) -> &R

Gets a reference to the underlying reader.

fn get_reader_mut(&mut self) -> &mut R

Gets a mutable reference to the underlying reader.

fn get_writer_ref(&self) -> &W

Gets a reference to the underlying writer.

fn get_writer_mut(&mut self) -> &mut W

Gets a mutable reference to the underlying writer.

fn into_inner(self) -> (R, W)

Unwraps this Duplex, returning the underlying reader and writer.

Trait Implementations

impl<R: Debug, W: Debug> Debug for Duplex<R, W>

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<R: Copy, W: Copy> Copy for Duplex<R, W>

impl<R: Clone, W: Clone> Clone for Duplex<R, W>

fn clone(&self) -> Duplex<R, W>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<R: PartialEq, W: PartialEq> PartialEq for Duplex<R, W>

fn eq(&self, __arg_0: &Duplex<R, W>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, __arg_0: &Duplex<R, W>) -> bool

This method tests for !=.

impl<R: Eq, W: Eq> Eq for Duplex<R, W>

impl<R: Read, W> Read for Duplex<R, W>

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

Pull some bytes from this source into the specified buffer, returning how many bytes were read.

unsafe fn initializer(&self) -> Initializer

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

Determines if this Reader can work with buffers of uninitialized memory.

fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>

Read all bytes until EOF in this source, placing them into buf.

fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>

Read all bytes until EOF in this source, placing them into buf.

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

Read the exact number of bytes required to fill buf.

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

Creates a "by reference" adaptor for this instance of Read.

fn bytes(self) -> Bytes<Self>

Transforms this Read instance to an [Iterator] over its bytes.

fn chars(self) -> Chars<Self>

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

the semantics of a partial read/write of where errors happen is currently unclear and may change

Transforms this Read instance to an [Iterator] over [char]s.

fn chain<R>(self, next: R) -> Chain<Self, R> where
    R: Read, 

Creates an adaptor which will chain this stream with another.

fn take(self, limit: u64) -> Take<Self>

Creates an adaptor which will read at most limit bytes from it.

impl<R: AsyncRead, W> AsyncRead for Duplex<R, W>

unsafe fn prepare_uninitialized_buffer(&self, buf: &mut [u8]) -> bool

Prepares an uninitialized buffer to be safe to pass to read. Returns true if the supplied buffer was zeroed out.

fn read_buf<B>(&mut self, buf: &mut B) -> Result<Async<usize>, Error> where
    B: BufMut, 

Pull some bytes from this source into the specified Buf, returning how many bytes were read.

fn framed<T>(self, codec: T) -> Framed<Self, T> where
    Self: AsyncWrite,
    T: Decoder + Encoder, 

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.

fn split(self) -> (ReadHalf<Self>, WriteHalf<Self>) where
    Self: AsyncWrite, 

Helper method for splitting this read/write object into two halves.

impl<R, W: Write> Write for Duplex<R, W>

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

Write a buffer into this object, returning how many bytes were written.

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

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

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

Attempts to write an entire buffer into this write.

fn write_fmt(&mut self, fmt: Arguments) -> Result<(), Error>

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

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

Creates a "by reference" adaptor for this instance of Write.

impl<R, W: AsyncWrite> AsyncWrite for Duplex<R, W>

fn shutdown(&mut self) -> Poll<(), Error>

Initiates or attempts to shut down this writer, returning success when the I/O connection has completely shut down.

fn write_buf<B>(&mut self, buf: &mut B) -> Result<Async<usize>, Error> where
    B: Buf, 

Write a Buf into this value, returning how many bytes were written.