Struct relative_path::RelativePath [−][src]
#[repr(transparent)]pub struct RelativePath { /* fields omitted */ }
A borrowed, immutable relative path.
Implementations
impl RelativePath
[src]
impl RelativePath
[src]pub fn new<S: AsRef<str> + ?Sized>(s: &S) -> &RelativePath
[src]
Directly wraps a string slice as a RelativePath
slice.
pub fn from_path<P: ?Sized + AsRef<Path>>(
path: &P
) -> Result<&RelativePath, FromPathError>
[src]
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()); }
pub fn as_str(&self) -> &str
[src]
Yields the underlying str
slice.
Examples
use relative_path::RelativePath; assert_eq!(RelativePath::new("foo.txt").as_str(), "foo.txt");
pub fn display(&self) -> Display<'_>
[src]
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());
pub fn join<P: AsRef<RelativePath>>(&self, path: P) -> RelativePathBuf
[src]
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"));
pub fn components(&self) -> Components<'_>ⓘNotable traits for Components<'a>
impl<'a> Iterator for Components<'a> type Item = Component<'a>;
[src]
Notable traits for Components<'a>
impl<'a> Iterator for Components<'a> type Item = Component<'a>;
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());
pub fn iter(&self) -> Iter<'_>ⓘ
[src]
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)
pub fn to_relative_path_buf(&self) -> RelativePathBuf
[src]
Convert to an owned RelativePathBuf.
pub fn to_path<P: AsRef<Path>>(&self, base: P) -> PathBuf
[src]
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);
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) { assert_eq!( Path::new("foo\\bar\\baz"), RelativePath::new("/bar/baz").to_path("foo") ); assert_eq!( Path::new("foo\\c:\\bar\\baz"), RelativePath::new("c:\\bar\\baz").to_path("foo") ); } if cfg!(unix) { assert_eq!( Path::new("foo/bar/baz"), RelativePath::new("/bar/baz").to_path("foo") ); assert_eq!( Path::new("foo/c:\\bar\\baz"), RelativePath::new("c:\\bar\\baz").to_path("foo") ); }
pub fn to_logical_path<P: AsRef<Path>>(&self, base: P) -> PathBuf
[src]
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:
- Component::CurDir leaves the
base
unmodified. - Component::ParentDir removes a component from
base
using path::PathBuf::pop. - Component::Normal pushes the given path component onto
base
using the same mechanism as to_path.
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) { assert_eq!( Path::new("foo\\bar\\baz"), RelativePath::new("/bar/baz").to_logical_path("foo") ); assert_eq!( Path::new("foo\\c:\\bar\\baz"), RelativePath::new("c:\\bar\\baz").to_logical_path("foo") ); } if cfg!(unix) { assert_eq!( Path::new("foo/bar/baz"), RelativePath::new("/bar/baz").to_logical_path("foo") ); assert_eq!( Path::new("foo/c:\\bar\\baz"), RelativePath::new("c:\\bar\\baz").to_logical_path("foo") ); }
pub fn parent(&self) -> Option<&RelativePath>
[src]
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());
pub fn file_name(&self) -> Option<&str>
[src]
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());
pub fn strip_prefix<P: AsRef<RelativePath>>(
&self,
base: P
) -> Result<&RelativePath, StripPrefixError>
[src]
&self,
base: P
) -> Result<&RelativePath, StripPrefixError>
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);
pub fn starts_with<P: AsRef<RelativePath>>(&self, base: P) -> bool
[src]
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"));
pub fn ends_with<P: AsRef<RelativePath>>(&self, child: P) -> bool
[src]
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"));
pub fn with_file_name<S: AsRef<str>>(&self, file_name: S) -> RelativePathBuf
[src]
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"));
pub fn file_stem(&self) -> Option<&str>
[src]
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());
pub fn extension(&self) -> Option<&str>
[src]
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());
pub fn with_extension<S: AsRef<str>>(&self, extension: S) -> RelativePathBuf
[src]
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"));
pub fn join_normalized<P: AsRef<RelativePath>>(
&self,
path: P
) -> RelativePathBuf
[src]
&self,
path: P
) -> RelativePathBuf
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() );
pub fn normalize(&self) -> RelativePathBuf
[src]
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 that is only valid if the relative path is part of some context which doesn’t have semantics that causes it to break, like symbolic links.
Examples
use relative_path::RelativePath; assert_eq!( "../foo/baz.txt", RelativePath::new("../foo/./bar/../baz.txt").normalize() ); assert_eq!( "", RelativePath::new(".").normalize() );
pub fn relative<P: AsRef<RelativePath>>(&self, path: P) -> RelativePathBuf
[src]
Constructs a relative path from the current path, to path
.
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 p = RelativePath::new("git/relative-path"); let r = RelativePath::new("git"); assert_eq!("relative-path", r.relative(p)); assert_eq!("..", p.relative(r)); let p = RelativePath::new("../../git/relative-path"); let r = RelativePath::new("git"); assert_eq!("../../../git/relative-path", r.relative(p)); assert_eq!("", p.relative(r)); 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
impl AsRef<RelativePath> for RelativePathBuf
[src]
impl AsRef<RelativePath> for RelativePathBuf
[src]fn as_ref(&self) -> &RelativePath
[src]
impl AsRef<RelativePath> for RelativePath
[src]
impl AsRef<RelativePath> for RelativePath
[src]fn as_ref(&self) -> &RelativePath
[src]
impl Borrow<RelativePath> for RelativePathBuf
[src]
impl Borrow<RelativePath> for RelativePathBuf
[src]fn borrow(&self) -> &RelativePath
[src]
impl Eq for RelativePath
[src]
impl Eq for RelativePath
[src]impl Hash for RelativePath
[src]
impl Hash for RelativePath
[src]impl Ord for RelativePath
[src]
impl Ord for RelativePath
[src]impl<'a, 'b> PartialEq<&'a RelativePath> for RelativePathBuf
[src]
impl<'a, 'b> PartialEq<&'a RelativePath> for RelativePathBuf
[src]impl<'a, 'b> PartialEq<&'a str> for RelativePath
[src]
impl<'a, 'b> PartialEq<&'a str> for RelativePath
[src]impl<'a, 'b> PartialEq<Cow<'a, RelativePath>> for RelativePath
[src]
impl<'a, 'b> PartialEq<Cow<'a, RelativePath>> for RelativePath
[src]impl<'a, 'b> PartialEq<Cow<'a, RelativePath>> for &'b RelativePath
[src]
impl<'a, 'b> PartialEq<Cow<'a, RelativePath>> for &'b RelativePath
[src]impl PartialEq<RelativePath> for RelativePath
[src]
impl PartialEq<RelativePath> for RelativePath
[src]impl<'a, 'b> PartialEq<RelativePath> for RelativePathBuf
[src]
impl<'a, 'b> PartialEq<RelativePath> for RelativePathBuf
[src]impl<'a, 'b> PartialEq<RelativePathBuf> for RelativePath
[src]
impl<'a, 'b> PartialEq<RelativePathBuf> for RelativePath
[src]impl<'a, 'b> PartialEq<RelativePathBuf> for &'a RelativePath
[src]
impl<'a, 'b> PartialEq<RelativePathBuf> for &'a RelativePath
[src]impl<'a, 'b> PartialEq<String> for RelativePath
[src]
impl<'a, 'b> PartialEq<String> for RelativePath
[src]impl<'a, 'b> PartialEq<String> for &'a RelativePath
[src]
impl<'a, 'b> PartialEq<String> for &'a RelativePath
[src]impl<'a, 'b> PartialEq<str> for RelativePath
[src]
impl<'a, 'b> PartialEq<str> for RelativePath
[src]impl<'a, 'b> PartialEq<str> for &'a RelativePath
[src]
impl<'a, 'b> PartialEq<str> for &'a RelativePath
[src]impl<'a, 'b> PartialOrd<&'a RelativePath> for RelativePathBuf
[src]
impl<'a, 'b> PartialOrd<&'a RelativePath> for RelativePathBuf
[src]fn partial_cmp(&self, other: &&'a RelativePath) -> Option<Ordering>
[src]
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, 'b> PartialOrd<&'a str> for RelativePath
[src]
impl<'a, 'b> PartialOrd<&'a str> for RelativePath
[src]impl<'a, 'b> PartialOrd<Cow<'a, RelativePath>> for RelativePath
[src]
impl<'a, 'b> PartialOrd<Cow<'a, RelativePath>> for RelativePath
[src]fn partial_cmp(&self, other: &Cow<'a, RelativePath>) -> Option<Ordering>
[src]
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, 'b> PartialOrd<Cow<'a, RelativePath>> for &'b RelativePath
[src]
impl<'a, 'b> PartialOrd<Cow<'a, RelativePath>> for &'b RelativePath
[src]fn partial_cmp(&self, other: &Cow<'a, RelativePath>) -> Option<Ordering>
[src]
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
impl PartialOrd<RelativePath> for RelativePath
[src]
impl PartialOrd<RelativePath> for RelativePath
[src]fn partial_cmp(&self, other: &RelativePath) -> Option<Ordering>
[src]
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, 'b> PartialOrd<RelativePath> for RelativePathBuf
[src]
impl<'a, 'b> PartialOrd<RelativePath> for RelativePathBuf
[src]fn partial_cmp(&self, other: &RelativePath) -> Option<Ordering>
[src]
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, 'b> PartialOrd<RelativePathBuf> for RelativePath
[src]
impl<'a, 'b> PartialOrd<RelativePathBuf> for RelativePath
[src]fn partial_cmp(&self, other: &RelativePathBuf) -> Option<Ordering>
[src]
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, 'b> PartialOrd<RelativePathBuf> for &'a RelativePath
[src]
impl<'a, 'b> PartialOrd<RelativePathBuf> for &'a RelativePath
[src]fn partial_cmp(&self, other: &RelativePathBuf) -> Option<Ordering>
[src]
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, 'b> PartialOrd<String> for RelativePath
[src]
impl<'a, 'b> PartialOrd<String> for RelativePath
[src]impl<'a, 'b> PartialOrd<String> for &'a RelativePath
[src]
impl<'a, 'b> PartialOrd<String> for &'a RelativePath
[src]impl<'a, 'b> PartialOrd<str> for RelativePath
[src]
impl<'a, 'b> PartialOrd<str> for RelativePath
[src]impl<'a, 'b> PartialOrd<str> for &'a RelativePath
[src]
impl<'a, 'b> PartialOrd<str> for &'a RelativePath
[src]impl ToOwned for RelativePath
[src]
impl ToOwned for RelativePath
[src]type Owned = RelativePathBuf
The resulting type after obtaining ownership.
fn to_owned(&self) -> RelativePathBuf
[src]
pub fn clone_into(&self, target: &mut Self::Owned)
[src]
Auto Trait Implementations
impl RefUnwindSafe for RelativePath
impl RefUnwindSafe for RelativePath
impl Send for RelativePath
impl Send for RelativePath
impl !Sized for RelativePath
impl !Sized for RelativePath
impl Sync for RelativePath
impl Sync for RelativePath
impl Unpin for RelativePath
impl Unpin for RelativePath
impl UnwindSafe for RelativePath
impl UnwindSafe for RelativePath