map/ model: make Vec<NodeInfo> a Hashmap<String, NodeInfo>

bin/map/src/main.rs

@@ -14,7 +14,7 @@ use log::{debug, info, trace};
 use serde_json::{json, Value};
 use simplelog::*;
 use smol::Executor;
-use std::collections::HashSet;
+use std::collections::{HashMap, HashSet};
 use std::{fs::File, io, io::Read, path::PathBuf};
 use termion::{async_stdin, event::Key, input::TermRead, raw::IntoRawMode};
 use tui::{
@@ -194,20 +194,22 @@ async fn poll(client: Map, model: Arc<Model>) -> Result<()> {
             inconnects.push(in0);
             inconnects.push(in1);
 
-            let infos = vec![NodeInfo {
+            let infos = NodeInfo {
                 // TODO: should never crash
-                id: id.as_str().unwrap().to_string(),
+                //id: id.as_str().unwrap().to_string(),
                 outgoing: outconnects,
                 incoming: inconnects,
-            }];
+            };
 
+            let mut node_info = HashMap::new();
+            node_info.insert(id.as_str().unwrap().to_string(), infos);
             let mut id_set = HashSet::new();
-            for node in infos {
-                id_set.insert(node.id);
+            for (id, value) in node_info {
+                id_set.insert(id.clone());
                 // update node info if we don't have it already
                 //if !model.id_list.node_id.lock().await.contains(&node.clone().id) {
 
-                //model.info_list.infos.lock().await.push(node.clone());
+                model.info_list.infos.lock().await.insert(id, value);
                 //debug!("Model ID list: {:?}", model.id_list.node_id.lock().await);
             }
             model.id_list.node_id.lock().await.union(&id_set);
@@ -240,15 +242,10 @@ async fn render<B: Backend>(
     view.info_list.index = 0;
 
     loop {
-        // on first run, add available nodes
-        // every time run the program, simply update nodes
-        //debug!("UPDATE INFO LIST: {:?}", model.info_list.infos.lock().await.clone());
         view.update(
             model.id_list.node_id.lock().await.clone(),
             model.info_list.infos.lock().await.clone(),
         );
-        //debug!("UPDATE INFO LIST: {:?}", model.info_list.infos.lock().await.clone());
-        //debug!("VIEW {:?}", view.info_list.infos);
         if view.info_list.infos.is_empty() {
             // TODO: make this a loading widget
             // TODO: this lags forever if IRC is not running. add an error

bin/map/src/model.rs

@@ -30,7 +30,6 @@ pub struct IdList {
 }
 
 impl IdList {
-    // change vec to hashset
     pub fn new(node_id: HashSet<String>) -> IdList {
         let node_id = Mutex::new(node_id);
         IdList { state: Mutex::new(ListState::default()), node_id }
@@ -40,14 +39,14 @@ impl IdList {
 pub struct InfoList {
     pub index: Mutex<usize>,
     // hashmap
-    pub infos: Mutex<Vec<NodeInfo>>,
+    pub infos: Mutex<HashMap<String, NodeInfo>>,
 }
 
 impl InfoList {
     pub fn new(infos: Vec<NodeInfo>) -> InfoList {
         let index = 0;
         let index = Mutex::new(index);
-        let infos = Mutex::new(infos);
+        let infos = Mutex::new(HashMap::new());
 
         InfoList { index, infos }
     }
@@ -55,14 +54,14 @@ impl InfoList {
 
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct NodeInfo {
-    pub id: String,
+    //pub id: String,
     pub outgoing: Vec<Connection>,
     pub incoming: Vec<Connection>,
 }
 
 impl NodeInfo {
     pub fn new() -> NodeInfo {
-        NodeInfo { id: String::new(), outgoing: Vec::new(), incoming: Vec::new() }
+        NodeInfo { outgoing: Vec::new(), incoming: Vec::new() }
     }
 }
 

bin/map/src/view.rs

@@ -1,6 +1,6 @@
 use crate::model::NodeInfo;
 use log::debug;
-use std::collections::HashSet;
+use std::collections::{HashMap, HashSet};
 use tui::widgets::ListState;
 
 #[derive(Clone)]
@@ -14,12 +14,12 @@ impl View {
         View { id_list, info_list }
     }
 
-    pub fn update(&mut self, node_id: HashSet<String>, infos: Vec<NodeInfo>) {
+    pub fn update(&mut self, node_id: HashSet<String>, infos: HashMap<String, NodeInfo>) {
         for node in node_id {
             self.id_list.node_id.insert(node);
         }
         // all node ids that are not contained
-        // node_id.union(self.id_list.node_id)
+        //node_id.union(&self.id_list.node_id)
         //let new_node_ids =
         //    node_id.into_iter().filter(|id| !self.id_list.node_id.contains(id)).collect();
         ////[self.id_list.node_id, new_node_ids].concat();