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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
|
use std::io::{Read, Write};
use std::path::Path;
use protobuf::Message;
use protobuf::parse_from_bytes;
use errors::*;
use sleep_register::*;
use metadata_msgs::{Index, Stat, Node};
/// "Sort of" follows rust std::fs API for file system access.
pub struct DatDrive {
metadata: SleepDirRegister,
content: SleepDirRegister,
}
impl DatDrive {
/// Instantiates a drive in the given directory. Path should be the complete path (eg, ending
/// in '/.dat/'), not an enclosing directory containing files.
pub fn create<P: AsRef<Path>>(path: P) -> Result<DatDrive> {
unimplemented!()
}
/// Path should be the complete path (eg, ending in '/.dat/'), not an enclosing directory
/// containing files.
pub fn open<P: AsRef<Path>>(path: P) -> Result<DatDrive> {
unimplemented!()
}
}
impl<'a> DatDrive {
pub fn history(start: u64) -> DriveHistory<'a> {
unimplemented!()
}
pub fn read_dir_recursive<P: AsRef<Path>>(path: P) -> ReadDriveDir<'a> {
unimplemented!()
}
pub fn read_dir<P: AsRef<Path>>(path: P) -> ReadDriveDir<'a> {
unimplemented!()
}
pub fn file_metadata<P: AsRef<Path>>(path: P) -> Result<Stat> {
unimplemented!()
}
pub fn create_file_bytes<P: AsRef<Path>>(path: P, stat: &Stat, data: &[u8]) -> Result<()> {
unimplemented!()
}
pub fn create_file<P: AsRef<Path>, R: Read>(path: P, stat: &Stat, source: R) -> Result<()> {
unimplemented!()
}
/// Copies Stat metadata and all content from a file in the "real" filesystem into the
/// DatDrive.
pub fn import_file<P: AsRef<Path>, Q: AsRef<Path>>(source: P, dest: Q) -> Result<()> {
unimplemented!()
}
/* Possible future helper functions to be even more like std::fs
pub fn rename<P: AsRef<Path>, Q: AsRef<Path>>(from: P, to: Q) -> Result<()>
pub fn copy<P: AsRef<Path>, Q: AsRef<Path>>(from: P, to: Q) -> Result<()>
pub fn remove_file<P: AsRef<Path>>(path: P) -> Result<()>
pub fn remove_dir_all<P: AsRef<Path>>(path: P) -> Result<()>
*/
}
#[test]
fn test_dd_open() {
let mut dd =
DatDrive::open(Path::new("test-data/dat/simple/.dat/")).unwrap();
// verified from dat log
assert_eq!(dd.history().collect().len(), 2);
assert_eq!(dd.read_dir().collect().len(), 1);
assert_eq!(dd.read_dir_recurisve().collect().len(), 1);
}
#[test]
fn test_dd_create() {
use tempdir::TempDir;
let tmp_dir = TempDir::new("geniza-test").unwrap();
let mut dd = DatDrive::create(tmp_dir.path()).unwrap();
assert_eq!(dd.history().collect().len(), 0);
assert_eq!(dd.read_dir().collect().len(), 0);
assert_eq!(dd.read_dir_recurisve().collect().len(), 0);
}
pub struct DriveEntry {
node: Node,
index: u64,
}
pub struct DriveHistory<'a> {
drive: &'a mut DatDrive,
}
/// Iterator
pub struct ReadDriveDir<'a> {
drive: &'a mut DatDrive,
recursive: bool,
// Entries to recurse over
entries: Vec<u64>,
}
impl<'a> ReadDriveDir<'a> {
fn init<P: AsRef<Path>>(drive: &mut DatDrive, path: P, recursive: bool) {
unimplemented!();
// TODO: starting from the last data entry, recurse up to nearest directory, then recurse
// down to base path
//ReadDriveDir {
// drive,
// recursive,
// entries: vec![],
//}
}
}
impl<'a> Iterator for DriveHistory<'a> {
type Item = DriveEntry;
fn next(&mut self) -> Option<DriveEntry> {
unimplemented!();
}
}
impl<'a> Iterator for ReadDriveDir<'a> {
type Item = DriveEntry;
fn next(&mut self) -> Option<DriveEntry> {
unimplemented!();
}
}
|
