winio-elm 0.6.0

ELM framework for winio.
Documentation 
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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
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()
    }
}