Enum PredicateClause 

#[non_exhaustive]
pub enum PredicateClause {
    Name {
        pattern: NamePattern,
        case: CaseSensitivity,
        negated: bool,
    },
    NameInSet {
        patterns: Vec<NamePattern>,
        case: CaseSensitivity,
        negated: bool,
    },
    IsType {
        entry_type: EntryType,
        negated: bool,
    },
    IsReparsePoint {
        negated: bool,
    },
    ReparseTag {
        tag: u32,
        negated: bool,
    },
    AttributesAllSet(u32),
    AttributesAllClear(u32),
    LogicalSize {
        operator: ComparisonOperator,
        value: u64,
    },
    AllocationSize {
        operator: ComparisonOperator,
        value: u64,
    },
    Timestamp {
        field: TimestampField,
        operator: ComparisonOperator,
        value: WindowsFileTimestamp,
    },
}

One condition an entry must satisfy.

Clauses that can be sensibly inverted carry their own negated flag rather than relying on an enclosing Not, which keeps the query flat and keeps the negation adjacent to the thing it negates.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Name

The name matches a pattern.

Fields

pattern: NamePattern

The pattern to match the entry’s leaf name against.

case: CaseSensitivity

How the comparison treats case.

negated: bool

Invert the result.

NameInSet

The name matches any pattern in a non-empty set.

Fields

patterns: Vec<NamePattern>

The alternatives. Must not be empty.

case: CaseSensitivity

How the comparisons treat case.

negated: bool

Invert the result, giving set non-membership.

IsType

The entry is (or, negated, is not) the given kind.

Fields

entry_type: EntryType

The kind to test for.

negated: bool

Invert the result.

IsReparsePoint

The entry is (or, negated, is not) a reparse point.

Fields

negated: bool

Invert the result.

ReparseTag

The entry is a reparse point whose tag equals tag.

A non-reparse entry has no tag, so it never satisfies this clause – and, negated, always does.

Fields

tag: u32

The tag to compare against.

negated: bool

Invert the result.

AttributesAllSet(u32)

Every bit in the mask is set in the entry’s attributes.

The mask must be non-zero.

AttributesAllClear(u32)

Every bit in the mask is clear in the entry’s attributes.

The mask must be non-zero.

LogicalSize

The entry’s logical size compares to value bytes.

Fields

operator: ComparisonOperator

How to compare.

value: u64

The size in bytes to compare against.

AllocationSize

The entry’s allocation size compares to value bytes.

Fields

operator: ComparisonOperator

How to compare.

value: u64

The size in bytes to compare against.

Timestamp

One of the entry’s four times compares to value.

Fields

field: TimestampField

Which time to read.

operator: ComparisonOperator

How to compare.

value: WindowsFileTimestamp

The timestamp to compare against.

Implementations

impl PredicateClause

pub fn matches(&self, entry: &DirectoryEntry) -> bool

Whether entry satisfies this clause.

Trait Implementations

impl Clone for PredicateClause

fn clone(&self) -> PredicateClause

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PredicateClause

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

Formats the value using the given formatter.

impl Eq for PredicateClause

impl PartialEq for PredicateClause

fn eq(&self, other: &PredicateClause) -> bool

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for PredicateClause