Struct thrift::transport::TBufferChannel

pub struct TBufferChannel { /* fields omitted */ }

In-memory read and write channel with fixed-size read and write buffers.

On a write bytes are written to the internal write buffer. Writes are no longer accepted once this buffer is full. Callers must empty_write_buffer() before subsequent writes are accepted.

You can set readable bytes in the internal read buffer by filling it with set_readable_bytes(...). Callers can then read until the buffer is depleted. No further reads are accepted until the internal read buffer is replenished again.

Methods

impl TBufferChannel

Important traits for TBufferChannel

impl Read for TBufferChannelimpl Write for TBufferChannel

pub fn with_capacity(
    read_capacity: usize,
    write_capacity: usize
) -> TBufferChannel

Constructs a new, empty TBufferChannel with the given read buffer capacity and write buffer capacity.

pub fn read_bytes(&self) -> Vec<u8>

Return a copy of the bytes held by the internal read buffer. Returns an empty vector if no readable bytes are present.

pub fn empty_read_buffer(&mut self)

Reset the number of readable bytes to zero.

Subsequent calls to read will return nothing.

pub fn set_readable_bytes(&mut self, buf: &[u8]) -> usize

Copy bytes from the source buffer buf into the internal read buffer, overwriting any existing bytes. Returns the number of bytes copied, which is min(buf.len(), internal_read_buf.len()).

pub fn write_bytes(&self) -> Vec<u8>

Return a copy of the bytes held by the internal write buffer. Returns an empty vector if no bytes were written.

pub fn empty_write_buffer(&mut self)

Resets the internal write buffer, making it seem like no bytes were written. Calling write_buffer after this returns an empty vector.

pub fn copy_write_buffer_to_read_buffer(&mut self)

Overwrites the contents of the read buffer with the contents of the write buffer. The write buffer is emptied after this operation.

Trait Implementations

impl TIoChannel for TBufferChannel

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

Split the channel into a readable half and a writable half, where the readable half implements io::Read and the writable half implements io::Write. Returns None if the channel was not initialized, or if it cannot be split safely.

impl Debug for TBufferChannel

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

Formats the value using the given formatter.

impl Read for TBufferChannel

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

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

fn read_vectored(&mut self, bufs: &mut [IoSliceMut]) -> Result<usize, Error>

Like read, except that it reads into a slice of buffers.

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, appending them to 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 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 Write for TBufferChannel

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

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

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

Flush 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 write_all(&mut self, buf: &[u8]) -> Result<(), Error>

Attempts to write an entire buffer into this writer.

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.