Implement it in a cached and long running way

Author: Dlurak

Cargo.lock

@@ -4,5 +4,5 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
-rayon = "1.10.0"
 modules = { path = "modules" }
+itertools = "0.14.0"

Cargo.toml

@@ -1,5 +1,5 @@
 /// Color of a Module
-#[derive(Clone, Copy, Default)]
+#[derive(Clone, Copy, Default, Hash)]
 pub enum Color {
     Black,
     White,
@@ -34,7 +34,7 @@ impl Color {
     }
 }
 
-#[derive(Clone, Copy, Default)]
+#[derive(Clone, Copy, Default, Hash)]
 pub struct Style {
     pub fg: Color,
     pub bg: Color,

modules/src/colors.rs

@@ -1,7 +1,7 @@
 use std::fmt;
 
 // Those are only constructed in config.rs
-#[derive(Clone, Copy)]
+#[derive(Clone, Copy, Hash)]
 pub enum Icon {
     Manual(char),
     Time,

modules/src/icons.rs

@@ -4,13 +4,16 @@ use crate::{
     icons::Icon,
 };
 use battery::{units, Manager, State};
-use std::fmt;
+use std::{
+    fmt,
+    time::{Duration, Instant},
+};
 
-#[derive(Clone, Copy)]
 pub struct Battery {
-    pub percentage: u8,
-    pub is_charging: bool,
+    percentage: u8,
+    is_charging: bool,
     minimum_digits: usize,
+    manager: Manager,
 }
 
 impl fmt::Display for Battery {
@@ -38,11 +41,33 @@ impl ToModule for Battery {
             Some(Icon::Battery(perc))
         }
     }
+
+    fn update(&mut self) {
+        let battery = self
+            .manager
+            .batteries()
+            .ok()
+            .map(|mut batteries| batteries.next())
+            .flatten()
+            .and_then(|b| b.ok());
+
+        if let Some(battery) = battery {
+            self.percentage = battery.state_of_charge().get::<units::ratio::percent>() as u8;
+            self.is_charging = battery.state() != State::Discharging;
+        }
+    }
+
+    fn next_render_time(&self) -> Option<Instant> {
+        let percentage: f32 = self.percentage.into();
+        let secs = percentage.sqrt();
+        Some(Instant::now() + Duration::from_secs_f32(secs))
+    }
 }
 
 impl Battery {
     pub fn try_new(minimum_digits: usize) -> Result<Option<Self>, battery::errors::Error> {
-        let mut batteries = Manager::new()?.batteries()?;
+        let manager = Manager::new()?;
+        let mut batteries = manager.batteries()?;
         let battery = match batteries.next() {
             Some(val) => val,
             None => return Ok(None),
@@ -56,6 +81,7 @@ impl Battery {
             percentage,
             is_charging,
             minimum_digits,
+            manager,
         }))
     }
 }

modules/src/modules/battery.rs

@@ -3,37 +3,30 @@ use crate::{
     colors::{Color, Style},
     icons::Icon,
 };
-use std::{fmt, thread};
+use std::{
+    fmt,
+    time::{Duration, Instant},
+};
 use sysinfo::{CpuRefreshKind, RefreshKind, System};
 
 pub struct Cpu {
     usage: f32,
     minimum_digits: usize,
     decimal_places: usize,
+    system: System,
 }
 
 impl Cpu {
     pub fn new(minimum_digits: usize, decimal_places: usize) -> Self {
+        let specifics = RefreshKind::new().with_cpu(CpuRefreshKind::everything());
+        let system = System::new_with_specifics(specifics);
         Self {
-            usage: Self::total_average(),
+            usage: 0.0,
             minimum_digits,
             decimal_places,
+            system,
         }
     }
-
-    fn total_average() -> f32 {
-        let mut s =
-            System::new_with_specifics(RefreshKind::new().with_cpu(CpuRefreshKind::everything()));
-
-        thread::sleep(sysinfo::MINIMUM_CPU_UPDATE_INTERVAL);
-        s.refresh_cpu();
-
-        let cpus = s.cpus();
-
-        let cpu_sum = cpus.iter().map(|cpu| cpu.cpu_usage()).sum::<f32>();
-
-        cpu_sum / cpus.len() as f32
-    }
 }
 
 impl fmt::Display for Cpu {
@@ -56,4 +49,18 @@ impl ToModule for Cpu {
     fn icon(&self) -> Option<Icon> {
         Some(Icon::Cpu)
     }
+
+    fn update(&mut self) {
+        let s = &mut self.system;
+
+        s.refresh_cpu();
+
+        let cpus = s.cpus();
+        let cpu_sum = cpus.iter().map(|cpu| cpu.cpu_usage()).sum::<f32>();
+        self.usage = cpu_sum / cpus.len() as f32;
+    }
+
+    fn next_render_time(&self) -> Option<Instant> {
+        Some(Instant::now() + Duration::from_secs_f32(2.5))
+    }
 }

modules/src/modules/cpu.rs

@@ -4,8 +4,12 @@ use crate::{
     icons::Icon,
 };
 use chrono::Local;
-use std::fmt;
+use std::{
+    fmt,
+    time::{Duration, Instant},
+};
 
+#[derive(Clone, Copy)]
 pub struct DateTime<'a> {
     format: &'a str,
 }
@@ -37,4 +41,8 @@ impl ToModule for DateTime<'_> {
     fn style(&self) -> Style {
         Style::new_with_fg(Color::Magenta)
     }
+    fn next_render_time(&self) -> Option<Instant> {
+        // TODO: Calculate the actual needed instant
+        Some(Instant::now() + Duration::from_secs(1))
+    }
 }

modules/src/modules/datetime.rs

@@ -3,33 +3,34 @@ use crate::{
     colors::{Color, Style},
     icons::Icon,
 };
-use std::fmt;
+use std::{
+    fmt,
+    time::{Duration, Instant},
+};
 use sysinfo::{MemoryRefreshKind, RefreshKind, System};
 
 pub struct Memory {
     usage: f32,
     minimum_digits: usize,
     decimal_places: usize,
+    system: System,
 }
 
 impl Memory {
     pub fn new(minimum_digits: usize, decimal_places: usize) -> Self {
+        let specifics = RefreshKind::new().with_memory(MemoryRefreshKind::everything());
+        let mut system = System::new_with_specifics(specifics);
+        system.refresh_memory();
+
+        let usage = (system.used_memory() as f32 / system.total_memory() as f32) * 100.0;
+
         Self {
-            usage: Self::total_usage(),
+            usage,
             minimum_digits,
             decimal_places,
+            system,
         }
     }
-
-    fn total_usage() -> f32 {
-        let mut sys = System::new_with_specifics(
-            RefreshKind::new().with_memory(MemoryRefreshKind::everything()),
-        );
-
-        sys.refresh_memory();
-
-        (sys.used_memory() as f32 / sys.total_memory() as f32) * 100.0
-    }
 }
 
 impl fmt::Display for Memory {
@@ -52,4 +53,14 @@ impl ToModule for Memory {
     fn icon(&self) -> Option<Icon> {
         Some(Icon::DoubleServer)
     }
+
+    fn update(&mut self) {
+        let system = &mut self.system;
+        system.refresh_memory();
+        self.usage = (system.used_memory() as f32 / system.total_memory() as f32) * 100.0;
+    }
+
+    fn next_render_time(&self) -> Option<Instant> {
+        Some(Instant::now() + Duration::from_secs_f32(7.5))
+    }
 }