| use core::iter::Rev; |
| |
| use crate::arch::generic::memchr as generic; |
| |
| /// Search for the first occurrence of a byte in a slice. |
| /// |
| /// This returns the index corresponding to the first occurrence of `needle` in |
| /// `haystack`, or `None` if one is not found. If an index is returned, it is |
| /// guaranteed to be less than `haystack.len()`. |
| /// |
| /// While this is semantically the same as something like |
| /// `haystack.iter().position(|&b| b == needle)`, this routine will attempt to |
| /// use highly optimized vector operations that can be an order of magnitude |
| /// faster (or more). |
| /// |
| /// # Example |
| /// |
| /// This shows how to find the first position of a byte in a byte string. |
| /// |
| /// ``` |
| /// use memchr::memchr; |
| /// |
| /// let haystack = b"the quick brown fox"; |
| /// assert_eq!(memchr(b'k', haystack), Some(8)); |
| /// ``` |
| #[inline] |
| pub fn memchr(needle: u8, haystack: &[u8]) -> Option<usize> { |
| // SAFETY: memchr_raw, when a match is found, always returns a valid |
| // pointer between start and end. |
| unsafe { |
| generic::search_slice_with_raw(haystack, |start, end| { |
| memchr_raw(needle, start, end) |
| }) |
| } |
| } |
| |
| /// Search for the last occurrence of a byte in a slice. |
| /// |
| /// This returns the index corresponding to the last occurrence of `needle` in |
| /// `haystack`, or `None` if one is not found. If an index is returned, it is |
| /// guaranteed to be less than `haystack.len()`. |
| /// |
| /// While this is semantically the same as something like |
| /// `haystack.iter().rposition(|&b| b == needle)`, this routine will attempt to |
| /// use highly optimized vector operations that can be an order of magnitude |
| /// faster (or more). |
| /// |
| /// # Example |
| /// |
| /// This shows how to find the last position of a byte in a byte string. |
| /// |
| /// ``` |
| /// use memchr::memrchr; |
| /// |
| /// let haystack = b"the quick brown fox"; |
| /// assert_eq!(memrchr(b'o', haystack), Some(17)); |
| /// ``` |
| #[inline] |
| pub fn memrchr(needle: u8, haystack: &[u8]) -> Option<usize> { |
| // SAFETY: memrchr_raw, when a match is found, always returns a valid |
| // pointer between start and end. |
| unsafe { |
| generic::search_slice_with_raw(haystack, |start, end| { |
| memrchr_raw(needle, start, end) |
| }) |
| } |
| } |
| |
| /// Search for the first occurrence of two possible bytes in a haystack. |
| /// |
| /// This returns the index corresponding to the first occurrence of one of the |
| /// needle bytes in `haystack`, or `None` if one is not found. If an index is |
| /// returned, it is guaranteed to be less than `haystack.len()`. |
| /// |
| /// While this is semantically the same as something like |
| /// `haystack.iter().position(|&b| b == needle1 || b == needle2)`, this routine |
| /// will attempt to use highly optimized vector operations that can be an order |
| /// of magnitude faster (or more). |
| /// |
| /// # Example |
| /// |
| /// This shows how to find the first position of one of two possible bytes in a |
| /// haystack. |
| /// |
| /// ``` |
| /// use memchr::memchr2; |
| /// |
| /// let haystack = b"the quick brown fox"; |
| /// assert_eq!(memchr2(b'k', b'q', haystack), Some(4)); |
| /// ``` |
| #[inline] |
| pub fn memchr2(needle1: u8, needle2: u8, haystack: &[u8]) -> Option<usize> { |
| // SAFETY: memchr2_raw, when a match is found, always returns a valid |
| // pointer between start and end. |
| unsafe { |
| generic::search_slice_with_raw(haystack, |start, end| { |
| memchr2_raw(needle1, needle2, start, end) |
| }) |
| } |
| } |
| |
| /// Search for the last occurrence of two possible bytes in a haystack. |
| /// |
| /// This returns the index corresponding to the last occurrence of one of the |
| /// needle bytes in `haystack`, or `None` if one is not found. If an index is |
| /// returned, it is guaranteed to be less than `haystack.len()`. |
| /// |
| /// While this is semantically the same as something like |
| /// `haystack.iter().rposition(|&b| b == needle1 || b == needle2)`, this |
| /// routine will attempt to use highly optimized vector operations that can be |
| /// an order of magnitude faster (or more). |
| /// |
| /// # Example |
| /// |
| /// This shows how to find the last position of one of two possible bytes in a |
| /// haystack. |
| /// |
| /// ``` |
| /// use memchr::memrchr2; |
| /// |
| /// let haystack = b"the quick brown fox"; |
| /// assert_eq!(memrchr2(b'k', b'o', haystack), Some(17)); |
| /// ``` |
| #[inline] |
| pub fn memrchr2(needle1: u8, needle2: u8, haystack: &[u8]) -> Option<usize> { |
| // SAFETY: memrchr2_raw, when a match is found, always returns a valid |
| // pointer between start and end. |
| unsafe { |
| generic::search_slice_with_raw(haystack, |start, end| { |
| memrchr2_raw(needle1, needle2, start, end) |
| }) |
| } |
| } |
| |
| /// Search for the first occurrence of three possible bytes in a haystack. |
| /// |
| /// This returns the index corresponding to the first occurrence of one of the |
| /// needle bytes in `haystack`, or `None` if one is not found. If an index is |
| /// returned, it is guaranteed to be less than `haystack.len()`. |
| /// |
| /// While this is semantically the same as something like |
| /// `haystack.iter().position(|&b| b == needle1 || b == needle2 || b == needle3)`, |
| /// this routine will attempt to use highly optimized vector operations that |
| /// can be an order of magnitude faster (or more). |
| /// |
| /// # Example |
| /// |
| /// This shows how to find the first position of one of three possible bytes in |
| /// a haystack. |
| /// |
| /// ``` |
| /// use memchr::memchr3; |
| /// |
| /// let haystack = b"the quick brown fox"; |
| /// assert_eq!(memchr3(b'k', b'q', b'u', haystack), Some(4)); |
| /// ``` |
| #[inline] |
| pub fn memchr3( |
| needle1: u8, |
| needle2: u8, |
| needle3: u8, |
| haystack: &[u8], |
| ) -> Option<usize> { |
| // SAFETY: memchr3_raw, when a match is found, always returns a valid |
| // pointer between start and end. |
| unsafe { |
| generic::search_slice_with_raw(haystack, |start, end| { |
| memchr3_raw(needle1, needle2, needle3, start, end) |
| }) |
| } |
| } |
| |
| /// Search for the last occurrence of three possible bytes in a haystack. |
| /// |
| /// This returns the index corresponding to the last occurrence of one of the |
| /// needle bytes in `haystack`, or `None` if one is not found. If an index is |
| /// returned, it is guaranteed to be less than `haystack.len()`. |
| /// |
| /// While this is semantically the same as something like |
| /// `haystack.iter().rposition(|&b| b == needle1 || b == needle2 || b == needle3)`, |
| /// this routine will attempt to use highly optimized vector operations that |
| /// can be an order of magnitude faster (or more). |
| /// |
| /// # Example |
| /// |
| /// This shows how to find the last position of one of three possible bytes in |
| /// a haystack. |
| /// |
| /// ``` |
| /// use memchr::memrchr3; |
| /// |
| /// let haystack = b"the quick brown fox"; |
| /// assert_eq!(memrchr3(b'k', b'o', b'n', haystack), Some(17)); |
| /// ``` |
| #[inline] |
| pub fn memrchr3( |
| needle1: u8, |
| needle2: u8, |
| needle3: u8, |
| haystack: &[u8], |
| ) -> Option<usize> { |
| // SAFETY: memrchr3_raw, when a match is found, always returns a valid |
| // pointer between start and end. |
| unsafe { |
| generic::search_slice_with_raw(haystack, |start, end| { |
| memrchr3_raw(needle1, needle2, needle3, start, end) |
| }) |
| } |
| } |
| |
| /// Returns an iterator over all occurrences of the needle in a haystack. |
| /// |
| /// The iterator returned implements `DoubleEndedIterator`. This means it |
| /// can also be used to find occurrences in reverse order. |
| #[inline] |
| pub fn memchr_iter<'h>(needle: u8, haystack: &'h [u8]) -> Memchr<'h> { |
| Memchr::new(needle, haystack) |
| } |
| |
| /// Returns an iterator over all occurrences of the needle in a haystack, in |
| /// reverse. |
| #[inline] |
| pub fn memrchr_iter(needle: u8, haystack: &[u8]) -> Rev<Memchr<'_>> { |
| Memchr::new(needle, haystack).rev() |
| } |
| |
| /// Returns an iterator over all occurrences of the needles in a haystack. |
| /// |
| /// The iterator returned implements `DoubleEndedIterator`. This means it |
| /// can also be used to find occurrences in reverse order. |
| #[inline] |
| pub fn memchr2_iter<'h>( |
| needle1: u8, |
| needle2: u8, |
| haystack: &'h [u8], |
| ) -> Memchr2<'h> { |
| Memchr2::new(needle1, needle2, haystack) |
| } |
| |
| /// Returns an iterator over all occurrences of the needles in a haystack, in |
| /// reverse. |
| #[inline] |
| pub fn memrchr2_iter( |
| needle1: u8, |
| needle2: u8, |
| haystack: &[u8], |
| ) -> Rev<Memchr2<'_>> { |
| Memchr2::new(needle1, needle2, haystack).rev() |
| } |
| |
| /// Returns an iterator over all occurrences of the needles in a haystack. |
| /// |
| /// The iterator returned implements `DoubleEndedIterator`. This means it |
| /// can also be used to find occurrences in reverse order. |
| #[inline] |
| pub fn memchr3_iter<'h>( |
| needle1: u8, |
| needle2: u8, |
| needle3: u8, |
| haystack: &'h [u8], |
| ) -> Memchr3<'h> { |
| Memchr3::new(needle1, needle2, needle3, haystack) |
| } |
| |
| /// Returns an iterator over all occurrences of the needles in a haystack, in |
| /// reverse. |
| #[inline] |
| pub fn memrchr3_iter( |
| needle1: u8, |
| needle2: u8, |
| needle3: u8, |
| haystack: &[u8], |
| ) -> Rev<Memchr3<'_>> { |
| Memchr3::new(needle1, needle2, needle3, haystack).rev() |
| } |
| |
| /// An iterator over all occurrences of a single byte in a haystack. |
| /// |
| /// This iterator implements `DoubleEndedIterator`, which means it can also be |
| /// used to find occurrences in reverse order. |
| /// |
| /// This iterator is created by the [`memchr_iter`] or `[memrchr_iter`] |
| /// functions. It can also be created with the [`Memchr::new`] method. |
| /// |
| /// The lifetime parameter `'h` refers to the lifetime of the haystack being |
| /// searched. |
| #[derive(Clone, Debug)] |
| pub struct Memchr<'h> { |
| needle1: u8, |
| it: crate::arch::generic::memchr::Iter<'h>, |
| } |
| |
| impl<'h> Memchr<'h> { |
| /// Returns an iterator over all occurrences of the needle byte in the |
| /// given haystack. |
| /// |
| /// The iterator returned implements `DoubleEndedIterator`. This means it |
| /// can also be used to find occurrences in reverse order. |
| #[inline] |
| pub fn new(needle1: u8, haystack: &'h [u8]) -> Memchr<'h> { |
| Memchr { |
| needle1, |
| it: crate::arch::generic::memchr::Iter::new(haystack), |
| } |
| } |
| } |
| |
| impl<'h> Iterator for Memchr<'h> { |
| type Item = usize; |
| |
| #[inline] |
| fn next(&mut self) -> Option<usize> { |
| // SAFETY: All of our implementations of memchr ensure that any |
| // pointers returns will fall within the start and end bounds, and this |
| // upholds the safety contract of `self.it.next`. |
| unsafe { |
| // NOTE: I attempted to define an enum of previously created |
| // searchers and then switch on those here instead of just |
| // calling `memchr_raw` (or `One::new(..).find_raw(..)`). But |
| // that turned out to have a fair bit of extra overhead when |
| // searching very small haystacks. |
| self.it.next(|s, e| memchr_raw(self.needle1, s, e)) |
| } |
| } |
| |
| #[inline] |
| fn count(self) -> usize { |
| self.it.count(|s, e| { |
| // SAFETY: We rely on our generic iterator to return valid start |
| // and end pointers. |
| unsafe { count_raw(self.needle1, s, e) } |
| }) |
| } |
| |
| #[inline] |
| fn size_hint(&self) -> (usize, Option<usize>) { |
| self.it.size_hint() |
| } |
| } |
| |
| impl<'h> DoubleEndedIterator for Memchr<'h> { |
| #[inline] |
| fn next_back(&mut self) -> Option<usize> { |
| // SAFETY: All of our implementations of memchr ensure that any |
| // pointers returns will fall within the start and end bounds, and this |
| // upholds the safety contract of `self.it.next_back`. |
| unsafe { self.it.next_back(|s, e| memrchr_raw(self.needle1, s, e)) } |
| } |
| } |
| |
| impl<'h> core::iter::FusedIterator for Memchr<'h> {} |
| |
| /// An iterator over all occurrences of two possible bytes in a haystack. |
| /// |
| /// This iterator implements `DoubleEndedIterator`, which means it can also be |
| /// used to find occurrences in reverse order. |
| /// |
| /// This iterator is created by the [`memchr2_iter`] or `[memrchr2_iter`] |
| /// functions. It can also be created with the [`Memchr2::new`] method. |
| /// |
| /// The lifetime parameter `'h` refers to the lifetime of the haystack being |
| /// searched. |
| #[derive(Clone, Debug)] |
| pub struct Memchr2<'h> { |
| needle1: u8, |
| needle2: u8, |
| it: crate::arch::generic::memchr::Iter<'h>, |
| } |
| |
| impl<'h> Memchr2<'h> { |
| /// Returns an iterator over all occurrences of the needle bytes in the |
| /// given haystack. |
| /// |
| /// The iterator returned implements `DoubleEndedIterator`. This means it |
| /// can also be used to find occurrences in reverse order. |
| #[inline] |
| pub fn new(needle1: u8, needle2: u8, haystack: &'h [u8]) -> Memchr2<'h> { |
| Memchr2 { |
| needle1, |
| needle2, |
| it: crate::arch::generic::memchr::Iter::new(haystack), |
| } |
| } |
| } |
| |
| impl<'h> Iterator for Memchr2<'h> { |
| type Item = usize; |
| |
| #[inline] |
| fn next(&mut self) -> Option<usize> { |
| // SAFETY: All of our implementations of memchr ensure that any |
| // pointers returns will fall within the start and end bounds, and this |
| // upholds the safety contract of `self.it.next`. |
| unsafe { |
| self.it.next(|s, e| memchr2_raw(self.needle1, self.needle2, s, e)) |
| } |
| } |
| |
| #[inline] |
| fn size_hint(&self) -> (usize, Option<usize>) { |
| self.it.size_hint() |
| } |
| } |
| |
| impl<'h> DoubleEndedIterator for Memchr2<'h> { |
| #[inline] |
| fn next_back(&mut self) -> Option<usize> { |
| // SAFETY: All of our implementations of memchr ensure that any |
| // pointers returns will fall within the start and end bounds, and this |
| // upholds the safety contract of `self.it.next_back`. |
| unsafe { |
| self.it.next_back(|s, e| { |
| memrchr2_raw(self.needle1, self.needle2, s, e) |
| }) |
| } |
| } |
| } |
| |
| impl<'h> core::iter::FusedIterator for Memchr2<'h> {} |
| |
| /// An iterator over all occurrences of three possible bytes in a haystack. |
| /// |
| /// This iterator implements `DoubleEndedIterator`, which means it can also be |
| /// used to find occurrences in reverse order. |
| /// |
| /// This iterator is created by the [`memchr2_iter`] or `[memrchr2_iter`] |
| /// functions. It can also be created with the [`Memchr3::new`] method. |
| /// |
| /// The lifetime parameter `'h` refers to the lifetime of the haystack being |
| /// searched. |
| #[derive(Clone, Debug)] |
| pub struct Memchr3<'h> { |
| needle1: u8, |
| needle2: u8, |
| needle3: u8, |
| it: crate::arch::generic::memchr::Iter<'h>, |
| } |
| |
| impl<'h> Memchr3<'h> { |
| /// Returns an iterator over all occurrences of the needle bytes in the |
| /// given haystack. |
| /// |
| /// The iterator returned implements `DoubleEndedIterator`. This means it |
| /// can also be used to find occurrences in reverse order. |
| #[inline] |
| pub fn new( |
| needle1: u8, |
| needle2: u8, |
| needle3: u8, |
| haystack: &'h [u8], |
| ) -> Memchr3<'h> { |
| Memchr3 { |
| needle1, |
| needle2, |
| needle3, |
| it: crate::arch::generic::memchr::Iter::new(haystack), |
| } |
| } |
| } |
| |
| impl<'h> Iterator for Memchr3<'h> { |
| type Item = usize; |
| |
| #[inline] |
| fn next(&mut self) -> Option<usize> { |
| // SAFETY: All of our implementations of memchr ensure that any |
| // pointers returns will fall within the start and end bounds, and this |
| // upholds the safety contract of `self.it.next`. |
| unsafe { |
| self.it.next(|s, e| { |
| memchr3_raw(self.needle1, self.needle2, self.needle3, s, e) |
| }) |
| } |
| } |
| |
| #[inline] |
| fn size_hint(&self) -> (usize, Option<usize>) { |
| self.it.size_hint() |
| } |
| } |
| |
| impl<'h> DoubleEndedIterator for Memchr3<'h> { |
| #[inline] |
| fn next_back(&mut self) -> Option<usize> { |
| // SAFETY: All of our implementations of memchr ensure that any |
| // pointers returns will fall within the start and end bounds, and this |
| // upholds the safety contract of `self.it.next_back`. |
| unsafe { |
| self.it.next_back(|s, e| { |
| memrchr3_raw(self.needle1, self.needle2, self.needle3, s, e) |
| }) |
| } |
| } |
| } |
| |
| impl<'h> core::iter::FusedIterator for Memchr3<'h> {} |
| |
| /// memchr, but using raw pointers to represent the haystack. |
| /// |
| /// # Safety |
| /// |
| /// Pointers must be valid. See `One::find_raw`. |
| #[inline] |
| unsafe fn memchr_raw( |
| needle: u8, |
| start: *const u8, |
| end: *const u8, |
| ) -> Option<*const u8> { |
| #[cfg(target_arch = "x86_64")] |
| { |
| // x86_64 does CPU feature detection at runtime in order to use AVX2 |
| // instructions even when the `avx2` feature isn't enabled at compile |
| // time. This function also handles using a fallback if neither AVX2 |
| // nor SSE2 (unusual) are available. |
| crate::arch::x86_64::memchr::memchr_raw(needle, start, end) |
| } |
| #[cfg(all(target_arch = "wasm32", target_feature = "simd128"))] |
| { |
| crate::arch::wasm32::memchr::memchr_raw(needle, start, end) |
| } |
| #[cfg(target_arch = "aarch64")] |
| { |
| crate::arch::aarch64::memchr::memchr_raw(needle, start, end) |
| } |
| #[cfg(not(any( |
| target_arch = "x86_64", |
| all(target_arch = "wasm32", target_feature = "simd128"), |
| target_arch = "aarch64" |
| )))] |
| { |
| crate::arch::all::memchr::One::new(needle).find_raw(start, end) |
| } |
| } |
| |
| /// memrchr, but using raw pointers to represent the haystack. |
| /// |
| /// # Safety |
| /// |
| /// Pointers must be valid. See `One::rfind_raw`. |
| #[inline] |
| unsafe fn memrchr_raw( |
| needle: u8, |
| start: *const u8, |
| end: *const u8, |
| ) -> Option<*const u8> { |
| #[cfg(target_arch = "x86_64")] |
| { |
| crate::arch::x86_64::memchr::memrchr_raw(needle, start, end) |
| } |
| #[cfg(all(target_arch = "wasm32", target_feature = "simd128"))] |
| { |
| crate::arch::wasm32::memchr::memrchr_raw(needle, start, end) |
| } |
| #[cfg(target_arch = "aarch64")] |
| { |
| crate::arch::aarch64::memchr::memrchr_raw(needle, start, end) |
| } |
| #[cfg(not(any( |
| target_arch = "x86_64", |
| all(target_arch = "wasm32", target_feature = "simd128"), |
| target_arch = "aarch64" |
| )))] |
| { |
| crate::arch::all::memchr::One::new(needle).rfind_raw(start, end) |
| } |
| } |
| |
| /// memchr2, but using raw pointers to represent the haystack. |
| /// |
| /// # Safety |
| /// |
| /// Pointers must be valid. See `Two::find_raw`. |
| #[inline] |
| unsafe fn memchr2_raw( |
| needle1: u8, |
| needle2: u8, |
| start: *const u8, |
| end: *const u8, |
| ) -> Option<*const u8> { |
| #[cfg(target_arch = "x86_64")] |
| { |
| crate::arch::x86_64::memchr::memchr2_raw(needle1, needle2, start, end) |
| } |
| #[cfg(all(target_arch = "wasm32", target_feature = "simd128"))] |
| { |
| crate::arch::wasm32::memchr::memchr2_raw(needle1, needle2, start, end) |
| } |
| #[cfg(target_arch = "aarch64")] |
| { |
| crate::arch::aarch64::memchr::memchr2_raw(needle1, needle2, start, end) |
| } |
| #[cfg(not(any( |
| target_arch = "x86_64", |
| all(target_arch = "wasm32", target_feature = "simd128"), |
| target_arch = "aarch64" |
| )))] |
| { |
| crate::arch::all::memchr::Two::new(needle1, needle2) |
| .find_raw(start, end) |
| } |
| } |
| |
| /// memrchr2, but using raw pointers to represent the haystack. |
| /// |
| /// # Safety |
| /// |
| /// Pointers must be valid. See `Two::rfind_raw`. |
| #[inline] |
| unsafe fn memrchr2_raw( |
| needle1: u8, |
| needle2: u8, |
| start: *const u8, |
| end: *const u8, |
| ) -> Option<*const u8> { |
| #[cfg(target_arch = "x86_64")] |
| { |
| crate::arch::x86_64::memchr::memrchr2_raw(needle1, needle2, start, end) |
| } |
| #[cfg(all(target_arch = "wasm32", target_feature = "simd128"))] |
| { |
| crate::arch::wasm32::memchr::memrchr2_raw(needle1, needle2, start, end) |
| } |
| #[cfg(target_arch = "aarch64")] |
| { |
| crate::arch::aarch64::memchr::memrchr2_raw( |
| needle1, needle2, start, end, |
| ) |
| } |
| #[cfg(not(any( |
| target_arch = "x86_64", |
| all(target_arch = "wasm32", target_feature = "simd128"), |
| target_arch = "aarch64" |
| )))] |
| { |
| crate::arch::all::memchr::Two::new(needle1, needle2) |
| .rfind_raw(start, end) |
| } |
| } |
| |
| /// memchr3, but using raw pointers to represent the haystack. |
| /// |
| /// # Safety |
| /// |
| /// Pointers must be valid. See `Three::find_raw`. |
| #[inline] |
| unsafe fn memchr3_raw( |
| needle1: u8, |
| needle2: u8, |
| needle3: u8, |
| start: *const u8, |
| end: *const u8, |
| ) -> Option<*const u8> { |
| #[cfg(target_arch = "x86_64")] |
| { |
| crate::arch::x86_64::memchr::memchr3_raw( |
| needle1, needle2, needle3, start, end, |
| ) |
| } |
| #[cfg(all(target_arch = "wasm32", target_feature = "simd128"))] |
| { |
| crate::arch::wasm32::memchr::memchr3_raw( |
| needle1, needle2, needle3, start, end, |
| ) |
| } |
| #[cfg(target_arch = "aarch64")] |
| { |
| crate::arch::aarch64::memchr::memchr3_raw( |
| needle1, needle2, needle3, start, end, |
| ) |
| } |
| #[cfg(not(any( |
| target_arch = "x86_64", |
| all(target_arch = "wasm32", target_feature = "simd128"), |
| target_arch = "aarch64" |
| )))] |
| { |
| crate::arch::all::memchr::Three::new(needle1, needle2, needle3) |
| .find_raw(start, end) |
| } |
| } |
| |
| /// memrchr3, but using raw pointers to represent the haystack. |
| /// |
| /// # Safety |
| /// |
| /// Pointers must be valid. See `Three::rfind_raw`. |
| #[inline] |
| unsafe fn memrchr3_raw( |
| needle1: u8, |
| needle2: u8, |
| needle3: u8, |
| start: *const u8, |
| end: *const u8, |
| ) -> Option<*const u8> { |
| #[cfg(target_arch = "x86_64")] |
| { |
| crate::arch::x86_64::memchr::memrchr3_raw( |
| needle1, needle2, needle3, start, end, |
| ) |
| } |
| #[cfg(all(target_arch = "wasm32", target_feature = "simd128"))] |
| { |
| crate::arch::wasm32::memchr::memrchr3_raw( |
| needle1, needle2, needle3, start, end, |
| ) |
| } |
| #[cfg(target_arch = "aarch64")] |
| { |
| crate::arch::aarch64::memchr::memrchr3_raw( |
| needle1, needle2, needle3, start, end, |
| ) |
| } |
| #[cfg(not(any( |
| target_arch = "x86_64", |
| all(target_arch = "wasm32", target_feature = "simd128"), |
| target_arch = "aarch64" |
| )))] |
| { |
| crate::arch::all::memchr::Three::new(needle1, needle2, needle3) |
| .rfind_raw(start, end) |
| } |
| } |
| |
| /// Count all matching bytes, but using raw pointers to represent the haystack. |
| /// |
| /// # Safety |
| /// |
| /// Pointers must be valid. See `One::count_raw`. |
| #[inline] |
| unsafe fn count_raw(needle: u8, start: *const u8, end: *const u8) -> usize { |
| #[cfg(target_arch = "x86_64")] |
| { |
| crate::arch::x86_64::memchr::count_raw(needle, start, end) |
| } |
| #[cfg(all(target_arch = "wasm32", target_feature = "simd128"))] |
| { |
| crate::arch::wasm32::memchr::count_raw(needle, start, end) |
| } |
| #[cfg(target_arch = "aarch64")] |
| { |
| crate::arch::aarch64::memchr::count_raw(needle, start, end) |
| } |
| #[cfg(not(any( |
| target_arch = "x86_64", |
| all(target_arch = "wasm32", target_feature = "simd128"), |
| target_arch = "aarch64" |
| )))] |
| { |
| crate::arch::all::memchr::One::new(needle).count_raw(start, end) |
| } |
| } |
| |
| #[cfg(test)] |
| mod tests { |
| use super::*; |
| |
| #[test] |
| fn forward1_iter() { |
| crate::tests::memchr::Runner::new(1).forward_iter( |
| |haystack, needles| { |
| Some(memchr_iter(needles[0], haystack).collect()) |
| }, |
| ) |
| } |
| |
| #[test] |
| fn forward1_oneshot() { |
| crate::tests::memchr::Runner::new(1).forward_oneshot( |
| |haystack, needles| Some(memchr(needles[0], haystack)), |
| ) |
| } |
| |
| #[test] |
| fn reverse1_iter() { |
| crate::tests::memchr::Runner::new(1).reverse_iter( |
| |haystack, needles| { |
| Some(memrchr_iter(needles[0], haystack).collect()) |
| }, |
| ) |
| } |
| |
| #[test] |
| fn reverse1_oneshot() { |
| crate::tests::memchr::Runner::new(1).reverse_oneshot( |
| |haystack, needles| Some(memrchr(needles[0], haystack)), |
| ) |
| } |
| |
| #[test] |
| fn count1_iter() { |
| crate::tests::memchr::Runner::new(1).count_iter(|haystack, needles| { |
| Some(memchr_iter(needles[0], haystack).count()) |
| }) |
| } |
| |
| #[test] |
| fn forward2_iter() { |
| crate::tests::memchr::Runner::new(2).forward_iter( |
| |haystack, needles| { |
| let n1 = needles.get(0).copied()?; |
| let n2 = needles.get(1).copied()?; |
| Some(memchr2_iter(n1, n2, haystack).collect()) |
| }, |
| ) |
| } |
| |
| #[test] |
| fn forward2_oneshot() { |
| crate::tests::memchr::Runner::new(2).forward_oneshot( |
| |haystack, needles| { |
| let n1 = needles.get(0).copied()?; |
| let n2 = needles.get(1).copied()?; |
| Some(memchr2(n1, n2, haystack)) |
| }, |
| ) |
| } |
| |
| #[test] |
| fn reverse2_iter() { |
| crate::tests::memchr::Runner::new(2).reverse_iter( |
| |haystack, needles| { |
| let n1 = needles.get(0).copied()?; |
| let n2 = needles.get(1).copied()?; |
| Some(memrchr2_iter(n1, n2, haystack).collect()) |
| }, |
| ) |
| } |
| |
| #[test] |
| fn reverse2_oneshot() { |
| crate::tests::memchr::Runner::new(2).reverse_oneshot( |
| |haystack, needles| { |
| let n1 = needles.get(0).copied()?; |
| let n2 = needles.get(1).copied()?; |
| Some(memrchr2(n1, n2, haystack)) |
| }, |
| ) |
| } |
| |
| #[test] |
| fn forward3_iter() { |
| crate::tests::memchr::Runner::new(3).forward_iter( |
| |haystack, needles| { |
| let n1 = needles.get(0).copied()?; |
| let n2 = needles.get(1).copied()?; |
| let n3 = needles.get(2).copied()?; |
| Some(memchr3_iter(n1, n2, n3, haystack).collect()) |
| }, |
| ) |
| } |
| |
| #[test] |
| fn forward3_oneshot() { |
| crate::tests::memchr::Runner::new(3).forward_oneshot( |
| |haystack, needles| { |
| let n1 = needles.get(0).copied()?; |
| let n2 = needles.get(1).copied()?; |
| let n3 = needles.get(2).copied()?; |
| Some(memchr3(n1, n2, n3, haystack)) |
| }, |
| ) |
| } |
| |
| #[test] |
| fn reverse3_iter() { |
| crate::tests::memchr::Runner::new(3).reverse_iter( |
| |haystack, needles| { |
| let n1 = needles.get(0).copied()?; |
| let n2 = needles.get(1).copied()?; |
| let n3 = needles.get(2).copied()?; |
| Some(memrchr3_iter(n1, n2, n3, haystack).collect()) |
| }, |
| ) |
| } |
| |
| #[test] |
| fn reverse3_oneshot() { |
| crate::tests::memchr::Runner::new(3).reverse_oneshot( |
| |haystack, needles| { |
| let n1 = needles.get(0).copied()?; |
| let n2 = needles.get(1).copied()?; |
| let n3 = needles.get(2).copied()?; |
| Some(memrchr3(n1, n2, n3, haystack)) |
| }, |
| ) |
| } |
| |
| // Prior to memchr 2.6, the memchr iterators both implemented Send and |
| // Sync. But in memchr 2.6, the iterator changed to use raw pointers |
| // internally and I didn't add explicit Send/Sync impls. This ended up |
| // regressing the API. This test ensures we don't do that again. |
| // |
| // See: https://github.com/BurntSushi/memchr/issues/133 |
| #[test] |
| fn sync_regression() { |
| use core::panic::{RefUnwindSafe, UnwindSafe}; |
| |
| fn assert_send_sync<T: Send + Sync + UnwindSafe + RefUnwindSafe>() {} |
| assert_send_sync::<Memchr>(); |
| assert_send_sync::<Memchr2>(); |
| assert_send_sync::<Memchr3>() |
| } |
| } |
