pub struct Error { /* private fields */ }
Expand description
An error produced by recursively walking a directory.
This error type is a light wrapper around std::io::Error
. In
particular, it adds the following information:
- The depth at which the error occurred in the file tree, relative to the root.
- The path, if any, associated with the IO error.
- An indication that a loop occurred when following symbolic links. In this case, there is no underlying IO error.
To maintain good ergonomics, this type has a
impl From<Error> for std::io::Error
defined which preserves the original context.
This allows you to use an io::Result
with methods in this crate if you don’t care about
accessing the underlying error data in a structured form.
Implementations
sourceimpl Error
impl Error
sourcepub fn path(&self) -> Option<&Path>
pub fn path(&self) -> Option<&Path>
Returns the path associated with this error if one exists.
For example, if an error occurred while opening a directory handle,
the error will include the path passed to std::fs::read_dir
.
sourcepub fn loop_ancestor(&self) -> Option<&Path>
pub fn loop_ancestor(&self) -> Option<&Path>
sourcepub fn io_error(&self) -> Option<&Error>
pub fn io_error(&self) -> Option<&Error>
Inspect the original io::Error
if there is one.
None
is returned if the Error
doesn’t correspond to an
io::Error
. This might happen, for example, when the error was
produced because a cycle was found in the directory tree while
following symbolic links.
This method returns a borrowed value that is bound to the lifetime of the Error
. To
obtain an owned value, the into_io_error
can be used instead.
This is the original
io::Error
and is not the same asimpl From<Error> for std::io::Error
which contains additional context about the error.
Example
use std::io;
use std::path::Path;
use walkdir::WalkDir;
for entry in WalkDir::new("foo") {
match entry {
Ok(entry) => println!("{}", entry.path().display()),
Err(err) => {
let path = err.path().unwrap_or(Path::new("")).display();
println!("failed to access entry {}", path);
if let Some(inner) = err.io_error() {
match inner.kind() {
io::ErrorKind::InvalidData => {
println!(
"entry contains invalid data: {}",
inner)
}
io::ErrorKind::PermissionDenied => {
println!(
"Missing permission to read entry: {}",
inner)
}
_ => {
println!(
"Unexpected error occurred: {}",
inner)
}
}
}
}
}
}
Trait Implementations
sourceimpl Error for Error
impl Error for Error
sourcefn description(&self) -> &str
fn description(&self) -> &str
use the Display impl or to_string()
sourcefn cause(&self) -> Option<&dyn Error>
fn cause(&self) -> Option<&dyn Error>
replaced by Error::source, which can support downcasting
sourceimpl From<Error> for Error
impl From<Error> for Error
sourcefn from(walk_err: Error) -> Error
fn from(walk_err: Error) -> Error
Convert the Error
to an io::Error
, preserving the original
Error
as the “inner error”. Note that this also makes the display
of the error include the context.
This is different from into_io_error
which returns the original
io::Error
.
Auto Trait Implementations
impl RefUnwindSafe for Error
impl Send for Error
impl Sync for Error
impl Unpin for Error
impl UnwindSafe for Error
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more