Enum Filter 

pub enum Filter<'a> {
    AllPaths,
    All(&'a [Filter<'a>]),
    Any(&'a [Filter<'a>]),
    IgnoredDirNames {
        names: &'a [&'a str],
        case: Case,
    },
    IgnoredFileExts {
        exts: &'a [&'a str],
        case: Case,
        files_without_extension: bool,
    },
    IgnoredFileNames {
        names: &'a [&'a str],
        case: Case,
    },
    NonSymlinkFiles,
    SameDevice {
        device_id: u64,
    },
    SomeDirNames {
        names: &'a [&'a str],
        case: Case,
    },
    SomeFileExts {
        exts: &'a [&'a str],
        case: Case,
        files_without_extension: bool,
    },
    SomeFileNames {
        names: &'a [&'a str],
        case: Case,
    },
    SymlinkFiles,
    UserDefined {
        accept: fn(&Path) -> Box<dyn Future<Output = bool> + Unpin>,
    },
}

Filter

Notes

• File extensions do not contain leading dot ..

Variants

AllPaths

A filter that accepts all paths

All(&'a [Filter<'a>])

A filter that combines all filters you provide, using logical conjunction

Notes

• If you provide an empty list, this filter rejects all paths.
• Files are only accepted if all filters accept them.

Any(&'a [Filter<'a>])

A filter that combines all filters you provide, using logical disjunction

Notes

• If you provide an empty list, this filter rejects all paths.
• Files are accepted if any of the filters accepts them.

IgnoredDirNames

A filter that ignores directories by names you provide

Notes

Providing an empty list means no names are ignored. So all directories will be accepted.

Fields

names: &'a [&'a str]

Directory names

case: Case

Case

IgnoredFileExts

A filter that ignores files by extensions you provide

Notes

If you provide an empty list, that means no extensions are ignored, so all files having extension will be accepted.

Fields

exts: &'a [&'a str]

File extensions

case: Case

Case

files_without_extension: bool

Flag for files which have no extension

IgnoredFileNames

A filter that ignores files by names you provide

Notes

Providing an empty list means no names are ignored. So all files will be accepted.

Fields

names: &'a [&'a str]

File names

case: Case

Case

NonSymlinkFiles

A filter that rejects symbolic link files

SameDevice

Available on Unix only.

Same Device filter

A filter which only accepts files on a same device of a file you provide.

Fields

device_id: u64

Device ID

SomeDirNames

A filter that only accepts directories by names you provide

Notes

Providing an empty list means you have no names to accept. So all directories will be ignored.

Fields

names: &'a [&'a str]

Names

case: Case

Case

SomeFileExts

A filter that only accepts files by extensions you provide

Notes

Providing an empty list means you have nothing to pick. So all files having extension will be ignored.

Fields

exts: &'a [&'a str]

File extensions

case: Case

Case

files_without_extension: bool

Flag for files which have no extension

SomeFileNames

A filter that only accepts files by names you provide

Notes

Providing an empty list means you have no names to accept. So all files will be ignored.

Fields

names: &'a [&'a str]

Names

case: Case

Case

SymlinkFiles

A filter that only accepts symbolic link files

UserDefined

User defined filter

accept() should return true to accept given path, false to ignore it

Notes

• Filters of files should always return true if input path is a directory.

• Filters of directories should always return true if input path is a file.

• Because of above rules, accept(...) == false is not always the opposite meaning that one might expect. For instance:

  • If SymlinkFiles ignores a file, that means the file is not a symbolic link file. However…
  • If it accepts that file, it does not mean that the file is a symbolic link file. Obviously, it might be a directory.

Fields

accept: fn(&Path) -> Box<dyn Future<Output = bool> + Unpin>

Available on crate feature async-std only.

User defined filter

Implementations

impl Filter<'_>

pub async fn make_same_device<P>(path: P) -> Result<Self>

where P: AsRef<Path>,

Available on crate feature async-std and Unix only.

Makes SameDevice from a path

Trait Implementations

impl<'a> Clone for Filter<'a>

fn clone(&self) -> Filter<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Filter<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> PartialEq for Filter<'a>

fn eq(&self, other: &Filter<'a>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> Eq for Filter<'a>

impl<'a> StructuralPartialEq for Filter<'a>