Struct CollectionStore

pub struct CollectionStore<E, MV = NoMac> { /* private fields */ }

Implementations

impl<E, MV> CollectionStore<E, MV>

pub fn new() -> Self

pub fn new_value(collection: Vec<E>) -> Self

pub fn reset(&self)

pub fn invalidate(&self)

pub fn transfer_state(&self) -> TransferState

pub fn set_transfer_state(&self, transfer_state: TransferState)

pub fn reset_transfer_error(&self)

pub fn loaded(&self) -> bool

pub fn loaded_signal(&self) -> impl Signal<Item = bool> + use<E, MV>

pub fn loaded_status(&self) -> Option<StatusCode>

pub fn loaded_status_signal( &self, ) -> impl Signal<Item = Option<StatusCode>> + use<E, MV>

pub fn stored(&self) -> bool

pub fn stored_signal(&self) -> impl Signal<Item = bool> + use<E, MV>

pub fn stored_status(&self) -> Option<StatusCode>

pub fn stored_status_signal( &self, ) -> impl Signal<Item = Option<StatusCode>> + use<E, MV>

pub fn pending(&self) -> bool

pub fn pending_signal(&self) -> impl Signal<Item = bool> + use<E, MV>

pub fn collection(&self) -> &MutableVec<E>

pub fn messages(&self) -> &Messages

pub fn paging(&self) -> &Mutable<Paging>

pub fn is_empty(&self) -> bool

pub fn any<F>(&self, f: F) -> bool

where F: Fn(&E) -> bool,

pub fn all<F>(&self, f: F) -> bool

where F: Fn(&E) -> bool,

pub fn lock_ref(&self) -> MutableVecLockRef<'_, E>

pub fn lock_mut(&self) -> MutableVecLockMut<'_, E>

pub fn inspect<F>(&self, f: F)

where F: FnOnce(&[E]),

pub fn inspect_mut<F>(&self, f: F)

where F: FnOnce(&mut MutableVecLockMut<'_, E>),

pub fn find_map<F, U>(&self, f: F) -> Option<U>

where F: Fn(&E) -> Option<U>,

pub fn map_vec<F, U>(&self, f: F) -> U

where F: FnOnce(&[E]) -> U,

pub fn map_vec_mut<F, U>(&self, f: F) -> U

where F: FnOnce(&mut MutableVecLockMut<'_, E>) -> U,

impl<E, MV> CollectionStore<E, MV>

where E: Copy,

pub fn empty_signal(&self) -> impl Signal<Item = bool> + use<E, MV>

pub fn collection_state_signal( &self, ) -> impl Signal<Item = CollectionState> + use<E, MV>

pub fn find<F>(&self, f: F) -> Option<E>

where F: Fn(&E) -> bool,

pub fn find_inspect_mut<P, F>(&self, predicate: P, f: F) -> Option<bool>

where P: FnMut(&E) -> bool, F: FnMut(&mut E) -> bool,

pub fn find_set<P>(&self, predicate: P, item: E) -> bool

where P: FnMut(&E) -> bool,

pub fn find_set_or_add<P>(&self, predicate: P, item: E)

where P: FnMut(&E) -> bool,

pub fn replace(&self, values: Vec<E>) -> Vec<E>

pub fn remove<P>(&self, predicate: P) -> bool

where P: FnMut(&E) -> bool,

pub fn set_externally_loaded(&self, values: Vec<E>)

pub fn signal_map<F, U>(&self, f: F) -> impl Signal<Item = U> + use<E, MV, F, U>

where F: FnMut(&[E]) -> U,

pub fn signal_vec(&self) -> MutableSignalVec<E>

pub fn signal_vec_filter<F>( &self, f: F, ) -> impl SignalVec<Item = E> + use<E, MV, F>

where F: FnMut(&E) -> bool,

pub fn signal_vec_filter_signal<F, U>( &self, f: F, ) -> impl SignalVec<Item = E> + use<E, MV, F, U>

where F: FnMut(&E) -> U, U: Signal<Item = bool>,

pub fn signal_vec_map<F, U>( &self, f: F, ) -> impl SignalVec<Item = U> + use<E, MV, F, U>

where F: FnMut(E) -> U,

pub fn signal_vec_map_signal<F, U>( &self, f: F, ) -> impl SignalVec<Item = U::Item> + use<E, MV, F, U>

where F: FnMut(E) -> U, U: Signal,

pub fn signal_vec_filter_map<F, U>( &self, f: F, ) -> impl SignalVec<Item = U> + use<E, MV, F, U>

where F: FnMut(E) -> Option<U>,

impl<E, MV> CollectionStore<E, MV>

where E: Clone,

pub fn empty_signal_cloned(&self) -> impl Signal<Item = bool> + use<E, MV>

pub fn collection_state_signal_cloned( &self, ) -> impl Signal<Item = CollectionState> + use<E, MV>

pub fn find_cloned<F>(&self, f: F) -> Option<E>

where F: Fn(&E) -> bool,

pub fn find_inspect_mut_cloned<P, F>(&self, predicate: P, f: F) -> Option<bool>

where P: FnMut(&E) -> bool, F: FnMut(&mut E) -> bool,

pub fn get_cloned(&self) -> Vec<E>

pub fn find_set_cloned<P>(&self, predicate: P, item: E) -> bool

where P: FnMut(&E) -> bool,

pub fn find_set_or_add_cloned<P>(&self, predicate: P, item: E)

where P: FnMut(&E) -> bool,

pub fn replace_cloned(&self, values: Vec<E>) -> Vec<E>

pub fn remove_cloned<P>(&self, predicate: P) -> bool

where P: FnMut(&E) -> bool,

pub fn set_externally_loaded_cloned(&self, values: Vec<E>)

pub fn signal_map_cloned<F, U>( &self, f: F, ) -> impl Signal<Item = U> + use<E, MV, F, U>

where F: FnMut(&[E]) -> U,

pub fn signal_vec_cloned(&self) -> MutableSignalVec<E>

pub fn signal_vec_filter_cloned<F>( &self, f: F, ) -> impl SignalVec<Item = E> + use<E, MV, F>

where F: FnMut(&E) -> bool,

pub fn signal_vec_filter_signal_cloned<F, U>( &self, f: F, ) -> impl SignalVec<Item = E> + use<E, MV, F, U>

where F: FnMut(&E) -> U, U: Signal<Item = bool>,

pub fn signal_vec_map_cloned<F, U>( &self, f: F, ) -> impl SignalVec<Item = U> + use<E, MV, F, U>

where F: FnMut(E) -> U,

pub fn signal_vec_map_signal_cloned<F, U>( &self, f: F, ) -> impl SignalVec<Item = U::Item> + use<E, MV, F, U>

where F: FnMut(E) -> U, U: Signal,

pub fn signal_vec_filter_map_cloned<F, U>( &self, f: F, ) -> impl SignalVec<Item = U> + use<E, MV, F, U>

where F: FnMut(E) -> Option<U>,

impl<E, MV> CollectionStore<E, MV>

where E: Clone, MV: MacVerify,

pub fn load<C>(&self, request: Request<'_>, result_callback: C)

where E: DeserializeOwned + 'static, C: FnOnce(StatusCode) + 'static,

pub fn load_skip_cache<C>(&self, request: Request<'_>, result_callback: C)

where E: DeserializeOwned + 'static, C: FnOnce(StatusCode) + 'static,

pub fn load_merge<F, C>( &self, request: Request<'_>, merge_fn: F, result_callback: C, )

where E: DeserializeOwned + 'static, F: FnMut(Vec<E>) + 'static, C: FnOnce(StatusCode) + 'static,

pub fn store<MS, C>(&self, request: Request<'_>, result_callback: C)

where E: Serialize + DeserializeOwned + 'static, MS: MacSign, C: FnOnce(StatusCode) + 'static,

Trait Implementations

impl<E: Debug, MV: Debug> Debug for CollectionStore<E, MV>

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

Formats the value using the given formatter.

impl<E, MV> Default for CollectionStore<E, MV>

fn default() -> Self

Returns the “default value” for a type.