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.

Implementations

impl 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 Clone for TBufferChannel

fn clone(&self) -> TBufferChannel

Returns a copy of the value.

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

Performs copy-assignment from source.

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.

fn is_read_vectored(&self) -> bool

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

Determines if this Reader has an efficient read_vectored implementation.

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, Global>) -> 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” adapter 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 adapter which will chain this stream with another.

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

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

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 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 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, 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” adapter for this instance of Write.