blob: 24ec98f13229c872435cdcbecd7fa54392d78491 (
plain)
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
|
use std::path::{Path, PathBuf};
use crate::{File, Marker, DOT_LOCK_SUFFIX};
fn strip_lock_suffix(lock_path: &Path) -> PathBuf {
let ext = lock_path
.extension()
.expect("at least our own extension")
.to_str()
.expect("no illegal UTF8 in extension");
lock_path.with_extension(ext.split_at(ext.len().saturating_sub(DOT_LOCK_SUFFIX.len())).0)
}
impl File {
/// Obtain a mutable reference to the write handle and call `f(out)` with it.
pub fn with_mut<T>(&mut self, f: impl FnOnce(&mut std::fs::File) -> std::io::Result<T>) -> std::io::Result<T> {
self.inner.with_mut(|tf| f(tf.as_file_mut())).and_then(|res| res)
}
/// Close the lock file to prevent further writes and to save system resources.
/// A call to [`Marker::commit()`] is allowed on the [`Marker`] to write changes back to the resource.
pub fn close(self) -> std::io::Result<Marker> {
Ok(Marker {
inner: self.inner.close()?,
created_from_file: true,
lock_path: self.lock_path,
})
}
/// Return the path at which the lock file resides
pub fn lock_path(&self) -> &Path {
&self.lock_path
}
/// Return the path at which the locked resource resides
pub fn resource_path(&self) -> PathBuf {
strip_lock_suffix(&self.lock_path)
}
}
mod io_impls {
use std::{io, io::SeekFrom};
use super::File;
impl io::Write for File {
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
self.inner.with_mut(|f| f.write(buf))?
}
fn flush(&mut self) -> io::Result<()> {
self.inner.with_mut(|f| f.flush())?
}
}
impl io::Seek for File {
fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {
self.inner.with_mut(|f| f.seek(pos))?
}
}
impl io::Read for File {
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
self.inner.with_mut(|f| f.read(buf))?
}
}
}
impl Marker {
/// Return the path at which the lock file resides
pub fn lock_path(&self) -> &Path {
&self.lock_path
}
/// Return the path at which the locked resource resides
pub fn resource_path(&self) -> PathBuf {
strip_lock_suffix(&self.lock_path)
}
}
|
