Struct List

pub struct List<T: Pattern> {
    pub patterns: Vec<Mapping<T::Value>>,
    pub source: Option<PathBuf>,
    pub base: Option<BString>,
}

A list of patterns which optionally know where they were loaded from and what their base is.

Knowing their base which is relative to a source directory, it will ignore all path to match against that don’t also start with said base.

Fields

patterns: Vec<Mapping<T::Value>>

Patterns and their associated data in the order they were loaded in or specified, the line number in its source file or its sequence number ((pattern, value, line_number)).

During matching, this order is reversed.

source: Option<PathBuf>

The path from which the patterns were read, or None if the patterns don’t originate in a file on disk.

base: Option<BString>

The parent directory of source, or None if the patterns are global to match against the repository root. It’s processed to contain slashes only and to end with a trailing slash, and is relative to the repository root.

Implementations

impl<T> List<T>

where T: Pattern,

Instantiation

pub fn from_bytes( bytes: &[u8], source_file: PathBuf, root: Option<&Path>, ) -> Self

source_file is the location of the bytes which represents a list of patterns, one pattern per line. If root is Some(…) it’s used to see source_file as relative to itself, if source_file is absolute. If source is relative and should be treated as base, set root to Some("").

pub fn from_file( source: impl Into<PathBuf>, root: Option<&Path>, follow_symlinks: bool, buf: &mut Vec<u8>, ) -> Result<Option<Self>>

Create a pattern list from the source file, which may be located underneath root, while optionally following symlinks with follow_symlinks, providing buf to temporarily store the data contained in the file.

impl<T> List<T>

where T: Pattern,

Utilities

pub fn strip_base_handle_recompute_basename_pos<'a>( &self, relative_path: &'a BStr, basename_pos: Option<usize>, case: Case, ) -> Option<(&'a BStr, Option<usize>)>

If this list is anchored to a base path, return relative_path as being relative to our base and return an updated basename_pos as well if it was set. case is respected for the comparison.

This is useful to turn repository-relative paths into paths relative to a particular search base.

Trait Implementations

impl<T: Clone + Pattern> Clone for List<T>

where T::Value: Clone,

fn clone(&self) -> List<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Pattern> Debug for List<T>

where T::Value: Debug,

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

Formats the value using the given formatter.

impl<T: Default + Pattern> Default for List<T>

where T::Value: Default,

fn default() -> List<T>

Returns the “default value” for a type.

impl<T: Hash + Pattern> Hash for List<T>

where T::Value: Hash,

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<T: Ord + Pattern> Ord for List<T>

where T::Value: Ord,

fn cmp(&self, other: &List<T>) -> 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<T: PartialEq + Pattern> PartialEq for List<T>

where T::Value: PartialEq,

fn eq(&self, other: &List<T>) -> 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<T: PartialOrd + Pattern> PartialOrd for List<T>

where T::Value: PartialOrd,

fn partial_cmp(&self, other: &List<T>) -> 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<T: Eq + Pattern> Eq for List<T>

where T::Value: Eq,

impl<T: Pattern> StructuralPartialEq for List<T>