Struct Path 

pub struct Path { /* private fields */ }

A validated logical path independent of any provider-native representation.

Examples

use qubit_fs::Path;
use qubit_fs::path::RelativePath;
let root = Path::parse("/reports")?;
let report = root.join(&RelativePath::parse("daily.csv")?);
assert_eq!("/reports/daily.csv", report.as_str());
assert!(report.is_absolute());

Implementations

impl Path

pub fn root() -> Self

Creates the canonical hierarchical root path.

pub fn from_components<I, S>(absolute: bool, components: I) -> FsResult<Self>

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

Constructs a hierarchical path from independently validated components.

Each item is validated as one component without reparsing a joined path string. An empty absolute sequence produces the root; an empty relative sequence returns an invalid-path error.

Parameters

• absolute: Whether the resulting path is rooted at the provider root.
• components: Validated path-component text to join in order.

Errors

Returns an invalid-path error when a component is empty, contains a separator or traversal marker, or when a relative sequence is empty.

pub fn parse(text: &str) -> FsResult<Self>

Parses a hierarchical logical path using normalized semantics.

Returns an invalid-path error for empty input, NUL, or root escape.

Errors

Returns FsError with an invalid-path kind when text is empty, contains NUL, or escapes above the hierarchical root.

pub fn parse_literal(text: &str) -> FsResult<Self>

Parses a provider-literal path without interpreting separators or dots.

Returns an invalid-path error for empty input or NUL.

Errors

Returns FsError with an invalid-path kind when text is empty or contains NUL.

pub fn parse_with_semantics( text: &str, semantics: PathSemantics, ) -> FsResult<Self>

Parses text according to explicitly selected provider semantics.

Hierarchical values normalize empty and dot components and reject root escapes. Object-key and provider-specific values preserve their text.

Parameters

• text: Provider path text to validate and normalize.
• semantics: Path semantics controlling normalization and root rules.

Errors

Returns an invalid-path error when text is empty, contains NUL, or escapes above the hierarchical root.

pub fn as_str(&self) -> &str

Returns the validated logical path text.

pub fn file_name(&self) -> Option<&str>

Returns the final non-empty path component, when one is present.

A root path and a literal path ending in a separator have no file name. Hierarchical paths are canonicalized during parsing, so their final component is always non-empty.

Returns

Some with the final non-empty component, or None for a root or a literal path ending in a separator.

pub const fn is_absolute(&self) -> bool

Returns whether this path is absolute.

pub const fn semantics(&self) -> PathSemantics

Returns the semantics used to validate this logical path.

pub fn components(&self) -> PathComponents<'_>

Iterates lexical component boundaries without using an empty root value.

pub fn child(&self, component: &PathComponent) -> Self

Appends one validated component without re-parsing provider text.

pub fn join(&self, relative: &RelativePath) -> Self

Appends a safe normalized relative path without re-parsing provider text.

Trait Implementations

impl AsRef<str> for Path

fn as_ref(&self) -> &str

Returns the logical path text for generic text consumers.

impl Clone for Path

fn clone(&self) -> Path

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Path

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

Formats the value using the given formatter.

impl Display for Path

fn fmt(&self, formatter: &mut Formatter<'_>) -> FmtResult

Formats the validated logical spelling.

impl Eq for Path

impl Hash for Path

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 for Path

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Path