map: ui::ui() renders new data types. cleanup

bin/map/src/main.rs

@@ -14,8 +14,13 @@ use log::{debug, info, trace};
 use serde_json::{json, Value};
 use simplelog::*;
 use smol::Executor;
-use std::collections::{HashMap, HashSet};
-use std::{fs::File, io, io::Read, path::PathBuf};
+use std::{
+    collections::{HashMap, HashSet},
+    fs::File,
+    io,
+    io::Read,
+    path::PathBuf,
+};
 use termion::{async_stdin, event::Key, input::TermRead, raw::IntoRawMode};
 use tui::{
     backend::{Backend, TermionBackend},
@@ -119,7 +124,7 @@ async fn main() -> Result<()> {
         .finish(|| {
             smol::future::block_on(async move {
                 run_rpc(&config, ex2.clone(), model.clone()).await?;
-                render(&config, &mut terminal, model.clone()).await?;
+                render(&mut terminal, model.clone()).await?;
                 drop(signal);
                 Ok::<(), darkfi::Error>(())
             })
@@ -159,8 +164,8 @@ async fn poll(client: Map, model: Arc<Model>) -> Result<()> {
             let mut outconnects = Vec::new();
             let mut inconnects = Vec::new();
 
+            // here we are simulating new messages by scrolling through a vector
             let msgs = outgoing[1].get("message").unwrap();
-
             if index == 0 {
                 index += 1;
             } else if index >= 5 {
@@ -168,7 +173,6 @@ async fn poll(client: Map, model: Arc<Model>) -> Result<()> {
             } else {
                 index = index + 1;
             }
-            //debug!("INDEX {}", index);
 
             let out0 = Connection::new(
                 outgoing[0].get("id").unwrap().as_str().unwrap().to_string(),
@@ -203,23 +207,16 @@ async fn poll(client: Map, model: Arc<Model>) -> Result<()> {
                 model.id_list.node_id.lock().await.insert(id.clone());
                 model.info_list.infos.lock().await.insert(id, value);
             }
-            //debug!("MODEL UPDATE HASHSET: {:?}", model.id_list.node_id.lock().await.clone());
-            //debug!("MODEL UPDATE HASHMAP: {:?}", model.info_list.infos.lock().await.clone());
         } else {
             // TODO: error handling
             debug!("Reply is empty");
         }
 
-        async_util::sleep(5).await;
+        async_util::sleep(2).await;
     }
 }
 
-// hashmap union
-async fn render<B: Backend>(
-    _config: &MapConfig,
-    terminal: &mut Terminal<B>,
-    model: Arc<Model>,
-) -> io::Result<()> {
+async fn render<B: Backend>(terminal: &mut Terminal<B>, model: Arc<Model>) -> io::Result<()> {
     let mut asi = async_stdin();
 
     terminal.clear()?;
@@ -251,7 +248,7 @@ async fn render<B: Backend>(
             match k.unwrap() {
                 Key::Char('q') => {
                     terminal.clear()?;
-                    return Ok(());
+                    return Ok(())
                 }
                 Key::Char('j') => {
                     view.id_list.next();
@@ -264,6 +261,5 @@ async fn render<B: Backend>(
                 _ => (),
             }
         }
-        //async_util::sleep(4).await;
     }
 }

bin/map/src/model.rs

@@ -13,15 +13,6 @@ impl Model {
     pub fn new(id_list: IdList, info_list: InfoList) -> Model {
         Model { id_list, info_list }
     }
-
-    pub async fn update(self, infos: Vec<NodeInfo>) -> Result<()> {
-        //for node in infos {
-        //    self.info_list.infos.lock().await.push(node.clone());
-        //    self.id_list.node_id.lock().await.push(node.clone().id);
-        //}
-        // Hashset will be a union
-        Ok(())
-    }
 }
 
 pub struct IdList {
@@ -38,7 +29,6 @@ impl IdList {
 
 pub struct InfoList {
     pub index: Mutex<usize>,
-    // hashmap
     pub infos: Mutex<HashMap<String, NodeInfo>>,
 }
 
@@ -54,7 +44,6 @@ impl InfoList {
 
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct NodeInfo {
-    //pub id: String,
     pub outgoing: Vec<Connection>,
     pub incoming: Vec<Connection>,
 }

bin/map/src/ui.rs

@@ -17,39 +17,36 @@ pub fn ui<B: Backend>(f: &mut Frame<'_, B>, mut view: View) {
         .split(f.size());
 
     let info = &view.info_list.infos;
-    //debug!("UI ID LIST: {:?}", view.id_list.node_id);
-    //debug!("UI INFO LIST: {:?}", view.info_list.infos);
     let index = view.info_list.index;
 
-    //let iconnects = info[index].incoming.clone();
-    //let oconnects = info[index].outgoing.clone();
-
     let nodes: Vec<ListItem> = view
         .id_list
         .node_id
         .iter()
         .map(|id| {
             let mut lines = vec![Spans::from(id.to_string())];
-            //for line in lines.clone() {
-            //    lines.push(Spans::from(Span::styled("  Outgoing:", Style::default())));
-            //    lines.push(Spans::from(format!(
-            //        "    {}         [R: {}]",
-            //        oconnects[0].id, oconnects[0].message
-            //    )));
-            //    lines.push(Spans::from(format!(
-            //        "    {}         [S: {}]",
-            //        oconnects[1].id, oconnects[1].message
-            //    )));
-            //    lines.push(Spans::from(Span::styled("  Incoming:", Style::default())));
-            //    lines.push(Spans::from(format!(
-            //        "    {}         [R: {}]",
-            //        iconnects[0].id, iconnects[0].message
-            //    )));
-            //    lines.push(Spans::from(format!(
-            //        "    {}         [S: {}]",
-            //        iconnects[1].id, iconnects[1].message
-            //    )));
-            //}
+            // TODO: handle the None case
+            let connects = info.get(id).unwrap();
+            for line in lines.clone() {
+                lines.push(Spans::from(Span::styled("  Outgoing:", Style::default())));
+                lines.push(Spans::from(format!(
+                    "    {}         [R: {}]",
+                    connects.outgoing[0].id, connects.outgoing[0].message
+                )));
+                lines.push(Spans::from(format!(
+                    "    {}         [S: {}]",
+                    connects.outgoing[1].id, connects.outgoing[1].message
+                )));
+                lines.push(Spans::from(Span::styled("  Incoming:", Style::default())));
+                lines.push(Spans::from(format!(
+                    "    {}         [R: {}]",
+                    connects.incoming[0].id, connects.incoming[0].message
+                )));
+                lines.push(Spans::from(format!(
+                    "    {}         [S: {}]",
+                    connects.incoming[1].id, connects.incoming[1].message
+                )));
+            }
             ListItem::new(lines).style(Style::default())
         })
         .collect();

bin/map/src/view.rs

@@ -19,37 +19,6 @@ impl View {
             self.id_list.node_id.insert(id.clone());
             self.info_list.infos.insert(id, info);
         }
-        debug!("VIEW UPDATE HASHSET: {:?}", self.id_list.node_id);
-        debug!("VIEW UPDATE HASHMAP: {:?}", self.info_list.infos);
-        // all node ids that are not contained
-        //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();
-        //self.id_list.update(new_node_ids);
-
-        //// all node infos of node info that is different
-        //// hashmap union
-        //let mut new_node_info: HashSet<NodeInfo> = infos
-        //    .into_iter()
-        //    .filter_map(|id| {
-        //        let opt_ni = self.info_list.infos.iter().find(|inf| inf.id == id.id);
-        //        opt_ni.map(|ni| (ni, id))
-        //    })
-        //    .filter(|(view_ni, ni)| *view_ni != ni)
-        //    .map(|(_, ni)| ni)
-        //    .collect();
-
-        //debug!("NEW NODE INFO: {:?}", new_node_info);
-        //self.info_list.infos = self
-        //    .info_list
-        //    .infos
-        //    .iter()
-        //    .cloned()
-        //    //.map(|i| new_node_info.find(|inf| i == *inf).map_or(i, |inf| inf))
-        //    .map(|i| new_node_info.get(&i).map_or(i, |inf| inf.clone()))
-        //    .collect();
-        ////self.info_list.update(new_node_info);
     }
 }
 
@@ -80,12 +49,9 @@ impl IdListView {
     pub fn previous(&mut self) {
         let i = match self.state.selected() {
             Some(i) => {
-                debug!("if {} == 0", i);
                 if i == 0 {
-                    debug!("{} -1 ", self.node_id.len());
                     self.node_id.len() - 1
                 } else {
-                    debug!("else {} -1 ", i);
                     i - 1
                 }
             }
@@ -97,12 +63,6 @@ impl IdListView {
     pub fn unselect(&mut self) {
         self.state.select(None);
     }
-
-    //pub fn update(&mut self, node_id: HashSet<String>) {
-    //    //for id in node_id {
-    //    //    self.node_id.push(id)
-    //    //}
-    //}
 }
 
 #[derive(Clone)]
@@ -122,8 +82,6 @@ impl InfoListView {
         self.index = (self.index + 1) % self.infos.len();
     }
 
-    // TODO: fix crash
-    // == 0
     pub async fn previous(&mut self) {
         if self.index > 0 {
             self.index -= 1;
@@ -131,10 +89,4 @@ impl InfoListView {
             self.index = self.infos.len() - 1;
         }
     }
-
-    //pub fn update(&mut self, infos: Vec<NodeInfo>) {
-    //    for info in infos {
-    //        self.infos.push(info);
-    //    }
-    //}
 }