ez_fs 0.1.0

A filesystem simplification over the standard library
Documentation 
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

use std::{io, time::SystemTime, fmt::Display};


///Representation of an open file.
///Wraps [`std::fs`] things such as metadata together to handle neatly.
#[derive(Debug)]
pub struct EzFile {
    path: String,
    handle: std::fs::File,
    metadata: std::fs::Metadata,
}
impl EzFile {
    ///Open a file in read-only mode.
    ///Refer to [`std::io::Read`] for more information.
    ///```
    ///use ez_fs::EzFile;
    ///use std::io::Read;
    ///
    ///let mut file = EzFile::open("foo.txt").unwrap();
    ///let mut buf = String::new();
    ///file.read_to_string(&mut buf).unwrap();
    ///```
    ///# Errors
    ///This function will error if `path` does not exist.
    pub fn open(path: &str) -> io::Result<Self> {
        let handle = std::fs::File::open(path)?;
        let metadata = handle.metadata()?;
        Ok(Self {
            path: path.to_string(),
            handle,
            metadata,
        })
    }
    ///Open a file in write-only mode.
    ///Refer to [`std::io::Write`] for more information.
    ///```
    ///use ez_fs::EzFile;
    ///use std::io::Write;
    ///
    ///let mut file = EzFile::create("foo.txt").unwrap();
    ///file.write_all(b"bar").unwrap();
    ///```
    ///# Errors
    ///This function will error if `path` does not exist.
    pub fn create(path: &str) -> io::Result<Self> {
        let handle = std::fs::File::create(path)?;
        let metadata = handle.metadata()?;
        Ok(Self {
            path: path.to_string(),
            handle,
            metadata,
        })
    }

    

    ///Deconstructs and returns the path, file handle, and metadata of a file.
    #[must_use] pub fn into_raw(self) -> (String, std::fs::File, std::fs::Metadata) {
        (self.path, self.handle, self.metadata)
    }


    //metadata delagates
    ///Returns the last access time of the file.
    ///Derived from [`std::fs::Metadata`].
    pub fn accessed(&self) -> io::Result<SystemTime> {
        self.metadata.accessed()
    }

    ///Returns the creation time of the file.
    ///Derived from [`std::fs::Metadata`].
    pub fn created(&self) -> io::Result<SystemTime> {
        self.metadata.created()
    }

    ///Returns the last modification time listed in the file.
    ///Derived from [`std::fs::Metadata`].
    pub fn modified(&self) -> io::Result<SystemTime> {
        self.metadata.modified()
    }

    ///Returns the permissions of the file.
    ///Derived from [`std::fs::Metadata`].
    #[must_use] pub fn permissions(&self) -> std::fs::Permissions {
        self.metadata.permissions()
    }

    ///Returns the path of the file. 
    #[must_use] pub fn path(&self) -> &str {
        self.path.as_ref()
    }
    
    ///Converts a read-only handle to a write-only handle. Calling this on an already WO handle
    ///will do nothing.
    pub fn to_write(&mut self) -> io::Result<()> {
        self.handle = std::fs::File::create(&self.path)?;
        Ok(())
    }

    ///Converts a write-only handle to a read-only handle. Calling this on an already RO handle
    ///will do nothing.
    pub fn to_read(&mut self) -> io::Result<()> {
        self.handle = std::fs::File::open(&self.path)?;
        Ok(())
    }

}

impl io::Read for EzFile {
    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
        //self.to_read()?;
        self.handle.read(buf)
    }
} 
impl io::Write for EzFile {
    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
        //self.to_write()?;
        self.handle.write(buf) 
    }

    fn flush(&mut self) -> io::Result<()> {
        self.handle.flush() 
    }
}

impl Display for EzFile {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.path())
    }
}