Struct breadx::connection::StdConnection

#[repr(transparent)]
pub struct StdConnection<C: ?Sized> { /* private fields */ }

A newtype wrapper around a type that implements Connection for certain types in the standard library.

Types within the Rust ecosystem can function as a reliable byte steam. This newtype allows these tpyes to be used in places that expect a Connection. Connection is implemented for types that implement the following traits:

• Read
• Write
• AsRawFd for Unix platforms
• AsRawSocket for Windows platforms

In addition, if Read and Write are implemented for &T, then Connection is implemented for &StdConnection<T>, allowing it to be used in shared contexts.

This type does not preform FD passing. If you need to pass file descriptors, either use NameConnection, SendmsgConnection, or build your own type.

Example

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

let socket = TcpStream::connect("localhost:6000")?;
let mut connection = StdConnection::new(socket);
let mut buf = [0; 1024];
connection.recv_slice(&mut buf)?;

Implementations

impl<C> StdConnection<C>

pub fn new(inner: C) -> Self

Create a new StdConnection wrapping around an existing connection.

Example

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

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

pub fn into_inner(self) -> C

Unwrap this newtype to get the underlying connection.

Example

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

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

// we need the connection back
let socket = connection.into_inner();

impl<C: ?Sized> StdConnection<C>

pub fn get_ref(&self) -> &C

Get a reference to the underlying connection.

Example

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

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

let peer_addr = connection.get_ref().peer_addr()?;
println!("peer address: {}", peer_addr);

pub fn get_mut(&mut self) -> &mut C

Get a mutable reference to the underlying connection.

Example

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

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

let peer_addr = connection.get_mut().peer_addr()?;
println!("peer address: {}", peer_addr);

Trait Implementations

impl<C: ?Sized> AsMut<C> for StdConnection<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 StdConnection<C>

fn as_raw_fd(&self) -> RawFd

Extracts the raw file descriptor.

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

fn as_ref(&self) -> &C

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

impl<C> Borrow<C> for StdConnection<C>

fn borrow(&self) -> &C

Immutably borrows from an owned value.

impl<C> BorrowMut<C> for StdConnection<C>

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

Mutably borrows from an owned value.

impl<C: Clone + ?Sized> Clone for StdConnection<C>

fn clone(&self) -> StdConnection<C>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<C: Read + Write + AsRawFd + ?Sized> Connection for StdConnection<C>

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 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 flush(&mut self) -> Result<()>

Flush all data in this connection’s buffer.

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 shutdown(&self) -> Result<()>

Shutdown this connection.

impl<'a, C: AsRawFd + ?Sized> Connection for &'a StdConnection<C> where
    &'a C: Read + Write, 

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 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 flush(&mut self) -> Result<()>

Flush all data in this connection’s buffer.

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 shutdown(&self) -> Result<()>

Shutdown this connection.

impl<C: Debug> Debug for StdConnection<C>

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

Formats the value using the given formatter.

impl<C: Default + ?Sized> Default for StdConnection<C>

fn default() -> StdConnection<C>

Returns the “default value” for a type.

impl<C> Deref for StdConnection<C>

type Target = C

The resulting type after dereferencing.

fn deref(&self) -> &C

Dereferences the value.

impl<C> DerefMut for StdConnection<C>

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

Mutably dereferences the value.

impl<C> From<C> for StdConnection<C>

fn from(inner: C) -> Self

Converts to this type from the input type.

impl<C: Hash + ?Sized> Hash for StdConnection<C>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl<C: Ord + ?Sized> Ord for StdConnection<C>

fn cmp(&self, other: &StdConnection<C>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl<C: PartialEq + ?Sized> PartialEq<StdConnection<C>> for StdConnection<C>

fn eq(&self, other: &StdConnection<C>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &StdConnection<C>) -> bool

This method tests for !=.

impl<C: PartialOrd + ?Sized> PartialOrd<StdConnection<C>> for StdConnection<C>

fn partial_cmp(&self, other: &StdConnection<C>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<C: Copy + ?Sized> Copy for StdConnection<C>

impl<C: Eq + ?Sized> Eq for StdConnection<C>

impl<C: ?Sized> StructuralEq for StdConnection<C>

impl<C: ?Sized> StructuralPartialEq for StdConnection<C>