use core::ptr;
use core::raw::Slice as RawSlice;
use core::slice;
-use core::uint;
+use core::usize;
/// A growable list type, written `Vec<T>` but pronounced 'vector.'
///
#[stable(feature = "rust1", since = "1.0.0")]
pub struct Vec<T> {
ptr: NonZero<*mut T>,
- len: uint,
- cap: uint,
+ len: usize,
+ cap: usize,
}
unsafe impl<T: Send> Send for Vec<T> { }
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn with_capacity(capacity: uint) -> Vec<T> {
+ pub fn with_capacity(capacity: usize) -> Vec<T> {
if mem::size_of::<T>() == 0 {
- Vec { ptr: unsafe { NonZero::new(EMPTY as *mut T) }, len: 0, cap: uint::MAX }
+ Vec { ptr: unsafe { NonZero::new(EMPTY as *mut T) }, len: 0, cap: usize::MAX }
} else if capacity == 0 {
Vec::new()
} else {
/// mem::forget(v);
///
/// // Overwrite memory with 4, 5, 6
- /// for i in 0..len as int {
+ /// for i in 0..len as isize {
/// ptr::write(p.offset(i), 4 + i);
/// }
///
/// }
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub unsafe fn from_raw_parts(ptr: *mut T, length: uint,
- capacity: uint) -> Vec<T> {
+ pub unsafe fn from_raw_parts(ptr: *mut T, length: usize,
+ capacity: usize) -> Vec<T> {
Vec { ptr: NonZero::new(ptr), len: length, cap: capacity }
}
#[inline]
#[unstable(feature = "collections",
reason = "may be better expressed via composition")]
- pub unsafe fn from_raw_buf(ptr: *const T, elts: uint) -> Vec<T> {
+ pub unsafe fn from_raw_buf(ptr: *const T, elts: usize) -> Vec<T> {
let mut dst = Vec::with_capacity(elts);
dst.set_len(elts);
ptr::copy_nonoverlapping_memory(dst.as_mut_ptr(), ptr, elts);
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn capacity(&self) -> uint {
+ pub fn capacity(&self) -> usize {
self.cap
}
///
/// # Panics
///
- /// Panics if the new capacity overflows `uint`.
+ /// Panics if the new capacity overflows `usize`.
///
/// # Examples
///
/// assert!(vec.capacity() >= 11);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn reserve(&mut self, additional: uint) {
+ pub fn reserve(&mut self, additional: usize) {
if self.cap - self.len < additional {
- let err_msg = "Vec::reserve: `uint` overflow";
+ let err_msg = "Vec::reserve: `usize` overflow";
let new_cap = self.len.checked_add(additional).expect(err_msg)
.checked_next_power_of_two().expect(err_msg);
self.grow_capacity(new_cap);
///
/// # Panics
///
- /// Panics if the new capacity overflows `uint`.
+ /// Panics if the new capacity overflows `usize`.
///
/// # Examples
///
/// assert!(vec.capacity() >= 11);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn reserve_exact(&mut self, additional: uint) {
+ pub fn reserve_exact(&mut self, additional: usize) {
if self.cap - self.len < additional {
match self.len.checked_add(additional) {
- None => panic!("Vec::reserve: `uint` overflow"),
+ None => panic!("Vec::reserve: `usize` overflow"),
Some(new_cap) => self.grow_capacity(new_cap)
}
}
pub fn into_boxed_slice(mut self) -> Box<[T]> {
self.shrink_to_fit();
unsafe {
- let xs: Box<[T]> = mem::transmute(self.as_mut_slice());
+ let xs: Box<[T]> = mem::transmute(&mut *self);
mem::forget(self);
xs
}
/// assert_eq!(vec, vec![1, 2]);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn truncate(&mut self, len: uint) {
+ pub fn truncate(&mut self, len: usize) {
unsafe {
// drop any extra elements
while len < self.len {
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn as_mut_slice<'a>(&'a mut self) -> &'a mut [T] {
+ pub fn as_mut_slice(&mut self) -> &mut [T] {
unsafe {
mem::transmute(RawSlice {
data: *self.ptr,
let cap = self.cap;
let begin = ptr as *const T;
let end = if mem::size_of::<T>() == 0 {
- (ptr as uint + self.len()) as *const T
+ (ptr as usize + self.len()) as *const T
} else {
- ptr.offset(self.len() as int) as *const T
+ ptr.offset(self.len() as isize) as *const T
};
mem::forget(self);
IntoIter { allocation: ptr, cap: cap, ptr: begin, end: end }
/// # Examples
///
/// ```
- /// let mut v = vec![1u, 2, 3, 4];
+ /// let mut v = vec![1, 2, 3, 4];
/// unsafe {
/// v.set_len(1);
/// }
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub unsafe fn set_len(&mut self, len: uint) {
+ pub unsafe fn set_len(&mut self, len: usize) {
self.len = len;
}
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn swap_remove(&mut self, index: uint) -> T {
+ pub fn swap_remove(&mut self, index: usize) -> T {
let length = self.len();
self.swap(index, length - 1);
self.pop().unwrap()
/// assert_eq!(vec, vec![1, 4, 2, 3, 5]);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn insert(&mut self, index: uint, element: T) {
+ pub fn insert(&mut self, index: usize, element: T) {
let len = self.len();
assert!(index <= len);
// space for the new element
unsafe { // infallible
// The spot to put the new value
{
- let p = self.as_mut_ptr().offset(index as int);
+ let p = self.as_mut_ptr().offset(index as isize);
// Shift everything over to make space. (Duplicating the
// `index`th element into two consecutive places.)
ptr::copy_memory(p.offset(1), &*p, len - index);
/// assert_eq!(v, vec![1, 3]);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn remove(&mut self, index: uint) -> T {
+ pub fn remove(&mut self, index: usize) -> T {
let len = self.len();
assert!(index < len);
unsafe { // infallible
let ret;
{
// the place we are taking from.
- let ptr = self.as_mut_ptr().offset(index as int);
+ let ptr = self.as_mut_ptr().offset(index as isize);
// copy it out, unsafely having a copy of the value on
// the stack and in the vector at the same time.
ret = ptr::read(ptr);
#[stable(feature = "rust1", since = "1.0.0")]
pub fn retain<F>(&mut self, mut f: F) where F: FnMut(&T) -> bool {
let len = self.len();
- let mut del = 0u;
+ let mut del = 0;
{
- let v = self.as_mut_slice();
+ let v = &mut **self;
- for i in 0u..len {
+ for i in 0..len {
if !f(&v[i]) {
del += 1;
} else if del > 0 {
///
/// # Panics
///
- /// Panics if the number of elements in the vector overflows a `uint`.
+ /// Panics if the number of elements in the vector overflows a `usize`.
///
/// # Examples
///
}
unsafe {
- let end = (*self.ptr).offset(self.len as int);
+ let end = (*self.ptr).offset(self.len as isize);
ptr::write(&mut *end, value);
self.len += 1;
}
///
/// # Panics
///
- /// Panics if the number of elements in the vector overflows a `uint`.
+ /// Panics if the number of elements in the vector overflows a `usize`.
///
/// # Examples
/// ```rust
#[inline]
#[unstable(feature = "collections",
reason = "matches collection reform specification, waiting for dust to settle")]
- pub fn drain<'a>(&'a mut self) -> Drain<'a, T> {
+ pub fn drain(&mut self) -> Drain<T> {
unsafe {
let begin = *self.ptr as *const T;
let end = if mem::size_of::<T>() == 0 {
- (*self.ptr as uint + self.len()) as *const T
+ (*self.ptr as usize + self.len()) as *const T
} else {
- (*self.ptr).offset(self.len() as int) as *const T
+ (*self.ptr).offset(self.len() as isize) as *const T
};
self.set_len(0);
Drain {
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn len(&self) -> uint { self.len }
+ pub fn len(&self) -> usize { self.len }
/// Returns `true` if the vector contains no elements.
///
/// # Examples
///
/// ```
- /// let v = vec![0u, 1, 2];
+ /// let v = vec![0, 1, 2];
/// let w = v.map_in_place(|i| i + 3);
/// assert_eq!(w.as_slice(), [3, 4, 5].as_slice());
///
// types are passed to the allocator by `Vec`.
assert!(mem::min_align_of::<T>() == mem::min_align_of::<U>());
- // This `as int` cast is safe, because the size of the elements of the
+ // This `as isize` cast is safe, because the size of the elements of the
// vector is not 0, and:
//
// 1) If the size of the elements in the vector is 1, the `int` may
// After `array.offset(offset)`: 0x9.
// (0x1 + 0x8 = 0x1 - 0x8)
//
- // 2) If the size of the elements in the vector is >1, the `uint` ->
+ // 2) If the size of the elements in the vector is >1, the `usize` ->
// `int` conversion can't overflow.
- let offset = vec.len() as int;
+ let offset = vec.len() as isize;
let start = vec.as_mut_ptr();
let mut pv = PartialVecNonZeroSized {
let u = f(t);
// Forget the `U` and increment `num_u`. This increment
- // cannot overflow the `uint` as we only do this for a
- // number of times that fits into a `uint` (and start with
+ // cannot overflow the `usize` as we only do this for a
+ // number of times that fits into a `usize` (and start with
// `0`). Again, we should not panic between these steps.
mem::forget(u);
pv.num_u += 1;
/// ```
#[unstable(feature = "collections",
reason = "matches collection reform specification; waiting for dust to settle")]
- pub fn resize(&mut self, new_len: uint, value: T) {
+ pub fn resize(&mut self, new_len: usize, value: T) {
let len = self.len();
if new_len > len {
let mut w = 1;
while r < ln {
- let p_r = p.offset(r as int);
- let p_wm1 = p.offset((w - 1) as int);
+ let p_r = p.offset(r as isize);
+ let p_wm1 = p.offset((w - 1) as isize);
if *p_r != *p_wm1 {
if r != w {
let p_w = p_wm1.offset(1);
///
/// If the capacity for `self` is already equal to or greater than the
/// requested capacity, then no action is taken.
- fn grow_capacity(&mut self, capacity: uint) {
+ fn grow_capacity(&mut self, capacity: usize) {
if mem::size_of::<T>() == 0 { return }
if capacity > self.cap {
// FIXME: #13996: need a way to mark the return value as `noalias`
#[inline(never)]
-unsafe fn alloc_or_realloc<T>(ptr: *mut T, old_size: uint, size: uint) -> *mut T {
+unsafe fn alloc_or_realloc<T>(ptr: *mut T, old_size: usize, size: usize) -> *mut T {
if old_size == 0 {
allocate(size, mem::min_align_of::<T>()) as *mut T
} else {
}
#[inline]
-unsafe fn dealloc<T>(ptr: *mut T, len: uint) {
+unsafe fn dealloc<T>(ptr: *mut T, len: usize) {
if mem::size_of::<T>() != 0 {
deallocate(ptr as *mut u8,
len * mem::size_of::<T>(),
#[unstable(feature = "collections")]
impl<T:Clone> Clone for Vec<T> {
- fn clone(&self) -> Vec<T> { ::slice::SliceExt::to_vec(self.as_slice()) }
+ fn clone(&self) -> Vec<T> { ::slice::SliceExt::to_vec(&**self) }
fn clone_from(&mut self, other: &Vec<T>) {
// drop anything in self that will not be overwritten
impl<S: hash::Writer + hash::Hasher, T: Hash<S>> Hash<S> for Vec<T> {
#[inline]
fn hash(&self, state: &mut S) {
- self.as_slice().hash(state);
+ Hash::hash(&**self, state)
}
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> Index<uint> for Vec<T> {
+impl<T> Index<usize> for Vec<T> {
type Output = T;
#[inline]
- fn index<'a>(&'a self, index: &uint) -> &'a T {
- &self.as_slice()[*index]
+ fn index(&self, index: &usize) -> &T {
+ // NB built-in indexing via `&[T]`
+ &(**self)[*index]
}
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> IndexMut<uint> for Vec<T> {
- type Output = T;
-
+impl<T> IndexMut<usize> for Vec<T> {
#[inline]
- fn index_mut<'a>(&'a mut self, index: &uint) -> &'a mut T {
- &mut self.as_mut_slice()[*index]
+ fn index_mut(&mut self, index: &usize) -> &mut T {
+ // NB built-in indexing via `&mut [T]`
+ &mut (**self)[*index]
}
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> ops::Index<ops::Range<uint>> for Vec<T> {
+impl<T> ops::Index<ops::Range<usize>> for Vec<T> {
type Output = [T];
#[inline]
- fn index(&self, index: &ops::Range<uint>) -> &[T] {
- self.as_slice().index(index)
+ fn index(&self, index: &ops::Range<usize>) -> &[T] {
+ Index::index(&**self, index)
}
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> ops::Index<ops::RangeTo<uint>> for Vec<T> {
+impl<T> ops::Index<ops::RangeTo<usize>> for Vec<T> {
type Output = [T];
#[inline]
- fn index(&self, index: &ops::RangeTo<uint>) -> &[T] {
- self.as_slice().index(index)
+ fn index(&self, index: &ops::RangeTo<usize>) -> &[T] {
+ Index::index(&**self, index)
}
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> ops::Index<ops::RangeFrom<uint>> for Vec<T> {
+impl<T> ops::Index<ops::RangeFrom<usize>> for Vec<T> {
type Output = [T];
#[inline]
- fn index(&self, index: &ops::RangeFrom<uint>) -> &[T] {
- self.as_slice().index(index)
+ fn index(&self, index: &ops::RangeFrom<usize>) -> &[T] {
+ Index::index(&**self, index)
}
}
#[stable(feature = "rust1", since = "1.0.0")]
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> ops::IndexMut<ops::Range<uint>> for Vec<T> {
- type Output = [T];
+impl<T> ops::IndexMut<ops::Range<usize>> for Vec<T> {
#[inline]
- fn index_mut(&mut self, index: &ops::Range<uint>) -> &mut [T] {
- self.as_mut_slice().index_mut(index)
+ fn index_mut(&mut self, index: &ops::Range<usize>) -> &mut [T] {
+ IndexMut::index_mut(&mut **self, index)
}
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> ops::IndexMut<ops::RangeTo<uint>> for Vec<T> {
- type Output = [T];
+impl<T> ops::IndexMut<ops::RangeTo<usize>> for Vec<T> {
#[inline]
- fn index_mut(&mut self, index: &ops::RangeTo<uint>) -> &mut [T] {
- self.as_mut_slice().index_mut(index)
+ fn index_mut(&mut self, index: &ops::RangeTo<usize>) -> &mut [T] {
+ IndexMut::index_mut(&mut **self, index)
}
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> ops::IndexMut<ops::RangeFrom<uint>> for Vec<T> {
- type Output = [T];
+impl<T> ops::IndexMut<ops::RangeFrom<usize>> for Vec<T> {
#[inline]
- fn index_mut(&mut self, index: &ops::RangeFrom<uint>) -> &mut [T] {
- self.as_mut_slice().index_mut(index)
+ fn index_mut(&mut self, index: &ops::RangeFrom<usize>) -> &mut [T] {
+ IndexMut::index_mut(&mut **self, index)
}
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<T> ops::IndexMut<ops::RangeFull> for Vec<T> {
- type Output = [T];
#[inline]
fn index_mut(&mut self, _index: &ops::RangeFull) -> &mut [T] {
self.as_mut_slice()
impl<T> ops::Deref for Vec<T> {
type Target = [T];
- fn deref<'a>(&'a self) -> &'a [T] { self.as_slice() }
+ fn deref(&self) -> &[T] { self.as_slice() }
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<T> ops::DerefMut for Vec<T> {
- fn deref_mut<'a>(&'a mut self) -> &'a mut [T] { self.as_mut_slice() }
+ fn deref_mut(&mut self) -> &mut [T] { self.as_mut_slice() }
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<T: PartialOrd> PartialOrd for Vec<T> {
#[inline]
fn partial_cmp(&self, other: &Vec<T>) -> Option<Ordering> {
- self.as_slice().partial_cmp(other.as_slice())
+ PartialOrd::partial_cmp(&**self, &**other)
}
}
impl<T: Ord> Ord for Vec<T> {
#[inline]
fn cmp(&self, other: &Vec<T>) -> Ordering {
- self.as_slice().cmp(other.as_slice())
+ Ord::cmp(&**self, &**other)
}
}
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- fn as_slice<'a>(&'a self) -> &'a [T] {
+ fn as_slice(&self) -> &[T] {
unsafe {
mem::transmute(RawSlice {
data: *self.ptr,
#[stable(feature = "rust1", since = "1.0.0")]
impl<T: fmt::Debug> fmt::Debug for Vec<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- fmt::Debug::fmt(self.as_slice(), f)
+ fmt::Debug::fmt(&**self, f)
}
}
#[stable(feature = "rust1", since = "1.0.0")]
pub struct IntoIter<T> {
allocation: *mut T, // the block of memory allocated for the vector
- cap: uint, // the capacity of the vector
+ cap: usize, // the capacity of the vector
ptr: *const T,
end: *const T
}
type Item = T;
#[inline]
- fn next<'a>(&'a mut self) -> Option<T> {
+ fn next(&mut self) -> Option<T> {
unsafe {
if self.ptr == self.end {
None
// purposefully don't use 'ptr.offset' because for
// vectors with 0-size elements this would return the
// same pointer.
- self.ptr = mem::transmute(self.ptr as uint + 1);
+ self.ptr = mem::transmute(self.ptr as usize + 1);
// Use a non-null pointer value
- Some(ptr::read(mem::transmute(1u)))
+ Some(ptr::read(EMPTY as *mut T))
} else {
let old = self.ptr;
self.ptr = self.ptr.offset(1);
}
#[inline]
- fn size_hint(&self) -> (uint, Option<uint>) {
- let diff = (self.end as uint) - (self.ptr as uint);
+ fn size_hint(&self) -> (usize, Option<usize>) {
+ let diff = (self.end as usize) - (self.ptr as usize);
let size = mem::size_of::<T>();
let exact = diff / (if size == 0 {1} else {size});
(exact, Some(exact))
#[stable(feature = "rust1", since = "1.0.0")]
impl<T> DoubleEndedIterator for IntoIter<T> {
#[inline]
- fn next_back<'a>(&'a mut self) -> Option<T> {
+ fn next_back(&mut self) -> Option<T> {
unsafe {
if self.end == self.ptr {
None
} else {
if mem::size_of::<T>() == 0 {
// See above for why 'ptr.offset' isn't used
- self.end = mem::transmute(self.end as uint - 1);
+ self.end = mem::transmute(self.end as usize - 1);
// Use a non-null pointer value
- Some(ptr::read(mem::transmute(1u)))
+ Some(ptr::read(EMPTY as *mut T))
} else {
self.end = self.end.offset(-1);
// purposefully don't use 'ptr.offset' because for
// vectors with 0-size elements this would return the
// same pointer.
- self.ptr = mem::transmute(self.ptr as uint + 1);
+ self.ptr = mem::transmute(self.ptr as usize + 1);
// Use a non-null pointer value
- Some(ptr::read(mem::transmute(1u)))
+ Some(ptr::read(EMPTY as *mut T))
} else {
let old = self.ptr;
self.ptr = self.ptr.offset(1);
}
#[inline]
- fn size_hint(&self) -> (uint, Option<uint>) {
- let diff = (self.end as uint) - (self.ptr as uint);
+ fn size_hint(&self) -> (usize, Option<usize>) {
+ let diff = (self.end as usize) - (self.ptr as usize);
let size = mem::size_of::<T>();
let exact = diff / (if size == 0 {1} else {size});
(exact, Some(exact))
} else {
if mem::size_of::<T>() == 0 {
// See above for why 'ptr.offset' isn't used
- self.end = mem::transmute(self.end as uint - 1);
+ self.end = mem::transmute(self.end as usize - 1);
// Use a non-null pointer value
- Some(ptr::read(mem::transmute(1u)))
+ Some(ptr::read(EMPTY as *mut T))
} else {
self.end = self.end.offset(-1);
/// When the destructor of this struct runs, all `num_t` `T`s and `num_u` `U`s
/// are destructed.
struct PartialVecZeroSized<T,U> {
- num_t: uint,
- num_u: uint,
+ num_t: usize,
+ num_u: usize,
marker_t: InvariantType<T>,
marker_u: InvariantType<U>,
}
use super::as_vec;
struct DropCounter<'a> {
- count: &'a mut int
+ count: &'a mut u32
}
#[unsafe_destructor]
#[test]
fn test_as_vec() {
let xs = [1u8, 2u8, 3u8];
- assert_eq!(as_vec(&xs).as_slice(), xs);
+ assert_eq!(&**as_vec(&xs), xs);
}
#[test]
#[test]
fn test_small_vec_struct() {
- assert!(size_of::<Vec<u8>>() == size_of::<uint>() * 3);
+ assert!(size_of::<Vec<u8>>() == size_of::<usize>() * 3);
}
#[test]
#[test]
fn test_slice_from_mut() {
- let mut values = vec![1u8,2,3,4,5];
+ let mut values = vec![1, 2, 3, 4, 5];
{
let slice = &mut values[2 ..];
assert!(slice == [3, 4, 5]);
#[test]
fn test_slice_to_mut() {
- let mut values = vec![1u8,2,3,4,5];
+ let mut values = vec![1, 2, 3, 4, 5];
{
let slice = &mut values[.. 2];
assert!(slice == [1, 2]);
#[test]
fn test_split_at_mut() {
- let mut values = vec![1u8,2,3,4,5];
+ let mut values = vec![1, 2, 3, 4, 5];
{
let (left, right) = values.split_at_mut(2);
{
}
}
- assert!(values == vec![2u8, 3, 5, 6, 7]);
+ assert!(values == vec![2, 3, 5, 6, 7]);
}
#[test]
fn test_clone() {
- let v: Vec<int> = vec!();
+ let v: Vec<i32> = vec![];
let w = vec!(1, 2, 3);
assert_eq!(v, v.clone());
#[test]
fn test_retain() {
- let mut vec = vec![1u, 2, 3, 4];
+ let mut vec = vec![1, 2, 3, 4];
vec.retain(|&x| x % 2 == 0);
- assert!(vec == vec![2u, 4]);
+ assert!(vec == vec![2, 4]);
}
#[test]
#[test]
fn test_partition() {
- assert_eq!(vec![].into_iter().partition(|x: &int| *x < 3), (vec![], vec![]));
- assert_eq!(vec![1, 2, 3].into_iter().partition(|x: &int| *x < 4), (vec![1, 2, 3], vec![]));
- assert_eq!(vec![1, 2, 3].into_iter().partition(|x: &int| *x < 2), (vec![1], vec![2, 3]));
- assert_eq!(vec![1, 2, 3].into_iter().partition(|x: &int| *x < 0), (vec![], vec![1, 2, 3]));
+ assert_eq!(vec![].into_iter().partition(|x: &i32| *x < 3), (vec![], vec![]));
+ assert_eq!(vec![1, 2, 3].into_iter().partition(|x| *x < 4), (vec![1, 2, 3], vec![]));
+ assert_eq!(vec![1, 2, 3].into_iter().partition(|x| *x < 2), (vec![1], vec![2, 3]));
+ assert_eq!(vec![1, 2, 3].into_iter().partition(|x| *x < 0), (vec![], vec![1, 2, 3]));
}
#[test]
// Test on-stack copy-from-buf.
let a = [1, 2, 3];
let ptr = a.as_ptr();
- let b = Vec::from_raw_buf(ptr, 3u);
+ let b = Vec::from_raw_buf(ptr, 3);
assert_eq!(b, vec![1, 2, 3]);
// Test on-heap copy-from-buf.
let c = vec![1, 2, 3, 4, 5];
let ptr = c.as_ptr();
- let d = Vec::from_raw_buf(ptr, 5u);
+ let d = Vec::from_raw_buf(ptr, 5);
assert_eq!(d, vec![1, 2, 3, 4, 5]);
}
}
#[test]
fn test_vec_truncate_drop() {
- static mut drops: uint = 0;
- struct Elem(int);
+ static mut drops: u32 = 0;
+ struct Elem(i32);
impl Drop for Elem {
fn drop(&mut self) {
unsafe { drops += 1; }
#[test]
#[should_fail]
fn test_vec_truncate_fail() {
- struct BadElem(int);
+ struct BadElem(i32);
impl Drop for BadElem {
fn drop(&mut self) {
let BadElem(ref mut x) = *self;
#[test]
fn test_index() {
- let vec = vec!(1, 2, 3);
+ let vec = vec![1, 2, 3];
assert!(vec[1] == 2);
}
#[test]
#[should_fail]
fn test_index_out_of_bounds() {
- let vec = vec!(1, 2, 3);
+ let vec = vec![1, 2, 3];
let _ = vec[3];
}
#[test]
#[should_fail]
fn test_slice_out_of_bounds_1() {
- let x: Vec<int> = vec![1, 2, 3, 4, 5];
+ let x = vec![1, 2, 3, 4, 5];
&x[-1..];
}
#[test]
#[should_fail]
fn test_slice_out_of_bounds_2() {
- let x: Vec<int> = vec![1, 2, 3, 4, 5];
+ let x = vec![1, 2, 3, 4, 5];
&x[..6];
}
#[test]
#[should_fail]
fn test_slice_out_of_bounds_3() {
- let x: Vec<int> = vec![1, 2, 3, 4, 5];
+ let x = vec![1, 2, 3, 4, 5];
&x[-1..4];
}
#[test]
#[should_fail]
fn test_slice_out_of_bounds_4() {
- let x: Vec<int> = vec![1, 2, 3, 4, 5];
+ let x = vec![1, 2, 3, 4, 5];
&x[1..6];
}
#[test]
#[should_fail]
fn test_slice_out_of_bounds_5() {
- let x: Vec<int> = vec![1, 2, 3, 4, 5];
+ let x = vec![1, 2, 3, 4, 5];
&x[3..2];
}
#[test]
#[should_fail]
fn test_swap_remove_empty() {
- let mut vec: Vec<uint> = vec!();
+ let mut vec= Vec::<i32>::new();
vec.swap_remove(0);
}
#[test]
fn test_move_iter_unwrap() {
- let mut vec: Vec<uint> = Vec::with_capacity(7);
+ let mut vec = Vec::with_capacity(7);
vec.push(1);
vec.push(2);
let ptr = vec.as_ptr();
#[test]
#[should_fail]
fn test_map_in_place_incompatible_types_fail() {
- let v = vec![0u, 1, 2];
+ let v = vec![0, 1, 2];
v.map_in_place(|_| ());
}
#[test]
fn test_map_in_place() {
- let v = vec![0u, 1, 2];
- assert_eq!(v.map_in_place(|i: uint| i as int - 1), [-1, 0, 1]);
+ let v = vec![0, 1, 2];
+ assert_eq!(v.map_in_place(|i: u32| i as i32 - 1), [-1, 0, 1]);
}
#[test]
DROP_COUNTER.fetch_add(1, Ordering::Relaxed);
}
}
- const NUM_ELEMENTS: uint = 2;
+ const NUM_ELEMENTS: usize = 2;
static DROP_COUNTER: AtomicUsize = ATOMIC_USIZE_INIT;
let v = repeat(Nothing).take(NUM_ELEMENTS).collect::<Vec<_>>();
#[test]
fn test_move_items() {
let vec = vec![1, 2, 3];
- let mut vec2 : Vec<i32> = vec![];
+ let mut vec2 = vec![];
for i in vec {
vec2.push(i);
}
#[test]
fn test_move_items_reverse() {
let vec = vec![1, 2, 3];
- let mut vec2 : Vec<i32> = vec![];
+ let mut vec2 = vec![];
for i in vec.into_iter().rev() {
vec2.push(i);
}
#[test]
fn test_move_items_zero_sized() {
let vec = vec![(), (), ()];
- let mut vec2 : Vec<()> = vec![];
+ let mut vec2 = vec![];
for i in vec {
vec2.push(i);
}
#[test]
fn test_drain_items() {
let mut vec = vec![1, 2, 3];
- let mut vec2: Vec<i32> = vec![];
+ let mut vec2 = vec![];
for i in vec.drain() {
vec2.push(i);
}
#[test]
fn test_drain_items_reverse() {
let mut vec = vec![1, 2, 3];
- let mut vec2: Vec<i32> = vec![];
+ let mut vec2 = vec![];
for i in vec.drain().rev() {
vec2.push(i);
}
assert_eq!(vec, []);
- assert_eq!(vec2, [ 3, 2, 1 ]);
+ assert_eq!(vec2, [3, 2, 1]);
}
#[test]
fn test_drain_items_zero_sized() {
let mut vec = vec![(), (), ()];
- let mut vec2: Vec<()> = vec![];
+ let mut vec2 = vec![];
for i in vec.drain() {
vec2.push(i);
}
#[test]
fn test_into_boxed_slice() {
- let xs = vec![1u, 2, 3];
+ let xs = vec![1, 2, 3];
let ys = xs.into_boxed_slice();
- assert_eq!(ys.as_slice(), [1u, 2, 3]);
+ assert_eq!(ys, [1, 2, 3]);
}
#[test]
#[bench]
fn bench_new(b: &mut Bencher) {
b.iter(|| {
- let v: Vec<uint> = Vec::new();
+ let v: Vec<u32> = Vec::new();
assert_eq!(v.len(), 0);
assert_eq!(v.capacity(), 0);
})
}
- fn do_bench_with_capacity(b: &mut Bencher, src_len: uint) {
+ fn do_bench_with_capacity(b: &mut Bencher, src_len: usize) {
b.bytes = src_len as u64;
b.iter(|| {
- let v: Vec<uint> = Vec::with_capacity(src_len);
+ let v: Vec<u32> = Vec::with_capacity(src_len);
assert_eq!(v.len(), 0);
assert_eq!(v.capacity(), src_len);
})
do_bench_with_capacity(b, 1000)
}
- fn do_bench_from_fn(b: &mut Bencher, src_len: uint) {
+ fn do_bench_from_fn(b: &mut Bencher, src_len: usize) {
b.bytes = src_len as u64;
b.iter(|| {
do_bench_from_fn(b, 1000)
}
- fn do_bench_from_elem(b: &mut Bencher, src_len: uint) {
+ fn do_bench_from_elem(b: &mut Bencher, src_len: usize) {
b.bytes = src_len as u64;
b.iter(|| {
- let dst: Vec<uint> = repeat(5).take(src_len).collect();
+ let dst: Vec<usize> = repeat(5).take(src_len).collect();
assert_eq!(dst.len(), src_len);
assert!(dst.iter().all(|x| *x == 5));
})
do_bench_from_elem(b, 1000)
}
- fn do_bench_from_slice(b: &mut Bencher, src_len: uint) {
- let src: Vec<uint> = FromIterator::from_iter(0..src_len);
+ fn do_bench_from_slice(b: &mut Bencher, src_len: usize) {
+ let src: Vec<_> = FromIterator::from_iter(0..src_len);
b.bytes = src_len as u64;
do_bench_from_slice(b, 1000)
}
- fn do_bench_from_iter(b: &mut Bencher, src_len: uint) {
- let src: Vec<uint> = FromIterator::from_iter(0..src_len);
+ fn do_bench_from_iter(b: &mut Bencher, src_len: usize) {
+ let src: Vec<_> = FromIterator::from_iter(0..src_len);
b.bytes = src_len as u64;
b.iter(|| {
- let dst: Vec<uint> = FromIterator::from_iter(src.clone().into_iter());
+ let dst: Vec<_> = FromIterator::from_iter(src.clone().into_iter());
assert_eq!(dst.len(), src_len);
assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
});
do_bench_from_iter(b, 1000)
}
- fn do_bench_extend(b: &mut Bencher, dst_len: uint, src_len: uint) {
- let dst: Vec<uint> = FromIterator::from_iter(0..dst_len);
- let src: Vec<uint> = FromIterator::from_iter(dst_len..dst_len + src_len);
+ fn do_bench_extend(b: &mut Bencher, dst_len: usize, src_len: usize) {
+ let dst: Vec<_> = FromIterator::from_iter(0..dst_len);
+ let src: Vec<_> = FromIterator::from_iter(dst_len..dst_len + src_len);
b.bytes = src_len as u64;
do_bench_extend(b, 1000, 1000)
}
- fn do_bench_push_all(b: &mut Bencher, dst_len: uint, src_len: uint) {
- let dst: Vec<uint> = FromIterator::from_iter(0..dst_len);
- let src: Vec<uint> = FromIterator::from_iter(dst_len..dst_len + src_len);
+ fn do_bench_push_all(b: &mut Bencher, dst_len: usize, src_len: usize) {
+ let dst: Vec<_> = FromIterator::from_iter(0..dst_len);
+ let src: Vec<_> = FromIterator::from_iter(dst_len..dst_len + src_len);
b.bytes = src_len as u64;
b.iter(|| {
let mut dst = dst.clone();
- dst.push_all(src.as_slice());
+ dst.push_all(&src);
assert_eq!(dst.len(), dst_len + src_len);
assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
});
do_bench_push_all(b, 1000, 1000)
}
- fn do_bench_push_all_move(b: &mut Bencher, dst_len: uint, src_len: uint) {
- let dst: Vec<uint> = FromIterator::from_iter(0u..dst_len);
- let src: Vec<uint> = FromIterator::from_iter(dst_len..dst_len + src_len);
+ fn do_bench_push_all_move(b: &mut Bencher, dst_len: usize, src_len: usize) {
+ let dst: Vec<_> = FromIterator::from_iter(0..dst_len);
+ let src: Vec<_> = FromIterator::from_iter(dst_len..dst_len + src_len);
b.bytes = src_len as u64;
do_bench_push_all_move(b, 1000, 1000)
}
- fn do_bench_clone(b: &mut Bencher, src_len: uint) {
- let src: Vec<uint> = FromIterator::from_iter(0..src_len);
+ fn do_bench_clone(b: &mut Bencher, src_len: usize) {
+ let src: Vec<usize> = FromIterator::from_iter(0..src_len);
b.bytes = src_len as u64;
do_bench_clone(b, 1000)
}
- fn do_bench_clone_from(b: &mut Bencher, times: uint, dst_len: uint, src_len: uint) {
- let dst: Vec<uint> = FromIterator::from_iter(0..src_len);
- let src: Vec<uint> = FromIterator::from_iter(dst_len..dst_len + src_len);
+ fn do_bench_clone_from(b: &mut Bencher, times: usize, dst_len: usize, src_len: usize) {
+ let dst: Vec<_> = FromIterator::from_iter(0..src_len);
+ let src: Vec<_> = FromIterator::from_iter(dst_len..dst_len + src_len);
b.bytes = (times * src_len) as u64;
projects / rust.git / blobdiff