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 Component for CacheManifest

where Self: Send + Sync + 'static,

const STORAGE_TYPE: StorageType = ::bevy::ecs::component::StorageType::SparseSet

A constant indicating the storage type used for this component.

type Mutability = Mutable

A marker type to assist Bevy with determining if this component is mutable, or immutable. Mutable components will have Component<Mutability = Mutable>, while immutable components will instead have Component<Mutability = Immutable>.

fn register_required_components( _requiree: ComponentId, required_components: &mut RequiredComponentsRegistrator<'_, '_>, )

Registers required components.

fn clone_behavior() -> ComponentCloneBehavior

Called when registering this component, allowing to override clone function (or disable cloning altogether) for this component.

fn relationship_accessor() -> Option<ComponentRelationshipAccessor<Self>>

Returns ComponentRelationshipAccessor required for working with relationships in dynamic contexts.

fn on_add() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_add ComponentHook for this Component if one is defined.

fn on_insert() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_insert ComponentHook for this Component if one is defined.

fn on_discard() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_discard ComponentHook for this Component if one is defined.

fn on_remove() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_remove ComponentHook for this Component if one is defined.

fn on_despawn() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_despawn ComponentHook for this Component if one is defined.

fn map_entities<E>(_this: &mut Self, _mapper: &mut E)

where E: EntityMapper,

Maps the entities on this component using the given EntityMapper. This is used to remap entities in contexts like scenes and entity cloning. When deriving Component, this is populated by annotating fields containing entities with #[entities]

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

Equality operator ==.

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

Inequality operator !=.

impl Resource for CacheManifest

where Self: Send + Sync + 'static,

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 StructuralPartialEq for CacheManifest