diff options
Diffstat (limited to 'vendor/fs_extra/src/error.rs')
-rw-r--r-- | vendor/fs_extra/src/error.rs | 158 |
1 files changed, 158 insertions, 0 deletions
diff --git a/vendor/fs_extra/src/error.rs b/vendor/fs_extra/src/error.rs new file mode 100644 index 000000000..f26613e90 --- /dev/null +++ b/vendor/fs_extra/src/error.rs @@ -0,0 +1,158 @@ +use std::error::Error as StdError; +use std::ffi::OsString; +use std::fmt; +use std::io::Error as IoError; +use std::io::ErrorKind as IoErrorKind; +use std::path::StripPrefixError; + +/// A list specifying general categories of fs_extra error. +#[derive(Debug)] +pub enum ErrorKind { + /// An entity was not found. + NotFound, + /// The operation lacked the necessary privileges to complete. + PermissionDenied, + /// An entity already exists. + AlreadyExists, + /// This operation was interrupted. + Interrupted, + /// Path does not a directory. + InvalidFolder, + /// Path does not a file. + InvalidFile, + /// Invalid file name. + InvalidFileName, + /// Invalid path. + InvalidPath, + /// Any I/O error. + Io(IoError), + /// Any StripPrefix error. + StripPrefix(StripPrefixError), + /// Any OsString error. + OsString(OsString), + /// Any fs_extra error not part of this list. + Other, +} + +impl ErrorKind { + fn as_str(&self) -> &str { + match *self { + ErrorKind::NotFound => "entity not found", + ErrorKind::PermissionDenied => "permission denied", + ErrorKind::AlreadyExists => "entity already exists", + ErrorKind::Interrupted => "operation interrupted", + ErrorKind::Other => "other os error", + ErrorKind::InvalidFolder => "invalid folder error", + ErrorKind::InvalidFile => "invalid file error", + ErrorKind::InvalidFileName => "invalid file name error", + ErrorKind::InvalidPath => "invalid path error", + ErrorKind::Io(_) => "Io error", + ErrorKind::StripPrefix(_) => "Strip prefix error", + ErrorKind::OsString(_) => "OsString error", + } + } +} + +/// A specialized Result type for fs_extra operations. +/// +/// This typedef is generally used to avoid writing out fs_extra::Error directly +/// and is otherwise a direct mapping to Result. +/// +///#Examples +/// +/// ```rust,ignore +/// extern crate fs_extra; +/// use fs_extra::dir::create; +/// +///fn get_string() -> io::Result<()> { +/// +/// create("test_dir")?; +/// +/// Ok(()) +/// } +/// ``` +pub type Result<T> = ::std::result::Result<T, Error>; + +/// The error type for fs_extra operations with files and folder. +/// +/// Errors mostly originate from the underlying OS, but custom instances of +/// `Error` can be created with crafted error messages and a particular value of +/// [`ErrorKind`]. +/// +/// [`ErrorKind`]: enum.ErrorKind.html +#[derive(Debug)] +pub struct Error { + /// Type error + pub kind: ErrorKind, + message: String, +} + +impl Error { + /// Create a new fs_extra error from a kind of error error as well as an arbitrary error payload. + /// + ///#Examples + /// ```rust,ignore + /// + /// extern crate fs_extra; + /// use fs_extra::error::{Error, ErrorKind}; + /// + /// errors can be created from strings + /// let custom_error = Error::new(ErrorKind::Other, "Other Error!"); + /// // errors can also be created from other errors + /// let custom_error2 = Error::new(ErrorKind::Interrupted, custom_error); + /// + /// ``` + pub fn new(kind: ErrorKind, message: &str) -> Error { + Error { + kind, + message: message.to_string(), + } + } +} + +impl fmt::Display for Error { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!(f, "{}", self.message) + } +} + +impl StdError for Error { + fn description(&self) -> &str { + self.kind.as_str() + } +} +impl From<StripPrefixError> for Error { + fn from(err: StripPrefixError) -> Error { + Error::new( + ErrorKind::StripPrefix(err), + "StripPrefixError. Look inside for more details", + ) + } +} + +impl From<OsString> for Error { + fn from(err: OsString) -> Error { + Error::new( + ErrorKind::OsString(err), + "OsString. Look inside for more details", + ) + } +} + +impl From<IoError> for Error { + fn from(err: IoError) -> Error { + let err_kind: ErrorKind; + match err.kind() { + IoErrorKind::NotFound => err_kind = ErrorKind::NotFound, + IoErrorKind::PermissionDenied => err_kind = ErrorKind::PermissionDenied, + IoErrorKind::AlreadyExists => err_kind = ErrorKind::AlreadyExists, + IoErrorKind::Interrupted => err_kind = ErrorKind::Interrupted, + IoErrorKind::Other => err_kind = ErrorKind::Other, + _ => { + err_kind = ErrorKind::Io(err); + return Error::new(err_kind, "Io error. Look inside err_kind for more details."); + } + } + Error::new(err_kind, &err.to_string()) + } +} |