use std::any::Any;
use std::fmt;
use serde::{Deserialize, Deserializer, Serialize, Serializer};
use crate::property_types;
pub trait ExtensionData: Send {
fn type_name(&self) -> &str;
fn clone_box(&self) -> Box<dyn ExtensionData>;
fn as_any(&self) -> &dyn Any;
fn eq(&self, other: &dyn ExtensionData) -> bool;
fn save(&self) -> Vec<u8>;
fn fcstd_members(&self) -> Option<Vec<(String, Vec<u8>)>> {
None
}
fn fcstd_sidecar(&self) -> Option<(String, Vec<u8>)> {
None
}
fn resolve_element_name(&self, _name: &str) -> Result<Option<String>, &'static str> {
Ok(None)
}
fn debug(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result;
}
pub struct ExtensionValue(Box<dyn ExtensionData>);
impl ExtensionValue {
pub fn new(data: Box<dyn ExtensionData>) -> Self {
ExtensionValue(data)
}
pub fn data(&self) -> &dyn ExtensionData {
self.0.as_ref()
}
pub fn type_name(&self) -> &str {
self.0.type_name()
}
}
impl Clone for ExtensionValue {
fn clone(&self) -> Self {
ExtensionValue(self.0.clone_box())
}
}
impl fmt::Debug for ExtensionValue {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
self.0.debug(f)
}
}
impl PartialEq for ExtensionValue {
fn eq(&self, other: &Self) -> bool {
self.0.type_name() == other.0.type_name() && self.0.eq(other.0.as_ref())
}
}
#[derive(Serialize, Deserialize)]
struct RawExtension {
#[serde(rename = "type")]
type_name: String,
bytes: Vec<u8>,
}
impl Serialize for ExtensionValue {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
RawExtension {
type_name: self.0.type_name().to_string(),
bytes: self.0.save(),
}
.serialize(serializer)
}
}
impl<'de> Deserialize<'de> for ExtensionValue {
fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
let raw = RawExtension::deserialize(deserializer)?;
property_types::restore_extension(&raw.type_name, &raw.bytes)
.map(ExtensionValue)
.ok_or_else(|| {
serde::de::Error::custom(format!(
"property type '{}' is not registered (module not loaded?)",
raw.type_name
))
})
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::property::Property;
struct Counter(i64);
impl ExtensionData for Counter {
fn type_name(&self) -> &str {
"Test::PropertyCounter"
}
fn clone_box(&self) -> Box<dyn ExtensionData> {
Box::new(Counter(self.0))
}
fn as_any(&self) -> &dyn Any {
self
}
fn eq(&self, other: &dyn ExtensionData) -> bool {
other
.as_any()
.downcast_ref::<Counter>()
.is_some_and(|c| c.0 == self.0)
}
fn save(&self) -> Vec<u8> {
self.0.to_le_bytes().to_vec()
}
fn debug(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "Counter({})", self.0)
}
}
fn restore(bytes: &[u8]) -> Option<Box<dyn ExtensionData>> {
let arr: [u8; 8] = bytes.try_into().ok()?;
Some(Box::new(Counter(i64::from_le_bytes(arr))))
}
fn register() {
property_types::register_extension(
"Test::PropertyCounter",
|| Property::Extension(ExtensionValue::new(Box::new(Counter(0)))),
restore,
);
}
#[test]
fn clone_equality_debug_and_type_name() {
register();
let a = Property::Extension(ExtensionValue::new(Box::new(Counter(3))));
let b = a.clone();
assert_eq!(a, b);
assert_ne!(
a,
Property::Extension(ExtensionValue::new(Box::new(Counter(4))))
);
assert_eq!(format!("{a:?}"), "Extension(Counter(3))");
assert_eq!(a.type_name(), "Test::PropertyCounter");
}
#[test]
fn round_trips_through_json() {
register();
let p = Property::Extension(ExtensionValue::new(Box::new(Counter(42))));
let json = serde_json::to_string(&p).unwrap();
let back: Property = serde_json::from_str(&json).unwrap();
assert_eq!(p, back);
}
#[test]
fn unregistered_type_fails_to_load() {
let json = r#"{"Extension":{"type":"Nope::PropertyX","bytes":[1,2]}}"#;
let err = serde_json::from_str::<Property>(json).unwrap_err().to_string();
assert!(err.contains("not registered"), "{err}");
}
}