Feature std compatibility

Cargo.toml

@@ -10,3 +10,18 @@ keywords = ["header", "heap", "vec", "vector", "graph"]
 categories = ["no-std"]
 license = "MIT"
 readme = "README.md"
+
+[features]
+default = ["std", "atomic_append"]
+std = []
+atomic_append = []
+
+[dev-dependencies]
+xmacro = "0.2.0"
+
+# include debug info for flamgraph and other profiling tools
+[profile.bench]
+debug = true
+
+[dependencies]
+mutants = "0.0.3"

README.md

@@ -3,3 +3,13 @@
 Allows one to store a header struct and a vector all inline in the same memory on the heap and share weak versions for minimizing random lookups in data structures
 
 If you use this without creating a weak ptr, it is safe. It is unsafe to create a weak pointer because you now have aliasing.
+
+## Features
+
+* `std`  
+  Enables API's that requires stdlib features. Provides more compatibility to `Vec`.
+  This feature is enabled by default.
+* `atomic_append`  
+  Enables the `atomic_push` API's that allows extending a `HeaderVec` with interior
+  mutability from a single thread by a immutable handle.
+  This feature is enabled by default.

benches/compare_std_vec.rs

@@ -2,6 +2,7 @@
 
 extern crate std;
 extern crate test;
+use xmacro::xmacro;
 
 use header_vec::*;
 use test::Bencher;
@@ -126,3 +127,135 @@ fn test_regular_vec_create(b: &mut Bencher) {
 //         acc
 //     });
 // }
+
+xmacro! {
+    $[
+        benchfunc:       type:
+        hv_create_bench  (HeaderVec::<(), _>)
+        vec_create_bench (Vec)
+    ]
+
+    fn $benchfunc<T>(b: &mut Bencher, init: &[T])
+    where
+        T: Clone + Default,
+    {
+        b.iter(|| {
+            let v = $type::from(init);
+            v
+        });
+    }
+}
+
+xmacro! {
+    // benching construction times.
+    $[
+        bench: init:
+        small  [123; 1]
+        middle [123; 1000]
+        large  [[123;32]; 100000]
+    ]
+
+    #[bench]
+    fn $+bench_hv_create_$bench(b: &mut Bencher) {
+        hv_create_bench(b, &$init);
+    }
+
+    #[bench]
+    fn $+bench_vec_create_$bench(b: &mut Bencher) {
+        vec_create_bench(b, &$init);
+    }
+}
+
+#[cfg(feature = "std")]
+mod stdbench {
+    use super::*;
+    use std::ops::RangeBounds;
+
+    xmacro! {
+        $[
+            benchfunc:      type:
+            hv_drain_bench  (HeaderVec::<(), _>)
+            vec_drain_bench (Vec)
+        ]
+
+        fn $benchfunc<T, R>(b: &mut Bencher, init: &[T], range: R)
+        where
+            T: Clone + Default,
+            R: RangeBounds<usize> + Clone,
+        {
+            b.iter(|| {
+                let mut v = $type::from(init);
+                v.drain(range.clone());
+                v
+            });
+        }
+    }
+
+    xmacro! {
+        $[
+            bench: init:       range:
+            begin  [123; 10000] (..5000)
+            middle [123; 10000] (1000..5000)
+            end    [123; 10000] (1000..)
+        ]
+
+        #[bench]
+        fn $+bench_hv_drain_$bench(b: &mut Bencher) {
+            hv_drain_bench(b, &$init, $range);
+        }
+
+        #[bench]
+        fn $+bench_vec_drain_$bench(b: &mut Bencher) {
+            vec_drain_bench(b, &$init, $range);
+        }
+    }
+
+    xmacro! {
+        $[
+            benchfunc:       type:
+            hv_splice_bench  (HeaderVec::<(), _>)
+            vec_splice_bench (Vec)
+        ]
+
+        fn $benchfunc<T, R, I>(b: &mut Bencher, init: &[T], range: R, replace_with: I)
+        where
+            T: Clone,
+            R: RangeBounds<usize> + Clone,
+            I: IntoIterator<Item = T> + Clone,
+        {
+            b.iter(|| {
+                let mut v = $type::from(init);
+                v.splice(range.clone(), replace_with.clone());
+                v
+            });
+        }
+    }
+
+    xmacro! {
+        $[
+            bench:           init:              range:       replace_with:
+            nop              [123; 10000]       (0..0)       []
+            insert           [123; 10000]       (1000..1000) [123; 5000]
+            insert_big       [[123;64]; 10000]  (1000..1000) [[123; 64]; 5000]
+            remove           [123; 10000]       (1000..6000) []
+            middle_shorter   [123; 10000]       (4000..5000) [234; 500]
+            middle_longer    [123; 10000]       (4000..5000) [345; 2000]
+            middle_same      [123; 10000]       (4000..5000) [456; 1000]
+            end_shorter      [123; 10000]       (9000..)     [234; 500]
+            end_longer       [123; 10000]       (9000..)     [345; 2000]
+            end_same         [123; 10000]       (9000..)     [456; 1000]
+            append_big       [[123;64]; 10000]  (10000..)    [[456; 64]; 5000]
+            append_front_big [[123;64]; 100000] (0..0)       [[456; 64]; 1]
+        ]
+
+        #[bench]
+        fn $+bench_hv_splice_$bench(b: &mut Bencher) {
+            hv_splice_bench(b, &$init, $range, $replace_with)
+        }
+
+        #[bench]
+        fn $+bench_vec_splice_$bench(b: &mut Bencher) {
+            vec_splice_bench(b, &$init, $range, $replace_with)
+        }
+    }
+}