use super::queue::Origin;
use serde::{Serialize, Serializer};
use std::{
any::Any,
fmt::{self, Debug},
sync::Arc,
};
#[derive(Clone, Default)]
pub struct ChannelRaw(Option<Arc<dyn Raw>>);
trait Raw: erased_serde::Serialize + Any + Debug + Send + Sync {}
impl<R: Serialize + Any + Debug + Send + Sync> Raw for R {}
erased_serde::serialize_trait_object!(Raw);
impl ChannelRaw {
pub(super) fn of<R: Serialize + Debug + Send + Sync + 'static>(raw: R) -> Self {
match (&raw as &dyn Any).downcast_ref::<Self>() {
Some(raw) => raw.clone(),
None => Self(Some(Arc::new(raw))),
}
}
pub fn downcast_ref<R: 'static>(&self) -> Option<&R> {
let raw: &dyn Any = self.0.as_deref()?;
raw.downcast_ref()
}
pub fn is_empty(&self) -> bool {
self.0.is_none()
}
}
impl Debug for ChannelRaw {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match &self.0 {
Some(raw) => raw.fmt(f),
None => f.write_str("None"),
}
}
}
impl Serialize for ChannelRaw {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match &self.0 {
Some(raw) => raw.serialize(serializer),
None => serializer.serialize_none(),
}
}
}
#[derive(Clone)]
pub struct ChannelOutput<T> {
pub(super) value: T,
pub(super) origin: Origin,
}
impl<T> From<T> for ChannelOutput<T> {
fn from(value: T) -> Self {
Self {
value,
origin: Origin::default(),
}
}
}