Struct ObservableCache 

pub struct ObservableCache<T, K> { /* private fields */ }

A cache whose edits and contents can be observed (ObservableCache<TObject, TKey>): the core of SourceCache, and the cache of AsObservableCache.

Implementations

impl<T: Clone + 'static, K: Eq + Hash + Clone + 'static> ObservableCache<T, K>

pub fn new(key_selector: impl Fn(&T) -> K + 'static) -> Self

An empty cache whose items are keyed by key_selector (ObservableCache(Func<TObject, TKey>)).

pub fn without_key_selector() -> Self

A cache without a key selector, for edits that give the keys (ObservableCache(Func<TObject, TKey>? = null)).

pub fn from_source<C: IChangeSet<T, K>>(source: Rc<dyn IObservable<C>>) -> Self

A cache that applies the change sets of source (ObservableCache(IObservable<IChangeSet>)).

pub fn key_selector(&self) -> Option<&KeySelector<T, K>>

The key selector of the cache.

pub fn update_from_source( &self, update: impl FnOnce(&mut dyn ISourceUpdater<T, K>), )

Runs an edit with the cache’s key selector (UpdateFromSource); the changes are delivered once the outermost edit ends.

pub fn update_from_intermediate( &self, update: impl FnOnce(&mut dyn ICacheUpdater<T, K>), )

Runs an edit that gives the keys (UpdateFromIntermediate).

pub fn suspend_count(&self) -> Rc<dyn IDisposable>

Holds back the notifications of count changes until the result is disposed (SuspendCount).

pub fn suspend_notifications(&self) -> Rc<dyn IDisposable>

Holds back the notifications of changes until the result is disposed; the changes made meanwhile are delivered as one change set (SuspendNotifications).

Trait Implementations

impl<T: Clone + 'static, K: Eq + Hash + Clone + 'static> CacheChangeSetSource for ObservableCache<T, K>

type Item = T

The type of the items.

type Key = K

The type of the keys.

fn source_change_sets(&self) -> Rc<dyn IObservable<ChangeSet<T, K>>>

The change sets of the source: the sequence itself, or Connect() of a cache.

impl<T, K> Clone for ObservableCache<T, K>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Clone + 'static, K: Eq + Hash + Clone + 'static> IConnectableCache<T, K> for ObservableCache<T, K>

fn count_changed(&self) -> Rc<dyn IObservable<usize>>

The number of items, now and whenever it changes (CountChanged).

fn connect_with( &self, predicate: Option<Rc<dyn Fn(&T) -> bool>>, suppress_empty_change_sets: bool, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

The items as additions, then the changes, of the items that predicate accepts; empty change sets are left out unless suppress_empty_change_sets is false (Connect).

fn preview_with( &self, predicate: Option<Rc<dyn Fn(&T) -> bool>>, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

The changes before they are applied, while the items are as they were (Preview).

fn watch(&self, key: K) -> Rc<dyn IObservable<Change<T, K>>>

The changes of the item of key (Watch).

fn connect(&self) -> Rc<dyn IObservable<ChangeSet<T, K>>>

The items and their changes (Connect()).

fn connect_filtered( &self, predicate: impl Fn(&T) -> bool + 'static, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

where Self: Sized,

The items that predicate accepts and their changes (Connect(Func<TObject, bool>)).

fn preview(&self) -> Rc<dyn IObservable<ChangeSet<T, K>>>

The changes before they are applied (Preview()).

impl<T: Clone + 'static, K: Eq + Hash + Clone + 'static> IDisposable for ObservableCache<T, K>

fn dispose(&self)

Ends the subscription to the source and completes the observers (Dispose).

impl<T: Clone + 'static, K: Eq + Hash + Clone + 'static> IObservableCache<T, K> for ObservableCache<T, K>

fn count(&self) -> usize

The number of items (Count).

fn items(&self) -> Vec<T>

The items (Items).

fn keys(&self) -> Vec<K>

The keys (Keys).

fn key_values(&self) -> Dictionary<K, T>

The keys and items (KeyValues).

fn lookup(&self, key: &K) -> Option<T>

The item of key (Lookup).