Struct PathFilter 

pub struct PathFilter { /* private fields */ }

A sophisticated path filter that supports multiple matching strategies.

The filter uses an OR logic - a path is included if it matches ANY of the configured criteria. This allows for flexible and powerful filtering configurations.

Examples

// Create a filter that matches encoder paths or any weight path
let filter = PathFilter::new()
    .with_regex(r"^encoder\..*")
    .with_regex(r".*\.weight$")
    .with_full_path("special_tensor");

// Check if a path should be included
if filter.matches("encoder.layer1.weight") {
    // This will match due to both regex patterns
}

Implementations

impl PathFilter

pub fn new() -> Self

Create a new empty filter (matches nothing by default)

pub fn all() -> Self

Create a filter that matches all paths

pub fn none() -> Self

Create a filter that matches nothing

pub fn with_regex<S: AsRef<str>>(self, pattern: S) -> Self

Add a regex pattern for matching paths

pub fn with_regexes<I, S>(self, patterns: I) -> Self

where I: IntoIterator<Item = S>, S: AsRef<str>,

Add multiple regex patterns

pub fn with_full_path<S: Into<String>>(self, path: S) -> Self

Add an exact full path to match

pub fn with_full_paths<I, S>(self, paths: I) -> Self

where I: IntoIterator<Item = S>, S: Into<String>,

Add multiple exact full paths

pub fn with_predicate(self, predicate: fn(&str, &str) -> bool) -> Self

Add a predicate function for custom matching based on path and container path

pub fn with_predicates<I>(self, predicates: I) -> Self

where I: IntoIterator<Item = fn(&str, &str) -> bool>,

Add multiple predicates

pub fn match_all(self) -> Self

Set to match all paths

pub fn matches(&self, path: &str) -> bool

Check if a path matches this filter (assumes empty container path for backward compatibility)

pub fn matches_with_container(&self, path: &str, container_type: &str) -> bool

Check if a path and container type match this filter (for backward compatibility)

pub fn matches_with_container_path( &self, path: &[String], container_stack: &[String], ) -> bool

Check if a path and container path match this filter

pub fn matches_with_container_path_str( &self, path: &str, container_path: &str, ) -> bool

Check if a path and container path (dot-notated strings) match this filter

pub fn is_empty(&self) -> bool

Check if the filter is empty (matches nothing)

pub fn criteria_count(&self) -> usize

Get the number of filter criteria configured

pub fn clear_regex(&mut self) -> &mut Self

Clear all regex patterns

pub fn clear_paths(&mut self) -> &mut Self

Clear all exact paths

pub fn clear_predicates(&mut self) -> &mut Self

Clear all predicates

pub fn clear(&mut self) -> &mut Self

Clear all filters

pub fn from_regex_patterns<I, S>(patterns: I) -> Self

where I: IntoIterator<Item = S>, S: AsRef<str>,

Create a filter from regex patterns only

pub fn from_paths<I, S>(paths: I) -> Self

where I: IntoIterator<Item = S>, S: Into<String>,

Create a filter from exact paths only

pub fn from_predicate(predicate: fn(&str, &str) -> bool) -> Self

Create a filter from a single predicate

pub fn or(self, other: Self) -> Self

Combine with another filter using OR logic

Trait Implementations

impl Clone for PathFilter

fn clone(&self) -> PathFilter

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PathFilter

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

Formats the value using the given formatter.

impl Default for PathFilter

fn default() -> PathFilter

Returns the “default value” for a type.

impl Display for PathFilter

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

Formats the value using the given formatter.