Struct SharableStack

pub struct SharableStack<T> { /* private fields */ }

Sharable wrapper for a network stack implementation.

An implementation of the stack traits that can contain (and provide provide single-threaded shared access to) another stack implementation. A direct implementation can only be used when owned or with a mutable reference. This implementation will store another implementation internally, and yield an arbitrary number of shared references to it, which themselves implement the stack traits.

use embedded_nal::SharableStack;
let mut driver = SomeNalDriver::new();
// Driver can only be used in one place at a time.
let mut sharable_driver = SharableStack::new(driver);
// Sharable driver can't do anything on its own, but it can create many usable copies.
let mut shared_driver0 = sharable_driver.acquire();
let mut shared_driver1 = sharable_driver.acquire();
// These shared copies can be passed around to other parts of an application's code, and used
// independently.
let mut socket0 = shared_driver0.socket()?;
shared_driver0.connect(&mut socket0, SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(127, 0, 0, 1), 8080)));
// ...

// ... and somewhere else
let mut socket1 = shared_driver1.socket()?;
shared_driver1.connect(&mut socket1, SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(127, 0, 0, 1), 8443)));
// ...

Implementations

impl<T> SharableStack<T>

pub fn new(stack: T) -> Self

Create a new SharedStack that contains and uses some other stack implementation.

pub fn acquire(&self) -> SharedStack<'_, T>

Returns a shared reference to the driver that can be used as a first-class implementation.

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.