# 1.0.0[−][src]Struct std::path::PathBuf

    pub struct PathBuf { /* fields omitted */ }

An owned, mutable path (akin to `String`).

This type provides methods like `push` and `set_extension` that mutate the path in place. It also implements `Deref` to `Path`, meaning that all methods on `Path` slices are available on `PathBuf` values as well.

More details about the overall approach can be found in the module documentation.

# Examples

You can use `push` to build up a `PathBuf` from components:

    use std::path::PathBuf;

    let mut path = PathBuf::new();

    path.push(r"C:\");
    path.push("windows");
    path.push("system32");

    path.set_extension("dll");

Run

However, `push` is best used for dynamic situations. This is a better way to do this when you know all of the components ahead of time:

    use std::path::PathBuf;

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

Run

We can still do better than this! Since these are all strings, we can use `From::from`:

    use std::path::PathBuf;

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

Run

Which method works best depends on what kind of situation you're in.

## Methods

### `impl PathBuf`[src]

#### `pub fn new() -> PathBuf`[src]

Allocates an empty `PathBuf`.

# Examples

    use std::path::PathBuf;

    let path = PathBuf::new();

Run

#### `pub fn with_capacity(capacity: usize) -> PathBuf`[src]

🔬 This is a nightly-only experimental API. (`path_buf_capacity` #58234)

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

# Examples

    #![feature(path_buf_capacity)]
    use std::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());

Run

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

Coerces to a `Path` slice.

# Examples

    use std::path::{Path, PathBuf};

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

Run

#### `pub fn push<P: AsRef<Path>>(&mut self, path: P)`[src]

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`.

# Examples

Pushing a relative path extends the existing path:

    use std::path::PathBuf;

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

Run

Pushing an absolute path replaces the existing path:

    use std::path::PathBuf;

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

Run

#### `pub fn pop(&mut self) -> bool`[src]

Truncates `self` to `self.parent`.

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

# Examples

    use std::path::{Path, PathBuf};

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

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

Run

#### `pub fn set_file_name<S: AsRef<OsStr>>(&mut self, file_name: S)`[src]

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 std::path::PathBuf;

    let mut buf = PathBuf::from("/");
    assert!(buf.file_name() == None);
    buf.set_file_name("bar");
    assert!(buf == PathBuf::from("/bar"));
    assert!(buf.file_name().is_some());
    buf.set_file_name("baz.txt");
    assert!(buf == PathBuf::from("/baz.txt"));

Run

#### `pub fn set_extension<S: AsRef<OsStr>>(&mut self, extension: S) -> bool`[src]

Updates `self.extension` to `extension`.

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.

# Examples

    use std::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());

Run

#### `pub fn into_os_string(self) -> OsString`[src]

Consumes the `PathBuf`, yielding its internal `OsString` storage.

# Examples

    use std::path::PathBuf;

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

Run

####
ⓘImportant traits for Box<F>

### Important traits for Box<F>

`impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<I> Iterator for Box<I> where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<R: Read + ?Sized> Read for Box<R>impl<W: Write + ?Sized> Write for Box<W>`
`pub fn into_boxed_path(self) -> Box<Path>`1.20.0[src]

Converts this `PathBuf` into a boxed `Path`.

#### `pub fn capacity(&self) -> usize`[src]

🔬 This is a nightly-only experimental API. (`path_buf_capacity` #58234)

Invokes `capacity` on the underlying instance of `OsString`.

#### `pub fn clear(&mut self)`[src]

🔬 This is a nightly-only experimental API. (`path_buf_capacity` #58234)

Invokes `clear` on the underlying instance of `OsString`.

#### `pub fn reserve(&mut self, additional: usize)`[src]

🔬 This is a nightly-only experimental API. (`path_buf_capacity` #58234)

Invokes `reserve` on the underlying instance of `OsString`.

#### `pub fn reserve_exact(&mut self, additional: usize)`[src]

🔬 This is a nightly-only experimental API. (`path_buf_capacity` #58234)

Invokes `reserve_exact` on the underlying instance of `OsString`.

#### `pub fn shrink_to_fit(&mut self)`[src]

🔬 This is a nightly-only experimental API. (`path_buf_capacity` #58234)

Invokes `shrink_to_fit` on the underlying instance of `OsString`.

#### `pub fn shrink_to(&mut self, min_capacity: usize)`[src]

🔬 This is a nightly-only experimental API. (`path_buf_capacity` #58234)

Invokes `shrink_to` on the underlying instance of `OsString`.

## Methods from Deref<Target = Path>

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

Yields the underlying `OsStr` slice.

# Examples

    use std::path::Path;

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

Run

#### `pub fn to_str(&self) -> Option<&str>`[src]

Yields a `&str` slice if the `Path` is valid unicode.

This conversion may entail doing a check for UTF-8 validity. Note that validation is performed because non-UTF-8 strings are perfectly valid for some OS.

# Examples

    use std::path::Path;

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

Run

#### `pub fn to_string_lossy(&self) -> Cow<str>`[src]

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 std::path::Path;

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

Run

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

#### `pub fn to_path_buf(&self) -> PathBuf`[src]

Converts a `Path` to an owned `PathBuf`.

# Examples

    use std::path::Path;

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

Run

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

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 std::path::Path;

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

Run

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

Returns `true` if the `Path` is relative, i.e., not absolute.

See `is_absolute`'s documentation for more details.

# Examples

    use std::path::Path;

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

Run

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

Returns `true` if the `Path` has a root.

- 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 std::path::Path;

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

Run

#### `pub fn parent(&self) -> Option<&Path>`[src]

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

Returns `None` if the path terminates in a root or prefix.

# Examples

    use std::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);

Run

####
ⓘImportant traits for Ancestors<'a>

### Important traits for Ancestors<'a>

`impl<'a> Iterator for Ancestors<'a> type Item = &'a Path;`
`pub fn ancestors(&self) -> Ancestors` 1.28.0[src]

Produces an iterator over `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 std::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);

Run

#### `pub fn file_name(&self) -> Option<&OsStr>`[src]

Returns the final component of the `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 std::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());

Run

#### `pub fn strip_prefix<P>(&self, base: P) -> Result<&Path, StripPrefixError> where
P: AsRef<Path>,` 1.7.0[src]

Returns a 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 std::path::{Path, PathBuf};

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

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

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

Run

#### `pub fn starts_with<P: AsRef<Path>>(&self, base: P) -> bool`[src]

Determines whether `base` is a prefix of `self`.

Only considers whole path components to match.

# Examples

    use std::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/"));

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

Run

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

Determines whether `child` is a suffix of `self`.

Only considers whole path components to match.

# Examples

    use std::path::Path;

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

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

Run

#### `pub fn file_stem(&self) -> Option<&OsStr>`[src]

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 std::path::Path;

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

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

Run

#### `pub fn extension(&self) -> Option<&OsStr>`[src]

Extracts the extension 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 std::path::Path;

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

    assert_eq!("rs", path.extension().unwrap());

Run

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

Creates an owned `PathBuf` with `path` adjoined to `self`.

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

# Examples

    use std::path::{Path, PathBuf};

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

Run

#### `pub fn with_file_name<S: AsRef<OsStr>>(&self, file_name: S) -> PathBuf`[src]

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

See `PathBuf::set_file_name` for more details.

# Examples

    use std::path::{Path, PathBuf};

    let path = Path::new("/tmp/foo.txt");
    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"));

Run

#### `pub fn with_extension<S: AsRef<OsStr>>(&self, extension: S) -> PathBuf`[src]

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

See `PathBuf::set_extension` for more details.

# Examples

    use std::path::{Path, PathBuf};

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

Run

####
ⓘImportant traits for Components<'a>

### Important traits for Components<'a>

`impl<'a> Iterator for Components<'a> type Item = Component<'a>;`
`pub fn components(&self) -> Components`[src]

Produces an iterator over the `Component`s 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 std::path::{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)

Run

####
ⓘImportant traits for Iter<'a>

### Important traits for Iter<'a>

`impl<'a> Iterator for Iter<'a> type Item = &'a OsStr;`
`pub fn iter(&self) -> Iter`[src]

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 std::path::{self, Path};
    use std::ffi::OsStr;

    let mut it = Path::new("/tmp/foo.txt").iter();
    assert_eq!(it.next(), Some(OsStr::new(&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)

Run

#### `pub fn display(&self) -> Display`[src]

Returns an object that implements `Display` for safely printing paths that may contain non-Unicode data.

# Examples

    use std::path::Path;

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

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

Run

#### `pub fn metadata(&self) -> Result<Metadata>`1.5.0[src]

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 `fs::metadata`.

# Examples

    use std::path::Path;

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

Run

#### `pub fn symlink_metadata(&self) -> Result<Metadata>`1.5.0[src]

Queries the metadata about a file without following symlinks.

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

# Examples

    use std::path::Path;

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

Run

#### `pub fn canonicalize(&self) -> Result<PathBuf>`1.5.0[src]

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

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

# Examples

    use std::path::{Path, PathBuf};

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

Run

#### `pub fn read_link(&self) -> Result<PathBuf>`1.5.0[src]

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

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

# Examples

    use std::path::Path;

    let path = Path::new("/laputa/sky_castle.rs");
    let path_link = path.read_link().expect("read_link call failed");

Run

#### `pub fn read_dir(&self) -> Result<ReadDir>`1.5.0[src]

Returns an iterator over the entries within a directory.

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

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

# Examples

    use std::path::Path;

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

Run

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

Returns `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 `false`.

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

# Examples

    use std::path::Path;
    assert_eq!(Path::new("does_not_exist.txt").exists(), false);

Run

# See Also

This is a convenience function that coerces errors to false. If you want to check errors, call fs::metadata.

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

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. In case of broken symbolic links this will return `false`.

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

# Examples

    use std::path::Path;
    assert_eq!(Path::new("./is_a_directory/").is_file(), false);
    assert_eq!(Path::new("a_file.txt").is_file(), true);

Run

# See Also

This is a convenience function that coerces errors to false. If you want to check errors, call fs::metadata and handle its Result. Then call fs::Metadata::is_file if it was Ok.

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

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. In case of broken symbolic links this will return `false`.

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

# Examples

    use std::path::Path;
    assert_eq!(Path::new("./is_a_directory/").is_dir(), true);
    assert_eq!(Path::new("a_file.txt").is_dir(), false);

Run

# See Also

This is a convenience function that coerces errors to false. If you want to check errors, call fs::metadata and handle its Result. Then call fs::Metadata::is_dir if it was Ok.

## Trait Implementations

### `impl AsRef<OsStr> for PathBuf`[src]

#### `fn as_ref(&self) -> &OsStr`[src]

Performs the conversion.

### `impl AsRef<Path> for PathBuf`[src]

#### `fn as_ref(&self) -> &Path`[src]

Performs the conversion.

### `impl Borrow<Path> for PathBuf`[src]

#### `fn borrow(&self) -> &Path`[src]

Immutably borrows from an owned value. Read more

### `impl Clone for PathBuf`[src]

#### `fn clone(&self) -> PathBuf`[src]

Returns a copy of the value. Read more

#### `fn clone_from(&mut self, source: &Self)`[src]

Performs copy-assignment from `source`. Read more

### `impl Debug for PathBuf`[src]

#### `fn fmt(&self, formatter: &mut Formatter) -> Result`[src]

Formats the value using the given formatter. Read more

### `impl Default for PathBuf` 1.17.0[src]

#### `fn default() -> Self`[src]

Returns the "default value" for a type. Read more

### `impl Deref for PathBuf`[src]

#### `type Target = Path`

The resulting type after dereferencing.

#### `fn deref(&self) -> &Path`[src]

Dereferences the value.

### `impl Eq for PathBuf`[src]

### `impl<P: AsRef<Path>> Extend<P> for PathBuf`[src]

#### `fn extend<I: IntoIterator<Item = P>>(&mut self, iter: I)`[src]

Extends a collection with the contents of an iterator. Read more

### `impl<'_, T: ?Sized + AsRef<OsStr>> From<&'_ T> for PathBuf`[src]

#### `fn from(s: &T) -> PathBuf`[src]

Performs the conversion.

### `impl<'a> From<&'a PathBuf> for Cow<'a, Path>`1.28.0[src]

#### `fn from(p: &'a PathBuf) -> Cow<'a, Path>`[src]

Performs the conversion.

### `impl From<Box<Path>> for PathBuf` 1.18.0[src]

#### `fn from(boxed: Box<Path>) -> PathBuf`[src]

Converts a `Box<Path>` into a `PathBuf`

This conversion does not allocate or copy memory.

### `impl<'a> From<Cow<'a, Path>> for PathBuf` 1.28.0[src]

#### `fn from(p: Cow<'a, Path>) -> Self`[src]

Performs the conversion.

### `impl From<OsString> for PathBuf`[src]

#### `fn from(s: OsString) -> PathBuf`[src]

Converts a `OsString` into a `PathBuf`

This conversion does not allocate or copy memory.

### `impl From<PathBuf> for Box<Path>`1.20.0[src]

####
ⓘImportant traits for Box<F>

### Important traits for Box<F>

`impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<I> Iterator for Box<I> where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<R: Read + ?Sized> Read for Box<R>impl<W: Write + ?Sized> Write for Box<W>`
`fn from(p: PathBuf) -> Box<Path>`[src]

Converts a `PathBuf` into a `Box<Path>`

This conversion currently should not allocate memory, but this behavior is not guaranteed on all platforms or in all future versions.

### `impl From<PathBuf> for OsString` 1.14.0[src]

#### `fn from(path_buf: PathBuf) -> OsString`[src]

Converts a `PathBuf` into a `OsString`

This conversion does not allocate or copy memory.

### `impl<'a> From<PathBuf> for Cow<'a, Path>`1.6.0[src]

#### `fn from(s: PathBuf) -> Cow<'a, Path>`[src]

Performs the conversion.

### `impl From<PathBuf> for Arc<Path>`1.24.0[src]

#### `fn from(s: PathBuf) -> Arc<Path>`[src]

Converts a `PathBuf` into an `Arc` by moving the `PathBuf` data into a new `Arc` buffer.

### `impl From<PathBuf> for Rc<Path>`1.24.0[src]

#### `fn from(s: PathBuf) -> Rc<Path>`[src]

Converts a `PathBuf` into an `Rc` by moving the `PathBuf` data into a new `Rc` buffer.

### `impl From<String> for PathBuf`[src]

#### `fn from(s: String) -> PathBuf`[src]

Converts a `String` into a `PathBuf`

This conversion does not allocate or copy memory.

### `impl<P: AsRef<Path>> FromIterator<P> for PathBuf`[src]

#### `fn from_iter<I: IntoIterator<Item = P>>(iter: I) -> PathBuf`[src]

Creates a value from an iterator. Read more

### `impl FromStr for PathBuf` 1.32.0[src]

#### `type Err = Infallible`

The associated error which can be returned from parsing.

#### `fn from_str(s: &str) -> Result<Self, Self::Err>`[src]

Parses a string `s` to return a value of this type. Read more

### `impl Hash for PathBuf`[src]

#### `fn hash<H: Hasher>(&self, h: &mut H)`[src]

Feeds this value into the given [`Hasher`]. Read more

#### `fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,` 1.3.0[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

### `impl<'a> IntoIterator for &'a PathBuf` 1.6.0[src]

#### `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?

####
ⓘImportant traits for Iter<'a>

### Important traits for Iter<'a>

`impl<'a> Iterator for Iter<'a> type Item = &'a OsStr;`
`fn into_iter(self) -> Iter<'a>`[src]

Creates an iterator from a value. Read more

### `impl Ord for PathBuf`[src]

#### `fn cmp(&self, other: &PathBuf) -> Ordering`[src]

This method returns an [`Ordering`] between `self` and `other`. Read more

#### `#[must_use] fn max(self, other: Self) -> Self` 1.21.0[src]

Compares and returns the maximum of two values. Read more

#### `#[must_use] fn min(self, other: Self) -> Self` 1.21.0[src]

Compares and returns the minimum of two values. Read more

#### `#[must_use] fn clamp(self, min: Self, max: Self) -> Self`[src]

🔬 This is a nightly-only experimental API. (`clamp` #44095)

Restrict a value to a certain interval. Read more

### `impl<'a, 'b> PartialEq<&'a OsStr> for PathBuf` 1.8.0[src]

#### `fn eq(&self, other: &&'a OsStr) -> bool`[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

#### `#[must_use] fn ne(&self, other: &Rhs) -> bool`[src]

This method tests for `!=`.

### `impl<'a, 'b> PartialEq<&'a Path> for PathBuf` 1.6.0[src]

#### `fn eq(&self, other: &&'a Path) -> bool`[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

#### `#[must_use] fn ne(&self, other: &Rhs) -> bool`[src]

This method tests for `!=`.

### `impl<'a, 'b> PartialEq<Cow<'a, OsStr>> for PathBuf` 1.8.0[src]

#### `fn eq(&self, other: &Cow<'a, OsStr>) -> bool`[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

#### `#[must_use] fn ne(&self, other: &Rhs) -> bool`[src]

This method tests for `!=`.

### `impl<'a, 'b> PartialEq<Cow<'a, Path>> for PathBuf` 1.6.0[src]

#### `fn eq(&self, other: &Cow<'a, Path>) -> bool`[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

#### `#[must_use] fn ne(&self, other: &Rhs) -> bool`[src]

This method tests for `!=`.

### `impl<'a, 'b> PartialEq<OsStr> for PathBuf` 1.8.0[src]

#### `fn eq(&self, other: &OsStr) -> bool`[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

#### `#[must_use] fn ne(&self, other: &Rhs) -> bool`[src]

This method tests for `!=`.

### `impl<'a, 'b> PartialEq<OsString> for PathBuf` 1.8.0[src]

#### `fn eq(&self, other: &OsString) -> bool`[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

#### `#[must_use] fn ne(&self, other: &Rhs) -> bool`[src]

This method tests for `!=`.

### `impl<'a, 'b> PartialEq<Path> for PathBuf` 1.6.0[src]

#### `fn eq(&self, other: &Path) -> bool`[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

#### `#[must_use] fn ne(&self, other: &Rhs) -> bool`[src]

This method tests for `!=`.

### `impl PartialEq<PathBuf> for PathBuf`[src]

#### `fn eq(&self, other: &PathBuf) -> bool`[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

#### `#[must_use] fn ne(&self, other: &Rhs) -> bool`[src]

This method tests for `!=`.

### `impl<'a, 'b> PartialEq<PathBuf> for Path` 1.6.0[src]

#### `fn eq(&self, other: &PathBuf) -> bool`[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

#### `#[must_use] fn ne(&self, other: &Rhs) -> bool`[src]

This method tests for `!=`.

### `impl<'a, 'b> PartialEq<PathBuf> for &'a Path` 1.6.0[src]

#### `fn eq(&self, other: &PathBuf) -> bool`[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

#### `#[must_use] fn ne(&self, other: &Rhs) -> bool`[src]

This method tests for `!=`.

### `impl<'a, 'b> PartialEq<PathBuf> for Cow<'a, Path>`1.6.0[src]

#### `fn eq(&self, other: &PathBuf) -> bool`[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

#### `#[must_use] fn ne(&self, other: &Rhs) -> bool`[src]

This method tests for `!=`.

### `impl<'a, 'b> PartialEq<PathBuf> for OsStr` 1.8.0[src]

#### `fn eq(&self, other: &PathBuf) -> bool`[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

#### `#[must_use] fn ne(&self, other: &Rhs) -> bool`[src]

This method tests for `!=`.

### `impl<'a, 'b> PartialEq<PathBuf> for &'a OsStr` 1.8.0[src]

#### `fn eq(&self, other: &PathBuf) -> bool`[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

#### `#[must_use] fn ne(&self, other: &Rhs) -> bool`[src]

This method tests for `!=`.

### `impl<'a, 'b> PartialEq<PathBuf> for Cow<'a, OsStr>`1.8.0[src]

#### `fn eq(&self, other: &PathBuf) -> bool`[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

#### `#[must_use] fn ne(&self, other: &Rhs) -> bool`[src]

This method tests for `!=`.

### `impl<'a, 'b> PartialEq<PathBuf> for OsString` 1.8.0[src]

#### `fn eq(&self, other: &PathBuf) -> bool`[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

#### `#[must_use] fn ne(&self, other: &Rhs) -> bool`[src]

This method tests for `!=`.

### `impl<'a, 'b> PartialOrd<&'a OsStr> for PathBuf` 1.8.0[src]

#### `fn partial_cmp(&self, other: &&'a OsStr) -> Option<Ordering>`[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

#### `#[must_use] fn lt(&self, other: &Rhs) -> bool`[src]

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

#### `#[must_use] fn le(&self, other: &Rhs) -> bool`[src]

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

#### `#[must_use] fn gt(&self, other: &Rhs) -> bool`[src]

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

#### `#[must_use] fn ge(&self, other: &Rhs) -> bool`[src]

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

### `impl<'a, 'b> PartialOrd<&'a Path> for PathBuf` 1.8.0[src]

#### `fn partial_cmp(&self, other: &&'a Path) -> Option<Ordering>`[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

#### `#[must_use] fn lt(&self, other: &Rhs) -> bool`[src]

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

#### `#[must_use] fn le(&self, other: &Rhs) -> bool`[src]

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

#### `#[must_use] fn gt(&self, other: &Rhs) -> bool`[src]

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

#### `#[must_use] fn ge(&self, other: &Rhs) -> bool`[src]

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

### `impl<'a, 'b> PartialOrd<Cow<'a, OsStr>> for PathBuf` 1.8.0[src]

#### `fn partial_cmp(&self, other: &Cow<'a, OsStr>) -> Option<Ordering>`[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

#### `#[must_use] fn lt(&self, other: &Rhs) -> bool`[src]

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

#### `#[must_use] fn le(&self, other: &Rhs) -> bool`[src]

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

#### `#[must_use] fn gt(&self, other: &Rhs) -> bool`[src]

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

#### `#[must_use] fn ge(&self, other: &Rhs) -> bool`[src]

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

### `impl<'a, 'b> PartialOrd<Cow<'a, Path>> for PathBuf` 1.8.0[src]

#### `fn partial_cmp(&self, other: &Cow<'a, Path>) -> Option<Ordering>`[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

#### `#[must_use] fn lt(&self, other: &Rhs) -> bool`[src]

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

#### `#[must_use] fn le(&self, other: &Rhs) -> bool`[src]

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

#### `#[must_use] fn gt(&self, other: &Rhs) -> bool`[src]

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

#### `#[must_use] fn ge(&self, other: &Rhs) -> bool`[src]

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

### `impl<'a, 'b> PartialOrd<OsStr> for PathBuf` 1.8.0[src]

#### `fn partial_cmp(&self, other: &OsStr) -> Option<Ordering>`[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

#### `#[must_use] fn lt(&self, other: &Rhs) -> bool`[src]

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

#### `#[must_use] fn le(&self, other: &Rhs) -> bool`[src]

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

#### `#[must_use] fn gt(&self, other: &Rhs) -> bool`[src]

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

#### `#[must_use] fn ge(&self, other: &Rhs) -> bool`[src]

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

### `impl<'a, 'b> PartialOrd<OsString> for PathBuf` 1.8.0[src]

#### `fn partial_cmp(&self, other: &OsString) -> Option<Ordering>`[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

#### `#[must_use] fn lt(&self, other: &Rhs) -> bool`[src]

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

#### `#[must_use] fn le(&self, other: &Rhs) -> bool`[src]

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

#### `#[must_use] fn gt(&self, other: &Rhs) -> bool`[src]

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

#### `#[must_use] fn ge(&self, other: &Rhs) -> bool`[src]

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

### `impl<'a, 'b> PartialOrd<Path> for PathBuf` 1.8.0[src]

#### `fn partial_cmp(&self, other: &Path) -> Option<Ordering>`[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

#### `#[must_use] fn lt(&self, other: &Rhs) -> bool`[src]

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

#### `#[must_use] fn le(&self, other: &Rhs) -> bool`[src]

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

#### `#[must_use] fn gt(&self, other: &Rhs) -> bool`[src]

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

#### `#[must_use] fn ge(&self, other: &Rhs) -> bool`[src]

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

### `impl PartialOrd<PathBuf> for PathBuf`[src]

#### `fn partial_cmp(&self, other: &PathBuf) -> Option<Ordering>`[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

#### `#[must_use] fn lt(&self, other: &Rhs) -> bool`[src]

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

#### `#[must_use] fn le(&self, other: &Rhs) -> bool`[src]

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

#### `#[must_use] fn gt(&self, other: &Rhs) -> bool`[src]

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

#### `#[must_use] fn ge(&self, other: &Rhs) -> bool`[src]

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

### `impl<'a, 'b> PartialOrd<PathBuf> for Path` 1.8.0[src]

#### `fn partial_cmp(&self, other: &PathBuf) -> Option<Ordering>`[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

#### `#[must_use] fn lt(&self, other: &Rhs) -> bool`[src]

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

#### `#[must_use] fn le(&self, other: &Rhs) -> bool`[src]

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

#### `#[must_use] fn gt(&self, other: &Rhs) -> bool`[src]

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

#### `#[must_use] fn ge(&self, other: &Rhs) -> bool`[src]

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

### `impl<'a, 'b> PartialOrd<PathBuf> for &'a Path` 1.8.0[src]

#### `fn partial_cmp(&self, other: &PathBuf) -> Option<Ordering>`[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

#### `#[must_use] fn lt(&self, other: &Rhs) -> bool`[src]

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

#### `#[must_use] fn le(&self, other: &Rhs) -> bool`[src]

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

#### `#[must_use] fn gt(&self, other: &Rhs) -> bool`[src]

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

#### `#[must_use] fn ge(&self, other: &Rhs) -> bool`[src]

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

### `impl<'a, 'b> PartialOrd<PathBuf> for Cow<'a, Path>`1.8.0[src]

#### `fn partial_cmp(&self, other: &PathBuf) -> Option<Ordering>`[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

#### `#[must_use] fn lt(&self, other: &Rhs) -> bool`[src]

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

#### `#[must_use] fn le(&self, other: &Rhs) -> bool`[src]

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

#### `#[must_use] fn gt(&self, other: &Rhs) -> bool`[src]

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

#### `#[must_use] fn ge(&self, other: &Rhs) -> bool`[src]

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

### `impl<'a, 'b> PartialOrd<PathBuf> for OsStr` 1.8.0[src]

#### `fn partial_cmp(&self, other: &PathBuf) -> Option<Ordering>`[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

#### `#[must_use] fn lt(&self, other: &Rhs) -> bool`[src]

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

#### `#[must_use] fn le(&self, other: &Rhs) -> bool`[src]

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

#### `#[must_use] fn gt(&self, other: &Rhs) -> bool`[src]

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

#### `#[must_use] fn ge(&self, other: &Rhs) -> bool`[src]

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

### `impl<'a, 'b> PartialOrd<PathBuf> for &'a OsStr` 1.8.0[src]

#### `fn partial_cmp(&self, other: &PathBuf) -> Option<Ordering>`[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

#### `#[must_use] fn lt(&self, other: &Rhs) -> bool`[src]

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

#### `#[must_use] fn le(&self, other: &Rhs) -> bool`[src]

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

#### `#[must_use] fn gt(&self, other: &Rhs) -> bool`[src]

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

#### `#[must_use] fn ge(&self, other: &Rhs) -> bool`[src]

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

### `impl<'a, 'b> PartialOrd<PathBuf> for Cow<'a, OsStr>`1.8.0[src]

#### `fn partial_cmp(&self, other: &PathBuf) -> Option<Ordering>`[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

#### `#[must_use] fn lt(&self, other: &Rhs) -> bool`[src]

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

#### `#[must_use] fn le(&self, other: &Rhs) -> bool`[src]

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

#### `#[must_use] fn gt(&self, other: &Rhs) -> bool`[src]

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

#### `#[must_use] fn ge(&self, other: &Rhs) -> bool`[src]

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

### `impl<'a, 'b> PartialOrd<PathBuf> for OsString` 1.8.0[src]

#### `fn partial_cmp(&self, other: &PathBuf) -> Option<Ordering>`[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

#### `#[must_use] fn lt(&self, other: &Rhs) -> bool`[src]

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

#### `#[must_use] fn le(&self, other: &Rhs) -> bool`[src]

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

#### `#[must_use] fn gt(&self, other: &Rhs) -> bool`[src]

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

#### `#[must_use] fn ge(&self, other: &Rhs) -> bool`[src]

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

## Auto Trait Implementations

### `impl RefUnwindSafe for PathBuf`

### `impl Send for PathBuf`

### `impl Sync for PathBuf`

### `impl Unpin for PathBuf`

### `impl UnwindSafe for PathBuf`

## Blanket Implementations

### `impl<T> Any for T where
T: 'static + ?Sized,` [src]

#### `fn type_id(&self) -> TypeId`[src]

Gets the `TypeId` of `self`. Read more

### `impl<T> Borrow<T> for T where
T: ?Sized,` [src]

####
ⓘImportant traits for &'_ mut I

### Important traits for &'_ mut I

`impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<'_, R: Read + ?Sized> Read for &'_ mut Rimpl<'_, W: Write + ?Sized> Write for &'_ mut W`
`fn borrow(&self) -> &T`[src]

Immutably borrows from an owned value. Read more

### `impl<T> BorrowMut<T> for T where
T: ?Sized,` [src]

####
ⓘImportant traits for &'_ mut I

### Important traits for &'_ mut I

`impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<'_, R: Read + ?Sized> Read for &'_ mut Rimpl<'_, W: Write + ?Sized> Write for &'_ mut W`
`fn borrow_mut(&mut self) -> &mut T`[src]

Mutably borrows from an owned value. Read more

### `impl<T> From<T> for T`[src]

#### `fn from(t: T) -> T`[src]

Performs the conversion.

### `impl<T, U> Into<U> for T where
U: From<T>,` [src]

#### `fn into(self) -> U`[src]

Performs the conversion.

### `impl<T> ToOwned for T where
T: Clone,` [src]

#### `type Owned = T`

The resulting type after obtaining ownership.

#### `fn to_owned(&self) -> T`[src]

Creates owned data from borrowed data, usually by cloning. Read more

#### `fn clone_into(&self, target: &mut T)`[src]

🔬 This is a nightly-only experimental API. (`toowned_clone_into` #41263)

recently added

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

### `impl<T, U> TryFrom<U> for T where
U: Into<T>,` [src]

#### `type Error = Infallible`

The type returned in the event of a conversion error.

#### `fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>`[src]

Performs the conversion.

### `impl<T, U> TryInto<U> for T where
U: TryFrom<T>,` [src]

#### `type Error = <U as TryFrom<T>>::Error`

The type returned in the event of a conversion error.

#### `fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>`[src]

Performs the conversion.