common/types: move stuff from requests to types

src/common/types.rs

@@ -1,19 +1,29 @@
 mod absolute_relative_song_position;
 mod audio;
 mod bool_or_oneshot;
+mod group_type;
 mod one_or_range;
+mod replay_gain_mode_mode;
+mod save_mode;
+mod seek_mode;
 mod subsystem;
 mod tag;
 mod time_interval;
+mod volume_value;
 mod window_range;
 
 pub use absolute_relative_song_position::AbsouluteRelativeSongPosition;
 pub use audio::Audio;
 pub use bool_or_oneshot::BoolOrOneshot;
+pub use group_type::GroupType;
 pub use one_or_range::OneOrRange;
+pub use replay_gain_mode_mode::ReplayGainModeMode;
+pub use save_mode::SaveMode;
+pub use seek_mode::SeekMode;
 pub use subsystem::SubSystem;
 pub use tag::Tag;
 pub use time_interval::TimeInterval;
+pub use volume_value::VolumeValue;
 pub use window_range::WindowRange;
 
 pub type SongPosition = u32;

src/common/types/group_type.rs

@@ -0,0 +1,43 @@
+use std::str::FromStr;
+
+use serde::{Deserialize, Serialize};
+
+// TODO: fill out
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub enum GroupType {
+    Artist,
+    Album,
+    AlbumArtist,
+    Date,
+    Genre,
+    Track,
+    Composer,
+    Performer,
+    Conductor,
+    Comment,
+    Disc,
+    Filename,
+    Any,
+}
+
+impl FromStr for GroupType {
+    type Err = ();
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "artist" => Ok(Self::Artist),
+            "album" => Ok(Self::Album),
+            "albumartist" => Ok(Self::AlbumArtist),
+            "date" => Ok(Self::Date),
+            "genre" => Ok(Self::Genre),
+            "track" => Ok(Self::Track),
+            "composer" => Ok(Self::Composer),
+            "performer" => Ok(Self::Performer),
+            "conductor" => Ok(Self::Conductor),
+            "comment" => Ok(Self::Comment),
+            "disc" => Ok(Self::Disc),
+            "filename" => Ok(Self::Filename),
+            "any" => Ok(Self::Any),
+            _ => Err(()),
+        }
+    }
+}

src/common/types/replay_gain_mode_mode.rs

@@ -0,0 +1,23 @@
+use std::str::FromStr;
+
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub enum ReplayGainModeMode {
+    Off,
+    Track,
+    Album,
+    Auto,
+}
+impl FromStr for ReplayGainModeMode {
+    type Err = ();
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "off" => Ok(Self::Off),
+            "track" => Ok(Self::Track),
+            "album" => Ok(Self::Album),
+            "auto" => Ok(Self::Auto),
+            _ => Err(()),
+        }
+    }
+}

src/common/types/save_mode.rs

@@ -0,0 +1,21 @@
+use std::str::FromStr;
+
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub enum SaveMode {
+    Create,
+    Append,
+    Replace,
+}
+impl FromStr for SaveMode {
+    type Err = ();
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "create" => Ok(Self::Create),
+            "append" => Ok(Self::Append),
+            "replace" => Ok(Self::Replace),
+            _ => Err(()),
+        }
+    }
+}

src/common/types/seek_mode.rs

@@ -0,0 +1,8 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub enum SeekMode {
+    Relative,
+    RelativeReverse,
+    Absolute,
+}

src/common/types/volume_value.rs

@@ -0,0 +1,26 @@
+use std::str::FromStr;
+
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct VolumeValue(u32);
+impl VolumeValue {
+    pub fn new(volume: u32) -> Result<Self, ()> {
+        match volume {
+            0..=100 => Ok(Self(volume)),
+            _ => Err(()),
+        }
+    }
+}
+impl From<VolumeValue> for u32 {
+    fn from(val: VolumeValue) -> Self {
+        val.0
+    }
+}
+impl FromStr for VolumeValue {
+    type Err = ();
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let volume = s.parse().map_err(|_| ())?;
+        VolumeValue::new(volume)
+    }
+}