cleaner representation of index

src/state.rs

@@ -1,29 +1,23 @@
 use crate::error;
 use crate::tasks;
-use crate::colour;
+use crate::index;
 use crate::tasks::Id;
 
 use std::fs;
 use std::path;
 use std::io;
 use std::io::{Write, Seek};
-use std::collections::HashMap;
 
-use serde_with::{serde_as, DisplayFromStr};
 
 pub struct State {
     file : fs::File,
     pub data : InternalState,
 }
 
-#[serde_as]
 #[derive(serde::Serialize, serde::Deserialize)]
 pub struct InternalState {
     pub next_id : Id,
-    #[serde_as(as = "HashMap<DisplayFromStr, _>")]
-    pub index : HashMap<String, Vec<Id>>,
-    //#[serde_as(as = "HashMap<DisplayFromStr, _>")]
-    //pub dependencies : HashMap<Id, Vec<Id>>,
+    pub index : index::Index,
 }
 
 impl State {
@@ -60,19 +54,8 @@ impl State {
 
             // Calculating out the index.
             let tasks = tasks::Task::load_all(vault_location, true)?;
-            let mut index : HashMap<String, Vec<Id>> = HashMap::with_capacity(tasks.len());
-            for task in tasks {
-                match index.get_mut(&task.data.name) {
-                    Some(ids) => {
-                        ids.push(task.data.id);
-                    },
-                    None => {
-                        index.insert(task.data.name.clone(), vec![task.data.id]);
-                    },
-                }
-            }
 
-            //
+            let index = index::Index::create(&tasks);
 
             let data = InternalState {
                 next_id : u64::try_from(max_id + 1).unwrap(),
@@ -115,61 +98,4 @@ impl State {
         Ok(())
     }
 
-    pub fn index_insert(&mut self, name : String, id : Id) {
-        match self.data.index.get_mut(&name) {
-            Some(ids) => {
-                ids.push(id);
-            },
-            None => {
-                self.data.index.insert(name, vec![id]);
-            }
-        }
-    }
-
-    pub fn index_remove(&mut self, name : String, id : Id) {
-        if let Some(mut ids) = self.data.index.remove(&name) {
-            if let Some(index) = ids.iter().position(|i| i == &id) {
-                ids.swap_remove(index);
-
-                if !ids.is_empty() {
-                    self.data.index.insert(name, ids);
-                }
-            }
-        }
-    }
-
-    pub fn name_or_id_to_id(&self, name : &String) -> Result<Id, error::Error> {
-        match name.parse::<Id>() {
-            Ok(id) => Ok(id),
-            Err(_) => {
-                match self.data.index.get(name) {
-                    Some(ids) => {
-                        if ids.len() == 1 {
-                            Ok(ids[0])
-                        }
-                        else {
-                            let coloured_ids : Vec<_> =
-                                ids.into_iter()
-                                .map(|i| colour::id(&i.to_string()))
-                                .collect();
-
-                            let mut display_ids = String::new();
-
-                            for id in coloured_ids {
-                                display_ids.push_str(&format!("{}, ", id));
-                            }
-
-                            if !display_ids.is_empty() {
-                                display_ids.pop();
-                                display_ids.pop();
-                            }
-
-                            Err(error::Error::Generic(format!("Multiple notes (Ids: [{}]) by that name exist", display_ids)))
-                        }
-                    },
-                    None => Err(error::Error::Generic(format!("A note by the name {} does not exist", colour::task_name(&name)))),
-                }
-            }
-        }
-    }
 }