use std::borrow::Cow;
use serde::{Deserialize, Deserializer, Serialize, Serializer};
use crate::plugin::PluginId;
use crate::state::PluginState;
#[derive(Serialize)]
struct Outgoing<'a> {
id: &'a PluginId,
name: &'a str,
vendor: &'a str,
version: &'a str,
component: &'a [u8],
controller: Option<&'a [u8]>,
}
#[derive(Deserialize)]
struct Incoming {
id: PluginId,
name: String,
vendor: String,
version: String,
component: Vec<u8>,
controller: Option<Vec<u8>>,
}
pub fn serialize<S: Serializer>(state: &PluginState, serializer: S) -> Result<S::Ok, S::Error> {
Outgoing {
id: &state.id,
name: &state.name,
vendor: &state.vendor,
version: &state.version,
component: &state.component,
controller: state.controller.as_deref(),
}
.serialize(serializer)
}
pub fn deserialize<'de, D: Deserializer<'de>>(deserializer: D) -> Result<PluginState, D::Error> {
let state = Incoming::deserialize(deserializer)?;
Ok(PluginState {
id: state.id,
name: state.name,
vendor: state.vendor,
version: state.version,
component: state.component,
controller: state.controller,
})
}
pub fn serialize_option<S: Serializer>(
state: &Option<Cow<'_, PluginState>>,
serializer: S,
) -> Result<S::Ok, S::Error> {
struct Borrowed<'a>(&'a PluginState);
impl Serialize for Borrowed<'_> {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
serialize(self.0, serializer)
}
}
state.as_deref().map(Borrowed).serialize(serializer)
}
pub fn deserialize_option_cow<'de, 'a, D: Deserializer<'de>>(
deserializer: D,
) -> Result<Option<Cow<'a, PluginState>>, D::Error> {
struct Owned(PluginState);
impl<'de> Deserialize<'de> for Owned {
fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Owned, D::Error> {
deserialize(deserializer).map(Owned)
}
}
Ok(Option::<Owned>::deserialize(deserializer)?.map(|state| Cow::Owned(state.0)))
}
pub fn deserialize_cow<'de, 'a, D: Deserializer<'de>>(
deserializer: D,
) -> Result<Cow<'a, PluginState>, D::Error> {
deserialize(deserializer).map(Cow::Owned)
}