1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
extern crate bincode;
extern crate prototty_storage;
extern crate serde;
pub use prototty_storage::{LoadError, Storage, StoreError};
use serde::de::DeserializeOwned;
use serde::ser::Serialize;
use std::env;
use std::fs::{self, File};
use std::io::{Read, Write};
use std::path::{Path, PathBuf};
pub struct FileStorage {
base_path: PathBuf,
}
impl FileStorage {
pub fn new<P: AsRef<Path>>(path: P, create: bool) -> Option<Self> {
if !path.as_ref().exists() {
if create {
if fs::create_dir_all(path.as_ref()).is_err() {
return None;
}
} else {
return None;
}
}
Some(Self {
base_path: path.as_ref().to_path_buf(),
})
}
pub fn next_to_exe<P: AsRef<Path>>(relative_path: P, create: bool) -> Option<Self> {
let mut exe_path = env::current_exe().ok()?;
exe_path.pop();
Self::new(exe_path.join(relative_path), create)
}
fn full_path<S: AsRef<str>>(&self, path: S) -> PathBuf {
let relative_path: PathBuf = path.as_ref().into();
self.base_path.join(relative_path)
}
}
impl Storage for FileStorage {
fn load<K, T>(&self, key: K) -> Result<T, LoadError>
where
K: AsRef<str>,
T: DeserializeOwned,
{
bincode::deserialize(self.load_raw(key)?.as_slice()).map_err(|_| LoadError::InvalidFormat)
}
fn store<K, T>(&mut self, key: K, value: &T) -> Result<(), StoreError>
where
K: AsRef<str>,
T: Serialize,
{
let bytes = bincode::serialize(value).expect("Failed to serialize data");
self.store_raw(key, bytes)
}
fn remove<K, T>(&mut self, key: K) -> Result<T, LoadError>
where
K: AsRef<str>,
T: DeserializeOwned,
{
let bytes = self.remove_raw(key)?;
bincode::deserialize(&bytes).map_err(|_| LoadError::InvalidFormat)
}
fn load_raw<K>(&self, key: K) -> Result<Vec<u8>, LoadError>
where
K: AsRef<str>,
{
let mut file = File::open(self.full_path(key)).map_err(|_| LoadError::NoSuchKey)?;
let mut contents = Vec::new();
file.read_to_end(&mut contents)
.map_err(|_| LoadError::IoError)?;
Ok(contents)
}
fn store_raw<K, V>(&mut self, key: K, value: V) -> Result<(), StoreError>
where
K: AsRef<str>,
V: AsRef<[u8]>,
{
let mut file = File::create(self.full_path(key)).map_err(|_| StoreError::IoError)?;
file.write_all(value.as_ref())
.map_err(|_| StoreError::IoError)?;
Ok(())
}
fn remove_raw<K>(&mut self, key: K) -> Result<Vec<u8>, LoadError>
where
K: AsRef<str>,
{
let contents = self.load_raw(&key)?;
let path = self.full_path(key);
fs::remove_file(path).expect("Failed to delete file");
Ok(contents)
}
fn exists<K>(&self, key: K) -> bool
where
K: AsRef<str>,
{
self.full_path(key).exists()
}
fn clear(&mut self) {
fs::remove_dir_all(&self.base_path).expect("Failed to remove base dir");
fs::create_dir_all(&self.base_path).expect("Failed to create base dir");
}
}