Struct FieldCore 

pub struct FieldCore<T> {
    pub signal: Signal<T>,
    pub interceptors: Arc<Mutex<Vec<(u64, Arc<dyn Fn(Change<T>) -> Option<Change<T>> + Send + Sync + 'static>)>>>,
    pub next_interceptor_id: Arc<AtomicUsize>,
    pub intercept_depth: InterceptDepth,
    pub rules: Arc<Mutex<Vec<DeclaredRule<T>>>>,
}

Fields

signal: Signal<T>

interceptors: Arc<Mutex<Vec<(u64, Arc<dyn Fn(Change<T>) -> Option<Change<T>> + Send + Sync + 'static>)>>>

next_interceptor_id: Arc<AtomicUsize>

intercept_depth: InterceptDepth

rules: Arc<Mutex<Vec<DeclaredRule<T>>>>

Implementations

impl<T: Clone + 'static> FieldCore<T>

pub fn new_with_signal(initial: Signal<T>) -> Self

pub fn new(initial: T) -> Self

pub fn rule<F>(&self, rule: F)

where F: Fn(&mut T) -> Result<(), String> + Send + Sync + 'static,

Adds a rule every write has to pass, after the interceptors and for as long as the field lives: there is no handle to take it off.

pub fn ruled(&self, value: &mut T) -> Result<(), String>

Puts value through the declared rules, in the order they were added.

pub fn get(&self) -> T

pub fn subscribe<F>(&self, callback: F) -> SignalSubscription

where F: for<'a> Fn(&'a T) + Send + Sync + 'static,

pub fn subscribe_with_source<F>(&self, callback: F) -> SignalSubscription

where F: for<'a> Fn(&'a T, Option<Uuid>) + Send + Sync + 'static,

pub fn intercept<F>(&self, path: StorePath, callback: F) -> InterceptDisposer

where F: Fn(Change<T>) -> Option<Change<T>> + Send + Sync + 'static,

pub fn run_interceptors( &self, path: StorePath, value: T, source: Option<Uuid>, ) -> Result<Change<T>, Refusal>

Trait Implementations

impl<T> Clone for FieldCore<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.