thread_safe_cache/
lib.rs

1mod tests;
2pub mod embedded;
3pub mod network;
4use std::collections::{BTreeMap, HashMap};
5use std::hash::Hash;
6use std::sync::{Arc, Mutex};
7use std::thread;
8use std::time::Duration;
9use tokio::net::TcpStream;
10use crate::embedded::{ThreadSafeCache, ThreadSafeCacheImpl};
11use crate::network::NetworkCache;
12
13
14pub struct BuilderNetwork<K, V> {
15    address: String,
16    rt: tokio::runtime::Runtime,
17    phantom_data: std::marker::PhantomData<(K, V)>,
18}
19
20
21impl <K: std::marker::Send  + 'static + Clone +  Eq + Hash + serde::Serialize + serde::de::DeserializeOwned,
22    V: std::marker::Send  + Clone + serde::de::DeserializeOwned + serde::Serialize +  'static>  BuilderNetwork<K, V>  {
23    pub fn init() -> BuilderNetwork<K, V> {
24        let rt = tokio::runtime::Runtime::new().unwrap();
25        BuilderNetwork {
26            address: "".to_string(),
27            rt: rt,
28            phantom_data: Default::default(),
29        }
30    }
31
32    pub fn address(&mut self, address: String) -> &mut Self {
33        self.address = address;
34        self
35    }
36     pub fn connect(self) -> NetworkCache<K, V> {
37         //         TcpStream::connect(self.address.as_str()).await.unwrap()
38         let  stream = self.rt.block_on(async {
39             let stream = TcpStream::connect(self.address.as_str()).await.unwrap();
40             stream
41         });
42        let ret = NetworkCache {
43            tcp_stream:  stream,
44            rt: self.rt,
45            phantom_data: Default::default(),
46        };
47        ret
48    }
49
50}
51
52pub struct BuilderEmbedded<K, V> {
53    max_size: i32,
54    phantom_data: std::marker::PhantomData<(K, V)>,
55}
56
57impl <K: std::marker::Send  + 'static + Clone +  Eq + Hash + serde::Serialize + serde::de::DeserializeOwned,
58    V: std::marker::Send  + Clone + serde::de::DeserializeOwned + serde::Serialize +  'static>  BuilderEmbedded<K, V>  {
59    pub fn init() -> BuilderEmbedded<K, V> {
60        BuilderEmbedded {
61            max_size: 1000,
62            phantom_data: Default::default(),
63        }
64    }
65
66    pub fn build(&self) -> ThreadSafeCache<K, V> {
67
68        let im = Arc::new(Mutex::new(ThreadSafeCacheImpl {
69            cache: HashMap::new(),
70            expiration_set: BTreeMap::new(),
71            max_size: self.max_size,
72            current_size: 0,
73        }));
74        let ret = ThreadSafeCache {
75            implementation: im,
76        };
77        let mut ret_clone = ret.clone();
78        thread::spawn(move || {
79            loop {
80                if !ret_clone.clean() {
81                    break;
82                }
83                thread::sleep(Duration::from_millis(1000));
84            }
85        });
86        ret
87
88    }
89
90    pub fn max_size(&mut self, max_size: i32) -> &mut Self {
91        self.max_size = max_size;
92        self
93    }
94    
95}
96
97
98pub trait  ThreadSafeCacheTrait<K: 'static + Clone +  Eq + Hash + serde::Serialize + serde::de::DeserializeOwned,
99    V:   Clone + serde::Serialize + serde::de::DeserializeOwned +'static> {
100    fn put(&mut self, key: K, val: V)
101        where K: Eq + Hash;
102    fn put_exp(&mut self, key: K, val: V, expiration: i32)
103        where K: Eq + Hash + Clone;
104    fn get(&mut self, key: K) -> Option<V>
105        where K: Eq + Hash, V: Clone;
106    fn exists(&mut self, key: K) -> bool;
107    fn rm(&mut self, key: K);
108}
109pub trait ThreadSafeCachePersistTrait<K:   'static + Clone +  Eq + Hash + serde::Serialize + serde::de::DeserializeOwned,
110    V:  Clone + serde::Serialize + serde::de::DeserializeOwned +'static>: ThreadSafeCacheTrait<K,V>  {
111    fn save(&mut self, file_name: &str);
112    fn load(&mut self, file_name: &str);
113}
114
115
116
117
118
thread_safe_cache/lib.rs

thread_safe_cache/
lib.rs
