Adapt internals

Signed-off-by: Marcel Müller <neikos@neikos.email>

crates/tytix-core/src/lib.rs

@@ -1,8 +1,13 @@
 #![feature(const_cmp)]
 #![feature(const_trait_impl)]
 
+#[macro_use]
+mod macros;
+
 use std::any::Any;
 use std::any::TypeId;
+use std::marker::PhantomData;
+use std::pin::Pin;
 
 pub use anyhow;
 
@@ -10,14 +15,6 @@ pub trait Message: Send + Any {
     type Reply: Send + Any;
 }
 
-pub trait MessageIdentifier {
-    const IDENT: BundleChain;
-}
-
-impl<M: Message> MessageIdentifier for M {
-    const IDENT: BundleChain = BundleChain::of::<M>();
-}
-
 pub struct InternalMessage {
     value: Box<dyn std::any::Any>,
     name: &'static str,
@@ -58,6 +55,46 @@ pub trait Address<MB> {
     fn send<M: Message>(&mut self, message: M) -> impl Future<Output = anyhow::Result<M::Reply>>;
 }
 
+pub struct BoxedAddress<MB> {
+    addr: Box<dyn Any>,
+    #[allow(clippy::type_complexity)]
+    send: for<'a> fn(
+        &'a mut dyn Any,
+        InternalMessage,
+    ) -> Pin<Box<dyn Future<Output = anyhow::Result<InternalMessage>> + 'a>>,
+    _pd: PhantomData<fn(MB)>,
+}
+
+impl<MB> BoxedAddress<MB> {
+    pub fn new<IMH>(addr: IMH) -> Self
+    where
+        IMH: InternalMessageHandler<HandledMessages = MB> + 'static,
+    {
+        BoxedAddress {
+            addr: Box::new(addr),
+            send: |addr, msg| {
+                let addr: &mut IMH = addr.downcast_mut().unwrap();
+
+                Box::pin(addr.handle_message(msg))
+            },
+            _pd: PhantomData,
+        }
+    }
+}
+
+impl<MB> InternalMessageHandler for BoxedAddress<MB>
+where
+    MB: MessageBundle,
+{
+    type HandledMessages = MB;
+    fn handle_message(
+        &mut self,
+        msg: InternalMessage,
+    ) -> impl Future<Output = anyhow::Result<InternalMessage>> {
+        (self.send)(self.addr.as_mut(), msg)
+    }
+}
+
 pub trait InternalMessageHandler {
     type HandledMessages: MessageBundle;
     fn handle_message(
@@ -93,22 +130,27 @@ where
     }
 }
 
-pub trait MessageReceiver {}
-
 pub trait MessageBundle {
-    const IDS: BundleChain;
+    const CHAIN: BundleChain;
 }
 
 impl MessageBundle for () {
-    const IDS: BundleChain = BundleChain {
+    const CHAIN: BundleChain = BundleChain::empty();
-        next: None,
+}
-        op: BundleOp::Remove(TypeId::of::<()>()),
+
+macro_rules! impl_message_bundles {
+    ( [ $($ty:ident),* ] , $last:ident ) => {
+        impl<$($ty,)* $last> MessageBundle for ($($ty,)* $last,)
+            where
+                $( $ty: Message, )*
+                $last: Message,
+        {
+            const CHAIN: BundleChain = <($($ty,)*) as MessageBundle>::CHAIN.with::<$last>();
+        }
     };
 }
 
-impl<M: Message> MessageBundle for (M,) {
+all_the_tuples_special_first!(impl_message_bundles);
-    const IDS: BundleChain = BundleChain::of::<M>();
-}
 
 #[derive(Debug, Clone, Copy)]
 pub struct BundleChain {
@@ -121,6 +163,7 @@ pub enum BundleOp {
     Add(TypeId),
     Remove(TypeId),
     Chain(&'static BundleChain),
+    None,
 }
 
 impl BundleChain {
@@ -135,6 +178,40 @@ impl BundleChain {
         check_is_contained(self, id)
     }
 
+    pub const fn is_subset_of(&self, ids: &BundleChain) -> bool {
+        let mut current = self;
+
+        loop {
+            match current.op {
+                BundleOp::Add(type_id) => {
+                    if !ids.contains(type_id) {
+                        return false;
+                    }
+                }
+                BundleOp::Remove(..) => (),
+                BundleOp::Chain(bundle_chain) => {
+                    let chain_result = bundle_chain.is_subset_of(ids);
+                    let own_result = if let Some(bc) = self.next {
+                        bc.is_subset_of(ids)
+                    } else {
+                        true
+                    };
+
+                    return chain_result && own_result;
+                }
+                BundleOp::None => (),
+            }
+
+            if let Some(next) = current.next {
+                current = next;
+            } else {
+                break;
+            };
+        }
+
+        true
+    }
+
     pub const fn with<M: Message>(&'static self) -> BundleChain {
         let to_add = TypeId::of::<M>();
         BundleChain {
@@ -157,24 +234,13 @@ impl BundleChain {
             next: Some(ids),
         }
     }
-}
 
-impl<A, B> MessageBundle for (A, B)
+    pub const fn empty() -> BundleChain {
-where
+        BundleChain {
-    A: Message,
+            op: BundleOp::None,
-    B: Message,
+            next: None,
-{
+        }
-    const IDS: BundleChain = BundleChain::of::<A>().with::<B>();
+    }
-}
-
-impl<A, B, C, D> MessageBundle for (A, B, C, D)
-where
-    A: Message,
-    B: Message,
-    C: Message,
-    D: Message,
-{
-    const IDS: BundleChain = BundleChain::of::<A>().with::<B>().with::<C>().with::<D>();
 }
 
 pub trait IsContainedInBundle<MB> {
@@ -186,7 +252,7 @@ where
     M: Message,
     MB: MessageBundle,
 {
-    const IS_CONTAINED: bool = check_is_contained(&MB::IDS, TypeId::of::<M>());
+    const IS_CONTAINED: bool = check_is_contained(&MB::CHAIN, TypeId::of::<M>());
 }
 
 const fn check_is_contained(ids: &BundleChain, id: TypeId) -> bool {
@@ -206,6 +272,7 @@ const fn check_is_contained(ids: &BundleChain, id: TypeId) -> bool {
                 return true;
             }
         }
+        BundleOp::None => (),
     }
 
     if let Some(next) = ids.next {
@@ -269,6 +336,16 @@ mod tests {
         ));
     }
 
+    #[test]
+    fn check_subset() {
+        const CHAIN: BundleChain = BundleChain::of::<Foo>().join(&BundleChain::of::<Bar>());
+        const SUB: BundleChain = BundleChain::of::<Foo>().with::<Bar>();
+
+        assert!(SUB.is_subset_of(&CHAIN));
+
+        assert!(!BundleChain::of::<Zap>().is_subset_of(&CHAIN));
+    }
+
     #[apply(test!)]
     async fn check_sending_messages() {
         struct Sender;

crates/tytix-core/src/macros.rs

@@ -0,0 +1,21 @@
+#[rustfmt::skip]
+macro_rules! all_the_tuples_special_first {
+    ($name:ident) => {
+        $name!([], M1);
+        $name!([M1], M2);
+        $name!([M1, M2], M3);
+        $name!([M1, M2, M3], M4);
+        $name!([M1, M2, M3, M4], M5);
+        $name!([M1, M2, M3, M4, M5], M6);
+        $name!([M1, M2, M3, M4, M5, M6], M7);
+        $name!([M1, M2, M3, M4, M5, M6, M7], M8);
+        $name!([M1, M2, M3, M4, M5, M6, M7, M8], M9);
+        $name!([M1, M2, M3, M4, M5, M6, M7, M8, M9], M10);
+        $name!([M1, M2, M3, M4, M5, M6, M7, M8, M9, M10], M11);
+        $name!([M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11], M12);
+        $name!([M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12], M13);
+        $name!([M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13], M14);
+        $name!([M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14], M15);
+        $name!([M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15], M16);
+    };
+}

crates/tytix/src/lib.rs

@@ -1,6 +1,7 @@
 use std::marker::PhantomData;
 
 use futures::FutureExt;
+use tytix_core::BoxedAddress;
 use tytix_core::InternalMessage;
 use tytix_core::InternalMessageHandler;
 use tytix_core::IsContainedInBundle;
@@ -18,17 +19,29 @@ pub trait AddressExt<MB> {
 
     fn inspect<F, M, U>(self, f: F) -> Inspect<Self, F, U, M>
     where
-        F: Fn(&M) -> U,
+        Inspect<Self, F, U, M>: InternalMessageHandler,
-        M: Message + IsContainedInBundle<MB>,
         Self: Sized;
 
     fn join<Other>(self, o: Other) -> Joined<Self, Other>
     where
         Joined<Self, Other>: InternalMessageHandler,
         Self: Sized;
+
+    fn simplify<SMB>(self) -> SimpleAddress<SMB, Self>
+    where
+        SimpleAddress<SMB, Self>: InternalMessageHandler,
+        Self: Sized;
+
+    fn boxed(self) -> BoxedAddress<MB>
+    where
+        BoxedAddress<MB>: InternalMessageHandler;
 }
 
-impl<MB: MessageBundle, A: InternalMessageHandler<HandledMessages = MB>> AddressExt<MB> for A {
+impl<MB, A> AddressExt<MB> for A
+where
+    MB: MessageBundle,
+    A: InternalMessageHandler<HandledMessages = MB> + 'static,
+{
     fn map<M, F, U, RF, RU>(self, f: F, r: RF) -> MappedMessage<Self, M, F, U, RF, RU>
     where
         MappedMessage<Self, M, F, U, RF, RU>: InternalMessageHandler,
@@ -44,16 +57,9 @@ impl<MB: MessageBundle, A: InternalMessageHandler<HandledMessages = MB>> Address
 
     fn inspect<F, M, U>(self, f: F) -> Inspect<Self, F, U, M>
     where
-        F: Fn(&M) -> U,
+        Inspect<Self, F, U, M>: InternalMessageHandler,
         Self: Sized,
-        M: Message + IsContainedInBundle<MB>,
     {
-        const {
-            let true = <M as IsContainedInBundle<MB>>::IS_CONTAINED else {
-                panic!("Message is not contained in MessageBundle",);
-            };
-        }
-
         Inspect {
             address: self,
             func: f,
@@ -71,6 +77,47 @@ impl<MB: MessageBundle, A: InternalMessageHandler<HandledMessages = MB>> Address
             right: o,
         }
     }
+
+    fn simplify<SMB>(self) -> SimpleAddress<SMB, Self>
+    where
+        SimpleAddress<SMB, Self>: InternalMessageHandler,
+        Self: Sized,
+    {
+        SimpleAddress {
+            inner: self,
+            _pd: PhantomData,
+        }
+    }
+
+    fn boxed(self) -> BoxedAddress<MB> {
+        BoxedAddress::new(self)
+    }
+}
+
+pub struct SimpleAddress<MB, A> {
+    inner: A,
+    _pd: PhantomData<fn(MB)>,
+}
+
+impl<SMB, MB, A> InternalMessageHandler for SimpleAddress<SMB, A>
+where
+    SMB: MessageBundle,
+    MB: MessageBundle,
+    A: InternalMessageHandler<HandledMessages = MB>,
+{
+    type HandledMessages = SMB;
+
+    fn handle_message(
+        &mut self,
+        msg: InternalMessage,
+    ) -> impl Future<Output = anyhow::Result<InternalMessage>> {
+        const {
+            let true = SMB::CHAIN.is_subset_of(&MB::CHAIN) else {
+                panic!("Message is not contained in MessageBundle",);
+            };
+        }
+        self.inner.handle_message(msg)
+    }
 }
 
 pub struct Joined<L, R> {
@@ -87,7 +134,8 @@ where
     L: MessageBundle,
     R: MessageBundle,
 {
-    const IDS: tytix_core::BundleChain = <L as MessageBundle>::IDS.join(&<R as MessageBundle>::IDS);
+    const CHAIN: tytix_core::BundleChain =
+        <L as MessageBundle>::CHAIN.join(&<R as MessageBundle>::CHAIN);
 }
 
 impl<L, R> InternalMessageHandler for Joined<L, R>
@@ -100,7 +148,7 @@ where
     async fn handle_message(&mut self, msg: InternalMessage) -> anyhow::Result<InternalMessage> {
         let message_id = msg.type_id();
 
-        if L::HandledMessages::IDS.contains(message_id) {
+        if L::HandledMessages::CHAIN.contains(message_id) {
             self.left.handle_message(msg).await
         } else {
             self.right.handle_message(msg).await
@@ -148,7 +196,7 @@ where
     M: Message,
     R: Message + IsContainedInBundle<MB>,
 {
-    const IDS: tytix_core::BundleChain = MB::IDS.without::<R>().with::<M>();
+    const CHAIN: tytix_core::BundleChain = MB::CHAIN.without::<R>().with::<M>();
 }
 
 impl<A, M, R, F, U, RF, RU> InternalMessageHandler for MappedMessage<A, M, F, U, RF, RU>
@@ -219,9 +267,9 @@ mod tests {
         type Reply = usize;
     }
 
-    struct SimpleAddress;
+    struct FooBarAddress;
 
-    impl InternalMessageHandler for SimpleAddress {
+    impl InternalMessageHandler for FooBarAddress {
         type HandledMessages = (Foo, Bar);
 
         async fn handle_message(
@@ -253,7 +301,7 @@ mod tests {
     async fn check_mapping() {
         static MSG: OnceLock<bool> = OnceLock::new();
 
-        let mut sa = SimpleAddress.map(
+        let mut sa = FooBarAddress.map(
             |_b: Bar| {
                 let _ = MSG.set(true);
                 async { Foo }
@@ -270,7 +318,7 @@ mod tests {
     async fn check_inspect() {
         static MSG: OnceLock<bool> = OnceLock::new();
 
-        let mut sa = SimpleAddress.inspect(|_b: &Bar| {
+        let mut sa = FooBarAddress.inspect(|_b: &Bar| {
             let _ = MSG.set(true);
             async {}
         });
@@ -285,11 +333,11 @@ mod tests {
     }
 
     #[apply(test!)]
-    async fn check_join() {
+    async fn check_simplify() {
         static MSG_SA: OnceLock<bool> = OnceLock::new();
         static MSG_ZAP: OnceLock<bool> = OnceLock::new();
 
-        let sa = SimpleAddress.inspect(|_b: &Bar| {
+        let sa = FooBarAddress.inspect(|_b: &Bar| {
             MSG_SA.set(true).unwrap();
             async {}
         });
@@ -308,4 +356,42 @@ mod tests {
 
         MSG_ZAP.get().expect("The message was NOT inspected!");
     }
+
+    #[apply(test!)]
+    async fn check_join() {
+        static MSG_SA: OnceLock<bool> = OnceLock::new();
+
+        let sa = FooBarAddress.inspect(|_b: &Bar| {
+            MSG_SA.set(true).unwrap();
+            async {}
+        });
+
+        let zap = ZapAddress.join(ZapAddress).join(ZapAddress);
+
+        let joined = sa.join(zap);
+
+        let mut simple = joined.simplify::<(Foo, Bar, Zap)>();
+
+        simple.send(Bar).await.unwrap();
+
+        MSG_SA.get().expect("The message was not :CC inspected!");
+    }
+
+    #[apply(test!)]
+    async fn check_boxed() {
+        static MSG_SA: OnceLock<bool> = OnceLock::new();
+
+        let sa = FooBarAddress.inspect(|_b: &Bar| {
+            MSG_SA.set(true).unwrap();
+            async {}
+        });
+
+        let zap = ZapAddress.join(ZapAddress).join(ZapAddress);
+
+        let mut boxed = zap.join(sa).simplify::<(Bar, Zap, Foo)>().boxed();
+
+        boxed.send(Bar).await.unwrap();
+
+        MSG_SA.get().expect("The message was not :CC inspected!");
+    }
 }