Struct NetStack 

pub struct NetStack<R: ScopedRawMutex, P: Profile> { /* private fields */ }

The Ergot Netstack

Implementations

impl<R, P> NetStack<R, P>

where R: ScopedRawMutex + ConstInit, P: Profile + ConstInit,

pub const fn new() -> Self

Create a new, uninitialized NetStack.

Requires that the ScopedRawMutex implements the mutex::ConstInit trait, and the Profile implements the interface_manager::ConstInit trait.

Example

use mutex::raw_impls::cs::CriticalSectionRawMutex as CSRMutex;
use ergot::NetStack;
use ergot::interface_manager::profiles::null::Null;

static STACK: NetStack<CSRMutex, Null> = NetStack::new();

impl<R, P> NetStack<R, P>

where R: ScopedRawMutex + ConstInit, P: Profile,

pub const fn new_with_profile(p: P) -> Self

impl<R, P> NetStack<R, P>

where R: ScopedRawMutex, P: Profile,

pub const fn const_new(r: R, p: P) -> Self

Manually create a new, uninitialized NetStack.

This method is useful if your ScopedRawMutex or Profile do not implement their corresponding ConstInit trait.

In general, this is most often only needed for loom testing, and NetStack::new() should be used when possible.

pub fn manage_profile<F: FnOnce(&mut P) -> U, U>(&self, f: F) -> U

Access the contained Profile.

Access to the Profile is made via the provided closure. The BlockingMutex is locked for the duration of this access, inhibiting all other usage of this NetStack.

This can be used to add new interfaces, obtain metadata, or other actions supported by the chosen Profile.

Example

static STACK: NetStack<CSRMutex, Null> = NetStack::new();

let res = STACK.manage_profile(|im| {
   // The mutex is locked for the full duration of this closure.
   // We can return whatever we want from this context, though not
   // anything borrowed from `im`.
   42
});
assert_eq!(res, 42);

pub fn send_raw( &self, hdr: &HeaderSeq, body: &[u8], source: P::InterfaceIdent, ) -> Result<(), NetStackSendError>

Send a raw (pre-serialized) message.

This interface should almost never be used by end-users, and is instead typically used by interfaces to feed received messages into the NetStack.

pub fn send_ty<T: 'static + Serialize + Clone>( &self, hdr: &Header, t: &T, ) -> Result<(), NetStackSendError>

Send a typed message

pub fn send_bor<T: Serialize>( &self, hdr: &Header, t: &T, ) -> Result<(), NetStackSendError>

pub fn send_err( &self, hdr: &Header, err: ProtocolError, source: Option<P::InterfaceIdent>, ) -> Result<(), NetStackSendError>

pub fn with_sockets<F, U>(&self, f: F) -> Option<U>

where for<'b> F: FnOnce(SocketHeaderIter<'b>) -> U,

Call the given function with an iterator over all discoverable sockets

Returns None if the mutex is already locked.

impl<R, P> NetStack<R, P>

where R: ScopedRawMutex, P: Profile,

pub fn trace_fmt(&self, args: &Arguments<'_>)

Send a trace-level formatted message to the ErgotFmtTxTopic as a broadcast topic message

You can use crate::fmt! or core::format_args! to create the value passed to this function

pub fn debug_fmt(&self, args: &Arguments<'_>)

Send a debug-level formatted message to the ErgotFmtTxTopic as a broadcast topic message

You can use crate::fmt! or core::format_args! to create the value passed to this function

pub fn info_fmt(&self, args: &Arguments<'_>)

Send an info-level formatted message to the ErgotFmtTxTopic as a broadcast topic message

You can use crate::fmt! or core::format_args! to create the value passed to this function

pub fn warn_fmt(&self, args: &Arguments<'_>)

Send a warn-level formatted message to the ErgotFmtTxTopic as a broadcast topic message

You can use crate::fmt! or core::format_args! to create the value passed to this function

pub fn error_fmt(&self, args: &Arguments<'_>)

Send an error-level formatted message to the ErgotFmtTxTopic as a broadcast topic message

You can use crate::fmt! or core::format_args! to create the value passed to this function

pub fn services(&self) -> Services<&Self>

pub fn endpoints(&self) -> Endpoints<&Self>

pub fn topics(&self) -> Topics<&Self>

Trait Implementations

impl<R, P> Default for NetStack<R, P>

where R: ScopedRawMutex + ConstInit, P: Profile + ConstInit,

fn default() -> Self

Returns the “default value” for a type.

impl<R, P> NetStackHandle for &NetStack<R, P>

where R: ScopedRawMutex, P: Profile,

type Mutex = R

type Profile = P

type Target = &NetStack<R, P>

fn stack(&self) -> Self::Target