1use std::fs::File;
9use std::io::{BufReader, Write};
10use std::path::{Path, PathBuf};
11
12use serde::de::DeserializeOwned;
13
14use crate::Error;
15
16pub struct WriteOptions {
18 no_overwrite: bool,
19}
20
21pub struct WriteOptionsBuilder {
23 no_overwrite: bool,
24}
25
26impl WriteOptionsBuilder {
27 pub fn new() -> Self {
29 Self {
30 no_overwrite: false
31 }
32 }
33
34 pub fn disallow_overwrite(mut self) -> Self {
36 self.no_overwrite = true;
37 self
38 }
39
40 pub fn build(self) -> WriteOptions {
42 WriteOptions {
43 no_overwrite : self.no_overwrite,
44 }
45 }
46}
47
48pub fn write_to_file<T: serde::ser::Serialize>(obj: &T, dir: &str, filename: &str, options: WriteOptions) -> Result<Option<PathBuf>, Error> {
51 let path = Path::new(dir);
52 let path = path.join(filename);
53
54 if options.no_overwrite && path.exists() {
55 return Ok(None)
56 }
57
58 write_to_path(&path, obj)?;
59 Ok(Some(path))
60}
61
62fn write_to_path<T: serde::ser::Serialize>(path: &PathBuf, obj: &T) -> Result<(), Error> {
63 let mut fp = File::create(&path)?;
64
65 fp.write_all(&serde_json::ser::to_vec(obj).unwrap())
66 .map_err(|e| Error::IoError(e))
67}
68
69pub fn read_from_file<T: DeserializeOwned>(dir: &str, filename: impl AsRef<Path>) -> Result<T, Error> {
71 let path = Path::new(dir);
72 let path = path.join(filename);
73 let file = File::open(path)?;
74 let reader = BufReader::new(file);
75 let obj = serde_json::from_reader(reader)?;
76 Ok(obj)
77}
78
79pub(crate) fn compose_filename(prefix: &str, extension: &str, evaluation_data_number: Option<u64>) -> String {
80 if let Some(evaluation_data_number) = evaluation_data_number {
81 format!("{}-{evaluation_data_number}{}", prefix, extension)
82 } else {
83 format!("{}{}", prefix, extension)
84 }
85}
86
87pub(crate) fn all_files<'a>(input_dir: &str, prefix: impl AsRef<str> + 'a, extension: &'a str) -> impl Iterator<Item = Result<std::fs::DirEntry, Error>> + 'a {
88 let (first, second) = match std::fs::read_dir(input_dir) {
92 Ok(it) => (Some(it), None),
93 Err(e) => (None, Some(Err(e))),
94 };
95 let entries = first.into_iter().flat_map(|it| it).chain(second.into_iter());
96
97 entries.filter_map(move |item| {
99 let prefix = prefix.as_ref();
100 match item {
101 Ok(entry) => {
102 let fname = entry.file_name();
103 let fname = fname.to_str()?;
104 if !(fname.starts_with(prefix) && fname.ends_with(extension)) {
105 return None;
106 }
107 if fname.len() != prefix.len() + extension.len() {
108 let middle = &fname[(prefix.len())..(fname.len() - extension.len())];
109 if !middle.starts_with("-") {
110 return None;
111 }
112 let _: u64 = middle[1..].parse().ok()?;
113 }
114 Some(Ok(entry))
115 },
116 Err(e) => Some(Err(e.into()))
117 }
118 })
119}
120
121#[cfg(test)]
122mod tests {
123 #[cfg(not(target_env = "sgx"))]
124 #[test]
125 fn test_all_files() {
126 use std::{collections::HashSet, ffi::OsString};
127
128 let a: HashSet<_> = Result::unwrap(super::all_files("./tests/data/read-dir-test", "prefix", ".ext").map(|i| i.map(|entry| entry.file_name()) ).collect());
129 let b: HashSet<_> = <_>::into_iter(["prefix-1.ext", "prefix-2.ext", "prefix-3.ext", "prefix.ext"]).map(|i| OsString::from(i)).collect();
130 assert_eq!(a, b);
131 }
132}