From 28e3340a078bfb53fd621900fb17d42d6e718526 Mon Sep 17 00:00:00 2001 From: Huon Wilson Date: Sat, 12 Apr 2014 20:42:17 +1000 Subject: [PATCH] std: migrate path::unix to using Vec internally. --- src/libstd/path/mod.rs | 35 ++++++++--------- src/libstd/path/posix.rs | 79 +++++++++++++++++++++----------------- src/libstd/path/windows.rs | 22 ++++++----- 3 files changed, 72 insertions(+), 64 deletions(-) diff --git a/src/libstd/path/mod.rs b/src/libstd/path/mod.rs index 660f92d8f7b92..72cbdccddc03b 100644 --- a/src/libstd/path/mod.rs +++ b/src/libstd/path/mod.rs @@ -70,10 +70,10 @@ 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 slice::{OwnedCloneableVector, OwnedVector, Vector}; use slice::{ImmutableEqVector, ImmutableVector}; +use vec::Vec; /// Typedef for POSIX file paths. /// See `posix::Path` for more info. @@ -184,7 +184,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; /// Returns an object that implements `Show` for printing paths /// @@ -293,7 +293,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 +301,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 +441,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 #[inline] - fn container_into_owned_bytes(self) -> ~[u8] { - self.container_as_bytes().to_owned() + fn container_into_owned_bytes(self) -> Vec { + Vec::from_slice(self.container_as_bytes()) } /// Returns the receiver interpreted as a utf-8 string, if possible #[inline] @@ -522,10 +522,6 @@ impl BytesContainer for ~str { self.as_bytes() } #[inline] - fn container_into_owned_bytes(self) -> ~[u8] { - self.into_bytes() - } - #[inline] fn container_as_str<'a>(&'a self) -> Option<&'a str> { Some(self.as_slice()) } @@ -545,8 +541,15 @@ impl BytesContainer for ~[u8] { fn container_as_bytes<'a>(&'a self) -> &'a [u8] { self.as_slice() } +} + +impl BytesContainer for Vec { + #[inline] + fn container_as_bytes<'a>(&'a self) -> &'a [u8] { + self.as_slice() + } #[inline] - fn container_into_owned_bytes(self) -> ~[u8] { + fn container_into_owned_bytes(self) -> Vec { self } } @@ -564,10 +567,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()) } diff --git a/src/libstd/path/posix.rs b/src/libstd/path/posix.rs index 69504a2ec8fca..72832f0a44fc0 100644 --- a/src/libstd/path/posix.rs +++ b/src/libstd/path/posix.rs @@ -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, // assumed to never be empty or contain NULs sepidx: Option // 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 { self.into_vec() } } @@ -119,38 +120,41 @@ impl GenericPathUnsafe for Path { unsafe fn new_unchecked(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(&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(&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 { 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 { 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+CloneableVector>(v: V) -> ~[u8] { + fn normalize+CloneableVector>(v: V) -> Vec { // 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> { 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) { diff --git a/src/libstd/path/windows.rs b/src/libstd/path/windows.rs index 93d8d9e3eb416..0693694ceabac 100644 --- a/src/libstd/path/windows.rs +++ b/src/libstd/path/windows.rs @@ -24,6 +24,8 @@ 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 @@ -128,7 +130,7 @@ impl BytesContainer for Path { self.as_vec() } #[inline] - fn container_into_owned_bytes(self) -> ~[u8] { + fn container_into_owned_bytes(self) -> Vec { self.into_vec() } #[inline] @@ -331,8 +333,8 @@ impl GenericPath for Path { } #[inline] - fn into_vec(self) -> ~[u8] { - self.repr.into_bytes() + fn into_vec(self) -> Vec { + Vec::from_slice(self.repr.as_bytes()) } #[inline] @@ -526,7 +528,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); @@ -711,12 +713,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![]); } } _ => () @@ -1023,7 +1025,7 @@ fn parse_prefix<'a>(mut path: &'a str) -> Option { } // None result means the string didn't need normalizing -fn normalize_helper<'a>(s: &'a str, prefix: Option) -> (bool,Option<~[&'a str]>) { +fn normalize_helper<'a>(s: &'a str, prefix: Option) -> (bool, Option>) { 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 +1034,11 @@ fn normalize_helper<'a>(s: &'a str, prefix: Option) -> (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) {