Struct clint::array::HandlerArray

pub struct HandlerArray<'a> { /* fields omitted */ }

Safely use Handlers by enclosing them in an array.

This type provides a safe wrapper around Handler by ensuring that closures are swapped safely using critical sections, and that the lifetime of those handlers is sufficient by using the inner scope of with_overrides/lock_overrides.

Methods

impl<'a> HandlerArray<'a>

pub const fn new() -> Self

Create a new HandlerArray filled with no-op handlers.

pub fn register<F>(&self, nr: usize, f: &'a mut F) where
    F: FnMut() + Send + 'a, 

Register f for entry nr in this array using the default critical section locker.

pub fn lock_register<F, CS>(&self, cs: &CS, nr: usize, f: &'a mut F) where
    F: FnMut() + Send + 'a,
    CS: CriticalSection, 

Register f for entry nr in this array using cs to create a critical section for updating the array.

pub fn call(&self, nr: usize)

Call the handler for entry nr.

pub fn with_overrides<'b>(&self, f: impl FnOnce(&HandlerArray<'b>))

Create a new array for use in f's scope. The existing handlers can be overridden using register or lock_register. When f exits, all previous handlers are restored.

pub fn lock_overrides<'b, CS>(&self, cs: &CS, f: impl FnOnce(&HandlerArray<'b>)) where
    CS: CriticalSection, 

Same as with_overrides but allows you to specify your own implementation of CriticalSection instead of using the default.

Trait Implementations

impl<'a> Debug for HandlerArray<'a>

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<'a> Sync for HandlerArray<'a>