Caching/

lib.rs

#![allow(non_snake_case)]

use std::fs::OpenOptions;
use std::io::Write;

///The cache is in form of a Struct with two elements
///The second part of the cache is the heart of the cache a Costume list type
///to get the needed performance for my project
pub struct Cache<E, T>
where
    T: std::cmp::PartialEq + Clone,
    E: Clone,
{
    function: fn(Lists<T, E>) -> bool,
    cache: Lists<T, E>,
}

impl<E, T> Cache<E, T>
where
    T: std::cmp::PartialEq + Clone + std::fmt::Display,
    E: Clone + std::fmt::Display,
{
    ///fn new() creates a new cache
    ///as an argument it takes an fn(Lists<E, T>) what returns a bool, to check if it had success or failure
    /// # Examples
    ///```rust
    /// use Caching;
    /// fn main() -> (){
    ///     let cache = caching::Cache::<i32,String>::new(|a/* This is a lists<i32, String>*/|-> bool {return true});
    ///     // Some Code
    /// }
    /// ```

    pub fn new(function: fn(Lists<T, E>) -> bool) -> Self {
        Self {
            function,
            cache: Lists::new(),
        }
    }
    /// calls the expression and parse the Cache cache into it
    /// this makes it possible to execute code directly in the cache
    /// # Examples
    ///```rust
    /// use Caching;
    /// fn main() -> (){
    ///     let cache = caching::Cache::<i32,String>::new(|a/* This is a lists<i32, String>*/|-> bool {return true});
    ///     cache.call(); //This executes the cade in the cache
    ///     // Some Code
    /// }
    /// ```
    pub fn call(&mut self) -> bool {
        (self.function)(self.cache.clone())
    }

    ///insert a linked value into the cache
    /// # Examples
    ///```rust
    /// use Caching;
    /// fn main() -> (){
    ///     let cache = caching::Cache::<i32,String>::new(|a/* This is a lists<i32, String>*/|-> bool {return true});
    ///     cache.insert(4,"4".to_string()); //This puts the values 4 and "4" in the cache
    ///     // Some Code
    /// }
    /// ```
    pub fn insert(&mut self, link: T, value: E) {
        self.cache.push(link, value);
    }

    ///insert a linked value into the cache
    /// # Examples
    ///```rust
    /// use Caching;
    /// fn main() -> (){
    ///     let cache = caching::Cache::<i32,String>::new(|a/* This is a lists<i32, String>*/|-> bool {return true});
    ///     cache.insert(4,"4".to_string()); //This puts the values 4 and "4" in the cache
    ///     cache.get(4); //returns Option enum with None if the value is not the cache and Some(), in this case Some("4")
    ///     // Some Code
    /// }
    /// ```
    pub fn get(&self, link: T) -> Option<E> {
        self.cache.get(link)
    }
    ///safes the cache into to files
    /// # Examples
    ///```rust
    /// use Caching;
    /// fn main() -> (){
    ///     let cache = caching::Cache::<i32,String>::new(|a/* This is a lists<i32, String>*/|-> bool {return true});
    ///     cache.insert(4,"4".to_string()); //This puts the values 4 and "4" in the cache
    ///     cahce.save();//This safes the cache in two file, BUT NOT THE FUNCTION  
    ///     // Some Code
    /// }

    pub fn save(&self) {
        self.cache.save();
    }
}

///This is the list used to increse performance
///by about 12.3 times against an HashMap
#[derive(Clone)]
pub struct Lists<T, E> {
    linked: Vec<T>,
    list: Vec<E>,
}

impl<T, E> Lists<T, E>
where
    T: std::cmp::PartialEq + std::fmt::Display,
    E: Clone + std::fmt::Display,
{
    //Creats a new list
    pub fn new() -> Self {
        Self {
            linked: Vec::new(),
            list: Vec::new(),
        }
    }
    ///pushes values into the list
    pub fn push(&mut self, link: T, list: E) {
        self.linked.push(link);
        self.list.push(list);
    }
    ///This returns the Element where link is Linked to
    pub fn get(&self, link: T) -> Option<E> {
        //this part returns the Element where linked is linked to
        for i in 0..=(self.linked.len() - 1) {
            if self.linked[i] == link {
                return Some(self.list[i].clone());
            }
        }
        None
    }

    pub fn save(&self) -> () {
        let mut linked = "".to_string();
        let mut list = "".to_string();
        for i in 0..=(self.linked.len() - 1) {
            linked = format!("{} {} ", linked, self.linked[i]);
            list = format!("{} {} ", list, self.list[i]);
        }
        wright(linked, "linked.vec".to_string());
        wright(list, "value.vec".to_string());
    }

    pub fn load(&self) -> () {
        todo!();
    }
}

pub(crate) fn wright(content: String, file: String) {
    match OpenOptions::new()
        .write(true)
        .append(true)
        .create(true)
        .read(true)
        .open(file)
    {
        Ok(mut e) => match e.write_all(content.as_bytes()) {
            Ok(_) => {
                e.flush().unwrap();
            }
            Err(e) => {
                println!("\x1b[31m Error with Wright to File: {}\x1b[0m", e);
            }
        },
        Err(e) => {
            println!("\x1b[31m{}\x1b[0m", e);
        }
    }
}
#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn it_works() {
        let mut cache = Cache::<i32, i32>::new(|a| -> bool { true });
        cache.insert(1, 3);
        cache.insert(2, 3);
        cache.insert(3, 3);
        cache.insert(4, 3);
        cache.insert(5, 3);
        cache.insert(6, 3);
        cache.insert(7, 3);
        cache.insert(8, 9);
        assert_eq!(9, cache.get(8).unwrap());
        assert!(cache.call());
        cache.save();
    }
}