boilerplate

src-tauri/src/commands.rs

@@ -1,9 +1,9 @@
 use std::io::Write;
 
-use crate::{model::Filters, Codec, Preprocessing};
+use crate::{filters::Filters, Codec, Preprocessing};
 
 pub trait Command {
-    fn write_as_binary(&self, buf: impl Write) -> Result<(), String>;
+    fn write_as_binary(&self, buf: impl Write);
 }
 
 #[repr(u16)]
@@ -41,10 +41,9 @@ impl GetVersion {
 }
 
 impl Command for GetVersion {
-    fn write_as_binary(&self, mut buf: impl Write) -> Result<(), String> {
+    fn write_as_binary(&self, mut buf: impl Write) {
         let _ = buf.write(&(StructureTypes::GetVersion as u16).to_le_bytes());
         let _ = buf.write(&(4u16).to_le_bytes());
-        Ok(())
     }
 }
 
@@ -57,12 +56,11 @@ impl<'a> SetPreprocessingConfiguration<'a> {
 }
 
 impl Command for SetPreprocessingConfiguration<'_> {
-    fn write_as_binary(&self, mut buf: impl Write) -> Result<(), String> {
+    fn write_as_binary(&self, mut buf: impl Write) {
         let payload = self.0.to_payload();
         let _ = buf.write(&(StructureTypes::PreProcessingConfiguration as u16).to_le_bytes());
         let _ = buf.write(&((4 + payload.len()) as u16).to_le_bytes());
         let _ = buf.write(&payload);
-        Ok(())
     }
 }
 
@@ -75,12 +73,11 @@ impl<'a> SetFilterConfiguration<'a> {
 }
 
 impl Command for SetFilterConfiguration<'_> {
-    fn write_as_binary(&self, mut buf: impl Write) -> Result<(), String> {
-        let payload = self.0.to_payload()?;
+    fn write_as_binary(&self, mut buf: impl Write) {
+        let payload = self.0.to_payload();
         let _ = buf.write(&(StructureTypes::FilterConfiguration as u16).to_le_bytes());
         let _ = buf.write(&((4 + payload.len()) as u16).to_le_bytes());
         let _ = buf.write(&payload);
-        Ok(())
     }
 }
 
@@ -93,12 +90,11 @@ impl<'a> SetPcm3060Configuration<'a> {
 }
 
 impl Command for SetPcm3060Configuration<'_> {
-    fn write_as_binary(&self, mut buf: impl Write) -> Result<(), String> {
+    fn write_as_binary(&self, mut buf: impl Write) {
         let payload = self.0.to_payload();
         let _ = buf.write(&(StructureTypes::Pcm3060Configuration as u16).to_le_bytes());
         let _ = buf.write(&((4 + payload.len()) as u16).to_le_bytes());
         let _ = buf.write(&payload);
-        Ok(())
     }
 }
 
@@ -123,19 +119,18 @@ impl<'a, 'b, 'c> SetConfiguration<'a, 'b, 'c> {
 }
 
 impl Command for SetConfiguration<'_, '_, '_> {
-    fn write_as_binary(&self, mut buf: impl Write) -> Result<(), String> {
+    fn write_as_binary(&self, mut buf: impl Write) {
         let _ = buf.write(&(StructureTypes::SetConfiguration as u16).to_le_bytes());
         let _ = buf.write(
             &((16
-                + self.filter.0.to_payload()?.len()
+                + self.filter.0.to_payload().len()
                 + self.preprocessing.0.to_payload().len()
                 + self.codec.0.to_payload().len()) as u16)
                 .to_le_bytes(),
         );
         let _ = &self.preprocessing.write_as_binary(&mut buf);
         let _ = &self.filter.write_as_binary(&mut buf);
         let _ = &self.codec.write_as_binary(&mut buf);
-        Ok(())
     }
 }
 
@@ -148,10 +143,9 @@ impl FactoryReset {
 }
 
 impl Command for FactoryReset {
-    fn write_as_binary(&self, mut buf: impl Write) -> Result<(), String> {
+    fn write_as_binary(&self, mut buf: impl Write) {
         let _ = buf.write(&(StructureTypes::FactoryReset as u16).to_le_bytes());
         let _ = buf.write(&(4u16).to_le_bytes());
-        Ok(())
     }
 }
 
@@ -164,10 +158,9 @@ impl SaveConfiguration {
 }
 
 impl Command for SaveConfiguration {
-    fn write_as_binary(&self, mut buf: impl Write) -> Result<(), String> {
+    fn write_as_binary(&self, mut buf: impl Write) {
         let _ = buf.write(&(StructureTypes::SaveConfiguration as u16).to_le_bytes());
         let _ = buf.write(&(4u16).to_le_bytes());
-        Ok(())
     }
 }
 
@@ -180,10 +173,9 @@ impl GetStoredConfiguration {
 }
 
 impl Command for GetStoredConfiguration {
-    fn write_as_binary(&self, mut buf: impl Write) -> Result<(), String> {
+    fn write_as_binary(&self, mut buf: impl Write) {
         let _ = buf.write(&(StructureTypes::GetStoredConfiguration as u16).to_le_bytes());
         let _ = buf.write(&(4u16).to_le_bytes());
-        Ok(())
     }
 }
 
@@ -194,7 +186,7 @@ mod tests {
     #[test]
     fn get_version_works() {
         let mut buf: Vec<u8> = Vec::new();
-        GetVersion::new().write_as_binary(&mut buf).unwrap();
+        GetVersion::new().write_as_binary(&mut buf);
         assert!(buf.len() > 0, "Command didn't write anything");
         assert_eq!(buf.as_slice(), &[3, 0, 4, 0], "Wrong data");
     }
@@ -203,7 +195,7 @@ mod tests {
     fn preprocessing_works() {
         let mut buf = Vec::new();
         let config = Preprocessing::new(0.0, 0.0, false);
-        SetPreprocessingConfiguration::new(&config).write_as_binary(&mut buf).unwrap();
+        SetPreprocessingConfiguration::new(&config).write_as_binary(&mut buf);
         assert!(buf.len() > 0, "Command didn't write anything");
         assert_eq!(
             buf.as_slice(),
@@ -216,7 +208,7 @@ mod tests {
     fn filter_works() {
         let mut buf = Vec::new();
         let config = Filters::default();
-        SetFilterConfiguration::new(&config).write_as_binary(&mut buf).unwrap();
+        SetFilterConfiguration::new(&config).write_as_binary(&mut buf);
         assert!(buf.len() > 0, "Command didn't write anything");
         assert_eq!(buf.as_slice(), &[1, 2, 4, 0], "Wrong data");
     }
@@ -225,7 +217,7 @@ mod tests {
     fn codec_works() {
         let mut buf = Vec::new();
         let config = Codec::default();
-        SetPcm3060Configuration::new(&config).write_as_binary(&mut buf).unwrap();
+        SetPcm3060Configuration::new(&config).write_as_binary(&mut buf);
         assert!(buf.len() > 0, "Command didn't write anything");
         assert_eq!(buf.as_slice(), &[2, 2, 8, 0, 0, 0, 0, 0], "Wrong data")
     }
@@ -240,7 +232,7 @@ mod tests {
         let prep = SetPreprocessingConfiguration::new(&prep_config);
         let filters = SetFilterConfiguration::new(&filters_config);
         let codec = SetPcm3060Configuration::new(&codec_config);
-        SetConfiguration::new(prep, filters, codec).write_as_binary(&mut buf).unwrap();
+        SetConfiguration::new(prep, filters, codec).write_as_binary(&mut buf);
         assert!(buf.len() > 0, "Command didn't write anything");
         assert_eq!(
             buf.as_slice(),
@@ -255,23 +247,23 @@ mod tests {
     #[test]
     fn reset_works() {
         let mut buf = Vec::new();
-        FactoryReset::new().write_as_binary(&mut buf).unwrap();
+        FactoryReset::new().write_as_binary(&mut buf);
         assert!(buf.len() > 0, "Command didn't write anything");
         assert_eq!(buf.as_slice(), &[8, 0, 4, 0], "Wrong data")
     }
 
     #[test]
     fn save_config_works() {
         let mut buf = Vec::new();
-        SaveConfiguration::new().write_as_binary(&mut buf).unwrap();
+        SaveConfiguration::new().write_as_binary(&mut buf);
         assert!(buf.len() > 0, "Command didn't write anything");
         assert_eq!(buf.as_slice(), &[7, 0, 4, 0], "Wrong data")
     }
 
     #[test]
     fn get_config_works() {
         let mut buf = Vec::new();
-        GetStoredConfiguration::new().write_as_binary(&mut buf).unwrap();
+        GetStoredConfiguration::new().write_as_binary(&mut buf);
         assert!(buf.len() > 0, "Command didn't write anything");
         assert_eq!(buf.as_slice(), &[6, 0, 4, 0], "Wrong data")
     }

src-tauri/src/dto.rs

@@ -0,0 +1,176 @@
+use std::marker::PhantomData;
+
+use serde::{Deserialize, Serialize};
+
+use crate::{
+    filters::{
+        Allpass, BandpassPeak, BandpassSkirt, CustomIIRFilter, FilterConfig, FilterName, Filters,
+        FreqGainQualFilter, FreqQualFilter, HighShelf, Highpass, LowShelf, Lowpass, Notch, Peaking,
+        SavedFilter,
+    },
+    Codec, Preprocessing, Config,
+};
+
+#[derive(Serialize, Deserialize, Default, Debug)]
+pub struct ConfigDTO {
+    pub preprocessing: Preprocessing,
+    pub filters: FiltersDTO,
+    pub codec: Codec,
+}
+
+impl TryInto<Config> for ConfigDTO {
+    type Error = String;
+    fn try_into(self) -> Result<Config, Self::Error> {
+        Ok(Config::new(self.preprocessing, self.filters.try_into()?, self.codec))
+    }
+}
+
+impl From<Config> for ConfigDTO {
+    fn from(value: Config) -> Self {
+        Self { preprocessing: value.preprocessing, filters: value.filters.into(), codec: value.codec }
+    }
+}
+
+#[derive(Serialize, Deserialize, Default, Debug)]
+pub struct FiltersDTO(Vec<SavedFilterDTO>);
+
+impl FiltersDTO {
+    pub fn add(&mut self, filter: FilterConfigDTO) {
+        self.0.push(SavedFilterDTO { enabled: true, filter: filter })
+    }
+}
+
+impl TryInto<Filters> for FiltersDTO {
+    type Error = String;
+    fn try_into(self) -> Result<Filters, Self::Error> {
+        self.0.into_iter().map(|f| f.try_into()).collect()
+    }
+}
+
+impl From<Filters> for FiltersDTO {
+    fn from(value: Filters) -> Self {
+        value.into_iter().collect()
+    }
+}
+
+impl FromIterator<SavedFilter> for FiltersDTO {
+    fn from_iter<T: IntoIterator<Item = SavedFilter>>(iter: T) -> Self {
+        iter.into_iter().map(|f| f.into()).collect()
+    }
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+struct SavedFilterDTO {
+    enabled: bool,
+
+    #[serde(flatten)]
+    filter: FilterConfigDTO,
+}
+
+impl TryInto<SavedFilter> for SavedFilterDTO {
+    type Error = String;
+    fn try_into(self) -> Result<SavedFilter, Self::Error> {
+        Ok(SavedFilter::new(self.enabled, self.filter.try_into()?))
+    }
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(tag = "filter_type")]
+pub enum FilterConfigDTO {
+    Lowpass(LowpassFilterDTO),
+    Highpass(HighpassFilterDTO),
+    BandpassSkirt(BandpassSkirtFilterDTO),
+    BandpassPeak(BandpassPeakFilterDTO),
+    Notch(NotchFilterDTO),
+    Allpass(AllpassFilterDTO),
+    Peaking(PeakingFilterDTO),
+    LowShelf(LowShelfFilterDTO),
+    HighShelf(HighShelfFilterDTO),
+    CustomIIR(CustomIIRFilter),
+}
+
+pub type LowpassFilterDTO = FreqQualFilterDTO<Lowpass>;
+pub type HighpassFilterDTO = FreqQualFilterDTO<Highpass>;
+pub type BandpassSkirtFilterDTO = FreqQualFilterDTO<BandpassSkirt>;
+pub type BandpassPeakFilterDTO = FreqQualFilterDTO<BandpassPeak>;
+pub type NotchFilterDTO = FreqQualFilterDTO<Notch>;
+pub type AllpassFilterDTO = FreqQualFilterDTO<Allpass>;
+pub type PeakingFilterDTO = FreqGainQualFilterDTO<Peaking>;
+pub type LowShelfFilterDTO = FreqGainQualFilterDTO<LowShelf>;
+pub type HighShelfFilterDTO = FreqGainQualFilterDTO<HighShelf>;
+
+impl TryInto<FilterConfig> for FilterConfigDTO {
+    type Error = String;
+    fn try_into(self) -> Result<FilterConfig, Self::Error> {
+        match self {
+            FilterConfigDTO::Lowpass(x) => Ok(FilterConfig::Lowpass(x.try_into()?)),
+            FilterConfigDTO::Highpass(x) => Ok(FilterConfig::Highpass(x.try_into()?)),
+            FilterConfigDTO::BandpassSkirt(x) => Ok(FilterConfig::BandpassSkirt(x.try_into()?)),
+            FilterConfigDTO::BandpassPeak(x) => Ok(FilterConfig::BandpassPeak(x.try_into()?)),
+            FilterConfigDTO::Notch(x) => Ok(FilterConfig::Notch(x.try_into()?)),
+            FilterConfigDTO::Allpass(x) => Ok(FilterConfig::Allpass(x.try_into()?)),
+            FilterConfigDTO::Peaking(x) => Ok(FilterConfig::Peaking(x.try_into()?)),
+            FilterConfigDTO::LowShelf(x) => Ok(FilterConfig::LowShelf(x.try_into()?)),
+            FilterConfigDTO::HighShelf(x) => Ok(FilterConfig::HighShelf(x.try_into()?)),
+            FilterConfigDTO::CustomIIR(x) => Ok(FilterConfig::CustomIIR(x)),
+        }
+    }
+}
+
+impl From<FilterConfig> for FilterConfigDTO {
+    fn from(value: FilterConfig) -> Self {
+        match value {
+            FilterConfig::Lowpass(x) => FilterConfigDTO::Lowpass(x.into()),
+            FilterConfig::Highpass(x) => FilterConfigDTO::Highpass(x.into()),
+            FilterConfig::BandpassSkirt(x) => FilterConfigDTO::BandpassSkirt(x.into()),
+            FilterConfig::BandpassPeak(x) => FilterConfigDTO::BandpassPeak(x.into()),
+            FilterConfig::Notch(x) => FilterConfigDTO::Notch(x.into()),
+            FilterConfig::Allpass(x) => FilterConfigDTO::Allpass(x.into()),
+            FilterConfig::Peaking(x) => FilterConfigDTO::Peaking(x.into()),
+            FilterConfig::LowShelf(x) => FilterConfigDTO::LowShelf(x.into()),
+            FilterConfig::HighShelf(x) => FilterConfigDTO::HighShelf(x.into()),
+            FilterConfig::CustomIIR(x) => FilterConfigDTO::CustomIIR(x.into()),
+        }
+    }
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct FreqQualFilterDTO<T: FilterName> {
+    _type: PhantomData<T>,
+    pub f0: f32,
+    pub q: f32,
+}
+
+impl<T: FilterName> TryInto<FreqQualFilter<T>> for FreqQualFilterDTO<T> {
+    type Error = String;
+    fn try_into(self) -> Result<FreqQualFilter<T>, Self::Error> {
+        FreqQualFilter::new(self.f0, self.q)
+    }
+}
+
+impl<T: FilterName> From<FreqQualFilter<T>> for FreqQualFilterDTO<T> {
+    fn from(value: FreqQualFilter<T>) -> Self {
+        Self { _type: PhantomData, f0: value.f0, q: value.q }
+    }
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct FreqGainQualFilterDTO<T: FilterName> {
+    _type: PhantomData<T>,
+    pub f0: f32,
+    pub q: f32,
+    pub db_gain: f32,
+}
+
+impl<T: FilterName> TryInto<FreqGainQualFilter<T>> for FreqGainQualFilterDTO<T> {
+    type Error = String;
+    fn try_into(self) -> Result<FreqGainQualFilter<T>, Self::Error> {
+        FreqGainQualFilter::new(self.f0, self.q, self.db_gain)
+    }
+}
+
+impl<T: FilterName> From<FreqGainQualFilter<T>> for FreqGainQualFilterDTO<T> {
+    fn from(value: FreqGainQualFilter<T>) -> Self {
+        Self { _type: PhantomData, f0: value.f0, q: value.q, db_gain: value.db_gain }
+    }
+}