From d12728ddb55e50c6760010e6b75ac77988d63d7c Mon Sep 17 00:00:00 2001
From: JIe <depressedjie@outlook.com>
Date: Mon, 6 Jan 2025 17:44:00 +0800
Subject: [PATCH] add split function

---
 include/toolkit.h | 77 +++++++++++++++++++++++++++++++++--------------
 1 file changed, 54 insertions(+), 23 deletions(-)

diff --git a/include/toolkit.h b/include/toolkit.h
index e80a156..8cb8c1f 100644
--- a/include/toolkit.h
+++ b/include/toolkit.h
@@ -8,65 +8,96 @@
 #include <string>
 #include <cstdlib>
 #include <ios>
+#include <vector>
+#include <ranges>
 
-//use for to_chars
+namespace ranges = std::ranges;
+namespace views = std::ranges::views;
+
+// use for to_chars
 constexpr size_t buffer_size = 32;
 
 template <typename T>
 concept _num_type = requires {
     std::is_same_v<T, int> ||
-    std::is_same_v<T, float> ||
-    std::is_same_v<T, long> ||
-    std::is_same_v<T, double>;
+        std::is_same_v<T, float> ||
+        std::is_same_v<T, long> ||
+        std::is_same_v<T, double>;
 };
 
-namespace toolkit{
-    template<typename T>
-    std::expected<std::string, std::string> to_string(T value){
-        if constexpr (std::is_same_v<T, int> || std::is_same_v<T, float> || std::is_same_v<T, double>){
+namespace toolkit
+{
+    template <typename T>
+    std::expected<std::string, std::string> to_string(T value)
+    {
+        if constexpr (std::is_same_v<T, int> || std::is_same_v<T, float> || std::is_same_v<T, double>)
+        {
             char buffer[buffer_size];
             auto res = std::to_chars(buffer, buffer + buffer_size, value);
-            if (res.ec != std::errc()) {
+            if (res.ec != std::errc())
+            {
                 return std::unexpected(std::make_error_code(res.ec).message());
             }
             return std::string(buffer, res.ptr - buffer);
-        } else if constexpr (std::is_same_v<typename std::remove_const<T>::type,
-                                            char *>) {
-          return std::to_string(value);
+        }
+        else if constexpr (std::is_same_v<typename std::remove_const<T>::type,
+                                          char *>)
+        {
+            return std::to_string(value);
         }
     }
 
-    template<typename T = double>// requires std::is_same_v<T, std::string>
-    std::expected<T, std::string> stoi(const std::string& str){
+    template <typename T = double> // requires std::is_same_v<T, std::string>
+    std::expected<T, std::string> stoi(const std::string &str)
+    {
         T value;
         auto res = std::from_chars(str.c_str(), str.c_str() + str.size(), value);
-        if(res.ec != std::errc()){
+        if (res.ec != std::errc())
+        {
             return std::unexpected(std::make_error_code(res.ec).message());
         }
         return value;
     }
 
     template <typename T>
-    requires std::is_same_v<std::string, T> || std::is_same_v<const char*, T>
-    std::string replace_string(const std::string& str, T d, T e){
+        requires std::is_same_v<std::string, T> || std::is_same_v<const char *, T>
+    std::string replace_string(const std::string &str, T d, T e)
+    {
         std::string result = str;
-        if(d == e){
+        if (d == e)
+        {
             return result;
         }
         size_t len = 0;
-        while(true){
+        while (true)
+        {
             auto pos = result.find(d);
-            if(pos == std::string::npos){
+            if (pos == std::string::npos)
+            {
                 return result;
             }
-            if constexpr(std::is_same_v<T, const char*>){
+            if constexpr (std::is_same_v<T, const char *>)
+            {
                 len = std::strlen(d);
-            }else{
+            }
+            else
+            {
                 len = d.length();
             }
-            result = result.replace(pos, len ,e);
+            result = result.replace(pos, len, e);
         }
     }
+
+    template <typename T = std::string>
+        requires std::is_same_v<T, std::string> ||
+                 std::is_same_v<T, std::string_view>
+    std::vector<T> split(T str, T d)
+    {
+        auto v = views::split(str, d) | views::transform([](auto word)
+                                                         { return T(word.begin(), word.end()); });
+        return std::vector<T>(v.begin(), v.end());
+    }
+
 }
 
 #endif