1use crate::engine::*;
2use melodium_core::common::executive::Level as LogLevel;
3use melodium_macro::{mel_data, mel_function, mel_treatment};
4
5#[mel_treatment(
6 model engine Engine
7 input messages Stream<string>
8)]
9pub async fn log_stream(level: Level, label: string) {
10 let engine = EngineModel::into(engine);
11
12 while let Ok(msgs) = messages
13 .recv_many()
14 .await
15 .map(|values| TryInto::<Vec<string>>::try_into(values).unwrap())
16 {
17 for msg in msgs {
18 engine
19 .world()
20 .log(level.level, label.clone(), msg, Some(track_id))
21 .await;
22 }
23 }
24}
25
26#[mel_treatment(
27 model engine Engine
28 input label Block<string>
29 input messages Stream<string>
30)]
31pub async fn log_stream_label(level: Level) {
32 let engine = EngineModel::into(engine);
33
34 if let Ok(label) = label
35 .recv_one()
36 .await
37 .map(|val| GetData::<String>::try_data(val).unwrap())
38 {
39 while let Ok(msgs) = messages
40 .recv_many()
41 .await
42 .map(|values| TryInto::<Vec<string>>::try_into(values).unwrap())
43 {
44 for msg in msgs {
45 engine
46 .world()
47 .log(level.level, label.clone(), msg, Some(track_id))
48 .await;
49 }
50 }
51 }
52}
53
54#[mel_treatment(
55 model engine Engine
56 input message Block<string>
57)]
58pub async fn log_block(level: Level, label: string) {
59 let engine = EngineModel::into(engine);
60
61 if let Ok(msg) = message
62 .recv_one()
63 .await
64 .map(|val| GetData::<string>::try_data(val).unwrap())
65 {
66 engine
67 .world()
68 .log(level.level, label, msg, Some(track_id))
69 .await;
70 }
71}
72
73#[mel_treatment(
74 model engine Engine
75 input label Block<string>
76 input message Block<string>
77)]
78pub async fn log_block_label(level: Level) {
79 let engine = EngineModel::into(engine);
80
81 if let Ok(label) = label
82 .recv_one()
83 .await
84 .map(|val| GetData::<String>::try_data(val).unwrap())
85 {
86 if let Ok(msg) = message
87 .recv_one()
88 .await
89 .map(|val| GetData::<string>::try_data(val).unwrap())
90 {
91 engine
92 .world()
93 .log(level.level, label, msg, Some(track_id))
94 .await;
95 }
96 }
97}
98
99#[mel_treatment(
100 model engine Engine
101 input display Stream<D>
102 generic D (Display)
103)]
104pub async fn log_data_stream(level: Level, label: string) {
105 let engine = EngineModel::into(engine);
106
107 while let Ok(values) = display
108 .recv_many()
109 .await
110 .map(|values| Into::<VecDeque<Value>>::into(values))
111 {
112 for val in values {
113 engine
114 .world()
115 .log(level.level, label.clone(), format!("{val}"), Some(track_id))
116 .await;
117 }
118 }
119}
120
121#[mel_treatment(
122 model engine Engine
123 input label Block<string>
124 input display Stream<D>
125 generic D (Display)
126)]
127pub async fn log_data_stream_label(level: Level) {
128 let engine = EngineModel::into(engine);
129
130 if let Ok(label) = label
131 .recv_one()
132 .await
133 .map(|val| GetData::<String>::try_data(val).unwrap())
134 {
135 while let Ok(values) = display
136 .recv_many()
137 .await
138 .map(|values| Into::<VecDeque<Value>>::into(values))
139 {
140 for val in values {
141 engine
142 .world()
143 .log(level.level, label.clone(), format!("{val}"), Some(track_id))
144 .await;
145 }
146 }
147 }
148}
149
150#[mel_treatment(
151 model engine Engine
152 input display Block<D>
153 generic D (Display)
154)]
155pub async fn log_data_block(level: Level, label: string) {
156 let engine = EngineModel::into(engine);
157
158 if let Ok(val) = display.recv_one().await {
159 engine
160 .world()
161 .log(level.level, label, format!("{val}"), Some(track_id))
162 .await;
163 }
164}
165
166#[mel_treatment(
167 model engine Engine
168 input label Block<string>
169 input display Block<D>
170 generic D (Display)
171)]
172pub async fn log_data_block_label(level: Level) {
173 let engine = EngineModel::into(engine);
174
175 if let Ok(label) = label
176 .recv_one()
177 .await
178 .map(|val| GetData::<String>::try_data(val).unwrap())
179 {
180 if let Ok(val) = display.recv_one().await {
181 engine
182 .world()
183 .log(level.level, label, format!("{val}"), Some(track_id))
184 .await;
185 }
186 }
187}
188
189#[derive(Debug, Serialize, Deserialize, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
190#[mel_data(traits(Serialize Deserialize Bounded PartialEquality Equality PartialOrder Order))]
191pub struct Level {
192 pub level: LogLevel,
193}
194
195fn level_bounded_min() -> Level {
196 Level {
197 level: LogLevel::Trace,
198 }
199}
200
201fn level_bounded_max() -> Level {
202 Level {
203 level: LogLevel::Error,
204 }
205}
206
207#[mel_function]
208pub fn error() -> Level {
209 Level {
210 level: LogLevel::Error,
211 }
212}
213
214#[mel_function]
215pub fn warning() -> Level {
216 Level {
217 level: LogLevel::Warning,
218 }
219}
220
221#[mel_function]
222pub fn info() -> Level {
223 Level {
224 level: LogLevel::Info,
225 }
226}
227
228#[mel_function]
229pub fn debug() -> Level {
230 Level {
231 level: LogLevel::Debug,
232 }
233}
234
235#[mel_function]
236pub fn trace() -> Level {
237 Level {
238 level: LogLevel::Trace,
239 }
240}