Extract Components from System

README.md

@@ -35,8 +35,8 @@ Otherwise, here is a little code sample:
 
 ```rust
 use sysinfo::{
-    Disks, DisksExt, NetworkExt, Networks, NetworksExt, ProcessExt, System,
-    SystemExt,
+    Components, ComponentsExt, Disks, DisksExt, NetworkExt, Networks,
+    NetworksExt, ProcessExt, System, SystemExt,
 };
 
 // Please note that we use "new_all" to ensure that all list of
@@ -65,16 +65,16 @@ println!("NB CPUs: {}", sys.cpus().len());
 
 // Display processes ID, name na disk usage:
 for (pid, process) in sys.processes() {
-    println!("[{}] {} {:?}", pid, process.name(), process.disk_usage());
+    println!("[{pid}] {} {:?}", process.name(), process.disk_usage());
 }
 
 // We display all disks' information:
 println!("=> disks:");
 let mut disks = Disks::new();
 // We refresh the disk list.
 disks.refresh_list();
-for disk in disks.disks() {
-    println!("{:?}", disk);
+for disk in disks.iter() {
+    println!("{disk:?}");
 }
 
 // Network interfaces name, data received and data transmitted:
@@ -83,13 +83,16 @@ let mut networks = Networks::new();
 networks.refresh_list();
 println!("=> networks:");
 for (interface_name, data) in &networks {
-    println!("{}: {}/{} B", interface_name, data.received(), data.transmitted());
+    println!("{interface_name}: {}/{} B", data.received(), data.transmitted());
 }
 
 // Components temperature:
+let mut components = Components::new();
+// We refresh the component list.
+components.refresh_list();
 println!("=> components:");
-for component in sys.components() {
-    println!("{:?}", component);
+for component in components.iter() {
+    println!("{component:?}");
 }
 ```
 

benches/basic.rs

@@ -3,7 +3,7 @@
 extern crate test;
 
 use sysinfo::get_current_pid;
-use sysinfo::{DiskExt, DisksExt, NetworksExt, SystemExt};
+use sysinfo::{ComponentsExt, DiskExt, DisksExt, NetworksExt, SystemExt};
 
 #[bench]
 fn bench_new(b: &mut test::Bencher) {
@@ -140,19 +140,21 @@ fn bench_refresh_cpu(b: &mut test::Bencher) {
 
 #[bench]
 fn bench_refresh_components(b: &mut test::Bencher) {
-    let mut s = sysinfo::System::new_all();
+    let mut c = sysinfo::Components::new();
+    c.refresh_list();
 
     b.iter(move || {
-        s.refresh_components();
+        c.refresh();
     });
 }
 
 #[bench]
 fn bench_refresh_components_list(b: &mut test::Bencher) {
-    let mut s = sysinfo::System::new_all();
+    let mut c = sysinfo::Components::new();
+    c.refresh_list();
 
     b.iter(move || {
-        s.refresh_components_list();
+        c.refresh_list();
     });
 }
 

examples/simple.c

@@ -58,15 +58,19 @@ bool process_loop(pid_t pid, CProcess process, void *data) {
 
 int main() {
     CSystem system = sysinfo_init();
+    CNetworks networks = sysinfo_networks_init();
+
     sysinfo_refresh_all(system);
+    sysinfo_networks_refresh_list(networks);
+
     printf("total memory:         %ld\n", sysinfo_total_memory(system));
     printf("free memory:          %ld\n", sysinfo_free_memory(system));
     printf("used memory:          %ld\n", sysinfo_used_memory(system));
     printf("total swap:           %ld\n", sysinfo_total_swap(system));
     printf("free swap:            %ld\n", sysinfo_free_swap(system));
     printf("used swap:            %ld\n", sysinfo_used_swap(system));
-    printf("networks received:    %ld\n", sysinfo_networks_received(system));
-    printf("networks transmitted: %ld\n", sysinfo_networks_transmitted(system));
+    printf("networks received:    %ld\n", sysinfo_networks_received(networks));
+    printf("networks transmitted: %ld\n", sysinfo_networks_transmitted(networks));
     unsigned int len = 0, i = 0;
     float *procs = NULL;
     sysinfo_cpus_usage(system, &len, &procs);
@@ -80,7 +84,8 @@ int main() {
     i = 0;
     printf("For a total of %ld processes.\n", sysinfo_processes(system, process_loop, &i));
     check_tasks(system);
-    // we can now free the CSystem object.
+    // we can now free the CSystem and the CNetworks objects.
     sysinfo_destroy(system);
+    sysinfo_networks_destroy(networks);
     return 0;
 }

examples/simple.rs

@@ -8,8 +8,8 @@ use std::io::{self, BufRead, Write};
 use std::str::FromStr;
 use sysinfo::Signal::*;
 use sysinfo::{
-    CpuExt, Disks, DisksExt, NetworkExt, Networks, NetworksExt, Pid, ProcessExt, Signal, System,
-    SystemExt, UserExt,
+    Components, ComponentsExt, CpuExt, Disks, DisksExt, NetworkExt, Networks, NetworksExt, Pid,
+    ProcessExt, Signal, System, SystemExt, UserExt,
 };
 
 const signals: &[Signal] = &[
@@ -147,6 +147,7 @@ fn interpret_input(
     sys: &mut System,
     networks: &mut Networks,
     disks: &mut Disks,
+    components: &mut Components,
 ) -> bool {
     match input.trim() {
         "help" => print_help(),
@@ -277,7 +278,7 @@ fn interpret_input(
             }
         }
         "temperature" => {
-            for component in sys.components() {
+            for component in components.iter() {
                 writeln!(&mut io::stdout(), "{component:?}");
             }
         }
@@ -438,11 +439,13 @@ fn interpret_input(
 
 fn main() {
     println!("Getting system information...");
-    let mut t = System::new_all();
-    let mut n = Networks::new();
-    let mut d = Disks::new();
-    n.refresh_list();
-    d.refresh_list();
+    let mut system = System::new_all();
+    let mut networks = Networks::new();
+    let mut disks = Disks::new();
+    let mut components = Components::new();
+    networks.refresh_list();
+    disks.refresh_list();
+    components.refresh_list();
     println!("Done.");
     let t_stin = io::stdin();
     let mut stin = t_stin.lock();
@@ -464,6 +467,12 @@ fn main() {
         if (&input as &str).ends_with('\n') {
             input.pop();
         }
-        done = interpret_input(input.as_ref(), &mut t, &mut n, &mut d);
+        done = interpret_input(
+            input.as_ref(),
+            &mut system,
+            &mut networks,
+            &mut disks,
+            &mut components,
+        );
     }
 }

md_doc/components.md

@@ -0,0 +1,11 @@
+Component interfaces.
+
+```no_run
+use sysinfo::{Components, ComponentsExt};
+
+let mut components = Components::new();
+components.refresh_list();
+for component in components.components() {
+    println!("{component:?}");
+}
+```

src/c_interface.rs

@@ -79,20 +79,6 @@ pub extern "C" fn sysinfo_refresh_cpu(system: CSystem) {
     }
 }
 
-/// Equivalent of [`System::refresh_components()`][crate::System#method.refresh_temperatures].
-#[no_mangle]
-pub extern "C" fn sysinfo_refresh_components(system: CSystem) {
-    assert!(!system.is_null());
-    unsafe {
-        let mut system: Box<System> = Box::from_raw(system as *mut System);
-        {
-            let system: &mut System = system.borrow_mut();
-            system.refresh_components();
-        }
-        Box::into_raw(system);
-    }
-}
-
 /// Equivalent of [`System::refresh_all()`][crate::System#method.refresh_all].
 #[no_mangle]
 pub extern "C" fn sysinfo_refresh_all(system: CSystem) {

src/common.rs

@@ -1,6 +1,8 @@
 // Take a look at the license at the top of the repository in the LICENSE file.
 
-use crate::{Disk, GroupExt, NetworkData, NetworksExt, User, UserExt};
+use crate::{
+    Component, Components, ComponentsExt, Disk, GroupExt, NetworkData, NetworksExt, User, UserExt,
+};
 
 use std::cmp::Ordering;
 use std::collections::HashMap;
@@ -367,8 +369,6 @@ pub struct RefreshKind {
     processes: Option<ProcessRefreshKind>,
     memory: bool,
     cpu: Option<CpuRefreshKind>,
-    components: bool,
-    components_list: bool,
     users_list: bool,
 }
 
@@ -383,8 +383,6 @@ impl RefreshKind {
     /// assert_eq!(r.processes().is_some(), false);
     /// assert_eq!(r.memory(), false);
     /// assert_eq!(r.cpu().is_some(), false);
-    /// assert_eq!(r.components(), false);
-    /// assert_eq!(r.components_list(), false);
     /// assert_eq!(r.users_list(), false);
     /// ```
     pub fn new() -> Self {
@@ -401,17 +399,13 @@ impl RefreshKind {
     /// assert_eq!(r.processes().is_some(), true);
     /// assert_eq!(r.memory(), true);
     /// assert_eq!(r.cpu().is_some(), true);
-    /// assert_eq!(r.components(), true);
-    /// assert_eq!(r.components_list(), true);
     /// assert_eq!(r.users_list(), true);
     /// ```
     pub fn everything() -> Self {
         Self {
             processes: Some(ProcessRefreshKind::everything()),
             memory: true,
             cpu: Some(CpuRefreshKind::everything()),
-            components: true,
-            components_list: true,
             users_list: true,
         }
     }
@@ -425,13 +419,6 @@ impl RefreshKind {
     );
     impl_get_set!(RefreshKind, memory, with_memory, without_memory);
     impl_get_set!(RefreshKind, cpu, with_cpu, without_cpu, CpuRefreshKind);
-    impl_get_set!(RefreshKind, components, with_components, without_components);
-    impl_get_set!(
-        RefreshKind,
-        components_list,
-        with_components_list,
-        without_components_list
-    );
     impl_get_set!(RefreshKind, users_list, with_users_list, without_users_list);
 }
 
@@ -490,15 +477,15 @@ impl<'a> Iterator for NetworksIter<'a> {
     }
 }
 
-/// Disks interfaces.
+/// Disk interfaces.
 ///
 /// ```no_run
 /// use sysinfo::{Disks, DisksExt};
 ///
 /// let mut disks = Disks::new();
 /// disks.refresh_list();
 /// for disk in disks.disks() {
-///     println!("{:?}", disk);
+///     println!("{disk:?}");
 /// }
 /// ```
 pub struct Disks {
@@ -542,6 +529,20 @@ pub enum DiskKind {
     Unknown(isize),
 }
 
+impl std::ops::Deref for Components {
+    type Target = [Component];
+
+    fn deref(&self) -> &Self::Target {
+        self.components()
+    }
+}
+
+impl std::ops::DerefMut for Components {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.components_mut()
+    }
+}
+
 /// An enum representing signals on UNIX-like systems.
 ///
 /// On non-unix systems, this enum is mostly useless and is only there to keep coherency between

src/debug.rs

@@ -1,8 +1,8 @@
 // Take a look at the license at the top of the repository in the LICENSE file.
 
 use crate::{
-    Component, ComponentExt, Cpu, CpuExt, Disk, DiskExt, Disks, NetworkData, NetworkExt, Networks,
-    NetworksExt, Process, ProcessExt, System, SystemExt, User, UserExt,
+    Component, ComponentExt, Components, Cpu, CpuExt, Disk, DiskExt, Disks, NetworkData,
+    NetworkExt, Networks, NetworksExt, Process, ProcessExt, System, SystemExt, User, UserExt,
 };
 
 use std::fmt;
@@ -30,7 +30,6 @@ impl fmt::Debug for System {
             .field("free swap", &self.free_swap())
             .field("nb CPUs", &self.cpus().len())
             .field("nb processes", &self.processes().len())
-            .field("nb components", &self.components().len())
             .finish()
     }
 }
@@ -76,6 +75,19 @@ impl fmt::Debug for Process {
     }
 }
 
+impl fmt::Debug for Components {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "Components {{ {} }}",
+            self.iter()
+                .map(|x| format!("{x:?}"))
+                .collect::<Vec<_>>()
+                .join(", ")
+        )
+    }
+}
+
 impl fmt::Debug for Component {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         if let Some(critical) = self.critical() {

src/lib.rs

@@ -56,10 +56,10 @@ pub use common::{
     Networks, NetworksIter, Pid, PidExt, ProcessRefreshKind, ProcessStatus, RefreshKind, Signal,
     Uid,
 };
-pub use sys::{Component, Cpu, Disk, NetworkData, Process, System, User};
+pub use sys::{Component, Components, Cpu, Disk, NetworkData, Process, System, User};
 pub use traits::{
-    ComponentExt, CpuExt, DiskExt, DisksExt, GroupExt, NetworkExt, NetworksExt, ProcessExt,
-    SystemExt, UserExt,
+    ComponentExt, ComponentsExt, CpuExt, DiskExt, DisksExt, GroupExt, NetworkExt, NetworksExt,
+    ProcessExt, SystemExt, UserExt,
 };
 
 #[cfg(feature = "c-interface")]

src/serde.rs

@@ -111,7 +111,6 @@ impl serde::Serialize for crate::System {
         state.serialize_field("free_swap", &self.free_swap())?;
         state.serialize_field("used_swap", &self.used_swap())?;
 
-        state.serialize_field("components", &self.components())?;
         state.serialize_field("users", &self.users())?;
 
         state.serialize_field("uptime", &self.uptime())?;
@@ -146,6 +145,15 @@ impl Serialize for crate::Disks {
     }
 }
 
+impl Serialize for crate::Components {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.collect_seq(self.iter())
+    }
+}
+
 impl Serialize for Signal {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where

src/sysinfo.h

@@ -19,7 +19,6 @@ void        sysinfo_networks_destroy(CNetworks networks);
 void        sysinfo_refresh_system(CSystem system);
 void        sysinfo_refresh_memory(CSystem system);
 void        sysinfo_refresh_cpu(CSystem system);
-void        sysinfo_refresh_components(CSystem system);
 void        sysinfo_refresh_all(CSystem system);
 void        sysinfo_refresh_processes(CSystem system);
 #ifdef __linux__