1use std::io::RawOsError;
2
3use derive_more::{Display, Error, From};
4
5use libc::EOPNOTSUPP;
6use libc::{EACCES, EBADF, EBUSY, EDQUOT, EEXIST, EFAULT, EFBIG, EINTR, EINVAL, EISDIR, ELOOP, EMFILE, ENAMETOOLONG, ENFILE, ENODEV, ENOENT, ENOMEM, ENOSPC, ENOTDIR, ENXIO, EOVERFLOW, EPERM, EROFS, ETXTBSY};
7
8use crate::fs::error::*;
9use crate::fs::panic::*;
10
11#[derive(#[automatically_derived]
impl ::core::fmt::Debug for CloseError {
#[inline]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match self {
CloseError::Interrupt(__self_0) =>
::core::fmt::Formatter::debug_tuple_field1_finish(f,
"Interrupt", &__self_0),
CloseError::IO(__self_0) =>
::core::fmt::Formatter::debug_tuple_field1_finish(f, "IO",
&__self_0),
CloseError::StorageExhausted(__self_0) =>
::core::fmt::Formatter::debug_tuple_field1_finish(f,
"StorageExhausted", &__self_0),
}
}
}Debug, #[allow(deprecated)]
#[allow(unreachable_code)]
#[automatically_derived]
impl derive_more::core::fmt::Display for CloseError {
fn fmt(&self, __derive_more_f: &mut derive_more::core::fmt::Formatter<'_>)
-> derive_more::core::fmt::Result {
match self {
Self::Interrupt(_0) => {
__derive_more_f.write_fmt(format_args!("error closing file or directory: {0}",
_0))
}
Self::IO(_0) => {
__derive_more_f.write_fmt(format_args!("error closing file or directory: {0}",
_0))
}
Self::StorageExhausted(_0) => {
__derive_more_f.write_fmt(format_args!("error closing file or directory: {0}",
_0))
}
}
}
}Display, #[automatically_derived]
impl ::core::clone::Clone for CloseError {
#[inline]
fn clone(&self) -> CloseError {
match self {
CloseError::Interrupt(__self_0) =>
CloseError::Interrupt(::core::clone::Clone::clone(__self_0)),
CloseError::IO(__self_0) =>
CloseError::IO(::core::clone::Clone::clone(__self_0)),
CloseError::StorageExhausted(__self_0) =>
CloseError::StorageExhausted(::core::clone::Clone::clone(__self_0)),
}
}
}Clone, #[allow(deprecated)]
#[allow(unreachable_code)]
#[automatically_derived]
impl derive_more::core::convert::From<(StorageExhaustedError)> for CloseError
{
#[inline]
fn from(value: (StorageExhaustedError)) -> Self {
CloseError::StorageExhausted(value)
}
}From, #[automatically_derived]
impl derive_more::core::error::Error for CloseError {
fn source(&self)
-> Option<&(dyn derive_more::core::error::Error + 'static)> {
use derive_more::__private::AsDynError as _;
match self {
CloseError::Interrupt(source) =>
Some(source.__derive_more_as_dyn_error()),
CloseError::IO(source) =>
Some(source.__derive_more_as_dyn_error()),
CloseError::StorageExhausted(source) =>
Some(source.__derive_more_as_dyn_error()),
}
}
}Error)]
12#[display("error closing file or directory: {_0}")]
13pub enum CloseError {
14 Interrupt(InterruptError),
15 IO(IOError),
16 StorageExhausted(StorageExhaustedError),
17}
18
19#[derive(#[automatically_derived]
impl ::core::fmt::Debug for SyncError {
#[inline]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match self {
SyncError::Interrupt(__self_0) =>
::core::fmt::Formatter::debug_tuple_field1_finish(f,
"Interrupt", &__self_0),
SyncError::IO(__self_0) =>
::core::fmt::Formatter::debug_tuple_field1_finish(f, "IO",
&__self_0),
SyncError::StorageExhausted(__self_0) =>
::core::fmt::Formatter::debug_tuple_field1_finish(f,
"StorageExhausted", &__self_0),
SyncError::SyncUnsupported(__self_0) =>
::core::fmt::Formatter::debug_tuple_field1_finish(f,
"SyncUnsupported", &__self_0),
}
}
}Debug, #[allow(deprecated)]
#[allow(unreachable_code)]
#[automatically_derived]
impl derive_more::core::fmt::Display for SyncError {
fn fmt(&self, __derive_more_f: &mut derive_more::core::fmt::Formatter<'_>)
-> derive_more::core::fmt::Result {
match self {
Self::Interrupt(_0) => {
__derive_more_f.write_fmt(format_args!("error syncing file to disk: {0}",
_0))
}
Self::IO(_0) => {
__derive_more_f.write_fmt(format_args!("error syncing file to disk: {0}",
_0))
}
Self::StorageExhausted(_0) => {
__derive_more_f.write_fmt(format_args!("error syncing file to disk: {0}",
_0))
}
Self::SyncUnsupported(_0) => {
__derive_more_f.write_fmt(format_args!("error syncing file to disk: {0}",
_0))
}
}
}
}Display, #[automatically_derived]
impl ::core::clone::Clone for SyncError {
#[inline]
fn clone(&self) -> SyncError {
match self {
SyncError::Interrupt(__self_0) =>
SyncError::Interrupt(::core::clone::Clone::clone(__self_0)),
SyncError::IO(__self_0) =>
SyncError::IO(::core::clone::Clone::clone(__self_0)),
SyncError::StorageExhausted(__self_0) =>
SyncError::StorageExhausted(::core::clone::Clone::clone(__self_0)),
SyncError::SyncUnsupported(__self_0) =>
SyncError::SyncUnsupported(::core::clone::Clone::clone(__self_0)),
}
}
}Clone, #[allow(deprecated)]
#[allow(unreachable_code)]
#[automatically_derived]
impl derive_more::core::convert::From<(SyncUnsupportedError)> for SyncError {
#[inline]
fn from(value: (SyncUnsupportedError)) -> Self {
SyncError::SyncUnsupported(value)
}
}From, #[automatically_derived]
impl derive_more::core::error::Error for SyncError {
fn source(&self)
-> Option<&(dyn derive_more::core::error::Error + 'static)> {
use derive_more::__private::AsDynError as _;
match self {
SyncError::Interrupt(source) =>
Some(source.__derive_more_as_dyn_error()),
SyncError::IO(source) =>
Some(source.__derive_more_as_dyn_error()),
SyncError::StorageExhausted(source) =>
Some(source.__derive_more_as_dyn_error()),
SyncError::SyncUnsupported(source) =>
Some(source.__derive_more_as_dyn_error()),
}
}
}Error)]
20#[display("error syncing file to disk: {_0}")]
21pub enum SyncError {
22 Interrupt(InterruptError),
23 IO(IOError),
24 StorageExhausted(StorageExhaustedError),
25 SyncUnsupported(SyncUnsupportedError),
26}
27
28#[derive(#[automatically_derived]
impl ::core::fmt::Debug for CloneError {
#[inline]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match self {
CloneError::FileCount(__self_0) =>
::core::fmt::Formatter::debug_tuple_field1_finish(f,
"FileCount", &__self_0),
CloneError::OOM(__self_0) =>
::core::fmt::Formatter::debug_tuple_field1_finish(f, "OOM",
&__self_0),
}
}
}Debug, #[allow(deprecated)]
#[allow(unreachable_code)]
#[automatically_derived]
impl derive_more::core::fmt::Display for CloneError {
fn fmt(&self, __derive_more_f: &mut derive_more::core::fmt::Formatter<'_>)
-> derive_more::core::fmt::Result {
match self {
Self::FileCount(_0) => {
__derive_more_f.write_fmt(format_args!("error cloning file or directory: {0}",
_0))
}
Self::OOM(_0) => {
__derive_more_f.write_fmt(format_args!("error cloning file or directory: {0}",
_0))
}
}
}
}Display, #[automatically_derived]
impl ::core::clone::Clone for CloneError {
#[inline]
fn clone(&self) -> CloneError {
match self {
CloneError::FileCount(__self_0) =>
CloneError::FileCount(::core::clone::Clone::clone(__self_0)),
CloneError::OOM(__self_0) =>
CloneError::OOM(::core::clone::Clone::clone(__self_0)),
}
}
}Clone, #[allow(deprecated)]
#[allow(unreachable_code)]
#[automatically_derived]
impl derive_more::core::convert::From<(OOMError)> for CloneError {
#[inline]
fn from(value: (OOMError)) -> Self { CloneError::OOM(value) }
}From, #[automatically_derived]
impl derive_more::core::error::Error for CloneError {
fn source(&self)
-> Option<&(dyn derive_more::core::error::Error + 'static)> {
use derive_more::__private::AsDynError as _;
match self {
CloneError::FileCount(source) =>
Some(source.__derive_more_as_dyn_error()),
CloneError::OOM(source) =>
Some(source.__derive_more_as_dyn_error()),
}
}
}Error)]
29#[display("error cloning file or directory: {_0}")]
30pub enum CloneError {
31 FileCount(FileCountError),
32 OOM(OOMError),
33}
34
35#[derive(#[automatically_derived]
impl ::core::fmt::Debug for LockError {
#[inline]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match self {
LockError::Interrupt(__self_0) =>
::core::fmt::Formatter::debug_tuple_field1_finish(f,
"Interrupt", &__self_0),
LockError::LockMem(__self_0) =>
::core::fmt::Formatter::debug_tuple_field1_finish(f,
"LockMem", &__self_0),
}
}
}Debug, #[allow(deprecated)]
#[allow(unreachable_code)]
#[automatically_derived]
impl derive_more::core::fmt::Display for LockError {
fn fmt(&self, __derive_more_f: &mut derive_more::core::fmt::Formatter<'_>)
-> derive_more::core::fmt::Result {
match self {
Self::Interrupt(_0) => {
__derive_more_f.write_fmt(format_args!("error locking file: {0}",
_0))
}
Self::LockMem(_0) => {
__derive_more_f.write_fmt(format_args!("error locking file: {0}",
_0))
}
}
}
}Display, #[automatically_derived]
impl ::core::clone::Clone for LockError {
#[inline]
fn clone(&self) -> LockError {
match self {
LockError::Interrupt(__self_0) =>
LockError::Interrupt(::core::clone::Clone::clone(__self_0)),
LockError::LockMem(__self_0) =>
LockError::LockMem(::core::clone::Clone::clone(__self_0)),
}
}
}Clone, #[allow(deprecated)]
#[allow(unreachable_code)]
#[automatically_derived]
impl derive_more::core::convert::From<(LockMemError)> for LockError {
#[inline]
fn from(value: (LockMemError)) -> Self { LockError::LockMem(value) }
}From, #[automatically_derived]
impl derive_more::core::error::Error for LockError {
fn source(&self)
-> Option<&(dyn derive_more::core::error::Error + 'static)> {
use derive_more::__private::AsDynError as _;
match self {
LockError::Interrupt(source) =>
Some(source.__derive_more_as_dyn_error()),
LockError::LockMem(source) =>
Some(source.__derive_more_as_dyn_error()),
}
}
}Error)]
36#[display("error locking file: {_0}")]
37pub enum LockError {
38 Interrupt(InterruptError),
39 LockMem(LockMemError),
40}
41
42#[derive(#[automatically_derived]
impl ::core::fmt::Debug for TryLockError {
#[inline]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match self {
TryLockError::Interrupt(__self_0) =>
::core::fmt::Formatter::debug_tuple_field1_finish(f,
"Interrupt", &__self_0),
TryLockError::LockMem(__self_0) =>
::core::fmt::Formatter::debug_tuple_field1_finish(f,
"LockMem", &__self_0),
TryLockError::WouldBlock(__self_0) =>
::core::fmt::Formatter::debug_tuple_field1_finish(f,
"WouldBlock", &__self_0),
}
}
}Debug, #[allow(deprecated)]
#[allow(unreachable_code)]
#[automatically_derived]
impl derive_more::core::fmt::Display for TryLockError {
fn fmt(&self, __derive_more_f: &mut derive_more::core::fmt::Formatter<'_>)
-> derive_more::core::fmt::Result {
match self {
Self::Interrupt(_0) => {
__derive_more_f.write_fmt(format_args!("error locking file: {0}",
_0))
}
Self::LockMem(_0) => {
__derive_more_f.write_fmt(format_args!("error locking file: {0}",
_0))
}
Self::WouldBlock(_0) => {
__derive_more_f.write_fmt(format_args!("error locking file: {0}",
_0))
}
}
}
}Display, #[automatically_derived]
impl ::core::clone::Clone for TryLockError {
#[inline]
fn clone(&self) -> TryLockError {
match self {
TryLockError::Interrupt(__self_0) =>
TryLockError::Interrupt(::core::clone::Clone::clone(__self_0)),
TryLockError::LockMem(__self_0) =>
TryLockError::LockMem(::core::clone::Clone::clone(__self_0)),
TryLockError::WouldBlock(__self_0) =>
TryLockError::WouldBlock(::core::clone::Clone::clone(__self_0)),
}
}
}Clone, #[allow(deprecated)]
#[allow(unreachable_code)]
#[automatically_derived]
impl derive_more::core::convert::From<(WouldBlockError)> for TryLockError {
#[inline]
fn from(value: (WouldBlockError)) -> Self {
TryLockError::WouldBlock(value)
}
}From, #[automatically_derived]
impl derive_more::core::error::Error for TryLockError {
fn source(&self)
-> Option<&(dyn derive_more::core::error::Error + 'static)> {
use derive_more::__private::AsDynError as _;
match self {
TryLockError::Interrupt(source) =>
Some(source.__derive_more_as_dyn_error()),
TryLockError::LockMem(source) =>
Some(source.__derive_more_as_dyn_error()),
TryLockError::WouldBlock(source) =>
Some(source.__derive_more_as_dyn_error()),
}
}
}Error)]
43#[display("error locking file: {_0}")]
44pub enum TryLockError {
45 Interrupt(InterruptError),
46 LockMem(LockMemError),
47 WouldBlock(WouldBlockError),
48}
49
50#[derive(#[automatically_derived]
impl ::core::fmt::Debug for MetadataError {
#[inline]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match self {
MetadataError::OOM(__self_0) =>
::core::fmt::Formatter::debug_tuple_field1_finish(f, "OOM",
&__self_0),
MetadataError::MetadataOverflow(__self_0) =>
::core::fmt::Formatter::debug_tuple_field1_finish(f,
"MetadataOverflow", &__self_0),
}
}
}Debug, #[allow(deprecated)]
#[allow(unreachable_code)]
#[automatically_derived]
impl derive_more::core::fmt::Display for MetadataError {
fn fmt(&self, __derive_more_f: &mut derive_more::core::fmt::Formatter<'_>)
-> derive_more::core::fmt::Result {
match self {
Self::OOM(_0) => {
__derive_more_f.write_fmt(format_args!("error retrieving metadata: {0}",
_0))
}
Self::MetadataOverflow(_0) => {
__derive_more_f.write_fmt(format_args!("error retrieving metadata: {0}",
_0))
}
}
}
}Display, #[automatically_derived]
impl ::core::clone::Clone for MetadataError {
#[inline]
fn clone(&self) -> MetadataError {
match self {
MetadataError::OOM(__self_0) =>
MetadataError::OOM(::core::clone::Clone::clone(__self_0)),
MetadataError::MetadataOverflow(__self_0) =>
MetadataError::MetadataOverflow(::core::clone::Clone::clone(__self_0)),
}
}
}Clone, #[allow(deprecated)]
#[allow(unreachable_code)]
#[automatically_derived]
impl derive_more::core::convert::From<(MetadataOverflowError)> for
MetadataError {
#[inline]
fn from(value: (MetadataOverflowError)) -> Self {
MetadataError::MetadataOverflow(value)
}
}From, #[automatically_derived]
impl derive_more::core::error::Error for MetadataError {
fn source(&self)
-> Option<&(dyn derive_more::core::error::Error + 'static)> {
use derive_more::__private::AsDynError as _;
match self {
MetadataError::OOM(source) =>
Some(source.__derive_more_as_dyn_error()),
MetadataError::MetadataOverflow(source) =>
Some(source.__derive_more_as_dyn_error()),
}
}
}Error)]
51#[display("error retrieving metadata: {_0}")]
52pub enum MetadataError {
53 OOM(OOMError),
54 MetadataOverflow(MetadataOverflowError),
55}
56
57#[derive(#[automatically_derived]
impl ::core::fmt::Debug for FileTypeError {
#[inline]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match self {
FileTypeError::OOM(__self_0) =>
::core::fmt::Formatter::debug_tuple_field1_finish(f, "OOM",
&__self_0),
FileTypeError::IncorrectType(__self_0) =>
::core::fmt::Formatter::debug_tuple_field1_finish(f,
"IncorrectType", &__self_0),
FileTypeError::MetadataOverflow(__self_0) =>
::core::fmt::Formatter::debug_tuple_field1_finish(f,
"MetadataOverflow", &__self_0),
}
}
}Debug, #[allow(deprecated)]
#[allow(unreachable_code)]
#[automatically_derived]
impl derive_more::core::fmt::Display for FileTypeError {
fn fmt(&self, __derive_more_f: &mut derive_more::core::fmt::Formatter<'_>)
-> derive_more::core::fmt::Result {
match self {
Self::OOM(_0) => {
derive_more::core::fmt::Display::fmt(_0, __derive_more_f)
}
Self::IncorrectType(_0) => {
derive_more::core::fmt::Display::fmt(_0, __derive_more_f)
}
Self::MetadataOverflow(_0) => {
derive_more::core::fmt::Display::fmt(_0, __derive_more_f)
}
}
}
}Display, #[automatically_derived]
impl ::core::clone::Clone for FileTypeError {
#[inline]
fn clone(&self) -> FileTypeError {
match self {
FileTypeError::OOM(__self_0) =>
FileTypeError::OOM(::core::clone::Clone::clone(__self_0)),
FileTypeError::IncorrectType(__self_0) =>
FileTypeError::IncorrectType(::core::clone::Clone::clone(__self_0)),
FileTypeError::MetadataOverflow(__self_0) =>
FileTypeError::MetadataOverflow(::core::clone::Clone::clone(__self_0)),
}
}
}Clone, #[allow(deprecated)]
#[allow(unreachable_code)]
#[automatically_derived]
impl derive_more::core::convert::From<(MetadataOverflowError)> for
FileTypeError {
#[inline]
fn from(value: (MetadataOverflowError)) -> Self {
FileTypeError::MetadataOverflow(value)
}
}From, #[automatically_derived]
impl derive_more::core::error::Error for FileTypeError {
fn source(&self)
-> Option<&(dyn derive_more::core::error::Error + 'static)> {
use derive_more::__private::AsDynError as _;
match self {
FileTypeError::OOM(source) =>
Some(source.__derive_more_as_dyn_error()),
FileTypeError::IncorrectType(source) =>
Some(source.__derive_more_as_dyn_error()),
FileTypeError::MetadataOverflow(source) =>
Some(source.__derive_more_as_dyn_error()),
}
}
}Error)]
58pub(crate) enum FileTypeError {
59 OOM(OOMError),
60 IncorrectType(IncorrectTypeError),
61 MetadataOverflow(MetadataOverflowError),
62}
63
64impl From<MetadataError> for FileTypeError {
65 fn from(value: MetadataError) -> Self {
66 match value {
67 MetadataError::OOM(e) => e.into(),
68 MetadataError::MetadataOverflow(e) => e.into(),
69 }
70 }
71}
72
73#[derive(#[automatically_derived]
impl ::core::fmt::Debug for OpenError {
#[inline]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match self {
OpenError::Access(__self_0) =>
::core::fmt::Formatter::debug_tuple_field1_finish(f, "Access",
&__self_0),
OpenError::Interrupt(__self_0) =>
::core::fmt::Formatter::debug_tuple_field1_finish(f,
"Interrupt", &__self_0),
OpenError::StorageExhausted(__self_0) =>
::core::fmt::Formatter::debug_tuple_field1_finish(f,
"StorageExhausted", &__self_0),
OpenError::OversizedFile(__self_0) =>
::core::fmt::Formatter::debug_tuple_field1_finish(f,
"OversizedFile", &__self_0),
OpenError::IncorrectType(__self_0) =>
::core::fmt::Formatter::debug_tuple_field1_finish(f,
"IncorrectType", &__self_0),
OpenError::InvalidBasename(__self_0) =>
::core::fmt::Formatter::debug_tuple_field1_finish(f,
"InvalidBasename", &__self_0),
OpenError::ExcessiveLinks(__self_0) =>
::core::fmt::Formatter::debug_tuple_field1_finish(f,
"ExcessiveLinks", &__self_0),
OpenError::FileCount(__self_0) =>
::core::fmt::Formatter::debug_tuple_field1_finish(f,
"FileCount", &__self_0),
OpenError::PathLength(__self_0) =>
::core::fmt::Formatter::debug_tuple_field1_finish(f,
"PathLength", &__self_0),
OpenError::MetadataOverflow(__self_0) =>
::core::fmt::Formatter::debug_tuple_field1_finish(f,
"MetadataOverflow", &__self_0),
OpenError::MissingComponent(__self_0) =>
::core::fmt::Formatter::debug_tuple_field1_finish(f,
"MissingComponent", &__self_0),
OpenError::OOM(__self_0) =>
::core::fmt::Formatter::debug_tuple_field1_finish(f, "OOM",
&__self_0),
OpenError::NonDirComponent(__self_0) =>
::core::fmt::Formatter::debug_tuple_field1_finish(f,
"NonDirComponent", &__self_0),
OpenError::Permission(__self_0) =>
::core::fmt::Formatter::debug_tuple_field1_finish(f,
"Permission", &__self_0),
OpenError::ReadOnlyFS(__self_0) =>
::core::fmt::Formatter::debug_tuple_field1_finish(f,
"ReadOnlyFS", &__self_0),
OpenError::BusyExecutable(__self_0) =>
::core::fmt::Formatter::debug_tuple_field1_finish(f,
"BusyExecutable", &__self_0),
}
}
}Debug, #[allow(deprecated)]
#[allow(unreachable_code)]
#[automatically_derived]
impl derive_more::core::fmt::Display for OpenError {
fn fmt(&self, __derive_more_f: &mut derive_more::core::fmt::Formatter<'_>)
-> derive_more::core::fmt::Result {
match self {
Self::Access(_0) => {
__derive_more_f.write_fmt(format_args!("error opening file or directory: {0}",
_0))
}
Self::Interrupt(_0) => {
__derive_more_f.write_fmt(format_args!("error opening file or directory: {0}",
_0))
}
Self::StorageExhausted(_0) => {
__derive_more_f.write_fmt(format_args!("error opening file or directory: {0}",
_0))
}
Self::OversizedFile(_0) => {
__derive_more_f.write_fmt(format_args!("error opening file or directory: {0}",
_0))
}
Self::IncorrectType(_0) => {
__derive_more_f.write_fmt(format_args!("error opening file or directory: {0}",
_0))
}
Self::InvalidBasename(_0) => {
__derive_more_f.write_fmt(format_args!("error opening file or directory: {0}",
_0))
}
Self::ExcessiveLinks(_0) => {
__derive_more_f.write_fmt(format_args!("error opening file or directory: {0}",
_0))
}
Self::FileCount(_0) => {
__derive_more_f.write_fmt(format_args!("error opening file or directory: {0}",
_0))
}
Self::PathLength(_0) => {
__derive_more_f.write_fmt(format_args!("error opening file or directory: {0}",
_0))
}
Self::MetadataOverflow(_0) => {
__derive_more_f.write_fmt(format_args!("error opening file or directory: {0}",
_0))
}
Self::MissingComponent(_0) => {
__derive_more_f.write_fmt(format_args!("error opening file or directory: {0}",
_0))
}
Self::OOM(_0) => {
__derive_more_f.write_fmt(format_args!("error opening file or directory: {0}",
_0))
}
Self::NonDirComponent(_0) => {
__derive_more_f.write_fmt(format_args!("error opening file or directory: {0}",
_0))
}
Self::Permission(_0) => {
__derive_more_f.write_fmt(format_args!("error opening file or directory: {0}",
_0))
}
Self::ReadOnlyFS(_0) => {
__derive_more_f.write_fmt(format_args!("error opening file or directory: {0}",
_0))
}
Self::BusyExecutable(_0) => {
__derive_more_f.write_fmt(format_args!("error opening file or directory: {0}",
_0))
}
}
}
}Display, #[automatically_derived]
impl ::core::clone::Clone for OpenError {
#[inline]
fn clone(&self) -> OpenError {
match self {
OpenError::Access(__self_0) =>
OpenError::Access(::core::clone::Clone::clone(__self_0)),
OpenError::Interrupt(__self_0) =>
OpenError::Interrupt(::core::clone::Clone::clone(__self_0)),
OpenError::StorageExhausted(__self_0) =>
OpenError::StorageExhausted(::core::clone::Clone::clone(__self_0)),
OpenError::OversizedFile(__self_0) =>
OpenError::OversizedFile(::core::clone::Clone::clone(__self_0)),
OpenError::IncorrectType(__self_0) =>
OpenError::IncorrectType(::core::clone::Clone::clone(__self_0)),
OpenError::InvalidBasename(__self_0) =>
OpenError::InvalidBasename(::core::clone::Clone::clone(__self_0)),
OpenError::ExcessiveLinks(__self_0) =>
OpenError::ExcessiveLinks(::core::clone::Clone::clone(__self_0)),
OpenError::FileCount(__self_0) =>
OpenError::FileCount(::core::clone::Clone::clone(__self_0)),
OpenError::PathLength(__self_0) =>
OpenError::PathLength(::core::clone::Clone::clone(__self_0)),
OpenError::MetadataOverflow(__self_0) =>
OpenError::MetadataOverflow(::core::clone::Clone::clone(__self_0)),
OpenError::MissingComponent(__self_0) =>
OpenError::MissingComponent(::core::clone::Clone::clone(__self_0)),
OpenError::OOM(__self_0) =>
OpenError::OOM(::core::clone::Clone::clone(__self_0)),
OpenError::NonDirComponent(__self_0) =>
OpenError::NonDirComponent(::core::clone::Clone::clone(__self_0)),
OpenError::Permission(__self_0) =>
OpenError::Permission(::core::clone::Clone::clone(__self_0)),
OpenError::ReadOnlyFS(__self_0) =>
OpenError::ReadOnlyFS(::core::clone::Clone::clone(__self_0)),
OpenError::BusyExecutable(__self_0) =>
OpenError::BusyExecutable(::core::clone::Clone::clone(__self_0)),
}
}
}Clone, #[allow(deprecated)]
#[allow(unreachable_code)]
#[automatically_derived]
impl derive_more::core::convert::From<(BusyExecutableError)> for OpenError {
#[inline]
fn from(value: (BusyExecutableError)) -> Self {
OpenError::BusyExecutable(value)
}
}From, #[automatically_derived]
impl derive_more::core::error::Error for OpenError {
fn source(&self)
-> Option<&(dyn derive_more::core::error::Error + 'static)> {
use derive_more::__private::AsDynError as _;
match self {
OpenError::Access(source) =>
Some(source.__derive_more_as_dyn_error()),
OpenError::Interrupt(source) =>
Some(source.__derive_more_as_dyn_error()),
OpenError::StorageExhausted(source) =>
Some(source.__derive_more_as_dyn_error()),
OpenError::OversizedFile(source) =>
Some(source.__derive_more_as_dyn_error()),
OpenError::IncorrectType(source) =>
Some(source.__derive_more_as_dyn_error()),
OpenError::InvalidBasename(source) =>
Some(source.__derive_more_as_dyn_error()),
OpenError::ExcessiveLinks(source) =>
Some(source.__derive_more_as_dyn_error()),
OpenError::FileCount(source) =>
Some(source.__derive_more_as_dyn_error()),
OpenError::PathLength(source) =>
Some(source.__derive_more_as_dyn_error()),
OpenError::MetadataOverflow(source) =>
Some(source.__derive_more_as_dyn_error()),
OpenError::MissingComponent(source) =>
Some(source.__derive_more_as_dyn_error()),
OpenError::OOM(source) =>
Some(source.__derive_more_as_dyn_error()),
OpenError::NonDirComponent(source) =>
Some(source.__derive_more_as_dyn_error()),
OpenError::Permission(source) =>
Some(source.__derive_more_as_dyn_error()),
OpenError::ReadOnlyFS(source) =>
Some(source.__derive_more_as_dyn_error()),
OpenError::BusyExecutable(source) =>
Some(source.__derive_more_as_dyn_error()),
}
}
}Error)]
74#[display("error opening file or directory: {_0}")]
75pub enum OpenError {
76 Access(AccessError),
77 Interrupt(InterruptError),
78 StorageExhausted(StorageExhaustedError),
79 OversizedFile(OversizedFileError),
80 IncorrectType(IncorrectTypeError),
81 InvalidBasename(InvalidBasenameError),
82 ExcessiveLinks(ExcessiveLinksError),
83 FileCount(FileCountError),
84 PathLength(PathLengthError),
85 MetadataOverflow(MetadataOverflowError),
86 MissingComponent(MissingComponentError),
87 OOM(OOMError),
88 NonDirComponent(NonDirComponentError),
89 Permission(PermissionError),
90 ReadOnlyFS(ReadOnlyFSError),
91 BusyExecutable(BusyExecutableError),
92}
93
94impl OpenError {
95 pub(crate) fn interpret_raw_error(error: RawOsError) -> Self {
96 match error {
97 EACCES => AccessError.into(),
98 EBADF => BadFdPanic.panic(),
99 EBUSY | EISDIR | ENODEV | ENXIO => IncorrectTypeError.into(),
100 EDQUOT | ENOSPC => StorageExhaustedError.into(),
101 EFAULT => BadStackAddrPanic.panic(),
102 EFBIG | EOVERFLOW => OversizedFileError.into(),
103 EINTR => InterruptError.into(),
104 EINVAL => InvalidBasenameError.into(),
105 ELOOP => ExcessiveLinksError.into(),
106 EMFILE | ENFILE => FileCountError.into(),
107 ENAMETOOLONG => PathLengthError.into(),
108 ENOENT => MissingComponentError.into(),
109 ENOMEM => OOMError.into(),
110 ENOTDIR => NonDirComponentError.into(),
111 EPERM => PermissionError.into(),
112 EROFS => ReadOnlyFSError.into(),
113 ETXTBSY => BusyExecutableError.into(),
114 e => UnexpectedErrorPanic(e).panic(),
115 }
116 }
117}
118
119impl From<FileTypeError> for OpenError {
120 fn from(value: FileTypeError) -> Self {
121 match value {
122 FileTypeError::OOM(e) => e.into(),
123 FileTypeError::IncorrectType(e) => e.into(),
124 FileTypeError::MetadataOverflow(e) => e.into(),
125 }
126 }
127}
128
129#[derive(#[automatically_derived]
impl ::core::fmt::Debug for CreateError {
#[inline]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match self {
CreateError::Access(__self_0) =>
::core::fmt::Formatter::debug_tuple_field1_finish(f, "Access",
&__self_0),
CreateError::Interrupt(__self_0) =>
::core::fmt::Formatter::debug_tuple_field1_finish(f,
"Interrupt", &__self_0),
CreateError::StorageExhausted(__self_0) =>
::core::fmt::Formatter::debug_tuple_field1_finish(f,
"StorageExhausted", &__self_0),
CreateError::InvalidBasename(__self_0) =>
::core::fmt::Formatter::debug_tuple_field1_finish(f,
"InvalidBasename", &__self_0),
CreateError::ExcessiveLinks(__self_0) =>
::core::fmt::Formatter::debug_tuple_field1_finish(f,
"ExcessiveLinks", &__self_0),
CreateError::FileCount(__self_0) =>
::core::fmt::Formatter::debug_tuple_field1_finish(f,
"FileCount", &__self_0),
CreateError::PathLength(__self_0) =>
::core::fmt::Formatter::debug_tuple_field1_finish(f,
"PathLength", &__self_0),
CreateError::MissingComponent(__self_0) =>
::core::fmt::Formatter::debug_tuple_field1_finish(f,
"MissingComponent", &__self_0),
CreateError::OOM(__self_0) =>
::core::fmt::Formatter::debug_tuple_field1_finish(f, "OOM",
&__self_0),
CreateError::NonDirComponent(__self_0) =>
::core::fmt::Formatter::debug_tuple_field1_finish(f,
"NonDirComponent", &__self_0),
CreateError::Permission(__self_0) =>
::core::fmt::Formatter::debug_tuple_field1_finish(f,
"Permission", &__self_0),
CreateError::ReadOnlyFS(__self_0) =>
::core::fmt::Formatter::debug_tuple_field1_finish(f,
"ReadOnlyFS", &__self_0),
CreateError::BusyExecutable(__self_0) =>
::core::fmt::Formatter::debug_tuple_field1_finish(f,
"BusyExecutable", &__self_0),
CreateError::AlreadyExists(__self_0) =>
::core::fmt::Formatter::debug_tuple_field1_finish(f,
"AlreadyExists", &__self_0),
}
}
}Debug, #[allow(deprecated)]
#[allow(unreachable_code)]
#[automatically_derived]
impl derive_more::core::fmt::Display for CreateError {
fn fmt(&self, __derive_more_f: &mut derive_more::core::fmt::Formatter<'_>)
-> derive_more::core::fmt::Result {
match self {
Self::Access(_0) => {
__derive_more_f.write_fmt(format_args!("error creating file: {0}",
_0))
}
Self::Interrupt(_0) => {
__derive_more_f.write_fmt(format_args!("error creating file: {0}",
_0))
}
Self::StorageExhausted(_0) => {
__derive_more_f.write_fmt(format_args!("error creating file: {0}",
_0))
}
Self::InvalidBasename(_0) => {
__derive_more_f.write_fmt(format_args!("error creating file: {0}",
_0))
}
Self::ExcessiveLinks(_0) => {
__derive_more_f.write_fmt(format_args!("error creating file: {0}",
_0))
}
Self::FileCount(_0) => {
__derive_more_f.write_fmt(format_args!("error creating file: {0}",
_0))
}
Self::PathLength(_0) => {
__derive_more_f.write_fmt(format_args!("error creating file: {0}",
_0))
}
Self::MissingComponent(_0) => {
__derive_more_f.write_fmt(format_args!("error creating file: {0}",
_0))
}
Self::OOM(_0) => {
__derive_more_f.write_fmt(format_args!("error creating file: {0}",
_0))
}
Self::NonDirComponent(_0) => {
__derive_more_f.write_fmt(format_args!("error creating file: {0}",
_0))
}
Self::Permission(_0) => {
__derive_more_f.write_fmt(format_args!("error creating file: {0}",
_0))
}
Self::ReadOnlyFS(_0) => {
__derive_more_f.write_fmt(format_args!("error creating file: {0}",
_0))
}
Self::BusyExecutable(_0) => {
__derive_more_f.write_fmt(format_args!("error creating file: {0}",
_0))
}
Self::AlreadyExists(_0) => {
__derive_more_f.write_fmt(format_args!("error creating file: {0}",
_0))
}
}
}
}Display, #[automatically_derived]
impl ::core::clone::Clone for CreateError {
#[inline]
fn clone(&self) -> CreateError {
match self {
CreateError::Access(__self_0) =>
CreateError::Access(::core::clone::Clone::clone(__self_0)),
CreateError::Interrupt(__self_0) =>
CreateError::Interrupt(::core::clone::Clone::clone(__self_0)),
CreateError::StorageExhausted(__self_0) =>
CreateError::StorageExhausted(::core::clone::Clone::clone(__self_0)),
CreateError::InvalidBasename(__self_0) =>
CreateError::InvalidBasename(::core::clone::Clone::clone(__self_0)),
CreateError::ExcessiveLinks(__self_0) =>
CreateError::ExcessiveLinks(::core::clone::Clone::clone(__self_0)),
CreateError::FileCount(__self_0) =>
CreateError::FileCount(::core::clone::Clone::clone(__self_0)),
CreateError::PathLength(__self_0) =>
CreateError::PathLength(::core::clone::Clone::clone(__self_0)),
CreateError::MissingComponent(__self_0) =>
CreateError::MissingComponent(::core::clone::Clone::clone(__self_0)),
CreateError::OOM(__self_0) =>
CreateError::OOM(::core::clone::Clone::clone(__self_0)),
CreateError::NonDirComponent(__self_0) =>
CreateError::NonDirComponent(::core::clone::Clone::clone(__self_0)),
CreateError::Permission(__self_0) =>
CreateError::Permission(::core::clone::Clone::clone(__self_0)),
CreateError::ReadOnlyFS(__self_0) =>
CreateError::ReadOnlyFS(::core::clone::Clone::clone(__self_0)),
CreateError::BusyExecutable(__self_0) =>
CreateError::BusyExecutable(::core::clone::Clone::clone(__self_0)),
CreateError::AlreadyExists(__self_0) =>
CreateError::AlreadyExists(::core::clone::Clone::clone(__self_0)),
}
}
}Clone, #[allow(deprecated)]
#[allow(unreachable_code)]
#[automatically_derived]
impl derive_more::core::convert::From<(AlreadyExistsError)> for CreateError {
#[inline]
fn from(value: (AlreadyExistsError)) -> Self {
CreateError::AlreadyExists(value)
}
}From, #[automatically_derived]
impl derive_more::core::error::Error for CreateError {
fn source(&self)
-> Option<&(dyn derive_more::core::error::Error + 'static)> {
use derive_more::__private::AsDynError as _;
match self {
CreateError::Access(source) =>
Some(source.__derive_more_as_dyn_error()),
CreateError::Interrupt(source) =>
Some(source.__derive_more_as_dyn_error()),
CreateError::StorageExhausted(source) =>
Some(source.__derive_more_as_dyn_error()),
CreateError::InvalidBasename(source) =>
Some(source.__derive_more_as_dyn_error()),
CreateError::ExcessiveLinks(source) =>
Some(source.__derive_more_as_dyn_error()),
CreateError::FileCount(source) =>
Some(source.__derive_more_as_dyn_error()),
CreateError::PathLength(source) =>
Some(source.__derive_more_as_dyn_error()),
CreateError::MissingComponent(source) =>
Some(source.__derive_more_as_dyn_error()),
CreateError::OOM(source) =>
Some(source.__derive_more_as_dyn_error()),
CreateError::NonDirComponent(source) =>
Some(source.__derive_more_as_dyn_error()),
CreateError::Permission(source) =>
Some(source.__derive_more_as_dyn_error()),
CreateError::ReadOnlyFS(source) =>
Some(source.__derive_more_as_dyn_error()),
CreateError::BusyExecutable(source) =>
Some(source.__derive_more_as_dyn_error()),
CreateError::AlreadyExists(source) =>
Some(source.__derive_more_as_dyn_error()),
}
}
}Error)]
130#[display("error creating file: {_0}")]
131pub enum CreateError {
132 Access(AccessError),
133 Interrupt(InterruptError),
134 StorageExhausted(StorageExhaustedError),
135 InvalidBasename(InvalidBasenameError),
136 ExcessiveLinks(ExcessiveLinksError),
137 FileCount(FileCountError),
138 PathLength(PathLengthError),
139 MissingComponent(MissingComponentError),
140 OOM(OOMError),
141 NonDirComponent(NonDirComponentError),
142 Permission(PermissionError),
143 ReadOnlyFS(ReadOnlyFSError),
144 BusyExecutable(BusyExecutableError),
145 AlreadyExists(AlreadyExistsError),
146}
147
148impl CreateError {
149 pub(crate) fn interpret_raw_error(error: RawOsError) -> Self {
150 match error {
151 EACCES => AccessError.into(),
152 EBADF => BadFdPanic.panic(),
153 EBUSY | EEXIST | EFBIG | EISDIR | ENODEV | ENXIO | EOVERFLOW => AlreadyExistsError.into(),
154 EDQUOT | ENOSPC => StorageExhaustedError.into(),
155 EFAULT => BadStackAddrPanic.panic(),
156 EINTR => InterruptError.into(),
157 EINVAL => InvalidBasenameError.into(),
158 ELOOP => ExcessiveLinksError.into(),
159 EMFILE | ENFILE => FileCountError.into(),
160 ENAMETOOLONG => PathLengthError.into(),
161 ENOENT => MissingComponentError.into(),
162 ENOMEM => OOMError.into(),
163 ENOTDIR => NonDirComponentError.into(),
164 EPERM => PermissionError.into(),
165 EROFS => ReadOnlyFSError.into(),
166 ETXTBSY => BusyExecutableError.into(),
167 e => UnexpectedErrorPanic(e).panic(),
168 }
169 }
170}
171
172#[derive(#[automatically_derived]
impl ::core::fmt::Debug for TempError {
#[inline]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match self {
TempError::Access(__self_0) =>
::core::fmt::Formatter::debug_tuple_field1_finish(f, "Access",
&__self_0),
TempError::Interrupt(__self_0) =>
::core::fmt::Formatter::debug_tuple_field1_finish(f,
"Interrupt", &__self_0),
TempError::StorageExhausted(__self_0) =>
::core::fmt::Formatter::debug_tuple_field1_finish(f,
"StorageExhausted", &__self_0),
TempError::OversizedFile(__self_0) =>
::core::fmt::Formatter::debug_tuple_field1_finish(f,
"OversizedFile", &__self_0),
TempError::InvalidBasename(__self_0) =>
::core::fmt::Formatter::debug_tuple_field1_finish(f,
"InvalidBasename", &__self_0),
TempError::ExcessiveLinks(__self_0) =>
::core::fmt::Formatter::debug_tuple_field1_finish(f,
"ExcessiveLinks", &__self_0),
TempError::FileCount(__self_0) =>
::core::fmt::Formatter::debug_tuple_field1_finish(f,
"FileCount", &__self_0),
TempError::PathLength(__self_0) =>
::core::fmt::Formatter::debug_tuple_field1_finish(f,
"PathLength", &__self_0),
TempError::MissingComponent(__self_0) =>
::core::fmt::Formatter::debug_tuple_field1_finish(f,
"MissingComponent", &__self_0),
TempError::OOM(__self_0) =>
::core::fmt::Formatter::debug_tuple_field1_finish(f, "OOM",
&__self_0),
TempError::NonDirComponent(__self_0) =>
::core::fmt::Formatter::debug_tuple_field1_finish(f,
"NonDirComponent", &__self_0),
TempError::Permission(__self_0) =>
::core::fmt::Formatter::debug_tuple_field1_finish(f,
"Permission", &__self_0),
TempError::ReadOnlyFS(__self_0) =>
::core::fmt::Formatter::debug_tuple_field1_finish(f,
"ReadOnlyFS", &__self_0),
TempError::BusyExecutable(__self_0) =>
::core::fmt::Formatter::debug_tuple_field1_finish(f,
"BusyExecutable", &__self_0),
TempError::TempFileUnsupported(__self_0) =>
::core::fmt::Formatter::debug_tuple_field1_finish(f,
"TempFileUnsupported", &__self_0),
}
}
}Debug, #[allow(deprecated)]
#[allow(unreachable_code)]
#[automatically_derived]
impl derive_more::core::fmt::Display for TempError {
fn fmt(&self, __derive_more_f: &mut derive_more::core::fmt::Formatter<'_>)
-> derive_more::core::fmt::Result {
match self {
Self::Access(_0) => {
__derive_more_f.write_fmt(format_args!("error creating temporary file: {0}",
_0))
}
Self::Interrupt(_0) => {
__derive_more_f.write_fmt(format_args!("error creating temporary file: {0}",
_0))
}
Self::StorageExhausted(_0) => {
__derive_more_f.write_fmt(format_args!("error creating temporary file: {0}",
_0))
}
Self::OversizedFile(_0) => {
__derive_more_f.write_fmt(format_args!("error creating temporary file: {0}",
_0))
}
Self::InvalidBasename(_0) => {
__derive_more_f.write_fmt(format_args!("error creating temporary file: {0}",
_0))
}
Self::ExcessiveLinks(_0) => {
__derive_more_f.write_fmt(format_args!("error creating temporary file: {0}",
_0))
}
Self::FileCount(_0) => {
__derive_more_f.write_fmt(format_args!("error creating temporary file: {0}",
_0))
}
Self::PathLength(_0) => {
__derive_more_f.write_fmt(format_args!("error creating temporary file: {0}",
_0))
}
Self::MissingComponent(_0) => {
__derive_more_f.write_fmt(format_args!("error creating temporary file: {0}",
_0))
}
Self::OOM(_0) => {
__derive_more_f.write_fmt(format_args!("error creating temporary file: {0}",
_0))
}
Self::NonDirComponent(_0) => {
__derive_more_f.write_fmt(format_args!("error creating temporary file: {0}",
_0))
}
Self::Permission(_0) => {
__derive_more_f.write_fmt(format_args!("error creating temporary file: {0}",
_0))
}
Self::ReadOnlyFS(_0) => {
__derive_more_f.write_fmt(format_args!("error creating temporary file: {0}",
_0))
}
Self::BusyExecutable(_0) => {
__derive_more_f.write_fmt(format_args!("error creating temporary file: {0}",
_0))
}
Self::TempFileUnsupported(_0) => {
__derive_more_f.write_fmt(format_args!("error creating temporary file: {0}",
_0))
}
}
}
}Display, #[automatically_derived]
impl ::core::clone::Clone for TempError {
#[inline]
fn clone(&self) -> TempError {
match self {
TempError::Access(__self_0) =>
TempError::Access(::core::clone::Clone::clone(__self_0)),
TempError::Interrupt(__self_0) =>
TempError::Interrupt(::core::clone::Clone::clone(__self_0)),
TempError::StorageExhausted(__self_0) =>
TempError::StorageExhausted(::core::clone::Clone::clone(__self_0)),
TempError::OversizedFile(__self_0) =>
TempError::OversizedFile(::core::clone::Clone::clone(__self_0)),
TempError::InvalidBasename(__self_0) =>
TempError::InvalidBasename(::core::clone::Clone::clone(__self_0)),
TempError::ExcessiveLinks(__self_0) =>
TempError::ExcessiveLinks(::core::clone::Clone::clone(__self_0)),
TempError::FileCount(__self_0) =>
TempError::FileCount(::core::clone::Clone::clone(__self_0)),
TempError::PathLength(__self_0) =>
TempError::PathLength(::core::clone::Clone::clone(__self_0)),
TempError::MissingComponent(__self_0) =>
TempError::MissingComponent(::core::clone::Clone::clone(__self_0)),
TempError::OOM(__self_0) =>
TempError::OOM(::core::clone::Clone::clone(__self_0)),
TempError::NonDirComponent(__self_0) =>
TempError::NonDirComponent(::core::clone::Clone::clone(__self_0)),
TempError::Permission(__self_0) =>
TempError::Permission(::core::clone::Clone::clone(__self_0)),
TempError::ReadOnlyFS(__self_0) =>
TempError::ReadOnlyFS(::core::clone::Clone::clone(__self_0)),
TempError::BusyExecutable(__self_0) =>
TempError::BusyExecutable(::core::clone::Clone::clone(__self_0)),
TempError::TempFileUnsupported(__self_0) =>
TempError::TempFileUnsupported(::core::clone::Clone::clone(__self_0)),
}
}
}Clone, #[allow(deprecated)]
#[allow(unreachable_code)]
#[automatically_derived]
impl derive_more::core::convert::From<(TempFileUnsupportedError)> for
TempError {
#[inline]
fn from(value: (TempFileUnsupportedError)) -> Self {
TempError::TempFileUnsupported(value)
}
}From, #[automatically_derived]
impl derive_more::core::error::Error for TempError {
fn source(&self)
-> Option<&(dyn derive_more::core::error::Error + 'static)> {
use derive_more::__private::AsDynError as _;
match self {
TempError::Access(source) =>
Some(source.__derive_more_as_dyn_error()),
TempError::Interrupt(source) =>
Some(source.__derive_more_as_dyn_error()),
TempError::StorageExhausted(source) =>
Some(source.__derive_more_as_dyn_error()),
TempError::OversizedFile(source) =>
Some(source.__derive_more_as_dyn_error()),
TempError::InvalidBasename(source) =>
Some(source.__derive_more_as_dyn_error()),
TempError::ExcessiveLinks(source) =>
Some(source.__derive_more_as_dyn_error()),
TempError::FileCount(source) =>
Some(source.__derive_more_as_dyn_error()),
TempError::PathLength(source) =>
Some(source.__derive_more_as_dyn_error()),
TempError::MissingComponent(source) =>
Some(source.__derive_more_as_dyn_error()),
TempError::OOM(source) =>
Some(source.__derive_more_as_dyn_error()),
TempError::NonDirComponent(source) =>
Some(source.__derive_more_as_dyn_error()),
TempError::Permission(source) =>
Some(source.__derive_more_as_dyn_error()),
TempError::ReadOnlyFS(source) =>
Some(source.__derive_more_as_dyn_error()),
TempError::BusyExecutable(source) =>
Some(source.__derive_more_as_dyn_error()),
TempError::TempFileUnsupported(source) =>
Some(source.__derive_more_as_dyn_error()),
}
}
}Error)]
173#[display("error creating temporary file: {_0}")]
174pub enum TempError {
175 Access(AccessError),
176 Interrupt(InterruptError),
177 StorageExhausted(StorageExhaustedError),
178 OversizedFile(OversizedFileError),
179 InvalidBasename(InvalidBasenameError),
180 ExcessiveLinks(ExcessiveLinksError),
181 FileCount(FileCountError),
182 PathLength(PathLengthError),
183 MissingComponent(MissingComponentError),
184 OOM(OOMError),
185 NonDirComponent(NonDirComponentError),
186 Permission(PermissionError),
187 ReadOnlyFS(ReadOnlyFSError),
188 BusyExecutable(BusyExecutableError),
189 TempFileUnsupported(TempFileUnsupportedError),
190}
191
192impl TempError {
193 pub(crate) fn interpret_raw_error(error: RawOsError) -> Self {
194 match error {
195 EACCES => AccessError.into(),
196 EBADF => BadFdPanic.panic(),
197 EBUSY | EFBIG | ENODEV | ENXIO | EISDIR | EOPNOTSUPP | EOVERFLOW => TempFileUnsupportedError.into(),
198 EDQUOT | ENOSPC => StorageExhaustedError.into(),
199 EFAULT => BadStackAddrPanic.panic(),
200 EINTR => InterruptError.into(),
201 EINVAL => InvalidFlagPanic.panic(),
202 ELOOP => ExcessiveLinksError.into(),
203 EMFILE | ENFILE => FileCountError.into(),
204 ENAMETOOLONG => PathLengthError.into(),
205 ENOENT => MissingComponentError.into(),
206 ENOMEM => OOMError.into(),
207 ENOTDIR => NonDirComponentError.into(),
208 EPERM => PermissionError.into(),
209 EROFS => ReadOnlyFSError.into(),
210 ETXTBSY => BusyExecutableError.into(),
211 e => UnexpectedErrorPanic(e).panic(),
212 }
213 }
214}