dope-core 0.26.0

Owned native I/O and completion driver for dope
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

use dope_sys::io::file::{Mode, Open};
use o3::alloc;

use crate::io::fs::{File, path};

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum Error {
    Path(path::Error),
    Allocation(alloc::Error),
    System(crate::Errno),
    Directory(crate::Errno),
}

impl From<path::CopyError> for Error {
    fn from(error: path::CopyError) -> Self {
        match error {
            path::CopyError::Nul { position } => Self::Path(path::Error::Nul { position }),
            path::CopyError::Allocation(error) => Self::Allocation(error),
        }
    }
}

const _: () = assert!(size_of::<Error>() == 4 * size_of::<usize>());

/// Opening policy independent of the selected asynchronous backend.
#[derive(Clone, Copy, Debug)]
pub struct Options {
    flags: Open,
    mode: Mode,
}

#[derive(Clone, Copy, Debug)]
pub enum Access {
    Read,
    Write,
    ReadWrite,
    Directory,
}

#[derive(Clone, Copy, Debug)]
pub enum Creation {
    Existing,
    Create,
    Exclusive,
}

impl Options {
    pub const fn new(access: Access) -> Self {
        let flags = match access {
            Access::Read => Open::READ,
            Access::Write => Open::WRITE,
            Access::ReadWrite => Open::READ_WRITE,
            Access::Directory => Open::DIRECTORY,
        };
        Self {
            flags: flags.union(Open::CLOSE_ON_EXEC),
            mode: Mode::new(0o666),
        }
    }

    pub const fn creation(mut self, creation: Creation) -> Self {
        let flags = match creation {
            Creation::Existing => Open::NONE,
            Creation::Create => Open::CREATE,
            Creation::Exclusive => Open::CREATE.union(Open::EXCLUSIVE),
        };
        self.flags = self
            .flags
            .difference(Open::CREATE.union(Open::EXCLUSIVE))
            .union(flags);
        self
    }

    pub const fn nofollow(mut self) -> Self {
        self.flags = self.flags.union(Open::NO_FOLLOW);
        self
    }

    pub const fn nonblock(mut self) -> Self {
        self.flags = self.flags.union(Open::NONBLOCK);
        self
    }

    /// Makes current-position writes append at the file's current end.
    pub const fn append(mut self) -> Self {
        self.flags = self.flags.union(Open::APPEND);
        self
    }

    pub const fn truncate(mut self) -> Self {
        self.flags = self.flags.union(Open::TRUNCATE);
        self
    }

    pub const fn mode(mut self, mode: Mode) -> Self {
        self.mode = mode;
        self
    }

    pub(super) const fn lower(self) -> (Open, Mode) {
        let mode = if self.flags.contains(Open::CREATE) {
            self.mode
        } else {
            Mode::new(0)
        };
        (self.flags, mode)
    }

    pub fn open(self, path: &std::ffi::CStr) -> Result<File, crate::Errno> {
        use dope_sys::io::file::File as _;

        let (flags, mode) = self.lower();
        crate::Backend::open::<dope_sys::Errno>(path, flags, mode).map(File::from)
    }
}