Use reverse_bits intrinsic based on feature

Author: thomwiggers

.travis.yml

@@ -1,13 +1,26 @@
 language: rust
 
+rust:
+  - stable
+  - beta
+  - nightly
+env:
+  - FEATURES=unsafe_internals
+  - FEATURES=reverse_bits
+  - FEATURES=reverse_bits unsafe_internals
+
 matrix:
+  # Exclude combinations with unstable features for stable and beta
+  exclude:
+    - rust: stable
+    - rust: beta
   include:
-    - rust: nightly
-      env: FEATURES=unsafe_internals
     - rust: nightly
       env: FEATURES=''
     - rust: stable
+      env: FEATURES=''
     - rust: beta
+      env: FEATURES=''
 
 script:
   - cargo build --features "$FEATURES"

Cargo.toml

@@ -19,3 +19,4 @@ rand = "0.5"
 
 [features]
 unsafe_internals = []
+reverse_bits = []

benches/vob.rs

@@ -3,9 +3,11 @@
 #[macro_use]
 extern crate vob;
 extern crate test;
+extern crate rand;
 
 use test::Bencher;
 use vob::*;
+use rand::Rng;
 
 const N: usize = 100000;
 
@@ -49,3 +51,14 @@ fn extend_vob_not_aligned(b: &mut Bencher) {
         vector.extend_from_vob(&source)
     });
 }
+
+#[bench]
+fn from_bytes(b: &mut Bencher) {
+    let mut rng = rand::thread_rng();
+    let mut source = [0u8; 1024];
+    rng.fill(&mut source);
+
+    b.iter(|| {
+        Vob::from_bytes(&source)
+    });
+}

src/lib.rs

@@ -1,3 +1,4 @@
+#![cfg_attr(feature = "reverse_bits", feature(reverse_bits))]
 // Copyright (c) 2018 King's College London created by the Software Development Team
 // <http://soft-dev.org/>
 //
@@ -162,6 +163,9 @@ impl Vob<usize> {
     /// Create a Vob from a `u8` slice. The most significant bit of each byte comes first in the
     /// resulting Vob.
     ///
+    /// If the optional feature `reverse_bits` is enabled (and you're running nightly)
+    /// it will use the new `reverse_bits` method.
+    ///
     /// # Examples
     ///
     /// ```
@@ -188,12 +192,21 @@ impl Vob<usize> {
                     continue;
                 }
                 let b = slice[off];
-                if b != 0 {
-                    let mut rb: u8 = 0; // the byte b with its bits in reverse order
-                    for k in 0..8 {
-                        rb |= ((b >> k) & 1) << (8 - k - 1);
+                #[cfg(not(feature = "reverse_bits"))]
+                {
+                    if b != 0 {
+                        {
+                            let mut rb: u8 = 0; // the byte b with its bits in reverse order
+                            for k in 0..8 {
+                                rb |= ((b >> k) & 1) << (8 - k - 1);
+                            }
+                            w |= (rb as usize) << (j * 8);
+                        }
                     }
-                    w |= (rb as usize) << (j * 8);
+                }
+                #[cfg(feature = "reverse_bits")]
+                {
+                    w |= (b.reverse_bits() as usize) << (j * 8);
                 }
             }
             v.vec.push(w);