feat: swap support for windows, android, openwrt and netbsd

src/android/mod.rs

@@ -360,15 +360,42 @@ impl MemoryReadout for AndroidMemoryReadout {
     }
 
     fn swap_total(&self) -> Result<u64, ReadoutError> {
-        return Err(ReadoutError::NotImplemented);
+        let mut info = self.sysinfo;
+        let info_ptr: *mut sysinfo = &mut info;
+        let ret = unsafe { sysinfo(info_ptr) };
+        if ret != -1 {
+            Ok(info.totalswap as u64 * info.mem_unit as u64 / 1024)
+        } else {
+            Err(ReadoutError::Other(
+                "Something went wrong during the initialization of the sysinfo struct.".to_string(),
+            ))
+        }
     }
 
     fn swap_free(&self) -> Result<u64, ReadoutError> {
-        return Err(ReadoutError::NotImplemented);
+        let mut info = self.sysinfo;
+        let info_ptr: *mut sysinfo = &mut info;
+        let ret = unsafe { sysinfo(info_ptr) };
+        if ret != -1 {
+            Ok(info.freeswap as u64 * info.mem_unit as u64 / 1024)
+        } else {
+            Err(ReadoutError::Other(
+                "Something went wrong during the initialization of the sysinfo struct.".to_string(),
+            ))
+        }
     }
 
     fn swap_used(&self) -> Result<u64, ReadoutError> {
-        return Err(ReadoutError::NotImplemented);
+        let mut info = self.sysinfo;
+        let info_ptr: *mut sysinfo = &mut info;
+        let ret = unsafe { sysinfo(info_ptr) };
+        if ret != -1 {
+            Ok((info.totalswap as u64 - info.freeswap as u64) * info.mem_unit as u64 / 1024)
+        } else {
+            Err(ReadoutError::Other(
+                "Something went wrong during the initialization of the sysinfo struct.".to_string(),
+            ))
+        }
     }
 }
 

src/freebsd/mod.rs

@@ -351,15 +351,15 @@ impl MemoryReadout for FreeBSDMemoryReadout {
     }
 
     fn swap_total(&self) -> Result<u64, ReadoutError> {
-        return Err(ReadoutError::NotImplemented);
+        Err(ReadoutError::NotImplemented)
     }
 
     fn swap_free(&self) -> Result<u64, ReadoutError> {
-        return Err(ReadoutError::NotImplemented);
+        Err(ReadoutError::NotImplemented)
     }
 
     fn swap_used(&self) -> Result<u64, ReadoutError> {
-        return Err(ReadoutError::NotImplemented);
+        Err(ReadoutError::NotImplemented)
     }
 }
 

src/macos/mod.rs

@@ -491,15 +491,15 @@ impl MemoryReadout for MacOSMemoryReadout {
     }
 
     fn swap_total(&self) -> Result<u64, ReadoutError> {
-        return Err(ReadoutError::NotImplemented);
+        Err(ReadoutError::NotImplemented)
     }
 
     fn swap_free(&self) -> Result<u64, ReadoutError> {
-        return Err(ReadoutError::NotImplemented);
+        Err(ReadoutError::NotImplemented)
     }
 
     fn swap_used(&self) -> Result<u64, ReadoutError> {
-        return Err(ReadoutError::NotImplemented);
+        Err(ReadoutError::NotImplemented)
     }
 }
 

src/netbsd/mod.rs

@@ -381,15 +381,18 @@ impl MemoryReadout for NetBSDMemoryReadout {
     }
 
     fn swap_total(&self) -> Result<u64, ReadoutError> {
-        return Err(ReadoutError::NotImplemented);
+        Ok(shared::get_meminfo_value("SwapTotal"))
     }
 
     fn swap_free(&self) -> Result<u64, ReadoutError> {
-        return Err(ReadoutError::NotImplemented);
+        Ok(shared::get_meminfo_value("SwapFree"))
     }
 
     fn swap_used(&self) -> Result<u64, ReadoutError> {
-        return Err(ReadoutError::NotImplemented);
+        let total = self.swap_total()?;
+        let free = self.swap_free()?;
+
+        Ok(total - free)
     }
 }
 

src/openwrt/mod.rs

@@ -290,15 +290,42 @@ impl MemoryReadout for OpenWrtMemoryReadout {
     }
 
     fn swap_total(&self) -> Result<u64, ReadoutError> {
-        return Err(ReadoutError::NotImplemented);
+        let mut info = self.sysinfo;
+        let info_ptr: *mut sysinfo = &mut info;
+        let ret = unsafe { sysinfo(info_ptr) };
+        if ret != -1 {
+            Ok(info.totalswap as u64 * info.mem_unit as u64 / 1024)
+        } else {
+            Err(ReadoutError::Other(
+                "Something went wrong during the initialization of the sysinfo struct.".to_string(),
+            ))
+        }
     }
 
     fn swap_free(&self) -> Result<u64, ReadoutError> {
-        return Err(ReadoutError::NotImplemented);
+        let mut info = self.sysinfo;
+        let info_ptr: *mut sysinfo = &mut info;
+        let ret = unsafe { sysinfo(info_ptr) };
+        if ret != -1 {
+            Ok(info.freeswap as u64 * info.mem_unit as u64 / 1024)
+        } else {
+            Err(ReadoutError::Other(
+                "Something went wrong during the initialization of the sysinfo struct.".to_string(),
+            ))
+        }
     }
 
     fn swap_used(&self) -> Result<u64, ReadoutError> {
-        return Err(ReadoutError::NotImplemented);
+        let mut info = self.sysinfo;
+        let info_ptr: *mut sysinfo = &mut info;
+        let ret = unsafe { sysinfo(info_ptr) };
+        if ret != -1 {
+            Ok((info.totalswap as u64 - info.freeswap as u64) * info.mem_unit as u64 / 1024)
+        } else {
+            Err(ReadoutError::Other(
+                "Something went wrong during the initialization of the sysinfo struct.".to_string(),
+            ))
+        }
     }
 }
 

src/traits.rs

@@ -199,6 +199,21 @@ impl MemoryReadout for MacOSMemoryReadout {
         // Get the currently used memory.
         Ok(256 * 1024) // Return 256mb in kilobytes.
     }
+
+    fn swap_total(&self) -> Result<u64, ReadoutError> {
+        // Get the total virtual memory of the machine
+        Ok(512 * 1024) // Return 512mb in kilobytes.
+    }
+
+    fn swap_free(&self) -> Result<u64, ReadoutError> {
+        // Get the currently free virtual memory
+        Ok(256 * 1024) // Return 256mb in kilobytes.
+    }
+
+    fn swap_used(&self) -> Result<u64, ReadoutError> {
+        // Get the currently used virtual memory
+        Ok(256 * 1024) // Return 256mb in kilobytes.
+    }
 }
 
 ```

src/windows/mod.rs

@@ -111,7 +111,8 @@ impl MemoryReadout for WindowsMemoryReadout {
     }
 
     fn free(&self) -> Result<u64, ReadoutError> {
-        Err(ReadoutError::NotImplemented)
+        let memory_status = WindowsMemoryReadout::get_memory_status()?;
+        Ok(memory_status.ullAvailPhys / 1024u64)
     }
 
     fn buffers(&self) -> Result<u64, ReadoutError> {
@@ -132,15 +133,18 @@ impl MemoryReadout for WindowsMemoryReadout {
     }
 
     fn swap_total(&self) -> Result<u64, ReadoutError> {
-        return Err(ReadoutError::NotImplemented);
+        let memory_status = WindowsMemoryReadout::get_memory_status()?;
+        Ok(memory_status.ullTotalVirtual / 1024u64)
     }
 
     fn swap_free(&self) -> Result<u64, ReadoutError> {
-        return Err(ReadoutError::NotImplemented);
+        let memory_status = WindowsMemoryReadout::get_memory_status()?;
+        Ok(memory_status.ullAvailVirtual / 1024u64)
     }
 
     fn swap_used(&self) -> Result<u64, ReadoutError> {
-        return Err(ReadoutError::NotImplemented);
+        let memory_status = WindowsMemoryReadout::get_memory_status()?;
+        Ok((memory_status.ullTotalVirtual - memory_status.ullAvailVirtual) / 1024u64)
     }
 }