Move SongQueue locking to audio_state.rs

src/audio/audio_state.rs

@@ -18,7 +18,7 @@ use tokio::sync::Mutex;
 use tokio::time::sleep;
 
 pub struct AudioState {
-    queue: SongQueue,
+    queue: Arc<Mutex<SongQueue>>,
     handler: Arc<SerenityMutex<Call>>,
     current_song: Mutex<Option<Song>>,
     track_handle: Mutex<Option<TrackHandle>>,
@@ -31,7 +31,7 @@ pub struct AudioState {
 impl AudioState {
     pub fn new(handler: Arc<SerenityMutex<Call>>, ctx: &Context, msg: &Message) -> Arc<AudioState> {
         let audio_state = AudioState {
-            queue: SongQueue::new(),
+            queue: Arc::new(Mutex::new(SongQueue::new())),
             handler,
             current_song: Mutex::new(None),
             track_handle: Mutex::new(None),
@@ -69,11 +69,12 @@ impl AudioState {
 
     async fn play_audio(audio_state: Arc<AudioState>) {
         let is_looping = audio_state.is_looping.lock().await;
+        let mut queue = audio_state.queue.lock().await;
         let song = if *is_looping {
             let mut current_song = audio_state.current_song.lock().await;
             current_song.take()
         } else {
-            audio_state.queue.pop().await
+            queue.pop().await
         };
         drop(is_looping);
 
@@ -129,7 +130,8 @@ impl AudioState {
     }
 
     pub async fn add_audio(audio_state: Arc<AudioState>, song: Song) {
-        audio_state.queue.push(vec![song]).await;
+        let mut queue = audio_state.queue.lock().await;
+        queue.push(vec![song]).await;
         let current_song = audio_state.current_song.lock().await;
         if current_song.is_none() {
             let audio_state = audio_state.clone();
@@ -154,11 +156,13 @@ impl AudioState {
     }
 
     pub async fn shuffle(audio_state: Arc<AudioState>) -> Result<(), String> {
-        audio_state.queue.shuffle().await
+        let mut queue = audio_state.queue.lock().await;
+        queue.shuffle().await
     }
 
     pub async fn clear(audio_state: Arc<AudioState>) -> Result<(), String> {
-        audio_state.queue.clear().await
+        let mut queue = audio_state.queue.lock().await;
+        queue.clear().await
     }
 
     // on success, returns a bool that specifies whether the queue is now being looped
@@ -180,10 +184,11 @@ impl AudioState {
             Some(song) => song.get_string().await,
             None => "*Not playing*\n".to_string(),
         };
+        let queue = audio_state.queue.lock().await;
         format!(
             "**Current Song:**\n{}\n\n**Queue:**\n{}",
             current_song,
-            audio_state.queue.get_string().await
+            queue.get_string().await
         )
     }
 }

src/audio/song_queue.rs

@@ -1,56 +1,53 @@
 use super::song::Song;
 use rand::seq::SliceRandom;
-use std::{cmp::min, collections::VecDeque, sync::Arc};
-use tokio::sync::Mutex;
+use std::{cmp::min, collections::VecDeque};
+
 pub struct SongQueue {
-    queue: Arc<Mutex<VecDeque<Song>>>,
+    queue: VecDeque<Song>,
 }
 
 impl SongQueue {
     pub fn new() -> SongQueue {
         SongQueue {
-            queue: Arc::new(Mutex::new(VecDeque::new())),
+            queue: VecDeque::new(),
         }
     }
-    pub async fn push(&self, songs: Vec<Song>) {
-        let mut queue = self.queue.lock().await;
+    pub async fn push(&mut self, songs: Vec<Song>) {
         for item in songs.into_iter() {
-            queue.push_back(item);
+            self.queue.push_back(item);
         }
     }
-    pub async fn pop(&self) -> Option<Song> {
-        let mut queue = self.queue.lock().await;
-        queue.pop_front()
+    pub async fn pop(&mut self) -> Option<Song> {
+        self.queue.pop_front()
     }
-    pub async fn shuffle(&self) -> Result<(), String> {
-        let mut queue = self.queue.lock().await;
-        if queue.len() == 0 {
+    pub async fn shuffle(&mut self) -> Result<(), String> {
+        if self.queue.len() == 0 {
             return Err("queue is empty".to_string());
         }
-        queue.make_contiguous().shuffle(&mut rand::thread_rng());
+        self.queue
+            .make_contiguous()
+            .shuffle(&mut rand::thread_rng());
 
         Ok(())
     }
-    pub async fn clear(&self) -> Result<(), String> {
-        let mut queue = self.queue.lock().await;
-        if queue.len() == 0 {
+    pub async fn clear(&mut self) -> Result<(), String> {
+        if self.queue.len() == 0 {
             return Err("queue is empty".to_string());
         };
-        queue.clear();
+        self.queue.clear();
         Ok(())
     }
     pub async fn get_string(&self) -> String {
-        let queue = self.queue.lock().await;
-        if queue.len() == 0 {
+        if self.queue.len() == 0 {
             return "*empty*".to_string();
         };
         let mut s = String::new();
         s.push_str(&format!(
             "*Showing {} of {} songs*\n",
-            min(20, queue.len()),
-            queue.len()
+            min(20, self.queue.len()),
+            self.queue.len()
         ));
-        for (i, song) in queue.iter().take(20).enumerate() {
+        for (i, song) in self.queue.iter().take(20).enumerate() {
             s += &format!("{}: ", i);
             s += &song.get_string().await;
             s += "\n";