Struct PathBuf

pub struct PathBuf<Form: PathForm = Any> { /* private fields */ }

A wrapper around std::path::PathBuf with extra invariants determined by its Form.

The possible path forms are Any, Relative, Absolute, or Canonical. To learn more, view the documentation on PathForm or any of the individual forms.

There are also several type aliases available, corresponding to each PathForm:

• RelativePathBuf (same as PathBuf<Relative>)
• AbsolutePathBuf (same as PathBuf<Absolute>)
• CanonicalPathBuf (same as PathBuf<Canonical>)

If the Form is not specified, then it defaults to Any, so PathBuf and PathBuf<Any> are one in the same.

Examples

To create a PathBuf with Any form, you can use the same techniques as when creating a std::path::PathBuf.

use nu_path::PathBuf;

let path = PathBuf::from(r"C:\windows\system32.dll");

let mut path1 = PathBuf::new();
path1.push(r"C:\");
path1.push("windows");
path1.push("system32");
path1.set_extension("dll");

let path2: PathBuf = [r"C:\", "windows", "system32.dll"].iter().collect();

assert_eq!(path1, path2);

Converting to std::path types

PathBufs with form Any cannot be easily referenced as a std::path::Path or converted to a std::path::PathBuf by design. Other Nushell crates need to account for the emulated current working directory before passing a path to functions in std or other third party crates. You can join a Path onto an AbsolutePath or a CanonicalPath. This will return an AbsolutePathBuf which can be easily referenced as a std::path::Path. If you really mean it, you can instead use as_relative_std_path or into_relative_std_path_buf to get the underlying std::path::Path or std::path::PathBuf from a PathBuf. But this may cause third-party code to use std::env::current_dir to resolve the path which is almost always incorrect behavior. Extra care is needed to ensure that this is not the case after using as_relative_std_path or into_relative_std_path_buf.

Implementations

impl<Form: PathForm> PathBuf<Form>

pub fn as_path(&self) -> &Path<Form>

Coerces to a Path slice.

Examples

use nu_path::{Path, PathBuf};

let p = PathBuf::from("/test");
assert_eq!(Path::new("/test"), p.as_path());

pub fn pop(&mut self) -> bool

Truncates self to self.parent.

Returns false and does nothing if self.parent is None. Otherwise, returns true.

Examples

use nu_path::{Path, PathBuf};

let mut p = PathBuf::from("/spirited/away.rs");

p.pop();
assert_eq!(Path::new("/spirited"), p);
p.pop();
assert_eq!(Path::new("/"), p);

pub fn into_os_string(self) -> OsString

Consumes the PathBuf, returning its internal OsString storage.

Examples

use nu_path::PathBuf;

let p = PathBuf::from("/the/head");
let os_str = p.into_os_string();

pub fn into_boxed_path(self) -> Box<Path<Form>>

Converts this PathBuf into a boxed Path.

pub fn capacity(&self) -> usize

Returns the capacity of the underlying OsString.

pub fn reserve(&mut self, additional: usize)

Invokes reserve on the underlying OsString.

pub fn try_reserve(&mut self, additional: usize) -> Result<(), TryReserveError>

Invokes try_reserve on the underlying OsString.

pub fn reserve_exact(&mut self, additional: usize)

Invokes reserve_exact on the underlying OsString.

pub fn try_reserve_exact( &mut self, additional: usize, ) -> Result<(), TryReserveError>

Invokes try_reserve_exact on the underlying OsString.

pub fn shrink_to_fit(&mut self)

Invokes shrink_to_fit on the underlying OsString.

pub fn shrink_to(&mut self, min_capacity: usize)

Invokes shrink_to on the underlying OsString.

pub fn cast_into<To>(self) -> PathBuf<To>

where To: PathForm, Form: PathCast<To>,

Consumes a PathBuf, returning it with a different form.

PathForms can be converted to one another based on PathCast implementations. Namely, the following form conversions are possible:

• Relative, Absolute, or Canonical into Any.
• Canonical into Absolute.
• Any form into itself.

Examples

use nu_path::{PathBuf, RelativePathBuf};

let p = RelativePathBuf::try_from("test.txt").unwrap();
let p: PathBuf = p.cast_into();
assert_eq!(PathBuf::from("test.txt"), p);

pub fn into_any(self) -> PathBuf

Consumes a PathBuf, returning it with form Any.

Examples

use nu_path::{PathBuf, RelativePathBuf};

let p = RelativePathBuf::try_from("test.txt").unwrap();
assert_eq!(PathBuf::from("test.txt"), p.into_any());

impl PathBuf

pub fn new() -> Self

Creates an empty PathBuf.

Examples

use nu_path::PathBuf;

let path = PathBuf::new();

pub fn with_capacity(capacity: usize) -> Self

Creates a new PathBuf with a given capacity used to create the internal OsString. See with_capacity defined on OsString.

Examples

use nu_path::PathBuf;

let mut path = PathBuf::with_capacity(10);
let capacity = path.capacity();

// This push is done without reallocating
path.push(r"C:\");

assert_eq!(capacity, path.capacity());

pub fn as_mut_os_string(&mut self) -> &mut OsString

Returns a mutable reference to the underlying OsString.

Examples

use nu_path::{Path, PathBuf};

let mut path = PathBuf::from("/foo");

path.push("bar");
assert_eq!(path, Path::new("/foo/bar"));

// OsString's `push` does not add a separator.
path.as_mut_os_string().push("baz");
assert_eq!(path, Path::new("/foo/barbaz"));

pub fn clear(&mut self)

Invokes clear on the underlying OsString.

pub fn try_into_relative(self) -> Result<RelativePathBuf, Self>

Consumes a PathBuf, returning an Ok RelativePathBuf if the PathBuf is relative. Otherwise, returns the original PathBuf as an Err.

Examples

use nu_path::PathBuf;

assert!(PathBuf::from("test.txt").try_into_relative().is_ok());

pub fn try_into_absolute(self) -> Result<AbsolutePathBuf, Self>

Consumes a PathBuf, returning an Ok AbsolutePathBuf if the PathBuf is absolute. Otherwise, returns the original PathBuf as an Err.

Examples

use nu_path::PathBuf;

assert!(PathBuf::from("test.txt").try_into_absolute().is_err());

impl<Form: PathPush> PathBuf<Form>

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

Extends self with path.

If path is absolute, it replaces the current path.

On Windows:

• if path has a root but no prefix (e.g., \windows), it replaces everything except for the prefix (if any) of self.
• if path has a prefix but no root, it replaces self.
• if self has a verbatim prefix (e.g. \\?\C:\windows) and path is not empty, the new path is normalized: all references to . and .. are removed.

Consider using Path::join if you need a new PathBuf instead of using this function on a cloned PathBuf.

Examples

Pushing a relative path extends the existing path:

use nu_path::PathBuf;

let mut path = PathBuf::from("/tmp");
path.push("file.bk");
assert_eq!(path, PathBuf::from("/tmp/file.bk"));

Pushing an absolute path replaces the existing path:

use nu_path::PathBuf;

let mut path = PathBuf::from("/tmp");
path.push("/etc");
assert_eq!(path, PathBuf::from("/etc"));

impl<Form: PathSet> PathBuf<Form>

pub fn set_file_name(&mut self, file_name: impl AsRef<OsStr>)

Updates self.file_name to file_name.

If self.file_name was None, this is equivalent to pushing file_name.

Otherwise it is equivalent to calling pop and then pushing file_name. The new path will be a sibling of the original path. (That is, it will have the same parent.)

Examples

use nu_path::PathBuf;

let mut buf = PathBuf::from("/");
assert!(buf.file_name() == None);

buf.set_file_name("foo.txt");
assert!(buf == PathBuf::from("/foo.txt"));
assert!(buf.file_name().is_some());

buf.set_file_name("bar.txt");
assert!(buf == PathBuf::from("/bar.txt"));

buf.set_file_name("baz");
assert!(buf == PathBuf::from("/baz"));

pub fn set_extension(&mut self, extension: impl AsRef<OsStr>) -> bool

Updates self.extension to Some(extension) or to None if extension is empty.

Returns false and does nothing if self.file_name is None, returns true and updates the extension otherwise.

If self.extension is None, the extension is added; otherwise it is replaced.

If extension is the empty string, self.extension will be None afterwards, not Some("").

Caveats

The new extension may contain dots and will be used in its entirety, but only the part after the final dot will be reflected in self.extension.

If the file stem contains internal dots and extension is empty, part of the old file stem will be considered the new self.extension.

Examples

use nu_path::{Path, PathBuf};

let mut p = PathBuf::from("/feel/the");

p.set_extension("force");
assert_eq!(Path::new("/feel/the.force"), p.as_path());

p.set_extension("dark.side");
assert_eq!(Path::new("/feel/the.dark.side"), p.as_path());

p.set_extension("cookie");
assert_eq!(Path::new("/feel/the.dark.cookie"), p.as_path());

p.set_extension("");
assert_eq!(Path::new("/feel/the.dark"), p.as_path());

p.set_extension("");
assert_eq!(Path::new("/feel/the"), p.as_path());

p.set_extension("");
assert_eq!(Path::new("/feel/the"), p.as_path());

impl<Form: MaybeRelative> PathBuf<Form>

pub fn into_relative_std_path_buf(self) -> PathBuf

Consumes a PathBuf and returns the, potentially relative, underlying std::path::PathBuf.

Note

Caution should be taken when using this function. Nushell keeps track of an emulated current working directory, and using the std::path::PathBuf returned from this method will likely use std::env::current_dir to resolve the path instead of using the emulated current working directory.

Instead, you should probably join this path onto the emulated current working directory. Any AbsolutePath or CanonicalPath will also suffice.

Examples

use nu_path::PathBuf;

let p = PathBuf::from("test.txt");
assert_eq!(std::path::PathBuf::from("test.txt"), p.into_relative_std_path_buf());

impl<Form: IsAbsolute> PathBuf<Form>

pub fn into_std_path_buf(self) -> PathBuf

Consumes a PathBuf and returns the underlying std::path::PathBuf.

Examples

use nu_path::AbsolutePathBuf;

let p = AbsolutePathBuf::try_from("/test").unwrap();
assert_eq!(std::path::PathBuf::from("/test"), p.into_std_path_buf());

impl PathBuf<Canonical>

pub fn into_absolute(self) -> AbsolutePathBuf

Consumes a CanonicalPathBuf and returns an AbsolutePathBuf.

Examples

use nu_path::AbsolutePathBuf;

let absolute = AbsolutePathBuf::try_from("/test").unwrap();
let p = absolute.canonicalize().unwrap();
assert_eq!(absolute, p.into_absolute());

Methods from Deref<Target = Path<Form>>

pub fn as_os_str(&self) -> &OsStr

Returns the underlying OsStr slice.

Examples

use nu_path::Path;

let os_str = Path::new("foo.txt").as_os_str();
assert_eq!(os_str, std::ffi::OsStr::new("foo.txt"));

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

Returns a str slice if the Path is valid unicode.

Examples

use nu_path::Path;

let path = Path::new("foo.txt");
assert_eq!(path.to_str(), Some("foo.txt"));

pub fn to_string_lossy(&self) -> Cow<'_, str>

Converts a Path to a Cow<str>.

Any non-Unicode sequences are replaced with U+FFFD REPLACEMENT CHARACTER.

Examples

Calling to_string_lossy on a Path with valid unicode:

use nu_path::Path;

let path = Path::new("foo.txt");
assert_eq!(path.to_string_lossy(), "foo.txt");

Had path contained invalid unicode, the to_string_lossy call might have returned "fo�.txt".

pub fn to_path_buf(&self) -> PathBuf<Form>

Converts a Path to an owned PathBuf.

Examples

use nu_path::{Path, PathBuf};

let path_buf = Path::new("foo.txt").to_path_buf();
assert_eq!(path_buf, PathBuf::from("foo.txt"));

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

Returns the Path without its final component, if there is one.

This means it returns Some("") for relative paths with one component.

Returns None if the path terminates in a root or prefix, or if it’s the empty string.

Examples

use nu_path::Path;

let path = Path::new("/foo/bar");
let parent = path.parent().unwrap();
assert_eq!(parent, Path::new("/foo"));

let grand_parent = parent.parent().unwrap();
assert_eq!(grand_parent, Path::new("/"));
assert_eq!(grand_parent.parent(), None);

let relative_path = Path::new("foo/bar");
let parent = relative_path.parent();
assert_eq!(parent, Some(Path::new("foo")));
let grand_parent = parent.and_then(Path::parent);
assert_eq!(grand_parent, Some(Path::new("")));
let great_grand_parent = grand_parent.and_then(Path::parent);
assert_eq!(great_grand_parent, None);

pub fn ancestors(&self) -> Ancestors<'_, Form>

Produces an iterator over a Path and its ancestors.

The iterator will yield the Path that is returned if the parent method is used zero or more times. That means, the iterator will yield &self, &self.parent().unwrap(), &self.parent().unwrap().parent().unwrap() and so on. If the parent method returns None, the iterator will do likewise. The iterator will always yield at least one value, namely &self.

Examples

use nu_path::Path;

let mut ancestors = Path::new("/foo/bar").ancestors();
assert_eq!(ancestors.next(), Some(Path::new("/foo/bar")));
assert_eq!(ancestors.next(), Some(Path::new("/foo")));
assert_eq!(ancestors.next(), Some(Path::new("/")));
assert_eq!(ancestors.next(), None);

let mut ancestors = Path::new("../foo/bar").ancestors();
assert_eq!(ancestors.next(), Some(Path::new("../foo/bar")));
assert_eq!(ancestors.next(), Some(Path::new("../foo")));
assert_eq!(ancestors.next(), Some(Path::new("..")));
assert_eq!(ancestors.next(), Some(Path::new("")));
assert_eq!(ancestors.next(), None);

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

Returns the final component of a Path, if there is one.

If the path is a normal file, this is the file name. If it’s the path of a directory, this is the directory name.

Returns None if the path terminates in ...

Examples

use nu_path::Path;
use std::ffi::OsStr;

assert_eq!(Some(OsStr::new("bin")), Path::new("/usr/bin/").file_name());
assert_eq!(Some(OsStr::new("foo.txt")), Path::new("tmp/foo.txt").file_name());
assert_eq!(Some(OsStr::new("foo.txt")), Path::new("foo.txt/.").file_name());
assert_eq!(Some(OsStr::new("foo.txt")), Path::new("foo.txt/.//").file_name());
assert_eq!(None, Path::new("foo.txt/..").file_name());
assert_eq!(None, Path::new("/").file_name());

pub fn strip_prefix( &self, base: impl AsRef<Path>, ) -> Result<&RelativePath, StripPrefixError>

Returns a relative path that, when joined onto base, yields self.

Examples

use nu_path::{Path, PathBuf};

let path = Path::new("/test/haha/foo.txt");

assert_eq!(path.strip_prefix("/").unwrap(), Path::new("test/haha/foo.txt"));
assert_eq!(path.strip_prefix("/test").unwrap(), Path::new("haha/foo.txt"));
assert_eq!(path.strip_prefix("/test/").unwrap(), Path::new("haha/foo.txt"));
assert_eq!(path.strip_prefix("/test/haha/foo.txt").unwrap(), Path::new(""));
assert_eq!(path.strip_prefix("/test/haha/foo.txt/").unwrap(), Path::new(""));

assert!(path.strip_prefix("test").is_err());
assert!(path.strip_prefix("/haha").is_err());

let prefix = PathBuf::from("/test/");
assert_eq!(path.strip_prefix(prefix).unwrap(), Path::new("haha/foo.txt"));

pub fn starts_with(&self, base: impl AsRef<Path>) -> bool

Determines whether base is a prefix of self.

Only considers whole path components to match.

Examples

use nu_path::Path;

let path = Path::new("/etc/passwd");

assert!(path.starts_with("/etc"));
assert!(path.starts_with("/etc/"));
assert!(path.starts_with("/etc/passwd"));
assert!(path.starts_with("/etc/passwd/")); // extra slash is okay
assert!(path.starts_with("/etc/passwd///")); // multiple extra slashes are okay

assert!(!path.starts_with("/e"));
assert!(!path.starts_with("/etc/passwd.txt"));

assert!(!Path::new("/etc/foo.rs").starts_with("/etc/foo"));

pub fn ends_with(&self, child: impl AsRef<Path>) -> bool

Determines whether child is a suffix of self.

Only considers whole path components to match.

Examples

use nu_path::Path;

let path = Path::new("/etc/resolv.conf");

assert!(path.ends_with("resolv.conf"));
assert!(path.ends_with("etc/resolv.conf"));
assert!(path.ends_with("/etc/resolv.conf"));

assert!(!path.ends_with("/resolv.conf"));
assert!(!path.ends_with("conf")); // use .extension() instead

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

Extracts the stem (non-extension) portion of self.file_name.

The stem is:

• None, if there is no file name;
• The entire file name if there is no embedded .;
• The entire file name if the file name begins with . and has no other .s within;
• Otherwise, the portion of the file name before the final .

Examples

use nu_path::Path;

assert_eq!("foo", Path::new("foo.rs").file_stem().unwrap());
assert_eq!("foo.tar", Path::new("foo.tar.gz").file_stem().unwrap());

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

Extracts the extension (without the leading dot) of self.file_name, if possible.

The extension is:

• None, if there is no file name;
• None, if there is no embedded .;
• None, if the file name begins with . and has no other .s within;
• Otherwise, the portion of the file name after the final .

Examples

use nu_path::Path;

assert_eq!("rs", Path::new("foo.rs").extension().unwrap());
assert_eq!("gz", Path::new("foo.tar.gz").extension().unwrap());

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

Produces an iterator over the Components of the path.

When parsing the path, there is a small amount of normalization:

• Repeated separators are ignored, so a/b and a//b both have a and b as components.

• Occurrences of . are normalized away, except if they are at the beginning of the path. For example, a/./b, a/b/, a/b/. and a/b all have a and b as components, but ./a/b starts with an additional CurDir component.

• A trailing slash is normalized away, /a/b and /a/b/ are equivalent.

Note that no other normalization takes place; in particular, a/c and a/b/../c are distinct, to account for the possibility that b is a symbolic link (so its parent isn’t a).

Examples

use nu_path::Path;
use std::path::Component;
use std::ffi::OsStr;

let mut components = Path::new("/tmp/foo.txt").components();

assert_eq!(components.next(), Some(Component::RootDir));
assert_eq!(components.next(), Some(Component::Normal(OsStr::new("tmp"))));
assert_eq!(components.next(), Some(Component::Normal(OsStr::new("foo.txt"))));
assert_eq!(components.next(), None)

pub fn iter(&self) -> Iter<'_>

Produces an iterator over the path’s components viewed as OsStr slices.

For more information about the particulars of how the path is separated into components, see components.

Examples

use nu_path::Path;
use std::ffi::OsStr;

let mut it = Path::new("/tmp/foo.txt").iter();
assert_eq!(it.next(), Some(OsStr::new(&std::path::MAIN_SEPARATOR.to_string())));
assert_eq!(it.next(), Some(OsStr::new("tmp")));
assert_eq!(it.next(), Some(OsStr::new("foo.txt")));
assert_eq!(it.next(), None)

pub fn display(&self) -> Display<'_>

Returns an object that implements Display for safely printing paths that may contain non-Unicode data. This may perform lossy conversion, depending on the platform. If you would like an implementation which escapes the path please use Debug instead.

Examples

use nu_path::Path;

let path = Path::new("/tmp/foo.rs");

println!("{}", path.display());

pub fn cast<To>(&self) -> &Path<To>

where To: PathForm, Form: PathCast<To>,

Returns a reference to the same Path in a different form.

PathForms can be converted to one another based on PathCast implementations. Namely, the following form conversions are possible:

• Relative, Absolute, or Canonical into Any.
• Canonical into Absolute.
• Any form into itself.

Examples

use nu_path::{Path, RelativePath};

let relative = RelativePath::try_new("test.txt").unwrap();
let p: &Path = relative.cast();
assert_eq!(p, relative);

pub fn as_any(&self) -> &Path

Returns a reference to a path with its form as Any.

Examples

use nu_path::{Path, RelativePath};

let p = RelativePath::try_new("test.txt").unwrap();
assert_eq!(Path::new("test.txt"), p.as_any());

pub fn as_mut_os_str(&mut self) -> &mut OsStr

Returns a mutable reference to the underlying OsStr slice.

Examples

use nu_path::{Path, PathBuf};

let mut path = PathBuf::from("Foo.TXT");

assert_ne!(path, Path::new("foo.txt"));

path.as_mut_os_str().make_ascii_lowercase();
assert_eq!(path, Path::new("foo.txt"));

pub fn is_absolute(&self) -> bool

Returns true if the Path is absolute, i.e., if it is independent of the current directory.

• On Unix, a path is absolute if it starts with the root, so is_absolute and has_root are equivalent.

• On Windows, a path is absolute if it has a prefix and starts with the root: c:\windows is absolute, while c:temp and \temp are not.

Examples

use nu_path::Path;

assert!(!Path::new("foo.txt").is_absolute());

pub fn is_relative(&self) -> bool

See is_absolute’s documentation for more details.

Examples

use nu_path::Path;

assert!(Path::new("foo.txt").is_relative());

pub fn try_absolute(&self) -> Result<&AbsolutePath, &RelativePath>

Returns an Ok AbsolutePath if the Path is absolute. Otherwise, returns an Err RelativePath.

Examples

use nu_path::Path;

assert!(Path::new("test.txt").try_absolute().is_err());

pub fn try_relative(&self) -> Result<&RelativePath, &AbsolutePath>

Returns an Ok RelativePath if the Path is relative. Otherwise, returns an Err AbsolutePath.

Examples

use nu_path::Path;

assert!(Path::new("test.txt").try_relative().is_ok());

pub fn join(&self, path: impl AsRef<Path>) -> PathBuf<Form::Output>

Creates an owned PathBuf with path adjoined to self.

If path is absolute, it replaces the current path.

See PathBuf::push for more details on what it means to adjoin a path.

Examples

use nu_path::{Path, PathBuf};

assert_eq!(Path::new("/etc").join("passwd"), PathBuf::from("/etc/passwd"));
assert_eq!(Path::new("/etc").join("/bin/sh"), PathBuf::from("/bin/sh"));

pub fn with_file_name(&self, file_name: impl AsRef<OsStr>) -> PathBuf<Form>

Creates an owned PathBuf like self but with the given file name.

See PathBuf::set_file_name for more details.

Examples

use nu_path::{Path, PathBuf};

let path = Path::new("/tmp/foo.png");
assert_eq!(path.with_file_name("bar"), PathBuf::from("/tmp/bar"));
assert_eq!(path.with_file_name("bar.txt"), PathBuf::from("/tmp/bar.txt"));

let path = Path::new("/tmp");
assert_eq!(path.with_file_name("var"), PathBuf::from("/var"));

pub fn with_extension(&self, extension: impl AsRef<OsStr>) -> PathBuf<Form>

Creates an owned PathBuf like self but with the given extension.

See PathBuf::set_extension for more details.

Examples

use nu_path::{Path, PathBuf};

let path = Path::new("foo.rs");
assert_eq!(path.with_extension("txt"), PathBuf::from("foo.txt"));

let path = Path::new("foo.tar.gz");
assert_eq!(path.with_extension(""), PathBuf::from("foo.tar"));
assert_eq!(path.with_extension("xz"), PathBuf::from("foo.tar.xz"));
assert_eq!(path.with_extension("").with_extension("txt"), PathBuf::from("foo.txt"));

pub fn as_relative_std_path(&self) -> &Path

Returns the, potentially relative, underlying std::path::Path.

Note

Caution should be taken when using this function. Nushell keeps track of an emulated current working directory, and using the std::path::Path returned from this method will likely use std::env::current_dir to resolve the path instead of using the emulated current working directory.

Instead, you should probably join this path onto the emulated current working directory. Any AbsolutePath or CanonicalPath will also suffice.

Examples

use nu_path::Path;

let p = Path::new("test.txt");
assert_eq!(std::path::Path::new("test.txt"), p.as_relative_std_path());

pub fn has_root(&self) -> bool

• On Unix, a path has a root if it begins with /.

• On Windows, a path has a root if it:

  • has no prefix and begins with a separator, e.g., \windows
  • has a prefix followed by a separator, e.g., c:\windows but not c:windows
  • has any non-disk prefix, e.g., \\server\share

Examples

use nu_path::Path;

assert!(Path::new("/etc/passwd").has_root());

pub fn as_std_path(&self) -> &Path

Returns the underlying std::path::Path.

Examples

use nu_path::AbsolutePath;

let p = AbsolutePath::try_new("/test").unwrap();
assert_eq!(std::path::Path::new("/test"), p.as_std_path());

pub fn to_std_path_buf(&self) -> PathBuf

Converts a Path to an owned std::path::PathBuf.

Examples

use nu_path::AbsolutePath;

let path = AbsolutePath::try_new("/foo").unwrap();
assert_eq!(path.to_std_path_buf(), std::path::PathBuf::from("/foo"));

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

Queries the file system to get information about a file, directory, etc.

This function will traverse symbolic links to query information about the destination file.

This is an alias to std::fs::metadata.

Examples

use nu_path::AbsolutePath;

let path = AbsolutePath::try_new("/Minas/tirith").unwrap();
let metadata = path.metadata().expect("metadata call failed");
println!("{:?}", metadata.file_type());

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

Returns an iterator over the entries within a directory.

The iterator will yield instances of io::Result<fs::DirEntry>. New errors may be encountered after an iterator is initially constructed.

This is an alias to std::fs::read_dir.

Examples

use nu_path::AbsolutePath;

let path = AbsolutePath::try_new("/laputa").unwrap();
for entry in path.read_dir().expect("read_dir call failed") {
    if let Ok(entry) = entry {
        println!("{:?}", entry.path());
    }
}

pub fn exists(&self) -> bool

Returns true if the path points at an existing entity.

Warning: this method may be error-prone, consider using try_exists instead! It also has a risk of introducing time-of-check to time-of-use (TOCTOU) bugs.

This function will traverse symbolic links to query information about the destination file.

If you cannot access the metadata of the file, e.g. because of a permission error or broken symbolic links, this will return false.

Examples

use nu_path::AbsolutePath;

let path = AbsolutePath::try_new("/does_not_exist").unwrap();
assert!(!path.exists());

pub fn is_file(&self) -> bool

Returns true if the path exists on disk and is pointing at a regular file.

This function will traverse symbolic links to query information about the destination file.

If you cannot access the metadata of the file, e.g. because of a permission error or broken symbolic links, this will return false.

Examples

use nu_path::AbsolutePath;

let path = AbsolutePath::try_new("/is_a_directory/").unwrap();
assert_eq!(path.is_file(), false);

let path = AbsolutePath::try_new("/a_file.txt").unwrap();
assert_eq!(path.is_file(), true);

See Also

When the goal is simply to read from (or write to) the source, the most reliable way to test the source can be read (or written to) is to open it. Only using is_file can break workflows like diff <( prog_a ) on a Unix-like system for example. See std::fs::File::open or std::fs::OpenOptions::open for more information.

pub fn is_dir(&self) -> bool

Returns true if the path exists on disk and is pointing at a directory.

This function will traverse symbolic links to query information about the destination file.

If you cannot access the metadata of the file, e.g. because of a permission error or broken symbolic links, this will return false.

Examples

use nu_path::AbsolutePath;

let path = AbsolutePath::try_new("/is_a_directory/").unwrap();
assert_eq!(path.is_dir(), true);

let path = AbsolutePath::try_new("/a_file.txt").unwrap();
assert_eq!(path.is_dir(), false);

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

Returns the canonical, absolute form of the path with all intermediate components normalized and symbolic links resolved.

On Windows, this will also simplify to a winuser path.

This is an alias to std::fs::canonicalize.

Examples

use nu_path::{AbsolutePath, PathBuf};

let path = AbsolutePath::try_new("/foo/test/../test/bar.rs").unwrap();
assert_eq!(path.canonicalize().unwrap(), PathBuf::from("/foo/test/bar.rs"));

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

Reads a symbolic link, returning the file that the link points to.

This is an alias to std::fs::read_link.

Examples

use nu_path::AbsolutePath;

let path = AbsolutePath::try_new("/laputa/sky_castle.rs").unwrap();
let path_link = path.read_link().expect("read_link call failed");

pub fn try_exists(&self) -> Result<bool>

Returns Ok(true) if the path points at an existing entity.

This function will traverse symbolic links to query information about the destination file. In case of broken symbolic links this will return Ok(false).

Path::exists only checks whether or not a path was both found and readable. By contrast, try_exists will return Ok(true) or Ok(false), respectively, if the path was verified to exist or not exist. If its existence can neither be confirmed nor denied, it will propagate an Err instead. This can be the case if e.g. listing permission is denied on one of the parent directories.

Note that while this avoids some pitfalls of the exists method, it still can not prevent time-of-check to time-of-use (TOCTOU) bugs. You should only use it in scenarios where those bugs are not an issue.

Examples

use nu_path::AbsolutePath;

let path = AbsolutePath::try_new("/does_not_exist").unwrap();
assert!(!path.try_exists().unwrap());

let path = AbsolutePath::try_new("/root/secret_file.txt").unwrap();
assert!(path.try_exists().is_err());

pub fn is_symlink(&self) -> bool

Returns true if the path exists on disk and is pointing at a symbolic link.

This function will not traverse symbolic links. In case of a broken symbolic link this will also return true.

If you cannot access the directory containing the file, e.g., because of a permission error, this will return false.

Examples

use nu_path::AbsolutePath;
use std::os::unix::fs::symlink;

let link_path = AbsolutePath::try_new("/link").unwrap();
symlink("/origin_does_not_exist/", link_path).unwrap();
assert_eq!(link_path.is_symlink(), true);
assert_eq!(link_path.exists(), false);

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

Queries the metadata about a file without following symlinks.

This is an alias to std::fs::symlink_metadata.

Examples

use nu_path::AbsolutePath;

let path = AbsolutePath::try_new("/Minas/tirith").unwrap();
let metadata = path.symlink_metadata().expect("symlink_metadata call failed");
println!("{:?}", metadata.file_type());

pub fn as_absolute(&self) -> &AbsolutePath

Returns a CanonicalPath as a AbsolutePath.

Examples

use nu_path::AbsolutePath;

let absolute = AbsolutePath::try_new("/test").unwrap();
let p = absolute.canonicalize().unwrap();
assert_eq!(absolute, p.as_absolute());

Trait Implementations

impl<Form: PathForm> AsRef<OsStr> for PathBuf<Form>

fn as_ref(&self) -> &OsStr

Converts this type into a shared reference of the (usually inferred) input type.

impl<From: PathCast<To>, To: PathForm> AsRef<Path<To>> for PathBuf<From>

fn as_ref(&self) -> &Path<To>

Converts this type into a shared reference of the (usually inferred) input type.

impl<Form: IsAbsolute> AsRef<Path> for PathBuf<Form>

fn as_ref(&self) -> &Path

Converts this type into a shared reference of the (usually inferred) input type.

impl<From: PathCast<To>, To: PathForm> Borrow<Path<To>> for PathBuf<From>

fn borrow(&self) -> &Path<To>

Immutably borrows from an owned value.

impl<Form: IsAbsolute> Borrow<Path> for PathBuf<Form>

fn borrow(&self) -> &Path

Immutably borrows from an owned value.

impl<Form: PathForm> Clone for PathBuf<Form>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Form: PathForm> Debug for PathBuf<Form>

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

Formats the value using the given formatter.

impl Default for PathBuf

fn default() -> Self

Returns the “default value” for a type.

impl<Form: PathForm> Deref for PathBuf<Form>

type Target = Path<Form>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for PathBuf

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<P: AsRef<Path>> Extend<P> for PathBuf

fn extend<T: IntoIterator<Item = P>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<'a, Form: IsAbsolute> From<&'a PathBuf<Form>> for Cow<'a, Path>

fn from(buf: &'a PathBuf<Form>) -> Self

Converts to this type from the input type.

impl<'a, Source: PathCast<To>, To: PathForm> From<&'a PathBuf<Source>> for Cow<'a, Path<To>>

fn from(buf: &'a PathBuf<Source>) -> Self

Converts to this type from the input type.

impl<T: ?Sized + AsRef<OsStr>> From<&T> for PathBuf

fn from(s: &T) -> Self

Converts to this type from the input type.

impl From<Box<Path<Absolute>>> for PathBuf

fn from(path: Box<AbsolutePath>) -> Self

Converts to this type from the input type.

impl From<Box<Path<Canonical>>> for PathBuf

fn from(path: Box<CanonicalPath>) -> Self

Converts to this type from the input type.

impl<Form: PathForm> From<Box<Path<Form>>> for PathBuf<Form>

fn from(path: Box<Path<Form>>) -> Self

Converts to this type from the input type.

impl From<Box<Path<Relative>>> for PathBuf

fn from(path: Box<RelativePath>) -> Self

Converts to this type from the input type.

impl From<Box<Path>> for PathBuf

fn from(path: Box<Path>) -> Self

Converts to this type from the input type.

impl From<Cow<'_, Path<Absolute>>> for PathBuf

fn from(cow: Cow<'_, AbsolutePath>) -> Self

Converts to this type from the input type.

impl From<Cow<'_, Path<Canonical>>> for PathBuf

fn from(cow: Cow<'_, CanonicalPath>) -> Self

Converts to this type from the input type.

impl<Form: PathForm> From<Cow<'_, Path<Form>>> for PathBuf<Form>

fn from(cow: Cow<'_, Path<Form>>) -> Self

Converts to this type from the input type.

impl From<Cow<'_, Path<Relative>>> for PathBuf

fn from(cow: Cow<'_, RelativePath>) -> Self

Converts to this type from the input type.

impl From<Cow<'_, Path>> for PathBuf

fn from(cow: Cow<'_, Path>) -> Self

Converts to this type from the input type.

impl From<OsString> for PathBuf

fn from(s: OsString) -> Self

Converts to this type from the input type.

impl From<PathBuf<Absolute>> for Arc<Path>

fn from(buf: AbsolutePathBuf) -> Self

Converts to this type from the input type.

impl From<PathBuf<Absolute>> for Box<Path>

fn from(buf: AbsolutePathBuf) -> Self

Converts to this type from the input type.

impl From<PathBuf<Absolute>> for Cow<'_, Path>

fn from(buf: AbsolutePathBuf) -> Self

Converts to this type from the input type.

impl From<PathBuf<Absolute>> for PathBuf

fn from(buf: AbsolutePathBuf) -> Self

Converts to this type from the input type.

impl From<PathBuf<Absolute>> for Rc<Path>

fn from(buf: AbsolutePathBuf) -> Self

Converts to this type from the input type.

impl From<PathBuf<Canonical>> for Arc<AbsolutePath>

fn from(buf: CanonicalPathBuf) -> Self

Converts to this type from the input type.

impl From<PathBuf<Canonical>> for Arc<Path>

fn from(buf: CanonicalPathBuf) -> Self

Converts to this type from the input type.

impl From<PathBuf<Canonical>> for Box<AbsolutePath>

fn from(buf: CanonicalPathBuf) -> Self

Converts to this type from the input type.

impl From<PathBuf<Canonical>> for Box<Path>

fn from(buf: CanonicalPathBuf) -> Self

Converts to this type from the input type.

impl From<PathBuf<Canonical>> for Cow<'_, AbsolutePath>

fn from(buf: CanonicalPathBuf) -> Self

Converts to this type from the input type.

impl From<PathBuf<Canonical>> for Cow<'_, Path>

fn from(buf: CanonicalPathBuf) -> Self

Converts to this type from the input type.

impl From<PathBuf<Canonical>> for PathBuf

fn from(buf: CanonicalPathBuf) -> Self

Converts to this type from the input type.

impl From<PathBuf<Canonical>> for AbsolutePathBuf

fn from(buf: CanonicalPathBuf) -> Self

Converts to this type from the input type.

impl From<PathBuf<Canonical>> for Rc<AbsolutePath>

fn from(buf: CanonicalPathBuf) -> Self

Converts to this type from the input type.

impl From<PathBuf<Canonical>> for Rc<Path>

fn from(buf: CanonicalPathBuf) -> Self

Converts to this type from the input type.

impl<Form: PathForm> From<PathBuf<Form>> for Arc<Path<Form>>

fn from(buf: PathBuf<Form>) -> Self

Converts to this type from the input type.

impl<Form: IsAbsolute> From<PathBuf<Form>> for Arc<Path>

fn from(buf: PathBuf<Form>) -> Self

Converts to this type from the input type.

impl<Form: PathForm> From<PathBuf<Form>> for Box<Path<Form>>

fn from(buf: PathBuf<Form>) -> Self

Converts to this type from the input type.

impl<Form: IsAbsolute> From<PathBuf<Form>> for Box<Path>

fn from(buf: PathBuf<Form>) -> Self

Converts to this type from the input type.

impl<Form: PathForm> From<PathBuf<Form>> for Cow<'_, Path<Form>>

fn from(buf: PathBuf<Form>) -> Self

Converts to this type from the input type.

impl<Form: IsAbsolute> From<PathBuf<Form>> for Cow<'_, Path>

fn from(buf: PathBuf<Form>) -> Self

Converts to this type from the input type.

impl<Form: PathForm> From<PathBuf<Form>> for OsString

fn from(buf: PathBuf<Form>) -> Self

Converts to this type from the input type.

impl<Form: IsAbsolute> From<PathBuf<Form>> for PathBuf

fn from(buf: PathBuf<Form>) -> Self

Converts to this type from the input type.

impl<Form: PathForm> From<PathBuf<Form>> for Rc<Path<Form>>

fn from(buf: PathBuf<Form>) -> Self

Converts to this type from the input type.

impl<Form: IsAbsolute> From<PathBuf<Form>> for Rc<Path>

fn from(buf: PathBuf<Form>) -> Self

Converts to this type from the input type.

impl From<PathBuf<Relative>> for Arc<Path>

fn from(buf: RelativePathBuf) -> Self

Converts to this type from the input type.

impl From<PathBuf<Relative>> for Box<Path>

fn from(buf: RelativePathBuf) -> Self

Converts to this type from the input type.

impl From<PathBuf<Relative>> for Cow<'_, Path>

fn from(buf: RelativePathBuf) -> Self

Converts to this type from the input type.

impl From<PathBuf<Relative>> for PathBuf

fn from(buf: RelativePathBuf) -> Self

Converts to this type from the input type.

impl From<PathBuf<Relative>> for Rc<Path>

fn from(buf: RelativePathBuf) -> Self

Converts to this type from the input type.

impl From<PathBuf> for PathBuf

fn from(buf: PathBuf) -> Self

Converts to this type from the input type.

impl From<String> for PathBuf

fn from(s: String) -> Self

Converts to this type from the input type.

impl<P: AsRef<Path>> FromIterator<P> for PathBuf

fn from_iter<T: IntoIterator<Item = P>>(iter: T) -> Self

Creates a value from an iterator.

impl FromStr for PathBuf

type Err = Infallible

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl<Form: PathForm> Hash for PathBuf<Form>

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<'a, Form: PathForm> IntoIterator for &'a PathBuf<Form>

type Item = &'a OsStr

The type of the elements being iterated over.

type IntoIter = Iter<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<Form: PathForm> Ord for PathBuf<Form>

fn cmp(&self, other: &Self) -> 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<'a, Form: PathForm> PartialEq<&'a OsStr> for PathBuf<Form>

fn eq(&self, other: &&'a OsStr) -> 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<'a> PartialEq<&'a Path<Absolute>> for PathBuf

fn eq(&self, other: &&'a AbsolutePath) -> 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<'a> PartialEq<&'a Path<Canonical>> for PathBuf

fn eq(&self, other: &&'a CanonicalPath) -> 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<'a, Form: PathForm> PartialEq<&'a Path<Form>> for PathBuf<Form>

fn eq(&self, other: &&'a Path<Form>) -> 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<'a> PartialEq<&'a Path<Relative>> for PathBuf

fn eq(&self, other: &&'a RelativePath) -> 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<'a, Form: PathForm> PartialEq<&'a Path> for PathBuf<Form>

fn eq(&self, other: &&'a Path) -> 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<'a, Form: PathForm> PartialEq<Cow<'a, OsStr>> for PathBuf<Form>

fn eq(&self, other: &Cow<'a, OsStr>) -> 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<'a> PartialEq<Cow<'a, Path<Absolute>>> for PathBuf

fn eq(&self, other: &Cow<'a, AbsolutePath>) -> 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<'a> PartialEq<Cow<'a, Path<Canonical>>> for PathBuf

fn eq(&self, other: &Cow<'a, CanonicalPath>) -> 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<'a, Form: PathForm> PartialEq<Cow<'a, Path<Form>>> for PathBuf<Form>

fn eq(&self, other: &Cow<'a, Path<Form>>) -> 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<'a> PartialEq<Cow<'a, Path<Relative>>> for PathBuf

fn eq(&self, other: &Cow<'a, RelativePath>) -> 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<'a, Form: PathForm> PartialEq<Cow<'a, Path>> for PathBuf<Form>

fn eq(&self, other: &Cow<'a, Path>) -> 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<Form: PathForm> PartialEq<OsStr> for PathBuf<Form>

fn eq(&self, other: &OsStr) -> 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<Form: PathForm> PartialEq<OsString> for PathBuf<Form>

fn eq(&self, other: &OsString) -> 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 PartialEq<Path<Absolute>> for PathBuf

fn eq(&self, other: &AbsolutePath) -> 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 PartialEq<Path<Canonical>> for PathBuf

fn eq(&self, other: &CanonicalPath) -> 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<Form: PathForm> PartialEq<Path<Form>> for PathBuf<Form>

fn eq(&self, other: &Path<Form>) -> 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 PartialEq<Path<Relative>> for PathBuf

fn eq(&self, other: &RelativePath) -> 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<Form: PathForm> PartialEq<Path> for PathBuf<Form>

fn eq(&self, other: &Path) -> 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<'a> PartialEq<PathBuf<Absolute>> for &'a Path

fn eq(&self, other: &AbsolutePathBuf) -> 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<'a> PartialEq<PathBuf<Absolute>> for &'a CanonicalPath

fn eq(&self, other: &AbsolutePathBuf) -> 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<'a> PartialEq<PathBuf<Absolute>> for Cow<'a, CanonicalPath>

fn eq(&self, other: &AbsolutePathBuf) -> 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<'a> PartialEq<PathBuf<Absolute>> for Cow<'a, Path>

fn eq(&self, other: &AbsolutePathBuf) -> 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 PartialEq<PathBuf<Absolute>> for Path

fn eq(&self, other: &AbsolutePathBuf) -> 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 PartialEq<PathBuf<Absolute>> for CanonicalPath

fn eq(&self, other: &AbsolutePathBuf) -> 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 PartialEq<PathBuf<Absolute>> for PathBuf

fn eq(&self, other: &AbsolutePathBuf) -> 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 PartialEq<PathBuf<Absolute>> for CanonicalPathBuf

fn eq(&self, other: &AbsolutePathBuf) -> 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<'a> PartialEq<PathBuf<Canonical>> for &'a Path

fn eq(&self, other: &CanonicalPathBuf) -> 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<'a> PartialEq<PathBuf<Canonical>> for &'a AbsolutePath

fn eq(&self, other: &CanonicalPathBuf) -> 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<'a> PartialEq<PathBuf<Canonical>> for Cow<'a, AbsolutePath>

fn eq(&self, other: &CanonicalPathBuf) -> 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<'a> PartialEq<PathBuf<Canonical>> for Cow<'a, Path>

fn eq(&self, other: &CanonicalPathBuf) -> 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 PartialEq<PathBuf<Canonical>> for Path

fn eq(&self, other: &CanonicalPathBuf) -> 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 PartialEq<PathBuf<Canonical>> for AbsolutePath

fn eq(&self, other: &CanonicalPathBuf) -> 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 PartialEq<PathBuf<Canonical>> for PathBuf

fn eq(&self, other: &CanonicalPathBuf) -> 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 PartialEq<PathBuf<Canonical>> for AbsolutePathBuf

fn eq(&self, other: &CanonicalPathBuf) -> 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<'a, Form: PathForm> PartialEq<PathBuf<Form>> for &'a OsStr

fn eq(&self, other: &PathBuf<Form>) -> 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<'a, Form: PathForm> PartialEq<PathBuf<Form>> for &'a Path

fn eq(&self, other: &PathBuf<Form>) -> 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<'a, Form: PathForm> PartialEq<PathBuf<Form>> for &'a Path<Form>

fn eq(&self, other: &PathBuf<Form>) -> 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<'a, Form: PathForm> PartialEq<PathBuf<Form>> for Cow<'a, OsStr>

fn eq(&self, other: &PathBuf<Form>) -> 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<'a, Form: PathForm> PartialEq<PathBuf<Form>> for Cow<'a, Path<Form>>

fn eq(&self, other: &PathBuf<Form>) -> 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<'a, Form: PathForm> PartialEq<PathBuf<Form>> for Cow<'a, Path>

fn eq(&self, other: &PathBuf<Form>) -> 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<Form: PathForm> PartialEq<PathBuf<Form>> for OsStr

fn eq(&self, other: &PathBuf<Form>) -> 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<Form: PathForm> PartialEq<PathBuf<Form>> for OsString

fn eq(&self, other: &PathBuf<Form>) -> 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<Form: PathForm> PartialEq<PathBuf<Form>> for Path

fn eq(&self, other: &PathBuf<Form>) -> 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<Form: PathForm> PartialEq<PathBuf<Form>> for Path<Form>

fn eq(&self, other: &PathBuf<Form>) -> 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<Form: PathForm> PartialEq<PathBuf<Form>> for PathBuf

fn eq(&self, other: &PathBuf<Form>) -> 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<'a> PartialEq<PathBuf<Relative>> for &'a Path

fn eq(&self, other: &RelativePathBuf) -> 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<'a> PartialEq<PathBuf<Relative>> for Cow<'a, Path>

fn eq(&self, other: &RelativePathBuf) -> 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 PartialEq<PathBuf<Relative>> for Path

fn eq(&self, other: &RelativePathBuf) -> 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 PartialEq<PathBuf<Relative>> for PathBuf

fn eq(&self, other: &RelativePathBuf) -> 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<'a> PartialEq<PathBuf> for &'a AbsolutePath

fn eq(&self, other: &PathBuf) -> 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<'a> PartialEq<PathBuf> for &'a CanonicalPath

fn eq(&self, other: &PathBuf) -> 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<'a> PartialEq<PathBuf> for &'a RelativePath

fn eq(&self, other: &PathBuf) -> 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<'a> PartialEq<PathBuf> for Cow<'a, AbsolutePath>

fn eq(&self, other: &PathBuf) -> 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<'a> PartialEq<PathBuf> for Cow<'a, CanonicalPath>

fn eq(&self, other: &PathBuf) -> 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<'a> PartialEq<PathBuf> for Cow<'a, RelativePath>

fn eq(&self, other: &PathBuf) -> 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 PartialEq<PathBuf> for AbsolutePath

fn eq(&self, other: &PathBuf) -> 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 PartialEq<PathBuf> for CanonicalPath

fn eq(&self, other: &PathBuf) -> 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 PartialEq<PathBuf> for RelativePath

fn eq(&self, other: &PathBuf) -> 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 PartialEq<PathBuf> for AbsolutePathBuf

fn eq(&self, other: &PathBuf) -> 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 PartialEq<PathBuf> for CanonicalPathBuf

fn eq(&self, other: &PathBuf) -> 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<Form: PathForm> PartialEq<PathBuf> for PathBuf<Form>

fn eq(&self, other: &PathBuf) -> 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 PartialEq<PathBuf> for RelativePathBuf

fn eq(&self, other: &PathBuf) -> 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<Form: PathForm> PartialEq for PathBuf<Form>

fn eq(&self, other: &Self) -> 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<'a, Form: PathForm> PartialOrd<&'a OsStr> for PathBuf<Form>

fn partial_cmp(&self, other: &&'a OsStr) -> 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<'a> PartialOrd<&'a Path<Absolute>> for PathBuf

fn partial_cmp(&self, other: &&'a AbsolutePath) -> 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<'a> PartialOrd<&'a Path<Canonical>> for PathBuf

fn partial_cmp(&self, other: &&'a CanonicalPath) -> 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<'a, Form: PathForm> PartialOrd<&'a Path<Form>> for PathBuf<Form>

fn partial_cmp(&self, other: &&'a Path<Form>) -> 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<'a> PartialOrd<&'a Path<Relative>> for PathBuf

fn partial_cmp(&self, other: &&'a RelativePath) -> 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<'a, Form: PathForm> PartialOrd<&'a Path> for PathBuf<Form>

fn partial_cmp(&self, other: &&'a Path) -> 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<'a, Form: PathForm> PartialOrd<Cow<'a, OsStr>> for PathBuf<Form>

fn partial_cmp(&self, other: &Cow<'a, OsStr>) -> 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<'a> PartialOrd<Cow<'a, Path<Absolute>>> for PathBuf

fn partial_cmp(&self, other: &Cow<'a, AbsolutePath>) -> 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<'a> PartialOrd<Cow<'a, Path<Canonical>>> for PathBuf

fn partial_cmp(&self, other: &Cow<'a, CanonicalPath>) -> 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<'a, Form: PathForm> PartialOrd<Cow<'a, Path<Form>>> for PathBuf<Form>

fn partial_cmp(&self, other: &Cow<'a, Path<Form>>) -> 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<'a> PartialOrd<Cow<'a, Path<Relative>>> for PathBuf

fn partial_cmp(&self, other: &Cow<'a, RelativePath>) -> 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<'a, Form: PathForm> PartialOrd<Cow<'a, Path>> for PathBuf<Form>

fn partial_cmp(&self, other: &Cow<'a, Path>) -> 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<Form: PathForm> PartialOrd<OsStr> for PathBuf<Form>

fn partial_cmp(&self, other: &OsStr) -> 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<Form: PathForm> PartialOrd<OsString> for PathBuf<Form>

fn partial_cmp(&self, other: &OsString) -> 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 PartialOrd<Path<Absolute>> for PathBuf

fn partial_cmp(&self, other: &AbsolutePath) -> 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 PartialOrd<Path<Canonical>> for PathBuf

fn partial_cmp(&self, other: &CanonicalPath) -> 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<Form: PathForm> PartialOrd<Path<Form>> for PathBuf<Form>

fn partial_cmp(&self, other: &Path<Form>) -> 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 PartialOrd<Path<Relative>> for PathBuf

fn partial_cmp(&self, other: &RelativePath) -> 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<Form: PathForm> PartialOrd<Path> for PathBuf<Form>

fn partial_cmp(&self, other: &Path) -> 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<'a> PartialOrd<PathBuf<Absolute>> for &'a Path

fn partial_cmp(&self, other: &AbsolutePathBuf) -> 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<'a> PartialOrd<PathBuf<Absolute>> for &'a CanonicalPath

fn partial_cmp(&self, other: &AbsolutePathBuf) -> 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<'a> PartialOrd<PathBuf<Absolute>> for Cow<'a, CanonicalPath>

fn partial_cmp(&self, other: &AbsolutePathBuf) -> 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<'a> PartialOrd<PathBuf<Absolute>> for Cow<'a, Path>

fn partial_cmp(&self, other: &AbsolutePathBuf) -> 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 PartialOrd<PathBuf<Absolute>> for Path

fn partial_cmp(&self, other: &AbsolutePathBuf) -> 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 PartialOrd<PathBuf<Absolute>> for CanonicalPath

fn partial_cmp(&self, other: &AbsolutePathBuf) -> 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 PartialOrd<PathBuf<Absolute>> for PathBuf

fn partial_cmp(&self, other: &AbsolutePathBuf) -> 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 PartialOrd<PathBuf<Absolute>> for CanonicalPathBuf

fn partial_cmp(&self, other: &AbsolutePathBuf) -> 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<'a> PartialOrd<PathBuf<Canonical>> for &'a Path

fn partial_cmp(&self, other: &CanonicalPathBuf) -> 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<'a> PartialOrd<PathBuf<Canonical>> for &'a AbsolutePath

fn partial_cmp(&self, other: &CanonicalPathBuf) -> 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<'a> PartialOrd<PathBuf<Canonical>> for Cow<'a, AbsolutePath>

fn partial_cmp(&self, other: &CanonicalPathBuf) -> 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<'a> PartialOrd<PathBuf<Canonical>> for Cow<'a, Path>

fn partial_cmp(&self, other: &CanonicalPathBuf) -> 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 PartialOrd<PathBuf<Canonical>> for Path

fn partial_cmp(&self, other: &CanonicalPathBuf) -> 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 PartialOrd<PathBuf<Canonical>> for AbsolutePath

fn partial_cmp(&self, other: &CanonicalPathBuf) -> 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 PartialOrd<PathBuf<Canonical>> for PathBuf

fn partial_cmp(&self, other: &CanonicalPathBuf) -> 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 PartialOrd<PathBuf<Canonical>> for AbsolutePathBuf

fn partial_cmp(&self, other: &CanonicalPathBuf) -> 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<'a, Form: PathForm> PartialOrd<PathBuf<Form>> for &'a OsStr

fn partial_cmp(&self, other: &PathBuf<Form>) -> 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<'a, Form: PathForm> PartialOrd<PathBuf<Form>> for &'a Path

fn partial_cmp(&self, other: &PathBuf<Form>) -> 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<'a, Form: PathForm> PartialOrd<PathBuf<Form>> for &'a Path<Form>

fn partial_cmp(&self, other: &PathBuf<Form>) -> 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<'a, Form: PathForm> PartialOrd<PathBuf<Form>> for Cow<'a, OsStr>

fn partial_cmp(&self, other: &PathBuf<Form>) -> 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<'a, Form: PathForm> PartialOrd<PathBuf<Form>> for Cow<'a, Path<Form>>

fn partial_cmp(&self, other: &PathBuf<Form>) -> 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<'a, Form: PathForm> PartialOrd<PathBuf<Form>> for Cow<'a, Path>

fn partial_cmp(&self, other: &PathBuf<Form>) -> 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<Form: PathForm> PartialOrd<PathBuf<Form>> for OsStr

fn partial_cmp(&self, other: &PathBuf<Form>) -> 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<Form: PathForm> PartialOrd<PathBuf<Form>> for OsString

fn partial_cmp(&self, other: &PathBuf<Form>) -> 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<Form: PathForm> PartialOrd<PathBuf<Form>> for Path

fn partial_cmp(&self, other: &PathBuf<Form>) -> 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<Form: PathForm> PartialOrd<PathBuf<Form>> for Path<Form>

fn partial_cmp(&self, other: &PathBuf<Form>) -> 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<Form: PathForm> PartialOrd<PathBuf<Form>> for PathBuf

fn partial_cmp(&self, other: &PathBuf<Form>) -> 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<'a> PartialOrd<PathBuf<Relative>> for &'a Path

fn partial_cmp(&self, other: &RelativePathBuf) -> 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<'a> PartialOrd<PathBuf<Relative>> for Cow<'a, Path>

fn partial_cmp(&self, other: &RelativePathBuf) -> 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 PartialOrd<PathBuf<Relative>> for Path

fn partial_cmp(&self, other: &RelativePathBuf) -> 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 PartialOrd<PathBuf<Relative>> for PathBuf

fn partial_cmp(&self, other: &RelativePathBuf) -> 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<'a> PartialOrd<PathBuf> for &'a AbsolutePath

fn partial_cmp(&self, other: &PathBuf) -> 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<'a> PartialOrd<PathBuf> for &'a CanonicalPath

fn partial_cmp(&self, other: &PathBuf) -> 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<'a> PartialOrd<PathBuf> for &'a RelativePath

fn partial_cmp(&self, other: &PathBuf) -> 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<'a> PartialOrd<PathBuf> for Cow<'a, AbsolutePath>

fn partial_cmp(&self, other: &PathBuf) -> 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<'a> PartialOrd<PathBuf> for Cow<'a, CanonicalPath>

fn partial_cmp(&self, other: &PathBuf) -> 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<'a> PartialOrd<PathBuf> for Cow<'a, RelativePath>

fn partial_cmp(&self, other: &PathBuf) -> 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 PartialOrd<PathBuf> for AbsolutePath

fn partial_cmp(&self, other: &PathBuf) -> 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 PartialOrd<PathBuf> for CanonicalPath

fn partial_cmp(&self, other: &PathBuf) -> 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 PartialOrd<PathBuf> for RelativePath

fn partial_cmp(&self, other: &PathBuf) -> 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 PartialOrd<PathBuf> for AbsolutePathBuf

fn partial_cmp(&self, other: &PathBuf) -> 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 PartialOrd<PathBuf> for CanonicalPathBuf

fn partial_cmp(&self, other: &PathBuf) -> 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<Form: PathForm> PartialOrd<PathBuf> for PathBuf<Form>

fn partial_cmp(&self, other: &PathBuf) -> 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 PartialOrd<PathBuf> for RelativePathBuf

fn partial_cmp(&self, other: &PathBuf) -> 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<Form: PathForm> PartialOrd for PathBuf<Form>

fn partial_cmp(&self, other: &Self) -> 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<'a> TryFrom<&'a PathBuf> for &'a AbsolutePath

type Error = TryAbsoluteError

The type returned in the event of a conversion error.

fn try_from(buf: &'a PathBuf) -> Result<Self, Self::Error>

Performs the conversion.

impl<'a> TryFrom<&'a PathBuf> for &'a RelativePath

type Error = TryRelativeError

The type returned in the event of a conversion error.

fn try_from(buf: &'a PathBuf) -> Result<Self, Self::Error>

Performs the conversion.

impl<'a> TryFrom<&'a PathBuf> for Cow<'a, AbsolutePath>

type Error = TryAbsoluteError

The type returned in the event of a conversion error.

fn try_from(path: &'a PathBuf) -> Result<Self, Self::Error>

Performs the conversion.

impl<'a> TryFrom<&'a PathBuf> for Cow<'a, RelativePath>

type Error = TryRelativeError

The type returned in the event of a conversion error.

fn try_from(path: &'a PathBuf) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<&PathBuf> for AbsolutePathBuf

type Error = TryAbsoluteError

The type returned in the event of a conversion error.

fn try_from(path: &PathBuf) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<&PathBuf> for RelativePathBuf

type Error = TryRelativeError

The type returned in the event of a conversion error.

fn try_from(path: &PathBuf) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<PathBuf> for Box<AbsolutePath>

type Error = PathBuf

The type returned in the event of a conversion error.

fn try_from(buf: PathBuf) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<PathBuf> for Box<RelativePath>

type Error = PathBuf

The type returned in the event of a conversion error.

fn try_from(buf: PathBuf) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<PathBuf> for AbsolutePathBuf

type Error = PathBuf

The type returned in the event of a conversion error.

fn try_from(buf: PathBuf) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<PathBuf> for RelativePathBuf

type Error = PathBuf

The type returned in the event of a conversion error.

fn try_from(buf: PathBuf) -> Result<Self, Self::Error>

Performs the conversion.

impl<Form: PathForm> Eq for PathBuf<Form>