Struct WalkParallel

pub struct WalkParallel { /* private fields */ }

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

pub fn run<F>(self, mkf: F)

where F: FnMut() -> Box<dyn FnMut(Result<DirEntry, Error>) -> WalkState + Send + 'static>,

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.

Examples found in repository

examples/walk.rs (lines 35-43)

fn main() {
    let mut path = env::args().nth(1).unwrap();
    let mut parallel = false;
    let mut simple = false;
    let (tx, rx) = channel::bounded::<DirEntry>(100);
    if path == "parallel" {
        path = env::args().nth(2).unwrap();
        parallel = true;
    } else if path == "walkdir" {
        path = env::args().nth(2).unwrap();
        simple = true;
    }

    let stdout_thread = thread::spawn(move || {
        let mut stdout = io::BufWriter::new(io::stdout());
        for dent in rx {
            write_path(&mut stdout, dent.path());
        }
    });

    if parallel {
        let walker = WalkBuilder::new(path).threads(6).build_parallel();
        walker.run(|| {
            let tx = tx.clone();
            Box::new(move |result| {
                use ignore::WalkState::*;

                tx.send(DirEntry::Y(result.unwrap())).unwrap();
                Continue
            })
        });
    } else if simple {
        let walker = WalkDir::new(path);
        for result in walker {
            tx.send(DirEntry::X(result.unwrap())).unwrap();
        }
    } else {
        let walker = WalkBuilder::new(path).build();
        for result in walker {
            tx.send(DirEntry::Y(result.unwrap())).unwrap();
        }
    }
    drop(tx);
    stdout_thread.join().unwrap();
}