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 fn load_persist<S>(&self, store: S, buf: &mut [u8]) -> Result<(), Error>

where S: KvBlobStore,

Re-hydrate the registry from store under BINDINGS_KEY.

Called on startup via the LifecycleOp::Startup lifecycle operation delivered to the BindingHandler instance(s) borrowing this registry.

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

where S: KvBlobStore,

Reset the registry to empty and remove its persisted blob from store (under BINDINGS_KEY).

Called on factory reset via the LifecycleOp::FactoryReset lifecycle operation delivered to the BindingHandler instance(s) borrowing this registry.

pub fn remove_for_fabric(&self, fab_idx: NonZero<u8>) -> bool

Drop every binding belonging to fab_idx, returning whether anything was removed.

Called on fabric removal via the LifecycleOp::FabricRemoval lifecycle operation delivered to the BindingHandler instance(s) borrowing this registry. Idempotent, since each borrowing handler instance receives the (broadcast) lifecycle operation.

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.