moduforge_runtime/
macros.rs

1#[macro_export]
2macro_rules! node {
3    ($name:expr) => {
4        {
5            let mut node = $crate::node::Node::default();
6            node.set_name($name);
7            node
8        }
9    };
10    ($name:expr, $desc:expr) => {
11        {
12            let mut node = $crate::node::Node::default();
13            node.set_name($name).set_desc($desc);
14            node
15        }
16    };
17    ($name:expr, $desc:expr, $content:expr) => {
18        {
19            let mut node = $crate::node::Node::default();
20            node.set_name($name).set_desc($desc).set_content($content);
21            node
22        }
23    };
24    ($name:expr, $desc:expr, $content:expr, $($key:expr => $value:expr),*) => {
25        {
26            let mut node = $crate::node::Node::default();
27            node.set_name($name)
28                .set_desc($desc)
29                .set_content($content);
30            $(
31                node.set_attr($key, Some($value));
32            )*
33            node
34        }
35    };
36}
37
38#[macro_export]
39macro_rules! mark {
40    ($name:expr) => {
41        {
42            let mut mark = $crate::mark::Mark::default();
43            mark.set_name($name);
44            mark
45        }
46    };
47    ($name:expr, $desc:expr) => {
48        {
49            let mut mark = $crate::mark::Mark::default();
50            mark.set_name($name).set_desc($desc);
51            mark
52        }
53    };
54    ($name:expr, $desc:expr, $($key:expr => $value:expr),*) => {
55        {
56            let mut mark = $crate::mark::Mark::default();
57            mark.set_name($name)
58                .set_desc($desc);
59            $(
60                mark.set_attr($key, Some($value));
61            )*
62            mark
63        }
64    };
65}
66
67#[macro_export]
68macro_rules! impl_plugin {
69    ($name:ident, $append_fn:expr) => {
70        #[derive(Debug)]
71        pub struct $name {}
72
73        #[async_trait]
74        impl PluginTrait for $name
75        where
76            Self: Send + Sync,
77        {
78            async fn append_transaction(
79                &self,
80                trs: &[Transaction],
81                old_state: &State,
82                new_state: &State,
83            ) -> Option<Transaction> {
84                $append_fn(trs, old_state, new_state).await
85            }
86
87            async fn filter_transaction(
88                &self,
89                _tr: &Transaction,
90                _state: &State,
91            ) -> bool {
92                true
93            }
94        }
95    };
96    ($name:ident, $append_fn:expr, $filter_fn:expr) => {
97        #[derive(Debug)]
98        pub struct $name {}
99
100        #[async_trait]
101        impl PluginTrait for $name
102        where
103            Self: Send + Sync,
104        {
105            async fn append_transaction(
106                &self,
107                tr: &Transaction,
108                old_state: &State,
109                new_state: &State,
110            ) -> Option<Transaction> {
111                $append_fn(tr, old_state, new_state).await
112            }
113
114            async fn filter_transaction(
115                &self,
116                tr: &Transaction,
117                state: &State,
118            ) -> bool {
119                $filter_fn(tr, state)
120            }
121        }
122    };
123}
124
125#[macro_export]
126macro_rules! impl_state_field {
127    ($name:ident, $init_fn:expr, $apply_fn:expr) => {
128        #[derive(Debug)]
129        pub struct $name;
130
131        #[async_trait]
132        impl StateField for $name
133        where
134            Self: Send + Sync,
135        {
136            async fn init(
137                &self,
138                config: &StateConfig,
139                instance: Option<&State>,
140            ) -> PluginState {
141                $init_fn(config, instance).await
142            }
143
144            async fn apply(
145                &self,
146                tr: &Transaction,
147                value: PluginState,
148                old_state: &State,
149                new_state: &State,
150            ) -> PluginState {
151                $apply_fn(tr, value, old_state, new_state).await
152            }
153        }
154    };
155}
156
157#[macro_export]
158macro_rules! impl_command {
159    ($name:ident, $execute_fn:expr) => {
160        #[derive(Debug)]
161        pub struct $name;
162
163        #[async_trait]
164        impl Command for $name {
165            async fn execute(
166                &self,
167                tr: &mut Transaction,
168            ) -> Result<(), TransformError> {
169                $execute_fn(tr).await
170            }
171
172            fn name(&self) -> String {
173                stringify!($name).to_string()
174            }
175        }
176    };
177    ($name:ident, $execute_fn:expr, $name_str:expr) => {
178        #[derive(Debug)]
179        pub struct $name;
180
181        #[async_trait]
182        impl Command for $name {
183            async fn execute(
184                &self,
185                tr: &mut Transaction,
186            ) -> Result<(), TransformError> {
187                $execute_fn(tr).await
188            }
189
190            fn name(&self) -> String {
191                $name_str.to_string()
192            }
193        }
194    };
195}
moduforge_runtime/macros.rs

moduforge_runtime/
macros.rs
