Merge pull request #91 from compio-rs/dev/boxed-components

feat(elm): boxed component

Author: Berrysoft

winio-elm/src/boxed.rs

@@ -0,0 +1,129 @@
+use std::{convert::Infallible, fmt::Debug, pin::Pin};
+
+use futures_util::FutureExt;
+
+use crate::{Component, ComponentMessage, ComponentSender, channel::Channel};
+
+type DynComponentSender<T> =
+    Channel<ComponentMessage<<T as DynComponent>::Message, <T as DynComponent>::Event>>;
+
+trait DynComponent {
+    type Message;
+    type Event;
+    type Error: Debug;
+
+    fn start<'a>(
+        &'a mut self,
+        sender: &'a DynComponentSender<Self>,
+    ) -> Pin<Box<dyn Future<Output = Infallible> + 'a>>;
+
+    fn update_children(&mut self) -> Pin<Box<dyn Future<Output = Result<bool, Self::Error>> + '_>>;
+
+    fn update<'a>(
+        &'a mut self,
+        message: Self::Message,
+        sender: &'a DynComponentSender<Self>,
+    ) -> Pin<Box<dyn Future<Output = Result<bool, Self::Error>> + 'a>>;
+
+    fn render(&mut self, sender: &DynComponentSender<Self>) -> Result<(), Self::Error>;
+
+    fn render_children(&mut self) -> Result<(), Self::Error>;
+}
+
+impl<T: Component + 'static> DynComponent for T {
+    type Error = <T as Component>::Error;
+    type Event = <T as Component>::Event;
+    type Message = <T as Component>::Message;
+
+    fn start<'a>(
+        &'a mut self,
+        sender: &'a DynComponentSender<Self>,
+    ) -> Pin<Box<dyn Future<Output = Infallible> + 'a>> {
+        let sender = ComponentSender::<T>::from_ref(sender);
+        Box::pin(Component::start(self, sender).map(|a| a))
+    }
+
+    fn update_children(&mut self) -> Pin<Box<dyn Future<Output = Result<bool, Self::Error>> + '_>> {
+        Box::pin(Component::update_children(self))
+    }
+
+    fn update<'a>(
+        &'a mut self,
+        message: Self::Message,
+        sender: &'a DynComponentSender<Self>,
+    ) -> Pin<Box<dyn Future<Output = Result<bool, Self::Error>> + 'a>> {
+        let sender = ComponentSender::<T>::from_ref(sender);
+        Box::pin(Component::update(self, message, sender))
+    }
+
+    fn render(&mut self, sender: &DynComponentSender<Self>) -> Result<(), Self::Error> {
+        let sender = ComponentSender::<T>::from_ref(sender);
+        Component::render(self, sender)
+    }
+
+    fn render_children(&mut self) -> Result<(), Self::Error> {
+        Component::render_children(self)
+    }
+}
+
+/// A boxed component. It is not initialized directly, but constructed by
+/// [`Child::into_boxed`] or [`Root::into_boxed`].
+///
+/// [`Child::into_boxed`]: crate::Child::into_boxed
+/// [`Root::into_boxed`]: crate::Root::into_boxed
+pub struct BoxComponent<M, Ev, Err>(Box<dyn DynComponent<Message = M, Event = Ev, Error = Err>>);
+
+impl<M, Ev, Err> BoxComponent<M, Ev, Err> {
+    pub(crate) fn new<T: Component<Message = M, Event = Ev, Error = Err> + 'static>(
+        component: T,
+    ) -> Self {
+        Self(Box::new(component))
+    }
+}
+
+impl<M, Ev, Err: Debug> Component for BoxComponent<M, Ev, Err> {
+    type Error = Err;
+    type Event = Ev;
+    type Init<'a> = Infallible;
+    type Message = M;
+
+    async fn init(
+        init: Self::Init<'_>,
+        _sender: &ComponentSender<Self>,
+    ) -> Result<Self, Self::Error> {
+        match init {}
+    }
+
+    async fn start(&mut self, sender: &ComponentSender<Self>) -> ! {
+        let sender = &sender.0;
+        match self.0.start(sender).await {}
+    }
+
+    async fn update_children(&mut self) -> Result<bool, Self::Error> {
+        self.0.update_children().await
+    }
+
+    async fn update(
+        &mut self,
+        message: Self::Message,
+        sender: &ComponentSender<Self>,
+    ) -> Result<bool, Self::Error> {
+        let sender = &sender.0;
+        self.0.update(message, sender).await
+    }
+
+    fn render(&mut self, sender: &ComponentSender<Self>) -> Result<(), Self::Error> {
+        let sender = &sender.0;
+        self.0.render(sender)
+    }
+
+    fn render_children(&mut self) -> Result<(), Self::Error> {
+        self.0.render_children()
+    }
+}
+
+impl<M, Ev, Err> Debug for BoxComponent<M, Ev, Err> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("BoxComponent").finish_non_exhaustive()
+    }
+}

winio-elm/src/child.rs

@@ -15,7 +15,7 @@ use winio_handle::{
 use winio_primitive::{Failable, Layoutable, Point, Rect, Size};
 
 use super::ComponentMessage;
-use crate::{Component, ComponentSender, Root};
+use crate::{BoxComponent, Component, ComponentSender, Root};
 
 /// Helper to embed one component into another. It handles different types of
 /// messages and events.
@@ -150,6 +150,18 @@ impl<T: Component> Child<T> {
     }
 }
 
+impl<T: Component + 'static> Child<T> {
+    /// Box the component.
+    pub fn into_boxed(self) -> Child<BoxComponent<T::Message, T::Event, T::Error>> {
+        let sender = ComponentSender(self.sender.0);
+        Child {
+            model: BoxComponent::new(self.model),
+            sender,
+            msg_cache: self.msg_cache,
+        }
+    }
+}
+
 impl<T: Component> Deref for Child<T> {
     type Target = T;
 

winio-elm/src/lib.rs

@@ -128,5 +128,8 @@ pub use macros::*;
 mod run;
 pub use run::*;
 
+mod boxed;
+pub use boxed::*;
+
 #[cfg(feature = "gen_blocks")]
 mod stream;

winio-elm/src/run.rs

@@ -6,7 +6,7 @@ use futures_util::{FutureExt, Stream};
 
 #[cfg(feature = "gen_blocks")]
 use crate::stream::stream;
-use crate::{Child, Component, ComponentMessage, ComponentSender};
+use crate::{BoxComponent, Child, Component, ComponentMessage, ComponentSender};
 
 /// Events yielded by the [`run`].
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -126,6 +126,14 @@ fn run_events_impl<'a, T: Component>(
     }
 }
 
+impl<T: Component + 'static> Root<T> {
+    /// Box the component.
+    pub fn into_boxed(self) -> Root<BoxComponent<T::Message, T::Event, T::Error>> {
+        let sender = ComponentSender(self.sender.0);
+        Root::new(BoxComponent::new(self.model), sender)
+    }
+}
+
 #[cfg(test)]
 mod test {
     use async_stream::stream;
@@ -226,4 +234,23 @@ mod test {
     }
 
     fn assert_send_sync<T: Send + Sync>(_: &T) {}
+
+    #[compio::test]
+    async fn test_boxed_run() {
+        let mut boxed_child = Root::<TestComponent>::init(vec![
+            TestMessage::Msg1,
+            TestMessage::Msg2,
+            TestMessage::Msg1,
+        ])
+        .await
+        .expect("failed to init component")
+        .into_boxed();
+        let events = boxed_child.run();
+        let expects = [TestEvent::Event1, TestEvent::Event2, TestEvent::Event1];
+        let zip = events.zip(futures_util::stream::iter(expects.into_iter()));
+        let mut zip = std::pin::pin!(zip);
+        while let Some((e, ex)) = zip.next().await {
+            assert_eq!(e, RunEvent::Event(ex));
+        }
+    }
 }