Struct CdManager

pub struct CdManager<'a> { /* private fields */ }

A “Change Directory” manager or CdManager prevents you from forgetting to pop directories at the end of a block.

It takes a reference to a PathBuf and, upon going out of scope, will manually pop all elements of the PathBuf off that were added during its life.

The only supported operations are push or pop, more complex operations such as cannot easily be managed.

Note that the CdManager uses a path’s Components to determine how many times to call pop, so this may cause some inconsistency if your path includes ..

A CdManager implements AsRef<Path> so it may be used anywhere a Path is needed.

Implementations

impl<'a> CdManager<'a>

pub fn new(path: &'a mut PathBuf) -> Self

Starts a new context from the given PathBuf

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

Pushes a Path onto the PathBuf, to be undone when the CdManager goes out of scope.

extern crate cd_manager;
use cd_manager::CdManager;
use std::path::PathBuf;

let mut path = PathBuf::from("a/path/to/something".to_string());
let mut p2 = path.clone();

{
    let mut manager = CdManager::new(&mut p2);

    path.push("foo/bar");
    manager.push("foo/bar");

    assert_eq!(path, manager);
} // Automatically pop "foo" from the manager

path.pop();
path.pop();
assert_eq!(path, p2);

pub fn pop(&mut self) -> Result<(), Error>

Pops a single link from the underlying PathBuf. This will return an error if this is identical to the PathBuf the CdManager was constructured with (that is, the number of pop calls matches the number of pushed Path components).

extern crate cd_manager;
use cd_manager::CdManager;
use std::path::PathBuf;

let mut path = PathBuf::from("a/path".to_string());
let mut p2 = path.clone();
{
    let mut cd = CdManager::new(&mut p2);
    cd.push("foo");

    cd.pop().unwrap();
    assert_eq!(cd, path);

    assert!(cd.pop().is_err());
}

assert_eq!(path, p2);

pub fn layer(&mut self) -> CdManager<'_>

Creates a new “layer” of the manager, for scoping purposes

That is, if you call CdManager::layer in a loop body or function call, it ensures that any behavior done to the returned CdManager will be undone for you.

You can think of this as a cheaper, scoped Clone.

extern crate cd_manager;
use cd_manager::CdManager;
use std::path::PathBuf;

let mut path = PathBuf::from("a/path".to_string());
let mut p2 = path.clone();

let mut cd = CdManager::new(&mut p2);

for _ in 0..100 {
    assert_eq!(cd, path);
    let mut cd = cd.layer();
    cd.push("bar");

    path.push("bar");
    assert_eq!(cd, path);
    path.pop();
}

pub fn clone_inner(&self) -> PathBuf

Returns a clone of the inner PathBuf.

Trait Implementations

impl<'a> AsRef<Path> for CdManager<'a>

fn as_ref(&self) -> &Path

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

impl<'a> Debug for CdManager<'a>

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

Formats the value using the given formatter.

impl<'a> Drop for CdManager<'a>

fn drop(&mut self)

Executes the destructor for this type.

impl<'a> PartialEq<CdManager<'a>> for PathBuf

fn eq(&self, other: &CdManager<'_>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, P: AsRef<Path>> PartialEq<P> for CdManager<'a>

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> Eq for CdManager<'a>