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

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.

Returns the path at which a cycle was detected.

If no cycle was detected, None is returned.

A cycle is detected when a directory entry is equivalent to one of its ancestors.

To get the path to the child directory entry in the cycle, use the path method.

Returns the depth at which this error occurred relative to the root.

The smallest depth is 0 and always corresponds to the path given to the new function on WalkDir. Its direct descendents have depth 1, and their descendents have depth 2, and so on.

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 as impl 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)
                    }
                }
            }
        }
    }
}

Similar to io_error except consumes self to convert to the original io::Error if one exists.

Trait Implementations

Formats the value using the given formatter. Read more

Formats the value using the given formatter. Read more

👎 Deprecated since 1.42.0:

use the Display impl or to_string()

👎 Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

The lower-level source of this error, if any. Read more

🔬 This is a nightly-only experimental API. (backtrace)

Returns a stack backtrace, if available, of where this error occurred. Read more

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

Blanket Implementations

Gets the TypeId of self. Read more

Immutably borrows from an owned value. Read more

Mutably borrows from an owned value. Read more

Returns the argument unchanged.

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Converts the given value to a String. Read more

The type returned in the event of a conversion error.

Performs the conversion.

The type returned in the event of a conversion error.

Performs the conversion.