Enum wax::Variance

pub enum Variance {
    Invariant(PathBuf),
    Variant,
}

Variance of a Program.

The variance of a pattern describes the kinds of paths it can match with respect to the platform file system APIs. Programs are either variant or invariant.

An invariant Program can be represented and completely described by an equivalent path using the platform’s file system APIs. For example, the glob expression path/to/file.txt resolves identically to the paths path/to/file.txt and path\to\file.txt on Unix and Windows, respectively.

A variant Program resolves differently than any particular path used with the platform’s file system APIs. Such an expression cannot be represented by a single path. This is typically because the expression matches multiple texts using a regular pattern, such as in the glob expression **/*.rs.

Variants

Invariant(PathBuf)

Tuple Fields

0: PathBuf

An equivalent path that completely describes the invariant Program with respect to platform file system APIs.

A Program is invariant and equivalent to a path.

Some non-literal expressions may be invariant, such as in the expression path/[t][o]/{file,file}.txt, which is invariant on Unix (but not on Windows, because the character class expressions do not match with case folding).

Variant

A Program is variant and cannot be completely described by a path.

Variant expressions may be formed from literals or other seemingly invariant expressions. For example, the variance of literals considers the case sensitivity of the platform’s file system APIs, so the expression (?i)path/to/file.txt is variant on Unix but not on Windows. Similarly, the expression path/[t][o]/file.txt is variant on Windows but not on Unix.

Implementations

impl Variance

pub fn path(&self) -> Option<&Path>

Gets the equivalent native path if invariant.

Returns None if variant.

pub fn is_invariant(&self) -> bool

Returns true if invariant.

pub fn is_variant(&self) -> bool

Returns true if variant.

Trait Implementations

impl Clone for Variance

fn clone(&self) -> Variance

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Variance

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

Formats the value using the given formatter.

impl Hash for Variance

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 PartialEq<Variance> for Variance

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Eq for Variance

impl StructuralEq for Variance

impl StructuralPartialEq for Variance