Struct thrift::transport::TTcpChannel

pub struct TTcpChannel { /* private fields */ }

Bidirectional TCP/IP channel.

Examples

Create a TTcpChannel.

use std::io::{Read, Write};
use thrift::transport::TTcpChannel;

let mut c = TTcpChannel::new();
c.open("localhost:9090").unwrap();

let mut buf = vec![0u8; 4];
c.read(&mut buf).unwrap();
c.write(&vec![0, 1, 2]).unwrap();

Create a TTcpChannel by wrapping an existing TcpStream.

use std::io::{Read, Write};
use std::net::TcpStream;
use thrift::transport::TTcpChannel;

let stream = TcpStream::connect("127.0.0.1:9189").unwrap();

// no need to call c.open() since we've already connected above
let mut c = TTcpChannel::with_stream(stream);

let mut buf = vec![0u8; 4];
c.read(&mut buf).unwrap();
c.write(&vec![0, 1, 2]).unwrap();

Implementations

impl TTcpChannel

pub fn new() -> TTcpChannel

Create an uninitialized TTcpChannel.

The returned instance must be opened using TTcpChannel::open(...) before it can be used.

pub fn with_stream(stream: TcpStream) -> TTcpChannel

Create a TTcpChannel that wraps an existing TcpStream.

The passed-in stream is assumed to have been opened before being wrapped by the created TTcpChannel instance.

pub fn open<A: ToSocketAddrs>(&mut self, remote_address: A) -> Result<()>

Connect to remote_address, which should implement ToSocketAddrs trait.

pub fn close(&mut self) -> Result<()>

Shut down this channel.

Both send and receive halves are closed, and this instance can no longer be used to communicate with another endpoint.

Trait Implementations

impl Debug for TTcpChannel

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

Formats the value using the given formatter.

impl Default for TTcpChannel

fn default() -> TTcpChannel

Returns the “default value” for a type.

impl Read for TTcpChannel

fn read(&mut self, b: &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.

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

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

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

Reads all bytes until EOF in this source, appending them to buf.

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

Reads the exact number of bytes required to fill buf.

fn read_buf(&mut self, buf: BorrowedCursor<'_>) -> Result<(), Error>

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

Pull some bytes from this source into the specified buffer.

fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>

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

Reads the exact number of bytes required to fill cursor.

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

where Self: Sized,

Creates a “by reference” adaptor for this instance of Read.

fn bytes(self) -> Bytes<Self>

where Self: Sized,

Transforms this Read instance to an Iterator over its bytes.

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

where R: Read, Self: Sized,

Creates an adapter which will chain this stream with another.

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

where Self: Sized,

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

impl TIoChannel for TTcpChannel

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 TTcpChannel

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

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

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

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, fmt: 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.