8389253df0
This commit: * Introduces `std::convert`, providing an implementation of RFC 529. * Deprecates the `AsPath`, `AsOsStr`, and `IntoBytes` traits, all in favor of the corresponding generic conversion traits. Consequently, various IO APIs now take `AsRef<Path>` rather than `AsPath`, and so on. Since the types provided by `std` implement both traits, this should cause relatively little breakage. * Deprecates many `from_foo` constructors in favor of `from`. * Changes `PathBuf::new` to take no argument (creating an empty buffer, as per convention). The previous behavior is now available as `PathBuf::from`. * De-stabilizes `IntoCow`. It's not clear whether we need this separate trait. Closes #22751 Closes #14433 [breaking-change]
81 lines
2.4 KiB
Rust
81 lines
2.4 KiB
Rust
// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
|
|
// file at the top-level directory of this distribution and at
|
|
// http://rust-lang.org/COPYRIGHT.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
|
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
|
// option. This file may not be copied, modified, or distributed
|
|
// except according to those terms.
|
|
|
|
use std::slice;
|
|
use std::path::{Path, PathBuf};
|
|
use session::early_error;
|
|
|
|
#[derive(Clone, Debug)]
|
|
pub struct SearchPaths {
|
|
paths: Vec<(PathKind, PathBuf)>,
|
|
}
|
|
|
|
pub struct Iter<'a> {
|
|
kind: PathKind,
|
|
iter: slice::Iter<'a, (PathKind, PathBuf)>,
|
|
}
|
|
|
|
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
|
|
pub enum PathKind {
|
|
Native,
|
|
Crate,
|
|
Dependency,
|
|
Framework,
|
|
ExternFlag,
|
|
All,
|
|
}
|
|
|
|
impl SearchPaths {
|
|
pub fn new() -> SearchPaths {
|
|
SearchPaths { paths: Vec::new() }
|
|
}
|
|
|
|
pub fn add_path(&mut self, path: &str) {
|
|
let (kind, path) = if path.starts_with("native=") {
|
|
(PathKind::Native, &path["native=".len()..])
|
|
} else if path.starts_with("crate=") {
|
|
(PathKind::Crate, &path["crate=".len()..])
|
|
} else if path.starts_with("dependency=") {
|
|
(PathKind::Dependency, &path["dependency=".len()..])
|
|
} else if path.starts_with("framework=") {
|
|
(PathKind::Framework, &path["framework=".len()..])
|
|
} else if path.starts_with("all=") {
|
|
(PathKind::All, &path["all=".len()..])
|
|
} else {
|
|
(PathKind::All, path)
|
|
};
|
|
if path.is_empty() {
|
|
early_error("empty search path given via `-L`");
|
|
}
|
|
self.paths.push((kind, PathBuf::from(path)));
|
|
}
|
|
|
|
pub fn iter(&self, kind: PathKind) -> Iter {
|
|
Iter { kind: kind, iter: self.paths.iter() }
|
|
}
|
|
}
|
|
|
|
impl<'a> Iterator for Iter<'a> {
|
|
type Item = (&'a Path, PathKind);
|
|
|
|
fn next(&mut self) -> Option<(&'a Path, PathKind)> {
|
|
loop {
|
|
match self.iter.next() {
|
|
Some(&(kind, ref p)) if self.kind == PathKind::All ||
|
|
kind == PathKind::All ||
|
|
kind == self.kind => {
|
|
return Some((p, kind))
|
|
}
|
|
Some(..) => {}
|
|
None => return None,
|
|
}
|
|
}
|
|
}
|
|
}
|