Struct thrift::transport::TTcpChannel

pub struct TTcpChannel { /* fields omitted */ }

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();

Methods

impl TTcpChannel

Important traits for TTcpChannel

impl Read for TTcpChannelimpl Write for TTcpChannel

pub fn new() -> TTcpChannel

Create an uninitialized TTcpChannel.

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

Important traits for TTcpChannel

impl Read for TTcpChannelimpl Write for TTcpChannel

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(&mut self, remote_address: &str) -> Result<()>

Connect to remote_address, which should have the form host:port.

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 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 Default for TTcpChannel

Important traits for TTcpChannel

impl Read for TTcpChannelimpl Write for TTcpChannel

fn default() -> TTcpChannel

Returns the "default value" for a type.

impl Debug for TTcpChannel

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

Formats the value using the given formatter.

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.

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 TTcpChannel

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