Struct normpath::BasePathBuf[−][src]

pub struct BasePathBuf(_);

Expand description

An owned BasePath.

Implementations

[src]

impl BasePathBuf

[src]

pub fn new(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());
}

[src]

pub fn try_new(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());
}

[src]

pub fn into_os_string(self) -> OsString

Returns the wrapped path as a platform string.

[src]

pub fn into_path_buf(self) -> PathBuf

Returns the wrapped path.

[src]

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

[src]

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

[src]

pub fn push(&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>

[src]

pub fn as_os_str(&self) -> &OsStr

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

[src]

pub fn as_path(&self) -> &Path

Returns a reference to the wrapped path.

[src]

pub fn exists(&self) -> bool

Equivalent to Path::exists.

[src]

pub fn extension(&self) -> Option<&OsStr>

Equivalent to Path::extension.

[src]

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

Equivalent to Path::file_name.

[src]

pub fn file_stem(&self) -> Option<&OsStr>

Equivalent to Path::file_stem.

[src]

pub fn has_root(&self) -> bool

Equivalent to Path::has_root.

[src]

pub fn is_absolute(&self) -> bool

Equivalent to Path::is_absolute.

[src]

pub fn is_dir(&self) -> bool

Equivalent to Path::is_dir.

[src]

pub fn is_file(&self) -> bool

Equivalent to Path::is_file.

[src]

pub fn is_relative(&self) -> bool

Equivalent to Path::is_relative.

[src]

pub fn join(&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"),
    );
}

[src]

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

Equivalent to Path::metadata.

[src]

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

Equivalent to PathExt::normalize.

[src]

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

This is supported on Windows only.

Equivalent to PathExt::normalize_virtually.

[src]

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

[src]

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