✨ v2.0.0

Author: JumperBot

Cargo.toml

@@ -1,11 +1,11 @@
 [package]
 name = "split-every"
-version = "1.0.0"
+version = "2.0.0"
 edition = "2021"
 authors = ["JumperBot_"]
-description = "Split for every n occurences of a pattern iteratively!"
+description = "Split for every n occurrences of a pattern iteratively!"
 license = "MIT"
-keywords = ["split", "string", "iterator", "pattern", "occurences"]
+keywords = ["split", "string", "iterator", "pattern", "occurrences"]
 categories = ["development-tools", "text-processing", "visualization", "parsing", "value-formatting"]
 repository = "https://github.com/JumperBot/split-every/"
 

README.md

@@ -17,8 +17,8 @@ use split_every::{SplitEveryImpl, SplitEvery};
 //              "I don't really"
 //              "know what to"
 //              "say".
-let mut splitter: SplitEvery =
-    "Oh hi there I don't really know what to say".split_every_n_of_str(" ", 3);
+let mut splitter: SplitEvery<&str> =
+    "Oh hi there I don't really know what to say".split_every_n_times(" ", 3);
 println!("{}", splitter.next().unwrap());
 println!("{}", splitter.next().unwrap());
 println!("{}", splitter.next().unwrap());
@@ -27,9 +27,9 @@ println!("{}", splitter.next().unwrap());
 
 ---
 
-## ✨ Split For Every N Occurences Of A Pattern Iteratively
+## ✨ Split For Every N Occurrences Of A Pattern Iteratively
 
-This crate **helps you** split a `string` for every `n` occurences of a `pattern`.  
+This crate **helps you** split a `string` for every `n` occurrences of a `pattern`.  
 It contains an exclusive `iterator`.
 
 ---

src/lib.rs

@@ -1,5 +1,5 @@
-//! Split for every n occurences of a pattern iteratively.
-//! This crate **helps you** split a `string` for every `n` occurences of a `pattern`.  
+//! Split for every n occurrences of a pattern iteratively.
+//! This crate **helps you** split a `string` for every `n` occurrences of a `pattern`.  
 //! It contains an exclusive `iterator`.
 //!
 //! # Examples
@@ -10,39 +10,30 @@
 //! //              "I don't really"
 //! //              "know what to"
 //! //              "say".
-//! let mut splitter: SplitEvery =
-//!     "Oh hi there I don't really know what to say".split_every_n_of_str(" ", 3);
+//! let mut splitter: SplitEvery<&str> =
+//!     "Oh hi there I don't really know what to say".split_every_n_times(" ", 3);
 //! println!("{}", splitter.next().unwrap());
 //! println!("{}", splitter.next().unwrap());
 //! println!("{}", splitter.next().unwrap());
 //! println!("{}", splitter.next().unwrap());
 //! ```
 
+/// Import all necessary traits and structs.
+pub mod prelude {
+    pub use crate::{SplitEvery, SplitEveryImpl};
+}
+
 /// A trait containing all `string` split-every functions.
 pub trait SplitEveryImpl: AsRef<str> {
     /// This splits a `string` every `n` times a `string` is found.
     /// This splits exclusively.
-    /// The `string` must be `utf8-encoded`.
-    #[must_use]
-    fn split_every_n_of_str<'a>(&'a self, pat: &'a str, n: usize) -> SplitEvery<'a> {
-        assert!(n > 0, "n must be greater than 0");
-        SplitEvery {
-            inner: self.as_ref(),
-            pat: Pattern::Str(pat),
-            n,
-            index: 0,
-        }
-    }
-
-    /// This splits a `string` every `n` times a `char` is found.
-    /// This splits exclusively.
-    /// The `string` must be `utf8-encoded`.
     #[must_use]
-    fn split_every_n_of_char(&self, pat: char, n: usize) -> SplitEvery<'_> {
-        assert!(n > 0, "n must be greater than 0");
+    #[allow(private_bounds)]
+    fn split_every_n_times<'a, T: Pattern<'a>>(&'a self, pat: T, n: usize) -> SplitEvery<'a, T> {
         SplitEvery {
             inner: self.as_ref(),
-            pat: Pattern::Ch(pat),
+            pat_byte_len: pat.byte_len(),
+            pat,
             n,
             index: 0,
         }
@@ -52,76 +43,149 @@ pub trait SplitEveryImpl: AsRef<str> {
 impl<T: AsRef<str>> SplitEveryImpl for T {}
 
 /// A convinient substitution to `std::str::pattern::Pattern`.
-enum Pattern<'a> {
-    Str(&'a str),
-    Ch(char),
-}
+trait Pattern<'a> {
+    /// A convinient `find` method.
+    fn find_in(&self, haystack: &str) -> Option<usize>;
 
-impl<'a> Pattern<'a> {
     /// A convinient `len` method.
-    fn len(&self) -> usize {
-        match self {
-            Self::Str(inner) => inner.len(),
-            Self::Ch(inner) => inner.len_utf8(),
-        }
+    fn byte_len(&self) -> Option<usize>;
+}
+
+impl<'a> Pattern<'a> for &'a str {
+    fn find_in(&self, haystack: &str) -> Option<usize> {
+        haystack.find(self)
+    }
+
+    fn byte_len(&self) -> Option<usize> {
+        Some(self.len())
     }
 }
 
-/// An `Iterator` struct for splitting a `string` every `n` occurences of a `pattern`.
-pub struct SplitEvery<'a> {
+impl<'a> Pattern<'a> for char {
+    fn find_in(&self, haystack: &str) -> Option<usize> {
+        haystack.find(*self)
+    }
+
+    fn byte_len(&self) -> Option<usize> {
+        Some(self.len_utf8())
+    }
+}
+
+impl<'a> Pattern<'a> for &'a [char] {
+    fn find_in(&self, haystack: &str) -> Option<usize> {
+        haystack.find(*self)
+    }
+
+    fn byte_len(&self) -> Option<usize> {
+        Some(self.iter().map(|ch| ch.len_utf8()).sum())
+    }
+}
+
+impl<'a, F: FnMut(char) -> bool + Copy> Pattern<'a> for F {
+    fn find_in(&self, haystack: &str) -> Option<usize> {
+        haystack.find(*self)
+    }
+
+    fn byte_len(&self) -> Option<usize> {
+        None
+    }
+}
+
+impl<'a> Pattern<'a> for &'a String {
+    fn find_in(&self, haystack: &str) -> Option<usize> {
+        haystack.find(*self)
+    }
+
+    fn byte_len(&self) -> Option<usize> {
+        Some(self.len())
+    }
+}
+
+/// An `Iterator` struct for splitting a `string` every `n` occurrences of a `pattern`.
+#[allow(private_bounds)]
+pub struct SplitEvery<'a, T: Pattern<'a>> {
     inner: &'a str,
-    pat: Pattern<'a>,
+    pat: T,
+    pat_byte_len: Option<usize>,
     n: usize,
     index: usize,
 }
 
-impl<'a> Iterator for SplitEvery<'a> {
+impl<'a, T: Pattern<'a>> Iterator for SplitEvery<'a, T> {
     type Item = &'a str;
 
     fn next(&mut self) -> Option<Self::Item> {
         if self.index == self.inner.len() {
             return None;
         }
-        let haystack: &str = unsafe { self.inner.get_unchecked(self.index..) };
+        let iter_haystack: &str = unsafe { self.inner.get_unchecked(self.index..) };
         let mut len: usize = 0;
-        for ind in 0..self.n {
-            let haystack: &str = unsafe { haystack.get_unchecked(len..) };
-            if let Some(byte_ind) = match self.pat {
-                Pattern::Str(inner) => haystack.find(inner),
-                Pattern::Ch(inner) => haystack.find(inner),
-            } {
-                len = unsafe { len.unchecked_add(byte_ind).unchecked_add(self.pat.len()) };
-                continue;
+        if let Some(pat_byte_len) = self.pat_byte_len {
+            for ind in 0..self.n {
+                let haystack: &str = unsafe { iter_haystack.get_unchecked(len..) };
+                if let Some(byte_ind) = self.pat.find_in(haystack) {
+                    len = unsafe { len.unchecked_add(byte_ind).unchecked_add(pat_byte_len) };
+                    continue;
+                }
+                if ind == 0 {
+                    self.index = self.inner.len();
+                    return Some(haystack);
+                }
+                break;
             }
-            if ind == 0 {
-                self.index = self.inner.len();
-                return Some(haystack);
+            self.index = unsafe { self.index.unchecked_add(len) };
+            Some(unsafe { iter_haystack.get_unchecked(..len.unchecked_sub(pat_byte_len)) })
+        } else {
+            let mut last_pat_len: usize = 0;
+            for ind in 0..self.n {
+                let haystack: &str = unsafe { iter_haystack.get_unchecked(len..) };
+                if let Some(byte_ind) = self.pat.find_in(haystack) {
+                    last_pat_len = match unsafe { haystack.as_bytes().get_unchecked(byte_ind) } {
+                        0b0000_0000..=0b0111_1111 => 1,
+                        0b1000_0000..=0b1101_1111 => 2,
+                        0b1110_0000..=0b1110_1111 => 3,
+                        0b1111_0000..=0b1111_1111 => 4,
+                    };
+                    len = unsafe { len.unchecked_add(byte_ind).unchecked_add(last_pat_len) };
+                    continue;
+                }
+                if ind == 0 {
+                    self.index = self.inner.len();
+                    return Some(haystack);
+                }
+                break;
             }
-            break;
+            self.index = unsafe { self.index.unchecked_add(len) };
+            Some(unsafe { iter_haystack.get_unchecked(..len.unchecked_sub(last_pat_len)) })
         }
-        self.index = unsafe { self.index.unchecked_add(len) };
-        Some(unsafe { haystack.get_unchecked(..len.unchecked_sub(self.pat.len())) })
     }
 }
 
 #[test]
 fn test() {
-    let mut splitter: SplitEvery = "oh oh oh oh oh".split_every_n_of_str(" ", 2);
+    let mut splitter: SplitEvery<&str> = "oh oh oh oh oh".split_every_n_times(" ", 2);
     assert_eq!(splitter.next(), Some("oh oh"));
     assert_eq!(splitter.next(), Some("oh oh"));
     assert_eq!(splitter.next(), Some("oh"));
     assert_eq!(splitter.next(), None);
     assert_eq!(splitter.next(), None);
 
-    let mut splitter: SplitEvery = "oboooobobobobob".split_every_n_of_char('o', 3);
+    let mut splitter = "oh—oh—oh—oh—oh".split_every_n_times(|ch| ch == '—', 2);
+    assert_eq!(splitter.next(), Some("oh—oh"));
+    assert_eq!(splitter.next(), Some("oh—oh"));
+    assert_eq!(splitter.next(), Some("oh"));
+    assert_eq!(splitter.next(), None);
+    assert_eq!(splitter.next(), None);
+
+    let mut splitter: SplitEvery<char> = "oboooobobobobob".split_every_n_times('o', 3);
     assert_eq!(splitter.next(), Some("obo"));
     assert_eq!(splitter.next(), Some("oob"));
     assert_eq!(splitter.next(), Some("bobob"));
     assert_eq!(splitter.next(), Some("b"));
     assert_eq!(splitter.next(), None);
     assert_eq!(splitter.next(), None);
 
-    let mut splitter: SplitEvery = "hhhahahahaha".split_every_n_of_char('h', 1);
+    let mut splitter: SplitEvery<char> = "hhhahahahaha".split_every_n_times('h', 1);
     assert_eq!(splitter.next(), Some(""));
     assert_eq!(splitter.next(), Some(""));
     assert_eq!(splitter.next(), Some(""));
@@ -133,8 +197,8 @@ fn test() {
     assert_eq!(splitter.next(), None);
     assert_eq!(splitter.next(), None);
 
-    let mut splitter: SplitEvery =
-        "Oh hi there I don't really know what to say".split_every_n_of_str(" ", 3);
+    let mut splitter: SplitEvery<&str> =
+        "Oh hi there I don't really know what to say".split_every_n_times(" ", 3);
     assert_eq!(splitter.next().unwrap(), "Oh hi there");
     assert_eq!(splitter.next().unwrap(), "I don't really");
     assert_eq!(splitter.next().unwrap(), "know what to");