Struct normpath::BasePathBuf

pub struct BasePathBuf(_);

An owned BasePath.

Implementations

impl BasePathBuf

pub fn new<P>(path: P) -> Result<Self> where
    P: Into<PathBuf>, 

Equivalent to BasePath::new but returns an owned path.

Examples

use std::path::Path;

use normpath::BasePathBuf;

if cfg!(windows) {
    let path = r"X:\foo\bar";
    assert_eq!(Path::new(path), BasePathBuf::new(path)?);

    assert!(BasePathBuf::new(r"foo\bar").is_ok());
}

pub fn try_new<P>(path: P) -> Result<Self, MissingPrefixBufError> where
    P: Into<PathBuf>, 

Equivalent to BasePath::try_new but returns an owned path.

Examples

use std::path::Path;

use normpath::BasePathBuf;

if cfg!(windows) {
    let path = r"X:\foo\bar";
    assert_eq!(Path::new(path), BasePathBuf::try_new(path)?);

    assert!(BasePathBuf::try_new(r"foo\bar").is_err());
}

#[must_use]pub fn into_os_string(self) -> OsString

Returns the wrapped path as a platform string.

#[must_use]pub fn into_path_buf(self) -> PathBuf

Returns the wrapped path.

pub fn pop(&mut self) -> Result<bool, ParentError>

Equivalent to BasePath::parent but modifies self in place.

Returns Ok(false) when BasePath::parent returns Ok(None).

Examples

use std::path::Path;

use normpath::BasePathBuf;

if cfg!(windows) {
    let mut path = BasePathBuf::try_new(r"X:\foo\bar").unwrap();
    assert!(path.pop()?);
    assert_eq!(Path::new(r"X:\foo"), path);
}

pub fn pop_unchecked(&mut self) -> bool

Equivalent to PathBuf::pop.

It is usually better to use pop.

Examples

use std::path::Path;

use normpath::BasePathBuf;

if cfg!(windows) {
    let mut path = BasePathBuf::try_new(r"X:\foo\..").unwrap();
    assert!(path.pop_unchecked());
    assert_eq!(Path::new(r"X:\foo"), path);
}

pub fn push<P>(&mut self, path: P) where
    P: AsRef<Path>, 

Equivalent to BasePath::join but modifies self in place.

Examples

use std::path::Path;

use normpath::BasePathBuf;

if cfg!(windows) {
    let mut path = BasePathBuf::try_new(r"\\?\foo\bar").unwrap();
    path.push("../baz/test.rs");
    assert_eq!(Path::new(r"\\?\foo\baz\test.rs"), path);
}

Methods from Deref<Target = BasePath>

#[must_use]pub fn as_os_str(&self) -> &OsStr

Returns a reference to the wrapped path as a platform string.

#[must_use]pub fn as_path(&self) -> &Path

Returns a reference to the wrapped path.

pub fn canonicalize(&self) -> Result<BasePathBuf>

Equivalent to Path::canonicalize.

#[must_use]pub fn components(&self) -> Components<'_>

Equivalent to Path::components.

#[must_use]pub fn ends_with<P>(&self, child: P) -> bool where
    P: AsRef<Path>, 

Equivalent to Path::ends_with.

#[must_use]pub fn exists(&self) -> bool

Equivalent to Path::exists.

#[must_use]pub fn extension(&self) -> Option<&OsStr>

Equivalent to Path::extension.

#[must_use]pub fn file_name(&self) -> Option<&OsStr>

Equivalent to Path::file_name.

#[must_use]pub fn file_stem(&self) -> Option<&OsStr>

Equivalent to Path::file_stem.

#[must_use]pub fn has_root(&self) -> bool

Equivalent to Path::has_root.

#[must_use]pub fn is_absolute(&self) -> bool

Equivalent to Path::is_absolute.

#[must_use]pub fn is_dir(&self) -> bool

Equivalent to Path::is_dir.

#[must_use]pub fn is_file(&self) -> bool

Equivalent to Path::is_file.

#[must_use]pub fn is_relative(&self) -> bool

Equivalent to Path::is_relative.

pub fn join<P>(&self, path: P) -> BasePathBuf where
    P: AsRef<Path>, 

An improved version of Path::join that handles more edge cases.

For example, on Windows, leading . and .. components of path will be normalized if possible. If self is a verbatim path, it would be invalid to normalize them later.

You should still call normalize before parent to normalize some additional components.

Examples

use std::path::Path;

use normpath::BasePath;

if cfg!(windows) {
    assert_eq!(
        Path::new(r"\\?\foo\baz\test.rs"),
        BasePath::try_new(r"\\?\foo\bar")
            .unwrap()
            .join("../baz/test.rs"),
    );
}

pub fn metadata(&self) -> Result<Metadata>

Equivalent to Path::metadata.

pub fn normalize(&self) -> Result<BasePathBuf>

Equivalent to PathExt::normalize.

pub fn normalize_virtually(&self) -> Result<BasePathBuf>

This is supported on Windows only.

Equivalent to PathExt::normalize_virtually.

pub fn parent(&self) -> Result<Option<&Self>, ParentError>

Returns this path without its last component.

Returns Ok(None) if the last component is Component::RootDir.

You should usually only call this method on normalized paths. They will prevent an unexpected path from being returned due to symlinks, and some . and .. components will be normalized.

Errors

Returns an error if the last component is not Component::Normal or Component::RootDir. To ignore this error, use parent_unchecked.

Examples

use std::path::Path;

use normpath::BasePath;

if cfg!(windows) {
    assert_eq!(
        Path::new(r"X:\foo"),
        BasePath::try_new(r"X:\foo\bar").unwrap().parent()?.unwrap(),
    );
}

#[must_use]pub fn parent_unchecked(&self) -> Option<&Self>

Equivalent to Path::parent.

It is usually better to use parent.

Examples

use std::path::Path;

use normpath::BasePath;

if cfg!(windows) {
    assert_eq!(
        Path::new(r"X:\foo"),
        BasePath::try_new(r"X:\foo\..")
            .unwrap()
            .parent_unchecked()
            .unwrap(),
    );
}

pub fn read_dir(&self) -> Result<ReadDir>

Equivalent to Path::read_dir.

pub fn read_link(&self) -> Result<PathBuf>

Equivalent to Path::read_link.

#[must_use]pub fn starts_with<P>(&self, base: P) -> bool where
    P: AsRef<Path>, 

Equivalent to Path::starts_with.

pub fn symlink_metadata(&self) -> Result<Metadata>

Equivalent to Path::symlink_metadata.

Trait Implementations

impl AsRef<BasePath> for BasePathBuf

fn as_ref(&self) -> &BasePath

Performs the conversion.

impl AsRef<OsStr> for BasePathBuf

fn as_ref(&self) -> &OsStr

Performs the conversion.

impl AsRef<Path> for BasePathBuf

fn as_ref(&self) -> &Path

Performs the conversion.

impl Borrow<BasePath> for BasePathBuf

fn borrow(&self) -> &BasePath

Immutably borrows from an owned value.

impl Clone for BasePathBuf

fn clone(&self) -> BasePathBuf

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for BasePathBuf

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

Formats the value using the given formatter.

impl Deref for BasePathBuf

type Target = BasePath

The resulting type after dereferencing.

fn deref(&self) -> &BasePath

Dereferences the value.

impl Eq for BasePathBuf

impl Hash for BasePathBuf

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

pub fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl Ord for BasePathBuf

fn cmp(&self, other: &BasePathBuf) -> Ordering

This method returns an Ordering between self and other.

#[must_use]pub fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]pub fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl PartialEq<&'_ BasePath> for BasePathBuf

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

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

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<&'_ Path> for BasePathBuf

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

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

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<BasePath> for BasePathBuf

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

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

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<BasePathBuf> for BasePath

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

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

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<BasePathBuf> for &BasePath

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

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

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<BasePathBuf> for BasePathBuf

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

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

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

This method tests for !=.

impl PartialEq<Cow<'_, BasePath>> for BasePathBuf

fn eq(&self, other: &Cow<'_, BasePath>) -> bool

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

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<Cow<'_, Path>> for BasePathBuf

fn eq(&self, other: &Cow<'_, Path>) -> bool

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

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<Path> for BasePathBuf

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

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

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<PathBuf> for BasePathBuf

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

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

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialOrd<&'_ BasePath> for BasePathBuf

fn partial_cmp(&self, other: &&BasePath) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use]pub fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]pub fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]pub fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]pub fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<&'_ Path> for BasePathBuf

fn partial_cmp(&self, other: &&Path) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use]pub fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]pub fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]pub fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]pub fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<BasePath> for BasePathBuf

fn partial_cmp(&self, other: &BasePath) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use]pub fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]pub fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]pub fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]pub fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<BasePathBuf> for BasePath

fn partial_cmp(&self, other: &BasePathBuf) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use]pub fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]pub fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]pub fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]pub fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<BasePathBuf> for &BasePath

fn partial_cmp(&self, other: &BasePathBuf) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use]pub fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]pub fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]pub fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]pub fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<BasePathBuf> for BasePathBuf

fn partial_cmp(&self, other: &BasePathBuf) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use]pub fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]pub fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]pub fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]pub fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<Cow<'_, BasePath>> for BasePathBuf

fn partial_cmp(&self, other: &Cow<'_, BasePath>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use]pub fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]pub fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]pub fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]pub fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<Cow<'_, Path>> for BasePathBuf

fn partial_cmp(&self, other: &Cow<'_, Path>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use]pub fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]pub fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]pub fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]pub fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<Path> for BasePathBuf

fn partial_cmp(&self, other: &Path) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use]pub fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]pub fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]pub fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]pub fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<PathBuf> for BasePathBuf

fn partial_cmp(&self, other: &PathBuf) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use]pub fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]pub fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]pub fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]pub fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl StructuralEq for BasePathBuf

impl StructuralPartialEq for BasePathBuf