Use i32 throughout for indexing

Author: sfackler

src/array.rs

@@ -19,7 +19,7 @@ impl<T: fmt::Display> fmt::Display for Array<T>{
  try!(write!(fmt,
 "[{}:{}]",
  dim.lower_bound,
- dim.lower_bound asisize+ dim.lenasisize - 1));
+ dim.lower_bound + dim.len - 1));
 }
  try!(write!(fmt,"="));
 }
@@ -61,7 +61,7 @@ impl<T> Array<T>{
 /// elements specified by the dimensions.
 pubfnfrom_parts(data:Vec<T>,dimensions:Vec<Dimension>) -> Array<T>{
 assert!((data.is_empty() && dimensions.is_empty()) ||
- data.len() == dimensions.iter().fold(1, |acc, i| acc * i.lenasusize),
+ data.len()asi32== dimensions.iter().fold(1, |acc, i| acc * i.len),
 "size mismatch");
 Array{
 dims: dimensions,
@@ -120,15 +120,15 @@ impl<T> Array<T>{
 &self.dims
 }
 
-fnshift_idx(&self,indices:&[isize]) -> usize{
+fnshift_idx(&self,indices:&[i32]) -> i32{
 assert_eq!(self.dims.len(), indices.len());
 self.dims
 .iter()
 .zip(indices.iter().cloned())
 .rev()
 .fold((0,1), |(acc, stride),(dim, idx)| {
 let shifted = dim.shift(idx);
-(acc + shifted * stride, dim.lenasusize* stride)
+(acc + shifted * stride, dim.len* stride)
 })
 .0
 }
@@ -161,51 +161,51 @@ pub trait ArrayIndex{
 ///
 /// Panics if the value of `self` does not correspond to an in-bounds
 /// element of the `Array`.
-fnindex<T>(&self,array:&Array<T>) -> usize;
+fnindex<T>(&self,array:&Array<T>) -> i32;
 }
 
-impl<'a>ArrayIndexfor&'a[isize]{
-fnindex<T>(&self,array:&Array<T>) -> usize{
+impl<'a>ArrayIndexfor&'a[i32]{
+fnindex<T>(&self,array:&Array<T>) -> i32{
  array.shift_idx(*self)
 }
 }
 
-implArrayIndexforisize{
-fnindex<T>(&self,array:&Array<T>) -> usize{
-let slice:&[isize] = &[*self];
+implArrayIndexfori32{
+fnindex<T>(&self,array:&Array<T>) -> i32{
+let slice:&[i32] = &[*self];
 ArrayIndex::index(&slice, array)
 }
 }
 
 macro_rules! tuple_impl {
 ($($name:ident : $t:ty),+) => {
 implArrayIndexfor($($t,)+){
-fn index<T>(&self, array:&Array<T>) -> usize{
+fn index<T>(&self, array:&Array<T>) -> i32{
 let($($name,)+) = *self;
-let slice:&[isize] = &[$($name),+];
+let slice:&[i32] = &[$($name),+];
 ArrayIndex::index(&slice, array)
 }
 }
 }
 }
 
-tuple_impl!(a:isize);
-tuple_impl!(a:isize, b:isize);
-tuple_impl!(a:isize, b:isize, c:isize);
-tuple_impl!(a:isize, b:isize, c:isize, d:isize);
-tuple_impl!(a:isize, b:isize, c:isize, d:isize, e:isize);
-tuple_impl!(a:isize, b:isize, c:isize, d:isize, e:isize, f:isize);
-tuple_impl!(a:isize, b:isize, c:isize, d:isize, e:isize, f:isize, g:isize);
-tuple_impl!(a:isize, b:isize, c:isize, d:isize, e:isize, f:isize, g:isize, h:isize);
-tuple_impl!(a:isize, b:isize, c:isize, d:isize, e:isize, f:isize, g:isize, h:isize, i:isize);
+tuple_impl!(a:i32);
+tuple_impl!(a:i32, b:i32);
+tuple_impl!(a:i32, b:i32, c:i32);
+tuple_impl!(a:i32, b:i32, c:i32, d:i32);
+tuple_impl!(a:i32, b:i32, c:i32, d:i32, e:i32);
+tuple_impl!(a:i32, b:i32, c:i32, d:i32, e:i32, f:i32);
+tuple_impl!(a:i32, b:i32, c:i32, d:i32, e:i32, f:i32, g:i32);
+tuple_impl!(a:i32, b:i32, c:i32, d:i32, e:i32, f:i32, g:i32, h:i32);
+tuple_impl!(a:i32, b:i32, c:i32, d:i32, e:i32, f:i32, g:i32, h:i32, i:i32);
 
 /// Indexes into the `Array`, retrieving a reference to the contained
 /// value.
 ///
 /// Since `Array`s can be multi-dimensional, the `Index` trait is
 /// implemented for a variety of index types. In the most generic case, a
-/// `&[isize]` can be used. In addition, a bare `isize` as well as tuples
-/// of up to 10 `isize` values may be used for convenience.
+/// `&[i32]` can be used. In addition, a bare `i32` as well as tuples
+/// of up to 10 `i32` values may be used for convenience.
 ///
 /// # Panics
 ///
@@ -228,14 +228,14 @@ impl<T, I: ArrayIndex> Index<I> for Array<T>{
 typeOutput = T;
 fnindex(&self,idx:I) -> &T{
 let idx = idx.index(self);
-&self.data[idx]
+&self.data[idxasusize]
 }
 }
 
 impl<T,I:ArrayIndex>IndexMut<I>forArray<T>{
 fnindex_mut(&mutself,idx:I) -> &mutT{
 let idx = idx.index(self);
-&mutself.data[idx]
+&mutself.data[idxasusize]
 }
 }
 

src/lib.rs

@@ -22,14 +22,15 @@ pub struct Dimension{
 }
 
 implDimension{
-fnshift(&self,idx:isize) -> usize{
-let offset = self.lower_boundasisize;
+fnshift(&self,idx:i32) -> i32{
+let offset = self.lower_bound;
 assert!(idx >= offset,"out of bounds array access");
-assert!(offset >= 0 || idx <= 0 || usize::max_value() - (-offset)asusize>= idxasusize,
+assert!(offset >= 0 || idx <= 0 || i32::max_value() - (-offset) >= idx,
 "out of bounds array access");
-let shifted = idx.wrapping_sub(offset)asusize;
-assert!(shifted < self.len asusize,"out of bounds array access");
- shifted
+match idx.checked_sub(offset){
+Some(shifted) => shifted,
+None => panic!("out of bounds array access"),
+}
 }
 }