Using methods a bit more.

1 files changed, 40 insertions, 15 deletions

diff --git a/src/main.rs b/src/main.rs
index 74f3f08..a5fee1c 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -22,36 +22,60 @@ struct Cli {
     socket: String,
 }
 
-#[derive(Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize)]
 struct Battery {
 }
 
-#[derive(Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize)]
 struct Power {
 }
 
-#[derive(Serialize, Deserialize)]
+impl Power {
+    fn new() -> Self {
+        return Power{}
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize)]
 struct Process {
-    power: Power,
 }
 
-#[derive(Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize)]
+struct Memory {
+}
+
+impl Memory {
+    fn new() -> Self {
+        return Memory{}
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize)]
 struct State {
     asof: SystemTime,
+    power: Power,
+    memory: Memory,
 }
 
-type Result<T> = std::result::Result<T, Box<dyn error::Error>>;
+impl State {
+    fn new() -> Self {
+        let asof = SystemTime::now();
+        return State {
+            asof: asof,
+            power: Power::new(),
+            memory: Memory::new()
+        }
+    }
 
-fn init_state() -> State {
-    let asof = SystemTime::now();
-    return State {
-        asof: asof,
+    fn update(&mut self) {
+        self.asof = SystemTime::now();
     }
 }
 
+type Result<T> = std::result::Result<T, Box<dyn error::Error>>;
+
 fn update_state(state: &mut State) {
-    let asof = SystemTime::now();
-    state.asof = asof;
+    state.update();
 }
 
 fn get_state(sockfile: String) -> Result<State> {
@@ -67,7 +91,7 @@ fn main() {
         let start = Instant::now();
         let delay_ms: u64 = args.delay * 1000;
         let mut cycle: u64 = 0;
-        let state_mutex = Arc::new(Mutex::new(init_state()));
+        let state_mutex = Arc::new(Mutex::new(State::new()));
         let listen_thread = {
             let state_mutex = Arc::clone(&state_mutex);
             spawn(move || {
@@ -88,8 +112,6 @@ fn main() {
             });
         };
         loop {
-            cycle += 1;
-            sleep(Duration::from_millis(cycle*delay_ms) - start.elapsed());
             if args.verbose {
                 println!("{:?} elapsed; updating state...", start.elapsed());
             }
@@ -97,9 +119,12 @@ fn main() {
                 let mut state = state_mutex.lock().unwrap();
                 update_state(&mut state);
             }
+            cycle += 1;
+            sleep(Duration::from_millis(cycle*delay_ms) - start.elapsed());
         }
     } else {
         let state = get_state(args.socket).unwrap();
+        println!("{:#?}", state)
     }
 }