Struct medea_reactive::ObservableField

pub struct ObservableField<D, S> { /* fields omitted */ }

Reactive cell which emits all modifications to its subscribers.

Subscribing to this field modifications is done with ObservableField::subscribe method.

If you want to get Future which will resolved only when an underlying data of this field will become equal to some value, you can use ObservableField::when or ObservableField::when_eq methods.

Implementations

impl<D> ObservableField<D, RefCell<Vec<UniversalSubscriber<D>>>> where
    D: 'static, 

pub fn new(data: D) -> Self

Returns new ObservableField with subscribable mutations.

Also you can subscribe to concrete mutations with ObservableField::when and ObservableField::when_eq methods.

impl<D, S> ObservableField<D, S> where
    D: 'static,
    S: Whenable<D>, 

pub fn when<F>(
    &self,
    assert_fn: F
) -> LocalBoxFuture<'static, Result<(), DroppedError>> where
    F: Fn(&D) -> bool + 'static, 

Returns Future which will resolve only on modifications that the given assert_fn returns true on.

impl<D: 'static> ObservableField<D, SubStore<D>>

pub fn new(data: D) -> Self

Returns new ObservableField with subscribable mutations.

Also, you can wait for all updates processing by awaiting on ObservableField::when_all_processed().

impl<D> ObservableField<D, SubStore<D>> where
    D: Clone + 'static, 

pub fn subscribe(&self) -> LocalBoxStream<'static, Guarded<D>>

Returns Stream into which underlying data updates (wrapped in the progressable::Guarded) will be emitted.

pub fn when_all_processed(&self) -> Processed<'static>

Returns Future resolving when all data updates will be processed by subscribers.

impl<D> ObservableField<D, RefCell<Vec<UniversalSubscriber<D>, Global>>> where
    D: Clone + 'static, 

pub fn subscribe(&self) -> LocalBoxStream<'static, D>

Returns Stream into which underlying data updates will be emitted.

impl<D, S> ObservableField<D, S> where
    D: PartialEq + 'static,
    S: Whenable<D>, 

pub fn when_eq(
    &self,
    should_be: D
) -> LocalBoxFuture<'static, Result<(), DroppedError>>

Returns Future which will resolve only when an underlying data of this ObservableField will become equal to the provided should_be value.

impl<D, S> ObservableField<D, S> where
    S: OnObservableFieldModification<D>,
    D: Clone + PartialEq, 

pub fn borrow_mut(&mut self) -> MutObservableFieldGuard<'_, D, S>

Returns MutObservableFieldGuard which can be mutably dereferenced to an underlying data.

If some mutation of data happens between calling ObservableField::borrow_mut and dropping of MutObservableFieldGuard, then all subscribers of this ObservableField will be notified about this.

Notification about mutation will be sent only if this field really changed. This will be checked with PartialEq implementation of underlying data.

Trait Implementations

impl<D: Debug, S: Debug> Debug for ObservableField<D, S>

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

Formats the value using the given formatter.

impl<D, S> Deref for ObservableField<D, S>

type Target = D

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<D, S> Display for ObservableField<D, S> where
    D: Display, 

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

Formats the value using the given formatter.