Struct Bindings 

pub struct Bindings<const N: usize> { /* private fields */ }

Shared registry of Binding entries across every endpoint and fabric. Persisted as a single TLV blob under BINDINGS_KEY.

N bounds the total number of entries the device can hold. Per Matter Core spec, device-type definitions may prescribe a minimum-per-fabric; the spec also says the total must be min_per_fabric × supported_fabrics — pick N accordingly.

Implementations

impl<const N: usize> Bindings<N>

pub const fn new() -> Bindings<N>

Create an empty registry. Prefer Self::init for non-trivial N so the storage is initialised in BSS.

pub fn init() -> impl Init<Bindings<N>>

Return an in-place initialiser for an empty registry.

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

where S: KvBlobStore,

Re-hydrate the registry from store under BINDINGS_KEY. Call once at startup, before exposing the data model.

pub fn len(&self) -> usize

The total number of Binding entries in the registry, across all local endpoints and fabrics. See Bindings::get.

pub fn is_empty(&self) -> bool

Whether the registry holds no bindings.

pub fn get(&self, index: usize) -> Option<Binding>

The index-th Binding in the registry (across all endpoints and fabrics), cloned out so the registry lock is not held by the caller, or None if index is out of range.

This flat, index-based accessor lets application code iterate the bindings and perform async work (e.g. a remote invoke) per entry without holding the lock across the await. Each Binding carries its local_endpoint and fab_idx, so the caller filters on those itself:

for i in 0..bindings.len() {
    let Some(b) = bindings.get(i) else { break };
    if b.local_endpoint != MY_ENDPOINT { continue; }
    if let (Some(node), Some(ep)) = (b.node, b.endpoint) {
        // lock already released here - safe to await
        let exchange = Exchange::initiate(matter, &crypto, b.fab_idx, node).await?;
        exchange.on_off().toggle(ep).await?;
    }
}

Trait Implementations

impl<const N: usize> Default for Bindings<N>

fn default() -> Bindings<N>

Returns the “default value” for a type.