sysinfo/
serde.rs

1// Take a look at the license at the top of the repository in the LICENSE file.
2
3#[cfg(any(
4    feature = "component",
5    feature = "disk",
6    feature = "network",
7    feature = "system",
8    feature = "user"
9))]
10use serde::{ser::SerializeStruct, Serialize, Serializer};
11
12#[cfg(feature = "disk")]
13impl Serialize for crate::Disk {
14    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
15    where
16        S: Serializer,
17    {
18        // `7` corresponds to the (maximum) number of fields.
19        let mut state = serializer.serialize_struct("Disk", 7)?;
20
21        state.serialize_field("DiskKind", &self.kind())?;
22        if let Some(s) = self.name().to_str() {
23            state.serialize_field("name", s)?;
24        }
25        state.serialize_field("file_system", &self.file_system())?;
26        state.serialize_field("mount_point", &self.mount_point())?;
27        state.serialize_field("total_space", &self.total_space())?;
28        state.serialize_field("available_space", &self.available_space())?;
29        state.serialize_field("is_removable", &self.is_removable())?;
30
31        state.end()
32    }
33}
34
35#[cfg(feature = "disk")]
36impl Serialize for crate::Disks {
37    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
38    where
39        S: Serializer,
40    {
41        serializer.collect_seq(self.iter())
42    }
43}
44
45#[cfg(feature = "disk")]
46impl Serialize for crate::DiskKind {
47    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
48    where
49        S: Serializer,
50    {
51        let (index, variant, maybe_value) = match *self {
52            Self::HDD => (0, "HDD", None),
53            Self::SSD => (1, "SSD", None),
54            Self::Unknown(ref s) => (2, "Unknown", Some(s)),
55        };
56
57        if let Some(ref value) = maybe_value {
58            serializer.serialize_newtype_variant("DiskKind", index, variant, value)
59        } else {
60            serializer.serialize_unit_variant("DiskKind", index, variant)
61        }
62    }
63}
64
65#[cfg(feature = "system")]
66impl Serialize for crate::Pid {
67    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
68    where
69        S: Serializer,
70    {
71        serializer.serialize_newtype_struct("Pid", &self.to_string())
72    }
73}
74
75#[cfg(feature = "system")]
76impl Serialize for crate::Process {
77    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
78    where
79        S: Serializer,
80    {
81        // `19` corresponds to the (maximum) number of fields.
82        let mut state = serializer.serialize_struct("Process", 19)?;
83
84        state.serialize_field("name", &self.name())?;
85        state.serialize_field("cmd", &self.cmd())?;
86        state.serialize_field("exe", &self.exe())?;
87        state.serialize_field("pid", &self.pid().as_u32())?;
88        state.serialize_field("environ", &self.environ())?;
89        state.serialize_field("cwd", &self.cwd())?;
90        state.serialize_field("root", &self.root())?;
91        state.serialize_field("memory", &self.memory())?;
92        state.serialize_field("virtual_memory", &self.virtual_memory())?;
93        state.serialize_field("parent", &self.parent())?;
94        state.serialize_field("status", &self.status())?;
95        state.serialize_field("start_time", &self.start_time())?;
96        state.serialize_field("run_time", &self.run_time())?;
97        state.serialize_field("cpu_usage", &self.cpu_usage())?;
98        state.serialize_field("accumulated_cpu_time", &self.accumulated_cpu_time())?;
99        state.serialize_field("disk_usage", &self.disk_usage())?;
100        state.serialize_field("user_id", &self.user_id())?;
101        state.serialize_field("group_id", &self.group_id())?;
102        state.serialize_field("session_id", &self.session_id())?;
103
104        state.end()
105    }
106}
107
108#[cfg(feature = "system")]
109impl Serialize for crate::Cpu {
110    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
111    where
112        S: Serializer,
113    {
114        // `5` corresponds to the number of fields.
115        let mut state = serializer.serialize_struct("Cpu", 5)?;
116
117        state.serialize_field("cpu_usage", &self.cpu_usage())?;
118        state.serialize_field("name", &self.name())?;
119        state.serialize_field("vendor_id", &self.vendor_id())?;
120        state.serialize_field("brand", &self.brand())?;
121        state.serialize_field("frequency", &self.frequency())?;
122
123        state.end()
124    }
125}
126
127#[cfg(feature = "system")]
128impl serde::Serialize for crate::System {
129    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
130    where
131        S: serde::Serializer,
132    {
133        // `19` corresponds to the number of fields.
134        let mut state = serializer.serialize_struct("System", 19)?;
135
136        state.serialize_field("global_cpu_usage", &self.global_cpu_usage())?;
137        state.serialize_field("cpus", &self.cpus())?;
138
139        state.serialize_field("physical_core_count", &Self::physical_core_count())?;
140        state.serialize_field("total_memory", &self.total_memory())?;
141        state.serialize_field("free_memory", &self.free_memory())?;
142        state.serialize_field("available_memory", &self.available_memory())?;
143        state.serialize_field("used_memory", &self.used_memory())?;
144        state.serialize_field("total_swap", &self.total_swap())?;
145        state.serialize_field("free_swap", &self.free_swap())?;
146        state.serialize_field("used_swap", &self.used_swap())?;
147
148        state.serialize_field("uptime", &Self::uptime())?;
149        state.serialize_field("boot_time", &Self::boot_time())?;
150        state.serialize_field("load_average", &Self::load_average())?;
151        state.serialize_field("name", &Self::name())?;
152        state.serialize_field("kernel_version", &Self::kernel_version())?;
153        state.serialize_field("os_version", &Self::os_version())?;
154        state.serialize_field("long_os_version", &Self::long_os_version())?;
155        state.serialize_field("distribution_id", &Self::distribution_id())?;
156        state.serialize_field("host_name", &Self::host_name())?;
157
158        state.end()
159    }
160}
161
162#[cfg(feature = "system")]
163impl Serialize for crate::CGroupLimits {
164    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
165    where
166        S: Serializer,
167    {
168        // `3` corresponds to the number of fields.
169        let mut state = serializer.serialize_struct("CGroupLimits", 3)?;
170
171        state.serialize_field("total_memory", &self.total_memory)?;
172        state.serialize_field("free_memory", &self.free_memory)?;
173        state.serialize_field("free_swap", &self.free_swap)?;
174
175        state.end()
176    }
177}
178
179#[cfg(feature = "system")]
180impl Serialize for crate::ThreadKind {
181    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
182    where
183        S: Serializer,
184    {
185        let (index, variant) = match *self {
186            Self::Kernel => (0, "Kernel"),
187            Self::Userland => (1, "Userland"),
188        };
189
190        serializer.serialize_unit_variant("ThreadKind", index, variant)
191    }
192}
193
194#[cfg(feature = "system")]
195impl Serialize for crate::Signal {
196    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
197    where
198        S: Serializer,
199    {
200        let (index, variant) = match *self {
201            Self::Hangup => (0, "Hangup"),
202            Self::Interrupt => (1, "Interrupt"),
203            Self::Quit => (2, "Quit"),
204            Self::Illegal => (3, "Illegal"),
205            Self::Trap => (4, "Trap"),
206            Self::Abort => (5, "Abort"),
207            Self::IOT => (6, "IOT"),
208            Self::Bus => (7, "Bus"),
209            Self::FloatingPointException => (8, "FloatingPointException"),
210            Self::Kill => (9, "Kill"),
211            Self::User1 => (10, "User1"),
212            Self::Segv => (11, "Segv"),
213            Self::User2 => (12, "User2"),
214            Self::Pipe => (13, "Pipe"),
215            Self::Alarm => (14, "Alarm"),
216            Self::Term => (15, "Term"),
217            Self::Child => (16, "Child"),
218            Self::Continue => (17, "Continue"),
219            Self::Stop => (18, "Stop"),
220            Self::TSTP => (19, "TSTP"),
221            Self::TTIN => (20, "TTIN"),
222            Self::TTOU => (21, "TTOU"),
223            Self::Urgent => (22, "Urgent"),
224            Self::XCPU => (23, "XCPU"),
225            Self::XFSZ => (24, "XFSZ"),
226            Self::VirtualAlarm => (25, "VirtualAlarm"),
227            Self::Profiling => (26, "Profiling"),
228            Self::Winch => (27, "Winch"),
229            Self::IO => (28, "IO"),
230            Self::Poll => (29, "Poll"),
231            Self::Power => (30, "Power"),
232            Self::Sys => (31, "Sys"),
233        };
234
235        serializer.serialize_unit_variant("Signal", index, variant)
236    }
237}
238
239#[cfg(feature = "system")]
240impl Serialize for crate::LoadAvg {
241    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
242    where
243        S: Serializer,
244    {
245        // `3` corresponds to the number of fields.
246        let mut state = serializer.serialize_struct("LoadAvg", 3)?;
247
248        state.serialize_field("one", &self.one)?;
249        state.serialize_field("five", &self.five)?;
250        state.serialize_field("fifteen", &self.fifteen)?;
251        state.end()
252    }
253}
254
255#[cfg(feature = "system")]
256impl Serialize for crate::ProcessStatus {
257    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
258    where
259        S: Serializer,
260    {
261        let (index, variant, maybe_value) = match *self {
262            Self::Idle => (0, "Idle", None),
263            Self::Run => (1, "Run", None),
264            Self::Sleep => (2, "Sleep", None),
265            Self::Stop => (3, "Stop", None),
266            Self::Zombie => (4, "Zombie", None),
267            Self::Tracing => (5, "Tracing", None),
268            Self::Dead => (6, "Dead", None),
269            Self::Wakekill => (7, "Wakekill", None),
270            Self::Waking => (8, "Waking", None),
271            Self::Parked => (9, "Parked", None),
272            Self::LockBlocked => (10, "LockBlocked", None),
273            Self::UninterruptibleDiskSleep => (11, "UninterruptibleDiskSleep", None),
274            Self::Unknown(n) => (12, "Unknown", Some(n)),
275        };
276
277        if let Some(ref value) = maybe_value {
278            serializer.serialize_newtype_variant("ProcessStatus", index, variant, value)
279        } else {
280            serializer.serialize_unit_variant("ProcessStatus", index, variant)
281        }
282    }
283}
284
285#[cfg(feature = "system")]
286impl Serialize for crate::DiskUsage {
287    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
288    where
289        S: Serializer,
290    {
291        // `4` corresponds to the number of fields.
292        let mut state = serializer.serialize_struct("DiskUsage", 4)?;
293
294        state.serialize_field("total_written_bytes", &self.total_written_bytes)?;
295        state.serialize_field("written_bytes", &self.written_bytes)?;
296        state.serialize_field("total_read_bytes", &self.total_read_bytes)?;
297        state.serialize_field("read_bytes", &self.read_bytes)?;
298
299        state.end()
300    }
301}
302
303#[cfg(feature = "component")]
304impl Serialize for crate::Components {
305    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
306    where
307        S: Serializer,
308    {
309        serializer.collect_seq(self.iter())
310    }
311}
312
313#[cfg(feature = "component")]
314impl Serialize for crate::Component {
315    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
316    where
317        S: Serializer,
318    {
319        // `4` corresponds to the number of fields.
320        let mut state = serializer.serialize_struct("Component", 4)?;
321
322        state.serialize_field("temperature", &self.temperature())?;
323        state.serialize_field("max", &self.max())?;
324        state.serialize_field("critical", &self.critical())?;
325        state.serialize_field("label", &self.label())?;
326
327        state.end()
328    }
329}
330
331#[cfg(feature = "network")]
332impl Serialize for crate::Networks {
333    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
334    where
335        S: Serializer,
336    {
337        serializer.collect_seq(self.iter())
338    }
339}
340
341#[cfg(feature = "network")]
342impl Serialize for crate::NetworkData {
343    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
344    where
345        S: Serializer,
346    {
347        // `14` corresponds to the number of fields.
348        let mut state = serializer.serialize_struct("NetworkData", 14)?;
349
350        state.serialize_field("received", &self.received())?;
351        state.serialize_field("total_received", &self.total_received())?;
352        state.serialize_field("transmitted", &self.transmitted())?;
353        state.serialize_field("total_transmitted", &self.total_transmitted())?;
354        state.serialize_field("packets_received", &self.packets_received())?;
355        state.serialize_field("total_packets_received", &self.total_packets_received())?;
356        state.serialize_field("packets_transmitted", &self.packets_transmitted())?;
357        state.serialize_field(
358            "total_packets_transmitted",
359            &self.total_packets_transmitted(),
360        )?;
361        state.serialize_field("errors_on_received", &self.errors_on_received())?;
362        state.serialize_field("total_errors_on_received", &self.total_errors_on_received())?;
363        state.serialize_field("errors_on_transmitted", &self.errors_on_transmitted())?;
364        state.serialize_field(
365            "total_errors_on_transmitted",
366            &self.total_errors_on_transmitted(),
367        )?;
368        state.serialize_field("mac_address", &self.mac_address())?;
369        state.serialize_field("ip_networks", &self.ip_networks())?;
370        state.serialize_field("mtu", &self.mtu())?;
371
372        state.end()
373    }
374}
375
376#[cfg(feature = "network")]
377impl Serialize for crate::MacAddr {
378    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
379    where
380        S: Serializer,
381    {
382        serializer.serialize_newtype_struct("MacAddr", &self.0)
383    }
384}
385
386#[cfg(feature = "network")]
387impl Serialize for crate::IpNetwork {
388    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
389    where
390        S: Serializer,
391    {
392        let mut state = serializer.serialize_struct("IpNetwork", 2)?;
393
394        state.serialize_field("addr", &self.addr)?;
395        state.serialize_field("prefix", &self.prefix)?;
396
397        state.end()
398    }
399}
400
401#[cfg(feature = "user")]
402impl Serialize for crate::Users {
403    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
404    where
405        S: Serializer,
406    {
407        serializer.collect_seq(self.iter())
408    }
409}
410
411#[cfg(feature = "user")]
412impl Serialize for crate::User {
413    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
414    where
415        S: Serializer,
416    {
417        // `4` corresponds to the number of fields.
418        let mut state = serializer.serialize_struct("User", 4)?;
419
420        state.serialize_field("id", &self.id())?;
421        state.serialize_field("group_id", &self.group_id())?;
422        state.serialize_field("name", &self.name())?;
423        state.serialize_field("groups", &self.groups())?;
424
425        state.end()
426    }
427}
428
429#[cfg(feature = "user")]
430impl Serialize for crate::Group {
431    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
432    where
433        S: Serializer,
434    {
435        // `2` corresponds to the number of fields.
436        let mut state = serializer.serialize_struct("Group", 2)?;
437
438        state.serialize_field("id", &self.id())?;
439        state.serialize_field("name", &self.name())?;
440
441        state.end()
442    }
443}
444
445#[cfg(any(feature = "user", feature = "system"))]
446impl Serialize for crate::Gid {
447    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
448    where
449        S: Serializer,
450    {
451        serializer.serialize_newtype_struct("Gid", &self.to_string())
452    }
453}
454
455#[cfg(any(feature = "user", feature = "system"))]
456impl Serialize for crate::Uid {
457    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
458    where
459        S: Serializer,
460    {
461        serializer.serialize_newtype_struct("Uid", &self.to_string())
462    }
463}
sysinfo/serde.rs

sysinfo/
serde.rs
