Struct normpath::BasePath[−][src]

#[repr(transparent)]pub struct BasePath(_);

A path that has a prefix on Windows.

Note that comparison traits such as PartialEq will compare paths literally instead of comparing components. The former is more efficient and easier to use correctly.

Safety

This type should not be used for memory safety, but implementations can panic if this path is missing a prefix on Windows. A safe new_unchecked method might be added later that can safely create invalid base paths.

Although this type is annotated with #[repr(transparent)], the inner representation is not stable. Transmuting between this type and any other causes immediate undefined behavior.

Implementations

`impl BasePath`[src]

`pub fn new<'a, P>(path: P) -> Result<Cow<'a, Self>> where P: Into<Cow<'a, Path>>,` [src]

Creates a new base path.

On Windows, if path is missing a prefix, it will be joined to the current directory.

Errors

Returns an error if reading the current directory fails.

Examples

use std::path::Path;

use normpath::BasePath;

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

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

`pub fn try_new<P: ?Sized>(path: &P) -> Result<&Self, MissingPrefixError> where P: AsRef<Path>,` [src]

Creates a new base path.

Errors

On Windows, returns an error if path is missing a prefix.

Examples

use std::path::Path;

use normpath::BasePath;

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

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

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

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

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

Returns a reference to the wrapped path.

`pub fn canonicalize(&self) -> Result<BasePathBuf>`[src]

Equivalent to Path::canonicalize.

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

Equivalent to Path::components.

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

Equivalent to Path::ends_with.

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

Equivalent to Path::exists.

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

Equivalent to Path::is_dir.

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

Equivalent to Path::is_file.

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

Equivalent to Path::is_relative.

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

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>`[src]

Equivalent to Path::metadata.

`pub fn normalize(&self) -> Result<BasePathBuf>`[src]

Equivalent to PathExt::normalize.

`pub fn normalize_virtually(&self) -> Result<BasePathBuf>`[src]

This is supported on Windows only.

Equivalent to PathExt::normalize_virtually.

`pub fn parent(&self) -> Result<Option<&Self>, ParentError>`[src]

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>`[src]

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(),
    );
}