Struct walkdir::FilterEntry[][src]

pub struct FilterEntry<I, P> { /* fields omitted */ }

A recursive directory iterator that skips entries.

Values of this type are created by calling .filter_entry() on an IntoIter, which is formed by calling .into_iter() on a WalkDir.

Directories that fail the predicate P are skipped. Namely, they are never yielded and never descended into.

Entries that are skipped with the min_depth and max_depth options are not passed through this filter.

If opening a handle to a directory resulted in an error, then it is yielded and no corresponding call to the predicate is made.

Type parameter I refers to the underlying iterator and P refers to the predicate, which is usually FnMut(&DirEntry) -> bool.

Implementations

impl<P> FilterEntry<IntoIter, P> where
    P: FnMut(&DirEntry) -> bool
[src]

pub fn filter_entry(self, predicate: P) -> FilterEntry<Self, P>

Notable traits for FilterEntry<IntoIter, P>

impl<P> Iterator for FilterEntry<IntoIter, P> where
    P: FnMut(&DirEntry) -> bool
type Item = Result<DirEntry>;
[src]

Yields only entries which satisfy the given predicate and skips descending into directories that do not satisfy the given predicate.

The predicate is applied to all entries. If the predicate is true, iteration carries on as normal. If the predicate is false, the entry is ignored and if it is a directory, it is not descended into.

This is often more convenient to use than skip_current_dir. For example, to skip hidden files and directories efficiently on unix systems:

use walkdir::{DirEntry, WalkDir};

fn is_hidden(entry: &DirEntry) -> bool {
    entry.file_name()
         .to_str()
         .map(|s| s.starts_with("."))
         .unwrap_or(false)
}

for entry in WalkDir::new("foo")
                     .into_iter()
                     .filter_entry(|e| !is_hidden(e)) {
    println!("{}", entry?.path().display());
}

Note that the iterator will still yield errors for reading entries that may not satisfy the predicate.

Note that entries skipped with min_depth and max_depth are not passed to this predicate.

Note that if the iterator has contents_first enabled, then this method is no different than calling the standard Iterator::filter method (because directory entries are yielded after they’ve been descended into).

pub fn skip_current_dir(&mut self)[src]

Skips the current directory.

This causes the iterator to stop traversing the contents of the least recently yielded directory. This means any remaining entries in that directory will be skipped (including sub-directories).

Note that the ergonomics of this method are questionable since it borrows the iterator mutably. Namely, you must write out the looping condition manually. For example, to skip hidden entries efficiently on unix systems:

use walkdir::{DirEntry, WalkDir};

fn is_hidden(entry: &DirEntry) -> bool {
    entry.file_name()
         .to_str()
         .map(|s| s.starts_with("."))
         .unwrap_or(false)
}

let mut it = WalkDir::new("foo").into_iter();
loop {
    let entry = match it.next() {
        None => break,
        Some(Err(err)) => panic!("ERROR: {}", err),
        Some(Ok(entry)) => entry,
    };
    if is_hidden(&entry) {
        if entry.file_type().is_dir() {
            it.skip_current_dir();
        }
        continue;
    }
    println!("{}", entry.path().display());
}

You may find it more convenient to use the filter_entry iterator adapter. (See its documentation for the same example functionality as above.)

Trait Implementations

impl<I: Debug, P: Debug> Debug for FilterEntry<I, P>[src]

impl<P> Iterator for FilterEntry<IntoIter, P> where
    P: FnMut(&DirEntry) -> bool
[src]

type Item = Result<DirEntry>

The type of the elements being iterated over.

fn next(&mut self) -> Option<Result<DirEntry>>[src]

Advances the iterator and returns the next value.

Errors

If the iterator fails to retrieve the next value, this method returns an error value. The error will be wrapped in an Option::Some.

Auto Trait Implementations

impl<I, P> RefUnwindSafe for FilterEntry<I, P> where
    I: RefUnwindSafe,
    P: RefUnwindSafe

impl<I, P> Send for FilterEntry<I, P> where
    I: Send,
    P: Send

impl<I, P> Sync for FilterEntry<I, P> where
    I: Sync,
    P: Sync

impl<I, P> Unpin for FilterEntry<I, P> where
    I: Unpin,
    P: Unpin

impl<I, P> UnwindSafe for FilterEntry<I, P> where
    I: UnwindSafe,
    P: UnwindSafe

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<I> IntoIterator for I where
    I: Iterator
[src]

type Item = <I as Iterator>::Item

The type of the elements being iterated over.

type IntoIter = I

Which kind of iterator are we turning this into?

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.