Struct QueueManager 

pub struct QueueManager {
    items: Vec<MediaItem>,
    current_index: Option<usize>,
    shuffle: bool,
    repeat: RepeatMode,
    shuffle_order: Vec<usize>,
    history: Vec<usize>,
    context: QueueContext,
}

Queue manager for playlist functionality

TRACES: UR-005, UR-015 | DR-005, DR-020

Fields

items: Vec<MediaItem>

All items in the queue

current_index: Option<usize>

Current item index

shuffle: bool

Whether shuffle is enabled

repeat: RepeatMode

Current repeat mode

shuffle_order: Vec<usize>

Shuffled order of indices (used when shuffle is on)

history: Vec<usize>

History of played indices (for going back with shuffle)

context: QueueContext

Context for the queue (album, playlist, or custom) Used for remote playback transfer to maintain album/playlist context

Implementations

impl QueueManager

pub fn new() -> Self

pub fn items(&self) -> &[MediaItem]

Get all items in the queue

pub fn items_mut(&mut self) -> &mut [MediaItem]

Mutable access to queue items.

Used to re-point streaming entries at a completed local download without disturbing queue order, shuffle state, or the current index.

pub fn current_index(&self) -> Option<usize>

Get the current item index

pub fn current(&self) -> Option<&MediaItem>

Get the current item

pub fn is_shuffle(&self) -> bool

Check if shuffle is enabled

pub fn repeat_mode(&self) -> RepeatMode

Get the current repeat mode

pub fn context(&self) -> &QueueContext

Get the current queue context (album, playlist, or custom)

pub fn set_context(&mut self, context: QueueContext)

Set the queue context

pub fn set_queue(&mut self, items: Vec<MediaItem>, start_index: usize)

Set the queue with new items (resets context to Custom)

pub fn set_queue_with_context( &mut self, items: Vec<MediaItem>, start_index: usize, context: QueueContext, )

Set the queue with new items and explicit context

pub fn clear(&mut self)

Clear the queue entirely, returning it to the empty state.

Used when playback genuinely stops (sleep timer fires, or the queue ends with repeat off) so the frontend’s currentQueueItem becomes null and the mini player hides. History and shuffle order are reset too.

pub fn add(&mut self, items: Vec<MediaItem>, position: AddPosition)

Add items to the queue

pub fn remove(&mut self, index: usize) -> Option<MediaItem>

Remove an item from the queue

pub fn next(&mut self) -> Option<&MediaItem>

Move to the next item

pub fn previous(&mut self) -> Option<&MediaItem>

Move to the previous item

pub fn skip_to(&mut self, index: usize) -> Option<&MediaItem>

Skip to a specific index

pub fn toggle_shuffle(&mut self)

Toggle shuffle mode

pub fn cycle_repeat(&mut self)

Cycle through repeat modes

pub fn has_next(&self) -> bool

Check if there’s a next item available

pub fn has_previous(&self) -> bool

Check if there’s a previous item available

pub fn get_upcoming(&self, count: usize) -> Vec<&MediaItem>

Get the next N upcoming items (for preloading) Returns items that will play after the current item, respecting shuffle order

pub fn move_item(&mut self, from_index: usize, to_index: usize) -> bool

Move an item from one index to another

pub fn update_current_stream_url(&mut self, new_url: String) -> bool

Update the stream URL of the current item (for transcoded seeking) Returns true if the update was successful

fn generate_shuffle_order( &self, length: usize, start_index: Option<usize>, ) -> Vec<usize>

Generate a shuffle order, optionally starting from a specific index

Trait Implementations

impl Clone for QueueManager

fn clone(&self) -> QueueManager

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for QueueManager

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

Formats the value using the given formatter.

impl Default for QueueManager

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for QueueManager

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl NamedType for QueueManager

fn sid() -> SpectaID

fn named_data_type( type_map: &mut TypeCollection, generics: &[DataType], ) -> NamedDataType

this is equivalent to [Type::inline] but returns a [NamedDataType] instead.

fn definition_named_data_type(type_map: &mut TypeCollection) -> NamedDataType

this is equivalent to [Type::definition] but returns a [NamedDataType] instead.

impl Serialize for QueueManager

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Type for QueueManager

fn inline(type_map: &mut TypeCollection, generics: Generics<'_>) -> DataType

Returns the definition of a type using the provided generics.

fn reference(type_map: &mut TypeCollection, generics: &[DataType]) -> Reference

Generates a datatype corresponding to a reference to this type, as determined by its category. Getting a reference to a type implies that it should belong in the type map (since it has to be referenced from somewhere), so the output of definition will be put into the type map.

impl Flatten for QueueManager