205 lines
5.6 KiB
Rust
205 lines
5.6 KiB
Rust
use super::DBError;
|
|
use std::{collections::HashMap, fmt, str};
|
|
|
|
#[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!(),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[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");
|
|
}
|
|
}
|