nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2025-05-14 02:49:40 +00:00
Code Issues Packages Projects Releases Wiki Activity

Rollup merge of #21969 - Gankro:collections-cleanup, r=alexcrichton

Browse Source 
This is 99% burning ints to the ground, but I also got rid of useless annotations or made code more \"idiomatic\" as I went along. Mostly changes in tests.
This commit is contained in:
Manish Goregaokar 2015-02-06 05:40:28 +05:30
commit f6d08b0b17
21 changed files with 1453 additions and 1488 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

35
src/libcollections/bench.rs
View File

@ -13,40 +13,40 @@ use std::rand;
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);
}
@ -60,18 +60,17 @@ pub fn insert_seq_n<M, I, R>(n: uint,
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);
@ -88,16 +87,16 @@ pub fn find_rand_n<M, T, I, F>(n: uint,
})
}
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);
}

121
src/libcollections/binary_heap.rs
View File

@ -28,12 +28,12 @@
//! ```
//! 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`.
@ -53,21 +53,21 @@
//! }
//! }
//!
//! // 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();
//!
@ -98,7 +98,7 @@
//! }
//!
//! // Goal not reachable
//! uint::MAX
//! usize::MAX
//! }
//!
//! fn main() {
@ -143,7 +143,7 @@
//! 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);
//! }
//! ```
@ -201,7 +201,7 @@ impl<T: Ord> BinaryHeap<T> {
/// 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) }
}
@ -295,7 +295,7 @@ impl<T: Ord> BinaryHeap<T> {
/// 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.
@ -306,7 +306,7 @@ impl<T: Ord> BinaryHeap<T> {
///
/// # Panics
///
/// Panics if the new capacity overflows `uint`.
/// Panics if the new capacity overflows `usize`.
///
/// # Examples
///
@ -318,7 +318,7 @@ impl<T: Ord> BinaryHeap<T> {
/// 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);
}
@ -327,7 +327,7 @@ impl<T: Ord> BinaryHeap<T> {
///
/// # Panics
///
/// Panics if the new capacity overflows `uint`.
/// Panics if the new capacity overflows `usize`.
///
/// # Examples
///
@ -339,7 +339,7 @@ impl<T: Ord> BinaryHeap<T> {
/// 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);
}
@ -497,7 +497,7 @@ impl<T: Ord> BinaryHeap<T> {
// 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());
@ -514,7 +514,7 @@ impl<T: Ord> BinaryHeap<T> {
}
}
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());
@ -536,14 +536,14 @@ impl<T: Ord> BinaryHeap<T> {
}
}
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")]
@ -584,7 +584,7 @@ impl<'a, T> Iterator for Iter<'a, T> {
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")]
@ -610,7 +610,7 @@ impl<T> Iterator for IntoIter<T> {
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")]
@ -636,7 +636,7 @@ impl<'a, T: 'a> Iterator for Drain<'a, T> {
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")]
@ -692,7 +692,7 @@ mod tests {
#[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;
@ -704,27 +704,27 @@ mod tests {
#[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().cloned().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();
@ -741,17 +741,17 @@ mod tests {
#[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);
@ -763,7 +763,7 @@ mod tests {
#[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);
@ -785,7 +785,7 @@ mod tests {
#[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);
@ -807,7 +807,7 @@ mod tests {
#[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);
@ -821,7 +821,7 @@ mod tests {
#[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);
@ -833,7 +833,7 @@ mod tests {
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();
@ -845,44 +845,44 @@ mod tests {
#[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);
@ -891,8 +891,7 @@ mod tests {
#[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);

496
src/libcollections/bit.rs
View File

File diff suppressed because it is too large Load Diff

110
src/libcollections/btree/map.rs
View File

@ -63,36 +63,20 @@ use super::node::{self, Node, Found, GoDown};
/// 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.
@ -171,7 +155,7 @@ impl<K: Ord, V> BTreeMap<K, V> {
/// 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,
@ -1001,7 +985,7 @@ impl<K, V, E, T> Iterator for AbsIter<T> where
}
}
fn size_hint(&self) -> (uint, Option<uint>) {
fn size_hint(&self) -> (usize, Option<usize>) {
(self.size, Some(self.size))
}
}
@ -1038,7 +1022,7 @@ impl<'a, K, V> Iterator for Iter<'a, K, V> {
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> {
@ -1052,7 +1036,7 @@ impl<'a, K, V> Iterator for IterMut<'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> {
@ -1066,7 +1050,7 @@ impl<K, V> Iterator for IntoIter<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> {
@ -1080,7 +1064,7 @@ impl<'a, K, V> Iterator for Keys<'a, 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> {
@ -1095,7 +1079,7 @@ impl<'a, K, V> Iterator for Values<'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> {
@ -1283,7 +1267,7 @@ impl<K, V> BTreeMap<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")]
@ -1329,7 +1313,7 @@ impl<K, V> BTreeMap<K, V> {
/// 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.
///
@ -1540,7 +1524,7 @@ impl<K: Ord, V> BTreeMap<K, V> {
/// 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() {
@ -1614,7 +1598,7 @@ mod test {
#[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 {
@ -1661,7 +1645,7 @@ mod test {
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));
@ -1674,12 +1658,12 @@ mod test {
#[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));
@ -1694,12 +1678,12 @@ mod test {
#[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));
@ -1714,13 +1698,13 @@ mod test {
#[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));
@ -1740,13 +1724,13 @@ mod test {
#[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;
@ -1756,10 +1740,10 @@ mod test {
#[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));
@ -1779,8 +1763,8 @@ mod test {
#[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 {
@ -1800,7 +1784,7 @@ mod test {
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) {
@ -1864,7 +1848,7 @@ mod bench {
#[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); });
@ -1872,7 +1856,7 @@ mod bench {
#[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); });
@ -1881,7 +1865,7 @@ mod bench {
// 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); });
@ -1889,7 +1873,7 @@ mod bench {
#[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); });
@ -1898,7 +1882,7 @@ mod bench {
// 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); });
@ -1906,7 +1890,7 @@ mod bench {
#[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); });
@ -1915,7 +1899,7 @@ mod bench {
// 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); });
@ -1923,14 +1907,14 @@ mod bench {
#[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 {

122
src/libcollections/btree/node.rs
View File

@ -65,7 +65,7 @@ pub struct Node<K, V> {
//
// 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
@ -74,7 +74,7 @@ pub struct Node<K, V> {
//
// 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> {
@ -102,7 +102,7 @@ struct MutNodeSlice<'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)
}
@ -120,10 +120,10 @@ fn test_rounding() {
// 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;
@ -135,10 +135,10 @@ fn calculate_offsets(keys_size: uint,
// 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);
@ -159,7 +159,7 @@ fn test_offset_calculation() {
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 {
@ -175,7 +175,7 @@ fn calculate_allocation_generic<K, V>(capacity: uint, is_leaf: bool) -> (uint, u
)
}
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>();
@ -203,16 +203,16 @@ impl<T> RawItems<T> {
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),
}
}
}
@ -221,7 +221,7 @@ impl<T> RawItems<T> {
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);
}
@ -239,7 +239,7 @@ impl<T> Iterator for RawItems<T> {
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);
}
@ -257,7 +257,7 @@ impl<T> DoubleEndedIterator for RawItems<T> {
} 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);
}
@ -299,7 +299,7 @@ impl<K, V> Drop for Node<K, V> {
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);
@ -309,15 +309,15 @@ impl<K, V> Node<K, V> {
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) };
@ -327,7 +327,7 @@ impl<K, V> Node<K, V> {
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,
@ -479,15 +479,15 @@ impl<K: Clone, V: Clone> Clone for Node<K, V> {
///
/// ```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 {
@ -524,7 +524,7 @@ impl<K: Clone, V: Clone> Clone for Node<K, V> {
#[derive(Copy)]
pub struct Handle<NodeRef, Type, NodeType> {
node: NodeRef,
index: uint
index: usize
}
pub mod handle {
@ -546,7 +546,7 @@ impl<K: Ord, V> Node<K, V> {
-> 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 }),
@ -557,12 +557,12 @@ impl<K: Ord, V> Node<K, V> {
// 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;
@ -575,12 +575,12 @@ impl <K, V> Node<K, V> {
}
/// 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
}
@ -1038,7 +1038,7 @@ impl<K, V> Node<K, V> {
/// # 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");
@ -1114,15 +1114,15 @@ impl<K, V> Node<K, V> {
// 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
);
@ -1136,10 +1136,10 @@ impl<K, V> Node<K, V> {
// 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);
@ -1166,18 +1166,18 @@ impl<K, V> Node<K, V> {
// 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
);
@ -1188,12 +1188,12 @@ impl<K, V> Node<K, V> {
// 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
);
@ -1220,18 +1220,18 @@ impl<K, V> Node<K, V> {
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
);
}
@ -1260,18 +1260,18 @@ impl<K, V> Node<K, V> {
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
);
@ -1284,12 +1284,12 @@ impl<K, V> Node<K, V> {
}
/// 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
}
@ -1334,7 +1334,7 @@ struct MoveTraversalImpl<K, V> {
// For deallocation when we are done iterating.
ptr: *mut u8,
capacity: uint,
capacity: usize,
is_leaf: bool
}
@ -1490,7 +1490,7 @@ macro_rules! node_slice_impl {
$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)) {

62
src/libcollections/btree/set.rs
View File

@ -101,7 +101,7 @@ impl<T: Ord> BTreeSet<T> {
/// 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) }
}
}
@ -114,13 +114,13 @@ impl<T> BTreeSet<T> {
/// ```
/// 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")]
@ -135,9 +135,9 @@ impl<T> BTreeSet<T> {
/// ```
/// 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")]
@ -196,7 +196,7 @@ impl<T: Ord> BTreeSet<T> {
/// 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")]
@ -219,7 +219,7 @@ impl<T: Ord> BTreeSet<T> {
/// 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")]
@ -243,7 +243,7 @@ impl<T: Ord> BTreeSet<T> {
/// 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")]
@ -265,7 +265,7 @@ impl<T: Ord> BTreeSet<T> {
/// 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")]
@ -286,7 +286,7 @@ impl<T: Ord> BTreeSet<T> {
/// 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
///
@ -625,7 +625,7 @@ impl<'a, T> Iterator for Iter<'a, T> {
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> {
@ -640,7 +640,7 @@ impl<T> Iterator for IntoIter<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> {
@ -770,23 +770,23 @@ mod test {
}
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();
@ -801,7 +801,7 @@ mod test {
#[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))
}
@ -817,7 +817,7 @@ mod test {
#[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))
}
@ -834,8 +834,7 @@ mod test {
#[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))
}
@ -849,8 +848,7 @@ mod test {
#[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))
}
@ -865,9 +863,9 @@ mod test {
#[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");
@ -878,13 +876,13 @@ mod test {
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());
}

74
src/libcollections/dlist.rs
View File

@ -35,7 +35,7 @@ use core::ptr;
/// 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>>,
}
@ -61,7 +61,7 @@ struct 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).
@ -82,7 +82,7 @@ pub struct IterMut<'a, T:'a> {
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`.
@ -345,7 +345,7 @@ impl<T> DList<T> {
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
pub fn len(&self) -> uint {
pub fn len(&self) -> usize {
self.length
}
@ -578,7 +578,7 @@ impl<T> DList<T> {
/// 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 {
@ -659,7 +659,7 @@ impl<'a, A> Iterator for Iter<'a, A> {
}
#[inline]
fn size_hint(&self) -> (uint, Option<uint>) {
fn size_hint(&self) -> (usize, Option<usize>) {
(self.nelem, Some(self.nelem))
}
}
@ -701,7 +701,7 @@ impl<'a, A> Iterator for IterMut<'a, A> {
}
#[inline]
fn size_hint(&self) -> (uint, Option<uint>) {
fn size_hint(&self) -> (usize, Option<usize>) {
(self.nelem, Some(self.nelem))
}
}
@ -810,7 +810,7 @@ impl<A> Iterator for IntoIter<A> {
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))
}
}
@ -935,11 +935,11 @@ mod tests {
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 {
@ -968,7 +968,7 @@ mod tests {
#[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);
@ -1007,7 +1007,7 @@ mod tests {
}
#[cfg(test)]
fn generate_test() -> DList<int> {
fn generate_test() -> DList<i32> {
list_from(&[0,1,2,3,4,5,6])
}
@ -1020,7 +1020,7 @@ mod tests {
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);
@ -1122,7 +1122,7 @@ mod tests {
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);
@ -1170,7 +1170,7 @@ mod tests {
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);
@ -1187,7 +1187,7 @@ mod tests {
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);
@ -1245,14 +1245,14 @@ mod tests {
}
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());
@ -1268,13 +1268,13 @@ mod tests {
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);
@ -1307,7 +1307,7 @@ mod tests {
#[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);
@ -1349,7 +1349,7 @@ mod tests {
#[test]
fn test_fuzz() {
for _ in 0u..25 {
for _ in 0..25 {
fuzz_test(3);
fuzz_test(16);
fuzz_test(189);
@ -1358,18 +1358,16 @@ mod tests {
#[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);
@ -1398,7 +1396,7 @@ mod tests {
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);
@ -1410,13 +1408,13 @@ mod tests {
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);
})
@ -1424,7 +1422,7 @@ mod tests {
#[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);
})
@ -1432,7 +1430,7 @@ mod tests {
#[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();
@ -1441,7 +1439,7 @@ mod tests {
#[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();
@ -1451,7 +1449,7 @@ mod tests {
#[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);
})
@ -1459,7 +1457,7 @@ mod tests {
#[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);
})
@ -1467,7 +1465,7 @@ mod tests {
#[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);
})
@ -1475,7 +1473,7 @@ mod tests {
#[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);
})

58
src/libcollections/enum_set.rs
View File

@ -26,7 +26,7 @@ use core::ops::{Sub, BitOr, BitAnd, BitXor};
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> {}
@ -47,37 +47,37 @@ impl<E:CLike + fmt::Debug> fmt::Debug 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
}
@ -92,7 +92,7 @@ impl<E:CLike> EnumSet<E> {
/// 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()
}
@ -205,8 +205,8 @@ impl<E:CLike> BitXor for EnumSet<E> {
/// 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)]`
@ -220,7 +220,7 @@ impl<E> Clone for Iter<E> {
}
impl<E:CLike> Iter<E> {
fn new(bits: uint) -> Iter<E> {
fn new(bits: usize) -> Iter<E> {
Iter { index: 0, bits: bits }
}
}
@ -237,13 +237,13 @@ impl<E:CLike> Iterator for Iter<E> {
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))
}
@ -282,17 +282,17 @@ mod test {
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) }
}
}
@ -486,7 +486,7 @@ mod test {
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,
@ -498,11 +498,11 @@ mod test {
}
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) }
}
}

1
src/libcollections/lib.rs
View File

@ -26,7 +26,6 @@
#![feature(box_syntax)]
#![feature(core)]
#![feature(hash)]
#![feature(int_uint)]
#![feature(staged_api)]
#![feature(unboxed_closures)]
#![feature(unicode)]

222
src/libcollections/ring_buf.rs
View File

@ -32,8 +32,8 @@ use std::cmp;
use alloc::heap;
static INITIAL_CAPACITY: uint = 7u; // 2^3 - 1
static MINIMUM_CAPACITY: uint = 1u; // 2 - 1
static INITIAL_CAPACITY: usize = 7; // 2^3 - 1
static MINIMUM_CAPACITY: usize = 1; // 2 - 1
/// `RingBuf` is a circular buffer, which can be used as a double-ended queue efficiently.
#[stable(feature = "rust1", since = "1.0.0")]
@ -44,9 +44,9 @@ pub struct RingBuf<T> {
// 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
}
@ -59,7 +59,7 @@ unsafe impl<T: Sync> Sync for RingBuf<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()
}
}
@ -99,14 +99,14 @@ impl<T> RingBuf<T> {
/// 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
@ -115,31 +115,31 @@ impl<T> RingBuf<T> {
/// 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);
}
}
@ -153,7 +153,7 @@ impl<T> RingBuf<T> {
/// 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");
@ -192,10 +192,10 @@ impl<T> RingBuf<T> {
/// 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
}
@ -222,10 +222,10 @@ impl<T> RingBuf<T> {
/// 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
}
@ -251,13 +251,13 @@ impl<T> RingBuf<T> {
/// 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))
}
}
@ -274,7 +274,7 @@ impl<T> RingBuf<T> {
/// ```
#[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.
@ -285,7 +285,7 @@ impl<T> RingBuf<T> {
///
/// # Panics
///
/// Panics if the new capacity overflows `uint`.
/// Panics if the new capacity overflows `usize`.
///
/// # Examples
///
@ -297,7 +297,7 @@ impl<T> RingBuf<T> {
/// 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);
}
@ -306,7 +306,7 @@ impl<T> RingBuf<T> {
///
/// # Panics
///
/// Panics if the new capacity overflows `uint`.
/// Panics if the new capacity overflows `usize`.
///
/// # Examples
///
@ -318,7 +318,7 @@ impl<T> RingBuf<T> {
/// 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() {
@ -482,7 +482,7 @@ impl<T> RingBuf<T> {
/// ```
#[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();
}
@ -529,13 +529,13 @@ impl<T> RingBuf<T> {
/// assert_eq!(&buf.iter_mut().collect::<Vec<&mut i32>>()[], b);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
pub fn iter_mut<'a>(&'a mut self) -> IterMut<'a, T> {
pub fn iter_mut(&mut self) -> IterMut<T> {
IterMut {
tail: self.tail,
head: self.head,
cap: self.cap,
ptr: self.ptr,
marker: marker::ContravariantLifetime::<'a>,
marker: marker::ContravariantLifetime,
}
}
@ -552,7 +552,7 @@ impl<T> RingBuf<T> {
#[inline]
#[unstable(feature = "collections",
reason = "matches collection reform specification, waiting for dust to settle")]
pub fn as_slices<'a>(&'a self) -> (&'a [T], &'a [T]) {
pub fn as_slices(&self) -> (&[T], &[T]) {
unsafe {
let contiguous = self.is_contiguous();
let buf = self.buffer_as_slice();
@ -572,7 +572,7 @@ impl<T> RingBuf<T> {
#[inline]
#[unstable(feature = "collections",
reason = "matches collection reform specification, waiting for dust to settle")]
pub fn as_mut_slices<'a>(&'a mut self) -> (&'a mut [T], &'a mut [T]) {
pub fn as_mut_slices(&mut self) -> (&mut [T], &mut [T]) {
unsafe {
let contiguous = self.is_contiguous();
let head = self.head;
@ -604,7 +604,7 @@ impl<T> RingBuf<T> {
/// 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
///
@ -878,7 +878,7 @@ impl<T> RingBuf<T> {
/// ```
#[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);
@ -911,7 +911,7 @@ impl<T> RingBuf<T> {
/// ```
#[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);
@ -939,7 +939,7 @@ impl<T> RingBuf<T> {
/// 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);
@ -1144,7 +1144,7 @@ impl<T> RingBuf<T> {
/// 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;
}
@ -1312,7 +1312,7 @@ impl<T: Clone> RingBuf<T> {
/// ```
#[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 {
@ -1325,14 +1325,14 @@ impl<T: Clone> RingBuf<T> {
/// 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)
}
@ -1341,8 +1341,8 @@ fn count(tail: uint, head: uint, size: uint) -> uint {
#[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)]`
@ -1371,7 +1371,7 @@ impl<'a, T> Iterator for Iter<'a, T> {
}
#[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))
}
@ -1395,13 +1395,13 @@ impl<'a, T> ExactSizeIterator for Iter<'a, T> {}
#[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 {
@ -1418,9 +1418,9 @@ impl<'a, T> RandomAccessIterator for Iter<'a, T> {
#[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>,
}
@ -1437,12 +1437,12 @@ impl<'a, T> Iterator for IterMut<'a, T> {
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))
}
@ -1458,7 +1458,7 @@ impl<'a, T> DoubleEndedIterator for IterMut<'a, T> {
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))
}
}
}
@ -1482,7 +1482,7 @@ impl<T> Iterator for IntoIter<T> {
}
#[inline]
fn size_hint(&self) -> (uint, Option<uint>) {
fn size_hint(&self) -> (usize, Option<usize>) {
let len = self.inner.len();
(len, Some(len))
}
@ -1526,7 +1526,7 @@ impl<'a, T: 'a> Iterator for Drain<'a, T> {
}
#[inline]
fn size_hint(&self) -> (uint, Option<uint>) {
fn size_hint(&self) -> (usize, Option<usize>) {
let len = self.inner.len();
(len, Some(len))
}
@ -1580,21 +1580,21 @@ impl<S: Writer + Hasher, A: Hash<S>> Hash<S> for RingBuf<A> {
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<A> Index<uint> for RingBuf<A> {
impl<A> Index<usize> for RingBuf<A> {
type Output = A;
#[inline]
fn index<'a>(&'a self, i: &uint) -> &'a A {
fn index(&self, i: &usize) -> &A {
self.get(*i).expect("Out of bounds access")
}
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<A> IndexMut<uint> for RingBuf<A> {
impl<A> IndexMut<usize> for RingBuf<A> {
type Output = A;
#[inline]
fn index_mut<'a>(&'a mut self, i: &uint) -> &'a mut A {
fn index_mut(&mut self, i: &usize) -> &mut A {
self.get_mut(*i).expect("Out of bounds access")
}
}
@ -1673,13 +1673,13 @@ mod tests {
#[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();
@ -1690,15 +1690,15 @@ mod tests {
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]);
@ -1743,21 +1743,21 @@ mod tests {
#[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);
}
}
@ -1765,7 +1765,7 @@ mod tests {
#[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);
@ -1775,7 +1775,7 @@ mod tests {
#[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];
@ -1784,7 +1784,7 @@ mod tests {
#[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);
})
}
@ -1815,7 +1815,7 @@ mod tests {
#[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;
@ -1828,7 +1828,7 @@ mod tests {
#[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;
@ -1852,7 +1852,7 @@ mod tests {
#[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;
@ -1865,7 +1865,7 @@ mod tests {
#[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;
@ -1978,11 +1978,7 @@ mod tests {
#[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);
}
@ -1990,21 +1986,17 @@ mod tests {
#[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]
@ -2018,7 +2010,7 @@ mod tests {
}
{
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 {
@ -2026,7 +2018,7 @@ mod tests {
}
{
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();
@ -2049,14 +2041,14 @@ mod tests {
}
{
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]
@ -2070,8 +2062,8 @@ mod tests {
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]
@ -2079,7 +2071,7 @@ mod tests {
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);
}
@ -2102,7 +2094,7 @@ mod tests {
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);
}
@ -2141,7 +2133,7 @@ mod tests {
}
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
@ -2155,7 +2147,7 @@ mod tests {
}
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
@ -2224,7 +2216,7 @@ mod tests {
// partially used
{
let mut d: RingBuf<i32> = RingBuf::new();
let mut d: RingBuf<_> = RingBuf::new();
for i in 0..5 {
d.push_back(i);
}
@ -2250,12 +2242,12 @@ mod tests {
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);
}
@ -2269,14 +2261,14 @@ mod tests {
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]
@ -2333,18 +2325,18 @@ mod tests {
#[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) {
@ -2364,7 +2356,7 @@ mod tests {
#[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) {
@ -2388,7 +2380,7 @@ mod tests {
#[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) {

658
src/libcollections/slice.rs
View File

File diff suppressed because it is too large Load Diff

220
src/libcollections/str.rs
View File

@ -241,7 +241,7 @@ impl<'a> Iterator for Decompositions<'a> {
}
}
fn size_hint(&self) -> (uint, Option<uint>) {
fn size_hint(&self) -> (usize, Option<usize>) {
let (lower, _) = self.iter.size_hint();
(lower, None)
}
@ -367,7 +367,7 @@ impl<'a> Iterator for Utf16Units<'a> {
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() }
}
/*
@ -464,7 +464,7 @@ pub trait StrExt: Index<RangeFull, Output = str> {
#[inline]
#[unstable(feature = "collections",
reason = "this functionality may be moved to libunicode")]
fn nfd_chars<'a>(&'a self) -> Decompositions<'a> {
fn nfd_chars(&self) -> Decompositions {
Decompositions {
iter: self[].chars(),
buffer: Vec::new(),
@ -478,7 +478,7 @@ pub trait StrExt: Index<RangeFull, Output = str> {
#[inline]
#[unstable(feature = "collections",
reason = "this functionality may be moved to libunicode")]
fn nfkd_chars<'a>(&'a self) -> Decompositions<'a> {
fn nfkd_chars(&self) -> Decompositions {
Decompositions {
iter: self[].chars(),
buffer: Vec::new(),
@ -492,7 +492,7 @@ pub trait StrExt: Index<RangeFull, Output = str> {
#[inline]
#[unstable(feature = "collections",
reason = "this functionality may be moved to libunicode")]
fn nfc_chars<'a>(&'a self) -> Recompositions<'a> {
fn nfc_chars(&self) -> Recompositions {
Recompositions {
iter: self.nfd_chars(),
state: Composing,
@ -507,7 +507,7 @@ pub trait StrExt: Index<RangeFull, Output = str> {
#[inline]
#[unstable(feature = "collections",
reason = "this functionality may be moved to libunicode")]
fn nfkc_chars<'a>(&'a self) -> Recompositions<'a> {
fn nfkc_chars(&self) -> Recompositions {
Recompositions {
iter: self.nfkd_chars(),
state: Composing,
@ -629,7 +629,7 @@ pub trait StrExt: Index<RangeFull, Output = str> {
/// assert_eq!(v, vec![""]);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
fn splitn<P: CharEq>(&self, count: uint, pat: P) -> SplitN<P> {
fn splitn<P: CharEq>(&self, count: usize, pat: P) -> SplitN<P> {
core_str::StrExt::splitn(&self[], count, pat)
}
@ -679,7 +679,7 @@ pub trait StrExt: Index<RangeFull, Output = str> {
/// assert_eq!(v, vec!["leopard", "tiger", "lionX"]);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
fn rsplitn<P: CharEq>(&self, count: uint, pat: P) -> RSplitN<P> {
fn rsplitn<P: CharEq>(&self, count: usize, pat: P) -> RSplitN<P> {
core_str::StrExt::rsplitn(&self[], count, pat)
}
@ -694,13 +694,13 @@ pub trait StrExt: Index<RangeFull, Output = str> {
/// # 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",
@ -762,19 +762,19 @@ pub trait StrExt: Index<RangeFull, Output = str> {
#[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`).
@ -801,7 +801,7 @@ pub trait StrExt: Index<RangeFull, Output = str> {
/// ```
#[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)
}
@ -812,7 +812,7 @@ pub trait StrExt: Index<RangeFull, Output = str> {
/// 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)
}
@ -925,7 +925,7 @@ pub trait StrExt: Index<RangeFull, Output = str> {
/// ```
#[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)
}
@ -945,7 +945,7 @@ pub trait StrExt: Index<RangeFull, Output = str> {
/// 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);
@ -975,7 +975,7 @@ pub trait StrExt: Index<RangeFull, Output = str> {
///
/// # 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
@ -984,7 +984,7 @@ pub trait StrExt: Index<RangeFull, Output = str> {
/// 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)
}
@ -1000,7 +1000,7 @@ pub trait StrExt: Index<RangeFull, Output = str> {
/// 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)
}
@ -1021,7 +1021,7 @@ pub trait StrExt: Index<RangeFull, Output = str> {
/// 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)
}
@ -1033,7 +1033,7 @@ pub trait StrExt: Index<RangeFull, Output = str> {
/// 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)
}
@ -1073,7 +1073,7 @@ pub trait StrExt: Index<RangeFull, Output = str> {
/// 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)
}
@ -1101,7 +1101,7 @@ pub trait StrExt: Index<RangeFull, Output = str> {
/// 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)
}
@ -1126,7 +1126,7 @@ pub trait StrExt: Index<RangeFull, Output = str> {
/// ```
#[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)
}
@ -1170,7 +1170,7 @@ pub trait StrExt: Index<RangeFull, Output = str> {
/// ```
#[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)
}
@ -1202,7 +1202,7 @@ pub trait StrExt: Index<RangeFull, Output = str> {
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
fn len(&self) -> uint {
fn len(&self) -> usize {
core_str::StrExt::len(&self[])
}
@ -1264,8 +1264,8 @@ pub trait StrExt: Index<RangeFull, Output = str> {
/// # 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",
@ -1301,7 +1301,7 @@ pub trait StrExt: Index<RangeFull, Output = str> {
/// `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)
}
@ -1326,15 +1326,15 @@ pub trait StrExt: Index<RangeFull, Output = str> {
#[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]
}
}
@ -1357,51 +1357,51 @@ mod tests {
#[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!("".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(), 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!("".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), 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!("ｈｅｌｌｏ".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]
@ -1424,37 +1424,37 @@ mod tests {
#[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);
@ -1527,7 +1527,7 @@ mod tests {
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");
@ -1536,7 +1536,7 @@ mod tests {
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");
@ -1547,7 +1547,7 @@ mod tests {
let letters = a_million_letter_a();
assert!(half_a_million_letter_a() ==
unsafe {String::from_str(letters.slice_unchecked(
0u,
0,
500000))});
}
@ -1644,7 +1644,7 @@ mod tests {
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("华华华华华华华华华华");
@ -1653,7 +1653,7 @@ mod tests {
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("华华华华华");
@ -1663,23 +1663,23 @@ mod tests {
}
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
@ -1695,7 +1695,7 @@ mod tests {
#[test]
#[should_fail]
fn test_slice_fail() {
"中华Việt Nam".slice(0u, 2u);
"中华Việt Nam".slice(0, 2);
}
#[test]
@ -1961,9 +1961,9 @@ mod tests {
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];
@ -1971,7 +1971,7 @@ mod tests {
debug!("{}", a);
debug!("{}", b);
assert_eq!(a, b);
i += 1u;
i += 1;
}
}
@ -2093,7 +2093,7 @@ mod tests {
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]);
@ -2108,7 +2108,7 @@ mod tests {
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]);
@ -2188,7 +2188,7 @@ mod tests {
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]));
@ -2205,7 +2205,7 @@ mod tests {
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]));
@ -2725,11 +2725,11 @@ mod tests {
// 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);
{
@ -2785,7 +2785,7 @@ mod tests {
#[test]
fn test_str_container() {
fn sum_len(v: &[&str]) -> uint {
fn sum_len(v: &[&str]) -> usize {
v.iter().map(|x| x.len()).sum()
}

62
src/libcollections/string.rs
View File

@ -79,7 +79,7 @@ impl String {
/// ```
#[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),
}
@ -156,10 +156,10 @@ impl String {
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 {
@ -318,7 +318,7 @@ impl String {
/// * 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),
}
@ -374,7 +374,7 @@ impl String {
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
pub fn capacity(&self) -> uint {
pub fn capacity(&self) -> usize {
self.vec.capacity()
}
@ -384,7 +384,7 @@ impl String {
///
/// # Panics
///
/// Panics if the new capacity overflows `uint`.
/// Panics if the new capacity overflows `usize`.
///
/// # Examples
///
@ -395,7 +395,7 @@ impl String {
/// ```
#[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)
}
@ -409,7 +409,7 @@ impl String {
///
/// # Panics
///
/// Panics if the new capacity overflows `uint`.
/// Panics if the new capacity overflows `usize`.
///
/// # Examples
///
@ -420,7 +420,7 @@ impl String {
/// ```
#[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)
}
@ -468,7 +468,7 @@ impl String {
// Attempt to not use an intermediate buffer by just pushing bytes
// directly onto this string.
let slice = RawSlice {
data: self.vec.as_ptr().offset(cur_len as int),
data: self.vec.as_ptr().offset(cur_len as isize),
len: 4,
};
let used = ch.encode_utf8(mem::transmute(slice)).unwrap_or(0);
@ -487,7 +487,7 @@ impl String {
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
pub fn as_bytes<'a>(&'a self) -> &'a [u8] {
pub fn as_bytes(&self) -> &[u8] {
&self.vec
}
@ -507,7 +507,7 @@ impl String {
/// ```
#[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)
}
@ -562,14 +562,14 @@ impl String {
/// ```
#[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);
let CharRange { ch, next } = self.char_range_at(idx);
unsafe {
ptr::copy_memory(self.vec.as_mut_ptr().offset(idx as int),
self.vec.as_ptr().offset(next as int),
ptr::copy_memory(self.vec.as_mut_ptr().offset(idx as isize),
self.vec.as_ptr().offset(next as isize),
len - next);
self.vec.set_len(len - (next - idx));
}
@ -589,7 +589,7 @@ impl String {
/// 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));
@ -598,10 +598,10 @@ impl String {
let amt = ch.encode_utf8(&mut bits).unwrap();
unsafe {
ptr::copy_memory(self.vec.as_mut_ptr().offset((idx + amt) as int),
self.vec.as_ptr().offset(idx as int),
ptr::copy_memory(self.vec.as_mut_ptr().offset((idx + amt) as isize),
self.vec.as_ptr().offset(idx as isize),
len - idx);
ptr::copy_memory(self.vec.as_mut_ptr().offset(idx as int),
ptr::copy_memory(self.vec.as_mut_ptr().offset(idx as isize),
bits.as_ptr(),
amt);
self.vec.set_len(len + amt);
@ -626,7 +626,7 @@ impl String {
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
pub unsafe fn as_mut_vec<'a>(&'a mut self) -> &'a mut Vec<u8> {
pub unsafe fn as_mut_vec(&mut self) -> &mut Vec<u8> {
&mut self.vec
}
@ -640,7 +640,7 @@ impl String {
/// ```
#[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
///
@ -802,7 +802,7 @@ impl<'a, 'b> PartialEq<CowString<'a>> for &'b str {
impl Str for String {
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
fn as_slice<'a>(&'a self) -> &'a str {
fn as_slice(&self) -> &str {
unsafe { mem::transmute(&*self.vec) }
}
}
@ -853,26 +853,26 @@ impl<'a> Add<&'a str> for String {
}
#[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]
}
}
@ -890,7 +890,7 @@ impl ops::Deref for String {
type Target = str;
#[inline]
fn deref<'a>(&'a self) -> &'a str {
fn deref(&self) -> &str {
unsafe { mem::transmute(&self.vec[]) }
}
}
@ -1297,7 +1297,7 @@ mod tests {
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");
@ -1306,7 +1306,7 @@ mod tests {
#[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]");

288
src/libcollections/vec.rs
View File

@ -66,7 +66,7 @@ use core::ops;
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.'
///
@ -138,8 +138,8 @@ use core::uint;
#[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> { }
@ -196,9 +196,9 @@ impl<T> 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 {
@ -234,7 +234,7 @@ impl<T> Vec<T> {
/// mem::forget(v);
///
/// // Overwrite memory with 4, 5, 6
/// for i in 0..len as int {
/// for i in 0..len as isize {
/// ptr::write(p.offset(i), 4 + i);
/// }
///
@ -245,8 +245,8 @@ impl<T> Vec<T> {
/// }
/// ```
#[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 }
}
@ -258,7 +258,7 @@ impl<T> Vec<T> {
#[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);
@ -276,7 +276,7 @@ impl<T> Vec<T> {
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
pub fn capacity(&self) -> uint {
pub fn capacity(&self) -> usize {
self.cap
}
@ -285,7 +285,7 @@ impl<T> Vec<T> {
///
/// # Panics
///
/// Panics if the new capacity overflows `uint`.
/// Panics if the new capacity overflows `usize`.
///
/// # Examples
///
@ -295,9 +295,9 @@ impl<T> Vec<T> {
/// 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);
@ -314,7 +314,7 @@ impl<T> Vec<T> {
///
/// # Panics
///
/// Panics if the new capacity overflows `uint`.
/// Panics if the new capacity overflows `usize`.
///
/// # Examples
///
@ -324,10 +324,10 @@ impl<T> Vec<T> {
/// 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)
}
}
@ -401,7 +401,7 @@ impl<T> Vec<T> {
/// 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 {
@ -425,7 +425,7 @@ impl<T> Vec<T> {
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
pub fn as_mut_slice<'a>(&'a mut self) -> &'a mut [T] {
pub fn as_mut_slice(&mut self) -> &mut [T] {
unsafe {
mem::transmute(RawSlice {
data: *self.ptr,
@ -455,9 +455,9 @@ impl<T> Vec<T> {
let cap = self.cap;
let begin = ptr as *const T;
let end = if mem::size_of::<T>() == 0 {
(ptr as uint + self.len()) as *const T
(ptr as usize + self.len()) as *const T
} else {
ptr.offset(self.len() as int) as *const T
ptr.offset(self.len() as isize) as *const T
};
mem::forget(self);
IntoIter { allocation: ptr, cap: cap, ptr: begin, end: end }
@ -473,14 +473,14 @@ impl<T> Vec<T> {
/// # Examples
///
/// ```
/// let mut v = vec![1u, 2, 3, 4];
/// let mut v = vec![1, 2, 3, 4];
/// unsafe {
/// v.set_len(1);
/// }
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
pub unsafe fn set_len(&mut self, len: uint) {
pub unsafe fn set_len(&mut self, len: usize) {
self.len = len;
}
@ -506,7 +506,7 @@ impl<T> Vec<T> {
/// ```
#[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()
@ -530,7 +530,7 @@ impl<T> Vec<T> {
/// 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
@ -539,7 +539,7 @@ impl<T> Vec<T> {
unsafe { // infallible
// The spot to put the new value
{
let p = self.as_mut_ptr().offset(index as int);
let p = self.as_mut_ptr().offset(index as isize);
// Shift everything over to make space. (Duplicating the
// `index`th element into two consecutive places.)
ptr::copy_memory(p.offset(1), &*p, len - index);
@ -566,14 +566,14 @@ impl<T> Vec<T> {
/// assert_eq!(v, vec![1, 3]);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
pub fn remove(&mut self, index: uint) -> T {
pub fn remove(&mut self, index: usize) -> T {
let len = self.len();
assert!(index < len);
unsafe { // infallible
let ret;
{
// the place we are taking from.
let ptr = self.as_mut_ptr().offset(index as int);
let ptr = self.as_mut_ptr().offset(index as isize);
// copy it out, unsafely having a copy of the value on
// the stack and in the vector at the same time.
ret = ptr::read(ptr);
@ -602,11 +602,11 @@ impl<T> Vec<T> {
#[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 {
@ -623,7 +623,7 @@ impl<T> Vec<T> {
///
/// # 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
///
@ -655,7 +655,7 @@ impl<T> Vec<T> {
}
unsafe {
let end = (*self.ptr).offset(self.len as int);
let end = (*self.ptr).offset(self.len as isize);
ptr::write(&mut *end, value);
self.len += 1;
}
@ -687,7 +687,7 @@ impl<T> Vec<T> {
///
/// # 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
@ -737,13 +737,13 @@ impl<T> Vec<T> {
#[inline]
#[unstable(feature = "collections",
reason = "matches collection reform specification, waiting for dust to settle")]
pub fn drain<'a>(&'a mut self) -> Drain<'a, T> {
pub fn drain(&mut self) -> Drain<T> {
unsafe {
let begin = *self.ptr as *const T;
let end = if mem::size_of::<T>() == 0 {
(*self.ptr as uint + self.len()) as *const T
(*self.ptr as usize + self.len()) as *const T
} else {
(*self.ptr).offset(self.len() as int) as *const T
(*self.ptr).offset(self.len() as isize) as *const T
};
self.set_len(0);
Drain {
@ -781,7 +781,7 @@ impl<T> Vec<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.
///
@ -808,7 +808,7 @@ impl<T> Vec<T> {
/// # 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());
///
@ -835,7 +835,7 @@ impl<T> Vec<T> {
// types are passed to the allocator by `Vec`.
assert!(mem::min_align_of::<T>() == mem::min_align_of::<U>());
// This `as int` cast is safe, because the size of the elements of the
// This `as isize` cast is safe, because the size of the elements of the
// vector is not 0, and:
//
// 1) If the size of the elements in the vector is 1, the `int` may
@ -850,9 +850,9 @@ impl<T> Vec<T> {
// After `array.offset(offset)`: 0x9.
// (0x1 + 0x8 = 0x1 - 0x8)
//
// 2) If the size of the elements in the vector is >1, the `uint` ->
// 2) If the size of the elements in the vector is >1, the `usize` ->
// `int` conversion can't overflow.
let offset = vec.len() as int;
let offset = vec.len() as isize;
let start = vec.as_mut_ptr();
let mut pv = PartialVecNonZeroSized {
@ -977,8 +977,8 @@ impl<T> Vec<T> {
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;
@ -1052,7 +1052,7 @@ impl<T: Clone> Vec<T> {
/// ```
#[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 {
@ -1179,8 +1179,8 @@ impl<T: PartialEq> Vec<T> {
let mut w = 1;
while r < ln {
let p_r = p.offset(r as int);
let p_wm1 = p.offset((w - 1) as int);
let p_r = p.offset(r as isize);
let p_wm1 = p.offset((w - 1) as isize);
if *p_r != *p_wm1 {
if r != w {
let p_w = p_wm1.offset(1);
@ -1205,7 +1205,7 @@ impl<T> Vec<T> {
///
/// 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 {
@ -1223,7 +1223,7 @@ impl<T> Vec<T> {
// 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 {
@ -1232,7 +1232,7 @@ unsafe fn alloc_or_realloc<T>(ptr: *mut T, old_size: uint, size: uint) -> *mut T
}
#[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>(),
@ -1274,22 +1274,22 @@ impl<S: hash::Writer + hash::Hasher, T: Hash<S>> Hash<S> for Vec<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(&self, index: &usize) -> &T {
// NB built-in indexing via `&[T]`
&(**self)[*index]
}
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<T> IndexMut<uint> for Vec<T> {
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(&mut self, index: &usize) -> &mut T {
// NB built-in indexing via `&mut [T]`
&mut (**self)[*index]
}
@ -1297,26 +1297,26 @@ impl<T> IndexMut<uint> for Vec<T> {
#[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)
}
}
@ -1330,26 +1330,26 @@ impl<T> ops::Index<ops::RangeFull> for Vec<T> {
}
#[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)
}
}
@ -1366,12 +1366,12 @@ impl<T> ops::IndexMut<ops::RangeFull> for Vec<T> {
impl<T> ops::Deref for Vec<T> {
type Target = [T];
fn deref<'a>(&'a self) -> &'a [T] { self.as_slice() }
fn deref(&self) -> &[T] { self.as_slice() }
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<T> ops::DerefMut for Vec<T> {
fn deref_mut<'a>(&'a mut self) -> &'a mut [T] { self.as_mut_slice() }
fn deref_mut(&mut self) -> &mut [T] { self.as_mut_slice() }
}
#[stable(feature = "rust1", since = "1.0.0")]
@ -1519,7 +1519,7 @@ impl<T> AsSlice<T> for Vec<T> {
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
fn as_slice<'a>(&'a self) -> &'a [T] {
fn as_slice(&self) -> &[T] {
unsafe {
mem::transmute(RawSlice {
data: *self.ptr,
@ -1609,7 +1609,7 @@ impl<'a, T> IntoCow<'a, Vec<T>, [T]> for &'a [T] where T: Clone {
#[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
}
@ -1636,7 +1636,7 @@ impl<T> Iterator for IntoIter<T> {
type Item = T;
#[inline]
fn next<'a>(&'a mut self) -> Option<T> {
fn next(&mut self) -> Option<T> {
unsafe {
if self.ptr == self.end {
None
@ -1645,10 +1645,10 @@ impl<T> Iterator for IntoIter<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)))
Some(ptr::read(EMPTY as *mut T))
} else {
let old = self.ptr;
self.ptr = self.ptr.offset(1);
@ -1660,8 +1660,8 @@ impl<T> Iterator for IntoIter<T> {
}
#[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))
@ -1671,17 +1671,17 @@ impl<T> Iterator for IntoIter<T> {
#[stable(feature = "rust1", since = "1.0.0")]
impl<T> DoubleEndedIterator for IntoIter<T> {
#[inline]
fn next_back<'a>(&'a mut self) -> Option<T> {
fn next_back(&mut self) -> Option<T> {
unsafe {
if self.end == self.ptr {
None
} else {
if mem::size_of::<T>() == 0 {
// See above for why 'ptr.offset' isn't used
self.end = mem::transmute(self.end as uint - 1);
self.end = mem::transmute(self.end as usize - 1);
// Use a non-null pointer value
Some(ptr::read(mem::transmute(1u)))
Some(ptr::read(EMPTY as *mut T))
} else {
self.end = self.end.offset(-1);
@ -1733,10 +1733,10 @@ impl<'a, T> Iterator for Drain<'a, 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)))
Some(ptr::read(EMPTY as *mut T))
} else {
let old = self.ptr;
self.ptr = self.ptr.offset(1);
@ -1748,8 +1748,8 @@ impl<'a, T> Iterator for Drain<'a, T> {
}
#[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))
@ -1766,10 +1766,10 @@ impl<'a, T> DoubleEndedIterator for Drain<'a, T> {
} else {
if mem::size_of::<T>() == 0 {
// See above for why 'ptr.offset' isn't used
self.end = mem::transmute(self.end as uint - 1);
self.end = mem::transmute(self.end as usize - 1);
// Use a non-null pointer value
Some(ptr::read(mem::transmute(1u)))
Some(ptr::read(EMPTY as *mut T))
} else {
self.end = self.end.offset(-1);
@ -1862,8 +1862,8 @@ struct PartialVecNonZeroSized<T,U> {
/// 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>,
}
@ -1920,7 +1920,7 @@ mod tests {
use super::as_vec;
struct DropCounter<'a> {
count: &'a mut int
count: &'a mut u32
}
#[unsafe_destructor]
@ -1949,7 +1949,7 @@ mod tests {
#[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]
@ -2020,7 +2020,7 @@ mod tests {
#[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]);
@ -2034,7 +2034,7 @@ mod tests {
#[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]);
@ -2048,7 +2048,7 @@ mod tests {
#[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);
{
@ -2068,12 +2068,12 @@ mod tests {
}
}
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());
@ -2108,9 +2108,9 @@ mod tests {
#[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]
@ -2169,20 +2169,20 @@ mod tests {
// 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) {
@ -2201,7 +2201,7 @@ mod tests {
#[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;
@ -2217,62 +2217,62 @@ mod tests {
#[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();
@ -2285,14 +2285,14 @@ mod tests {
#[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]
@ -2318,7 +2318,7 @@ mod tests {
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<_>>();
@ -2334,7 +2334,7 @@ mod tests {
#[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);
}
@ -2344,7 +2344,7 @@ mod tests {
#[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);
}
@ -2354,7 +2354,7 @@ mod tests {
#[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);
}
@ -2364,7 +2364,7 @@ mod tests {
#[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);
}
@ -2375,18 +2375,18 @@ mod tests {
#[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);
}
@ -2396,9 +2396,9 @@ mod tests {
#[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]
@ -2421,17 +2421,17 @@ mod tests {
#[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);
})
@ -2457,7 +2457,7 @@ mod tests {
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(|| {
@ -2487,11 +2487,11 @@ mod tests {
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));
})
@ -2517,8 +2517,8 @@ mod tests {
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;
@ -2549,13 +2549,13 @@ mod tests {
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));
});
@ -2581,9 +2581,9 @@ mod tests {
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;
@ -2630,9 +2630,9 @@ mod tests {
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;
@ -2679,9 +2679,9 @@ mod tests {
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;
@ -2728,8 +2728,8 @@ mod tests {
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;
@ -2760,9 +2760,9 @@ mod tests {
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;

156
src/libcollections/vec_map.rs
View File

@ -29,8 +29,6 @@ use core::ops::{Index, IndexMut};
use {vec, slice};
use vec::Vec;
// FIXME(conventions): capacity management???
/// A map optimized for small integer keys.
///
/// # Examples
@ -117,7 +115,7 @@ impl<S: Writer + Hasher, V: Hash<S>> Hash<S> for VecMap<V> {
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;
@ -148,7 +146,7 @@ impl<V> VecMap<V> {
/// 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) }
}
@ -164,7 +162,7 @@ impl<V> VecMap<V> {
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
pub fn capacity(&self) -> uint {
pub fn capacity(&self) -> usize {
self.v.capacity()
}
@ -183,7 +181,7 @@ impl<V> VecMap<V> {
/// 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);
@ -207,7 +205,7 @@ impl<V> VecMap<V> {
/// 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);
@ -215,11 +213,11 @@ impl<V> VecMap<V> {
}
/// 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) }
}
@ -229,13 +227,13 @@ impl<V> VecMap<V> {
#[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
///
@ -263,7 +261,7 @@ impl<V> VecMap<V> {
/// 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
///
@ -294,7 +292,7 @@ impl<V> VecMap<V> {
/// 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
///
@ -306,23 +304,23 @@ impl<V> VecMap<V> {
/// 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
///
@ -334,17 +332,17 @@ impl<V> VecMap<V> {
/// 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) }
}
@ -362,7 +360,7 @@ impl<V> VecMap<V> {
/// 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()
}
@ -411,7 +409,7 @@ impl<V> VecMap<V> {
/// 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),
@ -436,7 +434,7 @@ impl<V> VecMap<V> {
/// ```
#[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()
}
@ -456,7 +454,7 @@ impl<V> VecMap<V> {
/// 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),
@ -484,7 +482,7 @@ impl<V> VecMap<V> {
/// 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));
@ -506,7 +504,7 @@ impl<V> VecMap<V> {
/// 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;
}
@ -662,8 +660,8 @@ impl<V: fmt::Debug> fmt::Debug for VecMap<V> {
}
#[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
@ -695,29 +693,29 @@ impl<'a, T> IntoIterator for &'a mut VecMap<T> {
}
#[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")
}
}
@ -750,7 +748,7 @@ macro_rules! iterator {
}
#[inline]
fn size_hint(&self) -> (uint, Option<uint>) {
fn size_hint(&self) -> (usize, Option<usize>) {
(0, Some(self.back - self.front))
}
}
@ -787,8 +785,8 @@ macro_rules! double_ended_iterator {
/// 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>>
}
@ -803,25 +801,25 @@ impl<'a, V> Clone for Iter<'a, 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)]`
@ -836,7 +834,7 @@ impl<'a, V> Clone for Keys<'a, V> {
/// 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)]`
@ -853,39 +851,39 @@ impl<'a, V> Clone for Values<'a, V> {
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")]
@ -893,7 +891,7 @@ impl<'a, V> Iterator for Values<'a, V> {
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> {
@ -902,14 +900,14 @@ 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)]
@ -983,7 +981,7 @@ mod test_map {
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));
@ -996,7 +994,7 @@ mod test_map {
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'));
@ -1130,7 +1128,7 @@ mod test_map {
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);
@ -1139,7 +1137,7 @@ mod test_map {
#[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);
@ -1188,7 +1186,7 @@ mod test_map {
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);
@ -1206,7 +1204,7 @@ mod test_map {
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());
@ -1238,9 +1236,9 @@ mod test_map {
#[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));
@ -1249,7 +1247,7 @@ mod test_map {
#[test]
fn test_index() {
let mut map: VecMap<int> = VecMap::new();
let mut map = VecMap::new();
map.insert(1, 2);
map.insert(2, 1);
@ -1261,7 +1259,7 @@ mod test_map {
#[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);
@ -1274,7 +1272,7 @@ mod test_map {
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) {
@ -1330,7 +1328,7 @@ mod bench {
#[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); });
@ -1338,7 +1336,7 @@ mod bench {
#[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); });
@ -1347,7 +1345,7 @@ mod bench {
// 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); });
@ -1355,7 +1353,7 @@ mod bench {
#[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); });
@ -1364,7 +1362,7 @@ mod bench {
// 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); });
@ -1372,7 +1370,7 @@ mod bench {
#[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); });
@ -1381,7 +1379,7 @@ mod bench {
// 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); });
@ -1389,7 +1387,7 @@ mod bench {
#[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); });

4
src/librustc/middle/ty.rs
View File

@ -1591,10 +1591,10 @@ pub fn region_existential_bound<'tcx>(r: ty::Region) -> ExistentialBounds<'tcx>
}
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) }
}
}

4
src/libserialize/collection_impls.rs
View File

@ -136,7 +136,7 @@ impl<
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)
}
@ -150,7 +150,7 @@ impl<
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)

2
src/libstd/collections/hash/bench.rs
View File

@ -21,7 +21,7 @@ fn new_drop(b : &mut Bencher) {
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);
})
}

112
src/libstd/collections/hash/map.rs
View File

@ -45,9 +45,9 @@ use super::table::BucketState::{
};
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:
@ -62,7 +62,7 @@ impl DefaultResizePolicy {
}
#[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:
//
@ -72,7 +72,7 @@ impl DefaultResizePolicy {
/// 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:
@ -369,7 +369,7 @@ fn pop_internal<K, V>(starting_bucket: FullBucketMut<K, V>) -> (K, V) {
///
/// `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)
@ -515,7 +515,7 @@ impl<K: Hash<Hasher> + Eq, V> HashMap<K, V, RandomState> {
/// ```
#[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())
}
}
@ -569,7 +569,7 @@ impl<K, V, S, H> HashMap<K, V, S>
/// ```
#[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));
@ -593,7 +593,7 @@ impl<K, V, S, H> HashMap<K, V, S>
/// ```
#[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())
}
@ -603,7 +603,7 @@ impl<K, V, S, H> HashMap<K, V, S>
///
/// # Panics
///
/// Panics if the new allocation size overflows `uint`.
/// Panics if the new allocation size overflows `usize`.
///
/// # Example
///
@ -613,7 +613,7 @@ impl<K, V, S, H> HashMap<K, V, S>
/// 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);
@ -631,7 +631,7 @@ impl<K, V, S, H> HashMap<K, V, S>
/// 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);
@ -793,7 +793,7 @@ impl<K, V, S, H> HashMap<K, V, S>
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();
@ -951,7 +951,7 @@ impl<K, V, S, H> HashMap<K, V, S>
/// 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.
///
@ -1186,7 +1186,7 @@ fn search_entry_hashed<'a, K: Eq, V>(table: &'a mut RawTable<K,V>, hash: SafeHas
return Vacant(VacantEntry {
hash: hash,
key: k,
elem: NeqElem(bucket, robin_ib as uint),
elem: NeqElem(bucket, robin_ib as usize),
});
}
@ -1369,7 +1369,7 @@ pub enum Entry<'a, K: 'a, V: 'a> {
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>),
}
@ -1672,11 +1672,11 @@ mod test_map {
#[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;
});
@ -1709,24 +1709,24 @@ mod test_map {
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);
@ -1739,12 +1739,12 @@ mod test_map {
}
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);
}
@ -1752,7 +1752,7 @@ mod test_map {
}
DROP_VECTOR.with(|v| {
for i in 0u..200 {
for i in 0..200 {
assert_eq!(v.borrow()[i], 0);
}
});
@ -1768,19 +1768,19 @@ mod test_map {
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);
}
});
@ -1795,7 +1795,7 @@ mod test_map {
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);
}
});
@ -1803,11 +1803,11 @@ mod test_map {
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();
@ -1817,7 +1817,7 @@ mod test_map {
};
DROP_VECTOR.with(|v| {
for i in 0u..200 {
for i in 0..200 {
assert_eq!(v.borrow()[i], 0);
}
});
@ -1962,7 +1962,7 @@ mod test_map {
#[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);
@ -1979,8 +1979,8 @@ mod test_map {
#[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));
@ -1990,8 +1990,8 @@ mod test_map {
#[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'));
@ -2029,8 +2029,8 @@ mod test_map {
#[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);
@ -2049,7 +2049,7 @@ mod test_map {
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);
@ -2077,7 +2077,7 @@ mod test_map {
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;
@ -2119,21 +2119,21 @@ mod test_map {
#[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();
@ -2142,7 +2142,7 @@ mod test_map {
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();
@ -2157,7 +2157,7 @@ mod test_map {
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));
@ -2168,7 +2168,7 @@ mod test_map {
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();
@ -2181,7 +2181,7 @@ mod test_map {
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();
@ -2194,7 +2194,7 @@ mod test_map {
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();
@ -2207,7 +2207,7 @@ mod test_map {
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();
@ -2218,7 +2218,7 @@ mod test_map {
#[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);
@ -2230,7 +2230,7 @@ mod test_map {
#[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);
@ -2243,7 +2243,7 @@ mod test_map {
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) {
@ -2294,7 +2294,7 @@ mod test_map {
#[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);
@ -2305,12 +2305,12 @@ mod test_map {
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(_) => {},

66
src/libstd/collections/hash/set.rs
View File

@ -76,7 +76,7 @@ use super::state::HashState;
/// #[derive(Hash, Eq, PartialEq, Debug)]
/// struct Viking<'a> {
/// name: &'a str,
/// power: uint,
/// power: usize,
/// }
///
/// let mut vikings = HashSet::new();
@ -123,7 +123,7 @@ impl<T: Hash<Hasher> + Eq> HashSet<T, RandomState> {
/// ```
#[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) }
}
}
@ -174,7 +174,7 @@ impl<T, S, H> HashSet<T, S>
/// ```
#[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),
@ -192,7 +192,7 @@ impl<T, S, H> HashSet<T, S>
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
pub fn capacity(&self) -> uint {
pub fn capacity(&self) -> usize {
self.map.capacity()
}
@ -202,7 +202,7 @@ impl<T, S, H> HashSet<T, S>
///
/// # Panics
///
/// Panics if the new allocation size overflows `uint`.
/// Panics if the new allocation size overflows `usize`.
///
/// # Example
///
@ -212,7 +212,7 @@ impl<T, S, H> HashSet<T, S>
/// 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)
}
@ -402,7 +402,7 @@ impl<T, S, H> HashSet<T, S>
/// 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
///
@ -456,7 +456,7 @@ impl<T, S, H> HashSet<T, S>
/// ```
/// 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);
/// ```
@ -475,8 +475,8 @@ impl<T, S, H> HashSet<T, S>
/// ```
/// 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);
@ -496,8 +496,8 @@ impl<T, S, H> HashSet<T, S>
/// ```
/// 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);
@ -517,8 +517,8 @@ impl<T, S, H> HashSet<T, S>
/// ```
/// 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);
///
@ -670,10 +670,10 @@ impl<'a, 'b, T, S, H> BitOr<&'b HashSet<T, S>> for &'a HashSet<T, S>
/// ```
/// 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];
@ -703,10 +703,10 @@ impl<'a, 'b, T, S, H> BitAnd<&'b HashSet<T, S>> for &'a HashSet<T, S>
/// ```
/// 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];
@ -736,10 +736,10 @@ impl<'a, 'b, T, S, H> BitXor<&'b HashSet<T, S>> for &'a HashSet<T, S>
/// ```
/// 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];
@ -769,10 +769,10 @@ impl<'a, 'b, T, S, H> Sub<&'b HashSet<T, S>> for &'a HashSet<T, S>
/// ```
/// 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];
@ -1029,7 +1029,7 @@ mod test_set {
#[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;
@ -1152,7 +1152,7 @@ mod test_set {
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));
@ -1198,8 +1198,8 @@ mod test_set {
#[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);
@ -1212,19 +1212,19 @@ mod test_set {
#[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 {

68
src/libstd/collections/hash/table.rs
View File

@ -67,8 +67,8 @@ const EMPTY_BUCKET: u64 = 0u64;
/// 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.
@ -88,7 +88,7 @@ impl<K,V> Copy for RawBucket<K,V> {}
pub struct Bucket<K, V, M> {
raw: RawBucket<K, V>,
idx: uint,
idx: usize,
table: M
}
@ -96,13 +96,13 @@ impl<K,V,M:Copy> Copy for Bucket<K,V,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
}
@ -190,7 +190,7 @@ impl<K, V, M> FullBucket<K, V, M> {
self.table
}
/// Get the raw index.
pub fn index(&self) -> uint {
pub fn index(&self) -> usize {
self.idx
}
}
@ -212,21 +212,21 @@ impl<K, V, M> Bucket<K, V, M> {
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
@ -276,7 +276,7 @@ impl<K, V, M: Deref<Target=RawTable<K, V>>> Bucket<K, V, M> {
// ... 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;
@ -366,11 +366,11 @@ impl<K, V, M: Deref<Target=RawTable<K, V>>> FullBucket<K, V, M> {
///
/// 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]
@ -503,7 +503,7 @@ impl<K, V, M: Deref<Target=RawTable<K, V>>> GapThenFull<K, V, M> {
/// # 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)
}
@ -520,10 +520,10 @@ fn test_rounding() {
// 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;
@ -534,10 +534,10 @@ fn calculate_offsets(hashes_size: uint,
// 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,
@ -562,7 +562,7 @@ fn test_offset_calculation() {
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,
@ -601,7 +601,7 @@ impl<K, V> RawTable<K, V> {
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,
@ -623,15 +623,15 @@ impl<K, V> RawTable<K, V> {
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);
@ -640,13 +640,13 @@ impl<K, V> RawTable<K, V> {
}
/// 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
}
@ -654,7 +654,7 @@ impl<K, V> RawTable<K, V> {
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,
}
@ -705,7 +705,7 @@ impl<K, V> RawTable<K, V> {
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,
@ -758,7 +758,7 @@ impl<'a, K, V> Iterator for RawBuckets<'a, K, V> {
struct RevMoveBuckets<'a, K, V> {
raw: RawBucket<K, V>,
hashes_end: *mut u64,
elems_left: uint,
elems_left: usize,
marker: marker::ContravariantLifetime<'a>,
}
@ -791,7 +791,7 @@ impl<'a, K, V> Iterator for RevMoveBuckets<'a, K, V> {
/// 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)]`
@ -808,7 +808,7 @@ impl<'a, K, V> Clone for Iter<'a, K, V> {
/// 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.