0.4.0

Author: maciejhirsz

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "toolshed"
-version = "0.3.2"
+version = "0.4.0"
 authors = ["maciejhirsz <[email protected]>"]
 license = "MIT/Apache-2.0"
 description = "Arena allocator and a handful of useful data structures"

benches/list.rs

@@ -79,70 +79,66 @@ fn vec_create_256(b: &mut Bencher) {
 #[bench]
 fn list_create_016(b: &mut Bencher) {
     let arena = Arena::new();
-    let a     = &arena;
     let words = &WORDS[1..16];
 
     b.iter(|| {
-        unsafe { a.clear() };
-        let mut builder = ListBuilder::new(a, WORDS[0]);
+        unsafe { arena.clear() };
+        let builder = ListBuilder::new(&arena, WORDS[0]);
 
         for word in words.iter() {
-            builder.push(*word);
+            builder.push(&arena, *word);
         }
 
-        black_box(builder.into_list());
+        black_box(builder.as_list());
     })
 }
 
 #[bench]
 fn list_create_032(b: &mut Bencher) {
     let arena = Arena::new();
-    let a     = &arena;
     let words = &WORDS[1..32];
 
     b.iter(|| {
-        unsafe { a.clear() };
-        let mut builder = ListBuilder::new(a, WORDS[0]);
+        unsafe { arena.clear() };
+        let builder = ListBuilder::new(&arena, WORDS[0]);
 
         for word in words.iter() {
-            builder.push(*word);
+            builder.push(&arena, *word);
         }
 
-        black_box(builder.into_list());
+        black_box(builder.as_list());
     })
 }
 
 #[bench]
 fn list_create_064(b: &mut Bencher) {
     let arena = Arena::new();
-    let a     = &arena;
     let words = &WORDS[1..64];
 
     b.iter(|| {
-        unsafe { a.clear() };
-        let mut builder = ListBuilder::new(a, WORDS[0]);
+        unsafe { arena.clear() };
+        let builder = ListBuilder::new(&arena, WORDS[0]);
 
         for word in words.iter() {
-            builder.push(*word);
+            builder.push(&arena, *word);
         }
 
-        black_box(builder.into_list());
+        black_box(builder.as_list());
     })
 }
 
 #[bench]
 fn list_create_256(b: &mut Bencher) {
     let arena = Arena::new();
-    let a     = &arena;
 
     b.iter(|| {
-        unsafe { a.clear() };
-        let mut builder = ListBuilder::new(a, (0usize, 0));
+        unsafe { arena.clear() };
+        let builder = ListBuilder::new(&arena, (0usize, 0));
 
         for i in 1..256usize {
-            builder.push((i, i));
+            builder.push(&arena, (i, i));
         }
 
-        black_box(builder.into_list());
+        black_box(builder.as_list());
     })
 }

src/arena.rs

@@ -75,10 +75,11 @@ impl Arena {
         }
     }
 
-    /// Allocate an `&str` slice onto the arena with an extra null byte at the end.
-    /// Can be useful for C-style byte parsers where a null byte is not expected in
-    /// a well formatted string.
-    pub fn alloc_str_zero_end<'a>(&'a self, val: &str) -> *const u8 {
+    /// Allocate an `&str` slice onto the arena as null terminated C-style string.
+    /// No checks are performed on the source and whether or not it already contains
+    /// any nul bytes. While this does not create any memory issues, it assumes that
+    /// the reader of the source can deal with malformed source.
+    pub fn alloc_str_with_nul<'a>(&'a self, val: &str) -> *const u8 {
         let len_with_zero = val.len() + 1;
         let ptr = self.require(len_with_zero);
 
@@ -159,9 +160,22 @@ impl Arena {
     /// The only case where the use of this method would be justified is
     /// in benchmarks where creation of a structure on the arena is to be
     /// tested without the cost of re-creating the arena itself on every iteration.
+    #[doc(hidden)]
     #[inline]
     pub unsafe fn clear(&self) {
-        self.offset.set(0)
+        self.reset_to(0)
+    }
+
+    #[doc(hidden)]
+    #[inline]
+    pub unsafe fn offset(&self) -> usize {
+        self.offset.get()
+    }
+
+    #[doc(hidden)]
+    #[inline]
+    pub unsafe fn reset_to(&self, offset: usize) {
+        self.offset.set(offset)
     }
 }
 
@@ -224,9 +238,9 @@ mod test {
     }
 
     #[test]
-    fn alloc_str_zero_end() {
+    fn alloc_str_with_nul() {
         let arena = Arena::new();
-        let ptr = arena.alloc_str_zero_end("abcdefghijk");
+        let ptr = arena.alloc_str_with_nul("abcdefghijk");
         let allocated = unsafe { ::std::slice::from_raw_parts(ptr, 12) };
 
         assert_eq!(arena.offset.get(), 16);

src/impl_debug.rs

@@ -1,5 +1,5 @@
 use std::fmt::{self, Debug};
-use list::List;
+use list::{List, GrowableList, ListBuilder};
 use map::{Map, BloomMap};
 use set::{Set, BloomSet};
 
@@ -13,6 +13,26 @@ where
     }
 }
 
+impl<'arena, T> Debug for GrowableList<'arena, T>
+where
+    T: Debug,
+{
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.as_list().fmt(f)
+    }
+}
+
+impl<'arena, T> Debug for ListBuilder<'arena, T>
+where
+    T: Debug,
+{
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.as_list().fmt(f)
+    }
+}
+
 impl<'arena, K, V> Debug for Map<'arena, K, V>
 where
     K: Debug,