util/error: init

src/cpu.rs

@@ -1,46 +1,8 @@
 use crate::core::{GovernorOverrideMode, TurboSetting};
+use crate::util::error::ControlError;
 use core::str;
 use std::{fs, io, path::Path, string::ToString};
 
-#[derive(Debug)]
-pub enum ControlError {
-    Io(io::Error),
-    WriteError(String),
-    InvalidValueError(String),
-    NotSupported(String),
-    PermissionDenied(String),
-    InvalidProfile(String),
-}
-
-impl From<io::Error> for ControlError {
-    fn from(err: io::Error) -> Self {
-        match err.kind() {
-            io::ErrorKind::PermissionDenied => Self::PermissionDenied(err.to_string()),
-            _ => Self::Io(err),
-        }
-    }
-}
-
-impl std::fmt::Display for ControlError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::Io(e) => write!(f, "I/O error: {e}"),
-            Self::WriteError(s) => write!(f, "Failed to write to sysfs path: {s}"),
-            Self::InvalidValueError(s) => write!(f, "Invalid value for setting: {s}"),
-            Self::NotSupported(s) => write!(f, "Control action not supported: {s}"),
-            Self::PermissionDenied(s) => {
-                write!(f, "Permission denied: {s}. Try running with sudo.")
-            }
-            Self::InvalidProfile(s) => {
-                write!(
-                    f,
-                    "Invalid platform control profile {s} supplied, please provide a valid one."
-                )
-            }
-        }
-    }
-}
-
 impl std::error::Error for ControlError {}
 
 pub type Result<T, E = ControlError> = std::result::Result<T, E>;

src/engine.rs

@@ -1,6 +1,7 @@
 use crate::config::{AppConfig, ProfileConfig};
 use crate::core::{OperationalMode, SystemReport, TurboSetting};
-use crate::cpu::{self, ControlError};
+use crate::cpu::{self};
+use crate::util::error::ControlError;
 
 #[derive(Debug)]
 pub enum EngineError {
@@ -66,8 +67,8 @@ pub fn determine_and_apply_settings(
         // If no batteries, assume AC power (desktop).
         // Otherwise, check the ac_connected status from the (first) battery.
         // XXX: This relies on the setting ac_connected in BatteryInfo being set correctly.
-        let on_ac_power = report.batteries.is_empty()
-            || report.batteries.first().is_some_and(|b| b.ac_connected);
+        let on_ac_power =
+            report.batteries.is_empty() || report.batteries.first().is_some_and(|b| b.ac_connected);
 
         if on_ac_power {
             println!("Engine: On AC power, selecting Charger profile.");

src/main.rs

@@ -5,9 +5,11 @@ mod cpu;
 mod daemon;
 mod engine;
 mod monitor;
+mod util;
 
 use crate::config::AppConfig;
 use crate::core::{GovernorOverrideMode, TurboSetting};
+use crate::util::error::ControlError;
 use clap::Parser;
 
 #[derive(Parser, Debug)]
@@ -216,8 +218,8 @@ fn main() {
         // For example, check if e.downcast_ref::<cpu::ControlError>() matches PermissionDenied
         // and print a more specific message like "Try running with sudo."
         // We'll revisit this in the future once CPU logic is more stable.
-        if let Some(control_error) = e.downcast_ref::<cpu::ControlError>() {
-            if matches!(control_error, cpu::ControlError::PermissionDenied(_)) {
+        if let Some(control_error) = e.downcast_ref::<ControlError>() {
+            if matches!(control_error, ControlError::PermissionDenied(_)) {
                 eprintln!(
                     "Hint: This operation may require administrator privileges (e.g., run with sudo)."
                 );

src/monitor.rs

@@ -1,5 +1,7 @@
 use crate::config::AppConfig;
 use crate::core::{BatteryInfo, CpuCoreInfo, CpuGlobalInfo, SystemInfo, SystemLoad, SystemReport};
+use crate::util::error::ControlError;
+use crate::util::error::SysMonitorError;
 use std::{
     collections::HashMap,
     fs, io,
@@ -10,35 +12,6 @@ use std::{
     time::SystemTime,
 };
 
-#[derive(Debug)]
-pub enum SysMonitorError {
-    Io(io::Error),
-    ReadError(String),
-    ParseError(String),
-    ProcStatParseError(String),
-    NotAvailable(String),
-}
-
-impl From<io::Error> for SysMonitorError {
-    fn from(err: io::Error) -> Self {
-        Self::Io(err)
-    }
-}
-
-impl std::fmt::Display for SysMonitorError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::Io(e) => write!(f, "I/O error: {e}"),
-            Self::ReadError(s) => write!(f, "Failed to read sysfs path: {s}"),
-            Self::ParseError(s) => write!(f, "Failed to parse value: {s}"),
-            Self::ProcStatParseError(s) => {
-                write!(f, "Failed to parse /proc/stat: {s}")
-            }
-            Self::NotAvailable(s) => write!(f, "Information not available: {s}"),
-        }
-    }
-}
-
 impl std::error::Error for SysMonitorError {}
 
 pub type Result<T, E = SysMonitorError> = std::result::Result<T, E>;

src/util/error.rs

@@ -0,0 +1,69 @@
+use std::io;
+
+#[derive(Debug)]
+pub enum ControlError {
+    Io(io::Error),
+    WriteError(String),
+    InvalidValueError(String),
+    NotSupported(String),
+    PermissionDenied(String),
+    InvalidProfile(String),
+}
+
+impl From<io::Error> for ControlError {
+    fn from(err: io::Error) -> Self {
+        match err.kind() {
+            io::ErrorKind::PermissionDenied => Self::PermissionDenied(err.to_string()),
+            _ => Self::Io(err),
+        }
+    }
+}
+
+impl std::fmt::Display for ControlError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Io(e) => write!(f, "I/O error: {e}"),
+            Self::WriteError(s) => write!(f, "Failed to write to sysfs path: {s}"),
+            Self::InvalidValueError(s) => write!(f, "Invalid value for setting: {s}"),
+            Self::NotSupported(s) => write!(f, "Control action not supported: {s}"),
+            Self::PermissionDenied(s) => {
+                write!(f, "Permission denied: {s}. Try running with sudo.")
+            }
+            Self::InvalidProfile(s) => {
+                write!(
+                    f,
+                    "Invalid platform control profile {s} supplied, please provide a valid one."
+                )
+            }
+        }
+    }
+}
+
+#[derive(Debug)]
+pub enum SysMonitorError {
+    Io(io::Error),
+    ReadError(String),
+    ParseError(String),
+    ProcStatParseError(String),
+    NotAvailable(String),
+}
+
+impl From<io::Error> for SysMonitorError {
+    fn from(err: io::Error) -> Self {
+        Self::Io(err)
+    }
+}
+
+impl std::fmt::Display for SysMonitorError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Io(e) => write!(f, "I/O error: {e}"),
+            Self::ReadError(s) => write!(f, "Failed to read sysfs path: {s}"),
+            Self::ParseError(s) => write!(f, "Failed to parse value: {s}"),
+            Self::ProcStatParseError(s) => {
+                write!(f, "Failed to parse /proc/stat: {s}")
+            }
+            Self::NotAvailable(s) => write!(f, "Information not available: {s}"),
+        }
+    }
+}

src/util/mod.rs

@@ -0,0 +1 @@
+pub mod error;