Struct breadx::connection::BufConnection

pub struct BufConnection<C: ?Sized> { /* private fields */ }

A wrapper around a Connection that buffers all of the I/O.

System calls for I/O are expensive, while reading to and writing from memory is not. This type aims to provide a simple wrapper around a Connection that buffers all of the I/O. It serves a similar purpose to BufReader and BufWriter, but for Connections.

If the Connection is already in memory, then BufReader serves no purpose. In addition, programs that make larger reads/writes tend to lose the advantage of buffering. However, smaller, more frequent reads are common in X11, so this type is useful in general.

Example

use breadx::connection::{BufConnection, Connection, StdConnection};
use std::net::TcpStream;

// create a connection that isn't buffered
let socket = TcpStream::connect("localhost:6000")?;
let connection = StdConnection::new(socket);

// create a connection that is buffered
let mut connection = BufConnection::new(connection);

let (mut buf1, mut buf2) = ([0u8; 16], [0u8; 16]);

// these two reads would normally result in two syscalls
// however, with buffering, only one syscall occurs
connection.recv_slice(&mut buf1)?;
connection.recv_slice(&mut buf2)?;

Implementations

impl<C> BufConnection<C>

pub fn new(conn: C) -> Self

Create a new BufConnection from a given connection.

Example

use breadx::connection::{BufConnection, Connection, StdConnection};
use std::net::TcpStream;

let socket = TcpStream::connect("localhost:6000")?;
let connection = StdConnection::new(socket);
let connection = BufConnection::new(connection);

pub fn with_capacity(
    read_capacity: usize,
    write_capacity: usize,
    conn: C
) -> Self

Create a new BufConnection from a given connection, with the given read and write capacities.

This can be useful if you expect your program to use different amounts of read and write data than normal ones do.

Example

use breadx::connection::{BufConnection, Connection, StdConnection};
use std::net::TcpStream;

let socket = TcpStream::connect("localhost:6000")?;
let connection = StdConnection::new(socket);
let connection = BufConnection::with_capacity(1024, 2048, connection);

Trait Implementations

impl<C: ?Sized> AsMut<C> for BufConnection<C>

fn as_mut(&mut self) -> &mut C

Converts this type into a mutable reference of the (usually inferred) input type.

impl<C: AsRawFd + ?Sized> AsRawFd for BufConnection<C>

fn as_raw_fd(&self) -> RawFd

Extracts the raw file descriptor.

impl<C: ?Sized> AsRef<C> for BufConnection<C>

fn as_ref(&self) -> &C

Converts this type into a shared reference of the (usually inferred) input type.

impl<Conn: Connection + ?Sized> Connection for BufConnection<Conn>

fn recv_slices_and_fds(
    &mut self,
    slices: &mut [IoSliceMut<'_>],
    fds: &mut Vec<Fd>
) -> Result<usize>

Read data to a series of I/O slices and a buffer for file descriptors.

fn recv_slice_and_fds(
    &mut self,
    slice: &mut [u8],
    fds: &mut Vec<Fd>
) -> Result<usize>

Read data to a single I/O slice and a buffer for file descriptors.

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

Read data for a single I/O slice.

fn non_blocking_recv_slices_and_fds(
    &mut self,
    slices: &mut [IoSliceMut<'_>],
    fds: &mut Vec<Fd>
) -> Result<usize>

Receive data from the X11 server into a set of I/O slices, in a non-blocking manner.

fn non_blocking_recv_slice_and_fds(
    &mut self,
    slice: &mut [u8],
    fds: &mut Vec<Fd>
) -> Result<usize>

Receive data from the X11 server into a single slice, in a non-blocking manner.

fn send_slices_and_fds(
    &mut self,
    slices: &[IoSlice<'_>],
    fds: &mut Vec<Fd>
) -> Result<usize>

Write a series of I/O slices and a series of file descriptors to the X11 server.

fn send_slices(&mut self, slices: &[IoSlice<'_>]) -> Result<usize>

Write a series of I/O slices to the X11 server.

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

Write a slice of data to the X11 server.

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

Flush all data in this connection’s buffer.

fn shutdown(&self) -> Result<()>

Shutdown this connection.

impl<C> From<C> for BufConnection<C>

fn from(conn: C) -> Self

Converts to this type from the input type.