Struct WirelessNetworks 

pub struct WirelessNetworks<const N: usize, T> { /* private fields */ }

A fixed-size storage for wireless networks credentials.

Implementations

impl<const N: usize, T> WirelessNetworks<N, T>

where T: WirelessNetwork,

pub const fn new() -> WirelessNetworks<N, T>

pub fn init() -> impl Init<WirelessNetworks<N, T>>

pub fn reset(&mut self)

Reset the state

pub async fn reset_persist<S>( &mut self, kv: S, buf: &mut [u8], ) -> Result<(), Error>

where S: KvBlobStore,

Remove all networks from the provided BLOB store and from memory

Arguments

• store: the BLOB store to remove the networks from
• buf: a temporary buffer to use for removing the networks

pub async fn load_persist<S>( &mut self, kv: S, buf: &mut [u8], ) -> Result<(), Error>

where S: KvBlobStore,

Load all networks from the provided BLOB store

Arguments

• store: the BLOB store to load the networks from
• buf: a temporary buffer to use for loading the networks

pub fn load(&mut self, data: &[u8]) -> Result<(), Error>

Load the state from a byte slice.

Arguments

• data: The byte slice to load the state from

pub fn store(&self, buf: &mut [u8]) -> Result<usize, Error>

Store the state into a byte slice.

Arguments

• buf: The byte slice to store the state into

Returns the number of bytes written into the buffer.

pub fn networks<F>(&self, f: F) -> Result<(), Error>

where F: FnMut(&T) -> Result<(), Error>,

Iterate over the registered network credentials

Arguments

• f: A closure that will be called for each network registered in the storage

pub fn network<F>(&self, network_id: &[u8], f: F) -> Result<u8, NetworksError>

where F: FnOnce(&T) -> Result<(), Error>,

Get the credentials of a network by its ID

Arguments

• network_id: The ID of the network to get
• f: A closure that will be called with the credentials of the network, if the network exists

Returns the index of the network in the storage if the network exists, NetworkError::NetworkIdNotFound otherwise

pub fn next_network<F>( &self, last_network_id: Option<&[u8]>, f: F, ) -> Result<bool, Error>

where F: FnOnce(&T) -> Result<(), Error>,

Get the next network credentials after the one with the given ID

Arguments

• after_network_id: The ID of the network to get the next one after. If no network with the provided network ID exists, the first network in the storage will be returned.

pub fn add_or_update<A, U>( &mut self, network_id: &[u8], add: A, update: U, ) -> Result<u8, NetworksError>

where A: Init<T, Error>, U: FnOnce(&mut T) -> Result<(), Error>,

Add or update a network in the storage

Arguments

• network_id: The ID of the network to add or update
• add: An in-place initializer for the network to add. The initializer will be used only if a network with the provided network ID does not exist in the storage
• update: A closure that will be called with the network to update. The closure will be called only if a network with the provided network ID exists in the storage

pub fn reorder( &mut self, index: u8, network_id: &[u8], ) -> Result<u8, NetworksError>

Reorder a network in the storage

Arguments

• index: The new index of the network
• network_id: The ID of the network to reorder

Returns the new index of the network in the storage, if a network with the provided ID exists or NetworkError::NetworkIdNotFound otherwise

pub fn remove(&mut self, network_id: &[u8]) -> Result<u8, NetworksError>

Remove a network from the storage

Arguments

• network_id: The ID of the network to remove

Returns the index of the network in the storage if the network exists and was removed, NetworkError::NetworkIdNotFound otherwise

pub fn managed(&self) -> bool

pub fn set_managed(&mut self, managed: bool)

Trait Implementations

impl<const N: usize, T> Clone for WirelessNetworks<N, T>

where T: Clone,

fn clone(&self) -> WirelessNetworks<N, T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const N: usize, T> Debug for WirelessNetworks<N, T>

where T: Debug,

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

Formats the value using the given formatter.

impl<const N: usize, T> Default for WirelessNetworks<N, T>

where T: WirelessNetwork,

fn default() -> WirelessNetworks<N, T>

Returns the “default value” for a type.

impl<const N: usize, T> Networks for WirelessNetworks<N, T>

where T: WirelessNetwork,

fn max_networks(&self) -> Result<u8, Error>

Return the maximum number of networks supported by the implementation

fn networks( &self, f: &mut dyn FnMut(&[u8]) -> Result<(), Error>, ) -> Result<(), Error>

Iterate over the networks recorded in the implementation and call the provided function for each network

fn creds( &self, network_id: &[u8], f: &mut dyn FnMut(&WirelessCreds<'_>) -> Result<(), Error>, ) -> Result<u8, NetworksError>

Get the credentials for the given network ID by calling the provided function

fn next_creds( &self, last_network_id: Option<&[u8]>, f: &mut dyn FnMut(&WirelessCreds<'_>) -> Result<(), Error>, ) -> Result<bool, Error>

Return the next credentials after the ones corresponding to the given network ID by calling the provided function

fn enabled(&self) -> Result<bool, Error>

Return whether the network interface is enabled

fn set_enabled(&mut self, _enabled: bool) -> Result<(), Error>

Set the network interface enabled or disabled

fn add_or_update( &mut self, creds: &WirelessCreds<'_>, ) -> Result<u8, NetworksError>

Add or update the credentials for the given network ID

fn reorder(&mut self, index: u8, network_id: &[u8]) -> Result<u8, NetworksError>

Reorder the network with the given index

fn remove(&mut self, network_id: &[u8]) -> Result<u8, NetworksError>

Remove the network with the given network ID

fn managed(&self) -> Result<bool, Error>

Return whether the networks store is in “managed” state.

fn set_managed(&mut self, managed: bool) -> Result<(), Error>

Set the managed state of the networks store (see managed).

fn reset(&mut self) -> Result<(), Error>

Reset the networks to the initial state, removing all recorded network credentials

fn load(&mut self, data: &[u8]) -> Result<(), Error>

Load the networks’ credentials from the given data

fn save(&self, buf: &mut [u8]) -> Result<Option<usize>, Error>

Save the networks’ credentials into the given buffer and return the number of bytes written or None if the networks do not need persistence.