yule_log/
display.rs

1use std::fmt;
2use std::fmt::Formatter;
3
4use crate::model::inst::FieldValue;
5use crate::model::{def, inst, msg, CCharSlice};
6
7impl std::fmt::Display for inst::FieldValue {
8    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9        match self {
10            // Scalars
11            FieldValue::ScalarU8(v) => write!(f, "{v}"),
12            FieldValue::ScalarU16(v) => write!(f, "{v}"),
13            FieldValue::ScalarU32(v) => write!(f, "{v}"),
14            FieldValue::ScalarU64(v) => write!(f, "{v}"),
15            FieldValue::ScalarI8(v) => write!(f, "{v}"),
16            FieldValue::ScalarI16(v) => write!(f, "{v}"),
17            FieldValue::ScalarI32(v) => write!(f, "{v}"),
18            FieldValue::ScalarI64(v) => write!(f, "{v}"),
19            FieldValue::ScalarF32(v) => write!(f, "{v}"),
20            FieldValue::ScalarF64(v) => write!(f, "{v}"),
21            FieldValue::ScalarBool(v) => write!(f, "{v}"),
22            FieldValue::ScalarChar(c) => write!(f, "'{c}'"),
23            FieldValue::ScalarOther(fmt) => write!(f, "{{{fmt}}}"),
24
25            // Arrays
26            FieldValue::ArrayU8(arr) => Ok(fmt_array(arr, f)?),
27            FieldValue::ArrayU16(arr) => Ok(fmt_array(arr, f)?),
28            FieldValue::ArrayU32(arr) => Ok(fmt_array(arr, f)?),
29            FieldValue::ArrayU64(arr) => Ok(fmt_array(arr, f)?),
30            FieldValue::ArrayI8(arr) => Ok(fmt_array(arr, f)?),
31            FieldValue::ArrayI16(arr) => Ok(fmt_array(arr, f)?),
32            FieldValue::ArrayI32(arr) => Ok(fmt_array(arr, f)?),
33            FieldValue::ArrayI64(arr) => Ok(fmt_array(arr, f)?),
34            FieldValue::ArrayF32(arr) => Ok(fmt_array(arr, f)?),
35            FieldValue::ArrayF64(arr) => Ok(fmt_array(arr, f)?),
36            FieldValue::ArrayBool(arr) => Ok(fmt_array(arr, f)?),
37
38            FieldValue::ArrayChar(arr) => {
39                let s: String = arr.to_string_lossy();
40                write!(f, "\"{s}\"")
41            }
42
43            FieldValue::ArrayOther(arr) => {
44                let formatted: Vec<String> = arr.iter().map(|f| format!("{{{f}}}")).collect();
45                write!(f, "[{}]", formatted.join(", "))
46            }
47        }
48    }
49}
50
51// helper for formatting arrays
52fn fmt_array<T: fmt::Display>(arr: &[T], f: &mut Formatter<'_>) -> fmt::Result {
53    let s = arr
54        .iter()
55        .map(std::string::ToString::to_string)
56        .collect::<Vec<_>>()
57        .join(", ");
58    write!(f, "[{s}]")
59}
60
61impl fmt::Display for msg::Parameter {
62    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
63        write!(f, "{}: {}", self.key, self.value)
64    }
65}
66
67impl fmt::Display for inst::ParameterValue {
68    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
69        match self {
70            inst::ParameterValue::INT32(val) => write!(f, "{val}"),
71            inst::ParameterValue::FLOAT(val) => write!(f, "{val}"),
72        }
73    }
74}
75
76impl fmt::Display for msg::DefaultParameter {
77    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
78        let default_type = self.get_default_type();
79        let mut default_type_str = String::with_capacity(25);
80
81        if default_type.system_wide {
82            default_type_str.push_str("SystemWide");
83        }
84        if default_type.configuration {
85            if !default_type_str.is_empty() {
86                default_type_str.push('|');
87            }
88            default_type_str.push_str("Configuration");
89        }
90
91        write!(f, "{} ({}): {}", self.key, default_type_str, self.value)
92    }
93}
94
95impl fmt::Display for msg::Info {
96    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
97        write!(f, "{}: ", self.key)?;
98
99        match &self.value {
100            // Scalars
101            FieldValue::ScalarU8(val) => write!(f, "{val}")?,
102            FieldValue::ScalarU16(val) => write!(f, "{val}")?,
103            FieldValue::ScalarU32(val) => {
104                if self.key.starts_with("ver_") && self.key.ends_with("_release") {
105                    write!(f, "{val:#X}")?;
106                } else {
107                    write!(f, "{val}")?;
108                }
109            }
110            FieldValue::ScalarU64(val) => write!(f, "{val}")?,
111            FieldValue::ScalarI8(val) => write!(f, "{val}")?,
112            FieldValue::ScalarI16(val) => write!(f, "{val}")?,
113            FieldValue::ScalarI32(val) => write!(f, "{val}")?,
114            FieldValue::ScalarI64(val) => write!(f, "{val}")?,
115            FieldValue::ScalarF32(val) => write!(f, "{val}")?,
116            FieldValue::ScalarF64(val) => write!(f, "{val}")?,
117            FieldValue::ScalarBool(val) => write!(f, "{val}")?,
118            FieldValue::ScalarChar(ch) => write!(f, "{ch}")?,
119            FieldValue::ScalarOther(fmt) => write!(f, "{{{fmt}}}")?,
120
121            // Arrays
122            FieldValue::ArrayU8(arr) => fmt_array(arr, f)?,
123            FieldValue::ArrayU16(arr) => fmt_array(arr, f)?,
124            FieldValue::ArrayU32(arr) => fmt_array(arr, f)?,
125            FieldValue::ArrayU64(arr) => fmt_array(arr, f)?,
126            FieldValue::ArrayI8(arr) => fmt_array(arr, f)?,
127            FieldValue::ArrayI16(arr) => fmt_array(arr, f)?,
128            FieldValue::ArrayI32(arr) => fmt_array(arr, f)?,
129            FieldValue::ArrayI64(arr) => fmt_array(arr, f)?,
130            FieldValue::ArrayF32(arr) => fmt_array(arr, f)?,
131            FieldValue::ArrayF64(arr) => fmt_array(arr, f)?,
132            FieldValue::ArrayBool(arr) => fmt_array(arr, f)?,
133
134            FieldValue::ArrayChar(arr) => {
135                let s: String = arr.to_string_lossy();
136                write!(f, "\"{s}\"")?;
137            }
138
139            FieldValue::ArrayOther(arr) => {
140                let formatted: Vec<String> = arr.iter().map(|fmt| format!("{{{fmt}}}")).collect();
141                write!(f, "[{}]", formatted.join(", "))?;
142            }
143        }
144
145        Ok(())
146    }
147}
148
149impl fmt::Display for msg::MultiInfo {
150    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
151        write!(f, "{}: ", self.key)?;
152
153        match &self.value {
154            // Scalars
155            FieldValue::ScalarU8(val) => write!(f, "{val}")?,
156            FieldValue::ScalarU16(val) => write!(f, "{val}")?,
157            FieldValue::ScalarU32(val) => {
158                if self.key.starts_with("ver_") && self.key.ends_with("_release") {
159                    write!(f, "{val:#X}")?;
160                } else {
161                    write!(f, "{val}")?;
162                }
163            }
164            FieldValue::ScalarU64(val) => write!(f, "{val}")?,
165            FieldValue::ScalarI8(val) => write!(f, "{val}")?,
166            FieldValue::ScalarI16(val) => write!(f, "{val}")?,
167            FieldValue::ScalarI32(val) => write!(f, "{val}")?,
168            FieldValue::ScalarI64(val) => write!(f, "{val}")?,
169            FieldValue::ScalarF32(val) => write!(f, "{val}")?,
170            FieldValue::ScalarF64(val) => write!(f, "{val}")?,
171            FieldValue::ScalarBool(val) => write!(f, "{val}")?,
172            FieldValue::ScalarChar(ch) => write!(f, "{ch}")?,
173            FieldValue::ScalarOther(fmt) => write!(f, "{{{fmt}}}")?,
174
175            // Arrays
176            FieldValue::ArrayU8(arr) => fmt_array(arr, f)?,
177            FieldValue::ArrayU16(arr) => fmt_array(arr, f)?,
178            FieldValue::ArrayU32(arr) => fmt_array(arr, f)?,
179            FieldValue::ArrayU64(arr) => fmt_array(arr, f)?,
180            FieldValue::ArrayI8(arr) => fmt_array(arr, f)?,
181            FieldValue::ArrayI16(arr) => fmt_array(arr, f)?,
182            FieldValue::ArrayI32(arr) => fmt_array(arr, f)?,
183            FieldValue::ArrayI64(arr) => fmt_array(arr, f)?,
184            FieldValue::ArrayF32(arr) => fmt_array(arr, f)?,
185            FieldValue::ArrayF64(arr) => fmt_array(arr, f)?,
186            FieldValue::ArrayBool(arr) => fmt_array(arr, f)?,
187
188            FieldValue::ArrayChar(arr) => {
189                let s: String = arr.to_string_lossy();
190                write!(f, "\"{s}\"")?;
191            }
192
193            FieldValue::ArrayOther(arr) => {
194                let formatted: Vec<String> = arr.iter().map(|fmt| format!("{{{fmt}}}")).collect();
195                write!(f, "[{}]", formatted.join(", "))?;
196            }
197        }
198
199        Ok(())
200    }
201}
202
203impl fmt::Display for msg::Subscription {
204    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
205        write!(
206            f,
207            "Subscription: {} msg_id: {}",
208            self.message_name, self.msg_id
209        )
210    }
211}
212
213impl fmt::Display for def::Format {
214    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
215        //write!(f, "{}:", self.name)?;
216        for (i, field) in self.fields.iter().enumerate() {
217            if i > 0 {
218                write!(f, "; ")?;
219            }
220            write!(f, "{field}")?;
221        }
222        Ok(())
223    }
224}
225
226impl fmt::Display for def::Field {
227    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
228        write!(f, "{} {}", self.r#type, self.name)
229    }
230}
231
232impl fmt::Display for def::TypeExpr {
233    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
234        match self.array_size {
235            None => {
236                write!(f, "{}", self.base_type)
237            }
238            Some(array_size) => {
239                write!(f, "{}[{}]", self.base_type, array_size)
240            }
241        }
242    }
243}
244
245impl fmt::Display for def::BaseType {
246    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
247        match self {
248            def::BaseType::UINT8 => write!(f, "uint8_t"),
249            def::BaseType::UINT16 => write!(f, "uint16_t"),
250            def::BaseType::UINT32 => write!(f, "uint32_t"),
251            def::BaseType::UINT64 => write!(f, "uint64_t"),
252            def::BaseType::INT8 => write!(f, "int8_t"),
253            def::BaseType::INT16 => write!(f, "int16_t"),
254            def::BaseType::INT32 => write!(f, "int32_t"),
255            def::BaseType::INT64 => write!(f, "int64_t"),
256            def::BaseType::FLOAT => write!(f, "float"),
257            def::BaseType::DOUBLE => write!(f, "double"),
258            def::BaseType::BOOL => write!(f, "bool"),
259            def::BaseType::CHAR => write!(f, "char"),
260            def::BaseType::OTHER(s) => write!(f, "{s}"),
261        }
262    }
263}
264
265impl fmt::Display for inst::Format {
266    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
267        match &self.multi_id_index {
268            None => write!(f, "{name}", name = self.name),
269            Some(index) => write!(f, "{name}.{index:02}", name = self.name, index = index),
270        }
271    }
272}
273
274impl fmt::Display for msg::LoggedString {
275    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
276        match self.tag {
277            None => {
278                write!(f, "{} {}: {}", self.level, self.timestamp, self.msg)
279            }
280            Some(tag) => {
281                write!(
282                    f,
283                    "{} Tag: {} {}: {}",
284                    self.level, tag, self.timestamp, self.msg
285                )
286            }
287        }
288    }
289}
290
291impl fmt::Display for msg::LogLevel {
292    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
293        let level_str = match *self {
294            msg::LogLevel::Emerg => "EMERG",
295            msg::LogLevel::Alert => "ALERT",
296            msg::LogLevel::Crit => "CRIT",
297            msg::LogLevel::Err => "ERR",
298            msg::LogLevel::Warning => "WARNING",
299            msg::LogLevel::Notice => "NOTICE",
300            msg::LogLevel::Info => "INFO",
301            msg::LogLevel::Debug => "DEBUG",
302        };
303        write!(f, "{level_str}")
304    }
305}
306
307impl fmt::Display for msg::Dropout {
308    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
309        write!(f, "{}", self.duration)
310    }
311}
yule_log/display.rs

yule_log/
display.rs
