Struct CacheManifest 

pub struct CacheManifest {
    pub entries: HashMap<String, CacheEntry>,
}

Manifest tracking all cached assets. Persisted as RON on disk.

Fields

entries: HashMap<String, CacheEntry>

Implementations

impl CacheManifest

pub fn load_from_disk(config: &CacheConfig) -> Result<Self, CacheError>

Load the manifest from the filesystem. Returns Default if the file does not exist.

pub fn save_to_disk(&self, config: &CacheConfig) -> Result<(), CacheError>

Persist the manifest to disk as pretty-printed RON.

pub fn store<R: Read>( &mut self, config: &CacheConfig, key: &str, extension: &str, reader: R, max_age: Option<Duration>, ) -> Result<(), CacheError>

Store the contents of reader in the cache under key with the given file extension (e.g. "png"). The file written to disk will be named "{key}.{extension}". Overwrites any existing entry for the same key.

Accepting a Read instead of a byte slice means the data is streamed directly to disk without requiring an intermediate in-memory buffer. Use std::io::Cursor to wrap an existing slice or Vec<u8> when the data is already in memory.

max_age optionally sets a per-entry lifetime. It only takes effect when it exceeds CacheConfig::max_age; an entry cannot shorten its lifetime below the global policy.

pub fn remove( &mut self, config: &CacheConfig, key: &str, ) -> Result<(), CacheError>

Remove a cache entry and delete its file from disk. Returns Ok(()) even if the entry did not exist.

pub fn contains(&self, key: &str) -> bool

Check whether a key is present in the manifest.

pub fn get(&self, key: &str) -> Option<&CacheEntry>

Get the entry for a key, if it exists.

pub fn asset_path(&self, key: &str) -> Option<String>

Return the Bevy asset path suitable for AssetServer::load. Uses the cache:// asset source scheme.

pub fn is_cached(&self, config: &CacheConfig, key: &str) -> bool

Check whether a cached asset exists for key — both in the manifest and on disk. Returns false if the manifest entry is stale (file was deleted externally).

pub fn total_size_bytes(&self) -> u64

Returns the total size of all cached assets in bytes, as recorded in the manifest. This is a sum of CacheEntry::size_bytes across all entries

pub fn load_cached<A: Asset>( &self, config: &CacheConfig, key: &str, asset_server: &AssetServer, ) -> Result<Handle<A>, CacheError>

If a cached file exists for key, load it through the AssetServer and return the typed handle. Returns CacheError::NotFound when there is no manifest entry or the file is missing from disk.

This lets callers skip regenerating a dynamic asset when a valid cached copy is already available:

fn setup(
    manifest: Res<CacheManifest>,
    config: Res<CacheConfig>,
    asset_server: Res<AssetServer>,
) {
    let handle: Handle<Image> = manifest
        .load_cached(&config, "scene_thumb", &asset_server)
        .unwrap_or_else(|_| generate_and_cache_thumbnail(/* … */));
}

pub fn remove_expired(&mut self, config: &CacheConfig) -> usize

Remove expired entries and delete their files. An entry is expired when its age exceeds the effective max-age, which is the greater of CacheConfig::max_age and the entry’s own CacheEntry::max_age_secs (if set). Returns the number of entries removed.

pub fn enforce_max_entries(&mut self, config: &CacheConfig) -> usize

If the manifest exceeds max_entries, evict the oldest entries (by modified_at) until the limit is satisfied. Returns the number of entries removed.

Trait Implementations

impl Clone for CacheManifest

fn clone(&self) -> CacheManifest

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CacheManifest

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

Formats the value using the given formatter.

impl Default for CacheManifest

fn default() -> CacheManifest

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for CacheManifest

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for CacheManifest

fn eq(&self, other: &CacheManifest) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for CacheManifest

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Resource for CacheManifest

where Self: Send + Sync + 'static,

impl StructuralPartialEq for CacheManifest