use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RamInfo {
pub total: u64,
pub used: u64,
pub free: Option<u64>,
pub buffers: Option<u64>,
pub cached: Option<u64>,
pub shared: Option<u64>,
pub lfb: Option<u32>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SwapInfo {
pub total: Option<u64>,
pub used: Option<u64>,
pub cached: Option<u64>,
}
impl SwapInfo {
pub fn total_or_zero(&self) -> u64 {
self.total.unwrap_or(0)
}
pub fn used_or_zero(&self) -> u64 {
self.used.unwrap_or(0)
}
pub fn cached_or_zero(&self) -> u64 {
self.cached.unwrap_or(0)
}
pub fn is_reported(&self) -> bool {
self.total.is_some()
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EmcInfo {
pub online: bool,
pub clock_percent_of_max: u32,
pub current: u32,
pub max: u32,
pub min: u32,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct IramInfo {
pub total: u64,
pub used: u64,
pub lfb: Option<u32>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MemoryStats {
pub ram: RamInfo,
pub swap: SwapInfo,
pub emc: Option<EmcInfo>,
pub iram: Option<IramInfo>,
}
impl MemoryStats {
pub fn empty() -> Self {
Self {
ram: RamInfo {
total: 0,
used: 0,
free: None,
buffers: None,
cached: None,
shared: None,
lfb: None,
},
swap: SwapInfo {
total: None,
used: None,
cached: None,
},
emc: None,
iram: None,
}
}
pub fn ram_usage_percent(&self) -> Option<f32> {
if self.ram.total == 0 {
None
} else {
Some((self.ram.used as f32 / self.ram.total as f32) * 100.0)
}
}
pub fn swap_usage_percent(&self) -> Option<f32> {
let total = self.swap.total?;
let used = self.swap.used?;
if total == 0 {
Some(0.0)
} else {
Some((used as f32 / total as f32) * 100.0)
}
}
pub fn swap_usage_percent_or_zero(&self) -> f32 {
self.swap_usage_percent().unwrap_or(0.0)
}
}
impl Default for MemoryStats {
fn default() -> Self {
Self::empty()
}
}