use iter::{Iterator, IteratorExt, Map, repeat};
use mem;
use option::Option::{self, Some, None};
-use ops::{FullRange, Index};
+use ops::FullRange;
use slice::{SliceExt, SliceConcatExt};
use str::{SplitTerminator, FromStr, StrExt};
use string::{String, ToString};
s.push_str("..");
s.push(SEP);
s.push_str(filename);
- self.update_normalized(s.index(&FullRange));
+ self.update_normalized(&s[]);
}
None => {
self.update_normalized(filename);
}
- Some((_,idxa,end)) if self.repr.index(&(idxa..end)) == ".." => {
+ Some((_,idxa,end)) if &self.repr[idxa..end] == ".." => {
let mut s = String::with_capacity(end + 1 + filename.len());
- s.push_str(self.repr.index(&(0..end)));
+ s.push_str(&self.repr[..end]);
s.push(SEP);
s.push_str(filename);
- self.update_normalized(s.index(&FullRange));
+ self.update_normalized(&s[]);
}
Some((idxb,idxa,_)) if self.prefix == Some(DiskPrefix) && idxa == self.prefix_len() => {
let mut s = String::with_capacity(idxb + filename.len());
- s.push_str(self.repr.index(&(0..idxb)));
+ s.push_str(&self.repr[..idxb]);
s.push_str(filename);
- self.update_normalized(s.index(&FullRange));
+ self.update_normalized(&s[]);
}
Some((idxb,_,_)) => {
let mut s = String::with_capacity(idxb + 1 + filename.len());
- s.push_str(self.repr.index(&(0..idxb)));
+ s.push_str(&self.repr[..idxb]);
s.push(SEP);
s.push_str(filename);
- self.update_normalized(s.index(&FullRange));
+ self.update_normalized(&s[]);
}
}
}
let path = path.container_as_str().unwrap();
fn is_vol_abs(path: &str, prefix: Option<PathPrefix>) -> bool {
// assume prefix is Some(DiskPrefix)
- let rest = path.index(&(prefix_len(prefix)..));
+ let rest = &path[prefix_len(prefix)..];
!rest.is_empty() && rest.as_bytes()[0].is_ascii() && is_sep(rest.as_bytes()[0] as char)
}
fn shares_volume(me: &Path, path: &str) -> bool {
// path is assumed to have a prefix of Some(DiskPrefix)
- let repr = me.repr.index(&FullRange);
+ let repr = &me.repr[];
match me.prefix {
Some(DiskPrefix) => {
repr.as_bytes()[0] == path.as_bytes()[0].to_ascii_uppercase()
else { None };
let pathlen = path_.as_ref().map_or(path.len(), |p| p.len());
let mut s = String::with_capacity(me.repr.len() + 1 + pathlen);
- s.push_str(me.repr.index(&FullRange));
+ s.push_str(&me.repr[]);
let plen = me.prefix_len();
// if me is "C:" we don't want to add a path separator
match me.prefix {
}
match path_ {
None => s.push_str(path),
- Some(p) => s.push_str(p.index(&FullRange)),
+ Some(p) => s.push_str(&p[]),
};
- me.update_normalized(s.index(&FullRange))
+ me.update_normalized(&s[])
}
if !path.is_empty() {
match prefix {
Some(DiskPrefix) if !is_vol_abs(path, prefix) && shares_volume(self, path) => {
// cwd-relative path, self is on the same volume
- append_path(self, path.index(&(prefix_len(prefix)..)));
+ append_path(self, &path[prefix_len(prefix)..]);
}
Some(_) => {
// absolute path, or cwd-relative and self is not same volume
/// Always returns a `Some` value.
#[inline]
fn as_str<'a>(&'a self) -> Option<&'a str> {
- Some(self.repr.index(&FullRange))
+ Some(&self.repr[])
}
#[inline]
/// 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.index(&FullRange),
+ None if ".." == self.repr => &self.repr[],
None => ".",
- Some((_,idxa,end)) if self.repr.index(&(idxa..end)) == ".." => {
- self.repr.index(&FullRange)
+ Some((_,idxa,end)) if &self.repr[idxa..end] == ".." => {
+ &self.repr[]
}
- Some((idxb,_,end)) if self.repr.index(&(idxb..end)) == "\\" => {
- self.repr.index(&FullRange)
+ Some((idxb,_,end)) if &self.repr[idxb..end] == "\\" => {
+ &self.repr[]
}
- Some((0,idxa,_)) => self.repr.index(&(0..idxa)),
+ Some((0,idxa,_)) => &self.repr[..idxa],
Some((idxb,idxa,_)) => {
match self.prefix {
Some(DiskPrefix) | Some(VerbatimDiskPrefix) if idxb == self.prefix_len() => {
- self.repr.index(&(0..idxa))
+ &self.repr[..idxa]
}
- _ => self.repr.index(&(0..idxb))
+ _ => &self.repr[..idxb]
}
}
})
/// 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.index(&FullRange);
+ let repr = &self.repr[];
match self.sepidx_or_prefix_len() {
None if "." == repr || ".." == repr => None,
None => Some(repr),
- Some((_,idxa,end)) if repr.index(&(idxa..end)) == ".." => None,
+ Some((_,idxa,end)) if &repr[idxa..end] == ".." => None,
Some((_,idxa,end)) if idxa == end => None,
- Some((_,idxa,end)) => Some(repr.index(&(idxa..end)))
+ Some((_,idxa,end)) => Some(&repr[idxa..end])
}
}
true
}
Some((idxb,idxa,end)) if idxb == idxa && idxb == end => false,
- Some((idxb,_,end)) if self.repr.index(&(idxb..end)) == "\\" => false,
+ Some((idxb,_,end)) if &self.repr[idxb..end] == "\\" => false,
Some((idxb,idxa,_)) => {
let trunc = match self.prefix {
Some(DiskPrefix) | Some(VerbatimDiskPrefix) | None => {
if self.prefix.is_some() {
Some(Path::new(match self.prefix {
Some(DiskPrefix) if self.is_absolute() => {
- self.repr.index(&(0..(self.prefix_len()+1)))
+ &self.repr[..self.prefix_len()+1]
}
Some(VerbatimDiskPrefix) => {
- self.repr.index(&(0..(self.prefix_len()+1)))
+ &self.repr[..self.prefix_len()+1]
}
- _ => self.repr.index(&(0..self.prefix_len()))
+ _ => &self.repr[..self.prefix_len()]
}))
} else if is_vol_relative(self) {
- Some(Path::new(self.repr.index(&(0..1))))
+ Some(Path::new(&self.repr[..1]))
} else {
None
}
fn is_absolute(&self) -> bool {
match self.prefix {
Some(DiskPrefix) => {
- let rest = self.repr.index(&(self.prefix_len()..));
+ let rest = &self.repr[self.prefix_len()..];
rest.len() > 0 && rest.as_bytes()[0] == SEP_BYTE
}
Some(_) => true,
/// 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.index(&FullRange);
+ let repr = &self.repr[];
let s = match self.prefix {
Some(_) => {
let plen = self.prefix_len();
if repr.len() > plen && repr.as_bytes()[plen] == SEP_BYTE {
- repr.index(&((plen+1)..))
- } else { repr.index(&(plen..)) }
+ &repr[plen+1..]
+ } else { &repr[plen..] }
}
- None if repr.as_bytes()[0] == SEP_BYTE => repr.index(&(1..)),
+ None if repr.as_bytes()[0] == SEP_BYTE => &repr[1..],
None => repr
};
let some: fn(&'a str) -> Option<&'a str> = Some; // coerce to fn ptr
}
fn equiv_prefix(&self, other: &Path) -> bool {
- let s_repr = self.repr.index(&FullRange);
- let o_repr = other.repr.index(&FullRange);
+ let s_repr = &self.repr[];
+ let o_repr = &other.repr[];
match (self.prefix, other.prefix) {
(Some(DiskPrefix), Some(VerbatimDiskPrefix)) => {
self.is_absolute() &&
o_repr.as_bytes()[4].to_ascii_lowercase()
}
(Some(UNCPrefix(_,_)), Some(VerbatimUNCPrefix(_,_))) => {
- s_repr.index(&(2..self.prefix_len())) == o_repr.index(&(8..other.prefix_len()))
+ &s_repr[2..self.prefix_len()] == &o_repr[8..other.prefix_len()]
}
(Some(VerbatimUNCPrefix(_,_)), Some(UNCPrefix(_,_))) => {
- s_repr.index(&(8..self.prefix_len())) == o_repr.index(&(2..other.prefix_len()))
+ &s_repr[8..self.prefix_len()] == &o_repr[2..other.prefix_len()]
}
(None, None) => true,
(a, b) if a == b => {
- s_repr.index(&(0..self.prefix_len())) == o_repr.index(&(0..other.prefix_len()))
+ &s_repr[..self.prefix_len()] == &o_repr[..other.prefix_len()]
}
_ => false
}
match prefix.unwrap() {
DiskPrefix => {
let len = prefix_len(prefix) + is_abs as uint;
- let mut s = String::from_str(s.index(&(0..len)));
+ let mut s = String::from_str(&s[..len]);
unsafe {
let v = s.as_mut_vec();
v[0] = (*v)[0].to_ascii_uppercase();
}
VerbatimDiskPrefix => {
let len = prefix_len(prefix) + is_abs as uint;
- let mut s = String::from_str(s.index(&(0..len)));
+ let mut s = String::from_str(&s[..len]);
unsafe {
let v = s.as_mut_vec();
v[4] = (*v)[4].to_ascii_uppercase();
_ => {
let plen = prefix_len(prefix);
if s.len() > plen {
- Some(String::from_str(s.index(&(0..plen))))
+ Some(String::from_str(&s[..plen]))
} else { None }
}
}
} else if is_abs && comps.is_empty() {
Some(repeat(SEP).take(1).collect())
} else {
- let prefix_ = s.index(&(0..prefix_len(prefix)));
+ let prefix_ = &s[..prefix_len(prefix)];
let n = prefix_.len() +
if is_abs { comps.len() } else { comps.len() - 1} +
comps.iter().map(|v| v.len()).sum();
s.push(':');
}
Some(VerbatimDiskPrefix) => {
- s.push_str(prefix_.index(&(0..4)));
+ s.push_str(&prefix_[..4]);
s.push(prefix_.as_bytes()[4].to_ascii_uppercase() as char);
- s.push_str(prefix_.index(&(5..)));
+ s.push_str(&prefix_[5..]);
}
Some(UNCPrefix(a,b)) => {
s.push_str("\\\\");
- s.push_str(prefix_.index(&(2..(a+2))));
+ s.push_str(&prefix_[2..a+2]);
s.push(SEP);
- s.push_str(prefix_.index(&((3+a)..(3+a+b))));
+ s.push_str(&prefix_[3+a..3+a+b]);
}
Some(_) => s.push_str(prefix_),
None => ()
fn update_sepidx(&mut self) {
let s = if self.has_nonsemantic_trailing_slash() {
- self.repr.index(&(0..(self.repr.len()-1)))
- } else { self.repr.index(&FullRange) };
+ &self.repr[..self.repr.len()-1]
+ } else { &self.repr[] };
let sep_test: fn(char) -> bool = if !prefix_is_verbatim(self.prefix) {
is_sep
} else {
/// 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.index(&FullRange);
+ let repr = &path.repr[];
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(repr.index(&(4..)))
+ Path::new(&repr[4..])
}
Some(VerbatimUNCPrefix(_,_)) => {
// \\?\UNC\server\share
- Path::new(format!(r"\{}", repr.index(&(7..))))
+ Path::new(format!(r"\{}", &repr[7..]))
}
};
if new_path.prefix.is_none() {
return None;
}
// now ensure normalization didn't change anything
- if repr.index(&(path.prefix_len()..)) ==
- new_path.repr.index(&(new_path.prefix_len()..)) {
+ if &repr[path.prefix_len()..] == &new_path.repr[new_path.prefix_len()..] {
Some(new_path)
} else {
None
fn parse_prefix<'a>(mut path: &'a str) -> Option<PathPrefix> {
if path.starts_with("\\\\") {
// \\
- path = path.index(&(2..));
+ path = &path[2..];
if path.starts_with("?\\") {
// \\?\
- path = path.index(&(2..));
+ path = &path[2..];
if path.starts_with("UNC\\") {
// \\?\UNC\server\share
- path = path.index(&(4..));
+ path = &path[4..];
let (idx_a, idx_b) = match parse_two_comps(path, is_sep_verbatim) {
Some(x) => x,
None => (path.len(), 0)
}
} else if path.starts_with(".\\") {
// \\.\path
- path = path.index(&(2..));
+ path = &path[2..];
let idx = path.find('\\').unwrap_or(path.len());
return Some(DeviceNSPrefix(idx));
}
None => return None,
Some(x) => x
};
- path = path.index(&((idx_a+1)..));
+ path = &path[idx_a+1..];
let idx_b = path.find(f).unwrap_or(path.len());
Some((idx_a, idx_b))
}
is_sep_verbatim
};
let is_abs = s.len() > prefix_len(prefix) && f(s.char_at(prefix_len(prefix)));
- let s_ = s.index(&(prefix_len(prefix)..));
- let s_ = if is_abs { s_.index(&(1..)) } else { s_ };
+ let s_ = &s[prefix_len(prefix)..];
+ let s_ = if is_abs { &s_[1..] } else { s_ };
if is_abs && s_.is_empty() {
return (is_abs, match prefix {
projects / rust.git / blobdiff