added some helpful macros to implement indexable items, but do not mandate it for slice wrappers. Also add len() function

Author: danielrh

.travis.yml

@@ -2,12 +2,20 @@ language: rust
 rust:
   - nightly
   - stable
-  # The following Rust version represents the oldest supported version of Mio
-  - 1.6.0
+  - 1.12.0
+  - 1.8.0
 
 os:
   - linux
   - osx
 
 script:
   - cargo test
+  - cargo test --features=unsafe --release
+  - cargo test --features=no-stdlib
+  - cargo test --release
+
+matrix:
+  exclude:
+    - rust: 1.8.0
+      os: osx

Cargo.toml

@@ -1,14 +1,15 @@
 [package]
 name = "alloc-no-stdlib"
 description = "A dynamic allocator that may be used with or without the stdlib. This allows a package with nostd to allocate memory dynamically and be used either with a custom allocator, items on the stack, or by a package that wishes to simply use Box<>. It also provides options to use calloc or a mutable global variable for pre-zeroed memory"
-version = "1.2.0"
+version = "1.3.0"
 authors = ["Daniel Reiter Horn <[email protected]>"]
 documentation = "https://raw.githubusercontent.com/dropbox/rust-alloc-no-stdlib/master/tests/lib.rs"
 homepage = "https://github.com/dropbox/rust-alloc-no-stdlib"
 readme = "README.md"
 keywords = ["custom", "allocator", "calloc", "safe", "nostd"]
 license = "BSD-3-Clause"
 repository = "https://github.com/dropbox/rust-alloc-no-stdlib"
+autobins = false
 
 [[bin]]
 name = "example"

src/allocated_memory/mod.rs

@@ -1,19 +1,26 @@
 extern crate core;
-use core::ops;
+#[macro_use]
+mod index_macro;
+mod test;
 use core::default::Default;
-
+pub use core::ops::IndexMut;
+pub use core::ops::Index;
+pub use core::ops::Range;
 pub trait SliceWrapper<T> {
-  fn slice(& self) -> & [T];
+    fn slice(& self) -> & [T];
+    fn len(&self) -> usize{
+        self.slice().len()
+    }
 }
 
-pub trait SliceWrapperMut<T> {
+pub trait SliceWrapperMut<T> : SliceWrapper<T> {
   fn slice_mut (&mut self) -> & mut [T];
 }
 
 pub trait AllocatedSlice<T>
-    : SliceWrapperMut<T> + SliceWrapper<T> + ops::IndexMut<usize> + ops::Index<usize> + Default {
+    : SliceWrapperMut<T> + SliceWrapper<T> + Default {
 }
 
-impl<T, U> AllocatedSlice<T> for U where U : SliceWrapperMut<T> + SliceWrapper<T> + ops::IndexMut<usize> + ops::Index<usize> + Default {
+impl<T, U> AllocatedSlice<T> for U where U : SliceWrapperMut<T> + SliceWrapper<T> + Default {
 
 }

src/allocated_stack_memory.rs

@@ -1,29 +1,20 @@
 extern crate core;
+
 use super::allocated_memory::SliceWrapper;
 use super::allocated_memory::SliceWrapperMut;
-use core::ops;
+
 pub struct AllocatedStackMemory<'a, T:'a> {
     pub mem : &'a mut [T],
 }
 
+define_index_ops_mut!(a, T, AllocatedStackMemory<'a, T>);
+
 impl<'a, T: 'a> core::default::Default for AllocatedStackMemory<'a, T> {
     fn default() -> Self {
         return AllocatedStackMemory::<'a, T>{mem : &mut[]};
     }
 }
 
-impl<'a, T: 'a> ops::Index<usize> for AllocatedStackMemory<'a, T> {
-    type Output = T;
-    fn index<'b>(&'b self, _index : usize) -> &'b T {
-        return &self.mem[_index];
-    }
-}
-
-impl<'a, T: 'a> ops::IndexMut<usize> for AllocatedStackMemory<'a, T> {
-    fn index_mut<'b>(&'b mut self, _index : usize) -> &'b mut T {
-        return &mut self.mem[_index];
-    }
-}
 
 impl<'a, T: 'a> SliceWrapper<T> for AllocatedStackMemory<'a, T> {
     fn slice(& self) -> & [T] {

src/bin/example.rs

@@ -61,7 +61,7 @@ fn show_heap_prealloc() {
 fn main() {
   let mut global_buffer = unsafe {define_allocator_memory_pool!(4, u8, [0; 1024 * 1024 * 200], calloc)};
   {
-  let mut gbref = &mut global_buffer;
+  let gbref = &mut global_buffer;
 {
   let mut ags = CallocAllocatedFreelist4::<u8>::new_allocator(gbref.data, bzero);
 
@@ -123,4 +123,4 @@ fn main() {
                x[0], x[9], -999, z[0]);
   }
   show_heap_prealloc();
-}
+}

src/bin/heap_alloc.rs

@@ -1,6 +1,6 @@
 use alloc_no_stdlib;
-use core::ops;
 use core;
+use alloc_no_stdlib::{SliceWrapper, SliceWrapperMut};
 
 pub struct Rebox<T> {
    b : Box<[T]>,
@@ -13,19 +13,7 @@ impl<T> core::default::Default for Rebox<T> {
        return Rebox::<T>{b : b};
     }
 }
-
-impl<T> ops::Index<usize> for Rebox<T>{
-    type Output = T;
-    fn index(&self, index : usize) -> &T {
-        return &(*self.b)[index]
-    }
-}
-
-impl<T> ops::IndexMut<usize> for Rebox<T>{
-    fn index_mut(&mut self, index : usize) -> &mut T {
-        return &mut (*self.b)[index]
-    }
-}
+define_index_ops_mut!(T, Rebox<T>);
 
 impl<T> alloc_no_stdlib::SliceWrapper<T> for Rebox<T> {
     fn slice(&self) -> & [T] {

src/heap_alloc.rs

@@ -19,19 +19,7 @@ impl<T> core::default::Default for WrapBox<T> {
        return WrapBox::<T>{b : b};
     }
 }
-
-impl<T> ops::Index<usize> for WrapBox<T>{
-    type Output = T;
-    fn index(&self, index : usize) -> &T {
-        return &(*self.b)[index]
-    }
-}
-
-impl<T> ops::IndexMut<usize> for WrapBox<T>{
-    fn index_mut(&mut self, index : usize) -> &mut T {
-        return &mut (*self.b)[index]
-    }
-}
+define_index_ops_mut!(T, WrapBox<T>);
 
 impl<T> super::SliceWrapper<T> for WrapBox<T> {
     fn slice(&self) -> & [T] {

src/init.rs

@@ -180,9 +180,9 @@ macro_rules! declare_stack_allocator_struct(
 #[macro_export]
 macro_rules! bind_global_buffers_to_allocator(
     ($allocator : expr, $buffer : ident, $T : ty) => {
-        $allocator.free_list_start = $buffer::freelist.len();
-        $allocator.system_resources.freelist = &mut $buffer::freelist;
-        $allocator.free_cell(AllocatedStackMemory::<$T>{mem:&mut $buffer::heap});
+        $allocator.free_list_start = $buffer::FREELIST.len();
+        $allocator.system_resources.freelist = &mut $buffer::FREELIST;
+        $allocator.free_cell(AllocatedStackMemory::<$T>{mem:&mut $buffer::HEAP});
     };
 );
 
@@ -211,10 +211,10 @@ macro_rules! define_allocator_memory_pool(
     };
     ($freelist_size : tt, $T : ty, [$default_value : expr; $heap_size : expr], global, $name : ident) => {
        pub mod $name {
-           pub static mut freelist : [&'static mut [$T];
+           pub static mut FREELIST : [&'static mut [$T];
                                   define_allocator_memory_pool!(@as_expr $freelist_size)]
                = static_array!(&mut[]; $freelist_size);
-           pub static mut heap : [$T; $heap_size] = [$default_value; $heap_size];
+           pub static mut HEAP : [$T; $heap_size] = [$default_value; $heap_size];
        }
     };
 

src/lib.rs

@@ -3,6 +3,7 @@
 #[cfg(not(feature="no-stdlib"))]
 #[macro_use]
 extern crate std;
+#[macro_use]
 mod allocated_memory;
 mod stack_allocator;
 mod allocated_stack_memory;
@@ -81,4 +82,4 @@ impl<'a, T:'a> Drop for CallocBackingStore<'a, T> {
 
     }
   }
-}
+}

src/stack_allocator.rs

@@ -51,7 +51,7 @@ impl<'a, T : 'a, U : allocated_memory::AllocatedSlice<&'a mut[T]> >
         if !found {
             panic!("OOM");
         }
-        let mut available_slice = core::mem::replace(&mut self.system_resources.slice_mut()[index],
+        let available_slice = core::mem::replace(&mut self.system_resources.slice_mut()[index],
                                                     &mut[]);
         if available_slice.len() == len
            || (available_slice.len() < len + 32
@@ -60,7 +60,7 @@ impl<'a, T : 'a, U : allocated_memory::AllocatedSlice<&'a mut[T]> >
             // we must assign free_list_start
             if index != self.free_list_start {
                 assert!(index > self.free_list_start);
-                let mut farthest_free_list = core::mem::replace(
+                let farthest_free_list = core::mem::replace(
                     &mut self.system_resources.slice_mut()[self.free_list_start],
                     &mut []);
                 core::mem::replace(&mut self.system_resources.slice_mut()[index],
@@ -70,13 +70,13 @@ impl<'a, T : 'a, U : allocated_memory::AllocatedSlice<&'a mut[T]> >
             return self.clear_if_necessary(index,
                                            AllocatedStackMemory::<'a, T>{mem:available_slice});
         } else { // the memory allocated was not the entire range of items. Split and move on
-            let (mut retval, return_to_sender) = available_slice.split_at_mut(len);
+            let (retval, return_to_sender) = available_slice.split_at_mut(len);
             core::mem::replace(&mut self.system_resources.slice_mut()[index], return_to_sender);
             return self.clear_if_necessary(index, AllocatedStackMemory::<'a, T>{mem:retval});
         }
     }
     fn free_cell(self : &mut StackAllocator<'a, T, U>,
-                 mut val : AllocatedStackMemory<'a, T>) {
+                 val : AllocatedStackMemory<'a, T>) {
         if val.slice().len() == 0 {
             return;
         }