Struct `SockRef`

struct SockRef<'s> { ... }

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(())
# }

Implementations

`impl Debug for SockRef<'_>`

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

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

fn deref(self: &Self) -> &<Self as >::Target

`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>`

`impl<'s, S> From for SockRef<'s>`

fn from(socket: &'s S) -> Self: The caller must ensure S is actually a socket.

`impl<P, T> Receiver for SockRef<'s>`

`impl<T> Any for SockRef<'s>`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for SockRef<'s>`

fn borrow(self: &Self) -> &T

`impl<T> BorrowMut for SockRef<'s>`

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

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

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T, U> Into for SockRef<'s>`

fn into(self: 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 for SockRef<'s>`

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

`impl<T, U> TryInto for SockRef<'s>`

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