Enum Exclusion 

pub enum Exclusion<'a> {
    Path(Cow<'a, Path>),
    Pattern(Cow<'a, str>),
}

A rule for excluding files or directories from filesystem scans.

This enum represents two types of exclusion rules that can be used when loading a database to filter out unwanted files. Exclusions are evaluated during the scan performed by DatabaseLoader.

Lifetime

The 'a lifetime parameter allows the exclusion to borrow paths and patterns from configuration or other long-lived data structures, avoiding unnecessary allocations during database construction.

Variants

Path Exclusion

Excludes an exact filesystem path, which can be either a file or directory. When a directory is excluded, all files and subdirectories within it are also excluded.

Paths can be absolute or relative to the workspace. Relative paths are canonicalized during loader construction.

Pattern Exclusion

Excludes paths matching a glob pattern. Glob patterns support wildcards and are matched against the full path of each discovered file.

Common pattern syntax:

• * matches any characters except path separators
• ** matches any characters including path separators (recursive)
• ? matches a single character
• [abc] matches one character from the set

Ordering

Exclusions are ordered first by variant (Path before Pattern), then by the value within the variant. This enables efficient deduplication and set operations.

Variants

Path(Cow<'a, Path>)

Exclude a specific file or directory by its exact path.

The path can be absolute or relative to the workspace directory. If a directory is specified, all contents within it are recursively excluded.

Uses Cow to allow borrowing paths from configuration while supporting owned paths when canonicalization is required.

Pattern(Cow<'a, str>)

Exclude files and directories matching a glob pattern.

The pattern is evaluated against the full path of each file discovered during the scan. Supports standard glob syntax including wildcards, character classes, and recursive matchers.

Uses Cow to avoid allocating when borrowing patterns from configuration.

Trait Implementations

impl<'a> Clone for Exclusion<'a>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Exclusion<'a>

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

Formats the value using the given formatter.

impl<'de, 'a> Deserialize<'de> for Exclusion<'a>

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'a> Hash for Exclusion<'a>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a> Ord for Exclusion<'a>

fn cmp(&self, other: &Exclusion<'a>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<'a> PartialEq for Exclusion<'a>

fn eq(&self, other: &Exclusion<'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> PartialOrd for Exclusion<'a>

fn partial_cmp(&self, other: &Exclusion<'a>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'a> Serialize for Exclusion<'a>

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<'a> Eq for Exclusion<'a>

impl<'a> StructuralPartialEq for Exclusion<'a>