Struct SockRef

pub struct SockRef<'s> { /* private fields */ }

A reference to a Socket that can be used to configure socket types other than the Socket type itself.

This allows for example a TcpStream, found in the standard library, to be configured using all the additional methods found in the Socket API.

SockRef can be created from any socket type that implements AsFd (Unix) or AsSocket (Windows) using the From implementation.

Examples

Below is an example of converting a TcpStream into a SockRef.

use std::net::{TcpStream, SocketAddr};

use socket2::SockRef;

# fn main() -> Result<(), Box<dyn std::error::Error>> {
// Create `TcpStream` from the standard library.
let address: SocketAddr = "127.0.0.1:1234".parse()?;
# let b1 = std::sync::Arc::new(std::sync::Barrier::new(2));
# let b2 = b1.clone();
# let handle = std::thread::spawn(move || {
#    let listener = std::net::TcpListener::bind(address).unwrap();
#    b2.wait();
#    let (stream, _) = listener.accept().unwrap();
#    std::thread::sleep(std::time::Duration::from_millis(10));
#    drop(stream);
# });
# b1.wait();
let stream = TcpStream::connect(address)?;

// Create a `SockRef`erence to the stream.
let socket_ref = SockRef::from(&stream);
// Use `Socket::set_tcp_nodelay` on the stream.
socket_ref.set_tcp_nodelay(true)?;
drop(socket_ref);

assert_eq!(stream.nodelay()?, true);
# handle.join().unwrap();
# Ok(())
# }

Trait Implementations

impl Debug for SockRef<'_>

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

impl<'s> Deref for SockRef<'s>

type Target = Socket;
fn deref(&self) -> &Self::Target

impl<'s, S> From<&'s S> for SockRef<'s> where S: AsFd,

fn from(socket: &'s S) -> Self

The caller must ensure S is actually a socket.

Auto Trait Implementations

impl<'s> Freeze for SockRef<'s>

impl<'s> RefUnwindSafe for SockRef<'s>

impl<'s> Send for SockRef<'s>

impl<'s> Sync for SockRef<'s>

impl<'s> Unpin for SockRef<'s>

impl<'s> UnsafeUnpin for SockRef<'s>

impl<'s> UnwindSafe for SockRef<'s>

Blanket Implementations

impl<P, T> Receiver for SockRef<'s> where P: Deref<Target = T> + ?Sized, T: ?Sized,

type Target = T;

impl<T> Any for SockRef<'s> where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for SockRef<'s> where T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for SockRef<'s> where T: ?Sized,

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

impl<T> From<T> for SockRef<'s>

fn from(t: T) -> T

Returns the argument unchanged.

impl<T, U> Into<U> for SockRef<'s> where U: From<T>,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

impl<T, U> TryFrom<U> for SockRef<'s> where U: Into<T>,

type Error = never;
fn try_from(value: U) -> Result<T, never>

impl<T, U> TryInto<U> for SockRef<'s> where U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error;
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>