Struct WalkPlan

pub struct WalkPlan {
    pub check_list: Vec<PathBuf>,
    pub follow_symlinks: bool,
    pub depth_first: bool,
    pub capacity: usize,
    pub threads: usize,
    pub reject_when: fn(&WalkItem) -> bool,
    pub ignore_when: fn(&WalkItem) -> bool,
    pub finish_when: fn(&WalkItem) -> bool,
}

Start a directory walk plan

Fields

check_list: Vec<PathBuf>

Initial paths to search

follow_symlinks: bool

Follow symlinks

depth_first: bool

Depth first search or breadth first search

capacity: usize

Max number of items in the buffer

threads: usize

Number of threads to use

reject_when: fn(&WalkItem) -> bool

Check if a directory should be rejected

ignore_when: fn(&WalkItem) -> bool

Ignore a file if it matches the condition

finish_when: fn(&WalkItem) -> bool

Stop if a item matches the condition

Implementations

impl WalkPlan

pub fn ancestors(&self) -> AncestorWalker<'_>

impl WalkPlan

pub fn new<P: AsRef<Path>>(path: P) -> Self

Create a new plan with initial path

pub fn roots<I>(roots: I) -> Self

where I: IntoIterator, I::Item: AsRef<Path>,

Create a new plan with initial paths

pub fn breadth_first_search(self) -> Self

Search all subdirectories with breadth first

pub fn depth_first_search(self) -> Self

Search all subdirectories with depth first

pub fn with_threads(self, threads: usize) -> Self

Search with threads

pub fn reject_if(self, f: fn(&WalkItem) -> bool) -> Self

Reject directories if it matches the condition

Examples

• ignore hidden directories

let plan = WalkPlan::new(".").reject_if(|item| item.path.starts_with("."));

pub fn ignore_if(self, f: fn(&WalkItem) -> bool) -> Self

Ignore files if it’s name matches the condition

Notice that it does not ignore directories whose name matches the condition

Examples

• ignore non-ascii files

let plan = WalkPlan::new(".").ignore_if(|path| !path.is_ascii());

pub fn finish_if(self, f: fn(&WalkItem) -> bool) -> Self

Trait Implementations

impl Clone for WalkPlan

fn clone(&self) -> WalkPlan

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Default for WalkPlan

fn default() -> Self

Returns the “default value” for a type.

impl<'i> IntoIterator for &'i WalkPlan

type Item = Result<WalkItem, WalkError>

The type of the elements being iterated over.

type IntoIter = LinearWalker<'i>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.