Struct warmy::load::Store

pub struct Store<C, K> { /* fields omitted */ }

Resource store. Responsible for holding and presenting resources.

Methods

impl<C, K> Store<C, K> where
    K: Key, 

pub fn new(opt: StoreOpt<C, K>) -> Result<Self, StoreError<K>>

Create a new store.

Failures

This function will fail if the root path in the StoreOpt doesn’t resolve to a correct canonicalized path.

pub fn sync(&mut self, ctx: &mut C) where
    K: for<'a> From<&'a Path>, 

Synchronize the Store by updating the resources that ought to with a provided context.

Methods from Deref<Target = Storage<C, K>>

pub fn root(&self) -> &Path

The canonicalized root the Storage is configured with.

pub fn get<T>(
    &mut self,
    key: &K,
    ctx: &mut C
) -> Result<Res<T>, StoreErrorOr<T, C, K>> where
    T: Load<C, K>, 

Get a resource from the Storage and return an error if its loading failed.

This function uses the default loading method.

pub fn get_by<T, M>(
    &mut self,
    key: &K,
    ctx: &mut C,
    _: M
) -> Result<Res<T>, StoreErrorOr<T, C, K, M>> where
    T: Load<C, K, M>, 

Get a resource from the Storage by using a specific method and return and error if its loading failed.

pub fn get_proxied<T, P>(
    &mut self,
    key: &K,
    proxy: P,
    ctx: &mut C
) -> Result<Res<T>, StoreError<K>> where
    T: Load<C, K>,
    P: FnOnce() -> T, 

Get a resource from the Storage for the given key. If it fails, a proxied version is used, which will get replaced by the resource once it’s available and reloaded.

This function uses the default loading method.

pub fn get_proxied_by<T, M, P>(
    &mut self,
    key: &K,
    proxy: P,
    ctx: &mut C,
    method: M
) -> Result<Res<T>, StoreError<K>> where
    T: Load<C, K, M>,
    P: FnOnce() -> T, 

Get a resource from the Storage for the given key by using a specific method. If it fails, a proxied version is used, which will get replaced by the resource once it’s available and reloaded.

Trait Implementations

impl<C, K> DerefMut for Store<C, K>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<C, K> Deref for Store<C, K>

type Target = Storage<C, K>

The resulting type after dereferencing.

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

Dereferences the value.