Struct Cache 

pub struct Cache<T>
where
    T: Send + Sync + 'static,
{ /* private fields */ }

This is a cache for items used internally to track which items are already loaded, which are still loading and which are missing.

Implementations

impl<T> Cache<T>

where T: Send + Sync + 'static,

pub fn new_store() -> Store<Cache<T>>

Create a new store of the cache.

pub fn len(&self) -> usize

Length of the cache.

pub fn is_empty(&self) -> bool

pub fn resize(&mut self, len: usize)

Resize the cache to the specified length.

pub fn grow(&mut self, len: usize)

Grow the cache size to the specified length.

pub fn write_loading(this_store: Store<Cache<T>>, range: Range<usize>)

Marks the specified range of items as loading.

pub fn write_loaded( this_store: Store<Cache<T>>, loading_result: Result<LoadedItems<T>, String>, requested_load_range: Range<usize>, )

Called after the loader has finished loading items.

This will update the respective range of items with the loaded data (or errors).

pub fn missing_range(&self, range_to_load: Range<usize>) -> Option<Range<usize>>

Returns the range of items that are missing from the cache inside the given range.

Used to know what items should be loaded and which ones are already loaded or in the process of being loaded. Errored items are not considered missing here.

pub fn clear(this_store: Store<Cache<T>>)

Sets all items in the cache to the placeholder state.

Trait Implementations

impl<T> Debug for Cache<T>

where T: Debug + Send + Sync + 'static,

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

Formats the value using the given formatter.

impl<T> Default for Cache<T>

where T: Send + Sync + 'static,

fn default() -> Cache<T>

Returns the “default value” for a type.

impl<T> Index<Range<usize>> for Cache<T>

where T: Sync + Send,

type Output = [ItemState<T>]

The returned type after indexing.

fn index( &self, index: Range<usize>, ) -> &<Cache<T> as Index<Range<usize>>>::Output

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Cache<T>

where T: Send + Sync,

type Output = ItemState<T>

The returned type after indexing.

fn index(&self, index: usize) -> &<Cache<T> as Index<usize>>::Output

Performs the indexing (container[index]) operation.