let options_to_remove = [~"-O", ~"-g", ~"--debuginfo"];
let new_options = split_maybe_args(options).move_iter()
.filter(|x| !options_to_remove.contains(x))
- .collect::<~[~str]>()
+ .collect::<Vec<~str>>()
.connect(" ");
Some(new_options)
}
words.push(r.gen_vec::<u8>(range));
}
for _ in range(0, 20) {
- let mut input = ~[];
+ let mut input = vec![];
for _ in range(0, 2000) {
input.push_all(r.choose(words.as_slice()).as_slice());
}
debug!("de/inflate of {} bytes of random word-sequences",
input.len());
- let cmp = deflate_bytes(input).expect("deflation failed");
+ let cmp = deflate_bytes(input.as_slice()).expect("deflation failed");
let out = inflate_bytes(cmp.as_slice()).expect("inflation failed");
debug!("{} bytes deflated to {} ({:.1f}% size)",
input.len(), cmp.len(),
//!
//! let program = args[0].clone();
//!
-//! let opts = ~[
+//! let opts = [
//! optopt("o", "", "set output file name", "NAME"),
//! optflag("h", "help", "print this help menu")
//! ];
html_favicon_url = "http://www.rust-lang.org/favicon.ico",
html_root_url = "http://static.rust-lang.org/doc/master")]
+#![deny(deprecated_owned_vector)]
+
use std::cell::Cell;
use std::{cmp, os, path};
use std::io::fs;
*/
pub fn new(pattern: &str) -> Pattern {
- let chars = pattern.chars().collect::<~[_]>();
+ let chars = pattern.chars().collect::<Vec<_>>();
let mut tokens = Vec::new();
let mut i = 0;
while i < chars.len() {
- match chars[i] {
+ match *chars.get(i) {
'?' => {
tokens.push(AnyChar);
i += 1;
}
'*' => {
// *, **, ***, ****, ... are all equivalent
- while i < chars.len() && chars[i] == '*' {
+ while i < chars.len() && *chars.get(i) == '*' {
i += 1;
}
tokens.push(AnySequence);
}
'[' => {
- if i <= chars.len() - 4 && chars[i + 1] == '!' {
+ if i <= chars.len() - 4 && *chars.get(i + 1) == '!' {
match chars.slice_from(i + 3).position_elem(&']') {
None => (),
Some(j) => {
}
}
}
- else if i <= chars.len() - 3 && chars[i + 1] != '!' {
+ else if i <= chars.len() - 3 && *chars.get(i + 1) != '!' {
match chars.slice_from(i + 2).position_elem(&']') {
None => (),
Some(j) => {
} else {
None
})
- .collect::<~[&ast::Attribute]>();
+ .collect::<Vec<&ast::Attribute>>();
for m in link_args.iter() {
match m.value_str() {
Some(linkarg) => e.sess.cstore.add_used_link_args(linkarg.get()),
} else {
None
})
- .collect::<~[&ast::Attribute]>();
+ .collect::<Vec<&ast::Attribute>>();
for m in link_args.iter() {
match m.meta_item_list() {
Some(items) => {
slice::raw::buf_as_slice((*text).data, (*text).size as uint, |text| {
let text = str::from_utf8(text).unwrap();
let mut lines = text.lines().filter(|l| stripped_filtered_line(*l).is_none());
- let text = lines.collect::<~[&str]>().connect("\n");
+ let text = lines.collect::<Vec<&str>>().connect("\n");
let buf = buf {
data: text.as_bytes().as_ptr(),
Some(s) => s.to_lower().into_str(),
None => s.to_owned()
}
- }).collect::<~[~str]>().connect("-");
+ }).collect::<Vec<~str>>().connect("-");
let opaque = unsafe {&mut *(opaque as *mut my_opaque)};
let tests = &mut *(opaque as *mut ::test::Collector);
let text = str::from_utf8(text).unwrap();
let mut lines = text.lines().map(|l| stripped_filtered_line(l).unwrap_or(l));
- let text = lines.collect::<~[&str]>().connect("\n");
+ let text = lines.collect::<Vec<&str>>().connect("\n");
tests.add_test(text, should_fail, no_run, ignore);
})
}
it.name.get_ref().as_slice(),
t.generics,
parents));
- let required = t.methods.iter().filter(|m| m.is_req()).collect::<~[&clean::TraitMethod]>();
- let provided = t.methods.iter().filter(|m| !m.is_req()).collect::<~[&clean::TraitMethod]>();
+ let required = t.methods.iter().filter(|m| m.is_req()).collect::<Vec<&clean::TraitMethod>>();
+ let provided = t.methods.iter().filter(|m| !m.is_req()).collect::<Vec<&clean::TraitMethod>>();
if t.methods.len() == 0 {
try!(write!(w, "\\{ \\}"));
let mut non_trait = v.iter().filter(|p| {
p.ref0().trait_.is_none()
});
- let non_trait = non_trait.collect::<~[&(clean::Impl, Option<~str>)]>();
+ let non_trait = non_trait.collect::<Vec<&(clean::Impl, Option<~str>)>>();
let mut traits = v.iter().filter(|p| {
p.ref0().trait_.is_some()
});
- let traits = traits.collect::<~[&(clean::Impl, Option<~str>)]>();
+ let traits = traits.collect::<Vec<&(clean::Impl, Option<~str>)>>();
if non_trait.len() > 0 {
try!(write!(w, "<h2 id='methods'>Methods</h2>"));
}
/// Run any tests/code examples in the markdown file `input`.
-pub fn test(input: &str, libs: HashSet<Path>, mut test_args: ~[~str]) -> int {
+pub fn test(input: &str, libs: HashSet<Path>, mut test_args: Vec<~str>) -> int {
let input_str = load_or_return!(input, 1, 2);
let mut collector = Collector::new(input.to_owned(), libs, true, true);
find_testable_code(input_str, &mut collector);
test_args.unshift(~"rustdoctest");
- testing::test_main(test_args, collector.tests);
+ testing::test_main(test_args.as_slice(), collector.tests);
0
}
}
struct Inner {
- queue: ~[BlockedTask],
+ queue: Vec<BlockedTask>,
held: bool,
}
pub fn new() -> Access {
Access {
inner: UnsafeArc::new(Inner {
- queue: ~[],
+ queue: vec![],
held: false,
})
}
// FIXME #11059 handle NaN, inf and overflow
#[allow(deprecated_owned_vector)]
fn sum(self) -> f64 {
- let mut partials : ~[f64] = ~[];
+ let mut partials = vec![];
for &mut x in self.iter() {
let mut j = 0;
// This inner loop applies `hi`/`lo` summation to each
// partial so that the list of partial sums remains exact.
for i in range(0, partials.len()) {
- let mut y = partials[i];
+ let mut y = *partials.get(i);
if num::abs(x) < num::abs(y) {
mem::swap(&mut x, &mut y);
}
let hi = x + y;
let lo = y - (hi - x);
if lo != 0f64 {
- partials[j] = lo;
+ *partials.get_mut(j) = lo;
j += 1;
}
x = hi;
if j >= partials.len() {
partials.push(x);
} else {
- partials[j] = x;
+ *partials.get_mut(j) = x;
partials.truncate(j+1);
}
}
html_root_url = "http://static.rust-lang.org/doc/master")]
#![feature(phase)]
#![allow(visible_private_types)]
+#![deny(deprecated_owned_vector)]
#[phase(syntax, link)] extern crate log;
extern crate serialize;
}
// returns pairs of (kind, name)
- pub fn lookup_discovered_inputs(&self) -> ~[(~str, ~str)] {
- let mut rs = ~[];
+ pub fn lookup_discovered_inputs(&self) -> Vec<(~str, ~str)> {
+ let mut rs = vec![];
let WorkMap(ref discovered_inputs) = self.discovered_inputs;
for (k, v) in discovered_inputs.iter() {
let KindMap(ref vmap) = *v;
}
}
- pub fn lookup_declared_inputs(&self) -> ~[~str] {
- let mut rs = ~[];
+ pub fn lookup_declared_inputs(&self) -> Vec<~str> {
+ let mut rs = vec![];
let WorkMap(ref declared_inputs) = self.declared_inputs;
for (_, v) in declared_inputs.iter() {
let KindMap(ref vmap) = *v;
format!("{}\t trees of depth {}\t check: {}",
iterations * 2, depth, chk)
})
- }).collect::<~[Future<~str>]>();
+ }).collect::<Vec<Future<~str>>>();
for message in messages.mut_iter() {
println!("{}", *message.get_ref());