Struct relative_path::RelativePath

source ·
pub struct RelativePath { /* private fields */ }
Expand description

A borrowed, immutable relative path.

Implementations§

source§

impl RelativePath

source

pub fn new<S: AsRef<str> + ?Sized>(s: &S) -> &RelativePath

Directly wraps a string slice as a RelativePath slice.

source

pub fn from_path<P: ?Sized + AsRef<Path>>( path: &P ) -> Result<&RelativePath, FromPathError>

Try to convert a Path to a RelativePath without allocating a buffer.

§Errors

This requires the path to be a legal, platform-neutral relative path. Otherwise various forms of FromPathError will be returned as an Err.

§Examples
use relative_path::{RelativePath, FromPathErrorKind};

assert_eq!(
    Ok(RelativePath::new("foo/bar")),
    RelativePath::from_path("foo/bar")
);

// Note: absolute paths are different depending on platform.
if cfg!(windows) {
    let e = RelativePath::from_path("c:\\foo\\bar").unwrap_err();
    assert_eq!(FromPathErrorKind::NonRelative, e.kind());
}

if cfg!(unix) {
    let e = RelativePath::from_path("/foo/bar").unwrap_err();
    assert_eq!(FromPathErrorKind::NonRelative, e.kind());
}
source

pub fn as_str(&self) -> &str

Yields the underlying str slice.

§Examples
use relative_path::RelativePath;

assert_eq!(RelativePath::new("foo.txt").as_str(), "foo.txt");
source

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

👎Deprecated: RelativePath implements std::fmt::Display directly

Returns an object that implements Display.

§Examples
use relative_path::RelativePath;

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

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

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

Creates an owned RelativePathBuf with path adjoined to self.

§Examples
use relative_path::RelativePath;

let path = RelativePath::new("foo/bar");
assert_eq!("foo/bar/baz", path.join("baz"));
source

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

Iterate over all components in this relative path.

§Examples
use relative_path::{Component, RelativePath};

let path = RelativePath::new("foo/bar/baz");
let mut it = path.components();

assert_eq!(Some(Component::Normal("foo")), it.next());
assert_eq!(Some(Component::Normal("bar")), it.next());
assert_eq!(Some(Component::Normal("baz")), it.next());
assert_eq!(None, it.next());
source

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

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

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

§Examples
use relative_path::RelativePath;

let mut it = RelativePath::new("/tmp/foo.txt").iter();
assert_eq!(it.next(), Some("tmp"));
assert_eq!(it.next(), Some("foo.txt"));
assert_eq!(it.next(), None)
source

pub fn to_relative_path_buf(&self) -> RelativePathBuf

Convert to an owned RelativePathBuf.

source

pub fn to_path<P: AsRef<Path>>(&self, base: P) -> PathBuf

Build an owned PathBuf relative to base for the current relative path.

§Examples
use relative_path::RelativePath;
use std::path::Path;

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

let path = RelativePath::new("foo/bar").to_path("");
assert_eq!(Path::new("foo/bar"), path);
§Encoding an absolute path

Absolute paths are, in contrast to when using PathBuf::push ignored and will be added unchanged to the buffer.

This is to preserve the probability of a path conversion failing if the relative path contains platform-specific absolute path components.

use relative_path::RelativePath;
use std::path::Path;

if cfg!(windows) {
    let path = RelativePath::new("/bar/baz").to_path("foo");
    assert_eq!(Path::new("foo\\bar\\baz"), path);

    let path = RelativePath::new("c:\\bar\\baz").to_path("foo");
    assert_eq!(Path::new("foo\\c:\\bar\\baz"), path);
}

if cfg!(unix) {
    let path = RelativePath::new("/bar/baz").to_path("foo");
    assert_eq!(Path::new("foo/bar/baz"), path);

    let path = RelativePath::new("c:\\bar\\baz").to_path("foo");
    assert_eq!(Path::new("foo/c:\\bar\\baz"), path);
}
source

pub fn to_logical_path<P: AsRef<Path>>(&self, base: P) -> PathBuf

Build an owned PathBuf relative to base for the current relative path.

This is similar to to_path except that it doesn’t just unconditionally append one path to the other, instead it performs the following operations depending on its own components:

Note that the exact semantics of the path operation is determined by the corresponding PathBuf operation. E.g. popping a component off a path like . will result in an empty path.

use relative_path::RelativePath;
use std::path::Path;

let path = RelativePath::new("..").to_logical_path(".");
assert_eq!(path, Path::new(""));
§Examples
use relative_path::RelativePath;
use std::path::Path;

let path = RelativePath::new("..").to_logical_path("foo/bar");
assert_eq!(path, Path::new("foo"));
§Encoding an absolute path

Behaves the same as to_path when encoding absolute paths.

Absolute paths are, in contrast to when using PathBuf::push ignored and will be added unchanged to the buffer.

This is to preserve the probability of a path conversion failing if the relative path contains platform-specific absolute path components.

use relative_path::RelativePath;
use std::path::Path;

if cfg!(windows) {
    let path = RelativePath::new("/bar/baz").to_logical_path("foo");
    assert_eq!(Path::new("foo\\bar\\baz"), path);

    let path = RelativePath::new("c:\\bar\\baz").to_logical_path("foo");
    assert_eq!(Path::new("foo\\c:\\bar\\baz"), path);

    let path = RelativePath::new("foo/bar").to_logical_path("");
    assert_eq!(Path::new("foo\\bar"), path);
}

if cfg!(unix) {
    let path = RelativePath::new("/bar/baz").to_logical_path("foo");
    assert_eq!(Path::new("foo/bar/baz"), path);

    let path = RelativePath::new("c:\\bar\\baz").to_logical_path("foo");
    assert_eq!(Path::new("foo/c:\\bar\\baz"), path);

    let path = RelativePath::new("foo/bar").to_logical_path("");
    assert_eq!(Path::new("foo/bar"), path);
}
source

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

Returns a relative path, without its final Component if there is one.

§Examples
use relative_path::RelativePath;

assert_eq!(Some(RelativePath::new("foo")), RelativePath::new("foo/bar").parent());
assert_eq!(Some(RelativePath::new("")), RelativePath::new("foo").parent());
assert_eq!(None, RelativePath::new("").parent());
source

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

Returns the final component of the RelativePath, 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 relative_path::RelativePath;

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

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

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

§Errors

If base is not a prefix of self (i.e. starts_with returns false), returns Err.

§Examples
use relative_path::RelativePath;

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

assert_eq!(path.strip_prefix("test"), Ok(RelativePath::new("haha/foo.txt")));
assert_eq!(path.strip_prefix("test").is_ok(), true);
assert_eq!(path.strip_prefix("haha").is_ok(), false);
source

pub fn starts_with<P>(&self, base: P) -> bool
where P: AsRef<RelativePath>,

Determines whether base is a prefix of self.

Only considers whole path components to match.

§Examples
use relative_path::RelativePath;

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

assert!(path.starts_with("etc"));

assert!(!path.starts_with("e"));
source

pub fn ends_with<P>(&self, child: P) -> bool
where P: AsRef<RelativePath>,

Determines whether child is a suffix of self.

Only considers whole path components to match.

§Examples
use relative_path::RelativePath;

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

assert!(path.ends_with("passwd"));
source

pub fn is_normalized(&self) -> bool

Determines whether self is normalized.

§Examples
use relative_path::RelativePath;

// These are normalized.
assert!(RelativePath::new("").is_normalized());
assert!(RelativePath::new("baz.txt").is_normalized());
assert!(RelativePath::new("foo/bar/baz.txt").is_normalized());
assert!(RelativePath::new("..").is_normalized());
assert!(RelativePath::new("../..").is_normalized());
assert!(RelativePath::new("../../foo/bar/baz.txt").is_normalized());

// These are not normalized.
assert!(!RelativePath::new(".").is_normalized());
assert!(!RelativePath::new("./baz.txt").is_normalized());
assert!(!RelativePath::new("foo/..").is_normalized());
assert!(!RelativePath::new("foo/../baz.txt").is_normalized());
assert!(!RelativePath::new("foo/.").is_normalized());
assert!(!RelativePath::new("foo/./baz.txt").is_normalized());
assert!(!RelativePath::new("../foo/./bar/../baz.txt").is_normalized());
source

pub fn with_file_name<S: AsRef<str>>(&self, file_name: S) -> RelativePathBuf

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

See set_file_name for more details.

§Examples
use relative_path::{RelativePath, RelativePathBuf};

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

let path = RelativePath::new("tmp");
assert_eq!(path.with_file_name("var"), RelativePathBuf::from("var"));
source

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

Extracts the stem (non-extension) portion of 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 relative_path::RelativePath;

let path = RelativePath::new("foo.rs");

assert_eq!("foo", path.file_stem().unwrap());
source

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

Extracts the extension of 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 relative_path::RelativePath;

assert_eq!(Some("rs"), RelativePath::new("foo.rs").extension());
assert_eq!(None, RelativePath::new(".rs").extension());
assert_eq!(Some("rs"), RelativePath::new("foo.rs/.").extension());
source

pub fn with_extension<S: AsRef<str>>(&self, extension: S) -> RelativePathBuf

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

See set_extension for more details.

§Examples
use relative_path::{RelativePath, RelativePathBuf};

let path = RelativePath::new("foo.rs");
assert_eq!(path.with_extension("txt"), RelativePathBuf::from("foo.txt"));
source

pub fn join_normalized<P>(&self, path: P) -> RelativePathBuf
where P: AsRef<RelativePath>,

Build an owned RelativePathBuf, joined with the given path and normalized.

§Examples
use relative_path::RelativePath;

assert_eq!(
    RelativePath::new("foo/baz.txt"),
    RelativePath::new("foo/bar").join_normalized("../baz.txt").as_relative_path()
);

assert_eq!(
    RelativePath::new("../foo/baz.txt"),
    RelativePath::new("../foo/bar").join_normalized("../baz.txt").as_relative_path()
);
source

pub fn normalize(&self) -> RelativePathBuf

Return an owned RelativePathBuf, with all non-normal components moved to the beginning of the path.

This permits for a normalized representation of different relative components.

Normalization is a destructive operation if the path references an actual filesystem path. An example of this is symlinks under unix, a path like foo/../bar might reference a different location other than ./bar.

Normalization is a logical operation and does not guarantee that the constructed path corresponds to what the filesystem would do. On Linux for example symbolic links could mean that the logical path doesn’t correspond to the filesystem path.

§Examples
use relative_path::RelativePath;

assert_eq!(
    "../foo/baz.txt",
    RelativePath::new("../foo/./bar/../baz.txt").normalize()
);

assert_eq!(
    "",
    RelativePath::new(".").normalize()
);
source

pub fn relative<P>(&self, path: P) -> RelativePathBuf
where P: AsRef<RelativePath>,

Constructs a relative path from the current path, to path.

This function will return the empty RelativePath "" if this source contains unnamed components like .. that would have to be traversed to reach the destination path. This is necessary since we have no way of knowing what the names of those components are when we’re building the new relative path.

use relative_path::RelativePath;

// Here we don't know what directories `../..` refers to, so there's no
// way to construct a path back to `bar` in the current directory from
// `../..`.
let from = RelativePath::new("../../foo/relative-path");
let to = RelativePath::new("bar");
assert_eq!("", from.relative(to));

One exception to this is when two paths contains a common prefix at which point there’s no need to know what the names of those unnamed components are.

use relative_path::RelativePath;

let from = RelativePath::new("../../foo/bar");
let to = RelativePath::new("../../foo/baz");

assert_eq!("../baz", from.relative(to));

let from = RelativePath::new("../a/../../foo/bar");
let to = RelativePath::new("../../foo/baz");

assert_eq!("../baz", from.relative(to));
§Examples
use relative_path::RelativePath;

assert_eq!(
    "../../e/f",
    RelativePath::new("a/b/c/d").relative(RelativePath::new("a/b/e/f"))
);

assert_eq!(
    "../bbb",
    RelativePath::new("a/../aaa").relative(RelativePath::new("b/../bbb"))
);

let a = RelativePath::new("git/relative-path");
let b = RelativePath::new("git");
assert_eq!("relative-path", b.relative(a));
assert_eq!("..", a.relative(b));

let a = RelativePath::new("foo/bar/bap/foo.h");
let b = RelativePath::new("../arch/foo.h");
assert_eq!("../../../../../arch/foo.h", a.relative(b));
assert_eq!("", b.relative(a));

Trait Implementations§

source§

impl AsRef<RelativePath> for Component<'_>

AsRef<RelativePath> implementation for Component.

§Examples

use relative_path::RelativePath;

let mut it = RelativePath::new("../foo/bar").components();

let a = it.next().ok_or("a")?;
let b = it.next().ok_or("b")?;
let c = it.next().ok_or("c")?;

let a: &RelativePath = a.as_ref();
let b: &RelativePath = b.as_ref();
let c: &RelativePath = c.as_ref();

assert_eq!(a, "..");
assert_eq!(b, "foo");
assert_eq!(c, "bar");
source§

fn as_ref(&self) -> &RelativePath

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

impl AsRef<RelativePath> for RelativePath

source§

fn as_ref(&self) -> &RelativePath

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

impl AsRef<RelativePath> for RelativePathBuf

source§

fn as_ref(&self) -> &RelativePath

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

impl AsRef<RelativePath> for String

AsRef<RelativePath> implementation for String.

§Examples

use relative_path::RelativePath;

let path: String = format!("foo/bar");
let path: &RelativePath = path.as_ref();
assert_eq!(path, "foo/bar");
source§

fn as_ref(&self) -> &RelativePath

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

impl AsRef<RelativePath> for str

AsRef<RelativePath> implementation for str.

§Examples

use relative_path::RelativePath;

let path: &RelativePath = "foo/bar".as_ref();
assert_eq!(path, RelativePath::new("foo/bar"));
source§

fn as_ref(&self) -> &RelativePath

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

impl AsRef<str> for RelativePath

source§

fn as_ref(&self) -> &str

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

impl Borrow<RelativePath> for RelativePathBuf

source§

fn borrow(&self) -> &RelativePath

Immutably borrows from an owned value. Read more
source§

impl Clone for Box<RelativePath>

Clone implementation for Box<RelativePath>.

§Examples

use relative_path::RelativePath;

let path: Box<RelativePath> = RelativePath::new("foo/bar").into();
let path2 = path.clone();
assert_eq!(&*path, &*path2);
source§

fn clone(&self) -> Self

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
source§

impl Debug for RelativePath

source§

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

Formats the value using the given formatter. Read more
source§

impl<'de: 'a, 'a> Deserialize<'de> for &'a RelativePath

serde::de::Deserialize implementation for a RelativePath reference.

use serde::Deserialize;
use relative_path::RelativePath;

#[derive(Deserialize)]
struct Document<'a> {
    #[serde(borrow)]
    path: &'a RelativePath,
}
source§

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
source§

impl<'de> Deserialize<'de> for Box<RelativePath>

serde::de::Deserialize implementation for Box<RelativePath>.

use serde::Deserialize;
use relative_path::RelativePath;

#[derive(Deserialize)]
struct Document {
    path: Box<RelativePath>,
}
source§

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
source§

impl Display for RelativePath

source§

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

Formats the value using the given formatter. Read more
source§

impl From<&RelativePath> for Arc<RelativePath>

Conversion from RelativePath to Arc<RelativePath>.

§Examples

use std::sync::Arc;
use relative_path::RelativePath;

let path: Arc<RelativePath> = RelativePath::new("foo/bar").into();
assert_eq!(&*path, "foo/bar");
source§

fn from(path: &RelativePath) -> Arc<RelativePath>

Converts to this type from the input type.
source§

impl<'a> From<&'a RelativePath> for Cow<'a, RelativePath>

source§

fn from(s: &'a RelativePath) -> Cow<'a, RelativePath>

Converts to this type from the input type.
source§

impl From<&RelativePath> for Rc<RelativePath>

Conversion from RelativePathBuf to Arc<RelativePath>.

§Examples

use std::rc::Rc;
use relative_path::RelativePath;

let path: Rc<RelativePath> = RelativePath::new("foo/bar").into();
assert_eq!(&*path, "foo/bar");
source§

fn from(path: &RelativePath) -> Rc<RelativePath>

Converts to this type from the input type.
source§

impl<T> From<&T> for Box<RelativePath>
where T: ?Sized + AsRef<str>,

Conversion from a str reference to a Box<RelativePath>.

§Examples

use relative_path::RelativePath;

let path: Box<RelativePath> = "foo/bar".into();
assert_eq!(&*path, "foo/bar");

let path: Box<RelativePath> = RelativePath::new("foo/bar").into();
assert_eq!(&*path, "foo/bar");
source§

fn from(path: &T) -> Box<RelativePath>

Converts to this type from the input type.
source§

impl From<Box<str>> for Box<RelativePath>

Conversion from a Box<str> reference to a Box<RelativePath>.

§Examples

use relative_path::RelativePath;

let path: Box<RelativePath> = Box::<str>::from("foo/bar").into();
assert_eq!(&*path, "foo/bar");
source§

fn from(boxed: Box<str>) -> Box<RelativePath>

Converts to this type from the input type.
source§

impl From<RelativePathBuf> for Box<RelativePath>

Conversion from RelativePathBuf to Box<RelativePath>.

§Examples

use std::sync::Arc;
use relative_path::{RelativePath, RelativePathBuf};

let path = RelativePathBuf::from("foo/bar");
let path: Box<RelativePath> = path.into();
assert_eq!(&*path, "foo/bar");
source§

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

Converts to this type from the input type.
source§

impl Hash for RelativePath

source§

fn hash<H: Hasher>(&self, h: &mut H)

Feeds this value into the given Hasher. Read more
source§

impl<'a> IntoIterator for &'a RelativePath

§

type IntoIter = Iter<'a>

Which kind of iterator are we turning this into?
§

type Item = &'a str

The type of the elements being iterated over.
source§

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value. Read more
source§

impl Ord for RelativePath

source§

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

This method returns an Ordering between self and other. Read more
source§

impl<'a, 'b> PartialEq<&'b RelativePath> for Cow<'a, RelativePath>

source§

fn eq(&self, other: &&'b RelativePath) -> bool

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl<'a, 'b> PartialEq<&'a RelativePath> for RelativePathBuf

source§

fn eq(&self, other: &&'a RelativePath) -> bool

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl<'a, 'b> PartialEq<&'a RelativePath> for String

source§

fn eq(&self, other: &&'a RelativePath) -> bool

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl<'a, 'b> PartialEq<&'a RelativePath> for str

source§

fn eq(&self, other: &&'a RelativePath) -> bool

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl<'a, 'b> PartialEq<&'a str> for RelativePath

source§

fn eq(&self, other: &&'a str) -> bool

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl<'a, 'b> PartialEq<Cow<'a, RelativePath>> for &'b RelativePath

source§

fn eq(&self, other: &Cow<'a, RelativePath>) -> bool

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl<'a, 'b> PartialEq<Cow<'a, RelativePath>> for RelativePath

source§

fn eq(&self, other: &Cow<'a, RelativePath>) -> bool

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl<'a, 'b> PartialEq<RelativePath> for &'a str

source§

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl<'a, 'b> PartialEq<RelativePath> for Cow<'a, RelativePath>

source§

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl<'a, 'b> PartialEq<RelativePath> for RelativePathBuf

source§

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl<'a, 'b> PartialEq<RelativePath> for String

source§

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl<'a, 'b> PartialEq<RelativePath> for str

source§

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl<'a, 'b> PartialEq<RelativePathBuf> for &'a RelativePath

source§

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl<'a, 'b> PartialEq<RelativePathBuf> for RelativePath

source§

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl<'a, 'b> PartialEq<String> for &'a RelativePath

source§

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl<'a, 'b> PartialEq<String> for RelativePath

source§

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl<'a, 'b> PartialEq<str> for &'a RelativePath

source§

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl<'a, 'b> PartialEq<str> for RelativePath

source§

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl PartialEq for RelativePath

source§

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl<'a, 'b> PartialOrd<&'b RelativePath> for Cow<'a, RelativePath>

source§

fn partial_cmp(&self, other: &&'b RelativePath) -> Option<Ordering>

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · source§

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

This method tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · source§

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

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more
1.0.0 · source§

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

This method tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · source§

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

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

impl<'a, 'b> PartialOrd<&'a RelativePath> for RelativePathBuf

source§

fn partial_cmp(&self, other: &&'a RelativePath) -> Option<Ordering>

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · source§

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

This method tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · source§

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

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more
1.0.0 · source§

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

This method tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · source§

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

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

impl<'a, 'b> PartialOrd<&'a RelativePath> for String

source§

fn partial_cmp(&self, other: &&'a RelativePath) -> Option<Ordering>

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · source§

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

This method tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · source§

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

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more
1.0.0 · source§

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

This method tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · source§

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

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

impl<'a, 'b> PartialOrd<&'a RelativePath> for str

source§

fn partial_cmp(&self, other: &&'a RelativePath) -> Option<Ordering>

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · source§

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

This method tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · source§

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

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more
1.0.0 · source§

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

This method tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · source§

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

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

impl<'a, 'b> PartialOrd<&'a str> for RelativePath

source§

fn partial_cmp(&self, other: &&'a str) -> Option<Ordering>

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · source§

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

This method tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · source§

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

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more
1.0.0 · source§

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

This method tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · source§

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

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

impl<'a, 'b> PartialOrd<Cow<'a, RelativePath>> for &'b RelativePath

source§

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

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · source§

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

This method tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · source§

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

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more
1.0.0 · source§

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

This method tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · source§

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

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

impl<'a, 'b> PartialOrd<Cow<'a, RelativePath>> for RelativePath

source§

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

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · source§

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

This method tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · source§

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

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more
1.0.0 · source§

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

This method tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · source§

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

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

impl<'a, 'b> PartialOrd<RelativePath> for &'a str

source§

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

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · source§

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

This method tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · source§

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

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more
1.0.0 · source§

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

This method tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · source§

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

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

impl<'a, 'b> PartialOrd<RelativePath> for Cow<'a, RelativePath>

source§

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

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · source§

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

This method tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · source§

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

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more
1.0.0 · source§

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

This method tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · source§

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

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

impl<'a, 'b> PartialOrd<RelativePath> for RelativePathBuf

source§

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

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · source§

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

This method tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · source§

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

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more
1.0.0 · source§

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

This method tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · source§

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

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

impl<'a, 'b> PartialOrd<RelativePath> for String

source§

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

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · source§

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

This method tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · source§

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

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more
1.0.0 · source§

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

This method tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · source§

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

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

impl<'a, 'b> PartialOrd<RelativePath> for str

source§

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

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · source§

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

This method tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · source§

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

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more
1.0.0 · source§

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

This method tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · source§

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

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

impl<'a, 'b> PartialOrd<RelativePathBuf> for &'a RelativePath

source§

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

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · source§

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

This method tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · source§

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

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more
1.0.0 · source§

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

This method tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · source§

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

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

impl<'a, 'b> PartialOrd<RelativePathBuf> for RelativePath

source§

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

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · source§

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

This method tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · source§

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

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more
1.0.0 · source§

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

This method tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · source§

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

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

impl<'a, 'b> PartialOrd<String> for &'a RelativePath

source§

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

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · source§

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

This method tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · source§

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

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more
1.0.0 · source§

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

This method tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · source§

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

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

impl<'a, 'b> PartialOrd<String> for RelativePath

source§

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

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · source§

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

This method tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · source§

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

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more
1.0.0 · source§

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

This method tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · source§

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

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

impl<'a, 'b> PartialOrd<str> for &'a RelativePath

source§

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

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · source§

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

This method tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · source§

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

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more
1.0.0 · source§

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

This method tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · source§

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

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

impl<'a, 'b> PartialOrd<str> for RelativePath

source§

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

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · source§

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

This method tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · source§

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

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more
1.0.0 · source§

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

This method tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · source§

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

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

impl PartialOrd for RelativePath

source§

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

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · source§

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

This method tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · source§

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

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more
1.0.0 · source§

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

This method tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · source§

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

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

impl Serialize for RelativePath

serde::ser::Serialize implementation for RelativePath.

use serde::Serialize;
use relative_path::RelativePath;

#[derive(Serialize)]
struct Document<'a> {
    path: &'a RelativePath,
}
source§

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: Serializer,

Serialize this value into the given Serde serializer. Read more
source§

impl ToOwned for RelativePath

ToOwned implementation for RelativePath.

§Examples

use relative_path::RelativePath;

let path = RelativePath::new("foo/bar").to_owned();
assert_eq!(path, "foo/bar");
§

type Owned = RelativePathBuf

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> RelativePathBuf

Creates owned data from borrowed data, usually by cloning. Read more
1.63.0 · source§

fn clone_into(&self, target: &mut Self::Owned)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl Eq for RelativePath

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> ToString for T
where T: Display + ?Sized,

source§

default fn to_string(&self) -> String

Converts the given value to a String. Read more