shukusai 0.0.0

Festival (music player) internals
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

//---------------------------------------------------------------------------------------------------- Use
//use anyhow::{anyhow,bail,ensure};
//use log::{info,error,warn,trace,debug};
use serde::{Serialize,Deserialize};
//use crate::macros::*;
use disk::prelude::*;
use disk::{Bincode,bincode_file};
use std::collections::VecDeque;
use crate::collection::key::{
	QueueKey,
	PlaylistKey,
	Key,
};

//---------------------------------------------------------------------------------------------------- Queue/Playlist
#[derive(Clone,Debug,Hash,PartialEq,Eq,PartialOrd,Ord,Serialize,Deserialize)]
/// Dynamically-sized view into a contiguous [`Key`] sequence
///
/// Both `Queue` and `Playlist` are practically the same thing:
///   - A `Slice` of the `Collection`
///
/// They contain a bunch of `Key`s that point
/// to "segments" of the `Collection` (it's a slice).
///
/// They both are saved to disk via `State` which saves as `state.bin`.
pub struct Slice(VecDeque<Key>);

impl Slice {
	#[inline(always)]
	/// Returns a [`Slice`] with `20` capacity reserved upfront.
	pub fn new() -> Self {
		Self(VecDeque::with_capacity(20))
	}

	#[inline(always)]
	/// Create an empty "dummy" (empty) struct.
	pub const fn dummy() -> Self {
		Self(VecDeque::new())
	}

	/// Allows using `VecDeque` methods.
	#[inline(always)]
	pub const fn inner(&self) -> &VecDeque<Key> {
		&self.0
	}
	#[inline(always)]
	pub fn inner_mut(&mut self) -> &mut VecDeque<Key> {
		&mut self.0
	}

	#[inline(always)]
	pub fn queue(&self, key: QueueKey) -> Key {
		self.0[key.inner()]
	}

	#[inline(always)]
	pub fn playlist(&self, key: PlaylistKey) -> Key {
		self.0[key.inner()]
	}

	// Common functions `VecDeque` functions.
	#[inline(always)]
	pub fn len(&self) -> usize {
		self.0.len()
	}
	#[inline(always)]
	pub fn iter(&self) -> std::collections::vec_deque::Iter<'_, Key> {
		self.0.iter()
	}
	#[inline(always)]
	pub fn is_empty(&self) -> bool {
		self.0.is_empty()
	}
	#[inline(always)]
	pub fn clear(&mut self) {
		self.0.clear();
	}
	#[inline(always)]
	pub fn remove(&mut self, index: usize) -> Option<Key> {
		self.0.remove(index)
	}
	#[inline(always)]
	pub fn push_back(&mut self, key: Key) {
		self.0.push_back(key)
	}
	#[inline(always)]
	pub fn push_front(&mut self, key: Key) {
		self.0.push_front(key)
	}
	#[inline(always)]
	pub fn pop_back(&mut self) -> Option<Key> {
		self.0.pop_back()
	}
	#[inline(always)]
	pub fn pop_front(&mut self) -> Option<Key> {
		self.0.pop_front()
	}
}

impl std::default::Default for Slice {
	#[inline(always)]
	fn default() -> Self {
		Self::new()
	}
}

//---------------------------------------------------------------------------------------------------- TESTS
//#[cfg(test)]
//mod test {
//  #[test]
//  fn __TEST__() {
//  }
//}