Struct `WalkParallel`

struct WalkParallel { ... }

WalkParallel is a parallel recursive directory iterator over files paths in one or more directories.

Only file and directory paths matching the rules are returned. By default, ignore files like .gitignore are respected. The precise matching rules and precedence is explained in the documentation for WalkBuilder.

Unlike Walk, this uses multiple threads for traversing a directory.

Implementations

`impl WalkParallel`

fn run<'s, F>(self: Self, mkf: F) where F: FnMut() -> Box<dyn FnMut(Result<DirEntry, Error>) -> WalkState + Send + 's>

Execute the parallel recursive directory iterator. mkf is called for each thread used for iteration. The function produced by mkf is then in turn called for each visited file path.

fn visit(self: Self, builder: &mut dyn ParallelVisitorBuilder<'_>)

Execute the parallel recursive directory iterator using a custom visitor.

The builder given is used to construct a visitor for every thread used by this traversal. The visitor returned from each builder is then called for every directory entry seen by that thread.

Typically, creating a custom visitor is useful if you need to perform some kind of cleanup once traversal is finished. This can be achieved by implementing Drop for your builder (or for your visitor, if you want to execute cleanup for every thread that is launched).

For example, each visitor might build up a data structure of results corresponding to the directory entries seen for each thread. Since each visitor runs on only one thread, this build-up can be done without synchronization. Then, once traversal is complete, all of the results can be merged together into a single data structure.

`impl Freeze for WalkParallel`

`impl RefUnwindSafe for WalkParallel`

`impl Send for WalkParallel`

`impl Sync for WalkParallel`

`impl Unpin for WalkParallel`

`impl UnsafeUnpin for WalkParallel`

`impl UnwindSafe for WalkParallel`

`impl<T> Any for WalkParallel`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for WalkParallel`

fn borrow(self: &Self) -> &T

`impl<T> BorrowMut for WalkParallel`

fn borrow_mut(self: &mut Self) -> &mut T

`impl<T> From for WalkParallel`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T> Pointable for WalkParallel`

unsafe fn init(init: <T as Pointable>::Init) -> usize
unsafe fn deref<'a>(ptr: usize) -> &'a T
unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T
unsafe fn drop(ptr: usize)

`impl<T, U> Into for WalkParallel`

fn into(self: Self) -> U

Calls U::from(self).

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

`impl<T, U> TryFrom for WalkParallel`

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

`impl<T, U> TryInto for WalkParallel`

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>