Struct QueueConfig 

#[non_exhaustive]
pub struct QueueConfig<S>
where
    S: HasPool<u8> + HasPool<f32> + Send + Sync + 'static,
{
    pub action_at_item_end: ActionAtItemEnd,
    pub crossfade_settings: CrossfadeSettings,
    pub max_concurrent_loads: NonZeroUsize,
    pub cancel: Option<CancelToken>,
    pub store: Option<AssetStore<S>>,
    pub playback_order: PlaybackOrder,
    pub runtime: Option<Handle>,
    pub player: PlayerImpl<S>,
    pub should_autoplay: bool,
    pub prefetch_duration: f32,
    pub max_history_size: usize,
}

Configuration for a Queue.

Holds queue-level defaults plus the owned PlayerImpl instance whose item list the queue coordinates.

TrackSource::Uri resources share this queue’s store. A caller-supplied ResourceConfig retains its own store.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

action_at_item_end: ActionAtItemEnd

crossfade_settings: CrossfadeSettings

max_concurrent_loads: NonZeroUsize

Max concurrent background prefetch loads. Default: 3.

cancel: Option<CancelToken>

Master cancel for the queue. Some threads the app master so the queue subtree cascades from one app-wide owner; None falls back to a fresh standalone token (test / library use). Must never be None on the production app path.

store: Option<AssetStore<S>>

Shared store used for bare URI track sources.

playback_order: PlaybackOrder

runtime: Option<Handle>

Runtime the queue runs its loads and load completions on. None takes the runtime current where the queue is built; an embedding that drives the queue from threads without one (FFI hosts) passes its own.

player: PlayerImpl<S>

Player owned and decorated by this queue.

should_autoplay: bool

Whether the queue starts playback by itself once the first track appended to a queue with nothing selected finishes loading. Off by default: the embedding decides when playback starts. A document cannot name it, because starting playback is the embedding’s choice.

prefetch_duration: f32

Lead time in seconds before EOF at which the next queued track is preloaded into the audio processor. Default: 3.5. Stays f32 seconds rather than the campaign’s humantime duration convention: the value already reaches 10 setter and 14 read call sites as a bare f32, and converting the type would only churn those for a formatting preference.

max_history_size: usize

Entries the navigation history keeps. Only explicit selections and auto-advances land there, so the default is a listening session’s worth of back-steps; the queue’s own track list is unbounded.

Implementations

impl<S> QueueConfig<S>

where S: HasPool<u8> + HasPool<f32> + Send + Sync + 'static,

pub fn builder() -> QueueConfigBuilder<S>

Create an instance of QueueConfig using the builder syntax

impl<S> QueueConfig<S>

where S: HasPool<u8> + HasPool<f32> + Send + Sync + 'static,

pub fn apply(&mut self, patch: QueueConfigPatch)

Merge what a configuration document said onto this configuration.

A key the document did not name leaves the value already in place.

Trait Implementations

impl<S> Debug for QueueConfig<S>

where S: HasPool<u8> + HasPool<f32> + Send + Sync + 'static,

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

Formats the value using the given formatter.