Struct FlexPath

pub struct FlexPath(/* private fields */);

The FlexPath structure represents an always-resolved textual file path based on a [FlexPathVariant].

Implementations

impl FlexPath

pub fn new(path: &str, variant: FlexPathVariant) -> Self

Constructs a FlexPath with a given variant. This method will resolve the specified path.

pub fn new_common(path: &str) -> Self

Constructs a FlexPath whose variant is Common. This method will resolve the specified path.

pub fn new_native(path: &str) -> Self

Constructs a FlexPath whose variant is chosen according to the target platform. This method will resolve the specified path.

pub fn from_n<'a, T: IntoIterator<Item = &'a str>>( paths: T, variant: FlexPathVariant, ) -> Self

Constructs a FlexPath from multiple paths and a given variant.

pub fn from_n_common<'a, T: IntoIterator<Item = &'a str>>(paths: T) -> Self

Constructs a FlexPath from multiple paths and a Common variant.

pub fn from_n_native<'a, T: IntoIterator<Item = &'a str>>(paths: T) -> Self

Constructs a FlexPath from multiple paths and a variant based on the target platform.

pub fn variant(&self) -> FlexPathVariant

Returns the variant this FlexPath object is based on.

pub fn is_absolute(&self) -> bool

Indicates whether the FlexPath is absolute or not.

pub fn resolve(&self, path2: &str) -> FlexPath

Resolves path2 relative to path1.

Behavior:

• Eliminates the segments .. and ..
• If path2 is absolute, this function returns a resolution of solely path2.
• All path separators that are backslashes (\) are replaced by forward ones (/).
• If any path is absolute, this function returns an absolute path.
• Any empty segment and trailing path separators, such as in a/b/ and a//b are eliminated.

pub fn resolve_n<'a, T: IntoIterator<Item = &'a str>>( &self, paths: T, ) -> FlexPath

Resolves multiple paths relative to this path. The behavior is similiar to [.resolve]. If the given set has no items, an empty string is returned.

pub fn relative(&self, to_path: &str) -> String

Finds the relative path from this path to to_path.

Behavior:

• If the paths refer to the same path, this function returns an empty string.
• The function ensures that both paths are absolute and resolves any .. and . segments inside.
• If both paths have different prefix, to_path is returned.

Panics

Panics if given paths are not absolute.

Example

use file_paths::FlexPath;
assert_eq!("", FlexPath::new_common("/a/b").relative("/a/b"));
assert_eq!("c", FlexPath::new_common("/a/b").relative("/a/b/c"));
assert_eq!("../../c/d", FlexPath::new_common("/a/b").relative("/c/d"));
assert_eq!("../c", FlexPath::new_common("/a/b").relative("/a/c"));

pub fn change_extension(&self, extension: &str) -> FlexPath

Changes the extension of a path and returns a new string. This method adds any lacking dot (.) prefix automatically to the extension argument.

This method allows multiple dots per extension. If that is not desired, use [.change_last_extension].

Example

use file_paths::FlexPath;
assert_eq!("a.y", FlexPath::new_common("a.x").change_extension(".y").to_string());
assert_eq!("a.z", FlexPath::new_common("a.x.y").change_extension(".z").to_string());
assert_eq!("a.z.w", FlexPath::new_common("a.x.y").change_extension(".z.w").to_string());

pub fn change_last_extension(&self, extension: &str) -> FlexPath

Changes only the last extension of a path and returns a new string. This method adds any lacking dot (.) prefix automatically to the extension argument.

Panics

Panics if the extension contains more than one dot.

pub fn has_extension(&self, extension: &str) -> bool

Checks if a file path has a specific extension. This method adds any lacking dot (.) prefix automatically to the extension argument.

pub fn has_extensions<'a, T: IntoIterator<Item = &'a str>>( &self, extensions: T, ) -> bool

Checks if a file path has any of multiple specific extensions. This method adds any lacking dot (.) prefix automatically to each extension argument.

pub fn base_name(&self) -> String

Returns the base name of a file path.

Example

use file_paths::FlexPath;
assert_eq!("qux.html", FlexPath::new_common("foo/qux.html").base_name());

pub fn base_name_without_ext<'a, T>(&self, extensions: T) -> String

where T: IntoIterator<Item = &'a str>,

Returns the base name of a file path, removing any of the specified extensions. This method adds any lacking dot (.) prefix automatically to each extension argument.

Example

use file_paths::FlexPath;
assert_eq!("qux", FlexPath::new_common("foo/qux.html").base_name_without_ext([".html"]));

pub fn to_string_with_flex_separator(&self) -> String

Returns a string representation of the path, delimiting segments with either a forward slash (/) or backward slash (\) depending on the path’s FlexPathVariant.

Trait Implementations

impl Clone for FlexPath

fn clone(&self) -> FlexPath

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FlexPath

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

Formats the value using the given formatter.

impl Ord for FlexPath

fn cmp(&self, other: &FlexPath) -> 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 PartialEq for FlexPath

fn eq(&self, other: &FlexPath) -> 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 PartialOrd for FlexPath

fn partial_cmp(&self, other: &FlexPath) -> 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 ToString for FlexPath

fn to_string(&self) -> String

Returns a string representation of the path, always delimiting segments with a forward slash (/).

impl Eq for FlexPath

impl StructuralPartialEq for FlexPath