makeup 0.0.8

Stylish CLIs/TUIs for Rust!
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

use std::collections::HashMap;

use either::Either;

use crate::component::{Key, Mailbox, MakeupMessage, RawComponentMessage};
use crate::ui::UiControlMessage;
use crate::Component;

/// The post office is used for managing component mailboxes, including sending
/// and receiving messages.
#[derive(Debug)]
pub struct PostOffice<Message: std::fmt::Debug + Send + Sync + Clone> {
    boxes: HashMap<Key, Vec<RawComponentMessage<Message>>>,
    ui_mailbox: Vec<UiControlMessage>,
}

impl<Message: std::fmt::Debug + Send + Sync + Clone> PostOffice<Message> {
    /// Create a new post office instance.
    #[allow(clippy::new_without_default)]
    pub fn new() -> Self {
        Self {
            boxes: HashMap::new(),
            ui_mailbox: vec![],
        }
    }

    /// Send a message to the mailbox with the given key.
    pub fn send(&mut self, key: Key, message: Message) {
        self.boxes
            .entry(key)
            .or_default()
            .push(Either::Left(message));
    }

    /// Send an internal (makeup) message to the mailbox with the given key.
    pub fn send_makeup(&mut self, key: Key, message: MakeupMessage) {
        self.boxes
            .entry(key)
            .or_default()
            .push(Either::Right(message));
    }

    /// Send a UI control message to the UI message queue.
    pub fn send_control(&mut self, message: UiControlMessage) {
        self.ui_mailbox.push(message);
    }

    /// Get the mailbox for the given component.
    pub fn mailbox<C: Component<Message = Message> + ?Sized>(
        &self,
        component: &C,
    ) -> Option<&Mailbox<C>> {
        self.boxes.get(&component.key())
    }

    #[inline]
    #[doc(hidden)]
    pub fn clear_mailbox<C: Component<Message = Message> + ?Sized>(&mut self, component: &C) {
        if let Some(mailbox) = self.boxes.get_mut(&component.key()) {
            mailbox.clear();
        }
    }

    /// Get the UI message queue.
    pub(crate) fn ui_mailbox(&self) -> &Vec<UiControlMessage> {
        &self.ui_mailbox
    }

    /// Clear the UI message queue.
    pub(crate) fn clear_ui_mailbox(&mut self) {
        self.ui_mailbox.clear();
    }
}

#[doc(hidden)]
#[macro_export]
macro_rules! mail_pattern {
    ( $pattern:pat, MakeupMessage$($bullshit:tt)* ) => {
        Either::Right($pattern)
    };

    ( $pattern:pat, $x___:ty ) => {
        Either::Left($pattern)
    };
}

/// Check the mail for the current component. Clears mailboxes after reading.
///
/// Example:
///
/// ```ignore
/// use makeup::check_mail;
///
/// check_mail!(self, ctx, match _ {
///     MyMessage::Foo => {
///         // Handle your custom message here!
///     }
///     MakeupMessage::TextUpdate(text) => self.text = text.clone(),
/// });
/// ```
#[macro_export]
macro_rules! check_mail {
    ( $component:expr, $ctx:expr, $arms:expr ) => {{
        if let Some(mailbox) = $ctx.post_office.mailbox($component) {
            for message in mailbox.iter() {
                use either::Either;
                (makeup_macros::__do_check_mail_arms!($arms))
            }

            $ctx.post_office.clear_mailbox($component);
        }
    }};
}