use std::rand::Rng;
use test::{Bencher, black_box};
-pub fn insert_rand_n<M, I, R>(n: uint,
+pub fn insert_rand_n<M, I, R>(n: usize,
map: &mut M,
b: &mut Bencher,
mut insert: I,
mut remove: R) where
- I: FnMut(&mut M, uint),
- R: FnMut(&mut M, uint),
+ I: FnMut(&mut M, usize),
+ R: FnMut(&mut M, usize),
{
// setup
let mut rng = rand::weak_rng();
for _ in 0..n {
- insert(map, rng.gen::<uint>() % n);
+ insert(map, rng.gen::<usize>() % n);
}
// measure
b.iter(|| {
- let k = rng.gen::<uint>() % n;
+ let k = rng.gen::<usize>() % n;
insert(map, k);
remove(map, k);
});
black_box(map);
}
-pub fn insert_seq_n<M, I, R>(n: uint,
+pub fn insert_seq_n<M, I, R>(n: usize,
map: &mut M,
b: &mut Bencher,
mut insert: I,
mut remove: R) where
- I: FnMut(&mut M, uint),
- R: FnMut(&mut M, uint),
+ I: FnMut(&mut M, usize),
+ R: FnMut(&mut M, usize),
{
// setup
- for i in 0u..n {
+ for i in 0..n {
insert(map, i * 2);
}
black_box(map);
}
-pub fn find_rand_n<M, T, I, F>(n: uint,
+pub fn find_rand_n<M, T, I, F>(n: usize,
map: &mut M,
b: &mut Bencher,
mut insert: I,
mut find: F) where
- I: FnMut(&mut M, uint),
- F: FnMut(&M, uint) -> T,
+ I: FnMut(&mut M, usize),
+ F: FnMut(&M, usize) -> T,
{
// setup
let mut rng = rand::weak_rng();
- let mut keys = (0..n).map(|_| rng.gen::<uint>() % n)
- .collect::<Vec<_>>();
+ let mut keys: Vec<_> = (0..n).map(|_| rng.gen::<usize>() % n).collect();
for k in &keys {
insert(map, *k);
})
}
-pub fn find_seq_n<M, T, I, F>(n: uint,
+pub fn find_seq_n<M, T, I, F>(n: usize,
map: &mut M,
b: &mut Bencher,
mut insert: I,
mut find: F) where
- I: FnMut(&mut M, uint),
- F: FnMut(&M, uint) -> T,
+ I: FnMut(&mut M, usize),
+ F: FnMut(&M, usize) -> T,
{
// setup
- for i in 0u..n {
+ for i in 0..n {
insert(map, i);
}
//! ```
//! use std::cmp::Ordering;
//! use std::collections::BinaryHeap;
-//! use std::uint;
+//! use std::usize;
//!
//! #[derive(Copy, Eq, PartialEq)]
//! struct State {
-//! cost: uint,
-//! position: uint,
+//! cost: usize,
+//! position: usize,
//! }
//!
//! // The priority queue depends on `Ord`.
//! }
//! }
//!
-//! // Each node is represented as an `uint`, for a shorter implementation.
+//! // Each node is represented as an `usize`, for a shorter implementation.
//! struct Edge {
-//! node: uint,
-//! cost: uint,
+//! node: usize,
+//! cost: usize,
//! }
//!
//! // Dijkstra's shortest path algorithm.
//!
//! // Start at `start` and use `dist` to track the current shortest distance
//! // to each node. This implementation isn't memory-efficient as it may leave duplicate
-//! // nodes in the queue. It also uses `uint::MAX` as a sentinel value,
+//! // nodes in the queue. It also uses `usize::MAX` as a sentinel value,
//! // for a simpler implementation.
-//! fn shortest_path(adj_list: &Vec<Vec<Edge>>, start: uint, goal: uint) -> uint {
+//! fn shortest_path(adj_list: &Vec<Vec<Edge>>, start: usize, goal: usize) -> usize {
//! // dist[node] = current shortest distance from `start` to `node`
-//! let mut dist: Vec<_> = (0..adj_list.len()).map(|_| uint::MAX).collect();
+//! let mut dist: Vec<_> = (0..adj_list.len()).map(|_| usize::MAX).collect();
//!
//! let mut heap = BinaryHeap::new();
//!
//! }
//!
//! // Goal not reachable
-//! uint::MAX
+//! usize::MAX
//! }
//!
//! fn main() {
//! assert_eq!(shortest_path(&graph, 0, 3), 3);
//! assert_eq!(shortest_path(&graph, 3, 0), 7);
//! assert_eq!(shortest_path(&graph, 0, 4), 5);
-//! assert_eq!(shortest_path(&graph, 4, 0), uint::MAX);
+//! assert_eq!(shortest_path(&graph, 4, 0), usize::MAX);
//! }
//! ```
/// heap.push(4u);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn with_capacity(capacity: uint) -> BinaryHeap<T> {
+ pub fn with_capacity(capacity: usize) -> BinaryHeap<T> {
BinaryHeap { data: Vec::with_capacity(capacity) }
}
/// heap.push(4u);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn capacity(&self) -> uint { self.data.capacity() }
+ pub fn capacity(&self) -> usize { self.data.capacity() }
/// Reserves the minimum capacity for exactly `additional` more elements to be inserted in the
/// given `BinaryHeap`. Does nothing if the capacity is already sufficient.
///
/// # Panics
///
- /// Panics if the new capacity overflows `uint`.
+ /// Panics if the new capacity overflows `usize`.
///
/// # Examples
///
/// heap.push(4u);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn reserve_exact(&mut self, additional: uint) {
+ pub fn reserve_exact(&mut self, additional: usize) {
self.data.reserve_exact(additional);
}
///
/// # Panics
///
- /// Panics if the new capacity overflows `uint`.
+ /// Panics if the new capacity overflows `usize`.
///
/// # Examples
///
/// heap.push(4u);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn reserve(&mut self, additional: uint) {
+ pub fn reserve(&mut self, additional: usize) {
self.data.reserve(additional);
}
// zeroed element), shift along the others and move it back into the
// vector over the junk element. This reduces the constant factor
// compared to using swaps, which involves twice as many moves.
- fn sift_up(&mut self, start: uint, mut pos: uint) {
+ fn sift_up(&mut self, start: usize, mut pos: usize) {
unsafe {
let new = replace(&mut self.data[pos], zeroed());
}
}
- fn sift_down_range(&mut self, mut pos: uint, end: uint) {
+ fn sift_down_range(&mut self, mut pos: usize, end: usize) {
unsafe {
let start = pos;
let new = replace(&mut self.data[pos], zeroed());
}
}
- fn sift_down(&mut self, pos: uint) {
+ fn sift_down(&mut self, pos: usize) {
let len = self.len();
self.sift_down_range(pos, len);
}
/// Returns the length of the binary heap.
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn len(&self) -> uint { self.data.len() }
+ pub fn len(&self) -> usize { self.data.len() }
/// Checks if the binary heap is empty.
#[stable(feature = "rust1", since = "1.0.0")]
fn next(&mut self) -> Option<&'a T> { self.iter.next() }
#[inline]
- fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
+ fn size_hint(&self) -> (usize, Option<usize>) { self.iter.size_hint() }
}
#[stable(feature = "rust1", since = "1.0.0")]
fn next(&mut self) -> Option<T> { self.iter.next() }
#[inline]
- fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
+ fn size_hint(&self) -> (usize, Option<usize>) { self.iter.size_hint() }
}
#[stable(feature = "rust1", since = "1.0.0")]
fn next(&mut self) -> Option<T> { self.iter.next() }
#[inline]
- fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
+ fn size_hint(&self) -> (usize, Option<usize>) { self.iter.size_hint() }
}
#[stable(feature = "rust1", since = "1.0.0")]
#[test]
fn test_iterator() {
- let data = vec!(5, 9, 3);
+ let data = vec![5, 9, 3];
let iterout = [9, 5, 3];
let heap = BinaryHeap::from_vec(data);
let mut i = 0;
#[test]
fn test_iterator_reverse() {
- let data = vec!(5, 9, 3);
- let iterout = vec!(3, 5, 9);
+ let data = vec![5, 9, 3];
+ let iterout = vec![3, 5, 9];
let pq = BinaryHeap::from_vec(data);
- let v: Vec<int> = pq.iter().rev().map(|&x| x).collect();
+ let v: Vec<_> = pq.iter().rev().map(|&x| x).collect();
assert_eq!(v, iterout);
}
#[test]
fn test_move_iter() {
- let data = vec!(5, 9, 3);
- let iterout = vec!(9, 5, 3);
+ let data = vec![5, 9, 3];
+ let iterout = vec![9, 5, 3];
let pq = BinaryHeap::from_vec(data);
- let v: Vec<int> = pq.into_iter().collect();
+ let v: Vec<_> = pq.into_iter().collect();
assert_eq!(v, iterout);
}
#[test]
fn test_move_iter_size_hint() {
- let data = vec!(5, 9);
+ let data = vec![5, 9];
let pq = BinaryHeap::from_vec(data);
let mut it = pq.into_iter();
#[test]
fn test_move_iter_reverse() {
- let data = vec!(5, 9, 3);
- let iterout = vec!(3, 5, 9);
+ let data = vec![5, 9, 3];
+ let iterout = vec![3, 5, 9];
let pq = BinaryHeap::from_vec(data);
- let v: Vec<int> = pq.into_iter().rev().collect();
+ let v: Vec<_> = pq.into_iter().rev().collect();
assert_eq!(v, iterout);
}
#[test]
fn test_peek_and_pop() {
- let data = vec!(2u, 4, 6, 2, 1, 8, 10, 3, 5, 7, 0, 9, 1);
+ let data = vec![2, 4, 6, 2, 1, 8, 10, 3, 5, 7, 0, 9, 1];
let mut sorted = data.clone();
sorted.sort();
let mut heap = BinaryHeap::from_vec(data);
#[test]
fn test_push() {
- let mut heap = BinaryHeap::from_vec(vec!(2, 4, 9));
+ let mut heap = BinaryHeap::from_vec(vec![2, 4, 9]);
assert_eq!(heap.len(), 3);
assert!(*heap.peek().unwrap() == 9);
heap.push(11);
#[test]
fn test_push_unique() {
- let mut heap = BinaryHeap::from_vec(vec!(box 2, box 4, box 9));
+ let mut heap = BinaryHeap::from_vec(vec![box 2, box 4, box 9]);
assert_eq!(heap.len(), 3);
assert!(*heap.peek().unwrap() == box 9);
heap.push(box 11);
#[test]
fn test_push_pop() {
- let mut heap = BinaryHeap::from_vec(vec!(5, 5, 2, 1, 3));
+ let mut heap = BinaryHeap::from_vec(vec![5, 5, 2, 1, 3]);
assert_eq!(heap.len(), 5);
assert_eq!(heap.push_pop(6), 6);
assert_eq!(heap.len(), 5);
#[test]
fn test_replace() {
- let mut heap = BinaryHeap::from_vec(vec!(5, 5, 2, 1, 3));
+ let mut heap = BinaryHeap::from_vec(vec![5, 5, 2, 1, 3]);
assert_eq!(heap.len(), 5);
assert_eq!(heap.replace(6).unwrap(), 5);
assert_eq!(heap.len(), 5);
assert_eq!(heap.len(), 5);
}
- fn check_to_vec(mut data: Vec<int>) {
+ fn check_to_vec(mut data: Vec<i32>) {
let heap = BinaryHeap::from_vec(data.clone());
let mut v = heap.clone().into_vec();
v.sort();
#[test]
fn test_to_vec() {
- check_to_vec(vec!());
- check_to_vec(vec!(5));
- check_to_vec(vec!(3, 2));
- check_to_vec(vec!(2, 3));
- check_to_vec(vec!(5, 1, 2));
- check_to_vec(vec!(1, 100, 2, 3));
- check_to_vec(vec!(1, 3, 5, 7, 9, 2, 4, 6, 8, 0));
- check_to_vec(vec!(2, 4, 6, 2, 1, 8, 10, 3, 5, 7, 0, 9, 1));
- check_to_vec(vec!(9, 11, 9, 9, 9, 9, 11, 2, 3, 4, 11, 9, 0, 0, 0, 0));
- check_to_vec(vec!(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
- check_to_vec(vec!(10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0));
- check_to_vec(vec!(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 1, 2));
- check_to_vec(vec!(5, 4, 3, 2, 1, 5, 4, 3, 2, 1, 5, 4, 3, 2, 1));
+ check_to_vec(vec![]);
+ check_to_vec(vec![5]);
+ check_to_vec(vec![3, 2]);
+ check_to_vec(vec![2, 3]);
+ check_to_vec(vec![5, 1, 2]);
+ check_to_vec(vec![1, 100, 2, 3]);
+ check_to_vec(vec![1, 3, 5, 7, 9, 2, 4, 6, 8, 0]);
+ check_to_vec(vec![2, 4, 6, 2, 1, 8, 10, 3, 5, 7, 0, 9, 1]);
+ check_to_vec(vec![9, 11, 9, 9, 9, 9, 11, 2, 3, 4, 11, 9, 0, 0, 0, 0]);
+ check_to_vec(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+ check_to_vec(vec![10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]);
+ check_to_vec(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 1, 2]);
+ check_to_vec(vec![5, 4, 3, 2, 1, 5, 4, 3, 2, 1, 5, 4, 3, 2, 1]);
}
#[test]
fn test_empty_pop() {
- let mut heap = BinaryHeap::<int>::new();
+ let mut heap = BinaryHeap::<i32>::new();
assert!(heap.pop().is_none());
}
#[test]
fn test_empty_peek() {
- let empty = BinaryHeap::<int>::new();
+ let empty = BinaryHeap::<i32>::new();
assert!(empty.peek().is_none());
}
#[test]
fn test_empty_replace() {
- let mut heap = BinaryHeap::<int>::new();
+ let mut heap = BinaryHeap::new();
assert!(heap.replace(5).is_none());
}
#[test]
fn test_from_iter() {
- let xs = vec!(9u, 8, 7, 6, 5, 4, 3, 2, 1);
+ let xs = vec![9, 8, 7, 6, 5, 4, 3, 2, 1];
- let mut q: BinaryHeap<uint> = xs.iter().rev().map(|&x| x).collect();
+ let mut q: BinaryHeap<_> = xs.iter().rev().cloned().collect();
for &x in &xs {
assert_eq!(q.pop().unwrap(), x);
#[test]
fn test_drain() {
- let mut q: BinaryHeap<_> =
- [9u, 8, 7, 6, 5, 4, 3, 2, 1].iter().cloned().collect();
+ let mut q: BinaryHeap<_> = [9, 8, 7, 6, 5, 4, 3, 2, 1].iter().cloned().collect();
assert_eq!(q.drain().take(5).count(), 5);
// rather `or` and `and`.
// (1) Be careful, most things can overflow here because the amount of bits in
-// memory can overflow `uint`.
+// memory can overflow `usize`.
// (2) Make sure that the underlying vector has no excess length:
// E. g. `nbits == 16`, `storage.len() == 2` would be excess length,
// because the last word isn't used at all. This is important because some
//! bv.set(0, false);
//! bv.set(1, false);
//!
-//! for i in iter::range_inclusive(2, (max_prime as f64).sqrt() as uint) {
+//! for i in iter::range_inclusive(2, (max_prime as f64).sqrt() as usize) {
//! // if i is a prime
//! if bv[i] {
//! // Mark all multiples of i as non-prime (any multiples below i * i
//! };
//!
//! // Simple primality tests below our max bound
-//! let print_primes = 20u;
+//! let print_primes = 20;
//! print!("The primes below {} are: ", print_primes);
//! for x in 0..print_primes {
//! if primes.contains(&x) {
use core::num::Int;
use core::ops::Index;
use core::slice;
-use core::{u8, u32, uint};
+use core::{u8, u32, usize};
use bitv_set; //so meta
use Vec;
/// Internal representation of the bit vector
storage: Vec<u32>,
/// The number of valid bits in the internal representation
- nbits: uint
+ nbits: usize
}
// FIXME(Gankro): NopeNopeNopeNopeNope (wait for IndexGet to be a thing)
-impl Index<uint> for Bitv {
+impl Index<usize> for Bitv {
type Output = bool;
#[inline]
- fn index(&self, i: &uint) -> &bool {
+ fn index(&self, i: &usize) -> &bool {
if self.get(*i).expect("index out of bounds") {
&TRUE
} else {
}
/// Computes how many blocks are needed to store that many bits
-fn blocks_for_bits(bits: uint) -> uint {
+fn blocks_for_bits(bits: usize) -> usize {
// If we want 17 bits, dividing by 32 will produce 0. So we add 1 to make sure we
// reserve enough. But if we want exactly a multiple of 32, this will actually allocate
// one too many. So we need to check if that's the case. We can do that by computing if
// superior modulo operator on a power of two to this.
//
// Note that we can technically avoid this branch with the expression
- // `(nbits + u32::BITS - 1) / 32::BITS`, but if nbits is almost uint::MAX this will overflow.
+ // `(nbits + u32::BITS - 1) / 32::BITS`, but if nbits is almost usize::MAX this will overflow.
if bits % u32::BITS == 0 {
bits / u32::BITS
} else {
}
/// Computes the bitmask for the final word of the vector
-fn mask_for_bits(bits: uint) -> u32 {
+fn mask_for_bits(bits: usize) -> u32 {
// Note especially that a perfect multiple of u32::BITS should mask all 1s.
!0u32 >> (u32::BITS - bits % u32::BITS) % u32::BITS
}
/// assert_eq!(x, false);
/// }
/// ```
- pub fn from_elem(nbits: uint, bit: bool) -> Bitv {
+ pub fn from_elem(nbits: usize, bit: bool) -> Bitv {
let nblocks = blocks_for_bits(nbits);
let mut bitv = Bitv {
storage: repeat(if bit { !0u32 } else { 0u32 }).take(nblocks).collect(),
/// It is important to note that this function does not specify the
/// *length* of the returned bitvector, but only the *capacity*.
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn with_capacity(nbits: uint) -> Bitv {
+ pub fn with_capacity(nbits: usize) -> Bitv {
Bitv {
storage: Vec::with_capacity(blocks_for_bits(nbits)),
nbits: 0,
/// let bv = Bitv::from_fn(5, |i| { i % 2 == 0 });
/// assert!(bv.eq_vec(&[true, false, true, false, true]));
/// ```
- pub fn from_fn<F>(len: uint, mut f: F) -> Bitv where F: FnMut(uint) -> bool {
+ pub fn from_fn<F>(len: usize, mut f: F) -> Bitv where F: FnMut(usize) -> bool {
let mut bitv = Bitv::from_elem(len, false);
for i in 0u..len {
bitv.set(i, f(i));
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn get(&self, i: uint) -> Option<bool> {
+ pub fn get(&self, i: usize) -> Option<bool> {
if i >= self.nbits {
return None;
}
#[inline]
#[unstable(feature = "collections",
reason = "panic semantics are likely to change in the future")]
- pub fn set(&mut self, i: uint, x: bool) {
+ pub fn set(&mut self, i: usize, x: bool) {
assert!(i < self.nbits);
let w = i / u32::BITS;
let b = i % u32::BITS;
/// assert_eq!(bv.to_bytes(), vec!(0b00100000, 0b10000000));
/// ```
pub fn to_bytes(&self) -> Vec<u8> {
- fn bit(bitv: &Bitv, byte: uint, bit: uint) -> u8 {
+ fn bit(bitv: &Bitv, byte: usize, bit: usize) -> u8 {
let offset = byte * 8 + bit;
if offset >= bitv.nbits {
0
/// assert!(bv.eq_vec(&[false, true]));
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn truncate(&mut self, len: uint) {
+ pub fn truncate(&mut self, len: usize) {
if len < self.len() {
self.nbits = len;
// This fixes (2).
///
/// # Panics
///
- /// Panics if the new capacity overflows `uint`.
+ /// Panics if the new capacity overflows `usize`.
///
/// # Examples
///
/// assert!(bv.capacity() >= 13);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn reserve(&mut self, additional: uint) {
+ pub fn reserve(&mut self, additional: usize) {
let desired_cap = self.len().checked_add(additional).expect("capacity overflow");
let storage_len = self.storage.len();
if desired_cap > self.capacity() {
///
/// # Panics
///
- /// Panics if the new capacity overflows `uint`.
+ /// Panics if the new capacity overflows `usize`.
///
/// # Examples
///
/// assert!(bv.capacity() >= 13);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn reserve_exact(&mut self, additional: uint) {
+ pub fn reserve_exact(&mut self, additional: usize) {
let desired_cap = self.len().checked_add(additional).expect("capacity overflow");
let storage_len = self.storage.len();
if desired_cap > self.capacity() {
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn capacity(&self) -> uint {
- self.storage.capacity().checked_mul(u32::BITS).unwrap_or(uint::MAX)
+ pub fn capacity(&self) -> usize {
+ self.storage.capacity().checked_mul(u32::BITS).unwrap_or(usize::MAX)
}
/// Grows the `Bitv` in-place, adding `n` copies of `value` to the `Bitv`.
///
/// # Panics
///
- /// Panics if the new len overflows a `uint`.
+ /// Panics if the new len overflows a `usize`.
///
/// # Examples
///
/// assert_eq!(bv.len(), 10);
/// assert_eq!(bv.to_bytes(), vec!(0b01001011, 0b11000000));
/// ```
- pub fn grow(&mut self, n: uint, value: bool) {
+ pub fn grow(&mut self, n: usize, value: bool) {
// Note: we just bulk set all the bits in the last word in this fn in multiple places
// which is technically wrong if not all of these bits are to be used. However, at the end
// of this fn we call `fix_last_block` at the end of this fn, which should fix this.
/// Return the total number of bits in this vector
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn len(&self) -> uint { self.nbits }
+ pub fn len(&self) -> usize { self.nbits }
/// Returns true if there are no bits in this vector
#[inline]
#[derive(Clone)]
pub struct Iter<'a> {
bitv: &'a Bitv,
- next_idx: uint,
- end_idx: uint,
+ next_idx: usize,
+ end_idx: usize,
}
#[stable(feature = "rust1", since = "1.0.0")]
}
}
- fn size_hint(&self) -> (uint, Option<uint>) {
+ fn size_hint(&self) -> (usize, Option<usize>) {
let rem = self.end_idx - self.next_idx;
(rem, Some(rem))
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a> RandomAccessIterator for Iter<'a> {
#[inline]
- fn indexable(&self) -> uint {
+ fn indexable(&self) -> usize {
self.end_idx - self.next_idx
}
#[inline]
- fn idx(&mut self, index: uint) -> Option<bool> {
+ fn idx(&mut self, index: usize) -> Option<bool> {
if index >= self.indexable() {
None
} else {
///
/// It should also be noted that the amount of storage necessary for holding a
/// set of objects is proportional to the maximum of the objects when viewed
-/// as a `uint`.
+/// as a `usize`.
///
/// # Examples
///
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl FromIterator<uint> for BitvSet {
- fn from_iter<I:Iterator<Item=uint>>(iterator: I) -> BitvSet {
+impl FromIterator<usize> for BitvSet {
+ fn from_iter<I:Iterator<Item=usize>>(iterator: I) -> BitvSet {
let mut ret = BitvSet::new();
ret.extend(iterator);
ret
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl Extend<uint> for BitvSet {
+impl Extend<usize> for BitvSet {
#[inline]
- fn extend<I: Iterator<Item=uint>>(&mut self, iterator: I) {
+ fn extend<I: Iterator<Item=usize>>(&mut self, iterator: I) {
for i in iterator {
self.insert(i);
}
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn with_capacity(nbits: uint) -> BitvSet {
+ pub fn with_capacity(nbits: usize) -> BitvSet {
let bitv = Bitv::from_elem(nbits, false);
BitvSet::from_bitv(bitv)
}
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn capacity(&self) -> uint {
+ pub fn capacity(&self) -> usize {
self.bitv.capacity()
}
/// assert!(s.capacity() >= 10);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn reserve_len(&mut self, len: uint) {
+ pub fn reserve_len(&mut self, len: usize) {
let cur_len = self.bitv.len();
if len >= cur_len {
self.bitv.reserve(len - cur_len);
/// assert!(s.capacity() >= 10);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn reserve_len_exact(&mut self, len: uint) {
+ pub fn reserve_len_exact(&mut self, len: usize) {
let cur_len = self.bitv.len();
if len >= cur_len {
self.bitv.reserve_exact(len - cur_len);
})
}
- /// Iterator over each uint stored in `self` intersect `other`.
+ /// Iterator over each usize stored in `self` intersect `other`.
/// See [intersect_with](#method.intersect_with) for an efficient in-place version.
///
/// # Examples
}.take(min))
}
- /// Iterator over each uint stored in the `self` setminus `other`.
+ /// Iterator over each usize stored in the `self` setminus `other`.
/// See [difference_with](#method.difference_with) for an efficient in-place version.
///
/// # Examples
/// Return the number of set bits in this set.
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn len(&self) -> uint {
+ pub fn len(&self) -> usize {
self.bitv.blocks().fold(0, |acc, n| acc + n.count_ones())
}
/// Returns `true` if this set contains the specified integer.
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn contains(&self, value: &uint) -> bool {
+ pub fn contains(&self, value: &usize) -> bool {
let bitv = &self.bitv;
*value < bitv.nbits && bitv[*value]
}
/// Adds a value to the set. Returns `true` if the value was not already
/// present in the set.
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn insert(&mut self, value: uint) -> bool {
+ pub fn insert(&mut self, value: usize) -> bool {
if self.contains(&value) {
return false;
}
/// Removes a value from the set. Returns `true` if the value was
/// present in the set.
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn remove(&mut self, value: &uint) -> bool {
+ pub fn remove(&mut self, value: &usize) -> bool {
if !self.contains(value) {
return false;
}
#[stable(feature = "rust1", since = "1.0.0")]
pub struct SetIter<'a> {
set: &'a BitvSet,
- next_idx: uint
+ next_idx: usize
}
/// An iterator combining two `BitvSet` iterators.
other: &'a BitvSet,
merge: fn(u32, u32) -> u32,
current_word: u32,
- next_idx: uint
+ next_idx: usize
}
#[stable(feature = "rust1", since = "1.0.0")]
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a> Iterator for SetIter<'a> {
- type Item = uint;
+ type Item = usize;
- fn next(&mut self) -> Option<uint> {
+ fn next(&mut self) -> Option<usize> {
while self.next_idx < self.set.bitv.len() {
let idx = self.next_idx;
self.next_idx += 1;
}
#[inline]
- fn size_hint(&self) -> (uint, Option<uint>) {
+ fn size_hint(&self) -> (usize, Option<usize>) {
(0, Some(self.set.bitv.len() - self.next_idx))
}
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a> Iterator for TwoBitPositions<'a> {
- type Item = uint;
+ type Item = usize;
- fn next(&mut self) -> Option<uint> {
+ fn next(&mut self) -> Option<usize> {
while self.next_idx < self.set.bitv.len() ||
self.next_idx < self.other.bitv.len() {
let bit_idx = self.next_idx % u32::BITS;
}
#[inline]
- fn size_hint(&self) -> (uint, Option<uint>) {
+ fn size_hint(&self) -> (usize, Option<usize>) {
let cap = cmp::max(self.set.bitv.len(), self.other.bitv.len());
(0, Some(cap - self.next_idx))
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a> Iterator for Union<'a> {
- type Item = uint;
+ type Item = usize;
- #[inline] fn next(&mut self) -> Option<uint> { self.0.next() }
- #[inline] fn size_hint(&self) -> (uint, Option<uint>) { self.0.size_hint() }
+ #[inline] fn next(&mut self) -> Option<usize> { self.0.next() }
+ #[inline] fn size_hint(&self) -> (usize, Option<usize>) { self.0.size_hint() }
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a> Iterator for Intersection<'a> {
- type Item = uint;
+ type Item = usize;
- #[inline] fn next(&mut self) -> Option<uint> { self.0.next() }
- #[inline] fn size_hint(&self) -> (uint, Option<uint>) { self.0.size_hint() }
+ #[inline] fn next(&mut self) -> Option<usize> { self.0.next() }
+ #[inline] fn size_hint(&self) -> (usize, Option<usize>) { self.0.size_hint() }
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a> Iterator for Difference<'a> {
- type Item = uint;
+ type Item = usize;
- #[inline] fn next(&mut self) -> Option<uint> { self.0.next() }
- #[inline] fn size_hint(&self) -> (uint, Option<uint>) { self.0.size_hint() }
+ #[inline] fn next(&mut self) -> Option<usize> { self.0.next() }
+ #[inline] fn size_hint(&self) -> (usize, Option<usize>) { self.0.size_hint() }
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a> Iterator for SymmetricDifference<'a> {
- type Item = uint;
+ type Item = usize;
- #[inline] fn next(&mut self) -> Option<uint> { self.0.next() }
- #[inline] fn size_hint(&self) -> (uint, Option<uint>) { self.0.size_hint() }
+ #[inline] fn next(&mut self) -> Option<usize> { self.0.next() }
+ #[inline] fn size_hint(&self) -> (usize, Option<usize>) { self.0.size_hint() }
}
impl<'a> IntoIterator for &'a BitvSet {
#[test]
fn test_to_bools() {
- let bools = vec!(false, false, true, false, false, true, true, false);
+ let bools = vec![false, false, true, false, false, true, true, false];
assert_eq!(Bitv::from_bytes(&[0b00100110]).iter().collect::<Vec<bool>>(), bools);
}
assert_eq!(bitv.iter().collect::<Vec<bool>>(), bools);
- let long = (0i32..10000).map(|i| i % 2 == 0).collect::<Vec<_>>();
+ let long: Vec<_> = (0i32..10000).map(|i| i % 2 == 0).collect();
let bitv: Bitv = long.iter().map(|n| *n).collect();
assert_eq!(bitv.iter().collect::<Vec<bool>>(), long)
}
use super::Bitv;
- static BENCH_BITS : uint = 1 << 14;
+ static BENCH_BITS : usize = 1 << 14;
fn rng() -> rand::IsaacRng {
let seed: &[_] = &[1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
}
#[bench]
- fn bench_uint_small(b: &mut Bencher) {
+ fn bench_usize_small(b: &mut Bencher) {
let mut r = rng();
- let mut bitv = 0 as uint;
+ let mut bitv = 0 as usize;
b.iter(|| {
for _ in 0u..100 {
- bitv |= 1 << ((r.next_u32() as uint) % u32::BITS);
+ bitv |= 1 << ((r.next_u32() as usize) % u32::BITS);
}
black_box(&bitv);
});
let mut bitv = Bitv::from_elem(BENCH_BITS, false);
b.iter(|| {
for _ in 0u..100 {
- bitv.set((r.next_u32() as uint) % BENCH_BITS, true);
+ bitv.set((r.next_u32() as usize) % BENCH_BITS, true);
}
black_box(&bitv);
});
let mut bitv = Bitv::from_elem(BENCH_BITS, false);
b.iter(|| {
for _ in 0u..100 {
- bitv.set((r.next_u32() as uint) % BENCH_BITS, r.gen());
+ bitv.set((r.next_u32() as usize) % BENCH_BITS, r.gen());
}
black_box(&bitv);
});
let mut bitv = Bitv::from_elem(u32::BITS, false);
b.iter(|| {
for _ in 0u..100 {
- bitv.set((r.next_u32() as uint) % u32::BITS, true);
+ bitv.set((r.next_u32() as usize) % u32::BITS, true);
}
black_box(&bitv);
});
let mut sum = 0u;
for _ in 0u..10 {
for pres in &bitv {
- sum += pres as uint;
+ sum += pres as usize;
}
}
sum
b.iter(|| {
let mut sum = 0u;
for pres in &bitv {
- sum += pres as uint;
+ sum += pres as usize;
}
sum
})
}
#[test]
- fn test_bitv_set_from_uints() {
- let uints = vec![0, 2, 2, 3];
- let a: BitvSet = uints.into_iter().collect();
+ fn test_bitv_set_from_usizes() {
+ let usizes = vec![0, 2, 2, 3];
+ let a: BitvSet = usizes.into_iter().collect();
let mut b = BitvSet::new();
b.insert(0);
b.insert(2);
#[test]
fn test_bitv_set_iterator() {
- let uints = vec![0, 2, 2, 3];
- let bitv: BitvSet = uints.into_iter().collect();
+ let usizes = vec![0, 2, 2, 3];
+ let bitv: BitvSet = usizes.into_iter().collect();
- let idxs: Vec<uint> = bitv.iter().collect();
+ let idxs: Vec<_> = bitv.iter().collect();
assert_eq!(idxs, vec![0, 2, 3]);
let long: BitvSet = (0u..10000).filter(|&n| n % 2 == 0).collect();
- let real = range_step(0, 10000, 2).collect::<Vec<uint>>();
+ let real: Vec<_> = range_step(0, 10000, 2).collect();
- let idxs: Vec<uint> = long.iter().collect();
+ let idxs: Vec<_> = long.iter().collect();
assert_eq!(idxs, real);
}
assert!(b.insert(3));
let expected = [3, 5, 11, 77];
- let actual = a.intersection(&b).collect::<Vec<uint>>();
+ let actual: Vec<_> = a.intersection(&b).collect();
assert_eq!(actual, expected);
}
assert!(b.insert(200));
let expected = [1, 5, 500];
- let actual = a.difference(&b).collect::<Vec<uint>>();
+ let actual: Vec<_> = a.difference(&b).collect();
assert_eq!(actual, expected);
}
assert!(b.insert(220));
let expected = [1, 5, 11, 14, 220];
- let actual = a.symmetric_difference(&b).collect::<Vec<uint>>();
+ let actual: Vec<_> = a.symmetric_difference(&b).collect();
assert_eq!(actual, expected);
}
assert!(b.insert(19));
let expected = [1, 3, 5, 9, 11, 13, 19, 24, 160, 200];
- let actual = a.union(&b).collect::<Vec<uint>>();
+ let actual: Vec<_> = a.union(&b).collect();
assert_eq!(actual, expected);
}
use super::{Bitv, BitvSet};
- static BENCH_BITS : uint = 1 << 14;
+ static BENCH_BITS : usize = 1 << 14;
fn rng() -> rand::IsaacRng {
let seed: &[_] = &[1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
let mut r = rng();
let mut bitv = BitvSet::new();
b.iter(|| {
- for _ in 0u..100 {
- bitv.insert((r.next_u32() as uint) % u32::BITS);
+ for _ in 0..100 {
+ bitv.insert((r.next_u32() as usize) % u32::BITS);
}
black_box(&bitv);
});
let mut r = rng();
let mut bitv = BitvSet::new();
b.iter(|| {
- for _ in 0u..100 {
- bitv.insert((r.next_u32() as uint) % BENCH_BITS);
+ for _ in 0..100 {
+ bitv.insert((r.next_u32() as usize) % BENCH_BITS);
}
black_box(&bitv);
});
let bitv = BitvSet::from_bitv(Bitv::from_fn(BENCH_BITS,
|idx| {idx % 3 == 0}));
b.iter(|| {
- let mut sum = 0u;
+ let mut sum = 0;
for idx in &bitv {
- sum += idx as uint;
+ sum += idx as usize;
}
sum
})
/// would like to further explore choosing the optimal search strategy based on the choice of B,
/// and possibly other factors. Using linear search, searching for a random element is expected
/// to take O(B log<sub>B</sub>n) comparisons, which is generally worse than a BST. In practice,
-/// however, performance is excellent. `BTreeMap` is able to readily outperform `TreeMap` under
-/// many workloads, and is competitive where it doesn't. BTreeMap also generally *scales* better
-/// than TreeMap, making it more appropriate for large datasets.
-///
-/// However, `TreeMap` may still be more appropriate to use in many contexts. If elements are very
-/// large or expensive to compare, `TreeMap` may be more appropriate. It won't allocate any
-/// more space than is needed, and will perform the minimal number of comparisons necessary.
-/// `TreeMap` also provides much better performance stability guarantees. Generally, very few
-/// changes need to be made to update a BST, and two updates are expected to take about the same
-/// amount of time on roughly equal sized BSTs. However a B-Tree's performance is much more
-/// amortized. If a node is overfull, it must be split into two nodes. If a node is underfull, it
-/// may be merged with another. Both of these operations are relatively expensive to perform, and
-/// it's possible to force one to occur at every single level of the tree in a single insertion or
-/// deletion. In fact, a malicious or otherwise unlucky sequence of insertions and deletions can
-/// force this degenerate behaviour to occur on every operation. While the total amount of work
-/// done on each operation isn't *catastrophic*, and *is* still bounded by O(B log<sub>B</sub>n),
-/// it is certainly much slower when it does.
+/// however, performance is excellent.
#[derive(Clone)]
#[stable(feature = "rust1", since = "1.0.0")]
pub struct BTreeMap<K, V> {
root: Node<K, V>,
- length: uint,
- depth: uint,
- b: uint,
+ length: usize,
+ depth: usize,
+ b: usize,
}
/// An abstract base over-which all other BTree iterators are built.
struct AbsIter<T> {
traversals: RingBuf<T>,
- size: uint,
+ size: usize,
}
/// An iterator over a BTreeMap's entries.
/// Makes a new empty BTreeMap with the given B.
///
/// B cannot be less than 2.
- pub fn with_b(b: uint) -> BTreeMap<K, V> {
+ pub fn with_b(b: usize) -> BTreeMap<K, V> {
assert!(b > 1, "B must be greater than 1");
BTreeMap {
length: 0,
}
}
- fn size_hint(&self) -> (uint, Option<uint>) {
+ fn size_hint(&self) -> (usize, Option<usize>) {
(self.size, Some(self.size))
}
}
type Item = (&'a K, &'a V);
fn next(&mut self) -> Option<(&'a K, &'a V)> { self.inner.next() }
- fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
+ fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, K, V> DoubleEndedIterator for Iter<'a, K, V> {
type Item = (&'a K, &'a mut V);
fn next(&mut self) -> Option<(&'a K, &'a mut V)> { self.inner.next() }
- fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
+ fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, K, V> DoubleEndedIterator for IterMut<'a, K, V> {
type Item = (K, V);
fn next(&mut self) -> Option<(K, V)> { self.inner.next() }
- fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
+ fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<K, V> DoubleEndedIterator for IntoIter<K, V> {
type Item = &'a K;
fn next(&mut self) -> Option<(&'a K)> { self.inner.next() }
- fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
+ fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, K, V> DoubleEndedIterator for Keys<'a, K, V> {
type Item = &'a V;
fn next(&mut self) -> Option<(&'a V)> { self.inner.next() }
- fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
+ fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, K, V> DoubleEndedIterator for Values<'a, K, V> {
/// a.insert(1u, "a");
/// a.insert(2u, "b");
///
- /// let keys: Vec<uint> = a.keys().cloned().collect();
+ /// let keys: Vec<usize> = a.keys().cloned().collect();
/// assert_eq!(keys, vec![1u,2,]);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
/// assert_eq!(a.len(), 1);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn len(&self) -> uint { self.length }
+ pub fn len(&self) -> usize { self.length }
/// Return true if the map contains no elements.
///
/// use std::collections::BTreeMap;
/// use std::collections::btree_map::Entry;
///
- /// let mut count: BTreeMap<&str, uint> = BTreeMap::new();
+ /// let mut count: BTreeMap<&str, usize> = BTreeMap::new();
///
/// // count the number of occurrences of letters in the vec
/// for x in vec!["a","b","a","c","a","b"].iter() {
#[test]
fn test_basic_large() {
let mut map = BTreeMap::new();
- let size = 10000u;
+ let size = 10000;
assert_eq!(map.len(), 0);
for i in 0..size {
let mut map = BTreeMap::new();
assert_eq!(map.remove(&1), None);
assert_eq!(map.get(&1), None);
- assert_eq!(map.insert(1u, 1u), None);
+ assert_eq!(map.insert(1, 1), None);
assert_eq!(map.get(&1), Some(&1));
assert_eq!(map.insert(1, 2), Some(1));
assert_eq!(map.get(&1), Some(&2));
#[test]
fn test_iter() {
- let size = 10000u;
+ let size = 10000;
// Forwards
- let mut map: BTreeMap<uint, uint> = (0..size).map(|i| (i, i)).collect();
+ let mut map: BTreeMap<_, _> = (0..size).map(|i| (i, i)).collect();
- fn test<T>(size: uint, mut iter: T) where T: Iterator<Item=(uint, uint)> {
+ fn test<T>(size: usize, mut iter: T) where T: Iterator<Item=(usize, usize)> {
for i in 0..size {
assert_eq!(iter.size_hint(), (size - i, Some(size - i)));
assert_eq!(iter.next().unwrap(), (i, i));
#[test]
fn test_iter_rev() {
- let size = 10000u;
+ let size = 10000;
// Forwards
- let mut map: BTreeMap<uint, uint> = (0..size).map(|i| (i, i)).collect();
+ let mut map: BTreeMap<_, _> = (0..size).map(|i| (i, i)).collect();
- fn test<T>(size: uint, mut iter: T) where T: Iterator<Item=(uint, uint)> {
+ fn test<T>(size: usize, mut iter: T) where T: Iterator<Item=(usize, usize)> {
for i in 0..size {
assert_eq!(iter.size_hint(), (size - i, Some(size - i)));
assert_eq!(iter.next().unwrap(), (size - i - 1, size - i - 1));
#[test]
fn test_iter_mixed() {
- let size = 10000u;
+ let size = 10000;
// Forwards
- let mut map: BTreeMap<uint, uint> = (0..size).map(|i| (i, i)).collect();
+ let mut map: BTreeMap<_, _> = (0..size).map(|i| (i, i)).collect();
- fn test<T>(size: uint, mut iter: T)
- where T: Iterator<Item=(uint, uint)> + DoubleEndedIterator {
+ fn test<T>(size: usize, mut iter: T)
+ where T: Iterator<Item=(usize, usize)> + DoubleEndedIterator {
for i in 0..size / 4 {
assert_eq!(iter.size_hint(), (size - i * 2, Some(size - i * 2)));
assert_eq!(iter.next().unwrap(), (i, i));
#[test]
fn test_range_small() {
- let size = 5u;
+ let size = 5;
// Forwards
- let map: BTreeMap<uint, uint> = (0..size).map(|i| (i, i)).collect();
+ let map: BTreeMap<_, _> = (0..size).map(|i| (i, i)).collect();
- let mut j = 0u;
- for ((&k, &v), i) in map.range(Included(&2), Unbounded).zip(2u..size) {
+ let mut j = 0;
+ for ((&k, &v), i) in map.range(Included(&2), Unbounded).zip(2..size) {
assert_eq!(k, i);
assert_eq!(v, i);
j += 1;
#[test]
fn test_range_1000() {
- let size = 1000u;
- let map: BTreeMap<uint, uint> = (0..size).map(|i| (i, i)).collect();
+ let size = 1000;
+ let map: BTreeMap<_, _> = (0..size).map(|i| (i, i)).collect();
- fn test(map: &BTreeMap<uint, uint>, size: uint, min: Bound<&uint>, max: Bound<&uint>) {
+ fn test(map: &BTreeMap<u32, u32>, size: u32, min: Bound<&u32>, max: Bound<&u32>) {
let mut kvs = map.range(min, max).map(|(&k, &v)| (k, v));
let mut pairs = (0..size).map(|i| (i, i));
#[test]
fn test_range() {
- let size = 200u;
- let map: BTreeMap<uint, uint> = (0..size).map(|i| (i, i)).collect();
+ let size = 200;
+ let map: BTreeMap<_, _> = (0..size).map(|i| (i, i)).collect();
for i in 0..size {
for j in i..size {
fn test_entry(){
let xs = [(1, 10), (2, 20), (3, 30), (4, 40), (5, 50), (6, 60)];
- let mut map: BTreeMap<int, int> = xs.iter().map(|&x| x).collect();
+ let mut map: BTreeMap<_, _> = xs.iter().map(|&x| x).collect();
// Existing key (insert)
match map.entry(1) {
#[bench]
pub fn insert_rand_100(b: &mut Bencher) {
- let mut m : BTreeMap<uint,uint> = BTreeMap::new();
+ let mut m = BTreeMap::new();
insert_rand_n(100, &mut m, b,
|m, i| { m.insert(i, 1); },
|m, i| { m.remove(&i); });
#[bench]
pub fn insert_rand_10_000(b: &mut Bencher) {
- let mut m : BTreeMap<uint,uint> = BTreeMap::new();
+ let mut m = BTreeMap::new();
insert_rand_n(10_000, &mut m, b,
|m, i| { m.insert(i, 1); },
|m, i| { m.remove(&i); });
// Insert seq
#[bench]
pub fn insert_seq_100(b: &mut Bencher) {
- let mut m : BTreeMap<uint,uint> = BTreeMap::new();
+ let mut m = BTreeMap::new();
insert_seq_n(100, &mut m, b,
|m, i| { m.insert(i, 1); },
|m, i| { m.remove(&i); });
#[bench]
pub fn insert_seq_10_000(b: &mut Bencher) {
- let mut m : BTreeMap<uint,uint> = BTreeMap::new();
+ let mut m = BTreeMap::new();
insert_seq_n(10_000, &mut m, b,
|m, i| { m.insert(i, 1); },
|m, i| { m.remove(&i); });
// Find rand
#[bench]
pub fn find_rand_100(b: &mut Bencher) {
- let mut m : BTreeMap<uint,uint> = BTreeMap::new();
+ let mut m = BTreeMap::new();
find_rand_n(100, &mut m, b,
|m, i| { m.insert(i, 1); },
|m, i| { m.get(&i); });
#[bench]
pub fn find_rand_10_000(b: &mut Bencher) {
- let mut m : BTreeMap<uint,uint> = BTreeMap::new();
+ let mut m = BTreeMap::new();
find_rand_n(10_000, &mut m, b,
|m, i| { m.insert(i, 1); },
|m, i| { m.get(&i); });
// Find seq
#[bench]
pub fn find_seq_100(b: &mut Bencher) {
- let mut m : BTreeMap<uint,uint> = BTreeMap::new();
+ let mut m = BTreeMap::new();
find_seq_n(100, &mut m, b,
|m, i| { m.insert(i, 1); },
|m, i| { m.get(&i); });
#[bench]
pub fn find_seq_10_000(b: &mut Bencher) {
- let mut m : BTreeMap<uint,uint> = BTreeMap::new();
+ let mut m = BTreeMap::new();
find_seq_n(10_000, &mut m, b,
|m, i| { m.insert(i, 1); },
|m, i| { m.get(&i); });
}
- fn bench_iter(b: &mut Bencher, size: uint) {
- let mut map = BTreeMap::<uint, uint>::new();
+ fn bench_iter(b: &mut Bencher, size: i32) {
+ let mut map = BTreeMap::<i32, i32>::new();
let mut rng = weak_rng();
for _ in 0..size {
//
// Note: instead of accessing this field directly, please call the `len()` method, which should
// be more stable in the face of representation changes.
- _len: uint,
+ _len: usize,
// FIXME(gereeter) It shouldn't be necessary to store the capacity in every node, as it should
// be constant throughout the tree. Once a solution to this is found, it might be possible to
//
// Note: instead of accessing this field directly, please call the `capacity()` method, which
// should be more stable in the face of representation changes.
- _capacity: uint,
+ _capacity: usize,
}
struct NodeSlice<'a, K: 'a, V: 'a> {
///
/// Fails if `target_alignment` is not a power of two.
#[inline]
-fn round_up_to_next(unrounded: uint, target_alignment: uint) -> uint {
+fn round_up_to_next(unrounded: usize, target_alignment: usize) -> usize {
assert!(num::UnsignedInt::is_power_of_two(target_alignment));
(unrounded + target_alignment - 1) & !(target_alignment - 1)
}
// Returns a tuple of (val_offset, edge_offset),
// from the start of a mallocated array.
#[inline]
-fn calculate_offsets(keys_size: uint,
- vals_size: uint, vals_align: uint,
- edges_align: uint)
- -> (uint, uint) {
+fn calculate_offsets(keys_size: usize,
+ vals_size: usize, vals_align: usize,
+ edges_align: usize)
+ -> (usize, usize) {
let vals_offset = round_up_to_next(keys_size, vals_align);
let end_of_vals = vals_offset + vals_size;
// Returns a tuple of (minimum required alignment, array_size),
// from the start of a mallocated array.
#[inline]
-fn calculate_allocation(keys_size: uint, keys_align: uint,
- vals_size: uint, vals_align: uint,
- edges_size: uint, edges_align: uint)
- -> (uint, uint) {
+fn calculate_allocation(keys_size: usize, keys_align: usize,
+ vals_size: usize, vals_align: usize,
+ edges_size: usize, edges_align: usize)
+ -> (usize, usize) {
let (_, edges_offset) = calculate_offsets(keys_size,
vals_size, vals_align,
edges_align);
assert_eq!(calculate_offsets(6, 12, 4, 8), (8, 24));
}
-fn calculate_allocation_generic<K, V>(capacity: uint, is_leaf: bool) -> (uint, uint) {
+fn calculate_allocation_generic<K, V>(capacity: usize, is_leaf: bool) -> (usize, usize) {
let (keys_size, keys_align) = (capacity * mem::size_of::<K>(), mem::min_align_of::<K>());
let (vals_size, vals_align) = (capacity * mem::size_of::<V>(), mem::min_align_of::<V>());
let (edges_size, edges_align) = if is_leaf {
)
}
-fn calculate_offsets_generic<K, V>(capacity: uint, is_leaf: bool) -> (uint, uint) {
+fn calculate_offsets_generic<K, V>(capacity: usize, is_leaf: bool) -> (usize, usize) {
let keys_size = capacity * mem::size_of::<K>();
let vals_size = capacity * mem::size_of::<V>();
let vals_align = mem::min_align_of::<V>();
RawItems::from_parts(slice.as_ptr(), slice.len())
}
- unsafe fn from_parts(ptr: *const T, len: uint) -> RawItems<T> {
+ unsafe fn from_parts(ptr: *const T, len: usize) -> RawItems<T> {
if mem::size_of::<T>() == 0 {
RawItems {
head: ptr,
- tail: (ptr as uint + len) as *const T,
+ tail: (ptr as usize + len) as *const T,
}
} else {
RawItems {
head: ptr,
- tail: ptr.offset(len as int),
+ tail: ptr.offset(len as isize),
}
}
}
ptr::write(self.tail as *mut T, val);
if mem::size_of::<T>() == 0 {
- self.tail = (self.tail as uint + 1) as *const T;
+ self.tail = (self.tail as usize + 1) as *const T;
} else {
self.tail = self.tail.offset(1);
}
let ret = Some(ptr::read(self.head));
if mem::size_of::<T>() == 0 {
- self.head = (self.head as uint + 1) as *const T;
+ self.head = (self.head as usize + 1) as *const T;
} else {
self.head = self.head.offset(1);
}
} else {
unsafe {
if mem::size_of::<T>() == 0 {
- self.tail = (self.tail as uint - 1) as *const T;
+ self.tail = (self.tail as usize - 1) as *const T;
} else {
self.tail = self.tail.offset(-1);
}
impl<K, V> Node<K, V> {
/// Make a new internal node. The caller must initialize the result to fix the invariant that
/// there are `len() + 1` edges.
- unsafe fn new_internal(capacity: uint) -> Node<K, V> {
+ unsafe fn new_internal(capacity: usize) -> Node<K, V> {
let (alignment, size) = calculate_allocation_generic::<K, V>(capacity, false);
let buffer = heap::allocate(size, alignment);
Node {
keys: Unique(buffer as *mut K),
- vals: Unique(buffer.offset(vals_offset as int) as *mut V),
- edges: Unique(buffer.offset(edges_offset as int) as *mut Node<K, V>),
+ vals: Unique(buffer.offset(vals_offset as isize) as *mut V),
+ edges: Unique(buffer.offset(edges_offset as isize) as *mut Node<K, V>),
_len: 0,
_capacity: capacity,
}
}
/// Make a new leaf node
- fn new_leaf(capacity: uint) -> Node<K, V> {
+ fn new_leaf(capacity: usize) -> Node<K, V> {
let (alignment, size) = calculate_allocation_generic::<K, V>(capacity, true);
let buffer = unsafe { heap::allocate(size, alignment) };
Node {
keys: Unique(buffer as *mut K),
- vals: Unique(unsafe { buffer.offset(vals_offset as int) as *mut V }),
+ vals: Unique(unsafe { buffer.offset(vals_offset as isize) as *mut V }),
edges: Unique(ptr::null_mut()),
_len: 0,
_capacity: capacity,
///
/// ```rust,ignore
/// struct Nasty<'a> {
-/// first: &'a Node<uint, uint>,
-/// second: &'a Node<uint, uint>,
+/// first: &'a Node<usize, usize>,
+/// second: &'a Node<usize, usize>,
/// flag: &'a Cell<bool>,
/// }
///
/// impl<'a> Deref for Nasty<'a> {
-/// type Target = Node<uint, uint>;
+/// type Target = Node<usize, usize>;
///
-/// fn deref(&self) -> &Node<uint, uint> {
+/// fn deref(&self) -> &Node<usize, usize> {
/// if self.flag.get() {
/// &*self.second
/// } else {
#[derive(Copy)]
pub struct Handle<NodeRef, Type, NodeType> {
node: NodeRef,
- index: uint
+ index: usize
}
pub mod handle {
-> SearchResult<NodeRef> where Q: BorrowFrom<K> + Ord {
// FIXME(Gankro): Tune when to search linear or binary based on B (and maybe K/V).
// For the B configured as of this writing (B = 6), binary search was *significantly*
- // worse for uints.
+ // worse for usizes.
match node.as_slices_internal().search_linear(key) {
(index, true) => Found(Handle { node: node, index: index }),
(index, false) => GoDown(Handle { node: node, index: index }),
// Public interface
impl <K, V> Node<K, V> {
/// Make a leaf root from scratch
- pub fn make_leaf_root(b: uint) -> Node<K, V> {
+ pub fn make_leaf_root(b: usize) -> Node<K, V> {
Node::new_leaf(capacity_from_b(b))
}
/// Make an internal root and swap it with an old root
- pub fn make_internal_root(left_and_out: &mut Node<K,V>, b: uint, key: K, value: V,
+ pub fn make_internal_root(left_and_out: &mut Node<K,V>, b: usize, key: K, value: V,
right: Node<K,V>) {
let node = mem::replace(left_and_out, unsafe { Node::new_internal(capacity_from_b(b)) });
left_and_out._len = 1;
}
/// How many key-value pairs the node contains
- pub fn len(&self) -> uint {
+ pub fn len(&self) -> usize {
self._len
}
/// How many key-value pairs the node can fit
- pub fn capacity(&self) -> uint {
+ pub fn capacity(&self) -> usize {
self._capacity
}
/// # Panics (in debug build)
///
/// Panics if the given index is out of bounds.
- pub fn kv_handle(&mut self, index: uint) -> Handle<&mut Node<K, V>, handle::KV,
+ pub fn kv_handle(&mut self, index: usize) -> Handle<&mut Node<K, V>, handle::KV,
handle::LeafOrInternal> {
// Necessary for correctness, but in a private module
debug_assert!(index < self.len(), "kv_handle index out of bounds");
// This must be followed by insert_edge on an internal node.
#[inline]
- unsafe fn insert_kv(&mut self, index: uint, key: K, val: V) -> &mut V {
+ unsafe fn insert_kv(&mut self, index: usize, key: K, val: V) -> &mut V {
ptr::copy_memory(
- self.keys_mut().as_mut_ptr().offset(index as int + 1),
- self.keys().as_ptr().offset(index as int),
+ self.keys_mut().as_mut_ptr().offset(index as isize + 1),
+ self.keys().as_ptr().offset(index as isize),
self.len() - index
);
ptr::copy_memory(
- self.vals_mut().as_mut_ptr().offset(index as int + 1),
- self.vals().as_ptr().offset(index as int),
+ self.vals_mut().as_mut_ptr().offset(index as isize + 1),
+ self.vals().as_ptr().offset(index as isize),
self.len() - index
);
// This can only be called immediately after a call to insert_kv.
#[inline]
- unsafe fn insert_edge(&mut self, index: uint, edge: Node<K, V>) {
+ unsafe fn insert_edge(&mut self, index: usize, edge: Node<K, V>) {
ptr::copy_memory(
- self.edges_mut().as_mut_ptr().offset(index as int + 1),
- self.edges().as_ptr().offset(index as int),
+ self.edges_mut().as_mut_ptr().offset(index as isize + 1),
+ self.edges().as_ptr().offset(index as isize),
self.len() - index
);
ptr::write(self.edges_mut().get_unchecked_mut(index), edge);
// This must be followed by remove_edge on an internal node.
#[inline]
- unsafe fn remove_kv(&mut self, index: uint) -> (K, V) {
+ unsafe fn remove_kv(&mut self, index: usize) -> (K, V) {
let key = ptr::read(self.keys().get_unchecked(index));
let val = ptr::read(self.vals().get_unchecked(index));
ptr::copy_memory(
- self.keys_mut().as_mut_ptr().offset(index as int),
- self.keys().as_ptr().offset(index as int + 1),
+ self.keys_mut().as_mut_ptr().offset(index as isize),
+ self.keys().as_ptr().offset(index as isize + 1),
self.len() - index - 1
);
ptr::copy_memory(
- self.vals_mut().as_mut_ptr().offset(index as int),
- self.vals().as_ptr().offset(index as int + 1),
+ self.vals_mut().as_mut_ptr().offset(index as isize),
+ self.vals().as_ptr().offset(index as isize + 1),
self.len() - index - 1
);
// This can only be called immediately after a call to remove_kv.
#[inline]
- unsafe fn remove_edge(&mut self, index: uint) -> Node<K, V> {
+ unsafe fn remove_edge(&mut self, index: usize) -> Node<K, V> {
let edge = ptr::read(self.edges().get_unchecked(index));
ptr::copy_memory(
- self.edges_mut().as_mut_ptr().offset(index as int),
- self.edges().as_ptr().offset(index as int + 1),
+ self.edges_mut().as_mut_ptr().offset(index as isize),
+ self.edges().as_ptr().offset(index as isize + 1),
self.len() - index + 1
);
let right_offset = self.len() - right.len();
ptr::copy_nonoverlapping_memory(
right.keys_mut().as_mut_ptr(),
- self.keys().as_ptr().offset(right_offset as int),
+ self.keys().as_ptr().offset(right_offset as isize),
right.len()
);
ptr::copy_nonoverlapping_memory(
right.vals_mut().as_mut_ptr(),
- self.vals().as_ptr().offset(right_offset as int),
+ self.vals().as_ptr().offset(right_offset as isize),
right.len()
);
if !self.is_leaf() {
ptr::copy_nonoverlapping_memory(
right.edges_mut().as_mut_ptr(),
- self.edges().as_ptr().offset(right_offset as int),
+ self.edges().as_ptr().offset(right_offset as isize),
right.len() + 1
);
}
ptr::write(self.vals_mut().get_unchecked_mut(old_len), val);
ptr::copy_nonoverlapping_memory(
- self.keys_mut().as_mut_ptr().offset(old_len as int + 1),
+ self.keys_mut().as_mut_ptr().offset(old_len as isize + 1),
right.keys().as_ptr(),
right.len()
);
ptr::copy_nonoverlapping_memory(
- self.vals_mut().as_mut_ptr().offset(old_len as int + 1),
+ self.vals_mut().as_mut_ptr().offset(old_len as isize + 1),
right.vals().as_ptr(),
right.len()
);
if !self.is_leaf() {
ptr::copy_nonoverlapping_memory(
- self.edges_mut().as_mut_ptr().offset(old_len as int + 1),
+ self.edges_mut().as_mut_ptr().offset(old_len as isize + 1),
right.edges().as_ptr(),
right.len() + 1
);
}
/// Get the capacity of a node from the order of the parent B-Tree
-fn capacity_from_b(b: uint) -> uint {
+fn capacity_from_b(b: usize) -> usize {
2 * b - 1
}
/// Get the minimum load of a node from its capacity
-fn min_load_from_capacity(cap: uint) -> uint {
+fn min_load_from_capacity(cap: usize) -> usize {
// B - 1
cap / 2
}
// For deallocation when we are done iterating.
ptr: *mut u8,
- capacity: uint,
+ capacity: usize,
is_leaf: bool
}
$as_slices_internal:ident, $index:ident, $iter:ident) => {
impl<'a, K: Ord + 'a, V: 'a> $NodeSlice<'a, K, V> {
/// Performs linear search in a slice. Returns a tuple of (index, is_exact_match).
- fn search_linear<Q: ?Sized>(&self, key: &Q) -> (uint, bool)
+ fn search_linear<Q: ?Sized>(&self, key: &Q) -> (usize, bool)
where Q: BorrowFrom<K> + Ord {
for (i, k) in self.keys.iter().enumerate() {
match key.cmp(BorrowFrom::borrow_from(k)) {
/// B cannot be less than 2.
#[unstable(feature = "collections",
reason = "probably want this to be on the type, eventually")]
- pub fn with_b(b: uint) -> BTreeSet<T> {
+ pub fn with_b(b: usize) -> BTreeSet<T> {
BTreeSet { map: BTreeMap::with_b(b) }
}
}
/// ```
/// use std::collections::BTreeSet;
///
- /// let set: BTreeSet<uint> = [1u, 2, 3, 4].iter().map(|&x| x).collect();
+ /// let set: BTreeSet<usize> = [1u, 2, 3, 4].iter().map(|&x| x).collect();
///
/// for x in set.iter() {
/// println!("{}", x);
/// }
///
- /// let v: Vec<uint> = set.iter().map(|&x| x).collect();
+ /// let v: Vec<usize> = set.iter().map(|&x| x).collect();
/// assert_eq!(v, vec![1u,2,3,4]);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
/// ```
/// use std::collections::BTreeSet;
///
- /// let set: BTreeSet<uint> = [1u, 2, 3, 4].iter().map(|&x| x).collect();
+ /// let set: BTreeSet<usize> = [1u, 2, 3, 4].iter().map(|&x| x).collect();
///
- /// let v: Vec<uint> = set.into_iter().collect();
+ /// let v: Vec<usize> = set.into_iter().collect();
/// assert_eq!(v, vec![1u,2,3,4]);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
/// b.insert(2u);
/// b.insert(3u);
///
- /// let diff: Vec<uint> = a.difference(&b).cloned().collect();
+ /// let diff: Vec<usize> = a.difference(&b).cloned().collect();
/// assert_eq!(diff, vec![1u]);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
/// b.insert(2u);
/// b.insert(3u);
///
- /// let sym_diff: Vec<uint> = a.symmetric_difference(&b).cloned().collect();
+ /// let sym_diff: Vec<usize> = a.symmetric_difference(&b).cloned().collect();
/// assert_eq!(sym_diff, vec![1u,3]);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
/// b.insert(2u);
/// b.insert(3u);
///
- /// let intersection: Vec<uint> = a.intersection(&b).cloned().collect();
+ /// let intersection: Vec<usize> = a.intersection(&b).cloned().collect();
/// assert_eq!(intersection, vec![2u]);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
/// let mut b = BTreeSet::new();
/// b.insert(2u);
///
- /// let union: Vec<uint> = a.union(&b).cloned().collect();
+ /// let union: Vec<usize> = a.union(&b).cloned().collect();
/// assert_eq!(union, vec![1u,2]);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
/// assert_eq!(v.len(), 1);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn len(&self) -> uint { self.map.len() }
+ pub fn len(&self) -> usize { self.map.len() }
/// Returns true if the set contains no elements
///
type Item = &'a T;
fn next(&mut self) -> Option<&'a T> { self.iter.next() }
- fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
+ fn size_hint(&self) -> (usize, Option<usize>) { self.iter.size_hint() }
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, T> DoubleEndedIterator for Iter<'a, T> {
type Item = T;
fn next(&mut self) -> Option<T> { self.iter.next() }
- fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
+ fn size_hint(&self) -> (usize, Option<usize>) { self.iter.size_hint() }
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<T> DoubleEndedIterator for IntoIter<T> {
}
struct Counter<'a, 'b> {
- i: &'a mut uint,
- expected: &'b [int],
+ i: &'a mut usize,
+ expected: &'b [i32],
}
- impl<'a, 'b, 'c> FnMut<(&'c int,)> for Counter<'a, 'b> {
+ impl<'a, 'b, 'c> FnMut<(&'c i32,)> for Counter<'a, 'b> {
type Output = bool;
- extern "rust-call" fn call_mut(&mut self, (&x,): (&'c int,)) -> bool {
+ extern "rust-call" fn call_mut(&mut self, (&x,): (&'c i32,)) -> bool {
assert_eq!(x, self.expected[*self.i]);
*self.i += 1;
true
}
}
- fn check<F>(a: &[int], b: &[int], expected: &[int], f: F) where
+ fn check<F>(a: &[i32], b: &[i32], expected: &[i32], f: F) where
// FIXME Replace Counter with `Box<FnMut(_) -> _>`
- F: FnOnce(&BTreeSet<int>, &BTreeSet<int>, Counter) -> bool,
+ F: FnOnce(&BTreeSet<i32>, &BTreeSet<i32>, Counter) -> bool,
{
let mut set_a = BTreeSet::new();
let mut set_b = BTreeSet::new();
#[test]
fn test_intersection() {
- fn check_intersection(a: &[int], b: &[int], expected: &[int]) {
+ fn check_intersection(a: &[i32], b: &[i32], expected: &[i32]) {
check(a, b, expected, |x, y, f| x.intersection(y).all(f))
}
#[test]
fn test_difference() {
- fn check_difference(a: &[int], b: &[int], expected: &[int]) {
+ fn check_difference(a: &[i32], b: &[i32], expected: &[i32]) {
check(a, b, expected, |x, y, f| x.difference(y).all(f))
}
#[test]
fn test_symmetric_difference() {
- fn check_symmetric_difference(a: &[int], b: &[int],
- expected: &[int]) {
+ fn check_symmetric_difference(a: &[i32], b: &[i32], expected: &[i32]) {
check(a, b, expected, |x, y, f| x.symmetric_difference(y).all(f))
}
#[test]
fn test_union() {
- fn check_union(a: &[int], b: &[int],
- expected: &[int]) {
+ fn check_union(a: &[i32], b: &[i32], expected: &[i32]) {
check(a, b, expected, |x, y, f| x.union(y).all(f))
}
#[test]
fn test_zip() {
let mut x = BTreeSet::new();
- x.insert(5u);
- x.insert(12u);
- x.insert(11u);
+ x.insert(5);
+ x.insert(12);
+ x.insert(11);
let mut y = BTreeSet::new();
y.insert("foo");
let mut z = x.iter().zip(y.iter());
// FIXME: #5801: this needs a type hint to compile...
- let result: Option<(&uint, & &'static str)> = z.next();
- assert_eq!(result.unwrap(), (&5u, &("bar")));
+ let result: Option<(&usize, & &'static str)> = z.next();
+ assert_eq!(result.unwrap(), (&5, &("bar")));
- let result: Option<(&uint, & &'static str)> = z.next();
- assert_eq!(result.unwrap(), (&11u, &("foo")));
+ let result: Option<(&usize, & &'static str)> = z.next();
+ assert_eq!(result.unwrap(), (&11, &("foo")));
- let result: Option<(&uint, & &'static str)> = z.next();
+ let result: Option<(&usize, & &'static str)> = z.next();
assert!(result.is_none());
}
/// A doubly-linked list.
#[stable(feature = "rust1", since = "1.0.0")]
pub struct DList<T> {
- length: uint,
+ length: usize,
list_head: Link<T>,
list_tail: Rawlink<Node<T>>,
}
pub struct Iter<'a, T:'a> {
head: &'a Link<T>,
tail: Rawlink<Node<T>>,
- nelem: uint,
+ nelem: usize,
}
// FIXME #19839: deriving is too aggressive on the bounds (T doesn't need to be Clone).
list: &'a mut DList<T>,
head: Rawlink<Node<T>>,
tail: Rawlink<Node<T>>,
- nelem: uint,
+ nelem: usize,
}
/// An iterator over mutable references to the items of a `DList`.
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn len(&self) -> uint {
+ pub fn len(&self) -> usize {
self.length
}
/// assert_eq!(splitted.pop_front(), None);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn split_off(&mut self, at: uint) -> DList<T> {
+ pub fn split_off(&mut self, at: usize) -> DList<T> {
let len = self.len();
assert!(at < len, "Cannot split off at a nonexistent index");
if at == 0 {
}
#[inline]
- fn size_hint(&self) -> (uint, Option<uint>) {
+ fn size_hint(&self) -> (usize, Option<usize>) {
(self.nelem, Some(self.nelem))
}
}
}
#[inline]
- fn size_hint(&self) -> (uint, Option<uint>) {
+ fn size_hint(&self) -> (usize, Option<usize>) {
(self.nelem, Some(self.nelem))
}
}
fn next(&mut self) -> Option<A> { self.list.pop_front() }
#[inline]
- fn size_hint(&self) -> (uint, Option<uint>) {
+ fn size_hint(&self) -> (usize, Option<usize>) {
(self.list.length, Some(self.list.length))
}
}
use super::{DList, Node};
pub fn check_links<T>(list: &DList<T>) {
- let mut len = 0u;
+ let mut len = 0;
let mut last_ptr: Option<&Node<T>> = None;
let mut node_ptr: &Node<T>;
match list.list_head {
- None => { assert_eq!(0u, list.length); return }
+ None => { assert_eq!(0, list.length); return }
Some(ref node) => node_ptr = &**node,
}
loop {
#[test]
fn test_basic() {
- let mut m: DList<Box<int>> = DList::new();
+ let mut m = DList::new();
assert_eq!(m.pop_front(), None);
assert_eq!(m.pop_back(), None);
assert_eq!(m.pop_front(), None);
}
#[cfg(test)]
- fn generate_test() -> DList<int> {
+ fn generate_test() -> DList<i32> {
list_from(&[0,1,2,3,4,5,6])
}
fn test_append() {
// Empty to empty
{
- let mut m: DList<int> = DList::new();
+ let mut m = DList::<i32>::new();
let mut n = DList::new();
m.append(&mut n);
check_links(&m);
fn test_iterator() {
let m = generate_test();
for (i, elt) in m.iter().enumerate() {
- assert_eq!(i as int, *elt);
+ assert_eq!(i as i32, *elt);
}
let mut n = DList::new();
assert_eq!(n.iter().next(), None);
fn test_rev_iter() {
let m = generate_test();
for (i, elt) in m.iter().rev().enumerate() {
- assert_eq!((6 - i) as int, *elt);
+ assert_eq!((6 - i) as i32, *elt);
}
let mut n = DList::new();
assert_eq!(n.iter().rev().next(), None);
let mut m = generate_test();
let mut len = m.len();
for (i, elt) in m.iter_mut().enumerate() {
- assert_eq!(i as int, *elt);
+ assert_eq!(i as i32, *elt);
len -= 1;
}
assert_eq!(len, 0);
}
check_links(&m);
assert_eq!(m.len(), 3 + len * 2);
- assert_eq!(m.into_iter().collect::<Vec<int>>(), vec![-2,0,1,2,3,4,5,6,7,8,9,0,1]);
+ assert_eq!(m.into_iter().collect::<Vec<_>>(), vec![-2,0,1,2,3,4,5,6,7,8,9,0,1]);
}
#[test]
fn test_mut_rev_iter() {
let mut m = generate_test();
for (i, elt) in m.iter_mut().rev().enumerate() {
- assert_eq!((6-i) as int, *elt);
+ assert_eq!((6 - i) as i32, *elt);
}
let mut n = DList::new();
assert!(n.iter_mut().rev().next().is_none());
Thread::scoped(move || {
check_links(&n);
let a: &[_] = &[&1,&2,&3];
- assert_eq!(a, n.iter().collect::<Vec<&int>>());
+ assert_eq!(a, n.iter().collect::<Vec<_>>());
}).join().ok().unwrap();
}
#[test]
fn test_eq() {
- let mut n: DList<u8> = list_from(&[]);
+ let mut n = list_from(&[]);
let mut m = list_from(&[]);
assert!(n == m);
n.push_front(1);
#[test]
fn test_ord() {
- let n: DList<int> = list_from(&[]);
+ let n = list_from(&[]);
let m = list_from(&[1,2,3]);
assert!(n < m);
assert!(m > n);
#[test]
fn test_fuzz() {
- for _ in 0u..25 {
+ for _ in 0..25 {
fuzz_test(3);
fuzz_test(16);
fuzz_test(189);
#[test]
fn test_show() {
- let list: DList<i32> = (0..10).collect();
+ let list: DList<_> = (0..10).collect();
assert_eq!(format!("{:?}", list), "DList [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]");
- let list: DList<&str> = vec!["just", "one", "test", "more"].iter()
- .map(|&s| s)
- .collect();
+ let list: DList<_> = vec!["just", "one", "test", "more"].iter().cloned().collect();
assert_eq!(format!("{:?}", list), "DList [\"just\", \"one\", \"test\", \"more\"]");
}
#[cfg(test)]
- fn fuzz_test(sz: int) {
- let mut m: DList<int> = DList::new();
+ fn fuzz_test(sz: i32) {
+ let mut m: DList<_> = DList::new();
let mut v = vec![];
for i in 0..sz {
check_links(&m);
check_links(&m);
- let mut i = 0u;
+ let mut i = 0;
for (a, &b) in m.into_iter().zip(v.iter()) {
i += 1;
assert_eq!(a, b);
fn bench_collect_into(b: &mut test::Bencher) {
let v = &[0; 64];
b.iter(|| {
- let _: DList<int> = v.iter().map(|x| *x).collect();
+ let _: DList<_> = v.iter().cloned().collect();
})
}
#[bench]
fn bench_push_front(b: &mut test::Bencher) {
- let mut m: DList<int> = DList::new();
+ let mut m: DList<_> = DList::new();
b.iter(|| {
m.push_front(0);
})
#[bench]
fn bench_push_back(b: &mut test::Bencher) {
- let mut m: DList<int> = DList::new();
+ let mut m: DList<_> = DList::new();
b.iter(|| {
m.push_back(0);
})
#[bench]
fn bench_push_back_pop_back(b: &mut test::Bencher) {
- let mut m: DList<int> = DList::new();
+ let mut m: DList<_> = DList::new();
b.iter(|| {
m.push_back(0);
m.pop_back();
#[bench]
fn bench_push_front_pop_front(b: &mut test::Bencher) {
- let mut m: DList<int> = DList::new();
+ let mut m: DList<_> = DList::new();
b.iter(|| {
m.push_front(0);
m.pop_front();
#[bench]
fn bench_iter(b: &mut test::Bencher) {
let v = &[0; 128];
- let m: DList<int> = v.iter().map(|&x|x).collect();
+ let m: DList<_> = v.iter().cloned().collect();
b.iter(|| {
assert!(m.iter().count() == 128);
})
#[bench]
fn bench_iter_mut(b: &mut test::Bencher) {
let v = &[0; 128];
- let mut m: DList<int> = v.iter().map(|&x|x).collect();
+ let mut m: DList<_> = v.iter().cloned().collect();
b.iter(|| {
assert!(m.iter_mut().count() == 128);
})
#[bench]
fn bench_iter_rev(b: &mut test::Bencher) {
let v = &[0; 128];
- let m: DList<int> = v.iter().map(|&x|x).collect();
+ let m: DList<_> = v.iter().cloned().collect();
b.iter(|| {
assert!(m.iter().rev().count() == 128);
})
#[bench]
fn bench_iter_mut_rev(b: &mut test::Bencher) {
let v = &[0; 128];
- let mut m: DList<int> = v.iter().map(|&x|x).collect();
+ let mut m: DList<_> = v.iter().cloned().collect();
b.iter(|| {
assert!(m.iter_mut().rev().count() == 128);
})
pub struct EnumSet<E> {
// We must maintain the invariant that no bits are set
// for which no variant exists
- bits: uint
+ bits: usize
}
impl<E> Copy for EnumSet<E> {}
}
}
-/// An interface for casting C-like enum to uint and back.
+/// An interface for casting C-like enum to usize and back.
/// A typically implementation is as below.
///
/// ```{rust,ignore}
-/// #[repr(uint)]
+/// #[repr(usize)]
/// enum Foo {
/// A, B, C
/// }
///
/// impl CLike for Foo {
-/// fn to_uint(&self) -> uint {
-/// *self as uint
+/// fn to_usize(&self) -> usize {
+/// *self as usize
/// }
///
-/// fn from_uint(v: uint) -> Foo {
+/// fn from_usize(v: usize) -> Foo {
/// unsafe { mem::transmute(v) }
/// }
/// }
/// ```
pub trait CLike {
- /// Converts a C-like enum to a `uint`.
- fn to_uint(&self) -> uint;
- /// Converts a `uint` to a C-like enum.
- fn from_uint(uint) -> Self;
+ /// Converts a C-like enum to a `usize`.
+ fn to_usize(&self) -> usize;
+ /// Converts a `usize` to a C-like enum.
+ fn from_usize(usize) -> Self;
}
-fn bit<E:CLike>(e: &E) -> uint {
- use core::uint;
- let value = e.to_uint();
- assert!(value < uint::BITS,
- "EnumSet only supports up to {} variants.", uint::BITS - 1);
+fn bit<E:CLike>(e: &E) -> usize {
+ use core::usize;
+ let value = e.to_usize();
+ assert!(value < usize::BITS,
+ "EnumSet only supports up to {} variants.", usize::BITS - 1);
1 << value
}
/// Returns the number of elements in the given `EnumSet`.
#[unstable(feature = "collections",
reason = "matches collection reform specification, waiting for dust to settle")]
- pub fn len(&self) -> uint {
+ pub fn len(&self) -> usize {
self.bits.count_ones()
}
/// An iterator over an EnumSet
pub struct Iter<E> {
- index: uint,
- bits: uint,
+ index: usize,
+ bits: usize,
}
// FIXME(#19839) Remove in favor of `#[derive(Clone)]`
}
impl<E:CLike> Iter<E> {
- fn new(bits: uint) -> Iter<E> {
+ fn new(bits: usize) -> Iter<E> {
Iter { index: 0, bits: bits }
}
}
self.index += 1;
self.bits >>= 1;
}
- let elem = CLike::from_uint(self.index);
+ let elem = CLike::from_usize(self.index);
self.index += 1;
self.bits >>= 1;
Some(elem)
}
- fn size_hint(&self) -> (uint, Option<uint>) {
+ fn size_hint(&self) -> (usize, Option<usize>) {
let exact = self.bits.count_ones();
(exact, Some(exact))
}
use super::{EnumSet, CLike};
#[derive(Copy, PartialEq, Debug)]
- #[repr(uint)]
+ #[repr(usize)]
enum Foo {
A, B, C
}
impl CLike for Foo {
- fn to_uint(&self) -> uint {
- *self as uint
+ fn to_usize(&self) -> usize {
+ *self as usize
}
- fn from_uint(v: uint) -> Foo {
+ fn from_usize(v: usize) -> Foo {
unsafe { mem::transmute(v) }
}
}
fn test_overflow() {
#[allow(dead_code)]
#[derive(Copy)]
- #[repr(uint)]
+ #[repr(usize)]
enum Bar {
V00, V01, V02, V03, V04, V05, V06, V07, V08, V09,
V10, V11, V12, V13, V14, V15, V16, V17, V18, V19,
}
impl CLike for Bar {
- fn to_uint(&self) -> uint {
- *self as uint
+ fn to_usize(&self) -> usize {
+ *self as usize
}
- fn from_uint(v: uint) -> Bar {
+ fn from_usize(v: usize) -> Bar {
unsafe { mem::transmute(v) }
}
}
use alloc::heap;
-static INITIAL_CAPACITY: uint = 7u; // 2^3 - 1
-static MINIMUM_CAPACITY: uint = 1u; // 2 - 1
+static INITIAL_CAPACITY: usize = 7u; // 2^3 - 1
+static MINIMUM_CAPACITY: usize = 1u; // 2 - 1
/// `RingBuf` is a circular buffer, which can be used as a double-ended queue efficiently.
#[stable(feature = "rust1", since = "1.0.0")]
// If tail == head the buffer is empty. The length of the ringbuf
// is defined as the distance between the two.
- tail: uint,
- head: uint,
- cap: uint,
+ tail: usize,
+ head: usize,
+ cap: usize,
ptr: *mut T
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<T: Clone> Clone for RingBuf<T> {
fn clone(&self) -> RingBuf<T> {
- self.iter().map(|t| t.clone()).collect()
+ self.iter().cloned().collect()
}
}
/// Moves an element out of the buffer
#[inline]
- unsafe fn buffer_read(&mut self, off: uint) -> T {
- ptr::read(self.ptr.offset(off as int))
+ unsafe fn buffer_read(&mut self, off: usize) -> T {
+ ptr::read(self.ptr.offset(off as isize))
}
/// Writes an element into the buffer, moving it.
#[inline]
- unsafe fn buffer_write(&mut self, off: uint, t: T) {
- ptr::write(self.ptr.offset(off as int), t);
+ unsafe fn buffer_write(&mut self, off: usize, t: T) {
+ ptr::write(self.ptr.offset(off as isize), t);
}
/// Returns true iff the buffer is at capacity
/// Returns the index in the underlying buffer for a given logical element index.
#[inline]
- fn wrap_index(&self, idx: uint) -> uint { wrap_index(idx, self.cap) }
+ fn wrap_index(&self, idx: usize) -> usize { wrap_index(idx, self.cap) }
/// Copies a contiguous block of memory len long from src to dst
#[inline]
- unsafe fn copy(&self, dst: uint, src: uint, len: uint) {
+ unsafe fn copy(&self, dst: usize, src: usize, len: usize) {
debug_assert!(dst + len <= self.cap, "dst={} src={} len={} cap={}", dst, src, len,
self.cap);
debug_assert!(src + len <= self.cap, "dst={} src={} len={} cap={}", dst, src, len,
self.cap);
ptr::copy_memory(
- self.ptr.offset(dst as int),
- self.ptr.offset(src as int),
+ self.ptr.offset(dst as isize),
+ self.ptr.offset(src as isize),
len);
}
/// Copies a contiguous block of memory len long from src to dst
#[inline]
- unsafe fn copy_nonoverlapping(&self, dst: uint, src: uint, len: uint) {
+ unsafe fn copy_nonoverlapping(&self, dst: usize, src: usize, len: usize) {
debug_assert!(dst + len <= self.cap, "dst={} src={} len={} cap={}", dst, src, len,
self.cap);
debug_assert!(src + len <= self.cap, "dst={} src={} len={} cap={}", dst, src, len,
self.cap);
ptr::copy_nonoverlapping_memory(
- self.ptr.offset(dst as int),
- self.ptr.offset(src as int),
+ self.ptr.offset(dst as isize),
+ self.ptr.offset(src as isize),
len);
}
}
/// Creates an empty `RingBuf` with space for at least `n` elements.
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn with_capacity(n: uint) -> RingBuf<T> {
+ pub fn with_capacity(n: usize) -> RingBuf<T> {
// +1 since the ringbuffer always leaves one space empty
let cap = cmp::max(n + 1, MINIMUM_CAPACITY + 1).next_power_of_two();
assert!(cap > n, "capacity overflow");
/// assert_eq!(buf.get(1).unwrap(), &4);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn get(&self, i: uint) -> Option<&T> {
+ pub fn get(&self, i: usize) -> Option<&T> {
if i < self.len() {
let idx = self.wrap_index(self.tail + i);
- unsafe { Some(&*self.ptr.offset(idx as int)) }
+ unsafe { Some(&*self.ptr.offset(idx as isize)) }
} else {
None
}
/// assert_eq!(buf[1], 7);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn get_mut(&mut self, i: uint) -> Option<&mut T> {
+ pub fn get_mut(&mut self, i: usize) -> Option<&mut T> {
if i < self.len() {
let idx = self.wrap_index(self.tail + i);
- unsafe { Some(&mut *self.ptr.offset(idx as int)) }
+ unsafe { Some(&mut *self.ptr.offset(idx as isize)) }
} else {
None
}
/// assert_eq!(buf[2], 3);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn swap(&mut self, i: uint, j: uint) {
+ pub fn swap(&mut self, i: usize, j: usize) {
assert!(i < self.len());
assert!(j < self.len());
let ri = self.wrap_index(self.tail + i);
let rj = self.wrap_index(self.tail + j);
unsafe {
- ptr::swap(self.ptr.offset(ri as int), self.ptr.offset(rj as int))
+ ptr::swap(self.ptr.offset(ri as isize), self.ptr.offset(rj as isize))
}
}
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn capacity(&self) -> uint { self.cap - 1 }
+ pub fn capacity(&self) -> usize { self.cap - 1 }
/// Reserves the minimum capacity for exactly `additional` more elements to be inserted in the
/// given `RingBuf`. Does nothing if the capacity is already sufficient.
///
/// # Panics
///
- /// Panics if the new capacity overflows `uint`.
+ /// Panics if the new capacity overflows `usize`.
///
/// # Examples
///
/// assert!(buf.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) {
self.reserve(additional);
}
///
/// # Panics
///
- /// Panics if the new capacity overflows `uint`.
+ /// Panics if the new capacity overflows `usize`.
///
/// # Examples
///
/// assert!(buf.capacity() >= 11);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn reserve(&mut self, additional: uint) {
+ pub fn reserve(&mut self, additional: usize) {
let new_len = self.len() + additional;
assert!(new_len + 1 > self.len(), "capacity overflow");
if new_len > self.capacity() {
/// ```
#[unstable(feature = "collections",
reason = "matches collection reform specification; waiting on panic semantics")]
- pub fn truncate(&mut self, len: uint) {
+ pub fn truncate(&mut self, len: usize) {
for _ in len..self.len() {
self.pop_back();
}
/// assert_eq!(v.len(), 1);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn len(&self) -> uint { count(self.tail, self.head, self.cap) }
+ pub fn len(&self) -> usize { count(self.tail, self.head, self.cap) }
/// Returns true if the buffer contains no elements
///
/// ```
#[unstable(feature = "collections",
reason = "the naming of this function may be altered")]
- pub fn swap_back_remove(&mut self, index: uint) -> Option<T> {
+ pub fn swap_back_remove(&mut self, index: usize) -> Option<T> {
let length = self.len();
if length > 0 && index < length - 1 {
self.swap(index, length - 1);
/// ```
#[unstable(feature = "collections",
reason = "the naming of this function may be altered")]
- pub fn swap_front_remove(&mut self, index: uint) -> Option<T> {
+ pub fn swap_front_remove(&mut self, index: usize) -> Option<T> {
let length = self.len();
if length > 0 && index < length && index != 0 {
self.swap(index, 0);
/// buf.insert(1,11);
/// assert_eq!(Some(&11), buf.get(1));
/// ```
- pub fn insert(&mut self, i: uint, t: T) {
+ pub fn insert(&mut self, i: usize, t: T) {
assert!(i <= self.len(), "index out of bounds");
if self.is_full() {
self.reserve(1);
/// assert_eq!(Some(&15), buf.get(2));
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn remove(&mut self, i: uint) -> Option<T> {
+ pub fn remove(&mut self, i: usize) -> Option<T> {
if self.is_empty() || self.len() <= i {
return None;
}
/// ```
#[unstable(feature = "collections",
reason = "matches collection reform specification; waiting on panic semantics")]
- 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 {
/// Returns the index in the underlying buffer for a given logical element index.
#[inline]
-fn wrap_index(index: uint, size: uint) -> uint {
+fn wrap_index(index: usize, size: usize) -> usize {
// size is always a power of 2
index & (size - 1)
}
/// Calculate the number of elements left to be read in the buffer
#[inline]
-fn count(tail: uint, head: uint, size: uint) -> uint {
+fn count(tail: usize, head: usize, size: usize) -> usize {
// size is always a power of 2
(head - tail) & (size - 1)
}
#[stable(feature = "rust1", since = "1.0.0")]
pub struct Iter<'a, T:'a> {
ring: &'a [T],
- tail: uint,
- head: uint
+ tail: usize,
+ head: usize
}
// FIXME(#19839) Remove in favor of `#[derive(Clone)]`
}
#[inline]
- fn size_hint(&self) -> (uint, Option<uint>) {
+ fn size_hint(&self) -> (usize, Option<usize>) {
let len = count(self.tail, self.head, self.ring.len());
(len, Some(len))
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, T> RandomAccessIterator for Iter<'a, T> {
#[inline]
- fn indexable(&self) -> uint {
+ fn indexable(&self) -> usize {
let (len, _) = self.size_hint();
len
}
#[inline]
- fn idx(&mut self, j: uint) -> Option<&'a T> {
+ fn idx(&mut self, j: usize) -> Option<&'a T> {
if j >= self.indexable() {
None
} else {
#[stable(feature = "rust1", since = "1.0.0")]
pub struct IterMut<'a, T:'a> {
ptr: *mut T,
- tail: uint,
- head: uint,
- cap: uint,
+ tail: usize,
+ head: usize,
+ cap: usize,
marker: marker::ContravariantLifetime<'a>,
}
self.tail = wrap_index(self.tail + 1, self.cap);
unsafe {
- Some(&mut *self.ptr.offset(tail as int))
+ Some(&mut *self.ptr.offset(tail as isize))
}
}
#[inline]
- fn size_hint(&self) -> (uint, Option<uint>) {
+ fn size_hint(&self) -> (usize, Option<usize>) {
let len = count(self.tail, self.head, self.cap);
(len, Some(len))
}
self.head = wrap_index(self.head - 1, self.cap);
unsafe {
- Some(&mut *self.ptr.offset(self.head as int))
+ Some(&mut *self.ptr.offset(self.head as isize))
}
}
}
}
#[inline]
- fn size_hint(&self) -> (uint, Option<uint>) {
+ fn size_hint(&self) -> (usize, Option<usize>) {
let len = self.inner.len();
(len, Some(len))
}
}
#[inline]
- fn size_hint(&self) -> (uint, Option<uint>) {
+ fn size_hint(&self) -> (usize, Option<usize>) {
let len = self.inner.len();
(len, Some(len))
}
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<A> Index<u
int> for RingBuf<A> {
+impl<A> Index<u
size> for RingBuf<A> {
type Output = A;
#[inline]
- fn index<'a>(&'a self, i: &uint) -> &'a A {
+ fn index<'a>(&'a self, i: &usize) -> &'a A {
self.get(*i).expect("Out of bounds access")
}
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<A> IndexMut<u
int> for RingBuf<A> {
+impl<A> IndexMut<u
size> for RingBuf<A> {
type Output = A;
#[inline]
- fn index_mut<'a>(&'a mut self, i: &uint) -> &'a mut A {
+ fn index_mut<'a>(&'a mut self, i: &usize) -> &'a mut A {
self.get_mut(*i).expect("Out of bounds access")
}
}
#[allow(deprecated)]
fn test_simple() {
let mut d = RingBuf::new();
- assert_eq!(d.len(), 0u);
+ assert_eq!(d.len(), 0);
d.push_front(17);
d.push_front(42);
d.push_back(137);
- assert_eq!(d.len(), 3u);
+ assert_eq!(d.len(), 3);
d.push_back(137);
- assert_eq!(d.len(), 4u);
+ assert_eq!(d.len(), 4);
assert_eq!(*d.front().unwrap(), 42);
assert_eq!(*d.back().unwrap(), 137);
let mut i = d.pop_front();
assert_eq!(i, Some(137));
i = d.pop_back();
assert_eq!(i, Some(17));
- assert_eq!(d.len(), 0u);
+ assert_eq!(d.len(), 0);
d.push_back(3);
- assert_eq!(d.len(), 1u);
+ assert_eq!(d.len(), 1);
d.push_front(2);
- assert_eq!(d.len(), 2u);
+ assert_eq!(d.len(), 2);
d.push_back(4);
- assert_eq!(d.len(), 3u);
+ assert_eq!(d.len(), 3);
d.push_front(1);
- assert_eq!(d.len(), 4u);
+ assert_eq!(d.len(), 4);
debug!("{}", d[0]);
debug!("{}", d[1]);
debug!("{}", d[2]);
#[test]
fn test_push_front_grow() {
let mut deq = RingBuf::new();
- for i in 0u..66 {
+ for i in 0..66 {
deq.push_front(i);
}
assert_eq!(deq.len(), 66);
- for i in 0u..66 {
+ for i in 0..66 {
assert_eq!(deq[i], 65 - i);
}
let mut deq = RingBuf::new();
- for i in 0u..66 {
+ for i in 0..66 {
deq.push_back(i);
}
- for i in 0u..66 {
+ for i in 0..66 {
assert_eq!(deq[i], i);
}
}
#[test]
fn test_index() {
let mut deq = RingBuf::new();
- for i in 1u..4 {
+ for i in 1..4 {
deq.push_front(i);
}
assert_eq!(deq[1], 2);
#[should_fail]
fn test_index_out_of_bounds() {
let mut deq = RingBuf::new();
- for i in 1u..4 {
+ for i in 1..4 {
deq.push_front(i);
}
deq[3];
#[bench]
fn bench_new(b: &mut test::Bencher) {
b.iter(|| {
- let ring: RingBuf<u64> = RingBuf::new();
+ let ring: RingBuf<i32> = RingBuf::new();
test::black_box(ring);
})
}
#[bench]
fn bench_pop_back_100(b: &mut test::Bencher) {
- let mut deq: RingBuf<i32> = RingBuf::with_capacity(101);
+ let mut deq= RingBuf::<i32>::with_capacity(101);
b.iter(|| {
deq.head = 100;
#[bench]
fn bench_pop_front_100(b: &mut test::Bencher) {
- let mut deq: RingBuf<i32> = RingBuf::with_capacity(101);
+ let mut deq = RingBuf::<i32>::with_capacity(101);
b.iter(|| {
deq.head = 100;
#[bench]
fn bench_iter_1000(b: &mut test::Bencher) {
- let ring: RingBuf<i32> = (0..1000).collect();
+ let ring: RingBuf<_> = (0..1000).collect();
b.iter(|| {
let mut sum = 0;
#[bench]
fn bench_mut_iter_1000(b: &mut test::Bencher) {
- let mut ring: RingBuf<i32> = (0..1000).collect();
+ let mut ring: RingBuf<_> = (0..1000).collect();
b.iter(|| {
let mut sum = 0;
#[test]
fn test_reserve_exact() {
let mut d = RingBuf::new();
- d.push_back(0u64);
- d.reserve_exact(50);
- assert!(d.capacity() >= 51);
- let mut d = RingBuf::new();
- d.push_back(0u32);
+ d.push_back(0);
d.reserve_exact(50);
assert!(d.capacity() >= 51);
}
#[test]
fn test_reserve() {
let mut d = RingBuf::new();
- d.push_back(0u64);
- d.reserve(50);
- assert!(d.capacity() >= 51);
- let mut d = RingBuf::new();
- d.push_back(0u32);
+ d.push_back(0);
d.reserve(50);
assert!(d.capacity() >= 51);
}
#[test]
fn test_swap() {
- let mut d: RingBuf<i32> = (0..5).collect();
+ let mut d: RingBuf<_> = (0..5).collect();
d.pop_front();
d.swap(0, 3);
- assert_eq!(d.iter().map(|&x|x).collect::<Vec<i32>>(), vec!(4, 2, 3, 1));
+ assert_eq!(d.iter().cloned().collect::<Vec<_>>(), vec!(4, 2, 3, 1));
}
#[test]
}
{
let b: &[_] = &[&0,&1,&2,&3,&4];
- assert_eq!(d.iter().collect::<Vec<&i32>>(), b);
+ assert_eq!(d.iter().collect::<Vec<_>>(), b);
}
for i in 6..9 {
}
{
let b: &[_] = &[&8,&7,&6,&0,&1,&2,&3,&4];
- assert_eq!(d.iter().collect::<Vec<&i32>>(), b);
+ assert_eq!(d.iter().collect::<Vec<_>>(), b);
}
let mut it = d.iter();
}
{
let b: &[_] = &[&4,&3,&2,&1,&0];
- assert_eq!(d.iter().rev().collect::<Vec<&i32>>(), b);
+ assert_eq!(d.iter().rev().collect::<Vec<_>>(), b);
}
for i in 6..9 {
d.push_front(i);
}
let b: &[_] = &[&4,&3,&2,&1,&0,&6,&7,&8];
- assert_eq!(d.iter().rev().collect::<Vec<&i32>>(), b);
+ assert_eq!(d.iter().rev().collect::<Vec<_>>(), b);
}
#[test]
assert_eq!(d.pop_front(), Some(1));
d.push_back(4);
- assert_eq!(d.iter_mut().rev().map(|x| *x).collect::<Vec<i32>>(),
- vec!(4, 3, 2));
+ assert_eq!(d.iter_mut().rev().cloned().collect::<Vec<_>>(),
+ vec![4, 3, 2]);
}
#[test]
let mut d = RingBuf::new();
assert!(d.iter_mut().next().is_none());
- for i in 0u..3 {
+ for i in 0..3 {
d.push_front(i);
}
let mut d = RingBuf::new();
assert!(d.iter_mut().rev().next().is_none());
- for i in 0u..3 {
+ for i in 0..3 {
d.push_front(i);
}
}
let b = vec![0,1,2,3,4];
- assert_eq!(d.into_iter().collect::<Vec<i32>>(), b);
+ assert_eq!(d.into_iter().collect::<Vec<_>>(), b);
}
// wrapped iter
}
let b = vec![8,7,6,0,1,2,3,4];
- assert_eq!(d.into_iter().collect::<Vec<i32>>(), b);
+ assert_eq!(d.into_iter().collect::<Vec<_>>(), b);
}
// partially used
// partially used
{
- let mut d: RingBuf<i32> = RingBuf::new();
+ let mut d: RingBuf<_> = RingBuf::new();
for i in 0..5 {
d.push_back(i);
}
fn test_from_iter() {
use core::iter;
let v = vec!(1,2,3,4,5,6,7);
- let deq: RingBuf<i32> = v.iter().map(|&x| x).collect();
- let u: Vec<i32> = deq.iter().map(|&x| x).collect();
+ let deq: RingBuf<_> = v.iter().cloned().collect();
+ let u: Vec<_> = deq.iter().cloned().collect();
assert_eq!(u, v);
- let seq = iter::count(0u, 2).take(256);
- let deq: RingBuf<uint> = seq.collect();
+ let seq = iter::count(0, 2).take(256);
+ let deq: RingBuf<_> = seq.collect();
for (i, &x) in deq.iter().enumerate() {
assert_eq!(2*i, x);
}
d.push_front(42);
d.push_back(137);
d.push_back(137);
- assert_eq!(d.len(), 4u);
+ assert_eq!(d.len(), 4);
let mut e = d.clone();
- assert_eq!(e.len(), 4u);
+ assert_eq!(e.len(), 4);
while !d.is_empty() {
assert_eq!(d.pop_back(), e.pop_back());
}
- assert_eq!(d.len(), 0u);
- assert_eq!(e.len(), 0u);
+ assert_eq!(d.len(), 0);
+ assert_eq!(e.len(), 0);
}
#[test]
#[test]
fn test_show() {
- let ringbuf: RingBuf<i32> = (0..10).collect();
+ let ringbuf: RingBuf<_> = (0..10).collect();
assert_eq!(format!("{:?}", ringbuf), "RingBuf [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]");
- let ringbuf: RingBuf<&str> = vec!["just", "one", "test", "more"].iter()
- .map(|&s| s)
+ let ringbuf: RingBuf<_> = vec!["just", "one", "test", "more"].iter()
+ .cloned()
.collect();
assert_eq!(format!("{:?}", ringbuf), "RingBuf [\"just\", \"one\", \"test\", \"more\"]");
}
#[test]
fn test_drop() {
- static mut drops: uint = 0;
+ static mut drops: i32 = 0;
struct Elem;
impl Drop for Elem {
fn drop(&mut self) {
#[test]
fn test_drop_with_pop() {
- static mut drops: uint = 0;
+ static mut drops: i32 = 0;
struct Elem;
impl Drop for Elem {
fn drop(&mut self) {
#[test]
fn test_drop_clear() {
- static mut drops: uint = 0;
+ static mut drops: i32 = 0;
struct Elem;
impl Drop for Elem {
fn drop(&mut self) {
//! block of memory that a mutable slice points to:
//!
//! ```rust
-//! let x: &mut[int] = &mut [1, 2, 3];
+//! let x: &mut[i32] = &mut [1, 2, 3];
//! x[1] = 7;
//! assert_eq!(x[0], 1);
//! assert_eq!(x[1], 7);
/// ```
#[unstable(feature = "collections",
reason = "uncertain about this API approach")]
- fn move_from(&mut self, src: Vec<Self::Item>, start: uint, end: uint) -> uint;
+ fn move_from(&mut self, src: Vec<Self::Item>, start: usize, end: usize) -> usize;
/// Deprecated: use `&s[start .. end]` notation instead.
#[unstable(feature = "collections",
reason = "will be replaced by slice syntax")]
#[deprecated(since = "1.0.0", reason = "use &s[start .. end] instead")]
- fn slice(&self, start: uint, end: uint) -> &[Self::Item];
+ fn slice(&self, start: usize, end: usize) -> &[Self::Item];
/// Deprecated: use `&s[start..]` notation instead.
#[unstable(feature = "collections",
reason = "will be replaced by slice syntax")]
#[deprecated(since = "1.0.0", reason = "use &s[start..] instead")]
- fn slice_from(&self, start: uint) -> &[Self::Item];
+ fn slice_from(&self, start: usize) -> &[Self::Item];
/// Deprecated: use `&s[..end]` notation instead.
#[unstable(feature = "collections",
reason = "will be replaced by slice syntax")]
#[deprecated(since = "1.0.0", reason = "use &s[..end] instead")]
- fn slice_to(&self, end: uint) -> &[Self::Item];
+ fn slice_to(&self, end: usize) -> &[Self::Item];
/// Divides one slice into two at an index.
///
/// assert_eq!([30, 20, 50], v2);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- fn split_at(&self, mid: uint) -> (&[Self::Item], &[Self::Item]);
+ fn split_at(&self, mid: usize) -> (&[Self::Item], &[Self::Item]);
/// Returns an iterator over the slice.
#[stable(feature = "rust1", since = "1.0.0")]
/// }
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- fn splitn<F>(&self, n: uint, pred: F) -> SplitN<Self::Item, F>
+ fn splitn<F>(&self, n: usize, pred: F) -> SplitN<Self::Item, F>
where F: FnMut(&Self::Item) -> bool;
/// Returns an iterator over subslices separated by elements that match
/// }
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- fn rsplitn<F>(&self, n: uint, pred: F) -> RSplitN<Self::Item, F>
+ fn rsplitn<F>(&self, n: usize, pred: F) -> RSplitN<Self::Item, F>
where F: FnMut(&Self::Item) -> bool;
/// Returns an iterator over all contiguous windows of length
/// }
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- fn windows(&self, size: uint) -> Windows<Self::Item>;
+ fn windows(&self, size: usize) -> Windows<Self::Item>;
/// Returns an iterator over `size` elements of the slice at a
/// time. The chunks do not overlap. If `size` does not divide the
/// }
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- fn chunks(&self, size: uint) -> Chunks<Self::Item>;
+ fn chunks(&self, size: usize) -> Chunks<Self::Item>;
/// Returns the element of a slice at the given index, or `None` if the
/// index is out of bounds.
/// assert_eq!(None, v.get(3));
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- fn get(&self, index: uint) -> Option<&Self::Item>;
+ fn get(&self, index: usize) -> Option<&Self::Item>;
/// Returns the first element of a slice, or `None` if it is empty.
///
/// Returns a pointer to the element at the given index, without doing
/// bounds checking.
#[stable(feature = "rust1", since = "1.0.0")]
- unsafe fn get_unchecked(&self, index: uint) -> &Self::Item;
+ unsafe fn get_unchecked(&self, index: usize) -> &Self::Item;
/// Returns an unsafe pointer to the slice's buffer
///
/// assert!(match r { Ok(1...4) => true, _ => false, });
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- fn binary_search_by<F>(&self, f: F) -> Result<uint, uint> where
+ fn binary_search_by<F>(&self, f: F) -> Result<usize, usize> where
F: FnMut(&Self::Item) -> Ordering;
/// Return the number of elements in the slice
/// assert_eq!(a.len(), 3);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- fn len(&self) -> uint;
+ fn len(&self) -> usize;
/// Returns true if the slice has a length of 0
///
/// Returns a mutable reference to the element at the given index,
/// or `None` if the index is out of bounds
#[stable(feature = "rust1", since = "1.0.0")]
- fn get_mut(&mut self, index: uint) -> Option<&mut Self::Item>;
+ fn get_mut(&mut self, index: usize) -> Option<&mut Self::Item>;
/// Work with `self` as a mut slice.
/// Primarily intended for getting a &mut [T] from a [T; N].
#[unstable(feature = "collections",
reason = "will be replaced by slice syntax")]
#[deprecated(since = "1.0.0", reason = "use &mut s[start .. end] instead")]
- fn slice_mut(&mut self, start: uint, end: uint) -> &mut [Self::Item];
+ fn slice_mut(&mut self, start: usize, end: usize) -> &mut [Self::Item];
/// Deprecated: use `&mut s[start ..]` instead.
#[unstable(feature = "collections",
reason = "will be replaced by slice syntax")]
#[deprecated(since = "1.0.0", reason = "use &mut s[start ..] instead")]
- fn slice_from_mut(&mut self, start: uint) -> &mut [Self::Item];
+ fn slice_from_mut(&mut self, start: usize) -> &mut [Self::Item];
/// Deprecated: use `&mut s[.. end]` instead.
#[unstable(feature = "collections",
reason = "will be replaced by slice syntax")]
#[deprecated(since = "1.0.0", reason = "use &mut s[.. end] instead")]
- fn slice_to_mut(&mut self, end: uint) -> &mut [Self::Item];
+ fn slice_to_mut(&mut self, end: usize) -> &mut [Self::Item];
/// Returns an iterator that allows modifying each value
#[stable(feature = "rust1", since = "1.0.0")]
/// `pred`, limited to splitting at most `n` times. The matched element is
/// not contained in the subslices.
#[stable(feature = "rust1", since = "1.0.0")]
- fn splitn_mut<F>(&mut self, n: uint, pred: F) -> SplitNMut<Self::Item, F>
+ fn splitn_mut<F>(&mut self, n: usize, pred: F) -> SplitNMut<Self::Item, F>
where F: FnMut(&Self::Item) -> bool;
/// Returns an iterator over subslices separated by elements that match
/// the slice and works backwards. The matched element is not contained in
/// the subslices.
#[stable(feature = "rust1", since = "1.0.0")]
- fn rsplitn_mut<F>(&mut self, n: uint, pred: F) -> RSplitNMut<Self::Item, F>
+ fn rsplitn_mut<F>(&mut self, n: usize, pred: F) -> RSplitNMut<Self::Item, F>
where F: FnMut(&Self::Item) -> bool;
/// Returns an iterator over `chunk_size` elements of the slice at a time.
///
/// Panics if `chunk_size` is 0.
#[stable(feature = "rust1", since = "1.0.0")]
- fn chunks_mut(&mut self, chunk_size: uint) -> ChunksMut<Self::Item>;
+ fn chunks_mut(&mut self, chunk_size: usize) -> ChunksMut<Self::Item>;
/// Swaps two elements in a slice.
///
/// assert!(v == ["a", "d", "c", "b"]);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- fn swap(&mut self, a: uint, b: uint);
+ fn swap(&mut self, a: usize, b: usize);
/// Divides one `&mut` into two at an index.
///
/// }
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- fn split_at_mut(&mut self, mid: uint) -> (&mut [Self::Item], &mut [Self::Item]);
+ fn split_at_mut(&mut self, mid: usize) -> (&mut [Self::Item], &mut [Self::Item]);
/// Reverse the order of elements in a slice, in place.
///
/// Returns an unsafe mutable pointer to the element in index
#[stable(feature = "rust1", since = "1.0.0")]
- unsafe fn get_unchecked_mut(&mut self, index: uint) -> &mut Self::Item;
+ unsafe fn get_unchecked_mut(&mut self, index: usize) -> &mut Self::Item;
/// Return an unsafe mutable pointer to the slice's buffer.
///
/// assert!(dst == [3, 4, 5]);
/// ```
#[unstable(feature = "collections")]
- fn clone_from_slice(&mut self, &[Self::Item]) -> uint where Self::Item: Clone;
+ fn clone_from_slice(&mut self, &[Self::Item]) -> usize where Self::Item: Clone;
/// Sorts the slice, in place.
///
/// assert!(match r { Ok(1...4) => true, _ => false, });
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- fn binary_search(&self, x: &Self::Item) -> Result<uint, uint> where Self::Item: Ord;
+ fn binary_search(&self, x: &Self::Item) -> Result<usize, usize> where Self::Item: Ord;
/// Deprecated: use `binary_search` instead.
#[unstable(feature = "collections")]
#[deprecated(since = "1.0.0", reason = "use binary_search instead")]
- fn binary_search_elem(&self, x: &Self::Item) -> Result<uint, uint> where Self::Item: Ord {
+ fn binary_search_elem(&self, x: &Self::Item) -> Result<usize, usize> where Self::Item: Ord {
self.binary_search(x)
}
/// Find the first index containing a matching value.
#[unstable(feature = "collections")]
- fn position_elem(&self, t: &Self::Item) -> Option<uint> where Self::Item: PartialEq;
+ fn position_elem(&self, t: &Self::Item) -> Option<usize> where Self::Item: PartialEq;
/// Find the last index containing a matching value.
#[unstable(feature = "collections")]
- fn rposition_elem(&self, t: &Self::Item) -> Option<uint> where Self::Item: PartialEq;
+ fn rposition_elem(&self, t: &Self::Item) -> Option<usize> where Self::Item: PartialEq;
/// Returns true if the slice contains an element with the given value.
///
}
#[inline]
- fn move_from(&mut self, mut src: Vec<T>, start: uint, end: uint) -> uint {
+ fn move_from(&mut self, mut src: Vec<T>, start: usize, end: usize) -> usize {
for (a, b) in self.iter_mut().zip(src[start .. end].iter_mut()) {
mem::swap(a, b);
}
}
#[inline]
- fn slice<'a>(&'a self, start: uint, end: uint) -> &'a [T] {
+ fn slice<'a>(&'a self, start: usize, end: usize) -> &'a [T] {
&self[start .. end]
}
#[inline]
- fn slice_from<'a>(&'a self, start: uint) -> &'a [T] {
+ fn slice_from<'a>(&'a self, start: usize) -> &'a [T] {
&self[start ..]
}
#[inline]
- fn slice_to<'a>(&'a self, end: uint) -> &'a [T] {
+ fn slice_to<'a>(&'a self, end: usize) -> &'a [T] {
&self[.. end]
}
#[inline]
- fn split_at<'a>(&'a self, mid: uint) -> (&'a [T], &'a [T]) {
+ fn split_at<'a>(&'a self, mid: usize) -> (&'a [T], &'a [T]) {
core_slice::SliceExt::split_at(self, mid)
}
}
#[inline]
- fn splitn<F>(&self, n: uint, pred: F) -> SplitN<T, F>
+ fn splitn<F>(&self, n: usize, pred: F) -> SplitN<T, F>
where F: FnMut(&T) -> bool {
core_slice::SliceExt::splitn(self, n, pred)
}
#[inline]
- fn rsplitn<F>(&self, n: uint, pred: F) -> RSplitN<T, F>
+ fn rsplitn<F>(&self, n: usize, pred: F) -> RSplitN<T, F>
where F: FnMut(&T) -> bool {
core_slice::SliceExt::rsplitn(self, n, pred)
}
#[inline]
- fn windows<'a>(&'a self, size: uint) -> Windows<'a, T> {
+ fn windows<'a>(&'a self, size: usize) -> Windows<'a, T> {
core_slice::SliceExt::windows(self, size)
}
#[inline]
- fn chunks<'a>(&'a self, size: uint) -> Chunks<'a, T> {
+ fn chunks<'a>(&'a self, size: usize) -> Chunks<'a, T> {
core_slice::SliceExt::chunks(self, size)
}
#[inline]
- fn get<'a>(&'a self, index: uint) -> Option<&'a T> {
+ fn get<'a>(&'a self, index: usize) -> Option<&'a T> {
core_slice::SliceExt::get(self, index)
}
}
#[inline]
- unsafe fn get_unchecked<'a>(&'a self, index: uint) -> &'a T {
+ unsafe fn get_unchecked<'a>(&'a self, index: usize) -> &'a T {
core_slice::SliceExt::get_unchecked(self, index)
}
}
#[inline]
- fn binary_search_by<F>(&self, f: F) -> Result<uint, uint>
+ fn binary_search_by<F>(&self, f: F) -> Result<usize, usize>
where F: FnMut(&T) -> Ordering {
core_slice::SliceExt::binary_search_by(self, f)
}
#[inline]
- fn len(&self) -> uint {
+ fn len(&self) -> usize {
core_slice::SliceExt::len(self)
}
}
#[inline]
- fn get_mut<'a>(&'a mut self, index: uint) -> Option<&'a mut T> {
+ fn get_mut<'a>(&'a mut self, index: usize) -> Option<&'a mut T> {
core_slice::SliceExt::get_mut(self, index)
}
}
#[inline]
- fn slice_mut<'a>(&'a mut self, start: uint, end: uint) -> &'a mut [T] {
+ fn slice_mut<'a>(&'a mut self, start: usize, end: usize) -> &'a mut [T] {
&mut self[start .. end]
}
#[inline]
- fn slice_from_mut<'a>(&'a mut self, start: uint) -> &'a mut [T] {
+ fn slice_from_mut<'a>(&'a mut self, start: usize) -> &'a mut [T] {
&mut self[start ..]
}
#[inline]
- fn slice_to_mut<'a>(&'a mut self, end: uint) -> &'a mut [T] {
+ fn slice_to_mut<'a>(&'a mut self, end: usize) -> &'a mut [T] {
&mut self[.. end]
}
}
#[inline]
- fn splitn_mut<F>(&mut self, n: uint, pred: F) -> SplitNMut<T, F>
+ fn splitn_mut<F>(&mut self, n: usize, pred: F) -> SplitNMut<T, F>
where F: FnMut(&T) -> bool {
core_slice::SliceExt::splitn_mut(self, n, pred)
}
#[inline]
- fn rsplitn_mut<F>(&mut self, n: uint, pred: F) -> RSplitNMut<T, F>
+ fn rsplitn_mut<F>(&mut self, n: usize, pred: F) -> RSplitNMut<T, F>
where F: FnMut(&T) -> bool {
core_slice::SliceExt::rsplitn_mut(self, n, pred)
}
#[inline]
- fn chunks_mut<'a>(&'a mut self, chunk_size: uint) -> ChunksMut<'a, T> {
+ fn chunks_mut<'a>(&'a mut self, chunk_size: usize) -> ChunksMut<'a, T> {
core_slice::SliceExt::chunks_mut(self, chunk_size)
}
#[inline]
- fn swap(&mut self, a: uint, b: uint) {
+ fn swap(&mut self, a: usize, b: usize) {
core_slice::SliceExt::swap(self, a, b)
}
#[inline]
- fn split_at_mut<'a>(&'a mut self, mid: uint) -> (&'a mut [T], &'a mut [T]) {
+ fn split_at_mut<'a>(&'a mut self, mid: usize) -> (&'a mut [T], &'a mut [T]) {
core_slice::SliceExt::split_at_mut(self, mid)
}
}
#[inline]
- unsafe fn get_unchecked_mut<'a>(&'a mut self, index: uint) -> &'a mut T {
+ unsafe fn get_unchecked_mut<'a>(&'a mut self, index: usize) -> &'a mut T {
core_slice::SliceExt::get_unchecked_mut(self, index)
}
}
}
- fn clone_from_slice(&mut self, src: &[T]) -> uint where T: Clone {
+ fn clone_from_slice(&mut self, src: &[T]) -> usize where T: Clone {
core_slice::SliceExt::clone_from_slice(self, src)
}
self.sort_by(|a, b| a.cmp(b))
}
- fn binary_search(&self, x: &T) -> Result<uint, uint> where T: Ord {
+ fn binary_search(&self, x: &T) -> Result<usize, usize> where T: Ord {
core_slice::SliceExt::binary_search(self, x)
}
core_slice::SliceExt::prev_permutation(self)
}
- fn position_elem(&self, t: &T) -> Option<uint> where T: PartialEq {
+ fn position_elem(&self, t: &T) -> Option<usize> where T: PartialEq {
core_slice::SliceExt::position_elem(self, t)
}
- fn rposition_elem(&self, t: &T) -> Option<uint> where T: PartialEq {
+ fn rposition_elem(&self, t: &T) -> Option<usize> where T: PartialEq {
core_slice::SliceExt::rposition_elem(self, t)
}
/// If `true`, emit the last swap that returns the sequence to initial
/// state.
emit_reset: bool,
- swaps_made : uint,
+ swaps_made : usize,
}
impl ElementSwaps {
/// Creates an `ElementSwaps` iterator for a sequence of `length` elements.
#[unstable(feature = "collections")]
- pub fn new(length: uint) -> ElementSwaps {
+ pub fn new(length: usize) -> ElementSwaps {
// Initialize `sdir` with a direction that position should move in
// (all negative at the beginning) and the `size` of the
// element (equal to the original index).
/// An `Index` and `Direction` together.
#[derive(Copy, Clone)]
struct SizeDirection {
- size: uint,
+ size: usize,
dir: Direction,
}
#[stable(feature = "rust1", since = "1.0.0")]
impl Iterator for ElementSwaps {
- type Item = (uint, uint);
+ type Item = (usize, usize);
#[inline]
- fn next(&mut self) -> Option<(uint, uint)> {
- fn new_pos(i: uint, s: Direction) -> uint {
+ fn next(&mut self) -> Option<(usize, usize)> {
+ fn new_pos(i: usize, s: Direction) -> usize {
i + match s { Pos => 1, Neg => -1 }
}
}
#[inline]
- fn size_hint(&self) -> (uint, Option<uint>) {
+ fn size_hint(&self) -> (usize, Option<usize>) {
// For a vector of size n, there are exactly n! permutations.
let n = (2..self.sdir.len() + 1).product();
(n - self.swaps_made, Some(n - self.swaps_made))
}
#[inline]
- fn size_hint(&self) -> (uint, Option<uint>) {
+ fn size_hint(&self) -> (usize, Option<usize>) {
self.swaps.size_hint()
}
}
let tmp = ptr::read(read_ptr);
ptr::copy_memory(buf_v.offset(j + 1),
&*buf_v.offset(j),
- (i - j) as uint);
+ (i - j) as usize);
ptr::copy_nonoverlapping_memory(buf_v.offset(j),
&tmp,
1);
fn merge_sort<T, F>(v: &mut [T], mut compare: F) where F: FnMut(&T, &T) -> Ordering {
// warning: this wildly uses unsafe.
- static BASE_INSERTION: uint = 32;
- static LARGE_INSERTION: uint = 16;
+ static BASE_INSERTION: usize = 32;
+ static LARGE_INSERTION: usize = 16;
// FIXME #12092: smaller insertion runs seems to make sorting
// vectors of large elements a little faster on some platforms,
// `.offset(j)` is always in bounds.
ptr::copy_memory(buf_dat.offset(j + 1),
&*buf_dat.offset(j),
- i - j as uint);
+ i - j as usize);
ptr::copy_nonoverlapping_memory(buf_dat.offset(j), read_ptr, 1);
}
}
// case).
if left == right_start {
// the number remaining in this run.
- let elems = (right_end as uint - right as uint) / mem::size_of::<T>();
+ let elems = (right_end as usize - right as usize) / mem::size_of::<T>();
ptr::copy_nonoverlapping_memory(out, &*right, elems);
break;
} else if right == right_end {
- let elems = (right_start as uint - left as uint) / mem::size_of::<T>();
+ let elems = (right_start as usize - left as usize) / mem::size_of::<T>();
ptr::copy_nonoverlapping_memory(out, &*left, elems);
break;
}
#[cfg(test)]
mod tests {
use core::cmp::Ordering::{Greater, Less, Equal};
- use core::prelude::{Some, None, range, Clone};
+ use core::prelude::{Some, None, Clone};
use core::prelude::{Iterator, IteratorExt};
use core::prelude::{AsSlice};
use core::prelude::Ord;
use vec::Vec;
use super::{ElementSwaps, SliceConcatExt, SliceExt};
- fn square(n: uint) -> uint { n * n }
+ fn square(n: usize) -> usize { n * n }
- fn is_odd(n: &uint) -> bool { *n % 2u == 1u }
+ fn is_odd(n: &usize) -> bool { *n % 2 == 1 }
#[test]
fn test_from_fn() {
// Test on-stack from_fn.
- let mut v = (0u..3).map(square).collect::<Vec<_>>();
+ let mut v: Vec<_> = (0..3).map(square).collect();
{
let v = v;
- assert_eq!(v.len(), 3u);
- assert_eq!(v[0], 0u);
- assert_eq!(v[1], 1u);
- assert_eq!(v[2], 4u);
+ assert_eq!(v.len(), 3);
+ assert_eq!(v[0], 0);
+ assert_eq!(v[1], 1);
+ assert_eq!(v[2], 4);
}
// Test on-heap from_fn.
- v = (0u..5).map(square).collect::<Vec<_>>();
+ v = (0..5).map(square).collect();
{
let v = v;
- assert_eq!(v.len(), 5u);
- assert_eq!(v[0], 0u);
- assert_eq!(v[1], 1u);
- assert_eq!(v[2], 4u);
- assert_eq!(v[3], 9u);
- assert_eq!(v[4], 16u);
+ assert_eq!(v.len(), 5);
+ assert_eq!(v[0], 0);
+ assert_eq!(v[1], 1);
+ assert_eq!(v[2], 4);
+ assert_eq!(v[3], 9);
+ assert_eq!(v[4], 16);
}
}
#[test]
fn test_from_elem() {
// Test on-stack from_elem.
- let mut v = vec![10u, 10u];
+ let mut v = vec![10, 10];
{
let v = v;
- assert_eq!(v.len(), 2u);
- assert_eq!(v[0], 10u);
- assert_eq!(v[1], 10u);
+ assert_eq!(v.len(), 2);
+ assert_eq!(v[0], 10);
+ assert_eq!(v[1], 10);
}
// Test on-heap from_elem.
- v = vec![20u, 20u, 20u, 20u, 20u, 20u];
+ v = vec![20; 6];
{
- let v = v;
- assert_eq!(v[0], 20u);
- assert_eq!(v[1], 20u);
- assert_eq!(v[2], 20u);
- assert_eq!(v[3], 20u);
- assert_eq!(v[4], 20u);
- assert_eq!(v[5], 20u);
+ let v = v.as_slice();
+ assert_eq!(v[0], 20);
+ assert_eq!(v[1], 20);
+ assert_eq!(v[2], 20);
+ assert_eq!(v[3], 20);
+ assert_eq!(v[4], 20);
+ assert_eq!(v[5], 20);
}
}
#[test]
fn test_tail() {
let mut a = vec![11];
- let b: &[int] = &[];
+ let b: &[i32] = &[];
assert_eq!(a.tail(), b);
a = vec![11, 12];
- let b: &[int] = &[12];
+ let b: &[i32] = &[12];
assert_eq!(a.tail(), b);
}
#[test]
fn test_tail_mut() {
let mut a = vec![11];
- let b: &mut [int] = &mut [];
+ let b: &mut [i32] = &mut [];
assert!(a.tail_mut() == b);
a = vec![11, 12];
- let b: &mut [int] = &mut [12];
+ let b: &mut [_] = &mut [12];
assert!(a.tail_mut() == b);
}
#[test]
#[should_fail]
fn test_tail_empty() {
- let a: Vec<int> = vec![];
+ let a = Vec::<i32>::new();
a.tail();
}
#[test]
#[should_fail]
fn test_tail_mut_empty() {
- let mut a: Vec<int> = vec![];
+ let mut a = Vec::<i32>::new();
a.tail_mut();
}
#[test]
fn test_init() {
let mut a = vec![11];
- let b: &[int] = &[];
+ let b: &[i32] = &[];
assert_eq!(a.init(), b);
a = vec![11, 12];
- let b: &[int] = &[11];
+ let b: &[_] = &[11];
assert_eq!(a.init(), b);
}
#[test]
fn test_init_mut() {
let mut a = vec![11];
- let b: &mut [int] = &mut [];
+ let b: &mut [i32] = &mut [];
assert!(a.init_mut() == b);
a = vec![11, 12];
- let b: &mut [int] = &mut [11];
+ let b: &mut [_] = &mut [11];
assert!(a.init_mut() == b);
}
#[test]
#[should_fail]
fn test_init_empty() {
- let a: Vec<int> = vec![];
+ let a = Vec::<i32>::new();
a.init();
}
#[test]
#[should_fail]
fn test_init_mut_empty() {
- let mut a: Vec<int> = vec![];
+ let mut a = Vec::<i32>::new();
a.init_mut();
}
fn test_slice() {
// Test fixed length vector.
let vec_fixed = [1, 2, 3, 4];
- let v_a = vec_fixed[1u..vec_fixed.len()].to_vec();
- assert_eq!(v_a.len(), 3u);
- let v_a = v_a;
+ let v_a = vec_fixed[1..vec_fixed.len()].to_vec();
+ assert_eq!(v_a.len(), 3);
+
assert_eq!(v_a[0], 2);
assert_eq!(v_a[1], 3);
assert_eq!(v_a[2], 4);
// Test on stack.
let vec_stack: &[_] = &[1, 2, 3];
- let v_b = vec_stack[1u..3u].to_vec();
- assert_eq!(v_b.len(), 2u);
- let v_b = v_b;
+ let v_b = vec_stack[1..3].to_vec();
+ assert_eq!(v_b.len(), 2);
+
assert_eq!(v_b[0], 2);
assert_eq!(v_b[1], 3);
// Test `Box<[T]>`
let vec_unique = vec![1, 2, 3, 4, 5, 6];
- let v_d = vec_unique[1u..6u].to_vec();
- assert_eq!(v_d.len(), 5u);
- let v_d = v_d;
+ let v_d = vec_unique[1..6].to_vec();
+ assert_eq!(v_d.len(), 5);
+
assert_eq!(v_d[0], 2);
assert_eq!(v_d[1], 3);
assert_eq!(v_d[2], 4);
#[test]
fn test_slice_from() {
- let vec: &[int] = &[1, 2, 3, 4];
+ let vec: &[_] = &[1, 2, 3, 4];
assert_eq!(&vec[], vec);
- let b: &[int] = &[3, 4];
+ let b: &[_] = &[3, 4];
assert_eq!(&vec[2..], b);
- let b: &[int] = &[];
+ let b: &[_] = &[];
assert_eq!(&vec[4..], b);
}
#[test]
fn test_slice_to() {
- let vec: &[int] = &[1, 2, 3, 4];
+ let vec: &[_] = &[1, 2, 3, 4];
assert_eq!(&vec[..4], vec);
- let b: &[int] = &[1, 2];
+ let b: &[_] = &[1, 2];
assert_eq!(&vec[..2], b);
- let b: &[int] = &[];
+ let b: &[_] = &[];
assert_eq!(&vec[..0], b);
}
// Test on-stack push().
let mut v = vec![];
v.push(1);
- assert_eq!(v.len(), 1u);
+ assert_eq!(v.len(), 1);
assert_eq!(v[0], 1);
// Test on-heap push().
v.push(2);
- assert_eq!(v.len(), 2u);
+ assert_eq!(v.len(), 2);
assert_eq!(v[0], 1);
assert_eq!(v[1], 2);
}
#[test]
fn test_dedup() {
- fn case(a: Vec<uint>, b: Vec<uint>) {
+ fn case(a: Vec<i32>, b: Vec<i32>) {
let mut v = a;
v.dedup();
assert_eq!(v, b);
}
case(vec![], vec![]);
- case(vec![1u], vec![1]);
- case(vec![1u,1], vec![1]);
- case(vec![1u,2,3], vec![1,2,3]);
- case(vec![1u,1,2,3], vec![1,2,3]);
- case(vec![1u,2,2,3], vec![1,2,3]);
- case(vec![1u,2,3,3], vec![1,2,3]);
- case(vec![1u,1,2,2,2,3,3], vec![1,2,3]);
+ case(vec![1], vec![1]);
+ case(vec![1,1], vec![1]);
+ case(vec![1,2,3], vec![1,2,3]);
+ case(vec![1,1,2,3], vec![1,2,3]);
+ case(vec![1,2,2,3], vec![1,2,3]);
+ case(vec![1,2,3,3], vec![1,2,3]);
+ case(vec![1,1,2,2,2,3,3], vec![1,2,3]);
}
#[test]
#[test]
fn test_retain() {
- let mut v = vec![1u, 2, 3, 4, 5];
+ let mut v = vec![1, 2, 3, 4, 5];
v.retain(is_odd);
- assert_eq!(v, vec![1u, 3, 5]);
+ assert_eq!(v, vec![1, 3, 5]);
}
#[test]
#[test]
fn test_lexicographic_permutations() {
- let v : &mut[int] = &mut[1, 2, 3, 4, 5];
+ let v : &mut[_] = &mut[1, 2, 3, 4, 5];
assert!(v.prev_permutation() == false);
assert!(v.next_permutation());
- let b: &mut[int] = &mut[1, 2, 3, 5, 4];
+ let b: &mut[_] = &mut[1, 2, 3, 5, 4];
assert!(v == b);
assert!(v.prev_permutation());
- let b: &mut[int] = &mut[1, 2, 3, 4, 5];
+ let b: &mut[_] = &mut[1, 2, 3, 4, 5];
assert!(v == b);
assert!(v.next_permutation());
assert!(v.next_permutation());
- let b: &mut[int] = &mut[1, 2, 4, 3, 5];
+ let b: &mut[_] = &mut[1, 2, 4, 3, 5];
assert!(v == b);
assert!(v.next_permutation());
- let b: &mut[int] = &mut[1, 2, 4, 5, 3];
+ let b: &mut[_] = &mut[1, 2, 4, 5, 3];
assert!(v == b);
- let v : &mut[int] = &mut[1, 0, 0, 0];
+ let v : &mut[_] = &mut[1, 0, 0, 0];
assert!(v.next_permutation() == false);
assert!(v.prev_permutation());
- let b: &mut[int] = &mut[0, 1, 0, 0];
+ let b: &mut[_] = &mut[0, 1, 0, 0];
assert!(v == b);
assert!(v.prev_permutation());
- let b: &mut[int] = &mut[0, 0, 1, 0];
+ let b: &mut[_] = &mut[0, 0, 1, 0];
assert!(v == b);
assert!(v.prev_permutation());
- let b: &mut[int] = &mut[0, 0, 0, 1];
+ let b: &mut[_] = &mut[0, 0, 0, 1];
assert!(v == b);
assert!(v.prev_permutation() == false);
}
#[test]
fn test_lexicographic_permutations_empty_and_short() {
- let empty : &mut[int] = &mut[];
+ let empty : &mut[i32] = &mut[];
assert!(empty.next_permutation() == false);
- let b: &mut[int] = &mut[];
+ let b: &mut[i32] = &mut[];
assert!(empty == b);
assert!(empty.prev_permutation() == false);
assert!(empty == b);
- let one_elem : &mut[int] = &mut[4];
+ let one_elem : &mut[_] = &mut[4];
assert!(one_elem.prev_permutation() == false);
- let b: &mut[int] = &mut[4];
+ let b: &mut[_] = &mut[4];
assert!(one_elem == b);
assert!(one_elem.next_permutation() == false);
assert!(one_elem == b);
- let two_elem : &mut[int] = &mut[1, 2];
+ let two_elem : &mut[_] = &mut[1, 2];
assert!(two_elem.prev_permutation() == false);
- let b : &mut[int] = &mut[1, 2];
- let c : &mut[int] = &mut[2, 1];
+ let b : &mut[_] = &mut[1, 2];
+ let c : &mut[_] = &mut[2, 1];
assert!(two_elem == b);
assert!(two_elem.next_permutation());
assert!(two_elem == c);
assert!([].position_elem(&1).is_none());
let v1 = vec![1, 2, 3, 3, 2, 5];
- assert_eq!(v1.position_elem(&1), Some(0u));
- assert_eq!(v1.position_elem(&2), Some(1u));
- assert_eq!(v1.position_elem(&5), Some(5u));
+ assert_eq!(v1.position_elem(&1), Some(0));
+ assert_eq!(v1.position_elem(&2), Some(1));
+ assert_eq!(v1.position_elem(&5), Some(5));
assert!(v1.position_elem(&4).is_none());
}
#[test]
fn test_reverse() {
- let mut v: Vec<int> = vec![10, 20];
+ let mut v = vec![10, 20];
assert_eq!(v[0], 10);
assert_eq!(v[1], 20);
v.reverse();
assert_eq!(v[0], 20);
assert_eq!(v[1], 10);
- let mut v3: Vec<int> = vec![];
+ let mut v3 = Vec::<i32>::new();
v3.reverse();
assert!(v3.is_empty());
}
#[test]
fn test_sort() {
- for len in 4u..25 {
+ for len in 4..25 {
for _ in 0..100 {
- let mut v = thread_rng().gen_iter::<uint>().take(len)
- .collect::<Vec<uint>>();
+ let mut v: Vec<_> = thread_rng().gen_iter::<i32>().take(len).collect();
let mut v1 = v.clone();
v.sort();
}
// shouldn't panic
- let mut v: [uint; 0] = [];
+ let mut v: [i32; 0] = [];
v.sort();
- let mut v = [0xDEADBEEFu];
+ let mut v = [0xDEADBEEFu64];
v.sort();
assert!(v == [0xDEADBEEF]);
}
#[test]
fn test_sort_stability() {
for len in 4..25 {
- for _ in 0u..10 {
+ for _ in 0..10 {
let mut counts = [0; 10];
// create a vector like [(6, 1), (5, 1), (6, 2), ...],
// the second item represents which occurrence of that
// number this element is, i.e. the second elements
// will occur in sorted order.
- let mut v = (0..len).map(|_| {
- let n = thread_rng().gen::<uint>() % 10;
+ let mut v: Vec<_> = (0..len).map(|_| {
+ let n = thread_rng().gen::<usize>() % 10;
counts[n] += 1;
(n, counts[n])
- }).collect::<Vec<(uint, int)>>();
+ }).collect();
// only sort on the first element, so an unstable sort
// may mix up the counts.
#[test]
fn test_concat() {
- let v: [Vec<int>; 0] = [];
- let c: Vec<int> = v.concat();
+ let v: [Vec<i32>; 0] = [];
+ let c = v.concat();
assert_eq!(c, []);
- let d: Vec<int> = [vec![1], vec![2,3]].concat();
+ let d = [vec![1], vec![2,3]].concat();
assert_eq!(d, vec![1, 2, 3]);
- let v: [&[int]; 2] = [&[1], &[2, 3]];
+ let v: &[&[_]] = &[&[1], &[2, 3]];
assert_eq!(v.connect(&0), vec![1, 0, 2, 3]);
- let v: [&[int]; 3] = [&[1], &[2], &[3]];
+ let v: &[&[_]] = &[&[1], &[2], &[3]];
assert_eq!(v.connect(&0), vec![1, 0, 2, 0, 3]);
}
#[test]
fn test_connect() {
- let v: [Vec<int>; 0] = [];
+ let v: [Vec<i32>; 0] = [];
assert_eq!(v.connect(&0), vec![]);
assert_eq!([vec![1], vec![2, 3]].connect(&0), vec![1, 0, 2, 3]);
assert_eq!([vec![1], vec![2], vec![3]].connect(&0), vec![1, 0, 2, 0, 3]);
- let v: [&[int]; 2] = [&[1], &[2, 3]];
+ let v: [&[_]; 2] = [&[1], &[2, 3]];
assert_eq!(v.connect(&0), vec![1, 0, 2, 3]);
- let v: [&[int]; 3] = [&[1], &[2], &[3]];
+ let v: [&[_]; 3] = [&[1], &[2], &[3]];
assert_eq!(v.connect(&0), vec![1, 0, 2, 0, 3]);
}
#[test]
fn test_remove() {
- let mut a = vec![1,2,3,4];
+ let mut a = vec![1, 2, 3, 4];
assert_eq!(a.remove(2), 3);
- assert_eq!(a, vec![1,2,4]);
+ assert_eq!(a, vec![1, 2, 4]);
assert_eq!(a.remove(2), 4);
- assert_eq!(a, vec![1,2]);
+ assert_eq!(a, vec![1, 2]);
assert_eq!(a.remove(0), 1);
assert_eq!(a, vec![2]);
#[test]
fn test_capacity() {
- let mut v = vec![0u64];
- v.reserve_exact(10u);
- assert!(v.capacity() >= 11u);
- let mut v = vec![0u32];
- v.reserve_exact(10u);
- assert!(v.capacity() >= 11u);
+ let mut v = vec![0];
+ v.reserve_exact(10);
+ assert!(v.capacity() >= 11);
}
#[test]
fn test_slice_2() {
let v = vec![1, 2, 3, 4, 5];
- let v = v.slice(1u, 3u);
- assert_eq!(v.len(), 2u);
+ let v = v.slice(1, 3);
+ assert_eq!(v.len(), 2);
assert_eq!(v[0], 2);
assert_eq!(v[1], 3);
}
fn test_permute_fail() {
let v = [(box 0, Rc::new(0)), (box 0, Rc::new(0)),
(box 0, Rc::new(0)), (box 0, Rc::new(0))];
- let mut i = 0u;
+ let mut i = 0;
for _ in v.permutations() {
if i == 2 {
panic!()
#[test]
fn test_total_ord() {
- let c: &[int] = &[1, 2, 3];
+ let c = &[1, 2, 3];
[1, 2, 3, 4][].cmp(c) == Greater;
- let c: &[int] = &[1, 2, 3, 4];
+ let c = &[1, 2, 3, 4];
[1, 2, 3][].cmp(c) == Less;
- let c: &[int] = &[1, 2, 3, 6];
+ let c = &[1, 2, 3, 6];
[1, 2, 3, 4][].cmp(c) == Equal;
- let c: &[int] = &[1, 2, 3, 4, 5, 6];
+ let c = &[1, 2, 3, 4, 5, 6];
[1, 2, 3, 4, 5, 5, 5, 5][].cmp(c) == Less;
- let c: &[int] = &[1, 2, 3, 4];
+ let c = &[1, 2, 3, 4];
[2, 2][].cmp(c) == Greater;
}
#[test]
fn test_move_iterator() {
let xs = vec![1u,2,3,4,5];
- assert_eq!(xs.into_iter().fold(0, |a: uint, b: uint| 10*a + b), 12345);
+ assert_eq!(xs.into_iter().fold(0, |a: usize, b: usize| 10*a + b), 12345);
}
#[test]
fn test_move_rev_iterator() {
let xs = vec![1u,2,3,4,5];
- assert_eq!(xs.into_iter().rev().fold(0, |a: uint, b: uint| 10*a + b), 54321);
+ assert_eq!(xs.into_iter().rev().fold(0, |a: usize, b: usize| 10*a + b), 54321);
}
#[test]
fn test_splitator() {
let xs = &[1,2,3,4,5];
- let splits: &[&[int]] = &[&[1], &[3], &[5]];
- assert_eq!(xs.split(|x| *x % 2 == 0).collect::<Vec<&[int]>>(),
+ let splits: &[&[_]] = &[&[1], &[3], &[5]];
+ assert_eq!(xs.split(|x| *x % 2 == 0).collect::<Vec<_>>(),
splits);
- let splits: &[&[int]] = &[&[], &[2,3,4,5]];
- assert_eq!(xs.split(|x| *x == 1).collect::<Vec<&[int]>>(),
+ let splits: &[&[_]] = &[&[], &[2,3,4,5]];
+ assert_eq!(xs.split(|x| *x == 1).collect::<Vec<_>>(),
splits);
- let splits: &[&[int]] = &[&[1,2,3,4], &[]];
- assert_eq!(xs.split(|x| *x == 5).collect::<Vec<&[int]>>(),
+ let splits: &[&[_]] = &[&[1,2,3,4], &[]];
+ assert_eq!(xs.split(|x| *x == 5).collect::<Vec<_>>(),
splits);
- let splits: &[&[int]] = &[&[1,2,3,4,5]];
- assert_eq!(xs.split(|x| *x == 10).collect::<Vec<&[int]>>(),
+ let splits: &[&[_]] = &[&[1,2,3,4,5]];
+ assert_eq!(xs.split(|x| *x == 10).collect::<Vec<_>>(),
splits);
- let splits: &[&[int]] = &[&[], &[], &[], &[], &[], &[]];
- assert_eq!(xs.split(|_| true).collect::<Vec<&[int]>>(),
+ let splits: &[&[_]] = &[&[], &[], &[], &[], &[], &[]];
+ assert_eq!(xs.split(|_| true).collect::<Vec<&[i32]>>(),
splits);
- let xs: &[int] = &[];
- let splits: &[&[int]] = &[&[]];
- assert_eq!(xs.split(|x| *x == 5).collect::<Vec<&[int]>>(), splits);
+ let xs: &[i32] = &[];
+ let splits: &[&[i32]] = &[&[]];
+ assert_eq!(xs.split(|x| *x == 5).collect::<Vec<&[i32]>>(), splits);
}
#[test]
fn test_splitnator() {
let xs = &[1,2,3,4,5];
- let splits: &[&[int]] = &[&[1,2,3,4,5]];
- assert_eq!(xs.splitn(0, |x| *x % 2 == 0).collect::<Vec<&[int]>>(),
+ let splits: &[&[_]] = &[&[1,2,3,4,5]];
+ assert_eq!(xs.splitn(0, |x| *x % 2 == 0).collect::<Vec<_>>(),
splits);
- let splits: &[&[int]] = &[&[1], &[3,4,5]];
- assert_eq!(xs.splitn(1, |x| *x % 2 == 0).collect::<Vec<&[int]>>(),
+ let splits: &[&[_]] = &[&[1], &[3,4,5]];
+ assert_eq!(xs.splitn(1, |x| *x % 2 == 0).collect::<Vec<_>>(),
splits);
- let splits: &[&[int]] = &[&[], &[], &[], &[4,5]];
- assert_eq!(xs.splitn(3, |_| true).collect::<Vec<&[int]>>(),
+ let splits: &[&[_]] = &[&[], &[], &[], &[4,5]];
+ assert_eq!(xs.splitn(3, |_| true).collect::<Vec<_>>(),
splits);
- let xs: &[int] = &[];
- let splits: &[&[int]] = &[&[]];
- assert_eq!(xs.splitn(1, |x| *x == 5).collect::<Vec<&[int]>>(), splits);
+ let xs: &[i32] = &[];
+ let splits: &[&[i32]] = &[&[]];
+ assert_eq!(xs.splitn(1, |x| *x == 5).collect::<Vec<_>>(), splits);
}
#[test]
fn test_splitnator_mut() {
let xs = &mut [1,2,3,4,5];
- let splits: &[&mut [int]] = &[&mut [1,2,3,4,5]];
- assert_eq!(xs.splitn_mut(0, |x| *x % 2 == 0).collect::<Vec<&mut [int]>>(),
+ let splits: &[&mut[_]] = &[&mut [1,2,3,4,5]];
+ assert_eq!(xs.splitn_mut(0, |x| *x % 2 == 0).collect::<Vec<_>>(),
splits);
- let splits: &[&mut [int]] = &[&mut [1], &mut [3,4,5]];
- assert_eq!(xs.splitn_mut(1, |x| *x % 2 == 0).collect::<Vec<&mut [int]>>(),
+ let splits: &[&mut[_]] = &[&mut [1], &mut [3,4,5]];
+ assert_eq!(xs.splitn_mut(1, |x| *x % 2 == 0).collect::<Vec<_>>(),
splits);
- let splits: &[&mut [int]] = &[&mut [], &mut [], &mut [], &mut [4,5]];
- assert_eq!(xs.splitn_mut(3, |_| true).collect::<Vec<&mut [int]>>(),
+ let splits: &[&mut[_]] = &[&mut [], &mut [], &mut [], &mut [4,5]];
+ assert_eq!(xs.splitn_mut(3, |_| true).collect::<Vec<_>>(),
splits);
- let xs: &mut [int] = &mut [];
- let splits: &[&mut [int]] = &[&mut []];
- assert_eq!(xs.splitn_mut(1, |x| *x == 5).collect::<Vec<&mut [int]>>(),
+ let xs: &mut [i32] = &mut [];
+ let splits: &[&mut[i32]] = &[&mut []];
+ assert_eq!(xs.splitn_mut(1, |x| *x == 5).collect::<Vec<_>>(),
splits);
}
fn test_rsplitator() {
let xs = &[1,2,3,4,5];
- let splits: &[&[int]] = &[&[5], &[3], &[1]];
- assert_eq!(xs.split(|x| *x % 2 == 0).rev().collect::<Vec<&[int]>>(),
+ let splits: &[&[_]] = &[&[5], &[3], &[1]];
+ assert_eq!(xs.split(|x| *x % 2 == 0).rev().collect::<Vec<_>>(),
splits);
- let splits: &[&[int]] = &[&[2,3,4,5], &[]];
- assert_eq!(xs.split(|x| *x == 1).rev().collect::<Vec<&[int]>>(),
+ let splits: &[&[_]] = &[&[2,3,4,5], &[]];
+ assert_eq!(xs.split(|x| *x == 1).rev().collect::<Vec<_>>(),
splits);
- let splits: &[&[int]] = &[&[], &[1,2,3,4]];
- assert_eq!(xs.split(|x| *x == 5).rev().collect::<Vec<&[int]>>(),
+ let splits: &[&[_]] = &[&[], &[1,2,3,4]];
+ assert_eq!(xs.split(|x| *x == 5).rev().collect::<Vec<_>>(),
splits);
- let splits: &[&[int]] = &[&[1,2,3,4,5]];
- assert_eq!(xs.split(|x| *x == 10).rev().collect::<Vec<&[int]>>(),
+ let splits: &[&[_]] = &[&[1,2,3,4,5]];
+ assert_eq!(xs.split(|x| *x == 10).rev().collect::<Vec<_>>(),
splits);
- let xs: &[int] = &[];
- let splits: &[&[int]] = &[&[]];
- assert_eq!(xs.split(|x| *x == 5).rev().collect::<Vec<&[int]>>(), splits);
+ let xs: &[i32] = &[];
+ let splits: &[&[i32]] = &[&[]];
+ assert_eq!(xs.split(|x| *x == 5).rev().collect::<Vec<&[i32]>>(), splits);
}
#[test]
fn test_rsplitnator() {
let xs = &[1,2,3,4,5];
- let splits: &[&[int]] = &[&[1,2,3,4,5]];
- assert_eq!(xs.rsplitn(0, |x| *x % 2 == 0).collect::<Vec<&[int]>>(),
+ let splits: &[&[_]] = &[&[1,2,3,4,5]];
+ assert_eq!(xs.rsplitn(0, |x| *x % 2 == 0).collect::<Vec<_>>(),
splits);
- let splits: &[&[int]] = &[&[5], &[1,2,3]];
- assert_eq!(xs.rsplitn(1, |x| *x % 2 == 0).collect::<Vec<&[int]>>(),
+ let splits: &[&[_]] = &[&[5], &[1,2,3]];
+ assert_eq!(xs.rsplitn(1, |x| *x % 2 == 0).collect::<Vec<_>>(),
splits);
- let splits: &[&[int]] = &[&[], &[], &[], &[1,2]];
- assert_eq!(xs.rsplitn(3, |_| true).collect::<Vec<&[int]>>(),
+ let splits: &[&[_]] = &[&[], &[], &[], &[1,2]];
+ assert_eq!(xs.rsplitn(3, |_| true).collect::<Vec<_>>(),
splits);
- let xs: &[int] = &[];
- let splits: &[&[int]] = &[&[]];
- assert_eq!(xs.rsplitn(1, |x| *x == 5).collect::<Vec<&[int]>>(), splits);
+ let xs: &[i32] = &[];
+ let splits: &[&[i32]] = &[&[]];
+ assert_eq!(xs.rsplitn(1, |x| *x == 5).collect::<Vec<&[i32]>>(), splits);
}
#[test]
fn test_windowsator() {
let v = &[1,2,3,4];
- let wins: &[&[int]] = &[&[1,2], &[2,3], &[3,4]];
- assert_eq!(v.windows(2).collect::<Vec<&[int]>>(), wins);
- let wins: &[&[int]] = &[&[1,2,3], &[2,3,4]];
- assert_eq!(v.windows(3).collect::<Vec<&[int]>>(), wins);
+ let wins: &[&[_]] = &[&[1,2], &[2,3], &[3,4]];
+ assert_eq!(v.windows(2).collect::<Vec<_>>(), wins);
+
+ let wins: &[&[_]] = &[&[1,2,3], &[2,3,4]];
+ assert_eq!(v.windows(3).collect::<Vec<_>>(), wins);
assert!(v.windows(6).next().is_none());
}
assert_eq!(v.chunks(2).len(), 3);
- let chunks: &[&[int]] = &[&[1,2], &[3,4], &[5]];
- assert_eq!(v.chunks(2).collect::<Vec<&[int]>>(), chunks);
- let chunks: &[&[int]] = &[&[1,2,3], &[4,5]];
- assert_eq!(v.chunks(3).collect::<Vec<&[int]>>(), chunks);
- let chunks: &[&[int]] = &[&[1,2,3,4,5]];
- assert_eq!(v.chunks(6).collect::<Vec<&[int]>>(), chunks);
+ let chunks: &[&[_]] = &[&[1,2], &[3,4], &[5]];
+ assert_eq!(v.chunks(2).collect::<Vec<_>>(), chunks);
+ let chunks: &[&[_]] = &[&[1,2,3], &[4,5]];
+ assert_eq!(v.chunks(3).collect::<Vec<_>>(), chunks);
+ let chunks: &[&[_]] = &[&[1,2,3,4,5]];
+ assert_eq!(v.chunks(6).collect::<Vec<_>>(), chunks);
- let chunks: &[&[int]] = &[&[5], &[3,4], &[1,2]];
- assert_eq!(v.chunks(2).rev().collect::<Vec<&[int]>>(), chunks);
+ let chunks: &[&[_]] = &[&[5], &[3,4], &[1,2]];
+ assert_eq!(v.chunks(2).rev().collect::<Vec<_>>(), chunks);
let mut it = v.chunks(2);
assert_eq!(it.indexable(), 3);
- let chunk: &[int] = &[1,2];
+
+ let chunk: &[_] = &[1,2];
assert_eq!(it.idx(0).unwrap(), chunk);
- let chunk: &[int] = &[3,4];
+ let chunk: &[_] = &[3,4];
assert_eq!(it.idx(1).unwrap(), chunk);
- let chunk: &[int] = &[5];
+ let chunk: &[_] = &[5];
assert_eq!(it.idx(2).unwrap(), chunk);
assert_eq!(it.idx(3), None);
}
assert_eq!(format!("{:?}", x), x_str);
})
}
- let empty: Vec<int> = vec![];
+ let empty = Vec::<i32>::new();
test_show_vec!(empty, "[]");
test_show_vec!(vec![1], "[1]");
test_show_vec!(vec![1, 2, 3], "[1, 2, 3]");
test_show_vec!(vec![vec![], vec![1u], vec![1u, 1u]],
"[[], [1], [1, 1]]");
- let empty_mut: &mut [int] = &mut[];
+ let empty_mut: &mut [i32] = &mut[];
test_show_vec!(empty_mut, "[]");
- let v: &mut[int] = &mut[1];
+ let v = &mut[1];
test_show_vec!(v, "[1]");
- let v: &mut[int] = &mut[1, 2, 3];
+ let v = &mut[1, 2, 3];
test_show_vec!(v, "[1, 2, 3]");
- let v: &mut [&mut[uint]] = &mut[&mut[], &mut[1u], &mut[1u, 1u]];
+ let v: &mut[&mut[_]] = &mut[&mut[], &mut[1u], &mut[1u, 1u]];
test_show_vec!(v, "[[], [1], [1, 1]]");
}
}}
}
- t!(&[int]);
- t!(Vec<int>);
+ t!(&[i32]);
+ t!(Vec<i32>);
}
#[test]
let h = x.last_mut();
assert_eq!(*h.unwrap(), 5);
- let y: &mut [int] = &mut [];
+ let y: &mut [i32] = &mut [];
assert!(y.last_mut().is_none());
}
#[test]
fn test_to_vec() {
- let xs = box [1u, 2, 3];
+ let xs = box [1, 2, 3];
let ys = xs.to_vec();
- assert_eq!(ys, [1u, 2, 3]);
+ assert_eq!(ys, [1, 2, 3]);
}
}
fn iterator(b: &mut Bencher) {
// peculiar numbers to stop LLVM from optimising the summation
// out.
- let v = (0u..100).map(|i| i ^ (i << 1) ^ (i >> 1)).collect::<Vec<_>>();
+ let v: Vec<_> = (0..100).map(|i| i ^ (i << 1) ^ (i >> 1)).collect();
b.iter(|| {
let mut sum = 0;
#[bench]
fn mut_iterator(b: &mut Bencher) {
- let mut v = repeat(0).take(100).collect::<Vec<_>>();
+ let mut v: Vec<_> = repeat(0).take(100).collect();
b.iter(|| {
let mut i = 0;
#[bench]
fn concat(b: &mut Bencher) {
- let xss: Vec<Vec<uint>> =
- (0..100u).map(|i| (0..i).collect()).collect();
+ let xss: Vec<Vec<i32>> =
+ (0..100).map(|i| (0..i).collect()).collect();
b.iter(|| {
xss.concat();
});
#[bench]
fn connect(b: &mut Bencher) {
- let xss: Vec<Vec<uint>> =
- (0..100u).map(|i| (0..i).collect()).collect();
+ let xss: Vec<Vec<i32>> =
+ (0..100).map(|i| (0..i).collect()).collect();
b.iter(|| {
xss.connect(&0)
});
#[bench]
fn push(b: &mut Bencher) {
- let mut vec: Vec<uint> = vec![];
+ let mut vec = Vec::<i32>::new();
b.iter(|| {
vec.push(0);
black_box(&vec);
#[bench]
fn starts_with_same_vector(b: &mut Bencher) {
- let vec: Vec<uint> = (0u..100).collect();
+ let vec: Vec<_> = (0..100).collect();
b.iter(|| {
vec.starts_with(&vec)
})
#[bench]
fn starts_with_single_element(b: &mut Bencher) {
- let vec: Vec<uint> = vec![0];
+ let vec: Vec<_> = vec![0];
b.iter(|| {
vec.starts_with(&vec)
})
#[bench]
fn starts_with_diff_one_element_at_end(b: &mut Bencher) {
- let vec: Vec<uint> = (0u..100).collect();
- let mut match_vec: Vec<uint> = (0u..99).collect();
+ let vec: Vec<_> = (0..100).collect();
+ let mut match_vec: Vec<_> = (0..99).collect();
match_vec.push(0);
b.iter(|| {
vec.starts_with(&match_vec)
#[bench]
fn ends_with_same_vector(b: &mut Bencher) {
- let vec: Vec<uint> = (0u..100).collect();
+ let vec: Vec<_> = (0..100).collect();
b.iter(|| {
vec.ends_with(&vec)
})
#[bench]
fn ends_with_single_element(b: &mut Bencher) {
- let vec: Vec<uint> = vec![0];
+ let vec: Vec<_> = vec![0];
b.iter(|| {
vec.ends_with(&vec)
})
#[bench]
fn ends_with_diff_one_element_at_beginning(b: &mut Bencher) {
- let vec: Vec<uint> = (0u..100).collect();
- let mut match_vec: Vec<uint> = (0u..100).collect();
+ let vec: Vec<_> = (0..100).collect();
+ let mut match_vec: Vec<_> = (0..100).collect();
match_vec[0] = 200;
b.iter(|| {
vec.starts_with(&match_vec)
#[bench]
fn contains_last_element(b: &mut Bencher) {
- let vec: Vec<uint> = (0u..100).collect();
+ let vec: Vec<_> = (0..100).collect();
b.iter(|| {
- vec.contains(&99u)
+ vec.contains(&99)
})
}
#[bench]
fn zero_1kb_set_memory(b: &mut Bencher) {
b.iter(|| {
- let mut v: Vec<uint> = Vec::with_capacity(1024);
+ let mut v = Vec::<u8>::with_capacity(1024);
unsafe {
let vp = v.as_mut_ptr();
ptr::set_memory(vp, 0, 1024);
#[bench]
fn zero_1kb_loop_set(b: &mut Bencher) {
b.iter(|| {
- let mut v: Vec<uint> = Vec::with_capacity(1024);
+ let mut v = Vec::<u8>::with_capacity(1024);
unsafe {
v.set_len(1024);
}
- for i in 0u..1024 {
+ for i in 0..1024 {
v[i] = 0;
}
});
#[bench]
fn zero_1kb_mut_iter(b: &mut Bencher) {
b.iter(|| {
- let mut v = Vec::with_capacity(1024);
+ let mut v = Vec::<u8>::with_capacity(1024);
unsafe {
v.set_len(1024);
}
fn random_inserts(b: &mut Bencher) {
let mut rng = weak_rng();
b.iter(|| {
- let mut v = repeat((0u, 0u)).take(30).collect::<Vec<_>>();
+ let mut v: Vec<_> = repeat((0, 0)).take(30).collect();
for _ in 0u..100 {
let l = v.len();
- v.insert(rng.gen::<uint>() % (l + 1),
+ v.insert(rng.gen::<usize>() % (l + 1),
(1, 1));
}
})
fn random_removes(b: &mut Bencher) {
let mut rng = weak_rng();
b.iter(|| {
- let mut v = repeat((0u, 0u)).take(130).collect::<Vec<_>>();
+ let mut v: Vec<_> = repeat((0, 0)).take(130).collect();
for _ in 0u..100 {
let l = v.len();
- v.remove(rng.gen::<uint>() % l);
+ v.remove(rng.gen::<usize>() % l);
}
})
}
fn sort_random_small(b: &mut Bencher) {
let mut rng = weak_rng();
b.iter(|| {
- let mut v = rng.gen_iter::<u64>().take(5).collect::<Vec<u64>>();
+ let mut v: Vec<_> = rng.gen_iter::<u64>().take(5).collect();
v.sort();
});
b.bytes = 5 * mem::size_of::<u64>() as u64;
fn sort_random_medium(b: &mut Bencher) {
let mut rng = weak_rng();
b.iter(|| {
- let mut v = rng.gen_iter::<u64>().take(100).collect::<Vec<u64>>();
+ let mut v: Vec<_> = rng.gen_iter::<u64>().take(100).collect();
v.sort();
});
b.bytes = 100 * mem::size_of::<u64>() as u64;
fn sort_random_large(b: &mut Bencher) {
let mut rng = weak_rng();
b.iter(|| {
- let mut v = rng.gen_iter::<u64>().take(10000).collect::<Vec<u64>>();
+ let mut v: Vec<_> = rng.gen_iter::<u64>().take(10000).collect();
v.sort();
});
b.bytes = 10000 * mem::size_of::<u64>() as u64;
#[bench]
fn sort_sorted(b: &mut Bencher) {
- let mut v = (0u..10000).collect::<Vec<_>>();
+ let mut v: Vec<_> = (0..10000).collect();
b.iter(|| {
v.sort();
});
b.bytes = (v.len() * mem::size_of_val(&v[0])) as u64;
}
- type BigSortable = (u64,u64,u64,u64);
+ type BigSortable = (u64, u64, u64, u64);
#[bench]
fn sort_big_random_small(b: &mut Bencher) {
#[bench]
fn sort_big_sorted(b: &mut Bencher) {
- let mut v = (0..10000u).map(|i| (i, i, i, i)).collect::<Vec<_>>();
+ let mut v: Vec<BigSortable> = (0..10000).map(|i| (i, i, i, i)).collect();
b.iter(|| {
v.sort();
});
}
}
- fn size_hint(&self) -> (uint, Option<uint>) {
+ fn size_hint(&self) -> (usize, Option<usize>) {
let (lower, _) = self.iter.size_hint();
(lower, None)
}
fn next(&mut self) -> Option<u16> { self.encoder.next() }
#[inline]
- fn size_hint(&self) -> (uint, Option<uint>) { self.encoder.size_hint() }
+ fn size_hint(&self) -> (usize, Option<usize>) { self.encoder.size_hint() }
}
/*
/// assert_eq!(v, vec![""]);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- fn splitn<P: CharEq>(&self, count: u
int, pat: P) -> SplitN<P> {
+ fn splitn<P: CharEq>(&self, count: u
size, pat: P) -> SplitN<P> {
core_str::StrExt::splitn(&self[], count, pat)
}
/// assert_eq!(v, vec!["leopard", "tiger", "lionX"]);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- fn rsplitn<P: CharEq>(&self, count: u
int, pat: P) -> RSplitN<P> {
+ fn rsplitn<P: CharEq>(&self, count: u
size, pat: P) -> RSplitN<P> {
core_str::StrExt::rsplitn(&self[], count, pat)
}
/// # Example
///
/// ```rust
- /// let v: Vec<(uint, uint)> = "abcXXXabcYYYabc".match_indices("abc").collect();
+ /// let v: Vec<(usize, usize)> = "abcXXXabcYYYabc".match_indices("abc").collect();
/// assert_eq!(v, vec![(0,3), (6,9), (12,15)]);
///
- /// let v: Vec<(uint, uint)> = "1abcabc2".match_indices("abc").collect();
+ /// let v: Vec<(usize, usize)> = "1abcabc2".match_indices("abc").collect();
/// assert_eq!(v, vec![(1,4), (4,7)]);
///
- /// let v: Vec<(uint, uint)> = "ababa".match_indices("aba").collect();
+ /// let v: Vec<(usize, usize)> = "ababa".match_indices("aba").collect();
/// assert_eq!(v, vec![(0, 3)]); // only the first `aba`
/// ```
#[unstable(feature = "collections",
#[unstable(feature = "collections",
reason = "use slice notation [a..b] instead")]
#[deprecated(since = "1.0.0", reason = "use slice notation [a..b] instead")]
- fn slice(&self, begin: uint, end: uint) -> &str;
+ fn slice(&self, begin: usize, end: usize) -> &str;
/// Deprecated: use `s[a..]` instead.
#[unstable(feature = "collections",
reason = "use slice notation [a..b] instead")]
#[deprecated(since = "1.0.0", reason = "use slice notation [a..] instead")]
- fn slice_from(&self, begin: uint) -> &str;
+ fn slice_from(&self, begin: usize) -> &str;
/// Deprecated: use `s[..a]` instead.
#[unstable(feature = "collections",
reason = "use slice notation [a..b] instead")]
#[deprecated(since = "1.0.0", reason = "use slice notation [..a] instead")]
- fn slice_to(&self, end: uint) -> &str;
+ fn slice_to(&self, end: usize) -> &str;
/// Returns a slice of the string from the character range
/// [`begin`..`end`).
/// ```
#[unstable(feature = "collections",
reason = "may have yet to prove its worth")]
- fn slice_chars(&self, begin: uint, end: uint) -> &str {
+ fn slice_chars(&self, begin: usize, end: usize) -> &str {
core_str::StrExt::slice_chars(&self[], begin, end)
}
/// Caller must check both UTF-8 character boundaries and the boundaries of
/// the entire slice as well.
#[stable(feature = "rust1", since = "1.0.0")]
- unsafe fn slice_unchecked(&self, begin: uint, end: uint) -> &str {
+ unsafe fn slice_unchecked(&self, begin: usize, end: usize) -> &str {
core_str::StrExt::slice_unchecked(&self[], begin, end)
}
/// ```
#[unstable(feature = "collections",
reason = "naming is uncertain with container conventions")]
- fn is_char_boundary(&self, index: uint) -> bool {
+ fn is_char_boundary(&self, index: usize) -> bool {
core_str::StrExt::is_char_boundary(&self[], index)
}
/// use std::str::CharRange;
///
/// let s = "中华Việt Nam";
- /// let mut i = 0u;
+ /// let mut i = 0;
/// while i < s.len() {
/// let CharRange {ch, next} = s.char_range_at(i);
/// println!("{}: {}", i, ch);
///
/// # Return value
///
- /// A record {ch: char, next: uint} containing the char value and the byte
+ /// A record {ch: char, next: usize} containing the char value and the byte
/// index of the next Unicode character.
///
/// # Panics
/// If `i` is not the index of the beginning of a valid UTF-8 character.
#[unstable(feature = "collections",
reason = "naming is uncertain with container conventions")]
- fn char_range_at(&self, start: uint) -> CharRange {
+ fn char_range_at(&self, start: usize) -> CharRange {
core_str::StrExt::char_range_at(&self[], start)
}
/// If `i` is not an index following a valid UTF-8 character.
#[unstable(feature = "collections",
reason = "naming is uncertain with container conventions")]
- fn char_range_at_reverse(&self, start: uint) -> CharRange {
+ fn char_range_at_reverse(&self, start: usize) -> CharRange {
core_str::StrExt::char_range_at_reverse(&self[], start)
}
/// If `i` is not the index of the beginning of a valid UTF-8 character.
#[unstable(feature = "collections",
reason = "naming is uncertain with container conventions")]
- fn char_at(&self, i: uint) -> char {
+ fn char_at(&self, i: usize) -> char {
core_str::StrExt::char_at(&self[], i)
}
/// If `i` is not an index following a valid UTF-8 character.
#[unstable(feature = "collections",
reason = "naming is uncertain with container conventions")]
- fn char_at_reverse(&self, i: uint) -> char {
+ fn char_at_reverse(&self, i: usize) -> char {
core_str::StrExt::char_at_reverse(&self[], i)
}
/// assert_eq!(s.find(x), None);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- fn find<P: CharEq>(&self, pat: P) -> Option<uint> {
+ fn find<P: CharEq>(&self, pat: P) -> Option<usize> {
core_str::StrExt::find(&self[], pat)
}
/// assert_eq!(s.rfind(x), None);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- fn rfind<P: CharEq>(&self, pat: P) -> Option<uint> {
+ fn rfind<P: CharEq>(&self, pat: P) -> Option<usize> {
core_str::StrExt::rfind(&self[], pat)
}
/// ```
#[unstable(feature = "collections",
reason = "might get removed in favor of a more generic find in the future")]
- fn find_str(&self, needle: &str) -> Option<uint> {
+ fn find_str(&self, needle: &str) -> Option<usize> {
core_str::StrExt::find_str(&self[], needle)
}
/// ```
#[unstable(feature = "collections",
reason = "awaiting convention about comparability of arbitrary slices")]
- fn subslice_offset(&self, inner: &str) -> uint {
+ fn subslice_offset(&self, inner: &str) -> usize {
core_str::StrExt::subslice_offset(&self[], inner)
}
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
- fn len(&self) -> uint {
+ fn len(&self) -> usize {
core_str::StrExt::len(&self[])
}
/// # Example
///
/// ```rust
- /// let gr_inds = "a̐éö̲\r\n".grapheme_indices(true).collect::<Vec<(uint, &str)>>();
- /// let b: &[_] = &[(0u, "a̐"), (3, "é"), (6, "ö̲"), (11, "\r\n")];
+ /// let gr_inds = "a̐éö̲\r\n".grapheme_indices(true).collect::<Vec<(usize, &str)>>();
+ /// let b: &[_] = &[(0, "a̐"), (3, "é"), (6, "ö̲"), (11, "\r\n")];
/// assert_eq!(gr_inds.as_slice(), b);
/// ```
#[unstable(feature = "collections",
/// `is_cjk` = `false`) if the locale is unknown.
#[unstable(feature = "collections",
reason = "this functionality may only be provided by libunicode")]
- fn width(&self, is_cjk: bool) -> uint {
+ fn width(&self, is_cjk: bool) -> usize {
UnicodeStr::width(&self[], is_cjk)
}
#[stable(feature = "rust1", since = "1.0.0")]
impl StrExt for str {
- fn slice(&self, begin: uint, end: uint) -> &str {
+ fn slice(&self, begin: usize, end: usize) -> &str {
&self[begin..end]
}
- fn slice_from(&self, begin: uint) -> &str {
+ fn slice_from(&self, begin: usize) -> &str {
&self[begin..]
}
- fn slice_to(&self, end: uint) -> &str {
+ fn slice_to(&self, end: usize) -> &str {
&self[..end]
}
}
#[test]
fn test_len() {
- assert_eq!("".len(), 0u);
- assert_eq!("hello world".len(), 11u);
- assert_eq!("\x63".len(), 1u);
- assert_eq!("\u{a2}".len(), 2u);
- assert_eq!("\u{3c0}".len(), 2u);
- assert_eq!("\u{2620}".len(), 3u);
- assert_eq!("\u{1d11e}".len(), 4u);
-
- assert_eq!("".chars().count(), 0u);
- assert_eq!("hello world".chars().count(), 11u);
- assert_eq!("\x63".chars().count(), 1u);
- assert_eq!("\u{a2}".chars().count(), 1u);
- assert_eq!("\u{3c0}".chars().count(), 1u);
- assert_eq!("\u{2620}".chars().count(), 1u);
- assert_eq!("\u{1d11e}".chars().count(), 1u);
- assert_eq!("ประเทศไทย中华Việt Nam".chars().count(), 19u);
-
- assert_eq!("ｈｅｌｌｏ".width(false), 10u);
- assert_eq!("ｈｅｌｌｏ".width(true), 10u);
- assert_eq!("\0\0\0\0\0".width(false), 0u);
- assert_eq!("\0\0\0\0\0".width(true), 0u);
- assert_eq!("".width(false), 0u);
- assert_eq!("".width(true), 0u);
- assert_eq!("\u{2081}\u{2082}\u{2083}\u{2084}".width(false), 4u);
- assert_eq!("\u{2081}\u{2082}\u{2083}\u{2084}".width(true), 8u);
+ assert_eq!("".len(), 0);
+ assert_eq!("hello world".len(), 11);
+ assert_eq!("\x63".len(), 1);
+ assert_eq!("\u{a2}".len(), 2);
+ assert_eq!("\u{3c0}".len(), 2);
+ assert_eq!("\u{2620}".len(), 3);
+ assert_eq!("\u{1d11e}".len(), 4);
+
+ assert_eq!("".chars().count(), 0);
+ assert_eq!("hello world".chars().count(), 11);
+ assert_eq!("\x63".chars().count(), 1);
+ assert_eq!("\u{a2}".chars().count(), 1);
+ assert_eq!("\u{3c0}".chars().count(), 1);
+ assert_eq!("\u{2620}".chars().count(), 1);
+ assert_eq!("\u{1d11e}".chars().count(), 1);
+ assert_eq!("ประเทศไทย中华Việt Nam".chars().count(), 19);
+
+ assert_eq!("ｈｅｌｌｏ".width(false), 10);
+ assert_eq!("ｈｅｌｌｏ".width(true), 10);
+ assert_eq!("\0\0\0\0\0".width(false), 0);
+ assert_eq!("\0\0\0\0\0".width(true), 0);
+ assert_eq!("".width(false), 0);
+ assert_eq!("".width(true), 0);
+ assert_eq!("\u{2081}\u{2082}\u{2083}\u{2084}".width(false), 4);
+ assert_eq!("\u{2081}\u{2082}\u{2083}\u{2084}".width(true), 8);
}
#[test]
fn test_find() {
- assert_eq!("hello".find('l'), Some(2u));
- assert_eq!("hello".find(|c:char| c == 'o'), Some(4u));
+ assert_eq!("hello".find('l'), Some(2));
+ assert_eq!("hello".find(|c:char| c == 'o'), Some(4));
assert!("hello".find('x').is_none());
assert!("hello".find(|c:char| c == 'x').is_none());
- assert_eq!("ประเทศไทย中华Việt Nam".find('华'), Some(30u));
- assert_eq!("ประเทศไทย中华Việt Nam".find(|c: char| c == '华'), Some(30u));
+ assert_eq!("ประเทศไทย中华Việt Nam".find('华'), Some(30));
+ assert_eq!("ประเทศไทย中华Việt Nam".find(|c: char| c == '华'), Some(30));
}
#[test]
fn test_rfind() {
- assert_eq!("hello".rfind('l'), Some(3u));
- assert_eq!("hello".rfind(|c:char| c == 'o'), Some(4u));
+ assert_eq!("hello".rfind('l'), Some(3));
+ assert_eq!("hello".rfind(|c:char| c == 'o'), Some(4));
assert!("hello".rfind('x').is_none());
assert!("hello".rfind(|c:char| c == 'x').is_none());
- assert_eq!("ประเทศไทย中华Việt Nam".rfind('华'), Some(30u));
- assert_eq!("ประเทศไทย中华Việt Nam".rfind(|c: char| c == '华'), Some(30u));
+ assert_eq!("ประเทศไทย中华Việt Nam".rfind('华'), Some(30));
+ assert_eq!("ประเทศไทย中华Việt Nam".rfind(|c: char| c == '华'), Some(30));
}
#[test]
#[test]
fn test_find_str() {
// byte positions
- assert_eq!("".find_str(""), Some(0u));
+ assert_eq!("".find_str(""), Some(0));
assert!("banana".find_str("apple pie").is_none());
let data = "abcabc";
- assert_eq!(data[0u..6u].find_str("ab"), Some(0u));
- assert_eq!(data[2u..6u].find_str("ab"), Some(3u - 2u));
- assert!(data[2u..4u].find_str("ab").is_none());
+ assert_eq!(data[0..6].find_str("ab"), Some(0));
+ assert_eq!(data[2..6].find_str("ab"), Some(3 - 2));
+ assert!(data[2..4].find_str("ab").is_none());
let string = "ประเทศไทย中华Việt Nam";
let mut data = String::from_str(string);
data.push_str(string);
assert!(data.find_str("ไท华").is_none());
- assert_eq!(data[0u..43u].find_str(""), Some(0u));
- assert_eq!(data[6u..43u].find_str(""), Some(6u - 6u));
+ assert_eq!(data[0..43].find_str(""), Some(0));
+ assert_eq!(data[6..43].find_str(""), Some(6 - 6));
- assert_eq!(data[0u..43u].find_str("ประ"), Some( 0u));
- assert_eq!(data[0u..43u].find_str("ทศไ"), Some(12u));
- assert_eq!(data[0u..43u].find_str("ย中"), Some(24u));
- assert_eq!(data[0u..43u].find_str("iệt"), Some(34u));
- assert_eq!(data[0u..43u].find_str("Nam"), Some(40u));
+ assert_eq!(data[0..43].find_str("ประ"), Some( 0));
+ assert_eq!(data[0..43].find_str("ทศไ"), Some(12));
+ assert_eq!(data[0..43].find_str("ย中"), Some(24));
+ assert_eq!(data[0..43].find_str("iệt"), Some(34));
+ assert_eq!(data[0..43].find_str("Nam"), Some(40));
- assert_eq!(data[43u..86u].find_str("ประ"), Some(43u - 43u));
- assert_eq!(data[43u..86u].find_str("ทศไ"), Some(55u - 43u));
- assert_eq!(data[43u..86u].find_str("ย中"), Some(67u - 43u));
- assert_eq!(data[43u..86u].find_str("iệt"), Some(77u - 43u));
- assert_eq!(data[43u..86u].find_str("Nam"), Some(83u - 43u));
+ assert_eq!(data[43..86].find_str("ประ"), Some(43 - 43));
+ assert_eq!(data[43..86].find_str("ทศไ"), Some(55 - 43));
+ assert_eq!(data[43..86].find_str("ย中"), Some(67 - 43));
+ assert_eq!(data[43..86].find_str("iệt"), Some(77 - 43));
+ assert_eq!(data[43..86].find_str("Nam"), Some(83 - 43));
}
#[test]
fn test_slice_chars() {
- fn t(a: &str, b: &str, start: uint) {
+ fn t(a: &str, b: &str, start: usize) {
assert_eq!(a.slice_chars(start, start + b.chars().count()), b);
}
t("", "", 0);
assert_eq!("bc", unsafe {"abc".slice_unchecked(1, 3)});
assert_eq!("", unsafe {"abc".slice_unchecked(1, 1)});
fn a_million_letter_a() -> String {
- let mut i = 0u;
+ let mut i = 0;
let mut rs = String::new();
while i < 100000 {
rs.push_str("aaaaaaaaaa");
rs
}
fn half_a_million_letter_a() -> String {
- let mut i = 0u;
+ let mut i = 0;
let mut rs = String::new();
while i < 100000 {
rs.push_str("aaaaa");
let letters = a_million_letter_a();
assert!(half_a_million_letter_a() ==
unsafe {String::from_str(letters.slice_unchecked(
- 0u,
+ 0,
500000))});
}
assert_eq!("华", data.slice(30, 33));
fn a_million_letter_x() -> String {
- let mut i = 0u;
+ let mut i = 0;
let mut rs = String::new();
while i < 100000 {
rs.push_str("华华华华华华华华华华");
rs
}
fn half_a_million_letter_x() -> String {
- let mut i = 0u;
+ let mut i = 0;
let mut rs = String::new();
while i < 100000 {
rs.push_str("华华华华华");
}
let letters = a_million_letter_x();
assert!(half_a_million_letter_x() ==
- String::from_str(letters.slice(0u, 3u * 500000u)));
+ String::from_str(letters.slice(0, 3 * 500000)));
}
#[test]
fn test_slice_2() {
let ss = "中华Việt Nam";
- assert_eq!("华", ss.slice(3u, 6u));
- assert_eq!("Việt Nam", ss.slice(6u, 16u));
+ assert_eq!("华", ss.slice(3, 6));
+ assert_eq!("Việt Nam", ss.slice(6, 16));
- assert_eq!("ab", "abc".slice(0u, 2u));
- assert_eq!("bc", "abc".slice(1u, 3u));
- assert_eq!("", "abc".slice(1u, 1u));
+ assert_eq!("ab", "abc".slice(0, 2));
+ assert_eq!("bc", "abc".slice(1, 3));
+ assert_eq!("", "abc".slice(1, 1));
- assert_eq!("中", ss.slice(0u, 3u));
- assert_eq!("华V", ss.slice(3u, 7u));
- assert_eq!("", ss.slice(3u, 3u));
+ assert_eq!("中", ss.slice(0, 3));
+ assert_eq!("华V", ss.slice(3, 7));
+ assert_eq!("", ss.slice(3, 3));
/*0: 中
3: 华
6: V
#[test]
#[should_fail]
fn test_slice_fail() {
- "中华Việt Nam".slice(0u, 2u);
+ "中华Việt Nam".slice(0, 2);
}
#[test]
let v: Vec<u8> = s1.as_bytes().to_vec();
let s2: String = String::from_str(from_utf8(&v).unwrap());
- let mut i: uint = 0u;
- let n1: uint = s1.len();
- let n2: uint = v.len();
+ let mut i = 0;
+ let n1 = s1.len();
+ let n2 = v.len();
assert_eq!(n1, n2);
while i < n1 {
let a: u8 = s1.as_bytes()[i];
debug!("{}", a);
debug!("{}", b);
assert_eq!(a, b);
- i += 1u;
+ i += 1;
}
}
let v = ['ศ','ไ','ท','ย','中','华','V','i','ệ','t',' ','N','a','m'];
let mut pos = 0;
- let mut it = s.chars();
+ let it = s.chars();
for c in it {
assert_eq!(c, v[pos]);
let v = ['m', 'a', 'N', ' ', 't', 'ệ','i','V','华','中','ย','ท','ไ','ศ'];
let mut pos = 0;
- let mut it = s.chars().rev();
+ let it = s.chars().rev();
for c in it {
assert_eq!(c, v[pos]);
let v = ['ศ','ไ','ท','ย','中','华','V','i','ệ','t',' ','N','a','m'];
let mut pos = 0;
- let mut it = s.char_indices();
+ let it = s.char_indices();
for c in it {
assert_eq!(c, (p[pos], v[pos]));
let v = ['m', 'a', 'N', ' ', 't', 'ệ','i','V','华','中','ย','ท','ไ','ศ'];
let mut pos = 0;
- let mut it = s.char_indices().rev();
+ let it = s.char_indices().rev();
for c in it {
assert_eq!(c, (p[pos], v[pos]));
// test the indices iterators
let s = "a̐éö̲\r\n";
- let gr_inds = s.grapheme_indices(true).collect::<Vec<(uint, &str)>>();
- let b: &[_] = &[(0u, "a̐"), (3, "é"), (6, "ö̲"), (11, "\r\n")];
+ let gr_inds = s.grapheme_indices(true).collect::<Vec<(usize, &str)>>();
+ let b: &[_] = &[(0, "a̐"), (3, "é"), (6, "ö̲"), (11, "\r\n")];
assert_eq!(gr_inds, b);
- let gr_inds = s.grapheme_indices(true).rev().collect::<Vec<(uint, &str)>>();
- let b: &[_] = &[(11, "\r\n"), (6, "ö̲"), (3, "é"), (0u, "a̐")];
+ let gr_inds = s.grapheme_indices(true).rev().collect::<Vec<(usize, &str)>>();
+ let b: &[_] = &[(11, "\r\n"), (6, "ö̲"), (3, "é"), (0, "a̐")];
assert_eq!(gr_inds, b);
let mut gr_inds_iter = s.grapheme_indices(true);
{
#[test]
fn test_str_container() {
- fn sum_len(v: &[&str]) -> uint {
+ fn sum_len(v: &[&str]) -> usize {
v.iter().map(|x| x.len()).sum()
}
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn with_capacity(capacity: uint) -> String {
+ pub fn with_capacity(capacity: usize) -> String {
String {
vec: Vec::with_capacity(capacity),
}
static TAG_CONT_U8: u8 = 128u8;
static REPLACEMENT: &'static [u8] = b"\xEF\xBF\xBD"; // U+FFFD in UTF-8
let total = v.len();
- fn unsafe_get(xs: &[u8], i: uint) -> u8 {
+ fn unsafe_get(xs: &[u8], i: usize) -> u8 {
unsafe { *xs.get_unchecked(i) }
}
- fn safe_get(xs: &[u8], i: uint, total: uint) -> u8 {
+ fn safe_get(xs: &[u8], i: usize, total: usize) -> u8 {
if i >= total {
0
} else {
/// * We assume that the `Vec` contains valid UTF-8.
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub unsafe fn from_raw_parts(buf: *mut u8, length: uint, capacity: uint) -> String {
+ pub unsafe fn from_raw_parts(buf: *mut u8, length: usize, capacity: usize) -> String {
String {
vec: Vec::from_raw_parts(buf, length, capacity),
}
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn capacity(&self) -> uint {
+ pub fn capacity(&self) -> usize {
self.vec.capacity()
}
///
/// # Panics
///
- /// Panics if the new capacity overflows `uint`.
+ /// Panics if the new capacity overflows `usize`.
///
/// # Examples
///
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn reserve(&mut self, additional: uint) {
+ pub fn reserve(&mut self, additional: usize) {
self.vec.reserve(additional)
}
///
/// # Panics
///
- /// Panics if the new capacity overflows `uint`.
+ /// Panics if the new capacity overflows `usize`.
///
/// # Examples
///
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn reserve_exact(&mut self, additional: uint) {
+ pub fn reserve_exact(&mut self, additional: usize) {
self.vec.reserve_exact(additional)
}
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn truncate(&mut self, new_len: uint) {
+ pub fn truncate(&mut self, new_len: usize) {
assert!(self.is_char_boundary(new_len));
self.vec.truncate(new_len)
}
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn remove(&mut self, idx: uint) -> char {
+ pub fn remove(&mut self, idx: usize) -> char {
let len = self.len();
assert!(idx <= len);
/// this function will panic.
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn insert(&mut self, idx: uint, ch: char) {
+ pub fn insert(&mut self, idx: usize, ch: char) {
let len = self.len();
assert!(idx <= len);
assert!(self.is_char_boundary(idx));
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn len(&self) -> uint { self.vec.len() }
+ pub fn len(&self) -> usize { self.vec.len() }
/// Returns true if the string contains no bytes
///
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl ops::Index<ops::Range<uint>> for String {
+impl ops::Index<ops::Range<usize>> for String {
type Output = str;
#[inline]
- fn index(&self, index: &ops::Range<uint>) -> &str {
+ fn index(&self, index: &ops::Range<usize>) -> &str {
&self[][*index]
}
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl ops::Index<ops::RangeTo<uint>> for String {
+impl ops::Index<ops::RangeTo<usize>> for String {
type Output = str;
#[inline]
- fn index(&self, index: &ops::RangeTo<uint>) -> &str {
+ fn index(&self, index: &ops::RangeTo<usize>) -> &str {
&self[][*index]
}
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl ops::Index<ops::RangeFrom<uint>> for String {
+impl ops::Index<ops::RangeFrom<usize>> for String {
type Output = str;
#[inline]
- fn index(&self, index: &ops::RangeFrom<uint>) -> &str {
+ fn index(&self, index: &ops::RangeFrom<usize>) -> &str {
&self[][*index]
}
}
fn test_simple_types() {
assert_eq!(1.to_string(), "1");
assert_eq!((-1).to_string(), "-1");
- assert_eq!(200u.to_string(), "200");
+ assert_eq!(200.to_string(), "200");
assert_eq!(2u8.to_string(), "2");
assert_eq!(true.to_string(), "true");
assert_eq!(false.to_string(), "false");
#[test]
fn test_vectors() {
- let x: Vec<int> = vec![];
+ let x: Vec<i32> = vec![];
assert_eq!(format!("{:?}", x), "[]");
assert_eq!(format!("{:?}", vec![1]), "[1]");
assert_eq!(format!("{:?}", vec![1, 2, 3]), "[1, 2, 3]");
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 {
/// }
/// ```
#[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)
}
}
/// 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 {
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
};
/// ```
#[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
/// 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
#[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 = &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
///
///
/// # 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
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
};
/// ```
#[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());
///
// 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 start = vec.as_mut_ptr();
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 {
///
/// 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>(),
}
#[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 {
+ fn index<'a>(&'a self, index: &usize) -> &'a T {
// NB built-in indexing via `&[T]`
&(**self)[*index]
}
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> IndexMut<uint> for Vec<T> {
+impl<T> IndexMut<usize> for Vec<T> {
type Output = T;
#[inline]
- fn index_mut<'a>(&'a mut self, index: &uint) -> &'a mut T {
+ fn index_mut<'a>(&'a mut self, index: &usize) -> &'a 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] {
+ 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] {
+ 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] {
+ fn index(&self, index: &ops::RangeFrom<usize>) -> &[T] {
Index::index(&**self, index)
}
}
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> ops::IndexMut<ops::Range<uint>> for Vec<T> {
+impl<T> ops::IndexMut<ops::Range<usize>> for Vec<T> {
type Output = [T];
#[inline]
- fn index_mut(&mut self, index: &ops::Range<uint>) -> &mut [T] {
+ 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> {
+impl<T> ops::IndexMut<ops::RangeTo<usize>> for Vec<T> {
type Output = [T];
#[inline]
- fn index_mut(&mut self, index: &ops::RangeTo<uint>) -> &mut [T] {
+ 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> {
+impl<T> ops::IndexMut<ops::RangeFrom<usize>> for Vec<T> {
type Output = [T];
#[inline]
- fn index_mut(&mut self, index: &ops::RangeFrom<uint>) -> &mut [T] {
+ fn index_mut(&mut self, index: &ops::RangeFrom<usize>) -> &mut [T] {
IndexMut::index_mut(&mut **self, index)
}
}
#[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
}
// 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)))
}
#[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)))
// 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)))
}
#[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)))
/// 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_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 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;
+ static mut drops: u32 = 0;
struct Elem(int);
impl Drop for Elem {
fn drop(&mut self) {
#[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, [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;
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;
use {vec, slice};
use vec::Vec;
-// FIXME(conventions): capacity management???
-
/// A map optimized for small integer keys.
///
/// # Examples
fn hash(&self, state: &mut S) {
// In order to not traverse the `VecMap` twice, count the elements
// during iteration.
- let mut count: uint = 0;
+ let mut count: usize = 0;
for elt in self {
elt.hash(state);
count += 1;
/// let mut map: VecMap<&str> = VecMap::with_capacity(10);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn with_capacity(capacity: uint) -> VecMap<V> {
+ pub fn with_capacity(capacity: usize) -> VecMap<V> {
VecMap { v: Vec::with_capacity(capacity) }
}
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn capacity(&self) -> uint {
+ pub fn capacity(&self) -> usize {
self.v.capacity()
}
/// assert!(map.capacity() >= 10);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn reserve_len(&mut self, len: uint) {
+ pub fn reserve_len(&mut self, len: usize) {
let cur_len = self.v.len();
if len >= cur_len {
self.v.reserve(len - cur_len);
/// assert!(map.capacity() >= 10);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn reserve_len_exact(&mut self, len: uint) {
+ pub fn reserve_len_exact(&mut self, len: usize) {
let cur_len = self.v.len();
if len >= cur_len {
self.v.reserve_exact(len - cur_len);
}
/// Returns an iterator visiting all keys in ascending order of the keys.
- /// The iterator's element type is `uint`.
+ /// The iterator's element type is `usize`.
#[stable(feature = "rust1", since = "1.0.0")]
pub fn keys<'r>(&'r self) -> Keys<'r, V> {
fn first<A, B>((a, _): (A, B)) -> A { a }
- let first: fn((uint, &'r V)) -> uint = first; // coerce to fn pointer
+ let first: fn((usize, &'r V)) -> usize = first; // coerce to fn pointer
Keys { iter: self.iter().map(first) }
}
#[stable(feature = "rust1", since = "1.0.0")]
pub fn values<'r>(&'r self) -> Values<'r, V> {
fn second<A, B>((_, b): (A, B)) -> B { b }
- let second: fn((uint, &'r V)) -> &'r V = second; // coerce to fn pointer
+ let second: fn((usize, &'r V)) -> &'r V = second; // coerce to fn pointer
Values { iter: self.iter().map(second) }
}
/// Returns an iterator visiting all key-value pairs in ascending order of the keys.
- /// The iterator's element type is `(uint, &'r V)`.
+ /// The iterator's element type is `(usize, &'r V)`.
///
/// # Examples
///
/// Returns an iterator visiting all key-value pairs in ascending order of the keys,
/// with mutable references to the values.
- /// The iterator's element type is `(uint, &'r mut V)`.
+ /// The iterator's element type is `(usize, &'r mut V)`.
///
/// # Examples
///
/// Returns an iterator visiting all key-value pairs in ascending order of
/// the keys, consuming the original `VecMap`.
- /// The iterator's element type is `(uint, &'r V)`.
+ /// The iterator's element type is `(usize, &'r V)`.
///
/// # Examples
///
/// map.insert(3, "c");
/// map.insert(2, "b");
///
- /// let vec: Vec<(uint, &str)> = map.into_iter().collect();
+ /// let vec: Vec<(usize, &str)> = map.into_iter().collect();
///
/// assert_eq!(vec, vec![(1, "a"), (2, "b"), (3, "c")]);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
pub fn into_iter(self) -> IntoIter<V> {
- fn filter<A>((i, v): (uint, Option<A>)) -> Option<(uint, A)> {
+ fn filter<A>((i, v): (usize, Option<A>)) -> Option<(usize, A)> {
v.map(|v| (i, v))
}
- let filter: fn((uint, Option<V>)) -> Option<(uint, V)> = filter; // coerce to fn ptr
+ let filter: fn((usize, Option<V>)) -> Option<(usize, V)> = filter; // coerce to fn ptr
IntoIter { iter: self.v.into_iter().enumerate().filter_map(filter) }
}
/// Returns an iterator visiting all key-value pairs in ascending order of
/// the keys, emptying (but not consuming) the original `VecMap`.
- /// The iterator's element type is `(uint, &'r V)`. Keeps the allocated memory for reuse.
+ /// The iterator's element type is `(usize, &'r V)`. Keeps the allocated memory for reuse.
///
/// # Examples
///
/// map.insert(3, "c");
/// map.insert(2, "b");
///
- /// let vec: Vec<(uint, &str)> = map.drain().collect();
+ /// let vec: Vec<(usize, &str)> = map.drain().collect();
///
/// assert_eq!(vec, vec![(1, "a"), (2, "b"), (3, "c")]);
/// ```
#[unstable(feature = "collections",
reason = "matches collection reform specification, waiting for dust to settle")]
pub fn drain<'a>(&'a mut self) -> Drain<'a, V> {
- fn filter<A>((i, v): (uint, Option<A>)) -> Option<(uint, A)> {
+ fn filter<A>((i, v): (usize, Option<A>)) -> Option<(usize, A)> {
v.map(|v| (i, v))
}
- let filter: fn((uint, Option<V>)) -> Option<(uint, V)> = filter; // coerce to fn ptr
+ let filter: fn((usize, Option<V>)) -> Option<(usize, V)> = filter; // coerce to fn ptr
Drain { iter: self.v.drain().enumerate().filter_map(filter) }
}
/// assert_eq!(a.len(), 1);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn len(&self) -> uint {
+ pub fn len(&self) -> usize {
self.v.iter().filter(|elt| elt.is_some()).count()
}
/// assert_eq!(map.get(&2), None);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn get(&self, key: &uint) -> Option<&V> {
+ pub fn get(&self, key: &usize) -> Option<&V> {
if *key < self.v.len() {
match self.v[*key] {
Some(ref value) => Some(value),
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn contains_key(&self, key: &uint) -> bool {
+ pub fn contains_key(&self, key: &usize) -> bool {
self.get(key).is_some()
}
/// assert_eq!(map[1], "b");
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn get_mut(&mut self, key: &uint) -> Option<&mut V> {
+ pub fn get_mut(&mut self, key: &usize) -> Option<&mut V> {
if *key < self.v.len() {
match *(&mut self.v[*key]) {
Some(ref mut value) => Some(value),
/// assert_eq!(map[37], "c");
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn insert(&mut self, key: uint, value: V) -> Option<V> {
+ pub fn insert(&mut self, key: usize, value: V) -> Option<V> {
let len = self.v.len();
if len <= key {
self.v.extend((0..key - len + 1).map(|_| None));
/// assert_eq!(map.remove(&1), None);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn remove(&mut self, key: &uint) -> Option<V> {
+ pub fn remove(&mut self, key: &usize) -> Option<V> {
if *key >= self.v.len() {
return None;
}
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<V> FromIterator<(uint, V)> for VecMap<V> {
- fn from_iter<Iter: Iterator<Item=(uint, V)>>(iter: Iter) -> VecMap<V> {
+impl<V> FromIterator<(usize, V)> for VecMap<V> {
+ fn from_iter<Iter: Iterator<Item=(usize, V)>>(iter: Iter) -> VecMap<V> {
let mut map = VecMap::new();
map.extend(iter);
map
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<V> Extend<(uint, V)> for VecMap<V> {
- fn extend<Iter: Iterator<Item=(uint, V)>>(&mut self, iter: Iter) {
+impl<V> Extend<(usize, V)> for VecMap<V> {
+ fn extend<Iter: Iterator<Item=(usize, V)>>(&mut self, iter: Iter) {
for (k, v) in iter {
self.insert(k, v);
}
}
}
-impl<V> Index<uint> for VecMap<V> {
+impl<V> Index<usize> for VecMap<V> {
type Output = V;
#[inline]
- fn index<'a>(&'a self, i: &uint) -> &'a V {
+ fn index<'a>(&'a self, i: &usize) -> &'a V {
self.get(i).expect("key not present")
}
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<V> IndexMut<uint> for VecMap<V> {
+impl<V> IndexMut<usize> for VecMap<V> {
type Output = V;
#[inline]
- fn index_mut<'a>(&'a mut self, i: &uint) -> &'a mut V {
+ fn index_mut<'a>(&'a mut self, i: &usize) -> &'a mut V {
self.get_mut(i).expect("key not present")
}
}
}
#[inline]
- fn size_hint(&self) -> (uint, Option<uint>) {
+ fn size_hint(&self) -> (usize, Option<usize>) {
(0, Some(self.back - self.front))
}
}
/// An iterator over the key-value pairs of a map.
#[stable(feature = "rust1", since = "1.0.0")]
pub struct Iter<'a, V:'a> {
- front: uint,
- back: uint,
+ front: usize,
+ back: usize,
iter: slice::Iter<'a, Option<V>>
}
}
}
-iterator! { impl Iter -> (uint, &'a V), as_ref }
-double_ended_iterator! { impl Iter -> (uint, &'a V), as_ref }
+iterator! { impl Iter -> (usize, &'a V), as_ref }
+double_ended_iterator! { impl Iter -> (usize, &'a V), as_ref }
/// An iterator over the key-value pairs of a map, with the
/// values being mutable.
#[stable(feature = "rust1", since = "1.0.0")]
pub struct IterMut<'a, V:'a> {
- front: uint,
- back: uint,
+ front: usize,
+ back: usize,
iter: slice::IterMut<'a, Option<V>>
}
-iterator! { impl IterMut -> (uint, &'a mut V), as_mut }
-double_ended_iterator! { impl IterMut -> (uint, &'a mut V), as_mut }
+iterator! { impl IterMut -> (usize, &'a mut V), as_mut }
+double_ended_iterator! { impl IterMut -> (usize, &'a mut V), as_mut }
/// An iterator over the keys of a map.
#[stable(feature = "rust1", since = "1.0.0")]
pub struct Keys<'a, V: 'a> {
- iter: Map<Iter<'a, V>, fn((uint, &'a V)) -> uint>
+ iter: Map<Iter<'a, V>, fn((usize, &'a V)) -> usize>
}
// FIXME(#19839) Remove in favor of `#[derive(Clone)]`
/// An iterator over the values of a map.
#[stable(feature = "rust1", since = "1.0.0")]
pub struct Values<'a, V: 'a> {
- iter: Map<Iter<'a, V>, fn((uint, &'a V)) -> &'a V>
+ iter: Map<Iter<'a, V>, fn((usize, &'a V)) -> &'a V>
}
// FIXME(#19839) Remove in favor of `#[derive(Clone)]`
pub struct IntoIter<V> {
iter: FilterMap<
Enumerate<vec::IntoIter<Option<V>>>,
- fn((uint, Option<V>)) -> Option<(uint, V)>>
+ fn((usize, Option<V>)) -> Option<(usize, V)>>
}
#[unstable(feature = "collections")]
pub struct Drain<'a, V> {
iter: FilterMap<
Enumerate<vec::Drain<'a, Option<V>>>,
- fn((uint, Option<V>)) -> Option<(uint, V)>>
+ fn((usize, Option<V>)) -> Option<(usize, V)>>
}
#[unstable(feature = "collections")]
impl<'a, V> Iterator for Drain<'a, V> {
- type Item = (uint, V);
+ type Item = (usize, V);
- fn next(&mut self) -> Option<(uint, V)> { self.iter.next() }
- fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
+ fn next(&mut self) -> Option<(usize, V)> { self.iter.next() }
+ fn size_hint(&self) -> (usize, Option<usize>) { self.iter.size_hint() }
}
#[unstable(feature = "collections")]
impl<'a, V> DoubleEndedIterator for Drain<'a, V> {
- fn next_back(&mut self) -> Option<(uint, V)> { self.iter.next_back() }
+ fn next_back(&mut self) -> Option<(usize, V)> { self.iter.next_back() }
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, V> Iterator for Keys<'a, V> {
- type Item = uint;
+ type Item = usize;
- fn next(&mut self) -> Option<uint> { self.iter.next() }
- fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
+ fn next(&mut self) -> Option<usize> { self.iter.next() }
+ fn size_hint(&self) -> (usize, Option<usize>) { self.iter.size_hint() }
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, V> DoubleEndedIterator for Keys<'a, V> {
- fn next_back(&mut self) -> Option<uint> { self.iter.next_back() }
+ fn next_back(&mut self) -> Option<usize> { self.iter.next_back() }
}
#[stable(feature = "rust1", since = "1.0.0")]
type Item = &'a V;
fn next(&mut self) -> Option<(&'a V)> { self.iter.next() }
- fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
+ fn size_hint(&self) -> (usize, Option<usize>) { self.iter.size_hint() }
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, V> DoubleEndedIterator for Values<'a, V> {
#[stable(feature = "rust1", since = "1.0.0")]
impl<V> Iterator for IntoIter<V> {
- type Item = (uint, V);
+ type Item = (usize, V);
- fn next(&mut self) -> Option<(uint, V)> { self.iter.next() }
- fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
+ fn next(&mut self) -> Option<(usize, V)> { self.iter.next() }
+ fn size_hint(&self) -> (usize, Option<usize>) { self.iter.size_hint() }
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<V> DoubleEndedIterator for IntoIter<V> {
- fn next_back(&mut self) -> Option<(uint, V)> { self.iter.next_back() }
+ fn next_back(&mut self) -> Option<(usize, V)> { self.iter.next_back() }
}
#[cfg(test)]
map.insert(1, 'a');
map.insert(2, 'b');
map.insert(3, 'c');
- let keys = map.keys().collect::<Vec<uint>>();
+ let keys: Vec<_> = map.keys().collect();
assert_eq!(keys.len(), 3);
assert!(keys.contains(&1));
assert!(keys.contains(&2));
map.insert(1, 'a');
map.insert(2, 'b');
map.insert(3, 'c');
- let values = map.values().map(|&v| v).collect::<Vec<char>>();
+ let values: Vec<_> = map.values().cloned().collect();
assert_eq!(values.len(), 3);
assert!(values.contains(&'a'));
assert!(values.contains(&'b'));
map.insert(3, "c");
map.insert(2, "b");
- let vec: Vec<(usize, &str)> = map.drain().collect();
+ let vec: Vec<_> = map.drain().collect();
assert_eq!(vec, vec![(1, "a"), (2, "b"), (3, "c")]);
assert_eq!(map.len(), 0);
#[test]
fn test_show() {
let mut map = VecMap::new();
- let empty = VecMap::<int>::new();
+ let empty = VecMap::<i32>::new();
map.insert(1, 2);
map.insert(3, 4);
let mut b = VecMap::new();
assert!(!(a < b) && !(b < a));
- assert!(b.insert(2u, 5).is_none());
+ assert!(b.insert(2, 5).is_none());
assert!(a < b);
assert!(a.insert(2, 7).is_none());
assert!(!(a < b) && b < a);
let mut b = VecMap::new();
assert!(a <= b && a >= b);
- assert!(a.insert(1u, 1).is_none());
+ assert!(a.insert(1, 1).is_none());
assert!(a > b && a >= b);
assert!(b < a && b <= a);
assert!(b.insert(2, 2).is_none());
#[test]
fn test_from_iter() {
- let xs: Vec<(uint, char)> = vec![(1u, 'a'), (2, 'b'), (3, 'c'), (4, 'd'), (5, 'e')];
+ let xs = vec![(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd'), (5, 'e')];
- let map: VecMap<char> = xs.iter().map(|&x| x).collect();
+ let map: VecMap<_> = xs.iter().cloned().collect();
for &(k, v) in &xs {
assert_eq!(map.get(&k), Some(&v));
#[test]
fn test_index() {
- let mut map: VecMap<int> = VecMap::new();
+ let mut map = VecMap::new();
map.insert(1, 2);
map.insert(2, 1);
#[test]
#[should_fail]
fn test_index_nonexistent() {
- let mut map: VecMap<int> = VecMap::new();
+ let mut map = VecMap::new();
map.insert(1, 2);
map.insert(2, 1);
fn test_entry(){
let xs = [(1, 10), (2, 20), (3, 30), (4, 40), (5, 50), (6, 60)];
- let mut map: VecMap<i32> = xs.iter().map(|&x| x).collect();
+ let mut map: VecMap<_> = xs.iter().cloned().collect();
// Existing key (insert)
match map.entry(1) {
#[bench]
pub fn insert_rand_100(b: &mut Bencher) {
- let mut m : VecMap<uint> = VecMap::new();
+ let mut m = VecMap::new();
insert_rand_n(100, &mut m, b,
|m, i| { m.insert(i, 1); },
|m, i| { m.remove(&i); });
#[bench]
pub fn insert_rand_10_000(b: &mut Bencher) {
- let mut m : VecMap<uint> = VecMap::new();
+ let mut m = VecMap::new();
insert_rand_n(10_000, &mut m, b,
|m, i| { m.insert(i, 1); },
|m, i| { m.remove(&i); });
// Insert seq
#[bench]
pub fn insert_seq_100(b: &mut Bencher) {
- let mut m : VecMap<uint> = VecMap::new();
+ let mut m = VecMap::new();
insert_seq_n(100, &mut m, b,
|m, i| { m.insert(i, 1); },
|m, i| { m.remove(&i); });
#[bench]
pub fn insert_seq_10_000(b: &mut Bencher) {
- let mut m : VecMap<uint> = VecMap::new();
+ let mut m = VecMap::new();
insert_seq_n(10_000, &mut m, b,
|m, i| { m.insert(i, 1); },
|m, i| { m.remove(&i); });
// Find rand
#[bench]
pub fn find_rand_100(b: &mut Bencher) {
- let mut m : VecMap<uint> = VecMap::new();
+ let mut m = VecMap::new();
find_rand_n(100, &mut m, b,
|m, i| { m.insert(i, 1); },
|m, i| { m.get(&i); });
#[bench]
pub fn find_rand_10_000(b: &mut Bencher) {
- let mut m : VecMap<uint> = VecMap::new();
+ let mut m = VecMap::new();
find_rand_n(10_000, &mut m, b,
|m, i| { m.insert(i, 1); },
|m, i| { m.get(&i); });
// Find seq
#[bench]
pub fn find_seq_100(b: &mut Bencher) {
- let mut m : VecMap<uint> = VecMap::new();
+ let mut m = VecMap::new();
find_seq_n(100, &mut m, b,
|m, i| { m.insert(i, 1); },
|m, i| { m.get(&i); });
#[bench]
pub fn find_seq_10_000(b: &mut Bencher) {
- let mut m : VecMap<uint> = VecMap::new();
+ let mut m = VecMap::new();
find_seq_n(10_000, &mut m, b,
|m, i| { m.insert(i, 1); },
|m, i| { m.get(&i); });
}
impl CLike for BuiltinBound {
- fn to_uint(&self) -> uint {
+ fn to_usize(&self) -> uint {
*self as uint
}
- fn from_uint(v: uint) -> BuiltinBound {
+ fn from_usize(v: uint) -> BuiltinBound {
unsafe { mem::transmute(v) }
}
}
fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
let mut bits = 0;
for item in self {
- bits |= item.to_uint();
+ bits |= item.to_usize();
}
s.emit_uint(bits)
}
let mut set = EnumSet::new();
for bit in 0..uint::BITS {
if bits & (1 << bit) != 0 {
- set.insert(CLike::from_uint(1 << bit));
+ set.insert(CLike::from_usize(1 << bit));
}
}
Ok(set)
use super::map::HashMap;
b.iter(|| {
- let m : HashMap<int, int> = HashMap::new();
+ let m : HashMap<i32, i32> = HashMap::new();
assert_eq!(m.len(), 0);
})
}
};
use super::state::HashState;
-const INITIAL_LOG2_CAP: uint = 5;
+const INITIAL_LOG2_CAP: usize = 5;
#[unstable(feature = "std_misc")]
-pub const INITIAL_CAPACITY: uint = 1 << INITIAL_LOG2_CAP; // 2^5
+pub const INITIAL_CAPACITY: usize = 1 << INITIAL_LOG2_CAP; // 2^5
/// The default behavior of HashMap implements a load factor of 90.9%.
/// This behavior is characterized by the following condition:
}
#[inline]
- fn min_capacity(&self, usable_size: uint) -> uint {
+ fn min_capacity(&self, usable_size: usize) -> usize {
// Here, we are rephrasing the logic by specifying the lower limit
// on capacity:
//
/// An inverse of `min_capacity`, approximately.
#[inline]
- fn usable_capacity(&self, cap: uint) -> uint {
+ fn usable_capacity(&self, cap: usize) -> usize {
// As the number of entries approaches usable capacity,
// min_capacity(size) must be smaller than the internal capacity,
// so that the map is not resized:
///
/// `hash`, `k`, and `v` are the elements to "robin hood" into the hashtable.
fn robin_hood<'a, K: 'a, V: 'a>(mut bucket: FullBucketMut<'a, K, V>,
- mut ib: uint,
+ mut ib: usize,
mut hash: SafeHash,
mut k: K,
mut v: V)
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn with_capacity(capacity: uint) -> HashMap<K, V, RandomState> {
+ pub fn with_capacity(capacity: usize) -> HashMap<K, V, RandomState> {
HashMap::with_capacity_and_hash_state(capacity, Default::default())
}
}
/// ```
#[inline]
#[unstable(feature = "std_misc", reason = "hasher stuff is unclear")]
- pub fn with_capacity_and_hash_state(capacity: uint, hash_state: S)
+ pub fn with_capacity_and_hash_state(capacity: usize, hash_state: S)
-> HashMap<K, V, S> {
let resize_policy = DefaultResizePolicy::new();
let min_cap = max(INITIAL_CAPACITY, resize_policy.min_capacity(capacity));
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn capacity(&self) -> uint {
+ pub fn capacity(&self) -> usize {
self.resize_policy.usable_capacity(self.table.capacity())
}
///
/// # Panics
///
- /// Panics if the new allocation size overflows `uint`.
+ /// Panics if the new allocation size overflows `usize`.
///
/// # Example
///
/// map.reserve(10);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn reserve(&mut self, additional: uint) {
+ pub fn reserve(&mut self, additional: usize) {
let new_size = self.len().checked_add(additional).expect("capacity overflow");
let min_cap = self.resize_policy.min_capacity(new_size);
/// 1) Make sure the new capacity is enough for all the elements, accounting
/// for the load factor.
/// 2) Ensure new_capacity is a power of two or zero.
- fn resize(&mut self, new_capacity: uint) {
+ fn resize(&mut self, new_capacity: usize) {
assert!(self.table.size() <= new_capacity);
assert!(new_capacity.is_power_of_two() || new_capacity == 0);
if (ib as int) < robin_ib {
// Found a luckier bucket than me. Better steal his spot.
- return robin_hood(bucket, robin_ib as uint, hash, k, v);
+ return robin_hood(bucket, robin_ib as usize, hash, k, v);
}
probe = bucket.next();
/// assert_eq!(a.len(), 1);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn len(&self) -> uint { self.table.size() }
+ pub fn len(&self) -> usize { self.table.size() }
/// Returns true if the map contains no elements.
///
return Vacant(VacantEntry {
hash: hash,
key: k,
- elem: NeqElem(bucket, robin_ib as uint),
+ elem: NeqElem(bucket, robin_ib as usize),
});
}
enum VacantEntryState<K, V, M> {
/// The index is occupied, but the key to insert has precedence,
/// and will kick the current one out on insertion.
- NeqElem(FullBucket<K, V, M>, uint),
+ NeqElem(FullBucket<K, V, M>, usize),
/// The index is genuinely vacant.
NoElem(EmptyBucket<K, V, M>),
}
#[derive(Hash, PartialEq, Eq)]
struct Dropable {
- k: uint
+ k: usize
}
impl Dropable {
- fn new(k: uint) -> Dropable {
+ fn new(k: usize) -> Dropable {
DROP_VECTOR.with(|slot| {
slot.borrow_mut()[k] += 1;
});
let mut m = HashMap::new();
DROP_VECTOR.with(|v| {
- for i in 0u..200 {
+ for i in 0..200 {
assert_eq!(v.borrow()[i], 0);
}
});
- for i in 0u..100 {
+ for i in 0..100 {
let d1 = Dropable::new(i);
let d2 = Dropable::new(i+100);
m.insert(d1, d2);
}
DROP_VECTOR.with(|v| {
- for i in 0u..200 {
+ for i in 0..200 {
assert_eq!(v.borrow()[i], 1);
}
});
- for i in 0u..50 {
+ for i in 0..50 {
let k = Dropable::new(i);
let v = m.remove(&k);
}
DROP_VECTOR.with(|v| {
- for i in 0u..50 {
+ for i in 0..50 {
assert_eq!(v.borrow()[i], 0);
assert_eq!(v.borrow()[i+100], 0);
}
- for i in 50u..100 {
+ for i in 50..100 {
assert_eq!(v.borrow()[i], 1);
assert_eq!(v.borrow()[i+100], 1);
}
}
DROP_VECTOR.with(|v| {
- for i in 0u..200 {
+ for i in 0..200 {
assert_eq!(v.borrow()[i], 0);
}
});
let mut hm = HashMap::new();
DROP_VECTOR.with(|v| {
- for i in 0u..200 {
+ for i in 0..200 {
assert_eq!(v.borrow()[i], 0);
}
});
- for i in 0u..100 {
+ for i in 0..100 {
let d1 = Dropable::new(i);
let d2 = Dropable::new(i+100);
hm.insert(d1, d2);
}
DROP_VECTOR.with(|v| {
- for i in 0u..200 {
+ for i in 0..200 {
assert_eq!(v.borrow()[i], 1);
}
});
let mut half = hm.into_iter().take(50);
DROP_VECTOR.with(|v| {
- for i in 0u..200 {
+ for i in 0..200 {
assert_eq!(v.borrow()[i], 1);
}
});
for _ in half.by_ref() {}
DROP_VECTOR.with(|v| {
- let nk = (0u..100).filter(|&i| {
+ let nk = (0..100).filter(|&i| {
v.borrow()[i] == 1
}).count();
- let nv = (0u..100).filter(|&i| {
+ let nv = (0..100).filter(|&i| {
v.borrow()[i+100] == 1
}).count();
};
DROP_VECTOR.with(|v| {
- for i in 0u..200 {
+ for i in 0..200 {
assert_eq!(v.borrow()[i], 0);
}
});
#[test]
fn test_iterate() {
let mut m = HashMap::with_capacity(4);
- for i in 0u..32 {
+ for i in 0..32 {
assert!(m.insert(i, i*2).is_none());
}
assert_eq!(m.len(), 32);
#[test]
fn test_keys() {
let vec = vec![(1, 'a'), (2, 'b'), (3, 'c')];
- let map = vec.into_iter().collect::<HashMap<int, char>>();
- let keys = map.keys().map(|&k| k).collect::<Vec<int>>();
+ let map: HashMap<_, _> = vec.into_iter().collect();
+ let keys: Vec<_> = map.keys().cloned().collect();
assert_eq!(keys.len(), 3);
assert!(keys.contains(&1));
assert!(keys.contains(&2));
#[test]
fn test_values() {
let vec = vec![(1, 'a'), (2, 'b'), (3, 'c')];
- let map = vec.into_iter().collect::<HashMap<int, char>>();
- let values = map.values().map(|&v| v).collect::<Vec<char>>();
+ let map: HashMap<_, _> = vec.into_iter().collect();
+ let values: Vec<_> = map.values().cloned().collect();
assert_eq!(values.len(), 3);
assert!(values.contains(&'a'));
assert!(values.contains(&'b'));
#[test]
fn test_show() {
- let mut map: HashMap<int, int> = HashMap::new();
- let empty: HashMap<int, int> = HashMap::new();
+ let mut map = HashMap::new();
+ let empty: HashMap<i32, i32> = HashMap::new();
map.insert(1, 2);
map.insert(3, 4);
assert_eq!(m.len(), 0);
assert!(m.is_empty());
- let mut i = 0u;
+ let mut i = 0;
let old_cap = m.table.capacity();
while old_cap == m.table.capacity() {
m.insert(i, i);
assert_eq!(cap, initial_cap * 2);
- let mut i = 0u;
+ let mut i = 0;
for _ in 0..cap * 3 / 4 {
m.insert(i, i);
i += 1;
#[test]
fn test_reserve_shrink_to_fit() {
let mut m = HashMap::new();
- m.insert(0u, 0u);
+ m.insert(0, 0);
m.remove(&0);
assert!(m.capacity() >= m.len());
- for i in 0us..128 {
+ for i in 0..128 {
m.insert(i, i);
}
m.reserve(256);
let usable_cap = m.capacity();
- for i in 128us..128+256 {
+ for i in 128..(128 + 256) {
m.insert(i, i);
assert_eq!(m.capacity(), usable_cap);
}
- for i in 100us..128+256 {
+ for i in 100..(128 + 256) {
assert_eq!(m.remove(&i), Some(i));
}
m.shrink_to_fit();
assert!(!m.is_empty());
assert!(m.capacity() >= m.len());
- for i in 0us..100 {
+ for i in 0..100 {
assert_eq!(m.remove(&i), Some(i));
}
m.shrink_to_fit();
fn test_from_iter() {
let xs = [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)];
- let map: HashMap<int, int> = xs.iter().map(|&x| x).collect();
+ let map: HashMap<_, _> = xs.iter().cloned().collect();
for &(k, v) in &xs {
assert_eq!(map.get(&k), Some(&v));
fn test_size_hint() {
let xs = [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)];
- let map: HashMap<int, int> = xs.iter().map(|&x| x).collect();
+ let map: HashMap<_, _> = xs.iter().cloned().collect();
let mut iter = map.iter();
fn test_iter_len() {
let xs = [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)];
- let map: HashMap<int, int> = xs.iter().map(|&x| x).collect();
+ let map: HashMap<_, _> = xs.iter().cloned().collect();
let mut iter = map.iter();
fn test_mut_size_hint() {
let xs = [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)];
- let mut map: HashMap<int, int> = xs.iter().map(|&x| x).collect();
+ let mut map: HashMap<_, _> = xs.iter().cloned().collect();
let mut iter = map.iter_mut();
fn test_iter_mut_len() {
let xs = [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)];
- let mut map: HashMap<int, int> = xs.iter().map(|&x| x).collect();
+ let mut map: HashMap<_, _> = xs.iter().cloned().collect();
let mut iter = map.iter_mut();
#[test]
fn test_index() {
- let mut map: HashMap<int, int> = HashMap::new();
+ let mut map = HashMap::new();
map.insert(1, 2);
map.insert(2, 1);
#[test]
#[should_fail]
fn test_index_nonexistent() {
- let mut map: HashMap<int, int> = HashMap::new();
+ let mut map = HashMap::new();
map.insert(1, 2);
map.insert(2, 1);
fn test_entry(){
let xs = [(1, 10), (2, 20), (3, 30), (4, 40), (5, 50), (6, 60)];
- let mut map: HashMap<int, int> = xs.iter().map(|&x| x).collect();
+ let mut map: HashMap<_, _> = xs.iter().cloned().collect();
// Existing key (insert)
match map.entry(1) {
#[test]
fn test_entry_take_doesnt_corrupt() {
// Test for #19292
- fn check(m: &HashMap<int, ()>) {
+ fn check(m: &HashMap<isize, ()>) {
for k in m.keys() {
assert!(m.contains_key(k),
"{} is in keys() but not in the map?", k);
let mut rng = weak_rng();
// Populate the map with some items.
- for _ in 0u..50 {
+ for _ in 0..50 {
let x = rng.gen_range(-10, 10);
m.insert(x, ());
}
- for i in 0u..1000 {
+ for i in 0..1000 {
let x = rng.gen_range(-10, 10);
match m.entry(x) {
Vacant(_) => {},
/// #[derive(Hash, Eq, PartialEq, Debug)]
/// struct Viking<'a> {
/// name: &'a str,
-/// power: uint,
+/// power: usize,
/// }
///
/// let mut vikings = HashSet::new();
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn with_capacity(capacity: uint) -> HashSet<T, RandomState> {
+ pub fn with_capacity(capacity: usize) -> HashSet<T, RandomState> {
HashSet { map: HashMap::with_capacity(capacity) }
}
}
/// ```
#[inline]
#[unstable(feature = "std_misc", reason = "hasher stuff is unclear")]
- pub fn with_capacity_and_hash_state(capacity: uint, hash_state: S)
+ pub fn with_capacity_and_hash_state(capacity: usize, hash_state: S)
-> HashSet<T, S> {
HashSet {
map: HashMap::with_capacity_and_hash_state(capacity, hash_state),
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn capacity(&self) -> uint {
+ pub fn capacity(&self) -> usize {
self.map.capacity()
}
///
/// # Panics
///
- /// Panics if the new allocation size overflows `uint`.
+ /// Panics if the new allocation size overflows `usize`.
///
/// # Example
///
/// set.reserve(10);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn reserve(&mut self, additional: uint) {
+ pub fn reserve(&mut self, additional: usize) {
self.map.reserve(additional)
}
/// assert_eq!(v.len(), 1);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn len(&self) -> uint { self.map.len() }
+ pub fn len(&self) -> usize { self.map.len() }
/// Returns true if the set contains no elements
///
/// ```
/// use std::collections::HashSet;
///
- /// let set: HashSet<uint> = [1, 2, 3].iter().map(|&x| x).collect();
+ /// let set: HashSet<_> = [1, 2, 3].iter().cloned().collect();
/// assert_eq!(set.contains(&1), true);
/// assert_eq!(set.contains(&4), false);
/// ```
/// ```
/// use std::collections::HashSet;
///
- /// let a: HashSet<uint> = [1, 2, 3].iter().map(|&x| x).collect();
- /// let mut b: HashSet<uint> = HashSet::new();
+ /// let a: HashSet<_> = [1, 2, 3].iter().cloned().collect();
+ /// let mut b = HashSet::new();
///
/// assert_eq!(a.is_disjoint(&b), true);
/// b.insert(4);
/// ```
/// use std::collections::HashSet;
///
- /// let sup: HashSet<uint> = [1, 2, 3].iter().map(|&x| x).collect();
- /// let mut set: HashSet<uint> = HashSet::new();
+ /// let sup: HashSet<_> = [1, 2, 3].iter().cloned().collect();
+ /// let mut set = HashSet::new();
///
/// assert_eq!(set.is_subset(&sup), true);
/// set.insert(2);
/// ```
/// use std::collections::HashSet;
///
- /// let sub: HashSet<uint> = [1, 2].iter().map(|&x| x).collect();
- /// let mut set: HashSet<uint> = HashSet::new();
+ /// let sub: HashSet<_> = [1, 2].iter().cloned().collect();
+ /// let mut set = HashSet::new();
///
/// assert_eq!(set.is_superset(&sub), false);
///
/// ```
/// use std::collections::HashSet;
///
- /// let a: HashSet<int> = vec![1, 2, 3].into_iter().collect();
- /// let b: HashSet<int> = vec![3, 4, 5].into_iter().collect();
+ /// let a: HashSet<_> = vec![1, 2, 3].into_iter().collect();
+ /// let b: HashSet<_> = vec![3, 4, 5].into_iter().collect();
///
- /// let set: HashSet<int> = &a | &b;
+ /// let set = &a | &b;
///
/// let mut i = 0;
/// let expected = [1, 2, 3, 4, 5];
/// ```
/// use std::collections::HashSet;
///
- /// let a: HashSet<int> = vec![1, 2, 3].into_iter().collect();
- /// let b: HashSet<int> = vec![2, 3, 4].into_iter().collect();
+ /// let a: HashSet<_> = vec![1, 2, 3].into_iter().collect();
+ /// let b: HashSet<_> = vec![2, 3, 4].into_iter().collect();
///
- /// let set: HashSet<int> = &a & &b;
+ /// let set = &a & &b;
///
/// let mut i = 0;
/// let expected = [2, 3];
/// ```
/// use std::collections::HashSet;
///
- /// let a: HashSet<int> = vec![1, 2, 3].into_iter().collect();
- /// let b: HashSet<int> = vec![3, 4, 5].into_iter().collect();
+ /// let a: HashSet<_> = vec![1, 2, 3].into_iter().collect();
+ /// let b: HashSet<_> = vec![3, 4, 5].into_iter().collect();
///
- /// let set: HashSet<int> = &a ^ &b;
+ /// let set = &a ^ &b;
///
/// let mut i = 0;
/// let expected = [1, 2, 4, 5];
/// ```
/// use std::collections::HashSet;
///
- /// let a: HashSet<int> = vec![1, 2, 3].into_iter().collect();
- /// let b: HashSet<int> = vec![3, 4, 5].into_iter().collect();
+ /// let a: HashSet<_> = vec![1, 2, 3].into_iter().collect();
+ /// let b: HashSet<_> = vec![3, 4, 5].into_iter().collect();
///
- /// let set: HashSet<int> = &a - &b;
+ /// let set = &a - &b;
///
/// let mut i = 0;
/// let expected = [1, 2];
#[test]
fn test_iterate() {
let mut a = HashSet::new();
- for i in 0u..32 {
+ for i in 0..32 {
assert!(a.insert(i));
}
let mut observed: u32 = 0;
fn test_from_iter() {
let xs = [1, 2, 3, 4, 5, 6, 7, 8, 9];
- let set: HashSet<int> = xs.iter().map(|&x| x).collect();
+ let set: HashSet<_> = xs.iter().cloned().collect();
for x in &xs {
assert!(set.contains(x));
#[test]
fn test_show() {
- let mut set: HashSet<int> = HashSet::new();
- let empty: HashSet<int> = HashSet::new();
+ let mut set = HashSet::new();
+ let empty = HashSet::<i32>::new();
set.insert(1);
set.insert(2);
#[test]
fn test_trivial_drain() {
- let mut s = HashSet::<int>::new();
+ let mut s = HashSet::<i32>::new();
for _ in s.drain() {}
assert!(s.is_empty());
drop(s);
- let mut s = HashSet::<int>::new();
+ let mut s = HashSet::<i32>::new();
drop(s.drain());
assert!(s.is_empty());
}
#[test]
fn test_drain() {
- let mut s: HashSet<i32> = (1..100).collect();
+ let mut s: HashSet<_> = (1..100).collect();
// try this a bunch of times to make sure we don't screw up internal state.
for _ in 0..20 {
/// but in general is just a tricked out `Vec<Option<u64, K, V>>`.
#[unsafe_no_drop_flag]
pub struct RawTable<K, V> {
- capacity: uint,
- size: uint,
+ capacity: usize,
+ size: usize,
hashes: *mut u64,
// Because K/V do not appear directly in any of the types in the struct,
// inform rustc that in fact instances of K and V are reachable from here.
pub struct Bucket<K, V, M> {
raw: RawBucket<K, V>,
- idx: uint,
+ idx: usize,
table: M
}
pub struct EmptyBucket<K, V, M> {
raw: RawBucket<K, V>,
- idx: uint,
+ idx: usize,
table: M
}
pub struct FullBucket<K, V, M> {
raw: RawBucket<K, V>,
- idx: uint,
+ idx: usize,
table: M
}
self.table
}
/// Get the raw index.
- pub fn index(&self) -> uint {
+ pub fn index(&self) -> usize {
self.idx
}
}
self.table
}
/// Get the raw index.
- pub fn index(&self) -> uint {
+ pub fn index(&self) -> usize {
self.idx
}
}
impl<K, V, M: Deref<Target=RawTable<K, V>>> Bucket<K, V, M> {
pub fn new(table: M, hash: SafeHash) -> Bucket<K, V, M> {
- Bucket::at_index(table, hash.inspect() as uint)
+ Bucket::at_index(table, hash.inspect() as usize)
}
- pub fn at_index(table: M, ib_index: uint) -> Bucket<K, V, M> {
+ pub fn at_index(table: M, ib_index: usize) -> Bucket<K, V, M> {
let ib_index = ib_index & (table.capacity() - 1);
Bucket {
raw: unsafe {
- table.first_bucket_raw().offset(ib_index as int)
+ table.first_bucket_raw().offset(ib_index as isize)
},
idx: ib_index,
table: table
// ... and it's zero at all other times.
let maybe_wraparound_dist = (self.idx ^ (self.idx + 1)) & self.table.capacity();
// Finally, we obtain the offset 1 or the offset -cap + 1.
- let dist = 1 - (maybe_wraparound_dist as int);
+ let dist = 1 - (maybe_wraparound_dist as isize);
self.idx += 1;
///
/// In the cited blog posts above, this is called the "distance to
/// initial bucket", or DIB. Also known as "probe count".
- pub fn distance(&self) -> uint {
+ pub fn distance(&self) -> usize {
// Calculates the distance one has to travel when going from
// `hash mod capacity` onwards to `idx mod capacity`, wrapping around
// if the destination is not reached before the end of the table.
- (self.idx - self.hash().inspect() as uint) & (self.table.capacity() - 1)
+ (self.idx - self.hash().inspect() as usize) & (self.table.capacity() - 1)
}
#[inline]
/// # Panics
///
/// Panics if `target_alignment` is not a power of two.
-fn round_up_to_next(unrounded: uint, target_alignment: uint) -> uint {
+fn round_up_to_next(unrounded: usize, target_alignment: usize) -> usize {
assert!(target_alignment.is_power_of_two());
(unrounded + target_alignment - 1) & !(target_alignment - 1)
}
// Returns a tuple of (key_offset, val_offset),
// from the start of a mallocated array.
-fn calculate_offsets(hashes_size: uint,
- keys_size: uint, keys_align: uint,
- vals_align: uint)
- -> (uint, uint) {
+fn calculate_offsets(hashes_size: usize,
+ keys_size: usize, keys_align: usize,
+ vals_align: usize)
+ -> (usize, usize) {
let keys_offset = round_up_to_next(hashes_size, keys_align);
let end_of_keys = keys_offset + keys_size;
// Returns a tuple of (minimum required malloc alignment, hash_offset,
// array_size), from the start of a mallocated array.
-fn calculate_allocation(hash_size: uint, hash_align: uint,
- keys_size: uint, keys_align: uint,
- vals_size: uint, vals_align: uint)
- -> (uint, uint, uint) {
+fn calculate_allocation(hash_size: usize, hash_align: usize,
+ keys_size: usize, keys_align: usize,
+ vals_size: usize, vals_align: usize)
+ -> (usize, usize, usize) {
let hash_offset = 0;
let (_, vals_offset) = calculate_offsets(hash_size,
keys_size, keys_align,
impl<K, V> RawTable<K, V> {
/// Does not initialize the buckets. The caller should ensure they,
/// at the very least, set every hash to EMPTY_BUCKET.
- unsafe fn new_uninitialized(capacity: uint) -> RawTable<K, V> {
+ unsafe fn new_uninitialized(capacity: usize) -> RawTable<K, V> {
if capacity == 0 {
return RawTable {
size: 0,
let buffer = allocate(size, malloc_alignment);
if buffer.is_null() { ::alloc::oom() }
- let hashes = buffer.offset(hash_offset as int) as *mut u64;
+ let hashes = buffer.offset(hash_offset as isize) as *mut u64;
RawTable {
capacity: capacity,
unsafe {
RawBucket {
hash: self.hashes,
- key: buffer.offset(keys_offset as int) as *mut K,
- val: buffer.offset(vals_offset as int) as *mut V
+ key: buffer.offset(keys_offset as isize) as *mut K,
+ val: buffer.offset(vals_offset as isize) as *mut V
}
}
}
/// Creates a new raw table from a given capacity. All buckets are
/// initially empty.
- pub fn new(capacity: uint) -> RawTable<K, V> {
+ pub fn new(capacity: usize) -> RawTable<K, V> {
unsafe {
let ret = RawTable::new_uninitialized(capacity);
zero_memory(ret.hashes, capacity);
}
/// The hashtable's capacity, similar to a vector's.
- pub fn capacity(&self) -> uint {
+ pub fn capacity(&self) -> usize {
self.capacity
}
/// The number of elements ever `put` in the hashtable, minus the number
/// of elements ever `take`n.
- pub fn size(&self) -> uint {
+ pub fn size(&self) -> usize {
self.size
}
RawBuckets {
raw: self.first_bucket_raw(),
hashes_end: unsafe {
- self.hashes.offset(self.capacity as int)
+ self.hashes.offset(self.capacity as isize)
},
marker: marker::ContravariantLifetime,
}
unsafe fn rev_move_buckets(&mut self) -> RevMoveBuckets<K, V> {
let raw_bucket = self.first_bucket_raw();
RevMoveBuckets {
- raw: raw_bucket.offset(self.capacity as int),
+ raw: raw_bucket.offset(self.capacity as isize),
hashes_end: raw_bucket.hash,
elems_left: self.size,
marker: marker::ContravariantLifetime,
struct RevMoveBuckets<'a, K, V> {
raw: RawBucket<K, V>,
hashes_end: *mut u64,
- elems_left: uint,
+ elems_left: usize,
marker: marker::ContravariantLifetime<'a>,
}
/// Iterator over shared references to entries in a table.
pub struct Iter<'a, K: 'a, V: 'a> {
iter: RawBuckets<'a, K, V>,
- elems_left: uint,
+ elems_left: usize,
}
// FIXME(#19839) Remove in favor of `#[derive(Clone)]`
/// Iterator over mutable references to entries in a table.
pub struct IterMut<'a, K: 'a, V: 'a> {
iter: RawBuckets<'a, K, V>,
- elems_left: uint,
+ elems_left: usize,
}
/// Iterator over the entries in a table, consuming the table.
projects / rust.git / commitdiff