mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

auto merge of #13481 : huonw/rust/devec-path, r=alexcrichton

Browse Source 
Remove the use of ~[] from Path's internals.
This commit is contained in:
bors 2014-04-14 01:41:48 -07:00
commit 5dd94d86c6
4 changed files with 209 additions and 183 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

50
src/libstd/path/mod.rs
View File

@ -63,6 +63,8 @@ println!("path exists: {}", path.exists());
*/
#![deny(deprecated_owned_vector)]
use container::Container;
use c_str::CString;
use clone::Clone;
@ -70,10 +72,11 @@ use fmt;
use iter::Iterator;
use option::{Option, None, Some};
use str;
use str::{MaybeOwned, OwnedStr, Str, StrSlice, from_utf8_lossy};
use slice;
use slice::{CloneableVector, OwnedCloneableVector, OwnedVector, Vector};
use str::{MaybeOwned, Str, StrSlice, from_utf8_lossy};
use strbuf::StrBuf;
use slice::{OwnedCloneableVector, OwnedVector, Vector};
use slice::{ImmutableEqVector, ImmutableVector};
use vec::Vec;
/// Typedef for POSIX file paths.
/// See `posix::Path` for more info.
@ -184,7 +187,7 @@ pub trait GenericPath: Clone + GenericPathUnsafe {
fn as_vec<'a>(&'a self) -> &'a [u8];
/// Converts the Path into an owned byte vector
fn into_vec(self) -> ~[u8];
fn into_vec(self) -> Vec<u8>;
/// Returns an object that implements `Show` for printing paths
///
@ -293,7 +296,7 @@ pub trait GenericPath: Clone + GenericPathUnsafe {
let extlen = extension.container_as_bytes().len();
match (name.rposition_elem(&dot), extlen) {
(None, 0) | (Some(0), 0) => None,
(Some(idx), 0) => Some(name.slice_to(idx).to_owned()),
(Some(idx), 0) => Some(Vec::from_slice(name.slice_to(idx))),
(idx, extlen) => {
let idx = match idx {
None | Some(0) => name.len(),
@ -301,7 +304,7 @@ pub trait GenericPath: Clone + GenericPathUnsafe {
};
let mut v;
v = slice::with_capacity(idx + extlen + 1);
v = Vec::with_capacity(idx + extlen + 1);
v.push_all(name.slice_to(idx));
v.push(dot);
v.push_all(extension.container_as_bytes());
@ -441,10 +444,10 @@ pub trait GenericPath: Clone + GenericPathUnsafe {
pub trait BytesContainer {
/// Returns a &[u8] representing the receiver
fn container_as_bytes<'a>(&'a self) -> &'a [u8];
/// Consumes the receiver and converts it into ~[u8]
/// Consumes the receiver and converts it into Vec<u8>
#[inline]
fn container_into_owned_bytes(self) -> ~[u8] {
self.container_as_bytes().to_owned()
fn container_into_owned_bytes(self) -> Vec<u8> {
Vec::from_slice(self.container_as_bytes())
}
/// Returns the receiver interpreted as a utf-8 string, if possible
#[inline]
@ -522,7 +525,19 @@ impl BytesContainer for ~str {
self.as_bytes()
}
#[inline]
fn container_into_owned_bytes(self) -> ~[u8] {
fn container_as_str<'a>(&'a self) -> Option<&'a str> {
Some(self.as_slice())
}
#[inline]
fn is_str(_: Option<~str>) -> bool { true }
}
impl BytesContainer for StrBuf {
#[inline]
fn container_as_bytes<'a>(&'a self) -> &'a [u8] {
self.as_bytes()
}
#[inline]
fn container_into_owned_bytes(self) -> Vec<u8> {
self.into_bytes()
}
#[inline]
@ -530,7 +545,7 @@ impl BytesContainer for ~str {
Some(self.as_slice())
}
#[inline]
fn is_str(_: Option<~str>) -> bool { true }
fn is_str(_: Option<StrBuf>) -> bool { true }
}
impl<'a> BytesContainer for &'a [u8] {
@ -545,8 +560,15 @@ impl BytesContainer for ~[u8] {
fn container_as_bytes<'a>(&'a self) -> &'a [u8] {
self.as_slice()
}
}
impl BytesContainer for Vec<u8> {
#[inline]
fn container_into_owned_bytes(self) -> ~[u8] {
fn container_as_bytes<'a>(&'a self) -> &'a [u8] {
self.as_slice()
}
#[inline]
fn container_into_owned_bytes(self) -> Vec<u8> {
self
}
}
@ -564,10 +586,6 @@ impl<'a> BytesContainer for str::MaybeOwned<'a> {
self.as_slice().as_bytes()
}
#[inline]
fn container_into_owned_bytes(self) -> ~[u8] {
self.into_owned().into_bytes()
}
#[inline]
fn container_as_str<'b>(&'b self) -> Option<&'b str> {
Some(self.as_slice())
}

124
src/libstd/path/posix.rs
View File

@ -20,9 +20,10 @@ use iter::{AdditiveIterator, Extendable, Iterator, Map};
use option::{Option, None, Some};
use str;
use str::Str;
use slice;
use slice::{CloneableVector, RevSplits, Splits, Vector, VectorVector,
ImmutableEqVector, OwnedVector, ImmutableVector, OwnedCloneableVector};
use vec::Vec;
use super::{BytesContainer, GenericPath, GenericPathUnsafe};
/// Iterator that yields successive components of a Path as &[u8]
@ -40,7 +41,7 @@ pub type RevStrComponents<'a> = Map<'a, &'a [u8], Option<&'a str>,
/// Represents a POSIX file path
#[deriving(Clone)]
pub struct Path {
repr: ~[u8], // assumed to never be empty or contain NULs
repr: Vec<u8>, // assumed to never be empty or contain NULs
sepidx: Option<uint> // index of the final separator in repr
}
@ -103,7 +104,7 @@ impl BytesContainer for Path {
self.as_vec()
}
#[inline]
fn container_into_owned_bytes(self) -> ~[u8] {
fn container_into_owned_bytes(self) -> Vec<u8> {
self.into_vec()
}
}
@ -119,38 +120,41 @@ impl GenericPathUnsafe for Path {
unsafe fn new_unchecked<T: BytesContainer>(path: T) -> Path {
let path = Path::normalize(path.container_as_bytes());
assert!(!path.is_empty());
let idx = path.rposition_elem(&SEP_BYTE);
let idx = path.as_slice().rposition_elem(&SEP_BYTE);
Path{ repr: path, sepidx: idx }
}
unsafe fn set_filename_unchecked<T: BytesContainer>(&mut self, filename: T) {
let filename = filename.container_as_bytes();
match self.sepidx {
None if bytes!("..") == self.repr => {
let mut v = slice::with_capacity(3 + filename.len());
None if bytes!("..") == self.repr.as_slice() => {
let mut v = Vec::with_capacity(3 + filename.len());
v.push_all(dot_dot_static);
v.push(SEP_BYTE);
v.push_all(filename);
self.repr = Path::normalize(v);
// FIXME: this is slow
self.repr = Path::normalize(v.as_slice());
}
None => {
self.repr = Path::normalize(filename);
}
Some(idx) if self.repr.slice_from(idx+1) == bytes!("..") => {
let mut v = slice::with_capacity(self.repr.len() + 1 + filename.len());
v.push_all(self.repr);
let mut v = Vec::with_capacity(self.repr.len() + 1 + filename.len());
v.push_all(self.repr.as_slice());
v.push(SEP_BYTE);
v.push_all(filename);
self.repr = Path::normalize(v);
// FIXME: this is slow
self.repr = Path::normalize(v.as_slice());
}
Some(idx) => {
let mut v = slice::with_capacity(idx + 1 + filename.len());
let mut v = Vec::with_capacity(idx + 1 + filename.len());
v.push_all(self.repr.slice_to(idx+1));
v.push_all(filename);
self.repr = Path::normalize(v);
// FIXME: this is slow
self.repr = Path::normalize(v.as_slice());
}
}
self.sepidx = self.repr.rposition_elem(&SEP_BYTE);
self.sepidx = self.repr.as_slice().rposition_elem(&SEP_BYTE);
}
unsafe fn push_unchecked<T: BytesContainer>(&mut self, path: T) {
@ -159,13 +163,14 @@ impl GenericPathUnsafe for Path {
if path[0] == SEP_BYTE {
self.repr = Path::normalize(path);
} else {
let mut v = slice::with_capacity(self.repr.len() + path.len() + 1);
v.push_all(self.repr);
let mut v = Vec::with_capacity(self.repr.len() + path.len() + 1);
v.push_all(self.repr.as_slice());
v.push(SEP_BYTE);
v.push_all(path);
self.repr = Path::normalize(v);
// FIXME: this is slow
self.repr = Path::normalize(v.as_slice());
}
self.sepidx = self.repr.rposition_elem(&SEP_BYTE);
self.sepidx = self.repr.as_slice().rposition_elem(&SEP_BYTE);
}
}
}
@ -176,13 +181,13 @@ impl GenericPath for Path {
self.repr.as_slice()
}
fn into_vec(self) -> ~[u8] {
fn into_vec(self) -> Vec<u8> {
self.repr
}
fn dirname<'a>(&'a self) -> &'a [u8] {
match self.sepidx {
None if bytes!("..") == self.repr => self.repr.as_slice(),
None if bytes!("..") == self.repr.as_slice() => self.repr.as_slice(),
None => dot_static,
Some(0) => self.repr.slice_to(1),
Some(idx) if self.repr.slice_from(idx+1) == bytes!("..") => self.repr.as_slice(),
@ -192,7 +197,8 @@ impl GenericPath for Path {
fn filename<'a>(&'a self) -> Option<&'a [u8]> {
match self.sepidx {
None if bytes!(".") == self.repr || bytes!("..") == self.repr => None,
None if bytes!(".") == self.repr.as_slice() ||
bytes!("..") == self.repr.as_slice() => None,
None => Some(self.repr.as_slice()),
Some(idx) if self.repr.slice_from(idx+1) == bytes!("..") => None,
Some(0) if self.repr.slice_from(1).is_empty() => None,
@ -202,20 +208,20 @@ impl GenericPath for Path {
fn pop(&mut self) -> bool {
match self.sepidx {
None if bytes!(".") == self.repr => false,
None if bytes!(".") == self.repr.as_slice() => false,
None => {
self.repr = ~['.' as u8];
self.repr = vec!['.' as u8];
self.sepidx = None;
true
}
Some(0) if bytes!("/") == self.repr => false,
Some(0) if bytes!("/") == self.repr.as_slice() => false,
Some(idx) => {
if idx == 0 {
self.repr.truncate(idx+1);
} else {
self.repr.truncate(idx);
}
self.sepidx = self.repr.rposition_elem(&SEP_BYTE);
self.sepidx = self.repr.as_slice().rposition_elem(&SEP_BYTE);
true
}
}
@ -231,7 +237,7 @@ impl GenericPath for Path {
#[inline]
fn is_absolute(&self) -> bool {
self.repr[0] == SEP_BYTE
*self.repr.get(0) == SEP_BYTE
}
fn is_ancestor_of(&self, other: &Path) -> bool {
@ -240,7 +246,7 @@ impl GenericPath for Path {
} else {
let mut ita = self.components();
let mut itb = other.components();
if bytes!(".") == self.repr {
if bytes!(".") == self.repr.as_slice() {
return match itb.next() {
None => true,
Some(b) => b != bytes!("..")
@ -261,6 +267,7 @@ impl GenericPath for Path {
}
}
#[allow(deprecated_owned_vector)]
fn path_relative_from(&self, base: &Path) -> Option<Path> {
if self.is_absolute() != base.is_absolute() {
if self.is_absolute() {
@ -271,7 +278,7 @@ impl GenericPath for Path {
} else {
let mut ita = self.components();
let mut itb = base.components();
let mut comps = ~[];
let mut comps = vec![];
loop {
match (ita.next(), itb.next()) {
(None, None) => break,
@ -295,7 +302,7 @@ impl GenericPath for Path {
}
}
}
Some(Path::new(comps.connect_vec(&SEP_BYTE)))
Some(Path::new(comps.as_slice().connect_vec(&SEP_BYTE)))
}
}
@ -334,7 +341,7 @@ impl Path {
/// Returns a normalized byte vector representation of a path, by removing all empty
/// components, and unnecessary . and .. components.
fn normalize<V: Vector<u8>+CloneableVector<u8>>(v: V) -> ~[u8] {
fn normalize<V: Vector<u8>+CloneableVector<u8>>(v: V) -> Vec<u8> {
// borrowck is being very picky
let val = {
let is_abs = !v.as_slice().is_empty() && v.as_slice()[0] == SEP_BYTE;
@ -344,11 +351,11 @@ impl Path {
None => None,
Some(comps) => {
if is_abs && comps.is_empty() {
Some(~[SEP_BYTE])
Some(vec![SEP_BYTE])
} else {
let n = if is_abs { comps.len() } else { comps.len() - 1} +
comps.iter().map(|v| v.len()).sum();
let mut v = slice::with_capacity(n);
let mut v = Vec::with_capacity(n);
let mut it = comps.move_iter();
if !is_abs {
match it.next() {
@ -366,7 +373,7 @@ impl Path {
}
};
match val {
None => v.into_owned(),
None => Vec::from_slice(v.as_slice()),
Some(val) => val
}
}
@ -376,7 +383,7 @@ impl Path {
/// /a/b/c and a/b/c yield the same set of components.
/// A path of "/" yields no components. A path of "." yields one component.
pub fn components<'a>(&'a self) -> Components<'a> {
let v = if self.repr[0] == SEP_BYTE {
let v = if *self.repr.get(0) == SEP_BYTE {
self.repr.slice_from(1)
} else { self.repr.as_slice() };
let mut ret = v.split(is_sep_byte);
@ -390,7 +397,7 @@ impl Path {
/// Returns an iterator that yields each component of the path in reverse.
/// See components() for details.
pub fn rev_components<'a>(&'a self) -> RevComponents<'a> {
let v = if self.repr[0] == SEP_BYTE {
let v = if *self.repr.get(0) == SEP_BYTE {
self.repr.slice_from(1)
} else { self.repr.as_slice() };
let mut ret = v.rsplit(is_sep_byte);
@ -415,11 +422,11 @@ impl Path {
}
// None result means the byte vector didn't need normalizing
fn normalize_helper<'a>(v: &'a [u8], is_abs: bool) -> Option<~[&'a [u8]]> {
fn normalize_helper<'a>(v: &'a [u8], is_abs: bool) -> Option<Vec<&'a [u8]>> {
if is_abs && v.as_slice().is_empty() {
return None;
}
let mut comps: ~[&'a [u8]] = ~[];
let mut comps: Vec<&'a [u8]> = vec![];
let mut n_up = 0u;
let mut changed = false;
for comp in v.split(is_sep_byte) {
@ -511,9 +518,9 @@ mod tests {
t!(s: Path::new("foo/../../.."), "../..");
t!(s: Path::new("foo/../../bar"), "../bar");
assert!(Path::new(b!("foo/bar")).into_vec() == b!("foo/bar").to_owned());
assert!(Path::new(b!("/foo/../../bar")).into_vec() ==
b!("/bar").to_owned());
assert_eq!(Path::new(b!("foo/bar")).into_vec().as_slice(), b!("foo/bar"));
assert_eq!(Path::new(b!("/foo/../../bar")).into_vec().as_slice(),
b!("/bar"));
let p = Path::new(b!("foo/bar", 0x80));
assert!(p.as_str() == None);
@ -762,7 +769,7 @@ mod tests {
t!(s: "a/b/c", [~"d", ~"e"], "a/b/c/d/e");
t!(v: b!("a/b/c"), [b!("d"), b!("e")], b!("a/b/c/d/e"));
t!(v: b!("a/b/c"), [b!("d"), b!("/e"), b!("f")], b!("/e/f"));
t!(v: b!("a/b/c"), [b!("d").to_owned(), b!("e").to_owned()], b!("a/b/c/d/e"));
t!(v: b!("a/b/c"), [Vec::from_slice(b!("d")), Vec::from_slice(b!("e"))], b!("a/b/c/d/e"));
}
#[test]
@ -866,7 +873,7 @@ mod tests {
t!(s: "a/b/c", ["d", "/e", "f"], "/e/f");
t!(s: "a/b/c", [~"d", ~"e"], "a/b/c/d/e");
t!(v: b!("a/b/c"), [b!("d"), b!("e")], b!("a/b/c/d/e"));
t!(v: b!("a/b/c"), [b!("d").to_owned(), b!("e").to_owned()], b!("a/b/c/d/e"));
t!(v: b!("a/b/c"), [Vec::from_slice(b!("d")), Vec::from_slice(b!("e"))], b!("a/b/c/d/e"));
}
#[test]
@ -1179,13 +1186,13 @@ mod tests {
(s: $path:expr, $exp:expr) => (
{
let path = Path::new($path);
let comps = path.components().collect::<~[&[u8]]>();
let comps = path.components().collect::<Vec<&[u8]>>();
let exp: &[&str] = $exp;
let exps = exp.iter().map(|x| x.as_bytes()).collect::<~[&[u8]]>();
let exps = exp.iter().map(|x| x.as_bytes()).collect::<Vec<&[u8]>>();
assert!(comps == exps, "components: Expected {:?}, found {:?}",
comps, exps);
let comps = path.rev_components().collect::<~[&[u8]]>();
let exps = exps.move_rev_iter().collect::<~[&[u8]]>();
let comps = path.rev_components().collect::<Vec<&[u8]>>();
let exps = exps.move_iter().rev().collect::<Vec<&[u8]>>();
assert!(comps == exps, "rev_components: Expected {:?}, found {:?}",
comps, exps);
}
@ -1193,15 +1200,12 @@ mod tests {
(v: [$($arg:expr),+], [$([$($exp:expr),*]),*]) => (
{
let path = Path::new(b!($($arg),+));
let comps = path.components().collect::<~[&[u8]]>();
let comps = path.components().collect::<Vec<&[u8]>>();
let exp: &[&[u8]] = [$(b!($($exp),*)),*];
assert!(comps.as_slice() == exp, "components: Expected {:?}, found {:?}",
comps.as_slice(), exp);
let comps = path.rev_components().collect::<~[&[u8]]>();
let exp = exp.rev_iter().map(|&x|x).collect::<~[&[u8]]>();
assert!(comps.as_slice() == exp,
"rev_components: Expected {:?}, found {:?}",
comps.as_slice(), exp);
assert_eq!(comps.as_slice(), exp);
let comps = path.rev_components().collect::<Vec<&[u8]>>();
let exp = exp.rev_iter().map(|&x|x).collect::<Vec<&[u8]>>();
assert_eq!(comps, exp)
}
)
)
@ -1228,16 +1232,12 @@ mod tests {
(v: [$($arg:expr),+], $exp:expr) => (
{
let path = Path::new(b!($($arg),+));
let comps = path.str_components().collect::<~[Option<&str>]>();
let comps = path.str_components().collect::<Vec<Option<&str>>>();
let exp: &[Option<&str>] = $exp;
assert!(comps.as_slice() == exp,
"str_components: Expected {:?}, found {:?}",
comps.as_slice(), exp);
let comps = path.rev_str_components().collect::<~[Option<&str>]>();
let exp = exp.rev_iter().map(|&x|x).collect::<~[Option<&str>]>();
assert!(comps.as_slice() == exp,
"rev_str_components: Expected {:?}, found {:?}",
comps.as_slice(), exp);
assert_eq!(comps.as_slice(), exp);
let comps = path.rev_str_components().collect::<Vec<Option<&str>>>();
let exp = exp.rev_iter().map(|&x|x).collect::<Vec<Option<&str>>>();
assert_eq!(comps, exp);
}
)
)

208
src/libstd/path/windows.rs
View File

@ -22,8 +22,9 @@ use iter::{AdditiveIterator, DoubleEndedIterator, Extendable, Rev, Iterator, Map
use option::{Option, Some, None};
use slice::{Vector, OwnedVector, ImmutableVector};
use str::{CharSplits, OwnedStr, Str, StrVector, StrSlice};
use str;
use strbuf::StrBuf;
use vec::Vec;
use super::{contains_nul, BytesContainer, GenericPath, GenericPathUnsafe};
/// Iterator that yields successive components of a Path as &str
@ -82,7 +83,7 @@ pub type RevComponents<'a> = Map<'a, Option<&'a str>, &'a [u8],
// preserved by the data structure; let the Windows API error out on them.
#[deriving(Clone)]
pub struct Path {
repr: ~str, // assumed to never be empty
repr: StrBuf, // assumed to never be empty
prefix: Option<PathPrefix>,
sepidx: Option<uint> // index of the final separator in the non-prefix portion of repr
}
@ -128,7 +129,7 @@ impl BytesContainer for Path {
self.as_vec()
}
#[inline]
fn container_into_owned_bytes(self) -> ~[u8] {
fn container_into_owned_bytes(self) -> Vec<u8> {
self.into_vec()
}
#[inline]
@ -175,7 +176,7 @@ impl GenericPathUnsafe for Path {
unsafe fn set_filename_unchecked<T: BytesContainer>(&mut self, filename: T) {
let filename = filename.container_as_str().unwrap();
match self.sepidx_or_prefix_len() {
None if ".." == self.repr => {
None if ".." == self.repr.as_slice() => {
let mut s = StrBuf::with_capacity(3 + filename.len());
s.push_str("..");
s.push_char(SEP);
@ -185,22 +186,22 @@ impl GenericPathUnsafe for Path {
None => {
self.update_normalized(filename);
}
Some((_,idxa,end)) if self.repr.slice(idxa,end) == ".." => {
Some((_,idxa,end)) if self.repr.as_slice().slice(idxa,end) == ".." => {
let mut s = StrBuf::with_capacity(end + 1 + filename.len());
s.push_str(self.repr.slice_to(end));
s.push_str(self.repr.as_slice().slice_to(end));
s.push_char(SEP);
s.push_str(filename);
self.update_normalized(s);
}
Some((idxb,idxa,_)) if self.prefix == Some(DiskPrefix) && idxa == self.prefix_len() => {
let mut s = StrBuf::with_capacity(idxb + filename.len());
s.push_str(self.repr.slice_to(idxb));
s.push_str(self.repr.as_slice().slice_to(idxb));
s.push_str(filename);
self.update_normalized(s);
}
Some((idxb,_,_)) => {
let mut s = StrBuf::with_capacity(idxb + 1 + filename.len());
s.push_str(self.repr.slice_to(idxb));
s.push_str(self.repr.as_slice().slice_to(idxb));
s.push_char(SEP);
s.push_str(filename);
self.update_normalized(s);
@ -227,9 +228,10 @@ impl GenericPathUnsafe for Path {
}
fn shares_volume(me: &Path, path: &str) -> bool {
// path is assumed to have a prefix of Some(DiskPrefix)
let repr = me.repr.as_slice();
match me.prefix {
Some(DiskPrefix) => me.repr[0] == path[0].to_ascii().to_upper().to_byte(),
Some(VerbatimDiskPrefix) => me.repr[4] == path[0].to_ascii().to_upper().to_byte(),
Some(DiskPrefix) => repr[0] == path[0].to_ascii().to_upper().to_byte(),
Some(VerbatimDiskPrefix) => repr[4] == path[0].to_ascii().to_upper().to_byte(),
_ => false
}
}
@ -242,7 +244,7 @@ impl GenericPathUnsafe for Path {
let newpath = Path::normalize__(path, prefix);
me.repr = match newpath {
Some(p) => p,
None => path.to_owned()
None => StrBuf::from_str(path)
};
me.prefix = prefix;
me.update_sepidx();
@ -254,19 +256,19 @@ impl GenericPathUnsafe for Path {
else { None };
let pathlen = path_.as_ref().map_or(path.len(), |p| p.len());
let mut s = StrBuf::with_capacity(me.repr.len() + 1 + pathlen);
s.push_str(me.repr);
s.push_str(me.repr.as_slice());
let plen = me.prefix_len();
// if me is "C:" we don't want to add a path separator
match me.prefix {
Some(DiskPrefix) if me.repr.len() == plen => (),
_ if !(me.repr.len() > plen && me.repr[me.repr.len()-1] == SEP_BYTE) => {
_ if !(me.repr.len() > plen && me.repr.as_slice()[me.repr.len()-1] == SEP_BYTE) => {
s.push_char(SEP);
}
_ => ()
}
match path_ {
None => s.push_str(path),
Some(p) => s.push_str(p)
Some(p) => s.push_str(p.as_slice())
};
me.update_normalized(s)
}
@ -331,8 +333,8 @@ impl GenericPath for Path {
}
#[inline]
fn into_vec(self) -> ~[u8] {
self.repr.into_bytes()
fn into_vec(self) -> Vec<u8> {
Vec::from_slice(self.repr.as_bytes())
}
#[inline]
@ -344,21 +346,21 @@ impl GenericPath for Path {
/// Always returns a `Some` value.
fn dirname_str<'a>(&'a self) -> Option<&'a str> {
Some(match self.sepidx_or_prefix_len() {
None if ".." == self.repr => self.repr.as_slice(),
None if ".." == self.repr.as_slice() => self.repr.as_slice(),
None => ".",
Some((_,idxa,end)) if self.repr.slice(idxa, end) == ".." => {
Some((_,idxa,end)) if self.repr.as_slice().slice(idxa, end) == ".." => {
self.repr.as_slice()
}
Some((idxb,_,end)) if self.repr.slice(idxb, end) == "\\" => {
Some((idxb,_,end)) if self.repr.as_slice().slice(idxb, end) == "\\" => {
self.repr.as_slice()
}
Some((0,idxa,_)) => self.repr.slice_to(idxa),
Some((0,idxa,_)) => self.repr.as_slice().slice_to(idxa),
Some((idxb,idxa,_)) => {
match self.prefix {
Some(DiskPrefix) | Some(VerbatimDiskPrefix) if idxb == self.prefix_len() => {
self.repr.slice_to(idxa)
self.repr.as_slice().slice_to(idxa)
}
_ => self.repr.slice_to(idxb)
_ => self.repr.as_slice().slice_to(idxb)
}
}
})
@ -372,12 +374,13 @@ impl GenericPath for Path {
/// See `GenericPath::filename_str` for info.
/// Always returns a `Some` value if `filename` returns a `Some` value.
fn filename_str<'a>(&'a self) -> Option<&'a str> {
let repr = self.repr.as_slice();
match self.sepidx_or_prefix_len() {
None if "." == self.repr || ".." == self.repr => None,
None => Some(self.repr.as_slice()),
Some((_,idxa,end)) if self.repr.slice(idxa, end) == ".." => None,
None if "." == repr || ".." == repr => None,
None => Some(repr),
Some((_,idxa,end)) if repr.slice(idxa, end) == ".." => None,
Some((_,idxa,end)) if idxa == end => None,
Some((_,idxa,end)) => Some(self.repr.slice(idxa, end))
Some((_,idxa,end)) => Some(repr.slice(idxa, end))
}
}
@ -402,14 +405,14 @@ impl GenericPath for Path {
#[inline]
fn pop(&mut self) -> bool {
match self.sepidx_or_prefix_len() {
None if "." == self.repr => false,
None if "." == self.repr.as_slice() => false,
None => {
self.repr = ~".";
self.repr = StrBuf::from_str(".");
self.sepidx = None;
true
}
Some((idxb,idxa,end)) if idxb == idxa && idxb == end => false,
Some((idxb,_,end)) if self.repr.slice(idxb, end) == "\\" => false,
Some((idxb,_,end)) if self.repr.as_slice().slice(idxb, end) == "\\" => false,
Some((idxb,idxa,_)) => {
let trunc = match self.prefix {
Some(DiskPrefix) | Some(VerbatimDiskPrefix) | None => {
@ -429,15 +432,15 @@ impl GenericPath for Path {
if self.prefix.is_some() {
Some(Path::new(match self.prefix {
Some(DiskPrefix) if self.is_absolute() => {
self.repr.slice_to(self.prefix_len()+1)
self.repr.as_slice().slice_to(self.prefix_len()+1)
}
Some(VerbatimDiskPrefix) => {
self.repr.slice_to(self.prefix_len()+1)
self.repr.as_slice().slice_to(self.prefix_len()+1)
}
_ => self.repr.slice_to(self.prefix_len())
_ => self.repr.as_slice().slice_to(self.prefix_len())
}))
} else if is_vol_relative(self) {
Some(Path::new(self.repr.slice_to(1)))
Some(Path::new(self.repr.as_slice().slice_to(1)))
} else {
None
}
@ -456,7 +459,7 @@ impl GenericPath for Path {
fn is_absolute(&self) -> bool {
match self.prefix {
Some(DiskPrefix) => {
let rest = self.repr.slice_from(self.prefix_len());
let rest = self.repr.as_slice().slice_from(self.prefix_len());
rest.len() > 0 && rest[0] == SEP_BYTE
}
Some(_) => true,
@ -478,7 +481,7 @@ impl GenericPath for Path {
} else {
let mut ita = self.str_components().map(|x|x.unwrap());
let mut itb = other.str_components().map(|x|x.unwrap());
if "." == self.repr {
if "." == self.repr.as_slice() {
return itb.next() != Some("..");
}
loop {
@ -526,7 +529,7 @@ impl GenericPath for Path {
} else {
let mut ita = self.str_components().map(|x|x.unwrap());
let mut itb = base.str_components().map(|x|x.unwrap());
let mut comps = ~[];
let mut comps = vec![];
let a_verb = is_verbatim(self);
let b_verb = is_verbatim(base);
@ -613,15 +616,16 @@ impl Path {
/// Does not distinguish between absolute and cwd-relative paths, e.g.
/// C:\foo and C:foo.
pub fn str_components<'a>(&'a self) -> StrComponents<'a> {
let repr = self.repr.as_slice();
let s = match self.prefix {
Some(_) => {
let plen = self.prefix_len();
if self.repr.len() > plen && self.repr[plen] == SEP_BYTE {
self.repr.slice_from(plen+1)
} else { self.repr.slice_from(plen) }
if repr.len() > plen && repr[plen] == SEP_BYTE {
repr.slice_from(plen+1)
} else { repr.slice_from(plen) }
}
None if self.repr[0] == SEP_BYTE => self.repr.slice_from(1),
None => self.repr.as_slice()
None if repr[0] == SEP_BYTE => repr.slice_from(1),
None => repr
};
let ret = s.split_terminator(SEP).map(Some);
ret
@ -654,33 +658,35 @@ impl Path {
}
fn equiv_prefix(&self, other: &Path) -> bool {
let s_repr = self.repr.as_slice();
let o_repr = other.repr.as_slice();
match (self.prefix, other.prefix) {
(Some(DiskPrefix), Some(VerbatimDiskPrefix)) => {
self.is_absolute() &&
self.repr[0].to_ascii().eq_ignore_case(other.repr[4].to_ascii())
s_repr[0].to_ascii().eq_ignore_case(o_repr[4].to_ascii())
}
(Some(VerbatimDiskPrefix), Some(DiskPrefix)) => {
other.is_absolute() &&
self.repr[4].to_ascii().eq_ignore_case(other.repr[0].to_ascii())
s_repr[4].to_ascii().eq_ignore_case(o_repr[0].to_ascii())
}
(Some(VerbatimDiskPrefix), Some(VerbatimDiskPrefix)) => {
self.repr[4].to_ascii().eq_ignore_case(other.repr[4].to_ascii())
s_repr[4].to_ascii().eq_ignore_case(o_repr[4].to_ascii())
}
(Some(UNCPrefix(_,_)), Some(VerbatimUNCPrefix(_,_))) => {
self.repr.slice(2, self.prefix_len()) == other.repr.slice(8, other.prefix_len())
s_repr.slice(2, self.prefix_len()) == o_repr.slice(8, other.prefix_len())
}
(Some(VerbatimUNCPrefix(_,_)), Some(UNCPrefix(_,_))) => {
self.repr.slice(8, self.prefix_len()) == other.repr.slice(2, other.prefix_len())
s_repr.slice(8, self.prefix_len()) == o_repr.slice(2, other.prefix_len())
}
(None, None) => true,
(a, b) if a == b => {
self.repr.slice_to(self.prefix_len()) == other.repr.slice_to(other.prefix_len())
s_repr.slice_to(self.prefix_len()) == o_repr.slice_to(other.prefix_len())
}
_ => false
}
}
fn normalize_<S: Str>(s: S) -> (Option<PathPrefix>, ~str) {
fn normalize_<S: Str>(s: S) -> (Option<PathPrefix>, StrBuf) {
// make borrowck happy
let (prefix, val) = {
let prefix = parse_prefix(s.as_slice());
@ -688,20 +694,20 @@ impl Path {
(prefix, path)
};
(prefix, match val {
None => s.into_owned(),
None => s.into_strbuf(),
Some(val) => val
})
}
fn normalize__(s: &str, prefix: Option<PathPrefix>) -> Option<~str> {
fn normalize__(s: &str, prefix: Option<PathPrefix>) -> Option<StrBuf> {
if prefix_is_verbatim(prefix) {
// don't do any normalization
match prefix {
Some(VerbatimUNCPrefix(x, 0)) if s.len() == 8 + x => {
// the server component has no trailing '\'
let mut s = StrBuf::from_owned_str(s.into_owned());
let mut s = StrBuf::from_str(s);
s.push_char(SEP);
Some(s.into_owned())
Some(s)
}
_ => None
}
@ -711,12 +717,12 @@ impl Path {
match (comps.is_some(),prefix) {
(false, Some(DiskPrefix)) => {
if s[0] >= 'a' as u8 && s[0] <= 'z' as u8 {
comps = Some(~[]);
comps = Some(vec![]);
}
}
(false, Some(VerbatimDiskPrefix)) => {
if s[4] >= 'a' as u8 && s[0] <= 'z' as u8 {
comps = Some(~[]);
comps = Some(vec![]);
}
}
_ => ()
@ -728,37 +734,37 @@ impl Path {
match prefix.unwrap() {
DiskPrefix => {
let len = prefix_len(prefix) + is_abs as uint;
let mut s = s.slice_to(len).to_owned();
let mut s = StrBuf::from_str(s.slice_to(len));
unsafe {
str::raw::as_owned_vec(&mut s)[0] =
s[0].to_ascii().to_upper().to_byte();
let v = s.as_mut_vec();
*v.get_mut(0) = v.get(0).to_ascii().to_upper().to_byte();
}
if is_abs {
// normalize C:/ to C:\
unsafe {
str::raw::as_owned_vec(&mut s)[2] = SEP_BYTE;
*s.as_mut_vec().get_mut(2) = SEP_BYTE;
}
}
Some(s)
}
VerbatimDiskPrefix => {
let len = prefix_len(prefix) + is_abs as uint;
let mut s = s.slice_to(len).to_owned();
let mut s = StrBuf::from_str(s.slice_to(len));
unsafe {
str::raw::as_owned_vec(&mut s)[4] =
s[4].to_ascii().to_upper().to_byte();
let v = s.as_mut_vec();
*v.get_mut(4) = v.get(4).to_ascii().to_upper().to_byte();
}
Some(s)
}
_ => {
let plen = prefix_len(prefix);
if s.len() > plen {
Some(s.slice_to(plen).to_owned())
Some(StrBuf::from_str(s.slice_to(plen)))
} else { None }
}
}
} else if is_abs && comps.is_empty() {
Some(str::from_char(SEP))
Some(StrBuf::from_char(1, SEP))
} else {
let prefix_ = s.slice_to(prefix_len(prefix));
let n = prefix_.len() +
@ -795,7 +801,7 @@ impl Path {
s.push_char(SEP);
s.push_str(comp);
}
Some(s.into_owned())
Some(s)
}
}
}
@ -804,7 +810,7 @@ impl Path {
fn update_sepidx(&mut self) {
let s = if self.has_nonsemantic_trailing_slash() {
self.repr.slice_to(self.repr.len()-1)
self.repr.as_slice().slice_to(self.repr.len()-1)
} else { self.repr.as_slice() };
let idx = s.rfind(if !prefix_is_verbatim(self.prefix) { is_sep }
else { is_sep_verbatim });
@ -834,7 +840,7 @@ impl Path {
fn has_nonsemantic_trailing_slash(&self) -> bool {
is_verbatim(self) && self.repr.len() > self.prefix_len()+1 &&
self.repr[self.repr.len()-1] == SEP_BYTE
self.repr.as_slice()[self.repr.len()-1] == SEP_BYTE
}
fn update_normalized<S: Str>(&mut self, s: S) {
@ -850,7 +856,7 @@ impl Path {
/// but absolute within that volume.
#[inline]
pub fn is_vol_relative(path: &Path) -> bool {
path.prefix.is_none() && is_sep_byte(&path.repr[0])
path.prefix.is_none() && is_sep_byte(&path.repr.as_slice()[0])
}
/// Returns whether the path is considered "cwd-relative", which means a path
@ -880,16 +886,17 @@ pub fn is_verbatim(path: &Path) -> bool {
/// non-verbatim, the non-verbatim version is returned.
/// Otherwise, None is returned.
pub fn make_non_verbatim(path: &Path) -> Option<Path> {
let repr = path.repr.as_slice();
let new_path = match path.prefix {
Some(VerbatimPrefix(_)) | Some(DeviceNSPrefix(_)) => return None,
Some(UNCPrefix(_,_)) | Some(DiskPrefix) | None => return Some(path.clone()),
Some(VerbatimDiskPrefix) => {
// \\?\D:\
Path::new(path.repr.slice_from(4))
Path::new(repr.slice_from(4))
}
Some(VerbatimUNCPrefix(_,_)) => {
// \\?\UNC\server\share
Path::new(format!(r"\\{}", path.repr.slice_from(7)))
Path::new(format!(r"\\{}", repr.slice_from(7)))
}
};
if new_path.prefix.is_none() {
@ -898,7 +905,8 @@ pub fn make_non_verbatim(path: &Path) -> Option<Path> {
return None;
}
// now ensure normalization didn't change anything
if path.repr.slice_from(path.prefix_len()) == new_path.repr.slice_from(new_path.prefix_len()) {
if repr.slice_from(path.prefix_len()) ==
new_path.repr.as_slice().slice_from(new_path.prefix_len()) {
Some(new_path)
} else {
None
@ -1023,7 +1031,7 @@ fn parse_prefix<'a>(mut path: &'a str) -> Option<PathPrefix> {
}
// None result means the string didn't need normalizing
fn normalize_helper<'a>(s: &'a str, prefix: Option<PathPrefix>) -> (bool,Option<~[&'a str]>) {
fn normalize_helper<'a>(s: &'a str, prefix: Option<PathPrefix>) -> (bool, Option<Vec<&'a str>>) {
let f = if !prefix_is_verbatim(prefix) { is_sep } else { is_sep_verbatim };
let is_abs = s.len() > prefix_len(prefix) && f(s.char_at(prefix_len(prefix)));
let s_ = s.slice_from(prefix_len(prefix));
@ -1032,11 +1040,11 @@ fn normalize_helper<'a>(s: &'a str, prefix: Option<PathPrefix>) -> (bool,Option<
if is_abs && s_.is_empty() {
return (is_abs, match prefix {
Some(DiskPrefix) | None => (if is_sep_verbatim(s.char_at(prefix_len(prefix))) { None }
else { Some(~[]) }),
Some(_) => Some(~[]), // need to trim the trailing separator
else { Some(vec![]) }),
Some(_) => Some(vec![]), // need to trim the trailing separator
});
}
let mut comps: ~[&'a str] = ~[];
let mut comps: Vec<&'a str> = vec![];
let mut n_up = 0u;
let mut changed = false;
for comp in s_.split(f) {
@ -1217,9 +1225,8 @@ mod tests {
t!(s: Path::new("foo\\..\\..\\.."), "..\\..");
t!(s: Path::new("foo\\..\\..\\bar"), "..\\bar");
assert_eq!(Path::new(b!("foo\\bar")).into_vec(), b!("foo\\bar").to_owned());
assert_eq!(Path::new(b!("\\foo\\..\\..\\bar")).into_vec(),
b!("\\bar").to_owned());
assert_eq!(Path::new(b!("foo\\bar")).into_vec().as_slice(), b!("foo\\bar"));
assert_eq!(Path::new(b!("\\foo\\..\\..\\bar")).into_vec().as_slice(), b!("\\bar"));
t!(s: Path::new("\\\\a"), "\\a");
t!(s: Path::new("\\\\a\\"), "\\a");
@ -1573,7 +1580,8 @@ mod tests {
t!(s: "a\\b\\c", [~"d", ~"e"], "a\\b\\c\\d\\e");
t!(v: b!("a\\b\\c"), [b!("d"), b!("e")], b!("a\\b\\c\\d\\e"));
t!(v: b!("a\\b\\c"), [b!("d"), b!("\\e"), b!("f")], b!("\\e\\f"));
t!(v: b!("a\\b\\c"), [b!("d").to_owned(), b!("e").to_owned()], b!("a\\b\\c\\d\\e"));
t!(v: b!("a\\b\\c"), [Vec::from_slice(b!("d")), Vec::from_slice(b!("e"))],
b!("a\\b\\c\\d\\e"));
}
#[test]
@ -1712,7 +1720,8 @@ mod tests {
t!(s: "a\\b\\c", ["d", "\\e", "f"], "\\e\\f");
t!(s: "a\\b\\c", [~"d", ~"e"], "a\\b\\c\\d\\e");
t!(v: b!("a\\b\\c"), [b!("d"), b!("e")], b!("a\\b\\c\\d\\e"));
t!(v: b!("a\\b\\c"), [b!("d").to_owned(), b!("e").to_owned()], b!("a\\b\\c\\d\\e"));
t!(v: b!("a\\b\\c"), [Vec::from_slice(b!("d")), Vec::from_slice(b!("e"))],
b!("a\\b\\c\\d\\e"));
}
#[test]
@ -2227,33 +2236,25 @@ mod tests {
{
let path = Path::new($path);
let comps = path.str_components().map(|x|x.unwrap())
.collect::<~[&str]>();
.collect::<Vec<&str>>();
let exp: &[&str] = $exp;
assert!(comps.as_slice() == exp,
"str_components: Expected {:?}, found {:?}",
comps.as_slice(), exp);
assert_eq!(comps.as_slice(), exp);
let comps = path.rev_str_components().map(|x|x.unwrap())
.collect::<~[&str]>();
let exp = exp.rev_iter().map(|&x|x).collect::<~[&str]>();
assert!(comps.as_slice() == exp,
"rev_str_components: Expected {:?}, found {:?}",
comps.as_slice(), exp);
.collect::<Vec<&str>>();
let exp = exp.rev_iter().map(|&x|x).collect::<Vec<&str>>();
assert_eq!(comps, exp);
}
);
(v: [$($arg:expr),+], $exp:expr) => (
{
let path = Path::new(b!($($arg),+));
let comps = path.str_components().map(|x|x.unwrap()).collect::<~[&str]>();
let comps = path.str_components().map(|x|x.unwrap()).collect::<Vec<&str>>();
let exp: &[&str] = $exp;
assert!(comps.as_slice() == exp,
"str_components: Expected {:?}, found {:?}",
comps.as_slice(), exp);
assert_eq!(comps.as_slice(), exp);
let comps = path.rev_str_components().map(|x|x.unwrap())
.collect::<~[&str]>();
let exp = exp.rev_iter().map(|&x|x).collect::<~[&str]>();
assert!(comps.as_slice() == exp,
"rev_str_components: Expected {:?}, found {:?}",
comps.as_slice(), exp);
.collect::<Vec<&str>>();
let exp = exp.rev_iter().map(|&x|x).collect::<Vec<&str>>();
assert_eq!(comps, exp);
}
)
)
@ -2304,15 +2305,12 @@ mod tests {
(s: $path:expr, $exp:expr) => (
{
let path = Path::new($path);
let comps = path.components().collect::<~[&[u8]]>();
let comps = path.components().collect::<Vec<&[u8]>>();
let exp: &[&[u8]] = $exp;
assert!(comps.as_slice() == exp, "components: Expected {:?}, found {:?}",
comps.as_slice(), exp);
let comps = path.rev_components().collect::<~[&[u8]]>();
let exp = exp.rev_iter().map(|&x|x).collect::<~[&[u8]]>();
assert!(comps.as_slice() == exp,
"rev_components: Expected {:?}, found {:?}",
comps.as_slice(), exp);
assert_eq!(comps.as_slice(), exp);
let comps = path.rev_components().collect::<Vec<&[u8]>>();
let exp = exp.rev_iter().map(|&x|x).collect::<Vec<&[u8]>>();
assert_eq!(comps, exp);
}
)
)

10
src/libstd/strbuf.rs
View File

@ -229,6 +229,13 @@ impl StrBuf {
*self = self.as_slice().slice(1, len).into_strbuf();
Some(byte)
}
/// Views the string buffer as a mutable sequence of bytes.
///
/// Callers must preserve the valid UTF-8 property.
pub unsafe fn as_mut_vec<'a>(&'a mut self) -> &'a mut Vec<u8> {
&mut self.vec
}
}
impl Container for StrBuf {
@ -271,6 +278,9 @@ impl Str for StrBuf {
cast::transmute::<~[u8],~str>(vec.move_iter().collect())
}
}
#[inline]
fn into_strbuf(self) -> StrBuf { self }
}
impl fmt::Show for StrBuf {