compio-fs 0.5.1

Filesystem IO for compio
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

use std::{io, os::windows::fs::OpenOptionsExt, panic::resume_unwind, path::Path};

use windows_sys::Win32::Storage::FileSystem::FILE_FLAG_OVERLAPPED;

use crate::File;

#[derive(Clone, Debug)]
pub struct OpenOptions {
    opt: std::fs::OpenOptions,
}

impl OpenOptions {
    pub fn new() -> OpenOptions {
        OpenOptions {
            opt: std::fs::OpenOptions::new(),
        }
    }

    pub fn read(&mut self, read: bool) {
        self.opt.read(read);
    }

    pub fn write(&mut self, write: bool) {
        self.opt.write(write);
    }

    pub fn truncate(&mut self, truncate: bool) {
        self.opt.truncate(truncate);
    }

    pub fn create(&mut self, create: bool) {
        self.opt.create(create);
    }

    pub fn create_new(&mut self, create_new: bool) {
        self.opt.create_new(create_new);
    }

    pub fn custom_flags(&mut self, flags: u32) {
        self.opt.custom_flags(flags);
    }

    pub fn access_mode(&mut self, access_mode: u32) {
        self.opt.access_mode(access_mode);
    }

    pub fn share_mode(&mut self, share_mode: u32) {
        self.opt.share_mode(share_mode);
    }

    pub fn attributes(&mut self, attrs: u32) {
        self.opt.attributes(attrs);
    }

    pub fn security_qos_flags(&mut self, flags: u32) {
        self.opt.security_qos_flags(flags);
    }

    pub async fn open(&self, p: impl AsRef<Path>) -> io::Result<File> {
        let mut opt = self.opt.clone();
        opt.attributes(FILE_FLAG_OVERLAPPED);
        let p = p.as_ref().to_path_buf();
        let file = compio_runtime::spawn_blocking(move || opt.open(p))
            .await
            .unwrap_or_else(|e| resume_unwind(e))?;
        File::from_std(file)
    }
}