Struct walkdir::IntoIter [−][src]
An iterator for recursively descending into a directory.
A value with this type must be constructed with the WalkDir
type, which
uses a builder pattern to set options such as min/max depth, max open file
descriptors and whether the iterator should follow symbolic links. After
constructing a WalkDir
, call .into_iter()
at the end of the chain.
The order of elements yielded by this iterator is unspecified.
Implementations
impl IntoIter
[src][−]
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.)
pub fn filter_entry<P>(self, predicate: P) -> FilterEntry<Self, P>ⓘ where
P: FnMut(&DirEntry) -> bool,
[src][−]
P: FnMut(&DirEntry) -> bool,
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).
Trait Implementations
Auto Trait Implementations
impl !RefUnwindSafe for IntoIter
impl Send for IntoIter
impl Sync for IntoIter
impl Unpin for IntoIter
impl !UnwindSafe for IntoIter
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src][+]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src][+]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src][+]
T: ?Sized,
impl<T> From<T> for T
[src][+]
impl<T, U> Into<U> for T where
U: From<T>,
[src][+]
U: From<T>,
impl<I> IntoIterator for I where
I: Iterator,
[src][+]
I: Iterator,
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src][+]
U: Into<T>,
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src][+]
U: TryFrom<T>,