file_futures/
lib.rs

1/*
2 * This file is part of Tokio File Futures.
3 *
4 * Copyright © 2017 Riley Trautman
5 *
6 * Tokio File Futures is free software: you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation, either version 3 of the License, or
9 * (at your option) any later version.
10 *
11 * Tokio File Futures is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with Tokio File Futures.  If not, see <http://www.gnu.org/licenses/>.
18 */
19
20//! # File Futures
21//!
22//! This crate provides the Futures abstraction around many of the poll methods provided in tokio-fs.
23//!
24//! There's really not much to it.
25//!
26//! ### Example
27//! ```rust
28//! # extern crate file_futures;
29//! # extern crate futures;
30//! # extern crate tokio;
31//! # extern crate tokio_fs;
32//! use std::io::SeekFrom;
33//!
34//! use file_futures::AsyncFile;
35//! use futures::Future;
36//! use tokio_fs::File;
37//!
38//! fn main() {
39//!     let future = File::create("/tmp/some-tmpfile")
40//!         .map_err(|e| println!("Create Error {}", e))
41//!         .and_then(|_| {
42//!             let future1 = File::open("/tmp/some-tmpfile")
43//!                 .and_then(|file| file.metadata().and_then(|(_file, _metadata)| Ok(())))
44//!                 .map_err(|e| println!("Error1: {}", e));
45//!
46//!             let future2 = File::open("/tmp/some-tmpfile")
47//!                 .and_then(|file| {
48//!                     file.seek(SeekFrom::Start(30))
49//!                         .and_then(|(_file, _from_start)| Ok(()))
50//!                 })
51//!                 .map_err(|e| println!("Error2: {}", e));
52//!
53//!             future1.join(future2)
54//!         })
55//!         .map_err(|_| panic!("Error somewhere"));
56//!
57//!     tokio::run(future.map(|_| ()));
58//! }
59//! ```
60
61extern crate futures;
62extern crate tokio_fs;
63
64use std::{fs::{Metadata, Permissions}, io::{Error, SeekFrom}};
65use futures::{Async, Future, Poll};
66
67/// The trait that provides the futures associated with `tokio_fs::File`'s poll methods.
68pub trait AsyncFile: Sized {
69    fn poll_seek(&mut self, pos: SeekFrom) -> Poll<u64, Error>;
70    fn poll_sync_all(&mut self) -> Poll<(), Error>;
71    fn poll_sync_data(&mut self) -> Poll<(), Error>;
72    fn poll_set_len(&mut self, size: u64) -> Poll<(), Error>;
73    fn poll_metadata(&mut self) -> Poll<Metadata, Error>;
74    fn poll_try_clone(&mut self) -> Poll<tokio_fs::file::File, Error>;
75    fn poll_set_permissions(&mut self, perm: Permissions) -> Poll<(), Error>;
76
77    fn seek(self, pos: SeekFrom) -> Seek<Self> {
78        Seek {
79            pos,
80            inner: Some(self),
81        }
82    }
83
84    fn sync_all(self) -> SyncAll<Self> {
85        SyncAll { inner: Some(self) }
86    }
87
88    fn sync_data(self) -> SyncData<Self> {
89        SyncData { inner: Some(self) }
90    }
91
92    fn set_len(self, size: u64) -> SetLen<Self> {
93        SetLen {
94            size,
95            inner: Some(self),
96        }
97    }
98
99    fn metadata(self) -> GetMetadata<Self> {
100        GetMetadata { inner: Some(self) }
101    }
102
103    fn try_clone(self) -> TryClone<Self> {
104        TryClone { inner: Some(self) }
105    }
106
107    fn set_permissions(self, perm: Permissions) -> SetPermissions<Self> {
108        SetPermissions {
109            perm,
110            inner: Some(self),
111        }
112    }
113}
114
115impl AsyncFile for tokio_fs::file::File {
116    fn poll_seek(&mut self, pos: SeekFrom) -> Poll<u64, Error> {
117        tokio_fs::file::File::poll_seek(self, pos)
118    }
119
120    fn poll_sync_all(&mut self) -> Poll<(), Error> {
121        tokio_fs::file::File::poll_sync_all(self)
122    }
123
124    fn poll_sync_data(&mut self) -> Poll<(), Error> {
125        tokio_fs::file::File::poll_sync_data(self)
126    }
127
128    fn poll_set_len(&mut self, size: u64) -> Poll<(), Error> {
129        tokio_fs::file::File::poll_set_len(self, size)
130    }
131
132    fn poll_metadata(&mut self) -> Poll<Metadata, Error> {
133        tokio_fs::file::File::poll_metadata(self)
134    }
135
136    fn poll_try_clone(&mut self) -> Poll<tokio_fs::file::File, Error> {
137        tokio_fs::file::File::poll_try_clone(self)
138    }
139
140    fn poll_set_permissions(&mut self, perm: Permissions) -> Poll<(), Error> {
141        tokio_fs::file::File::poll_set_permissions(self, perm)
142    }
143}
144
145pub struct Seek<T> {
146    pos: SeekFrom,
147    inner: Option<T>,
148}
149
150impl<T> Future for Seek<T>
151where
152    T: AsyncFile,
153{
154    type Item = (T, u64);
155    type Error = Error;
156
157    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
158        let mut inner = self.inner.take().unwrap();
159
160        match inner.poll_seek(self.pos) {
161            Ok(Async::Ready(seek)) => Ok(Async::Ready((inner, seek))),
162            Ok(_) => Ok(Async::NotReady),
163            Err(e) => Err(e),
164        }
165    }
166}
167
168impl<T> AsyncFile for Seek<T>
169where
170    T: AsyncFile,
171{
172    fn poll_seek(&mut self, pos: SeekFrom) -> Poll<u64, Error> {
173        let mut inner = self.inner.take().unwrap();
174
175        let res = inner.poll_seek(pos);
176        self.inner = Some(inner);
177
178        res
179    }
180
181    fn poll_sync_all(&mut self) -> Poll<(), Error> {
182        let mut inner = self.inner.take().unwrap();
183
184        let res = inner.poll_sync_all();
185        self.inner = Some(inner);
186
187        res
188    }
189
190    fn poll_sync_data(&mut self) -> Poll<(), Error> {
191        let mut inner = self.inner.take().unwrap();
192
193        let res = inner.poll_sync_data();
194        self.inner = Some(inner);
195
196        res
197    }
198
199    fn poll_set_len(&mut self, size: u64) -> Poll<(), Error> {
200        let mut inner = self.inner.take().unwrap();
201
202        let res = inner.poll_set_len(size);
203        self.inner = Some(inner);
204
205        res
206    }
207
208    fn poll_metadata(&mut self) -> Poll<Metadata, Error> {
209        let mut inner = self.inner.take().unwrap();
210
211        let res = inner.poll_metadata();
212        self.inner = Some(inner);
213
214        res
215    }
216
217    fn poll_try_clone(&mut self) -> Poll<tokio_fs::file::File, Error> {
218        let mut inner = self.inner.take().unwrap();
219
220        let res = inner.poll_try_clone();
221        self.inner = Some(inner);
222
223        res
224    }
225
226    fn poll_set_permissions(&mut self, perm: Permissions) -> Poll<(), Error> {
227        let mut inner = self.inner.take().unwrap();
228
229        let res = inner.poll_set_permissions(perm);
230        self.inner = Some(inner);
231
232        res
233    }
234}
235
236pub struct SyncAll<T> {
237    inner: Option<T>,
238}
239
240impl<T> Future for SyncAll<T>
241where
242    T: AsyncFile,
243{
244    type Item = T;
245    type Error = Error;
246
247    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
248        let mut inner = self.inner.take().unwrap();
249
250        match inner.poll_sync_all() {
251            Ok(Async::Ready(())) => Ok(Async::Ready(inner)),
252            Ok(_) => Ok(Async::NotReady),
253            Err(e) => Err(e),
254        }
255    }
256}
257
258impl<T> AsyncFile for SyncAll<T>
259where
260    T: AsyncFile,
261{
262    fn poll_seek(&mut self, pos: SeekFrom) -> Poll<u64, Error> {
263        let mut inner = self.inner.take().unwrap();
264
265        let res = inner.poll_seek(pos);
266        self.inner = Some(inner);
267
268        res
269    }
270
271    fn poll_sync_all(&mut self) -> Poll<(), Error> {
272        let mut inner = self.inner.take().unwrap();
273
274        let res = inner.poll_sync_all();
275        self.inner = Some(inner);
276
277        res
278    }
279
280    fn poll_sync_data(&mut self) -> Poll<(), Error> {
281        let mut inner = self.inner.take().unwrap();
282
283        let res = inner.poll_sync_data();
284        self.inner = Some(inner);
285
286        res
287    }
288
289    fn poll_set_len(&mut self, size: u64) -> Poll<(), Error> {
290        let mut inner = self.inner.take().unwrap();
291
292        let res = inner.poll_set_len(size);
293        self.inner = Some(inner);
294
295        res
296    }
297
298    fn poll_metadata(&mut self) -> Poll<Metadata, Error> {
299        let mut inner = self.inner.take().unwrap();
300
301        let res = inner.poll_metadata();
302        self.inner = Some(inner);
303
304        res
305    }
306
307    fn poll_try_clone(&mut self) -> Poll<tokio_fs::file::File, Error> {
308        let mut inner = self.inner.take().unwrap();
309
310        let res = inner.poll_try_clone();
311        self.inner = Some(inner);
312
313        res
314    }
315
316    fn poll_set_permissions(&mut self, perm: Permissions) -> Poll<(), Error> {
317        let mut inner = self.inner.take().unwrap();
318
319        let res = inner.poll_set_permissions(perm);
320        self.inner = Some(inner);
321
322        res
323    }
324}
325
326pub struct SyncData<T> {
327    inner: Option<T>,
328}
329
330impl<T> Future for SyncData<T>
331where
332    T: AsyncFile,
333{
334    type Item = T;
335    type Error = Error;
336
337    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
338        let mut inner = self.inner.take().unwrap();
339
340        match inner.poll_sync_all() {
341            Ok(Async::Ready(())) => Ok(Async::Ready(inner)),
342            Ok(_) => Ok(Async::NotReady),
343            Err(e) => Err(e),
344        }
345    }
346}
347
348impl<T> AsyncFile for SyncData<T>
349where
350    T: AsyncFile,
351{
352    fn poll_seek(&mut self, pos: SeekFrom) -> Poll<u64, Error> {
353        let mut inner = self.inner.take().unwrap();
354
355        let res = inner.poll_seek(pos);
356        self.inner = Some(inner);
357
358        res
359    }
360
361    fn poll_sync_all(&mut self) -> Poll<(), Error> {
362        let mut inner = self.inner.take().unwrap();
363
364        let res = inner.poll_sync_all();
365        self.inner = Some(inner);
366
367        res
368    }
369
370    fn poll_sync_data(&mut self) -> Poll<(), Error> {
371        let mut inner = self.inner.take().unwrap();
372
373        let res = inner.poll_sync_data();
374        self.inner = Some(inner);
375
376        res
377    }
378
379    fn poll_set_len(&mut self, size: u64) -> Poll<(), Error> {
380        let mut inner = self.inner.take().unwrap();
381
382        let res = inner.poll_set_len(size);
383        self.inner = Some(inner);
384
385        res
386    }
387
388    fn poll_metadata(&mut self) -> Poll<Metadata, Error> {
389        let mut inner = self.inner.take().unwrap();
390
391        let res = inner.poll_metadata();
392        self.inner = Some(inner);
393
394        res
395    }
396
397    fn poll_try_clone(&mut self) -> Poll<tokio_fs::file::File, Error> {
398        let mut inner = self.inner.take().unwrap();
399
400        let res = inner.poll_try_clone();
401        self.inner = Some(inner);
402
403        res
404    }
405
406    fn poll_set_permissions(&mut self, perm: Permissions) -> Poll<(), Error> {
407        let mut inner = self.inner.take().unwrap();
408
409        let res = inner.poll_set_permissions(perm);
410        self.inner = Some(inner);
411
412        res
413    }
414}
415
416pub struct SetLen<T> {
417    size: u64,
418    inner: Option<T>,
419}
420
421impl<T> Future for SetLen<T>
422where
423    T: AsyncFile,
424{
425    type Item = T;
426    type Error = Error;
427
428    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
429        let mut inner = self.inner.take().unwrap();
430
431        match inner.poll_set_len(self.size) {
432            Ok(Async::Ready(())) => Ok(Async::Ready(inner)),
433            Ok(_) => Ok(Async::NotReady),
434            Err(e) => Err(e),
435        }
436    }
437}
438
439impl<T> AsyncFile for SetLen<T>
440where
441    T: AsyncFile,
442{
443    fn poll_seek(&mut self, pos: SeekFrom) -> Poll<u64, Error> {
444        let mut inner = self.inner.take().unwrap();
445
446        let res = inner.poll_seek(pos);
447        self.inner = Some(inner);
448
449        res
450    }
451
452    fn poll_sync_all(&mut self) -> Poll<(), Error> {
453        let mut inner = self.inner.take().unwrap();
454
455        let res = inner.poll_sync_all();
456        self.inner = Some(inner);
457
458        res
459    }
460
461    fn poll_sync_data(&mut self) -> Poll<(), Error> {
462        let mut inner = self.inner.take().unwrap();
463
464        let res = inner.poll_sync_data();
465        self.inner = Some(inner);
466
467        res
468    }
469
470    fn poll_set_len(&mut self, size: u64) -> Poll<(), Error> {
471        let mut inner = self.inner.take().unwrap();
472
473        let res = inner.poll_set_len(size);
474        self.inner = Some(inner);
475
476        res
477    }
478
479    fn poll_metadata(&mut self) -> Poll<Metadata, Error> {
480        let mut inner = self.inner.take().unwrap();
481
482        let res = inner.poll_metadata();
483        self.inner = Some(inner);
484
485        res
486    }
487
488    fn poll_try_clone(&mut self) -> Poll<tokio_fs::file::File, Error> {
489        let mut inner = self.inner.take().unwrap();
490
491        let res = inner.poll_try_clone();
492        self.inner = Some(inner);
493
494        res
495    }
496
497    fn poll_set_permissions(&mut self, perm: Permissions) -> Poll<(), Error> {
498        let mut inner = self.inner.take().unwrap();
499
500        let res = inner.poll_set_permissions(perm);
501        self.inner = Some(inner);
502
503        res
504    }
505}
506
507pub struct GetMetadata<T> {
508    inner: Option<T>,
509}
510
511impl<T> Future for GetMetadata<T>
512where
513    T: AsyncFile,
514{
515    type Item = (T, Metadata);
516    type Error = Error;
517
518    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
519        let mut inner = self.inner.take().unwrap();
520
521        match inner.poll_metadata() {
522            Ok(Async::Ready(metadata)) => Ok(Async::Ready((inner, metadata))),
523            Ok(_) => Ok(Async::NotReady),
524            Err(e) => Err(e),
525        }
526    }
527}
528
529impl<T> AsyncFile for GetMetadata<T>
530where
531    T: AsyncFile,
532{
533    fn poll_seek(&mut self, pos: SeekFrom) -> Poll<u64, Error> {
534        let mut inner = self.inner.take().unwrap();
535
536        let res = inner.poll_seek(pos);
537        self.inner = Some(inner);
538
539        res
540    }
541
542    fn poll_sync_all(&mut self) -> Poll<(), Error> {
543        let mut inner = self.inner.take().unwrap();
544
545        let res = inner.poll_sync_all();
546        self.inner = Some(inner);
547
548        res
549    }
550
551    fn poll_sync_data(&mut self) -> Poll<(), Error> {
552        let mut inner = self.inner.take().unwrap();
553
554        let res = inner.poll_sync_data();
555        self.inner = Some(inner);
556
557        res
558    }
559
560    fn poll_set_len(&mut self, size: u64) -> Poll<(), Error> {
561        let mut inner = self.inner.take().unwrap();
562
563        let res = inner.poll_set_len(size);
564        self.inner = Some(inner);
565
566        res
567    }
568
569    fn poll_metadata(&mut self) -> Poll<Metadata, Error> {
570        let mut inner = self.inner.take().unwrap();
571
572        let res = inner.poll_metadata();
573        self.inner = Some(inner);
574
575        res
576    }
577
578    fn poll_try_clone(&mut self) -> Poll<tokio_fs::file::File, Error> {
579        let mut inner = self.inner.take().unwrap();
580
581        let res = inner.poll_try_clone();
582        self.inner = Some(inner);
583
584        res
585    }
586
587    fn poll_set_permissions(&mut self, perm: Permissions) -> Poll<(), Error> {
588        let mut inner = self.inner.take().unwrap();
589
590        let res = inner.poll_set_permissions(perm);
591        self.inner = Some(inner);
592
593        res
594    }
595}
596
597pub struct TryClone<T> {
598    inner: Option<T>,
599}
600
601impl<T> Future for TryClone<T>
602where
603    T: AsyncFile,
604{
605    type Item = (T, tokio_fs::file::File);
606    type Error = Error;
607
608    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
609        let mut inner = self.inner.take().unwrap();
610
611        match inner.poll_try_clone() {
612            Ok(Async::Ready(file)) => Ok(Async::Ready((inner, file))),
613            Ok(_) => Ok(Async::NotReady),
614            Err(e) => Err(e),
615        }
616    }
617}
618
619impl<T> AsyncFile for TryClone<T>
620where
621    T: AsyncFile,
622{
623    fn poll_seek(&mut self, pos: SeekFrom) -> Poll<u64, Error> {
624        let mut inner = self.inner.take().unwrap();
625
626        let res = inner.poll_seek(pos);
627        self.inner = Some(inner);
628
629        res
630    }
631
632    fn poll_sync_all(&mut self) -> Poll<(), Error> {
633        let mut inner = self.inner.take().unwrap();
634
635        let res = inner.poll_sync_all();
636        self.inner = Some(inner);
637
638        res
639    }
640
641    fn poll_sync_data(&mut self) -> Poll<(), Error> {
642        let mut inner = self.inner.take().unwrap();
643
644        let res = inner.poll_sync_data();
645        self.inner = Some(inner);
646
647        res
648    }
649
650    fn poll_set_len(&mut self, size: u64) -> Poll<(), Error> {
651        let mut inner = self.inner.take().unwrap();
652
653        let res = inner.poll_set_len(size);
654        self.inner = Some(inner);
655
656        res
657    }
658
659    fn poll_metadata(&mut self) -> Poll<Metadata, Error> {
660        let mut inner = self.inner.take().unwrap();
661
662        let res = inner.poll_metadata();
663        self.inner = Some(inner);
664
665        res
666    }
667
668    fn poll_try_clone(&mut self) -> Poll<tokio_fs::file::File, Error> {
669        let mut inner = self.inner.take().unwrap();
670
671        let res = inner.poll_try_clone();
672        self.inner = Some(inner);
673
674        res
675    }
676
677    fn poll_set_permissions(&mut self, perm: Permissions) -> Poll<(), Error> {
678        let mut inner = self.inner.take().unwrap();
679
680        let res = inner.poll_set_permissions(perm);
681        self.inner = Some(inner);
682
683        res
684    }
685}
686
687pub struct SetPermissions<T> {
688    perm: Permissions,
689    inner: Option<T>,
690}
691
692impl<T> Future for SetPermissions<T>
693where
694    T: AsyncFile,
695{
696    type Item = T;
697    type Error = Error;
698
699    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
700        let mut inner = self.inner.take().unwrap();
701
702        match inner.poll_set_permissions(self.perm.clone()) {
703            Ok(Async::Ready(())) => Ok(Async::Ready(inner)),
704            Ok(_) => Ok(Async::NotReady),
705            Err(e) => Err(e),
706        }
707    }
708}
709
710impl<T> AsyncFile for SetPermissions<T>
711where
712    T: AsyncFile,
713{
714    fn poll_seek(&mut self, pos: SeekFrom) -> Poll<u64, Error> {
715        let mut inner = self.inner.take().unwrap();
716
717        let res = inner.poll_seek(pos);
718        self.inner = Some(inner);
719
720        res
721    }
722
723    fn poll_sync_all(&mut self) -> Poll<(), Error> {
724        let mut inner = self.inner.take().unwrap();
725
726        let res = inner.poll_sync_all();
727        self.inner = Some(inner);
728
729        res
730    }
731
732    fn poll_sync_data(&mut self) -> Poll<(), Error> {
733        let mut inner = self.inner.take().unwrap();
734
735        let res = inner.poll_sync_data();
736        self.inner = Some(inner);
737
738        res
739    }
740
741    fn poll_set_len(&mut self, size: u64) -> Poll<(), Error> {
742        let mut inner = self.inner.take().unwrap();
743
744        let res = inner.poll_set_len(size);
745        self.inner = Some(inner);
746
747        res
748    }
749
750    fn poll_metadata(&mut self) -> Poll<Metadata, Error> {
751        let mut inner = self.inner.take().unwrap();
752
753        let res = inner.poll_metadata();
754        self.inner = Some(inner);
755
756        res
757    }
758
759    fn poll_try_clone(&mut self) -> Poll<tokio_fs::file::File, Error> {
760        let mut inner = self.inner.take().unwrap();
761
762        let res = inner.poll_try_clone();
763        self.inner = Some(inner);
764
765        res
766    }
767
768    fn poll_set_permissions(&mut self, perm: Permissions) -> Poll<(), Error> {
769        let mut inner = self.inner.take().unwrap();
770
771        let res = inner.poll_set_permissions(perm);
772        self.inner = Some(inner);
773
774        res
775    }
776}
file_futures/lib.rs

file_futures/
lib.rs
