Struct CacheQueue 

pub struct CacheQueue { /* private fields */ }

Resource holding queued asset-save requests.

Assets can be enqueued in two ways:

1. enqueue_reflect — pass any value that implements Reflect. The value will be serialized to RON via Bevy’s ReflectSerializer using the AppTypeRegistry. The type must be registered in the type registry (via app.register_type::<T>()) and should have ReflectSerialize type data (derived automatically for types that implement both Reflect and serde::Serialize).

2. enqueue — pass any [Read]er containing pre-serialized data and a file extension. No reflection or registry required. Use std::io::Cursor in tests or for in-memory data.

Enqueued entries are processed by [process_pending_saves] which runs each frame in PostUpdate.

Implementations

impl CacheQueue

pub fn is_empty(&self) -> bool

Returns true when there are no pending save requests.

pub fn len(&self) -> usize

Returns the number of pending save requests.

pub fn enqueue_reflect( &mut self, value: Box<dyn Reflect>, key: impl Into<String>, extension: impl Into<String>, max_age: Option<Duration>, )

Enqueue a reflected value for caching.

The value will be serialized to RON using Bevy’s ReflectSerializer during [process_pending_saves]. The type must be registered in the AppTypeRegistry.

Example

#[derive(Asset, TypePath, Reflect, serde::Serialize)]
#[reflect(Serialize)]
struct LevelData { tiles: Vec<u32> }

fn cache_level(
    mut pending: ResMut<CacheQueue>,
    assets: Res<Assets<LevelData>>,
    handle: Res<MyLevelHandle>,
) {
    if let Some(level) = assets.get(&handle.0) {
        pending.enqueue_reflect(
            Box::new(level.clone()),
            "level_01",
            "ron",
            None,
        );
    }
}

pub fn enqueue<R: Read + Send + Sync + 'static>( &mut self, key: impl Into<String>, extension: impl Into<String>, reader: R, max_age: Option<Duration>, )

Enqueue a [Read]er for caching.

The caller is responsible for serialization; the data is streamed as-is to {key}.{extension} in the cache directory without buffering the entire payload in memory.

Use std::io::Cursor to wrap in-memory buffers:

Example

fn cache_screenshot(mut pending: ResMut<CacheQueue>) {
    let png_bytes: Vec<u8> = capture_screenshot();
    pending.enqueue("scene_01", "png", std::io::Cursor::new(png_bytes), None);
}

Trait Implementations

impl Default for CacheQueue

fn default() -> CacheQueue

Returns the “default value” for a type.

impl Resource for CacheQueue

where Self: Send + Sync + 'static,