Struct IntermediateCache 

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

A cache without a key selector, whose edits give the keys (IntermediateCache<TObject, TKey>): the cache of the operators that keep items under keys of their own. A clone is a handle to the same cache.

Implementations

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

pub fn new() -> Self

An empty cache (IntermediateCache()).

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

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

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

Runs an edit (Edit(Action<ICacheUpdater>)).

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 (SuspendNotifications).

pub fn add_or_update(&self, item: T, key: K)

Adds item under key, or replaces the item of key (AddOrUpdate(IIntermediateCache, TObject, TKey)).

pub fn clear(&self)

Removes every item (Clear(IIntermediateCache)).

pub fn remove_key(&self, key: K)

Removes the item of key (Remove(IIntermediateCache, TKey)).

pub fn remove_keys(&self, keys: impl IntoIterator<Item = K>)

Removes the items of keys (Remove(IIntermediateCache, IEnumerable<TKey>)).

Trait Implementations

impl<T, K> Clone for IntermediateCache<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> Default for IntermediateCache<T, K>

fn default() -> Self

Returns the “default value” for a type.

impl<T: Clone + 'static, K: Eq + Hash + Clone + 'static> IConnectableCache<T, K> for IntermediateCache<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 IntermediateCache<T, K>

fn dispose(&self)

impl<T: Clone + 'static, K: Eq + Hash + Clone + 'static> IIntermediateCache<T, K> for IntermediateCache<T, K>

fn edit(&self, update: &mut dyn FnMut(&mut dyn ICacheUpdater<T, K>))

Runs an edit; its changes are delivered as one change set when it ends (Edit).

impl<T: Clone + 'static, K: Eq + Hash + Clone + 'static> IObservableCache<T, K> for IntermediateCache<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).