diff options
Diffstat (limited to 'src/libstd')
45 files changed, 152 insertions, 154 deletions
diff --git a/src/libstd/ascii.rs b/src/libstd/ascii.rs index 3ca08797dd1..33638fffc6d 100644 --- a/src/libstd/ascii.rs +++ b/src/libstd/ascii.rs @@ -19,7 +19,7 @@ use container::Container; use cast; use fmt; use iter::Iterator; -use vec::{ImmutableVector, MutableVector, Vector}; +use slice::{ImmutableVector, MutableVector, Vector}; use vec_ng::Vec; use option::{Option, Some, None}; diff --git a/src/libstd/c_str.rs b/src/libstd/c_str.rs index af5d9838186..96c7c218127 100644 --- a/src/libstd/c_str.rs +++ b/src/libstd/c_str.rs @@ -76,8 +76,8 @@ use ptr::RawPtr; use ptr; use str::StrSlice; use str; -use vec::{ImmutableVector, MutableVector}; -use vec; +use slice::{ImmutableVector, MutableVector}; +use slice; use rt::global_heap::malloc_raw; use raw::Slice; @@ -343,7 +343,7 @@ impl<'a> ToCStr for &'a [u8] { unsafe fn with_c_str<T>(v: &[u8], checked: bool, f: |*libc::c_char| -> T) -> T { if v.len() < BUF_LEN { let mut buf: [u8, .. BUF_LEN] = mem::uninit(); - vec::bytes::copy_memory(buf, v); + slice::bytes::copy_memory(buf, v); buf[v.len()] = 0; let buf = buf.as_mut_ptr(); diff --git a/src/libstd/comm/shared.rs b/src/libstd/comm/shared.rs index 328dd70223b..8c8ae85e4ea 100644 --- a/src/libstd/comm/shared.rs +++ b/src/libstd/comm/shared.rs @@ -30,7 +30,7 @@ use rt::task::{Task, BlockedTask}; use rt::thread::Thread; use sync::atomics; use unstable::mutex::NativeMutex; -use vec::OwnedVector; +use slice::OwnedVector; use mpsc = sync::mpsc_queue; diff --git a/src/libstd/comm/stream.rs b/src/libstd/comm/stream.rs index d386e97d5bf..5820b13a35f 100644 --- a/src/libstd/comm/stream.rs +++ b/src/libstd/comm/stream.rs @@ -30,7 +30,7 @@ use rt::task::{Task, BlockedTask}; use rt::thread::Thread; use spsc = sync::spsc_queue; use sync::atomics; -use vec::OwnedVector; +use slice::OwnedVector; static DISCONNECTED: int = int::MIN; #[cfg(test)] diff --git a/src/libstd/fmt/mod.rs b/src/libstd/fmt/mod.rs index 67e2fc00b8b..d3ceba025ea 100644 --- a/src/libstd/fmt/mod.rs +++ b/src/libstd/fmt/mod.rs @@ -490,8 +490,8 @@ use repr; use result::{Ok, Err}; use str::StrSlice; use str; -use vec::ImmutableVector; -use vec; +use slice::ImmutableVector; +use slice; pub use self::num::radix; pub use self::num::Radix; @@ -520,7 +520,7 @@ pub struct Formatter<'a> { /// Output buffer. buf: &'a mut io::Writer, - priv curarg: vec::Items<'a, Argument<'a>>, + priv curarg: slice::Items<'a, Argument<'a>>, priv args: &'a [Argument<'a>], } diff --git a/src/libstd/fmt/num.rs b/src/libstd/fmt/num.rs index 681d0678ed4..4b35a7596c9 100644 --- a/src/libstd/fmt/num.rs +++ b/src/libstd/fmt/num.rs @@ -17,7 +17,7 @@ use fmt; use iter::{Iterator, DoubleEndedIterator}; use num::{Int, cast, zero}; use option::{Some, None}; -use vec::{ImmutableVector, MutableVector}; +use slice::{ImmutableVector, MutableVector}; /// A type that represents a specific radix trait GenericRadix { diff --git a/src/libstd/hash/mod.rs b/src/libstd/hash/mod.rs index dd40f600873..d329c15a7d7 100644 --- a/src/libstd/hash/mod.rs +++ b/src/libstd/hash/mod.rs @@ -70,7 +70,7 @@ use ops::Deref; use option::{Option, Some, None}; use rc::Rc; use str::{Str, StrSlice}; -use vec::{Vector, ImmutableVector}; +use slice::{Vector, ImmutableVector}; use vec_ng::Vec; /// Reexport the `sip::hash` function as our default hasher. @@ -293,7 +293,7 @@ mod tests { use iter::{Iterator}; use option::{Some, None}; use result::Ok; - use vec::ImmutableVector; + use slice::ImmutableVector; use super::{Hash, Hasher}; diff --git a/src/libstd/hash/sip.rs b/src/libstd/hash/sip.rs index d1d4d4c90f9..d448f4eeb37 100644 --- a/src/libstd/hash/sip.rs +++ b/src/libstd/hash/sip.rs @@ -30,7 +30,7 @@ use default::Default; use io::{IoResult, Writer}; use iter::Iterator; use result::Ok; -use vec::ImmutableVector; +use slice::ImmutableVector; use super::{Hash, Hasher}; @@ -292,7 +292,7 @@ mod tests { use num::ToStrRadix; use option::{Some, None}; use str::{Str, OwnedStr}; - use vec::{Vector, ImmutableVector, OwnedVector}; + use slice::{Vector, ImmutableVector, OwnedVector}; use self::test::BenchHarness; use super::super::Hash; diff --git a/src/libstd/io/buffered.rs b/src/libstd/io/buffered.rs index 3ae44e4a1b5..ab9a8377136 100644 --- a/src/libstd/io/buffered.rs +++ b/src/libstd/io/buffered.rs @@ -17,8 +17,8 @@ use iter::ExactSize; use ops::Drop; use option::{Some, None, Option}; use result::{Ok, Err}; -use vec::{OwnedVector, ImmutableVector, MutableVector}; -use vec; +use slice::{OwnedVector, ImmutableVector, MutableVector}; +use slice; /// Wraps a Reader and buffers input from it /// @@ -58,7 +58,7 @@ impl<R: Reader> BufferedReader<R> { // everything up-front. This allows creation of BufferedReader instances // to be very cheap (large mallocs are not nearly as expensive as large // callocs). - let mut buf = vec::with_capacity(cap); + let mut buf = slice::with_capacity(cap); unsafe { buf.set_len(cap); } BufferedReader { inner: inner, @@ -106,7 +106,7 @@ impl<R: Reader> Reader for BufferedReader<R> { let nread = { let available = try!(self.fill()); let nread = cmp::min(available.len(), buf.len()); - vec::bytes::copy_memory(buf, available.slice_to(nread)); + slice::bytes::copy_memory(buf, available.slice_to(nread)); nread }; self.pos += nread; @@ -140,7 +140,7 @@ impl<W: Writer> BufferedWriter<W> { /// Creates a new `BufferedWriter` with the specified buffer capacity pub fn with_capacity(cap: uint, inner: W) -> BufferedWriter<W> { // See comments in BufferedReader for why this uses unsafe code. - let mut buf = vec::with_capacity(cap); + let mut buf = slice::with_capacity(cap); unsafe { buf.set_len(cap); } BufferedWriter { inner: Some(inner), @@ -190,7 +190,7 @@ impl<W: Writer> Writer for BufferedWriter<W> { self.inner.get_mut_ref().write(buf) } else { let dst = self.buf.mut_slice_from(self.pos); - vec::bytes::copy_memory(dst, buf); + slice::bytes::copy_memory(dst, buf); self.pos += buf.len(); Ok(()) } diff --git a/src/libstd/io/comm_adapters.rs b/src/libstd/io/comm_adapters.rs index f09555e93a0..075c65e04be 100644 --- a/src/libstd/io/comm_adapters.rs +++ b/src/libstd/io/comm_adapters.rs @@ -16,7 +16,7 @@ use io; use option::{None, Option, Some}; use result::{Ok, Err}; use super::{Reader, Writer, IoResult}; -use vec::{bytes, CloneableVector, MutableVector, ImmutableVector}; +use slice::{bytes, CloneableVector, MutableVector, ImmutableVector}; /// Allows reading from a rx. /// diff --git a/src/libstd/io/extensions.rs b/src/libstd/io/extensions.rs index f7cab755714..070cbd569e6 100644 --- a/src/libstd/io/extensions.rs +++ b/src/libstd/io/extensions.rs @@ -21,7 +21,7 @@ use option::{Option, Some, None}; use result::{Ok, Err}; use io; use io::{IoError, IoResult, Reader}; -use vec::{OwnedVector, ImmutableVector}; +use slice::{OwnedVector, ImmutableVector}; use ptr::RawPtr; /// An iterator that reads a single byte on each iteration, @@ -114,7 +114,7 @@ pub fn u64_from_be_bytes(data: &[u8], -> u64 { use ptr::{copy_nonoverlapping_memory}; use mem::from_be64; - use vec::MutableVector; + use slice::MutableVector; assert!(size <= 8u); @@ -470,10 +470,10 @@ mod bench { macro_rules! u64_from_be_bytes_bench_impl( ($size:expr, $stride:expr, $start_index:expr) => ({ - use vec; + use slice; use super::u64_from_be_bytes; - let data = vec::from_fn($stride*100+$start_index, |i| i as u8); + let data = slice::from_fn($stride*100+$start_index, |i| i as u8); let mut sum = 0u64; bh.iter(|| { let mut i = $start_index; diff --git a/src/libstd/io/fs.rs b/src/libstd/io/fs.rs index 3435c9a07aa..aab2f8c887c 100644 --- a/src/libstd/io/fs.rs +++ b/src/libstd/io/fs.rs @@ -62,7 +62,7 @@ use option::{Some, None, Option}; use result::{Ok, Err}; use path; use path::{Path, GenericPath}; -use vec::{OwnedVector, ImmutableVector}; +use slice::{OwnedVector, ImmutableVector}; use vec_ng::Vec; /// Unconstrained file access type that exposes read and write operations diff --git a/src/libstd/io/mem.rs b/src/libstd/io/mem.rs index 3e79225f9ab..d0c4ef308b3 100644 --- a/src/libstd/io/mem.rs +++ b/src/libstd/io/mem.rs @@ -16,8 +16,8 @@ use option::None; use result::{Err, Ok}; use io; use io::{Reader, Writer, Seek, Buffer, IoError, SeekStyle, IoResult}; -use vec; -use vec::{Vector, ImmutableVector, MutableVector, OwnedCloneableVector}; +use slice; +use slice::{Vector, ImmutableVector, MutableVector, OwnedCloneableVector}; fn combine(seek: SeekStyle, cur: uint, end: uint, offset: i64) -> IoResult<u64> { // compute offset as signed and clamp to prevent overflow @@ -64,7 +64,7 @@ impl MemWriter { /// Create a new `MemWriter`, allocating at least `n` bytes for /// the internal buffer. pub fn with_capacity(n: uint) -> MemWriter { - MemWriter { buf: vec::with_capacity(n), pos: 0 } + MemWriter { buf: slice::with_capacity(n), pos: 0 } } /// Acquires an immutable reference to the underlying buffer of this @@ -98,7 +98,7 @@ impl Writer for MemWriter { // Do the necessary writes if left.len() > 0 { - vec::bytes::copy_memory(self.buf.mut_slice_from(self.pos), left); + slice::bytes::copy_memory(self.buf.mut_slice_from(self.pos), left); } if right.len() > 0 { self.buf.push_all(right); @@ -171,7 +171,7 @@ impl Reader for MemReader { let input = self.buf.slice(self.pos, self.pos + write_len); let output = buf.mut_slice(0, write_len); assert_eq!(input.len(), output.len()); - vec::bytes::copy_memory(output, input); + slice::bytes::copy_memory(output, input); } self.pos += write_len; assert!(self.pos <= self.buf.len()); @@ -246,7 +246,7 @@ impl<'a> Writer for BufWriter<'a> { }) } - vec::bytes::copy_memory(self.buf.mut_slice_from(self.pos), buf); + slice::bytes::copy_memory(self.buf.mut_slice_from(self.pos), buf); self.pos += buf.len(); Ok(()) } @@ -303,7 +303,7 @@ impl<'a> Reader for BufReader<'a> { let input = self.buf.slice(self.pos, self.pos + write_len); let output = buf.mut_slice(0, write_len); assert_eq!(input.len(), output.len()); - vec::bytes::copy_memory(output, input); + slice::bytes::copy_memory(output, input); } self.pos += write_len; assert!(self.pos <= self.buf.len()); diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs index c18d4e273c4..cbced77d014 100644 --- a/src/libstd/io/mod.rs +++ b/src/libstd/io/mod.rs @@ -223,8 +223,8 @@ use str::{StrSlice, OwnedStr}; use str; use uint; use unstable::finally::try_finally; -use vec::{OwnedVector, MutableVector, ImmutableVector, OwnedCloneableVector}; -use vec; +use slice::{OwnedVector, MutableVector, ImmutableVector, OwnedCloneableVector}; +use slice; // Reexports pub use self::stdio::stdin; @@ -406,7 +406,7 @@ pub trait Reader { /// (not returned as part of the error). If this is unacceptable, then it is /// recommended to use the `push_bytes` or `read` methods. fn read_bytes(&mut self, len: uint) -> IoResult<~[u8]> { - let mut buf = vec::with_capacity(len); + let mut buf = slice::with_capacity(len); match self.push_bytes(&mut buf, len) { Ok(()) => Ok(buf), Err(e) => Err(e), @@ -422,7 +422,7 @@ pub trait Reader { /// /// When EOF is encountered, all bytes read up to that point are returned. fn read_to_end(&mut self) -> IoResult<~[u8]> { - let mut buf = vec::with_capacity(DEFAULT_BUF_SIZE); + let mut buf = slice::with_capacity(DEFAULT_BUF_SIZE); loop { match self.push_bytes(&mut buf, DEFAULT_BUF_SIZE) { Ok(()) => {} diff --git a/src/libstd/io/net/addrinfo.rs b/src/libstd/io/net/addrinfo.rs index 80ca353523f..6e0b766a587 100644 --- a/src/libstd/io/net/addrinfo.rs +++ b/src/libstd/io/net/addrinfo.rs @@ -23,7 +23,7 @@ use io::IoResult; use io::net::ip::{SocketAddr, IpAddr}; use option::{Option, Some, None}; use rt::rtio::{IoFactory, LocalIo}; -use vec::ImmutableVector; +use slice::ImmutableVector; /// Hints to the types of sockets that are desired when looking up hosts pub enum SocketType { diff --git a/src/libstd/io/net/ip.rs b/src/libstd/io/net/ip.rs index 7c9321d87d9..dc24ead6258 100644 --- a/src/libstd/io/net/ip.rs +++ b/src/libstd/io/net/ip.rs @@ -16,7 +16,7 @@ use from_str::FromStr; use iter::Iterator; use option::{Option, None, Some}; use str::StrSlice; -use vec::{MutableCloneableVector, ImmutableVector, MutableVector}; +use slice::{MutableCloneableVector, ImmutableVector, MutableVector}; pub type Port = u16; diff --git a/src/libstd/io/signal.rs b/src/libstd/io/signal.rs index c66fcd13917..d6700fda23d 100644 --- a/src/libstd/io/signal.rs +++ b/src/libstd/io/signal.rs @@ -27,7 +27,7 @@ use mem::drop; use option::{Some, None}; use result::{Ok, Err}; use rt::rtio::{IoFactory, LocalIo, RtioSignal}; -use vec::{ImmutableVector, OwnedVector}; +use slice::{ImmutableVector, OwnedVector}; /// Signals that can be sent and received #[repr(int)] diff --git a/src/libstd/io/stdio.rs b/src/libstd/io/stdio.rs index 7c65e76ab47..2389a8655f3 100644 --- a/src/libstd/io/stdio.rs +++ b/src/libstd/io/stdio.rs @@ -40,7 +40,7 @@ use rt::local::Local; use rt::rtio::{DontClose, IoFactory, LocalIo, RtioFileStream, RtioTTY}; use rt::task::Task; use str::StrSlice; -use vec::ImmutableVector; +use slice::ImmutableVector; // And so begins the tale of acquiring a uv handle to a stdio stream on all // platforms in all situations. Our story begins by splitting the world into two diff --git a/src/libstd/io/util.rs b/src/libstd/io/util.rs index d6d1de00d86..2df0dec2d13 100644 --- a/src/libstd/io/util.rs +++ b/src/libstd/io/util.rs @@ -13,7 +13,7 @@ use prelude::*; use cmp; use io; -use vec::bytes::MutableByteVector; +use slice::bytes::MutableByteVector; /// Wraps a `Reader`, limiting the number of bytes that can be read from it. pub struct LimitReader<R> { diff --git a/src/libstd/iter.rs b/src/libstd/iter.rs index 9e988eb4094..320383d4f81 100644 --- a/src/libstd/iter.rs +++ b/src/libstd/iter.rs @@ -2293,7 +2293,7 @@ pub mod order { #[test] fn test_lt() { - use vec::ImmutableVector; + use slice::ImmutableVector; let empty: [int, ..0] = []; let xs = [1,2,3]; diff --git a/src/libstd/lib.rs b/src/libstd/lib.rs index 17c0e2235c0..c6a1d710a52 100644 --- a/src/libstd/lib.rs +++ b/src/libstd/lib.rs @@ -119,7 +119,7 @@ pub mod bool; pub mod char; pub mod tuple; -pub mod vec; +pub mod slice; pub mod vec_ng; pub mod str; diff --git a/src/libstd/local_data.rs b/src/libstd/local_data.rs index 9fc635647f3..f1f1977462f 100644 --- a/src/libstd/local_data.rs +++ b/src/libstd/local_data.rs @@ -42,7 +42,7 @@ local_data::get(key_vector, |opt| assert_eq!(*opt.unwrap(), ~[4])); use cast; use option::{None, Option, Some}; -use vec::{ImmutableVector, MutableVector, OwnedVector}; +use slice::{ImmutableVector, MutableVector, OwnedVector}; use iter::{Iterator}; use rt::task::{Task, LocalStorage}; use mem::replace; diff --git a/src/libstd/num/mod.rs b/src/libstd/num/mod.rs index f53c95de414..98379b5e5fb 100644 --- a/src/libstd/num/mod.rs +++ b/src/libstd/num/mod.rs @@ -1727,12 +1727,12 @@ mod bench { extern crate test; use self::test::BenchHarness; use num; - use vec; + use slice; use prelude::*; #[bench] fn bench_pow_function(b: &mut BenchHarness) { - let v = vec::from_fn(1024, |n| n); + let v = slice::from_fn(1024, |n| n); b.iter(|| {v.iter().fold(0, |old, new| num::pow(old, *new));}); } } diff --git a/src/libstd/num/strconv.rs b/src/libstd/num/strconv.rs index 00497b6f0ea..9d3d012bae7 100644 --- a/src/libstd/num/strconv.rs +++ b/src/libstd/num/strconv.rs @@ -18,8 +18,8 @@ use option::{None, Option, Some}; use char; use str::{StrSlice}; use str; -use vec::{CloneableVector, ImmutableVector, MutableVector}; -use vec::OwnedVector; +use slice::{CloneableVector, ImmutableVector, MutableVector}; +use slice::OwnedVector; use num; use num::{NumCast, Zero, One, cast, Int}; use num::{Round, Float, FPNaN, FPInfinite, ToPrimitive}; diff --git a/src/libstd/option.rs b/src/libstd/option.rs index ea9ccde0be9..5f733302d6f 100644 --- a/src/libstd/option.rs +++ b/src/libstd/option.rs @@ -145,7 +145,7 @@ use default::Default; use iter::{Iterator, DoubleEndedIterator, FromIterator, ExactSize}; use kinds::Send; use mem; -use vec; +use slice; /// The `Option` #[deriving(Clone, Eq, Ord, TotalEq, TotalOrd, Show)] @@ -215,7 +215,7 @@ impl<T> Option<T> { #[inline] pub fn as_slice<'r>(&'r self) -> &'r [T] { match *self { - Some(ref x) => vec::ref_slice(x), + Some(ref x) => slice::ref_slice(x), None => &[] } } @@ -224,7 +224,7 @@ impl<T> Option<T> { #[inline] pub fn as_mut_slice<'r>(&'r mut self) -> &'r mut [T] { match *self { - Some(ref mut x) => vec::mut_ref_slice(x), + Some(ref mut x) => slice::mut_ref_slice(x), None => &mut [] } } @@ -614,7 +614,7 @@ mod tests { use iter::range; use str::StrSlice; use kinds::marker; - use vec::ImmutableVector; + use slice::ImmutableVector; #[test] fn test_get_ptr() { diff --git a/src/libstd/os.rs b/src/libstd/os.rs index 040d5c0e175..d03757c1e69 100644 --- a/src/libstd/os.rs +++ b/src/libstd/os.rs @@ -47,7 +47,7 @@ use fmt; use sync::atomics::{AtomicInt, INIT_ATOMIC_INT, SeqCst}; use path::{Path, GenericPath}; use iter::Iterator; -use vec::{Vector, CloneableVector, ImmutableVector, MutableVector, OwnedVector}; +use slice::{Vector, CloneableVector, ImmutableVector, MutableVector, OwnedVector}; use ptr::RawPtr; #[cfg(unix)] @@ -101,8 +101,8 @@ pub mod win32 { use os::TMPBUF_SZ; use str::StrSlice; use str; - use vec::{MutableVector, ImmutableVector, OwnedVector}; - use vec; + use slice::{MutableVector, ImmutableVector, OwnedVector}; + use slice; pub fn fill_utf16_buf_and_decode(f: |*mut u16, DWORD| -> DWORD) -> Option<~str> { @@ -112,7 +112,7 @@ pub mod win32 { let mut res = None; let mut done = false; while !done { - let mut buf = vec::from_elem(n as uint, 0u16); + let mut buf = slice::from_elem(n as uint, 0u16); let k = f(buf.as_mut_ptr(), n); if k == (0 as DWORD) { done = true; @@ -412,7 +412,7 @@ pub fn self_exe_name() -> Option<Path> { unsafe { use libc::funcs::bsd44::*; use libc::consts::os::extra::*; - use vec; + use slice; let mib = ~[CTL_KERN as c_int, KERN_PROC as c_int, KERN_PROC_PATHNAME as c_int, -1 as c_int]; @@ -422,7 +422,7 @@ pub fn self_exe_name() -> Option<Path> { 0u as libc::size_t); if err != 0 { return None; } if sz == 0 { return None; } - let mut v: ~[u8] = vec::with_capacity(sz as uint); + let mut v: ~[u8] = slice::with_capacity(sz as uint); let err = sysctl(mib.as_ptr(), mib.len() as ::libc::c_uint, v.as_mut_ptr() as *mut c_void, &mut sz, ptr::null(), 0u as libc::size_t); @@ -448,11 +448,11 @@ pub fn self_exe_name() -> Option<Path> { fn load_self() -> Option<~[u8]> { unsafe { use libc::funcs::extra::_NSGetExecutablePath; - use vec; + use slice; let mut sz: u32 = 0; _NSGetExecutablePath(ptr::mut_null(), &mut sz); if sz == 0 { return None; } - let mut v: ~[u8] = vec::with_capacity(sz as uint); + let mut v: ~[u8] = slice::with_capacity(sz as uint); let err = _NSGetExecutablePath(v.as_mut_ptr() as *mut i8, &mut sz); if err != 0 { return None; } v.set_len(sz as uint - 1); // chop off trailing NUL @@ -817,7 +817,7 @@ fn real_args() -> ~[~str] { #[cfg(windows)] fn real_args() -> ~[~str] { - use vec; + use slice; let mut nArgs: c_int = 0; let lpArgCount: *mut c_int = &mut nArgs; @@ -833,7 +833,7 @@ fn real_args() -> ~[~str] { while *ptr.offset(len as int) != 0 { len += 1; } // Push it onto the list. - let opt_s = vec::raw::buf_as_slice(ptr, len, |buf| { + let opt_s = slice::raw::buf_as_slice(ptr, len, |buf| { str::from_utf16(str::truncate_utf16_at_nul(buf)) }); args.push(opt_s.expect("CommandLineToArgvW returned invalid UTF-16")); diff --git a/src/libstd/path/mod.rs b/src/libstd/path/mod.rs index 09124f63361..c8465eb039f 100644 --- a/src/libstd/path/mod.rs +++ b/src/libstd/path/mod.rs @@ -71,9 +71,9 @@ use iter::Iterator; use option::{Option, None, Some}; use str; use str::{MaybeOwned, OwnedStr, Str, StrSlice, from_utf8_lossy}; -use vec; -use vec::{CloneableVector, OwnedCloneableVector, OwnedVector, Vector}; -use vec::{ImmutableEqVector, ImmutableVector}; +use slice; +use slice::{CloneableVector, OwnedCloneableVector, OwnedVector, Vector}; +use slice::{ImmutableEqVector, ImmutableVector}; /// Typedef for POSIX file paths. /// See `posix::Path` for more info. @@ -300,7 +300,7 @@ pub trait GenericPath: Clone + GenericPathUnsafe { } else { let mut v; let extension = extension.container_as_bytes(); - v = vec::with_capacity(name.len() + extension.len() + 1); + v = slice::with_capacity(name.len() + extension.len() + 1); v.push_all(name); v.push(dot); v.push_all(extension); @@ -313,7 +313,7 @@ pub trait GenericPath: Clone + GenericPathUnsafe { } else { let mut v; let extension = extension.container_as_bytes(); - v = vec::with_capacity(idx + extension.len() + 1); + v = slice::with_capacity(idx + extension.len() + 1); v.push_all(name.slice_to(idx+1)); v.push_all(extension); Some(v) diff --git a/src/libstd/path/posix.rs b/src/libstd/path/posix.rs index 8345a2d04d1..f654f59266a 100644 --- a/src/libstd/path/posix.rs +++ b/src/libstd/path/posix.rs @@ -20,9 +20,9 @@ use iter::{AdditiveIterator, Extendable, Iterator, Map}; use option::{Option, None, Some}; use str; use str::Str; -use vec; -use vec::{CloneableVector, RevSplits, Splits, Vector, VectorVector, - ImmutableEqVector, OwnedVector, ImmutableVector, OwnedCloneableVector}; +use slice; +use slice::{CloneableVector, RevSplits, Splits, Vector, VectorVector, + ImmutableEqVector, OwnedVector, ImmutableVector, OwnedCloneableVector}; use super::{BytesContainer, GenericPath, GenericPathUnsafe}; /// Iterator that yields successive components of a Path as &[u8] @@ -125,7 +125,7 @@ impl GenericPathUnsafe for Path { let filename = filename.container_as_bytes(); match self.sepidx { None if bytes!("..") == self.repr => { - let mut v = vec::with_capacity(3 + filename.len()); + let mut v = slice::with_capacity(3 + filename.len()); v.push_all(dot_dot_static); v.push(SEP_BYTE); v.push_all(filename); @@ -135,14 +135,14 @@ impl GenericPathUnsafe for Path { self.repr = Path::normalize(filename); } Some(idx) if self.repr.slice_from(idx+1) == bytes!("..") => { - let mut v = vec::with_capacity(self.repr.len() + 1 + filename.len()); + let mut v = slice::with_capacity(self.repr.len() + 1 + filename.len()); v.push_all(self.repr); v.push(SEP_BYTE); v.push_all(filename); self.repr = Path::normalize(v); } Some(idx) => { - let mut v = vec::with_capacity(idx + 1 + filename.len()); + let mut v = slice::with_capacity(idx + 1 + filename.len()); v.push_all(self.repr.slice_to(idx+1)); v.push_all(filename); self.repr = Path::normalize(v); @@ -157,7 +157,7 @@ impl GenericPathUnsafe for Path { if path[0] == SEP_BYTE { self.repr = Path::normalize(path); } else { - let mut v = vec::with_capacity(self.repr.len() + path.len() + 1); + let mut v = slice::with_capacity(self.repr.len() + path.len() + 1); v.push_all(self.repr); v.push(SEP_BYTE); v.push_all(path); @@ -346,7 +346,7 @@ impl Path { } else { let n = if is_abs { comps.len() } else { comps.len() - 1} + comps.iter().map(|v| v.len()).sum(); - let mut v = vec::with_capacity(n); + let mut v = slice::with_capacity(n); let mut it = comps.move_iter(); if !is_abs { match it.next() { diff --git a/src/libstd/path/windows.rs b/src/libstd/path/windows.rs index 180078ae959..dba8af4128b 100644 --- a/src/libstd/path/windows.rs +++ b/src/libstd/path/windows.rs @@ -22,7 +22,7 @@ use iter::{AdditiveIterator, DoubleEndedIterator, Extendable, Rev, Iterator, Map use option::{Option, Some, None}; use str; use str::{CharSplits, OwnedStr, Str, StrVector, StrSlice}; -use vec::{Vector, OwnedVector, ImmutableVector}; +use slice::{Vector, OwnedVector, ImmutableVector}; use super::{contains_nul, BytesContainer, GenericPath, GenericPathUnsafe}; /// Iterator that yields successive components of a Path as &str diff --git a/src/libstd/prelude.rs b/src/libstd/prelude.rs index a04b59ae601..0b1de74330d 100644 --- a/src/libstd/prelude.rs +++ b/src/libstd/prelude.rs @@ -55,10 +55,10 @@ pub use to_str::{ToStr, IntoStr}; pub use tuple::{Tuple1, Tuple2, Tuple3, Tuple4}; pub use tuple::{Tuple5, Tuple6, Tuple7, Tuple8}; pub use tuple::{Tuple9, Tuple10, Tuple11, Tuple12}; -pub use vec::{ImmutableEqVector, ImmutableTotalOrdVector, ImmutableCloneableVector}; -pub use vec::{OwnedVector, OwnedCloneableVector, OwnedEqVector}; -pub use vec::{MutableVector, MutableTotalOrdVector}; -pub use vec::{Vector, VectorVector, CloneableVector, ImmutableVector}; +pub use slice::{ImmutableEqVector, ImmutableTotalOrdVector, ImmutableCloneableVector}; +pub use slice::{OwnedVector, OwnedCloneableVector, OwnedEqVector}; +pub use slice::{MutableVector, MutableTotalOrdVector}; +pub use slice::{Vector, VectorVector, CloneableVector, ImmutableVector}; // Reexported runtime types pub use comm::{channel, Sender, Receiver}; diff --git a/src/libstd/ptr.rs b/src/libstd/ptr.rs index bf5ba6db5c3..179100255c4 100644 --- a/src/libstd/ptr.rs +++ b/src/libstd/ptr.rs @@ -388,7 +388,7 @@ pub mod ptr_tests { use cast; use libc; use str; - use vec::{ImmutableVector, MutableVector}; + use slice::{ImmutableVector, MutableVector}; #[test] fn test() { diff --git a/src/libstd/repr.rs b/src/libstd/repr.rs index c1b276899d5..f623dd472fd 100644 --- a/src/libstd/repr.rs +++ b/src/libstd/repr.rs @@ -28,7 +28,7 @@ use reflect::{MovePtr, align}; use result::{Ok, Err}; use str::StrSlice; use to_str::ToStr; -use vec::OwnedVector; +use slice::OwnedVector; use intrinsics::{Disr, Opaque, TyDesc, TyVisitor, get_tydesc, visit_tydesc}; use raw; diff --git a/src/libstd/rt/args.rs b/src/libstd/rt/args.rs index 6f73265978b..53b8db8499d 100644 --- a/src/libstd/rt/args.rs +++ b/src/libstd/rt/args.rs @@ -124,10 +124,10 @@ mod imp { #[cfg(not(test))] unsafe fn load_argc_and_argv(argc: int, argv: **u8) -> ~[~[u8]] { use c_str::CString; - use {vec, libc}; - use vec::CloneableVector; + use {slice, libc}; + use slice::CloneableVector; - vec::from_fn(argc as uint, |i| { + slice::from_fn(argc as uint, |i| { let cs = CString::new(*(argv as **libc::c_char).offset(i as int), false); cs.as_bytes_no_nul().to_owned() }) diff --git a/src/libstd/rt/at_exit_imp.rs b/src/libstd/rt/at_exit_imp.rs index 185f4b4edd7..96dcc5244c0 100644 --- a/src/libstd/rt/at_exit_imp.rs +++ b/src/libstd/rt/at_exit_imp.rs @@ -18,7 +18,7 @@ use mem; use option::{Some, None}; use ptr::RawPtr; use unstable::sync::Exclusive; -use vec::OwnedVector; +use slice::OwnedVector; type Queue = Exclusive<~[proc()]>; diff --git a/src/libstd/rt/backtrace.rs b/src/libstd/rt/backtrace.rs index bc75a98e085..7ae2521c423 100644 --- a/src/libstd/rt/backtrace.rs +++ b/src/libstd/rt/backtrace.rs @@ -349,7 +349,7 @@ mod imp { use path::GenericPath; use ptr::RawPtr; use ptr; - use vec::{ImmutableVector, MutableVector}; + use slice::{ImmutableVector, MutableVector}; //////////////////////////////////////////////////////////////////////// // libbacktrace.h API @@ -510,7 +510,7 @@ mod imp { use unstable::dynamic_lib::DynamicLibrary; use intrinsics; use unstable::mutex::{StaticNativeMutex, NATIVE_MUTEX_INIT}; - use vec::ImmutableVector; + use slice::ImmutableVector; extern "system" { fn GetCurrentProcess() -> libc::HANDLE; diff --git a/src/libstd/rt/crate_map.rs b/src/libstd/rt/crate_map.rs index c6d5a80208b..52cced26254 100644 --- a/src/libstd/rt/crate_map.rs +++ b/src/libstd/rt/crate_map.rs @@ -16,7 +16,7 @@ use rt::rtio::EventLoop; #[cfg(stage0)] use cmp::TotalOrd; #[cfg(stage0)] use container::MutableSet; #[cfg(stage0)] use iter::Iterator; -#[cfg(stage0)] use vec::{ImmutableVector, OwnedVector}; +#[cfg(stage0)] use slice::{ImmutableVector, OwnedVector}; // Need to tell the linker on OS X to not barf on undefined symbols // and instead look them up at runtime, which we need to resolve diff --git a/src/libstd/rt/local_heap.rs b/src/libstd/rt/local_heap.rs index 29b3dcaa4f2..91452f5aa0d 100644 --- a/src/libstd/rt/local_heap.rs +++ b/src/libstd/rt/local_heap.rs @@ -21,7 +21,7 @@ use rt::global_heap; use rt::local::Local; use rt::task::Task; use raw; -use vec::ImmutableVector; +use slice::ImmutableVector; use vec_ng::Vec; // This has no meaning with out rtdebug also turned on. diff --git a/src/libstd/rt/util.rs b/src/libstd/rt/util.rs index 6fe4db54944..4c208a64ddf 100644 --- a/src/libstd/rt/util.rs +++ b/src/libstd/rt/util.rs @@ -20,7 +20,7 @@ use os; use result::Ok; use str::StrSlice; use unstable::running_on_valgrind; -use vec::ImmutableVector; +use slice::ImmutableVector; // Indicates whether we should perform expensive sanity checks, including rtassert! // FIXME: Once the runtime matures remove the `true` below to turn off rtassert, etc. diff --git a/src/libstd/vec.rs b/src/libstd/slice.rs index 8080f57550b..12718c55923 100644 --- a/src/libstd/vec.rs +++ b/src/libstd/slice.rs @@ -158,7 +158,7 @@ pub fn from_elem<T:Clone>(n_elts: uint, t: T) -> ~[T] { // FIXME (#7136): manually inline from_fn for 2x plus speedup (sadly very // important, from_elem is a bottleneck in borrowck!). Unfortunately it // still is substantially slower than using the unsafe - // vec::with_capacity/ptr::set_memory for primitive types. + // slice::with_capacity/ptr::set_memory for primitive types. unsafe { let mut v = with_capacity(n_elts); let p = v.as_mut_ptr(); @@ -1464,7 +1464,7 @@ impl<T> OwnedVector<T> for ~[T] { fn reserve_additional(&mut self, n: uint) { if self.capacity() - self.len() < n { match self.len().checked_add(&n) { - None => fail!("vec::reserve_additional: `uint` overflow"), + None => fail!("slice::reserve_additional: `uint` overflow"), Some(new_cap) => self.reserve(new_cap) } } @@ -2430,7 +2430,7 @@ pub trait MutableCloneableVector<T> { /// # Example /// /// ```rust - /// use std::vec::MutableCloneableVector; + /// use std::slice::MutableCloneableVector; /// /// let mut dst = [0, 0, 0]; /// let src = [1, 2]; @@ -2497,7 +2497,7 @@ pub mod raw { use cast::transmute; use ptr; use ptr::RawPtr; - use vec::{with_capacity, MutableVector, OwnedVector}; + use slice::{with_capacity, MutableVector, OwnedVector}; use raw::Slice; /** @@ -2576,7 +2576,7 @@ pub mod raw { /// Operations on `[u8]`. pub mod bytes { use container::Container; - use vec::{MutableVector, OwnedVector, ImmutableVector}; + use slice::{MutableVector, OwnedVector, ImmutableVector}; use ptr; use ptr::RawPtr; @@ -2952,7 +2952,7 @@ impl<A> Extendable<A> for ~[A] { mod tests { use prelude::*; use mem; - use vec::*; + use slice::*; use cmp::*; use rand::{Rng, task_rng}; @@ -4105,7 +4105,7 @@ mod tests { #[test] fn test_bytes_set_memory() { - use vec::bytes::MutableByteVector; + use slice::bytes::MutableByteVector; let mut values = [1u8,2,3,4,5]; values.mut_slice(0,5).set_memory(0xAB); assert!(values == [0xAB, 0xAB, 0xAB, 0xAB, 0xAB]); @@ -4185,11 +4185,11 @@ mod tests { let xs = ~[Foo, Foo, Foo]; assert_eq!(format!("{:?}", xs.slice(0, 2).to_owned()), - ~"~[vec::tests::Foo, vec::tests::Foo]"); + ~"~[slice::tests::Foo, slice::tests::Foo]"); let xs: [Foo, ..3] = [Foo, Foo, Foo]; assert_eq!(format!("{:?}", xs.slice(0, 2).to_owned()), - ~"~[vec::tests::Foo, vec::tests::Foo]"); + ~"~[slice::tests::Foo, slice::tests::Foo]"); cnt = 0; for f in xs.iter() { assert!(*f == Foo); @@ -4365,13 +4365,13 @@ mod bench { use prelude::*; use ptr; use rand::{weak_rng, Rng}; - use vec; + use slice; #[bench] fn iterator(bh: &mut BenchHarness) { // peculiar numbers to stop LLVM from optimising the summation // out. - let v = vec::from_fn(100, |i| i ^ (i << 1) ^ (i >> 1)); + let v = slice::from_fn(100, |i| i ^ (i << 1) ^ (i >> 1)); bh.iter(|| { let mut sum = 0; @@ -4385,7 +4385,7 @@ mod bench { #[bench] fn mut_iterator(bh: &mut BenchHarness) { - let mut v = vec::from_elem(100, 0); + let mut v = slice::from_elem(100, 0); bh.iter(|| { let mut i = 0; @@ -4407,7 +4407,7 @@ mod bench { #[bench] fn concat(bh: &mut BenchHarness) { - let xss: &[~[uint]] = vec::from_fn(100, |i| range(0, i).collect()); + let xss: &[~[uint]] = slice::from_fn(100, |i| range(0, i).collect()); bh.iter(|| { let _ = xss.concat_vec(); }); @@ -4415,7 +4415,7 @@ mod bench { #[bench] fn connect(bh: &mut BenchHarness) { - let xss: &[~[uint]] = vec::from_fn(100, |i| range(0, i).collect()); + let xss: &[~[uint]] = slice::from_fn(100, |i| range(0, i).collect()); bh.iter(|| { let _ = xss.connect_vec(&0); }); @@ -4432,7 +4432,7 @@ mod bench { #[bench] fn starts_with_same_vector(bh: &mut BenchHarness) { - let vec: ~[uint] = vec::from_fn(100, |i| i); + let vec: ~[uint] = slice::from_fn(100, |i| i); bh.iter(|| { vec.starts_with(vec) }) @@ -4448,8 +4448,8 @@ mod bench { #[bench] fn starts_with_diff_one_element_at_end(bh: &mut BenchHarness) { - let vec: ~[uint] = vec::from_fn(100, |i| i); - let mut match_vec: ~[uint] = vec::from_fn(99, |i| i); + let vec: ~[uint] = slice::from_fn(100, |i| i); + let mut match_vec: ~[uint] = slice::from_fn(99, |i| i); match_vec.push(0); bh.iter(|| { vec.starts_with(match_vec) @@ -4458,7 +4458,7 @@ mod bench { #[bench] fn ends_with_same_vector(bh: &mut BenchHarness) { - let vec: ~[uint] = vec::from_fn(100, |i| i); + let vec: ~[uint] = slice::from_fn(100, |i| i); bh.iter(|| { vec.ends_with(vec) }) @@ -4474,8 +4474,8 @@ mod bench { #[bench] fn ends_with_diff_one_element_at_beginning(bh: &mut BenchHarness) { - let vec: ~[uint] = vec::from_fn(100, |i| i); - let mut match_vec: ~[uint] = vec::from_fn(100, |i| i); + let vec: ~[uint] = slice::from_fn(100, |i| i); + let mut match_vec: ~[uint] = slice::from_fn(100, |i| i); match_vec[0] = 200; bh.iter(|| { vec.starts_with(match_vec) @@ -4484,7 +4484,7 @@ mod bench { #[bench] fn contains_last_element(bh: &mut BenchHarness) { - let vec: ~[uint] = vec::from_fn(100, |i| i); + let vec: ~[uint] = slice::from_fn(100, |i| i); bh.iter(|| { vec.contains(&99u) }) @@ -4493,14 +4493,14 @@ mod bench { #[bench] fn zero_1kb_from_elem(bh: &mut BenchHarness) { bh.iter(|| { - let _v: ~[u8] = vec::from_elem(1024, 0u8); + let _v: ~[u8] = slice::from_elem(1024, 0u8); }); } #[bench] fn zero_1kb_set_memory(bh: &mut BenchHarness) { bh.iter(|| { - let mut v: ~[u8] = vec::with_capacity(1024); + let mut v: ~[u8] = slice::with_capacity(1024); unsafe { let vp = v.as_mut_ptr(); ptr::set_memory(vp, 0, 1024); @@ -4522,7 +4522,7 @@ mod bench { // Slower because the { len, cap, [0 x T] }* repr allows a pointer to the length // field to be aliased (in theory) and prevents LLVM from optimizing loads away. bh.iter(|| { - let mut v: ~[u8] = vec::with_capacity(1024); + let mut v: ~[u8] = slice::with_capacity(1024); unsafe { v.set_len(1024); } @@ -4535,7 +4535,7 @@ mod bench { #[bench] fn zero_1kb_mut_iter(bh: &mut BenchHarness) { bh.iter(|| { - let mut v: ~[u8] = vec::with_capacity(1024); + let mut v: ~[u8] = slice::with_capacity(1024); unsafe { v.set_len(1024); } @@ -4550,7 +4550,7 @@ mod bench { fn random_inserts(bh: &mut BenchHarness) { let mut rng = weak_rng(); bh.iter(|| { - let mut v = vec::from_elem(30, (0u, 0u)); + let mut v = slice::from_elem(30, (0u, 0u)); for _ in range(0, 100) { let l = v.len(); v.insert(rng.gen::<uint>() % (l + 1), @@ -4562,7 +4562,7 @@ mod bench { fn random_removes(bh: &mut BenchHarness) { let mut rng = weak_rng(); bh.iter(|| { - let mut v = vec::from_elem(130, (0u, 0u)); + let mut v = slice::from_elem(130, (0u, 0u)); for _ in range(0, 100) { let l = v.len(); v.remove(rng.gen::<uint>() % l); @@ -4602,7 +4602,7 @@ mod bench { #[bench] fn sort_sorted(bh: &mut BenchHarness) { - let mut v = vec::from_fn(10000, |i| i); + let mut v = slice::from_fn(10000, |i| i); bh.iter(|| { v.sort(); }); @@ -4643,7 +4643,7 @@ mod bench { #[bench] fn sort_big_sorted(bh: &mut BenchHarness) { - let mut v = vec::from_fn(10000u, |i| (i, i, i, i)); + let mut v = slice::from_fn(10000u, |i| (i, i, i, i)); bh.iter(|| { v.sort(); }); diff --git a/src/libstd/str.rs b/src/libstd/str.rs index ccd08e8a716..92e86a5cccb 100644 --- a/src/libstd/str.rs +++ b/src/libstd/str.rs @@ -99,8 +99,8 @@ use option::{None, Option, Some}; use ptr; use ptr::RawPtr; use from_str::FromStr; -use vec; -use vec::{OwnedVector, OwnedCloneableVector, ImmutableVector, MutableVector}; +use slice; +use slice::{OwnedVector, OwnedCloneableVector, ImmutableVector, MutableVector}; use vec_ng::Vec; use default::Default; use raw::Repr; @@ -360,7 +360,7 @@ pub type RevCharOffsets<'a> = Rev<CharOffsets<'a>>; /// External iterator for a string's bytes. /// Use with the `std::iter` module. pub type Bytes<'a> = - Map<'a, &'a u8, u8, vec::Items<'a, u8>>; + Map<'a, &'a u8, u8, slice::Items<'a, u8>>; /// External iterator for a string's bytes in reverse order. /// Use with the `std::iter` module. @@ -738,7 +738,7 @@ Section: Misc /// `iter` reset such that it is pointing at the first byte in the /// invalid sequence. #[inline(always)] -fn run_utf8_validation_iterator(iter: &mut vec::Items<u8>) -> bool { +fn run_utf8_validation_iterator(iter: &mut slice::Items<u8>) -> bool { loop { // save the current thing we're pointing at. let old = *iter; @@ -855,7 +855,7 @@ pub fn is_utf16(v: &[u16]) -> bool { /// of `u16`s. #[deriving(Clone)] pub struct UTF16Items<'a> { - priv iter: vec::Items<'a, u16> + priv iter: slice::Items<'a, u16> } /// The possibilities for values decoded from a `u16` stream. #[deriving(Eq, TotalEq, Clone, Show)] @@ -1025,7 +1025,7 @@ pub fn from_utf16_lossy(v: &[u16]) -> ~str { #[inline] pub fn with_capacity(capacity: uint) -> ~str { unsafe { - cast::transmute(vec::with_capacity::<~[u8]>(capacity)) + cast::transmute(slice::with_capacity::<~[u8]>(capacity)) } } @@ -1360,13 +1360,13 @@ pub mod raw { use ptr::RawPtr; use option::{Option, Some, None}; use str::{is_utf8, OwnedStr, StrSlice}; - use vec; - use vec::{MutableVector, ImmutableVector, OwnedVector}; + use slice; + use slice::{MutableVector, ImmutableVector, OwnedVector}; use raw::Slice; /// Create a Rust string from a *u8 buffer of the given length pub unsafe fn from_buf_len(buf: *u8, len: uint) -> ~str { - let mut v: ~[u8] = vec::with_capacity(len); + let mut v: ~[u8] = slice::with_capacity(len); ptr::copy_memory(v.as_mut_ptr(), buf, len); v.set_len(len); @@ -1463,7 +1463,7 @@ pub mod raw { /// The caller must preserve the valid UTF-8 property. #[inline] pub unsafe fn push_bytes(s: &mut ~str, bytes: &[u8]) { - vec::bytes::push_bytes(as_owned_vec(s), bytes); + slice::bytes::push_bytes(as_owned_vec(s), bytes); } /// Removes the last byte from a string and returns it. @@ -2603,7 +2603,7 @@ impl<'a> StrSlice<'a> for &'a str { fn to_owned(&self) -> ~str { let len = self.len(); unsafe { - let mut v = vec::with_capacity(len); + let mut v = slice::with_capacity(len); ptr::copy_memory(v.as_mut_ptr(), self.as_ptr(), len); v.set_len(len); @@ -2766,7 +2766,7 @@ impl<'a> StrSlice<'a> for &'a str { if slen == 0 { return tlen; } if tlen == 0 { return slen; } - let mut dcol = vec::from_fn(tlen + 1, |x| x); + let mut dcol = slice::from_fn(tlen + 1, |x| x); for (i, sc) in self.chars().enumerate() { @@ -2921,7 +2921,7 @@ impl OwnedStr for ~str { // Attempt to not use an intermediate buffer by just pushing bytes // directly onto this string. let write_ptr = v.as_mut_ptr().offset(cur_len as int); - let used = vec::raw::mut_buf_as_slice(write_ptr, 4, |slc| c.encode_utf8(slc)); + let used = slice::raw::mut_buf_as_slice(write_ptr, 4, |slc| c.encode_utf8(slc)); v.set_len(cur_len + used); } @@ -4667,7 +4667,7 @@ mod bench { #[bench] fn from_utf8_lossy_100_invalid(bh: &mut BenchHarness) { - let s = ::vec::from_elem(100, 0xF5u8); + let s = ::slice::from_elem(100, 0xF5u8); bh.iter(|| { let _ = from_utf8_lossy(s); }); diff --git a/src/libstd/sync/arc.rs b/src/libstd/sync/arc.rs index 56c71a5e4ff..883e81355e1 100644 --- a/src/libstd/sync/arc.rs +++ b/src/libstd/sync/arc.rs @@ -27,7 +27,7 @@ use kinds::Send; use ops::Drop; use ptr::RawPtr; use sync::atomics::{fence, AtomicUint, Relaxed, Acquire, Release}; -use vec; +use slice; /// An atomically reference counted pointer. /// @@ -69,7 +69,7 @@ impl<T: Send> UnsafeArc<T> { ~[] // need to free data here } else { let ptr = new_inner(data, num_handles); - vec::from_fn(num_handles, |_| UnsafeArc { data: ptr }) + slice::from_fn(num_handles, |_| UnsafeArc { data: ptr }) } } } diff --git a/src/libstd/sync/deque.rs b/src/libstd/sync/deque.rs index 1cd6920612e..658ee48af1a 100644 --- a/src/libstd/sync/deque.rs +++ b/src/libstd/sync/deque.rs @@ -61,7 +61,7 @@ use ptr::RawPtr; use sync::arc::UnsafeArc; use sync::atomics::{AtomicInt, AtomicPtr, SeqCst}; use unstable::sync::Exclusive; -use vec::{OwnedVector, ImmutableVector}; +use slice::{OwnedVector, ImmutableVector}; // Once the queue is less than 1/K full, then it will be downsized. Note that // the deque requires that this number be less than 2. @@ -404,7 +404,7 @@ mod tests { use rand::Rng; use sync::atomics::{AtomicBool, INIT_ATOMIC_BOOL, SeqCst, AtomicUint, INIT_ATOMIC_UINT}; - use vec; + use slice; #[test] fn smoke() { @@ -600,7 +600,7 @@ mod tests { let mut pool = BufferPool::<(int, uint)>::new(); let (mut w, s) = pool.deque(); - let (threads, hits) = vec::unzip(range(0, NTHREADS).map(|_| { + let (threads, hits) = slice::unzip(range(0, NTHREADS).map(|_| { let s = s.clone(); let unique_box = ~AtomicUint::new(0); let thread_box = unsafe { diff --git a/src/libstd/sync/mpmc_bounded_queue.rs b/src/libstd/sync/mpmc_bounded_queue.rs index ad0434c634a..95f592baff0 100644 --- a/src/libstd/sync/mpmc_bounded_queue.rs +++ b/src/libstd/sync/mpmc_bounded_queue.rs @@ -35,7 +35,7 @@ use num::next_power_of_two; use option::{Option, Some, None}; use sync::arc::UnsafeArc; use sync::atomics::{AtomicUint,Relaxed,Release,Acquire}; -use vec; +use slice; struct Node<T> { sequence: AtomicUint, @@ -69,8 +69,8 @@ impl<T: Send> State<T> { } else { capacity }; - let buffer = vec::from_fn(capacity, |i:uint| { - Node{sequence:AtomicUint::new(i),value:None} + let buffer = slice::from_fn(capacity, |i| { + Node { sequence:AtomicUint::new(i), value: None } }); State{ pad0: [0, ..64], diff --git a/src/libstd/unicode.rs b/src/libstd/unicode.rs index b43003f0de2..645db8e040b 100644 --- a/src/libstd/unicode.rs +++ b/src/libstd/unicode.rs @@ -13,10 +13,9 @@ #[allow(missing_doc)]; #[allow(non_uppercase_statics)]; - fn bsearch_range_table(c: char, r: &'static [(char,char)]) -> bool { use cmp::{Equal, Less, Greater}; - use vec::ImmutableVector; + use slice::ImmutableVector; use option::None; r.bsearch(|&(lo,hi)| { if lo <= c && c <= hi { Equal } @@ -25,7 +24,6 @@ fn bsearch_range_table(c: char, r: &'static [(char,char)]) -> bool { }) != None } - pub mod general_category { static Cc_table : &'static [(char,char)] = &[ ('\x00', '\x1f'), ('\x7f', '\x9f') @@ -108,7 +106,7 @@ pub mod general_category { pub mod decompose { use option::Option; use option::{Some, None}; - use vec::ImmutableVector; + use slice::ImmutableVector; fn bsearch_table(c: char, r: &'static [(char, &'static [char])]) -> Option<&'static [char]> { use cmp::{Equal, Less, Greater}; @@ -4136,8 +4134,8 @@ pub mod derived_property { pub fn XID_Start(c: char) -> bool { super::bsearch_range_table(c, XID_Start_table) } - } + pub mod property { static White_Space_table : &'static [(char,char)] = &[ ('\x09', '\x0d'), ('\x20', '\x20'), @@ -4151,12 +4149,11 @@ pub mod property { pub fn White_Space(c: char) -> bool { super::bsearch_range_table(c, White_Space_table) } - } -pub mod conversions { +pub mod conversions { use cmp::{Equal, Less, Greater}; - use vec::ImmutableVector; + use slice::ImmutableVector; use tuple::Tuple2; use option::{Option, Some, None}; @@ -4181,7 +4178,8 @@ pub mod conversions { else { Greater } }) } - static LuLl_table : &'static [(char, char)] = &[ + + static LuLl_table : &'static [(char, char)] = &[ ('\x41', '\x61'), ('\x42', '\x62'), ('\x43', '\x63'), ('\x44', '\x64'), ('\x45', '\x65'), ('\x46', '\x66'), diff --git a/src/libstd/vec_ng.rs b/src/libstd/vec_ng.rs index 04e3ad920ec..553f528745b 100644 --- a/src/libstd/vec_ng.rs +++ b/src/libstd/vec_ng.rs @@ -27,8 +27,8 @@ use ptr::RawPtr; use ptr; use rt::global_heap::{malloc_raw, realloc_raw}; use raw::Slice; -use vec::{ImmutableEqVector, ImmutableVector, Items, MutItems, MutableVector}; -use vec::{MutableTotalOrdVector}; +use slice::{ImmutableEqVector, ImmutableVector, Items, MutItems, MutableVector}; +use slice::{MutableTotalOrdVector}; /// An owned, growable vector /// |