ByteSubstring now takes the needle as generic type T instead of &[u8]

This allows to either own (consume) the needle or keep a reference to it.

Author: tsnoam

src/fallback.rs

@@ -21,23 +21,23 @@ where
     }
 }
 
-pub struct ByteSubstring<'a> {
-    needle: &'a [u8],
+pub struct ByteSubstring<T> {
+    needle: T,
 }
 
-impl<'a> ByteSubstring<'a> {
-    pub /* const */ fn new(needle: &'a[u8]) -> Self {
+impl<T> ByteSubstring<T> where T: AsRef<[u8]> {
+    pub /* const */ fn new(needle: T) -> Self {
         ByteSubstring { needle }
     }
 
     #[cfg(feature = "pattern")]
     pub fn needle_len(&self) -> usize {
-        self.needle.len()
+        self.needle.as_ref().len()
     }
 
     pub fn find(&self, haystack: &[u8]) -> Option<usize> {
         haystack
-            .windows(self.needle.len())
-            .position(|window| window == self.needle)
+            .windows(self.needle.as_ref().len())
+            .position(|window| window == self.needle.as_ref())
     }
 }

src/lib.rs

@@ -283,16 +283,16 @@ where
 pub type AsciiCharsConst = AsciiChars<fn(u8) -> bool>;
 
 /// Searches a slice for the first occurence of the subslice.
-pub struct ByteSubstring<'a> {
+pub struct ByteSubstring<T> {
     #[cfg(any(jetscii_sse4_2 = "yes", jetscii_sse4_2 = "maybe"))]
     simd: simd::ByteSubstring<'a>,
 
     #[cfg(any(jetscii_sse4_2 = "maybe", jetscii_sse4_2 = "no"))]
-    fallback: fallback::ByteSubstring<'a>,
+    fallback: fallback::ByteSubstring<T>,
 }
 
-impl<'a> ByteSubstring<'a> {
-    pub /* const */ fn new(needle: &'a [u8]) -> Self {
+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),
@@ -321,10 +321,10 @@ impl<'a> ByteSubstring<'a> {
 }
 
 /// A convenience type that can be used in a constant or static.
-pub type ByteSubstringConst = ByteSubstring<'static>;
+pub type ByteSubstringConst = ByteSubstring<&'static [u8]>;
 
 /// Searches a string for the first occurence of the substring.
-pub struct Substring<'a>(ByteSubstring<'a>);
+pub struct Substring<'a>(ByteSubstring<&'a [u8]>);
 
 impl<'a> Substring<'a> {
     pub /* const */ fn new(needle: &'a str) -> Self {

src/simd.rs

@@ -248,19 +248,19 @@ impl<'b> PackedCompareControl for &'b Bytes {
     }
 }
 
-pub struct ByteSubstring<'a> {
-    complete_needle: &'a [u8],
+pub struct ByteSubstring<T> {
+    complete_needle: T,
     needle: __m128i,
     needle_len: i32,
 }
 
-impl<'a> ByteSubstring<'a> {
-    pub /* const */ fn new(needle: &'a[u8]) -> Self {
+impl<T> ByteSubstring<T> where T: AsRef<[u8]> {
+    pub /* const */ fn new(needle: T) -> Self {
         use std::cmp;
 
         let mut simd_needle = [0; 16];
         let len = cmp::min(simd_needle.len(), needle.len());
-        simd_needle[..len].copy_from_slice(&needle[..len]);
+        simd_needle[..len].copy_from_slice(&needle.as_ref()[..len]);
         ByteSubstring {
             complete_needle: needle,
             needle: unsafe { TransmuteToSimd { bytes: simd_needle }.simd },
@@ -270,7 +270,7 @@ impl<'a> ByteSubstring<'a> {
 
     #[cfg(feature = "pattern")]
     pub fn needle_len(&self) -> usize {
-        self.complete_needle.len()
+        self.complete_needle.as_ref().len()
     }
 
     #[inline]
@@ -281,7 +281,7 @@ impl<'a> ByteSubstring<'a> {
         while let Some(idx) = find(PackedCompare::<_, _SIDD_CMP_EQUAL_ORDERED>(self), &haystack[offset..]) {
             let abs_offset = offset + idx;
             // Found a match, but is it really?
-            if haystack[abs_offset..].starts_with(self.complete_needle) {
+            if haystack[abs_offset..].starts_with(self.complete_needle.as_ref()) {
                 return Some(abs_offset);
             }