Struct std_embedded_nal_async::Stack

pub struct Stack;

The operating system’s network stack, implementing embedded_nal_async::UdpStack.

The user may instantiate a stack using the Stack::default() function.

The stack can be cloned, as it is not a resource that needs any synchronization. This is not made implicit as Copy, though (although there’s not technical reason not to). That is to alert users to the difficulties that’d arise when copying around a stack rather than using it through some mechanism of synchronization.

Trait Implementations

impl Clone for Stack

fn clone(&self) -> Stack

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Default for Stack

fn default() -> Stack

Returns the “default value” for a type.

impl Dns for Stack

type Error = Error

The type returned when we have an error

async fn get_host_by_name( &self, hostname: &str, addr_type: AddrType ) -> Result<IpAddr, Self::Error>

Resolve the first ip address of a host, given its hostname and a desired address record type to look for

async fn get_host_by_address( &self, addr: IpAddr, result: &mut [u8] ) -> Result<usize, Self::Error>

Resolve the hostname of a host, given its ip address.

impl TcpConnect for Stack

type Error = Error

Error type returned on connect failure.

type Connection<'a> = TcpConnection

Type holding state of a TCP connection. Should close the connection when dropped.

async fn connect<'a>( &'a self, addr: SocketAddr ) -> Result<Self::Connection<'a>, Error>

Connect to the given remote host and port.

impl UdpStack for Stack

type Error = Error

Error type returned on socket creation failure.

type Connected = ConnectedSocket

Eventual socket return type of the [.connect()] method

type UniquelyBound = UniquelyBoundSocket

Eventual socket return type of the [.bind_single()] method

type MultiplyBound = MultiplyBoundSocket

Eventual return type of the [.bind_multiple()] method

async fn connect_from( &self, local: SocketAddr, remote: SocketAddr ) -> Result<(SocketAddr, Self::Connected), Self::Error>

Create a socket that has a fixed remote address.

async fn bind_single( &self, local: SocketAddr ) -> Result<(SocketAddr, Self::UniquelyBound), Self::Error>

Create a socket that has a fixed local address.

async fn bind_multiple( &self, local: SocketAddr ) -> Result<Self::MultiplyBound, Self::Error>

Create a socket that has no single fixed local address.

async fn connect( &self, remote: SocketAddr ) -> Result<(SocketAddr, Self::Connected), Self::Error>

Create a socket that has a fixed remote address.