mirror of
https://github.com/rust-lang/rust.git
synced 2024-12-05 13:13:40 +00:00
94 lines
2.5 KiB
Rust
94 lines
2.5 KiB
Rust
// build-pass
|
|
|
|
// Regression test for #20797.
|
|
|
|
use std::default::Default;
|
|
use std::io;
|
|
use std::fs;
|
|
use std::path::PathBuf;
|
|
|
|
pub trait PathExtensions {
|
|
fn is_dir(&self) -> bool { false }
|
|
}
|
|
|
|
impl PathExtensions for PathBuf {}
|
|
|
|
/// A strategy for acquiring more subpaths to walk.
|
|
pub trait Strategy {
|
|
type P: PathExtensions;
|
|
/// Gets additional subpaths from a given path.
|
|
fn get_more(&self, item: &Self::P) -> io::Result<Vec<Self::P>>;
|
|
/// Determine whether a path should be walked further.
|
|
/// This is run against each item from `get_more()`.
|
|
fn prune(&self, p: &Self::P) -> bool;
|
|
}
|
|
|
|
/// The basic fully-recursive strategy. Nothing is pruned.
|
|
#[derive(Copy, Clone, Default)]
|
|
pub struct Recursive;
|
|
|
|
impl Strategy for Recursive {
|
|
type P = PathBuf;
|
|
fn get_more(&self, p: &PathBuf) -> io::Result<Vec<PathBuf>> {
|
|
Ok(fs::read_dir(p).unwrap().map(|s| s.unwrap().path()).collect())
|
|
}
|
|
|
|
fn prune(&self, _: &PathBuf) -> bool { false }
|
|
}
|
|
|
|
/// A directory walker of `P` using strategy `S`.
|
|
pub struct Subpaths<S: Strategy> {
|
|
stack: Vec<S::P>,
|
|
strategy: S,
|
|
}
|
|
|
|
impl<S: Strategy> Subpaths<S> {
|
|
/// Creates a directory walker with a root path and strategy.
|
|
pub fn new(p: &S::P, strategy: S) -> io::Result<Subpaths<S>> {
|
|
let stack = strategy.get_more(p)?;
|
|
Ok(Subpaths { stack: stack, strategy: strategy })
|
|
}
|
|
}
|
|
|
|
impl<S: Default + Strategy> Subpaths<S> {
|
|
/// Creates a directory walker with a root path and a default strategy.
|
|
pub fn walk(p: &S::P) -> io::Result<Subpaths<S>> {
|
|
Subpaths::new(p, Default::default())
|
|
}
|
|
}
|
|
|
|
impl<S: Default + Strategy> Default for Subpaths<S> {
|
|
fn default() -> Subpaths<S> {
|
|
Subpaths { stack: Vec::new(), strategy: Default::default() }
|
|
}
|
|
}
|
|
|
|
impl<S: Strategy> Iterator for Subpaths<S> {
|
|
type Item = S::P;
|
|
fn next (&mut self) -> Option<S::P> {
|
|
let mut opt_path = self.stack.pop();
|
|
while opt_path.is_some() && self.strategy.prune(opt_path.as_ref().unwrap()) {
|
|
opt_path = self.stack.pop();
|
|
}
|
|
match opt_path {
|
|
Some(path) => {
|
|
if path.is_dir() {
|
|
let result = self.strategy.get_more(&path);
|
|
match result {
|
|
Ok(dirs) => { self.stack.extend(dirs); },
|
|
Err(..) => { }
|
|
}
|
|
}
|
|
Some(path)
|
|
}
|
|
None => None,
|
|
}
|
|
}
|
|
}
|
|
|
|
fn _foo() {
|
|
let _walker: Subpaths<Recursive> = Subpaths::walk(&PathBuf::from("/home")).unwrap();
|
|
}
|
|
|
|
fn main() {}
|