use std::fmt;
use std::path::{Path, PathBuf};
use serde::{Deserialize, Deserializer, Serialize, Serializer};
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum PluginFormat {
Vst3,
AudioUnit,
Clap,
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct ClassId(String);
impl ClassId {
fn new(format: PluginFormat, id: impl Into<String>) -> ClassId {
let mut id = id.into();
match format {
PluginFormat::Vst3 | PluginFormat::AudioUnit => id.make_ascii_uppercase(),
PluginFormat::Clap => {}
}
ClassId(id)
}
pub fn as_str(&self) -> &str {
&self.0
}
}
impl fmt::Display for ClassId {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(&self.0)
}
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct PluginId {
format: PluginFormat,
class_id: ClassId,
}
impl PluginId {
#[must_use]
pub fn new(format: PluginFormat, class_id: impl Into<String>) -> PluginId {
PluginId {
format,
class_id: ClassId::new(format, class_id),
}
}
pub fn format(&self) -> PluginFormat {
self.format
}
pub fn class_id(&self) -> &ClassId {
&self.class_id
}
}
#[derive(Serialize, Deserialize)]
#[serde(rename = "PluginId")]
struct PersistedId {
format: PersistedFormat,
class_id: String,
}
#[derive(Serialize, Deserialize)]
enum PersistedFormat {
#[serde(rename = "vst3")]
Vst3,
#[serde(rename = "audio-unit")]
AudioUnit,
#[serde(rename = "clap")]
Clap,
}
impl Serialize for PluginId {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
let format = match self.format {
PluginFormat::Vst3 => PersistedFormat::Vst3,
PluginFormat::AudioUnit => PersistedFormat::AudioUnit,
PluginFormat::Clap => PersistedFormat::Clap,
};
PersistedId {
format,
class_id: self.class_id.0.clone(),
}
.serialize(serializer)
}
}
impl<'de> Deserialize<'de> for PluginId {
fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<PluginId, D::Error> {
let persisted = PersistedId::deserialize(deserializer)?;
let format = match persisted.format {
PersistedFormat::Vst3 => PluginFormat::Vst3,
PersistedFormat::AudioUnit => PluginFormat::AudioUnit,
PersistedFormat::Clap => PluginFormat::Clap,
};
Ok(PluginId::new(format, persisted.class_id))
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct PluginRef {
pub(crate) id: PluginId,
pub(crate) bundle: Option<PathBuf>,
}
impl PluginRef {
#[must_use]
pub fn vst3(bundle: impl Into<PathBuf>, class_id: impl Into<String>) -> PluginRef {
PluginRef {
id: PluginId::new(PluginFormat::Vst3, class_id),
bundle: Some(bundle.into()),
}
}
#[must_use]
pub fn clap(bundle: impl Into<PathBuf>, class_id: impl Into<String>) -> PluginRef {
PluginRef {
id: PluginId::new(PluginFormat::Clap, class_id),
bundle: Some(bundle.into()),
}
}
#[must_use]
pub fn audio_unit(class_id: impl Into<String>) -> PluginRef {
PluginRef {
id: PluginId::new(PluginFormat::AudioUnit, class_id),
bundle: None,
}
}
pub fn id(&self) -> &PluginId {
&self.id
}
pub fn bundle(&self) -> Option<&Path> {
self.bundle.as_deref()
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum PluginKind {
Effect,
Instrument,
}
#[derive(Clone, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub struct PluginInfo {
pub id: PluginId,
pub name: String,
pub vendor: String,
pub version: String,
pub sdk_version: String,
pub kind: PluginKind,
pub categories: Vec<String>,
}
impl PluginInfo {
#[must_use]
pub fn new(id: PluginId, name: impl Into<String>, kind: PluginKind) -> PluginInfo {
PluginInfo {
id,
name: name.into(),
vendor: String::new(),
version: String::new(),
sdk_version: String::new(),
kind,
categories: Vec::new(),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn hexadecimal_ids_compare_whatever_their_case() {
let lower = PluginId::new(PluginFormat::Vst3, "abcdef019182faeb4163747a44784c76");
let upper = PluginId::new(PluginFormat::Vst3, "ABCDEF019182FAEB4163747A44784C76");
assert_eq!(lower, upper);
assert_eq!(
lower.class_id().as_str(),
"ABCDEF019182FAEB4163747A44784C76"
);
assert_eq!(
PluginId::new(PluginFormat::AudioUnit, "6175667864656c796170706c"),
PluginId::new(PluginFormat::AudioUnit, "6175667864656C796170706C")
);
assert_ne!(
PluginId::new(PluginFormat::Clap, "com.example.Delay"),
PluginId::new(PluginFormat::Clap, "com.example.delay")
);
}
#[test]
fn ids_persist_with_their_format_names_and_read_back_canonical() {
let id = PluginId::new(PluginFormat::AudioUnit, "6175667864656C796170706C");
assert_eq!(
serde_json::to_string(&id).unwrap(),
r#"{"format":"audio-unit","class_id":"6175667864656C796170706C"}"#
);
for (json, format) in [
(
r#"{"format":"vst3","class_id":"abcdef01"}"#,
PluginFormat::Vst3,
),
(
r#"{"format":"audio-unit","class_id":"abcdef01"}"#,
PluginFormat::AudioUnit,
),
] {
assert_eq!(
serde_json::from_str::<PluginId>(json).unwrap(),
PluginId::new(format, "ABCDEF01")
);
}
let clap = PluginId::new(PluginFormat::Clap, "com.example.Delay");
let json = serde_json::to_string(&clap).unwrap();
assert_eq!(json, r#"{"format":"clap","class_id":"com.example.Delay"}"#);
assert_eq!(serde_json::from_str::<PluginId>(&json).unwrap(), clap);
}
}