rfd/file_handle/
native.rs

1use std::{
2    future::Future,
3    path::{Path, PathBuf},
4    pin::Pin,
5    sync::{Arc, Mutex},
6    task::{Context, Poll, Waker},
7};
8
9#[derive(Default)]
10struct ReaderState {
11    res: Option<std::io::Result<Vec<u8>>>,
12    waker: Option<Waker>,
13}
14
15struct Reader {
16    state: Arc<Mutex<ReaderState>>,
17}
18
19impl Reader {
20    fn new(path: &Path) -> Self {
21        let state: Arc<Mutex<ReaderState>> = Arc::new(Mutex::new(Default::default()));
22
23        {
24            let path = path.to_owned();
25            let state = state.clone();
26            std::thread::Builder::new()
27                .name("rfd_file_read".into())
28                .spawn(move || {
29                    let res = std::fs::read(path);
30
31                    let mut state = state.lock().unwrap();
32                    state.res.replace(res);
33
34                    if let Some(waker) = state.waker.take() {
35                        waker.wake();
36                    }
37                })
38                .unwrap();
39        }
40
41        Self { state }
42    }
43}
44
45impl Future for Reader {
46    type Output = Vec<u8>;
47
48    fn poll(self: Pin<&mut Self>, ctx: &mut Context<'_>) -> Poll<Self::Output> {
49        let mut state = self.state.lock().unwrap();
50        if let Some(res) = state.res.take() {
51            Poll::Ready(res.unwrap())
52        } else {
53            state.waker.replace(ctx.waker().clone());
54            Poll::Pending
55        }
56    }
57}
58
59struct WriterState {
60    waker: Option<Waker>,
61    res: Option<std::io::Result<()>>,
62}
63
64struct Writer {
65    state: Arc<Mutex<WriterState>>,
66}
67
68impl Writer {
69    fn new(path: &Path, bytes: &[u8]) -> Self {
70        let state = Arc::new(Mutex::new(WriterState {
71            waker: None,
72            res: None,
73        }));
74
75        {
76            let path = path.to_owned();
77            let bytes = bytes.to_owned();
78            let state = state.clone();
79            std::thread::Builder::new()
80                .name("rfd_file_write".into())
81                .spawn(move || {
82                    let res = std::fs::write(path, bytes);
83
84                    let mut state = state.lock().unwrap();
85                    state.res.replace(res);
86
87                    if let Some(waker) = state.waker.take() {
88                        waker.wake();
89                    }
90                })
91                .unwrap();
92        }
93
94        Self { state }
95    }
96}
97
98impl Future for Writer {
99    type Output = std::io::Result<()>;
100
101    fn poll(self: Pin<&mut Self>, ctx: &mut Context<'_>) -> Poll<Self::Output> {
102        let mut state = self.state.lock().unwrap();
103        if let Some(res) = state.res.take() {
104            Poll::Ready(res)
105        } else {
106            state.waker.replace(ctx.waker().clone());
107            Poll::Pending
108        }
109    }
110}
111
112/// FileHandle is a way of abstracting over a file returned by a dialog
113#[derive(Clone)]
114pub struct FileHandle(PathBuf);
115
116impl FileHandle {
117    /// On native platforms it wraps path.
118    ///
119    /// On `WASM32` it wraps JS `File` object.
120    pub(crate) fn wrap(path_buf: PathBuf) -> Self {
121        Self(path_buf)
122    }
123
124    /// Get name of a file
125    pub fn file_name(&self) -> String {
126        self.0
127            .file_name()
128            .and_then(|f| f.to_str())
129            .map(|f| f.to_string())
130            .unwrap_or_default()
131    }
132
133    /// Gets path to a file.
134    ///
135    /// Does not exist in `WASM32`
136    pub fn path(&self) -> &Path {
137        &self.0
138    }
139
140    /// Reads a file asynchronously.
141    ///
142    /// On native platforms it spawns a `std::thread` in the background.
143    ///
144    /// `This fn exists solely to keep native api in pair with async only web api.`
145    pub async fn read(&self) -> Vec<u8> {
146        Reader::new(&self.0).await
147    }
148
149    /// Writes a file asynchronously.
150    ///
151    /// On native platforms it spawns a `std::thread` in the background.
152    ///
153    /// `This fn exists solely to keep native api in pair with async only web api.`
154    pub async fn write(&self, data: &[u8]) -> std::io::Result<()> {
155        Writer::new(&self.0, data).await
156    }
157
158    /// Unwraps a `FileHandle` and returns inner type.
159    ///
160    /// It should be used, if user wants to handle file read themselves
161    ///
162    /// On native platforms returns path.
163    ///
164    /// On `WASM32` it returns JS `File` object.
165    ///
166    /// #### Behind a `file-handle-inner` feature flag
167    #[cfg(feature = "file-handle-inner")]
168    pub fn inner(&self) -> &Path {
169        &self.0
170    }
171}
172
173impl std::fmt::Debug for FileHandle {
174    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
175        write!(f, "{:?}", self.path())
176    }
177}
178
179impl From<PathBuf> for FileHandle {
180    fn from(path: PathBuf) -> Self {
181        Self::wrap(path)
182    }
183}
184
185impl From<FileHandle> for PathBuf {
186    fn from(file_handle: FileHandle) -> Self {
187        file_handle.0
188    }
189}
190
191impl From<&FileHandle> for PathBuf {
192    fn from(file_handle: &FileHandle) -> Self {
193        PathBuf::from(file_handle.path())
194    }
195}
rfd/file_handle/native.rs

rfd/file_handle/
native.rs
