firehazard 0.0.0-2022-09-10

Unopinionated low level API bindings focused on soundness, safety, and stronger types over raw FFI.
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

use core::fmt::{self, Debug, Display, Formatter};



pub trait Read {
    fn read(&mut self, buf: &mut [u8]) -> Result<usize>;
    // TODO: lots
}

pub trait Write {
    fn write(&mut self, buf: &[u8]) -> Result<usize>;
    fn flush(&mut self) -> Result<()>;
    // TODO: lots
}

pub struct Error(ErrorImpl);

pub type Result<T> = core::result::Result<T, Error>;

#[derive(Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
enum ErrorImpl {
    Code(i32),
    Kind(ErrorKind),
}

impl Error {
    // fn new
    // fn other
    pub fn last_os_error() -> Self { Self::from_raw_os_error(crate::Error::get_last().into()) }
    pub fn from_raw_os_error(code: i32) -> Self { Self(ErrorImpl::Code(code)) }
    pub fn raw_os_error(&self) -> Option<i32> { match self.0 { ErrorImpl::Code(c) => Some(c), _ => None } }
    // fn get_ref
    // fn get_mut
    // fn into_inner
    pub fn kind(&self) -> ErrorKind { match self.0 { ErrorImpl::Kind(k) => k, _ => ErrorKind::Other } }
}

impl From<ErrorKind> for Error { fn from(kind: ErrorKind) -> Self { Self(ErrorImpl::Kind(kind)) } }

#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub enum ErrorKind {
    NotFound,
    PermissionDenied,
    ConnectionRefused,
    ConnectionReset,
    HostUnreachable,
    NetworkUnreachable,
    ConnectionAborted,
    NotConnected,
    AddrInUse,
    AddrNotAvailable,
    NetworkDown,
    BrokenPipe,
    AlreadyExists,
    WouldBlock,
    NotADirectory,
    IsADirectory,
    DirectoryNotEmpty,
    ReadOnlyFilesystem,
    FilesystemLoop,
    StaleNetworkFileHandle,
    InvalidInput,
    InvalidData,
    TimedOut,
    WriteZero,
    StorageFull,
    NotSeekable,
    FilesystemQuotaExceeded,
    FileTooLarge,
    ResourceBusy,
    ExecutableFileBusy,
    Deadlock,
    CrossesDevices,
    TooManyLinks,
    InvalidFilename,
    ArgumentListTooLong,
    Interrupted,
    Unsupported,
    UnexpectedEof,
    OutOfMemory,
    Other,
}



impl Debug for Error {
    fn fmt(&self, fmt: &mut Formatter) -> fmt::Result {
        match self.0 {
            ErrorImpl::Code(code) => write!(fmt, "io::Error {{ os: {code} }}"),
            ErrorImpl::Kind(kind) => write!(fmt, "io::Error {{ kind: {kind} }}"),
        }
    }
}

impl Display for Error {
    fn fmt(&self, fmt: &mut Formatter) -> fmt::Result {
        match self.0 {
            ErrorImpl::Code(code) => write!(fmt, "io::Error {{ os: {code} }}"),
            ErrorImpl::Kind(kind) => write!(fmt, "io::Error {{ kind: {kind} }}"),
        }
    }
}

impl Display for ErrorKind {
    fn fmt(&self, fmt: &mut Formatter) -> fmt::Result {
        Debug::fmt(self, fmt)
    }
}