Struct canadensis::register::basic::ValidatedRegister

pub struct ValidatedRegister<T, V = fn(_: &T) -> bool> { /* private fields */ }

A register with a validation function that can reject invalid write operations

Each write operation is checked with the validator. If the validator returns false, the value of the register does not change.

Examples

fn is_finite_float(value: &f32) -> bool {
    !(value.is_infinite() || value.is_nan())
}
let mut finite_float_register =
    ValidatedRegister::new("test.float", true, true, is_finite_float);
assert!(finite_float_register
    .write(&Value::Real32(Real32 { value: heapless::Vec::from_slice(&[37.0]).unwrap() }))
    .is_ok());
assert!(finite_float_register
    .write(&Value::Real32(Real32 {
        value: heapless::Vec::from_slice(&[f32::INFINITY]).unwrap()}
    ))
    .is_err());
assert!(finite_float_register
    .write(&Value::Real32(Real32 {
        value:heapless::Vec::from_slice(&[f32::NEG_INFINITY]).unwrap()}
    ))
    .is_err());
assert!(finite_float_register
    .write(&Value::Real32(Real32 {
        value: heapless::Vec::from_slice(&[f32::NAN]).unwrap()}
    ))
    .is_err());

Implementations

impl<T, V> ValidatedRegister<T, V> where
    T: Default, 

pub fn new(
    name: &'static str,
    mutable: bool,
    persistent: bool,
    validator: V
) -> Self

Creates a register containing the default value of type T

The validator should consider T::default() to be valid.

impl<T, V> ValidatedRegister<T, V>

pub fn with_value(
    name: &'static str,
    mutable: bool,
    persistent: bool,
    value: T,
    validator: V
) -> Self

Creates a register with the provided initial value

The validator should consider the provided value to be valid

pub fn value(&self) -> &T

Returns a reference to the value of this register

pub fn value_mut(&mut self) -> &mut T

Returns a mutable reference to the value of this register

pub fn set_value(&mut self, value: T)

Sets the value of this register

Trait Implementations

impl<T, V> Debug for ValidatedRegister<T, V> where
    T: Debug, 

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

Formats the value using the given formatter.

impl<T, V> Register for ValidatedRegister<T, V> where
    T: RegisterType + Clone,
    V: Validator<T>, 

fn name(&self) -> &str

Returns the name of this register

fn access(&self) -> Access

Returns information about how this register can be accessed

fn read(&self) -> Value

Reads this register and returns its value

fn write(&mut self, value: &Value) -> Result<(), WriteError>

Writes the value of this register