Consolidated code.

src/morethantext/mod.rs

@@ -1,4 +1,3 @@
-mod cachetype;
 pub mod error;
 
 use async_std::{
@@ -7,7 +6,6 @@ use async_std::{
     sync::{Arc, Mutex},
     task::{sleep, spawn},
 };
-use cachetype::{CacheType, Databases};
 use error::DBError;
 use rand::{distributions::Alphanumeric, thread_rng, Rng};
 use std::{
@@ -19,6 +17,86 @@ use std::{
 const DATA: &str = "data";
 const ENTRY: &str = "databases";
 
+#[derive(Clone)]
+pub struct Databases;
+
+impl Databases {
+    pub fn new() -> Self {
+        Self {}
+    }
+
+    fn add_database(&self, _name: &str) {
+    }
+}
+
+#[derive(Clone)]
+pub enum CacheType {
+    Raw(String),
+    DBMap(Databases),
+    TableMap,
+}
+
+impl CacheType {
+    pub fn entry_type(&self) -> String {
+        match self {
+            CacheType::Raw(_) => "Raw".to_string(),
+            CacheType::DBMap(_) => "DBMap".to_string(),
+            CacheType::TableMap => "TableMap".to_string(),
+        }
+    }
+
+    pub fn to_bytes(&self) -> Vec<u8> {
+        let mut output = self.entry_type().into_bytes();
+        output.push(0);
+        match self {
+            CacheType::Raw(s) => output.append(&mut s.as_bytes().to_vec()),
+            CacheType::DBMap(_) => (),
+            CacheType::TableMap => (),
+        }
+        return output;
+    }
+
+    pub fn from_bytes(data: Vec<u8>) -> Result<CacheType, DBError> {
+        let mut data_iter = data.iter();
+        let mut letter: u8;
+        match data_iter.next() {
+            Some(item) => letter = *item,
+            None => return Err(DBError::new("empty file")),
+        }
+        let mut header: Vec<u8> = Vec::new();
+        while letter != 0 {
+            header.push(letter.clone());
+            match data_iter.next() {
+                Some(item) => letter = *item,
+                None => return Err(DBError::new("incomplete file")),
+            }
+        }
+        let header = str::from_utf8(&header).unwrap().to_string();
+        match header.as_str() {
+            "Raw" => {
+                let mut output: Vec<u8> = Vec::new();
+                for letter in data_iter {
+                    output.push(letter.clone());
+                }
+                Ok(CacheType::Raw(str::from_utf8(&output).unwrap().to_string()))
+            }
+            "DBMap" => Ok(CacheType::DBMap(Databases::new())),
+            "TableMap" => Ok(CacheType::TableMap),
+            _ => Err(DBError::new("data corruption")),
+        }
+    }
+}
+
+impl fmt::Display for CacheType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            CacheType::Raw(s) => write!(f, "{}", s),
+            CacheType::DBMap(_) => todo!(),
+            CacheType::TableMap => todo!(),
+        }
+    }
+}
+
 #[derive(Clone)]
 struct CacheEntry {
     data: CacheType,
@@ -579,3 +657,125 @@ mod cache_entry {
         );
     }
 }
+
+#[cfg(test)]
+mod databases {
+    use super::*;
+
+    #[test]
+    fn add_database() {
+        let dbs = Databases::new();
+        let name = "db1";
+        dbs.add_database(name);
+    }
+}
+
+#[cfg(test)]
+mod enum_ctype {
+    use super::*;
+
+    #[test]
+    fn bad_file_header() {
+        let mut data: Vec<u8> = Vec::new();
+        let mut ctype = "jlksdfg".as_bytes().to_vec();
+        let mut cdata = "ghjk".as_bytes().to_vec();
+        data.append(&mut ctype);
+        data.push(0);
+        data.append(&mut cdata);
+        match CacheType::from_bytes(data) {
+            Ok(_) => assert!(false, "This should fail."),
+            Err(err) => assert_eq!(err.to_string(), "data corruption"),
+        }
+    }
+
+    #[test]
+    fn incomplete_file() {
+        let mut data: Vec<u8> = Vec::new();
+        let mut ctype = "uoisfde".as_bytes().to_vec();
+        data.append(&mut ctype);
+        match CacheType::from_bytes(data) {
+            Ok(_) => assert!(false, "This should fail."),
+            Err(err) => assert_eq!(err.to_string(), "incomplete file"),
+        }
+    }
+
+    #[test]
+    fn empty_file() {
+        let data: Vec<u8> = Vec::new();
+        match CacheType::from_bytes(data) {
+            Ok(_) => assert!(false, "This should fail."),
+            Err(err) => assert_eq!(err.to_string(), "empty file"),
+        }
+    }
+
+    #[test]
+    fn get_raw_type() {
+        let holder = CacheType::Raw("nothing important".to_string());
+        assert_eq!(holder.entry_type(), "Raw");
+    }
+
+    #[test]
+    fn get_raw_bytes() {
+        let data = "addams";
+        let holder = CacheType::Raw(data.to_string());
+        let mut expected = holder.entry_type().into_bytes();
+        expected.push(0);
+        expected.append(&mut data.as_bytes().to_vec());
+        let output = holder.to_bytes();
+        assert_eq!(output, expected);
+    }
+
+    #[test]
+    fn from_raw_bytes() {
+        let holder = CacheType::Raw("stored item".to_string());
+        let data = holder.to_bytes();
+        let output = CacheType::from_bytes(data).unwrap();
+        assert_eq!(output.to_string(), holder.to_string());
+    }
+
+    #[test]
+    fn get_dbmap_type() {
+        let holder = CacheType::DBMap(Databases::new());
+        assert_eq!(holder.entry_type(), "DBMap");
+    }
+
+    #[test]
+    fn get_new_databases_bytes() {
+        let holder = CacheType::DBMap(Databases::new());
+        let mut expected = "DBMap".as_bytes().to_vec();
+        expected.push(0);
+        let output = holder.to_bytes();
+        assert_eq!(output, expected);
+    }
+
+    #[test]
+    fn from_new_databases_bytes() {
+        let mut data = "DBMap".as_bytes().to_vec();
+        data.push(0);
+        let output = CacheType::from_bytes(data).unwrap();
+        assert_eq!(output.entry_type(), "DBMap");
+    }
+
+    #[test]
+    fn get_tablemap_type() {
+        let holder = CacheType::TableMap;
+        assert_eq!(holder.entry_type(), "TableMap");
+    }
+
+    #[test]
+    fn get_new_database_bytes() {
+        let holder = CacheType::TableMap;
+        let mut expected = "TableMap".as_bytes().to_vec();
+        expected.push(0);
+        let output = holder.to_bytes();
+        assert_eq!(output, expected);
+    }
+
+    #[test]
+    fn from_new_database_bytes() {
+        let mut data = "TableMap".as_bytes().to_vec();
+        data.push(0);
+        let output = CacheType::from_bytes(data).unwrap();
+        assert_eq!(output.entry_type(), "TableMap");
+    }
+}