Struct SharedStack

pub struct SharedStack<'a, T> { /* private fields */ }

Single-thread shared reference to an internal network stack implementation.

This can only be created by calling SharableStack::acquire()

Trait Implementations

impl<'a, T> TcpClientStack for SharedStack<'a, T>

where T: TcpClientStack,

type TcpSocket = <T as TcpClientStack>::TcpSocket

The type returned when we create a new TCP socket

type Error = <T as TcpClientStack>::Error

The type returned when we have an error

fn socket(&mut self) -> Result<Self::TcpSocket, Self::Error>

Open a socket for usage as a TCP client.

fn connect( &mut self, socket: &mut Self::TcpSocket, address: SocketAddr, ) -> Result<(), Error<<T as TcpClientStack>::Error>>

Connect to the given remote host and port.

fn send( &mut self, socket: &mut Self::TcpSocket, data: &[u8], ) -> Result<usize, Error<<T as TcpClientStack>::Error>>

Write to the stream.

fn receive( &mut self, socket: &mut Self::TcpSocket, data: &mut [u8], ) -> Result<usize, Error<<T as TcpClientStack>::Error>>

Receive data from the stream.

fn close(&mut self, socket: Self::TcpSocket) -> Result<(), Self::Error>

Close an existing TCP socket.

impl<'a, T> TcpFullStack for SharedStack<'a, T>

where T: TcpFullStack,

fn bind( &mut self, socket: &mut Self::TcpSocket, port: u16, ) -> Result<(), <T as TcpClientStack>::Error>

Create a new TCP socket and bind it to the specified local port.

fn listen( &mut self, socket: &mut Self::TcpSocket, ) -> Result<(), <T as TcpClientStack>::Error>

Begin listening for connection requests on a previously-bound socket.

fn accept( &mut self, socket: &mut Self::TcpSocket, ) -> Result<(<T as TcpClientStack>::TcpSocket, SocketAddr), Error<<T as TcpClientStack>::Error>>

Accept an active connection request on a listening socket.

impl<'a, T> UdpClientStack for SharedStack<'a, T>

where T: UdpClientStack,

type Error = <T as UdpClientStack>::Error

The type returned when we have an error

type UdpSocket = <T as UdpClientStack>::UdpSocket

The type returned when we create a new UDP socket

fn socket(&mut self) -> Result<Self::UdpSocket, Self::Error>

Allocate a socket for further use.

fn connect( &mut self, socket: &mut Self::UdpSocket, address: SocketAddr, ) -> Result<(), Self::Error>

Connect a UDP socket with a peer using a dynamically selected port.

fn send( &mut self, socket: &mut Self::UdpSocket, data: &[u8], ) -> Result<(), Error<<T as UdpClientStack>::Error>>

Send a datagram to the remote host.

fn receive( &mut self, socket: &mut Self::UdpSocket, data: &mut [u8], ) -> Result<(usize, SocketAddr), Error<<T as UdpClientStack>::Error>>

Read a datagram the remote host has sent to us.

fn close(&mut self, socket: Self::UdpSocket) -> Result<(), Self::Error>

Close an existing UDP socket.

impl<'a, T> UdpFullStack for SharedStack<'a, T>

where T: UdpFullStack,

fn bind( &mut self, socket: &mut Self::UdpSocket, local_port: u16, ) -> Result<(), Self::Error>

Bind a UDP socket with a specified port

fn send_to( &mut self, socket: &mut Self::UdpSocket, remote: SocketAddr, buffer: &[u8], ) -> Result<(), Error<<T as UdpClientStack>::Error>>

Send a packet to a remote host/port.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 4 bytes