1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102

use core::any::{self, Any};
use core::fmt;
// use erased_serde::{Deserializer, Serialize};

pub trait Message: Any + fmt::Debug/*Serialize + for<'a> Deserializer<'a> + */ + Unpin + Clone + Send + Sync + 'static {}
impl<T: Any + fmt::Debug + Unpin + Clone + Send + Sync> Message for T {}

trait SafeMessage: Any + fmt::Debug/*+ Serialize + for<'a> Deserializer<'a>*/ + Unpin + Send + Sync + 'static {
    fn type_name(&self) -> &'static str;
    fn clone_boxed(&self) -> Box<dyn SafeMessage>;
}

impl<T: Message> SafeMessage for T {
    fn type_name(&self) -> &'static str {
        any::type_name::<T>()
    }

    fn clone_boxed(&self) -> Box<dyn SafeMessage> {
        Box::new(self.clone())
    }
}

// pub struct BoxedEnvelop {
//     inner: Box<dyn SafeMessage>,
// }

// impl BoxedEnvelop {
//     pub fn from_message<M: Message>(m: M) -> Self {
//         Self {
//             inner: Box::new(m)
//         }
//     }

//     pub fn as_ref(&self) -> Envelop<'_> {
//         Envelop { inner: &*self.inner }
//     }

//     pub fn downcast<T: 'static>(self) -> Option<Box<T>> {
//         if (*self.inner).type_id() == TypeId::of::<T>() {
//             unsafe {
//                 let raw: *mut dyn SafeMessage = Box::into_raw(self.inner);

//                 Some(Box::from_raw(raw as *mut T))
//             }
//         } else {
//             None
//         }
//     }
// }

#[derive(Copy, Clone)]
pub struct Envelop<'inner> {
    inner: &'inner dyn SafeMessage,
}

impl<'inner> fmt::Debug for Envelop<'inner> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "Envelop(")?;
        self.inner.fmt(f)?;
        write!(f, ")")?;

        Ok(())
    }
}

impl<'inner> Envelop<'inner> {
    // pub fn new<T: Message>(inner: &'inner T) -> Self {
    //     Self { inner }
    // }

    // #[inline]
    // pub fn downcast_to<T: 'static>(&self) -> Option<&T> {
    //     if self.inner.type_id() == TypeId::of::<T>() {
    //         unsafe { Some(&*(self.inner as *const dyn SafeMessage as *const T)) }
    //     } else {
    //         None
    //     }
    // }

    // #[inline]
    // pub fn type_id(&self) -> TypeId {
    //     self.inner.type_id()
    // }

    // #[inline]
    // pub fn type_name(&self) -> &'static str {
    //     self.inner.type_name()
    // }

    // #[inline]
    // pub fn clone_boxed(&self) -> BoxedEnvelop {
    //     BoxedEnvelop {
    //         inner: self.inner.clone_boxed(),
    //     }
    // }
}

// impl<'inner> serde::Serialize for Envelop<'inner> {
//     fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
//         erased_serde::serialize(self.inner, serializer)
//     }
// }