quing 2.2.1

A (hopefully) minimalist toml based song shuffler
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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//! [I hate myself, for making documentation.]
//!
//! ### How Quing works.
//! Quing works around 2 central structures:
//! - A [`Track`]
//! - A [`Playlist`] (grouping of [`Tracks`], with additional data)
//!
//! [`Track`]: playback::Track
//! [`Tracks`]: playback::Track
//! [`Playlist`]: playback::Playlist
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
use crossbeam_channel::{RecvError, RecvTimeoutError, TryRecvError};
use rodio::{decoder::DecoderError, PlayError, StreamError};
use std::{env::VarError, io::Error as IOError};
use thiserror::Error;
use toml::de::Error as TOMLError;
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// A module for handling and interacting with external devices.
pub mod in_out;

/// SerDe, specifically: TOML, based structure representations of the structures of [`playback`].
pub mod serde;

/// The module responsible for handling the playing of [sources]
///
/// [sources]: rodio::Source
pub mod playback;

/// Implementation utilities.
mod utilities;
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#[derive(Error, Debug)]
/// Errors encountered when
#[doc = env!("CARGO_PKG_NAME")]
/// interacts with [`Vec`]-esque structures.
#[cfg_attr(
	any(debug_assertions, feature = "traits"),
	derive(PartialEq, Eq, PartialOrd, Ord),
	derive(Hash)
)]
pub enum VectorError {
	#[error("Index out of bounds")]
	/// Overflowing an index, because under-flowing an [unsigned integer] based index is impossible.
	///
	/// [unsigned integer]: usize
	OutOfBounds,

	#[error("Empty vector encountered.")]
	/// As the name says.
	Empty,
}

#[derive(Error, Debug)]
#[cfg_attr(
	any(debug_assertions, feature = "traits"),
	derive(PartialEq, Eq, PartialOrd, Ord),
	derive(Hash)
)]
#[derive(Default)]
pub enum ChannelError {
	#[error("A Channel-Timeout occurred.")]
	Timeout,
	#[error("A Channel is empty.")]
	Empty,
	#[error("A Channel disconnected.")]
	#[default]
	Disconnect,
}

#[derive(Error, Debug)]
pub enum Error {
	#[error("IO: {0}")]
	Io(#[from] IOError),

	#[error("Rodio-Decode: {0}")]
	Decode(#[from] DecoderError),
	#[error("Rodio-Play: {0}")]
	Play(#[from] PlayError),
	#[error("Rodio-Stream: {0}")]
	Stream(#[from] StreamError),

	#[error("TOML: {0}")]
	Deserialise(#[from] TOMLError),

	#[error("Variable: {0}")]
	Variable(#[from] VarError),

	#[error("Vector: {0}")]
	Vector(#[from] VectorError),

	#[error("Channel: {0}")]
	Channel(#[from] ChannelError),
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
impl From<RecvTimeoutError> for ChannelError {
	#[inline(always)]
	/// Convert from [`RecvTimoutError`] to [`Self`].
	///
	/// This is a handwritten version of [`thiserror`]'s `Error::from` attribute.
	fn from(error: RecvTimeoutError) -> Self {
		match error {
			RecvTimeoutError::Timeout => Self::Timeout,
			RecvTimeoutError::Disconnected => Self::Disconnect,
		}
	}
}

impl From<()> for ChannelError {
	#[inline(always)]
	/// Convenience to construct a [`Disconnect`].
	///
	/// [`Disconnect`]: Self.Disconnect
	fn from(_: ()) -> Self {
		Self::default()
	}
}

impl From<RecvError> for ChannelError {
	#[inline(always)]
	/// Convert any [`RecvError`] into a [`Disconnect`].
	///
	/// [`Disconnect`]: Self.Disconnect
	fn from(_: RecvError) -> Self {
		().into()
	}
}

impl From<TryRecvError> for ChannelError {
	#[inline(always)]
	/// Convert from [`TryRecvError`] to [`Self`]
	///
	/// This is a handwritten version of [`thiserror`]'s `Error::from` attribute.
	fn from(error: TryRecvError) -> Self {
		match error {
			TryRecvError::Empty => Self::Empty,
			TryRecvError::Disconnected => Self::Disconnect,
		}
	}
}