Public APIs ByteSubstring & Bytes are now enums

This gains two purposes:
1. Fix ownership issue of trying to own needle `T` by both simd & fallback
   modules.

2. Simplifies the runtime checks done by the code when running in `maybe` mode.

Author: shepmaster

src/lib.rs

@@ -150,8 +150,6 @@ extern crate proptest;
 #[cfg(test)]
 extern crate region;
 
-use std::marker::PhantomData;
-
 include!(concat!(env!("OUT_DIR"), "/src/macros.rs"));
 
 #[cfg(any(jetscii_sse4_2 = "yes", jetscii_sse4_2 = "maybe"))]
@@ -163,49 +161,18 @@ mod fallback;
 #[cfg(feature = "pattern")]
 mod pattern;
 
-macro_rules! dispatch {
-    (simd: $simd:expr,fallback: $fallback:expr,) => {
-        // If we can tell at compile time that we have support,
-        // call the optimized code directly.
-        #[cfg(jetscii_sse4_2 = "yes")]
-        {
-            $simd
-        }
-
-        // If we can tell at compile time that we will *never* have
-        // support, call the fallback directly.
-        #[cfg(jetscii_sse4_2 = "no")]
-        {
-            $fallback
-        }
-
-        // Otherwise, we will be run on a machine with or without
-        // support, so we perform runtime detection.
-        #[cfg(jetscii_sse4_2 = "maybe")]
-        {
-            if is_x86_feature_detected!("sse4.2") {
-                $simd
-            } else {
-                $fallback
-            }
-        }
-    };
-}
-
 /// Searches a slice for a set of bytes. Up to 16 bytes may be used.
-pub struct Bytes<F>
+pub enum Bytes<F>
 where
     F: Fn(u8) -> bool,
 {
     #[cfg(any(jetscii_sse4_2 = "yes", jetscii_sse4_2 = "maybe"))]
-    simd: simd::Bytes,
+    // Since we might not use the fallback implementation, we add
+    // PhantomData to avoid an unused type parameter
+    SIMD(simd::Bytes, core::marker::PhantomData<F>),
 
     #[cfg(any(jetscii_sse4_2 = "maybe", jetscii_sse4_2 = "no"))]
-    fallback: fallback::Bytes<F>,
-
-    // Since we might not use the fallback implementation, we add this
-    // to avoid unused type parameters.
-    _fallback: PhantomData<F>,
+    Fallback(fallback::Bytes<F>),
 }
 
 impl<F> Bytes<F>
@@ -220,23 +187,34 @@ where
     /// the same bytes as in the array.
     #[allow(unused_variables)]
     pub /* const */ fn new(bytes: [u8; 16], len: i32, fallback: F) -> Self {
-        Bytes {
-            #[cfg(any(jetscii_sse4_2 = "yes", jetscii_sse4_2 = "maybe"))]
-            simd: simd::Bytes::new(bytes, len),
+        #[cfg(jetscii_sse4_2 = "yes")]
+        {
+            Self::SIMD(simd::Bytes::new(bytes, len), Default::default())
+        }
 
-            #[cfg(any(jetscii_sse4_2 = "maybe", jetscii_sse4_2 = "no"))]
-            fallback: fallback::Bytes::new(fallback),
+        #[cfg(jetscii_sse4_2 = "no")]
+        {
+            Self::Fallback(fallback::Bytes::new(fallback))
+        }
 
-            _fallback: PhantomData,
+        #[cfg(jetscii_sse4_2 = "maybe")]
+        {
+            if is_x86_feature_detected!("sse4.2") {
+                Self::SIMD(simd::Bytes::new(bytes, len), Default::default())
+            } else {
+                Self::Fallback(fallback::Bytes::new(fallback))
+            }
         }
     }
 
     /// Searches the slice for the first matching byte in the set.
     #[inline]
     pub fn find(&self, haystack: &[u8]) -> Option<usize> {
-        dispatch! {
-            simd: unsafe { self.simd.find(haystack) },
-            fallback: self.fallback.find(haystack),
+        match self {
+            #[cfg(any(jetscii_sse4_2 = "yes", jetscii_sse4_2 = "maybe"))]
+            Self::SIMD(needle, _) => unsafe { needle.find(haystack) },
+            #[cfg(any(jetscii_sse4_2 = "maybe", jetscii_sse4_2 = "no"))]
+            Self::Fallback(needle) => needle.find(haystack),
         }
     }
 }
@@ -282,42 +260,55 @@ where
 pub type AsciiCharsConst = AsciiChars<fn(u8) -> bool>;
 
 /// Searches a slice for the first occurence of the subslice.
-pub struct ByteSubstring<T> {
+pub enum ByteSubstring<T> {
     #[cfg(any(jetscii_sse4_2 = "yes", jetscii_sse4_2 = "maybe"))]
-    simd: simd::ByteSubstring<'a>,
+    SIMD(simd::ByteSubstring<T>),
 
     #[cfg(any(jetscii_sse4_2 = "maybe", jetscii_sse4_2 = "no"))]
-    fallback: fallback::ByteSubstring<T>,
+    Fallback(fallback::ByteSubstring<T>),
 }
 
 impl<T> ByteSubstring<T>
 where
     T: AsRef<[u8]>,
 {
     pub /* const */ fn new(needle: T) -> Self {
-        ByteSubstring {
-            #[cfg(any(jetscii_sse4_2 = "yes", jetscii_sse4_2 = "maybe"))]
-            simd: simd::ByteSubstring::new(needle),
+        #[cfg(jetscii_sse4_2 = "yes")]
+        {
+            Self::SIMD(simd::ByteSubstring::new(needle))
+        }
 
-            #[cfg(any(jetscii_sse4_2 = "maybe", jetscii_sse4_2 = "no"))]
-            fallback: fallback::ByteSubstring::new(needle),
+        #[cfg(jetscii_sse4_2 = "no")]
+        {
+            Self::Fallback(fallback::ByteSubstring::new(needle))
+        }
+
+        #[cfg(jetscii_sse4_2 = "maybe")]
+        if is_x86_feature_detected!("sse4.2") {
+            Self::SIMD(simd::ByteSubstring::new(needle))
+        } else {
+            Self::Fallback(fallback::ByteSubstring::new(needle))
         }
     }
 
     #[cfg(feature = "pattern")]
     fn needle_len(&self) -> usize {
-        dispatch! {
-            simd: self.simd.needle_len(),
-            fallback: self.fallback.needle_len(),
+        match self {
+            #[cfg(any(jetscii_sse4_2 = "yes", jetscii_sse4_2 = "maybe"))]
+            Self::SIMD(needle) => needle.needle_len(),
+            #[cfg(any(jetscii_sse4_2 = "maybe", jetscii_sse4_2 = "no"))]
+            Self::Fallback(needle) => needle.needle_len(),
         }
     }
 
     /// Searches the slice for the first occurence of the subslice.
     #[inline]
     pub fn find(&self, haystack: &[u8]) -> Option<usize> {
-        dispatch! {
-            simd: unsafe { self.simd.find(haystack) },
-            fallback: self.fallback.find(haystack),
+        match self {
+            #[cfg(any(jetscii_sse4_2 = "yes", jetscii_sse4_2 = "maybe"))]
+            Self::SIMD(needle) => unsafe { needle.find(haystack) },
+            #[cfg(any(jetscii_sse4_2 = "maybe", jetscii_sse4_2 = "no"))]
+            Self::Fallback(needle) => needle.find(haystack),
         }
     }
 }

src/simd.rs

@@ -248,12 +248,16 @@ impl<'b> PackedCompareControl for &'b Bytes {
     }
 }
 
-pub struct ByteSubstring<T> {
-    complete_needle: T,
+struct PackedNeedle {
     needle: __m128i,
     needle_len: i32,
 }
 
+pub struct ByteSubstring<T> {
+    complete_needle: T,
+    packed_needle: PackedNeedle,
+}
+
 impl<T> ByteSubstring<T>
 where
     T: AsRef<[u8]>,
@@ -262,12 +266,15 @@ where
         use std::cmp;
 
         let mut simd_needle = [0; 16];
-        let len = cmp::min(simd_needle.len(), needle.len());
+        let len = cmp::min(simd_needle.len(), needle.as_ref().len());
         simd_needle[..len].copy_from_slice(&needle.as_ref()[..len]);
-        ByteSubstring {
-            complete_needle: needle,
+        let packed_needle = PackedNeedle {
             needle: unsafe { TransmuteToSimd { bytes: simd_needle }.simd },
             needle_len: len as i32,
+        };
+        ByteSubstring {
+            complete_needle: needle,
+            packed_needle,
         }
     }
 
@@ -281,7 +288,10 @@ where
     pub unsafe fn find(&self, haystack: &[u8]) -> Option<usize> {
         let mut offset = 0;
 
-        while let Some(idx) = find(PackedCompare::<_, _SIDD_CMP_EQUAL_ORDERED>(self), &haystack[offset..]) {
+        while let Some(idx) = find(
+            PackedCompare::<_, _SIDD_CMP_EQUAL_ORDERED>(&self.packed_needle),
+            &haystack[offset..],
+        ) {
             let abs_offset = offset + idx;
             // Found a match, but is it really?
             if haystack[abs_offset..].starts_with(self.complete_needle.as_ref()) {
@@ -296,10 +306,11 @@ where
     }
 }
 
-impl<'a, 'b> PackedCompareControl for &'b ByteSubstring<'a> {
+impl<'b> PackedCompareControl for &'b PackedNeedle {
     fn needle(&self) -> __m128i {
         self.needle
     }
+
     fn needle_len(&self) -> i32 {
         self.needle_len
     }