State Pattern: "Music Player"

Author: fadeevab

Cargo.toml

@@ -22,4 +22,5 @@ members = [
   "behavioral/mediator",
   "behavioral/memento",
   "behavioral/observer",
+  "behavioral/state",
 ]

behavioral/command/Cargo.toml

@@ -9,4 +9,3 @@ path = "main.rs"
 
 [dependencies]
 cursive = {version = "0.19", default-features = false, features = ["termion-backend"]}
-owning_ref = "0.4"

behavioral/state/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+edition = "2021"
+name = "state"
+version = "0.1.0"
+
+[[bin]]
+name = "state"
+path = "main.rs"
+
+[dependencies]
+cursive = {version = "0.19", default-features = false, features = ["termion-backend"]}

behavioral/state/README.md

@@ -0,0 +1,22 @@
+# State
+
+State Pattern reminds a finite-state machine, but each state is represented by
+a separate trait (with a common supertrait) and there are transitions between these
+state traits.
+
+The State Pattern is described in detail in The Rust Book:
+https://doc.rust-lang.org/book/ch17-03-oo-design-patterns.html
+
+## Run
+
+```bash
+cargo run --bin state
+```
+
+Press buttons, ESC for exit, enjoy!
+
+## Screenshots
+
+|                                |                                |
+| ------------------------------ | ------------------------------ |
+| ![Stopped](images/stopped.png) | ![Playing](images/playing.png) |

behavioral/state/images/playing.png

@@ -0,0 +1,53 @@
+mod player;
+mod state;
+
+use cursive::{
+    views::{Dialog, TextView},
+    Cursive, event::Key, view::Nameable,
+};
+use player::Player;
+use state::{State, StoppedState};
+
+struct PlayerApplication {
+    player: Player,
+    state: Box<dyn State>,
+}
+
+fn main() {
+    let mut app = cursive::default();
+
+    app.set_user_data(PlayerApplication {
+        player: Player::default(),
+        state: Box::new(StoppedState),
+    });
+
+    app.add_layer(
+        Dialog::around(TextView::new("Press Play").with_name("Player Status"))
+            .title("Music Player")
+            .button("Play", |s| execute(s, "Play"))
+            .button("Stop", |s| execute(s, "Stop"))
+            .button("Prev", |s| execute(s, "Prev"))
+            .button("Next", |s| execute(s, "Next")),
+    );
+
+    app.add_global_callback(Key::Esc, |s| s.quit());
+
+    app.run();
+}
+
+fn execute(s: &mut Cursive, button: &'static str) {
+    let PlayerApplication {mut player, mut state} = s.take_user_data().unwrap();
+    let mut view = s.find_name::<TextView>("Player Status").unwrap();
+
+    state = match button {
+        "Play" => state.play(&mut player),
+        "Stop" => state.stop(&mut player),
+        "Prev" => state.prev(&mut player),
+        "Next" => state.next(&mut player),
+        _ => unreachable!(),
+    };
+
+    state.render(&player, &mut view);
+
+    s.set_user_data(PlayerApplication {player, state});
+}

behavioral/state/images/stopped.png

@@ -0,0 +1,66 @@
+pub struct Track {
+    pub title: String,
+    pub duration: u32,
+    cursor: u32,
+}
+
+impl Track {
+    pub fn new(title: &'static str, duration: u32) -> Self {
+        Self {
+            title: title.into(),
+            duration,
+            cursor: 0,
+        }
+    }
+}
+
+pub struct Player {
+    playlist: Vec<Track>,
+    current_track: usize,
+    _volume: u8,
+}
+
+impl Default for Player {
+    fn default() -> Self {
+        Self {
+            playlist: vec![
+                Track::new("Track 1", 180),
+                Track::new("Track 2", 165),
+                Track::new("Track 3", 197),
+                Track::new("Track 4", 205),
+            ],
+            current_track: 0,
+            _volume: 25,
+        }
+    }
+}
+
+impl Player {
+    pub fn next_track(&mut self) {
+        self.current_track = (self.current_track + 1) % self.playlist.len();
+    }
+
+    pub fn prev_track(&mut self) {
+        self.current_track = (self.playlist.len() + self.current_track - 1) % self.playlist.len();
+    }
+
+    pub fn play(&mut self) {
+        self.track_mut().cursor = 10; // Playback imitation.
+    }
+
+    pub fn pause(&mut self) {
+        self.track_mut().cursor = 43; // Paused at some moment.
+    }
+
+    pub fn rewind(&mut self) {
+        self.track_mut().cursor = 0;
+    }
+
+    pub fn track(&self) -> &Track {
+        &self.playlist[self.current_track]
+    }
+
+    fn track_mut(&mut self) -> &mut Track {
+        &mut self.playlist[self.current_track]
+    }
+}

behavioral/state/main.rs

@@ -0,0 +1,96 @@
+use cursive::views::TextView;
+
+use crate::player::Player;
+
+pub struct StoppedState;
+pub struct PausedState;
+pub struct PlayingState;
+
+pub trait State {
+    fn play(self: Box<Self>, player: &mut Player) -> Box<dyn State>;
+    fn stop(self: Box<Self>, player: &mut Player) -> Box<dyn State>;
+    fn render(&self, player: &Player, view: &mut TextView);
+}
+
+impl State for StoppedState {
+    fn play(self: Box<Self>, player: &mut Player) -> Box<dyn State> {
+        player.play();
+
+        // Stopped -> Playing.
+        Box::new(PlayingState)
+    }
+
+    fn stop(self: Box<Self>, _: &mut Player) -> Box<dyn State> {
+        // Change no state.
+        self
+    }
+
+    fn render(&self, _: &Player, view: &mut TextView) {
+        view.set_content("[Stopped] Press 'Play'")
+    }
+}
+
+impl State for PausedState {
+    fn play(self: Box<Self>, player: &mut Player) -> Box<dyn State> {
+        player.pause();
+
+        // Paused -> Playing.
+        Box::new(PlayingState)
+    }
+
+    fn stop(self: Box<Self>, player: &mut Player) -> Box<dyn State> {
+        player.pause();
+        player.rewind();
+
+        // Paused -> Stopped.
+        Box::new(StoppedState)
+    }
+
+    fn render(&self, player: &Player, view: &mut TextView) {
+        view.set_content(format!(
+            "[Paused] {} - {} sec",
+            player.track().title,
+            player.track().duration
+        ))
+    }
+}
+
+impl State for PlayingState {
+    fn play(self: Box<Self>, _: &mut Player) -> Box<dyn State> {
+        // Playing -> Paused.
+        Box::new(PausedState)
+    }
+
+    fn stop(self: Box<Self>, player: &mut Player) -> Box<dyn State> {
+        player.pause();
+        player.rewind();
+
+        // Playing -> Stopped.
+        Box::new(StoppedState)
+    }
+
+    fn render(&self, player: &Player, view: &mut TextView) {
+        view.set_content(format!(
+            "[Playing] {} - {} sec",
+            player.track().title,
+            player.track().duration
+        ))
+    }
+}
+
+// Default "next" and "prev" implementations for the trait.
+impl dyn State {
+    pub fn next(self: Box<Self>, player: &mut Player) -> Box<dyn State> {
+        player.next_track();
+
+        // Change no state.
+        self
+    }
+
+    pub fn prev(self: Box<Self>, player: &mut Player) -> Box<dyn State> {
+        player.prev_track();
+
+        // Change no state.
+        self
+    }
+}