string: add VarList

include/hyprutils/string/VarList.hpp

@@ -0,0 +1,67 @@
+#pragma once
+#include <functional>
+#include <vector>
+#include <string>
+
+namespace Hyprutils {
+    namespace String {
+        class CVarList {
+          public:
+            /** Split string into arg list
+                @param lastArgNo stop splitting after argv reaches maximum size, last arg will contain rest of unsplit args
+                @param delim if delimiter is 's', use std::isspace
+                @param removeEmpty remove empty args from argv
+            */
+            CVarList(const std::string& in, const size_t maxSize = 0, const char delim = ',', const bool removeEmpty = false);
+
+            ~CVarList() = default;
+
+            size_t size() const {
+                return m_vArgs.size();
+            }
+
+            std::string join(const std::string& joiner, size_t from = 0, size_t to = 0) const;
+
+            void        map(std::function<void(std::string&)> func) {
+                for (auto& s : m_vArgs)
+                    func(s);
+            }
+
+            void append(const std::string arg) {
+                m_vArgs.emplace_back(arg);
+            }
+
+            std::string operator[](const size_t& idx) const {
+                if (idx >= m_vArgs.size())
+                    return "";
+                return m_vArgs[idx];
+            }
+
+            // for range-based loops
+            std::vector<std::string>::iterator begin() {
+                return m_vArgs.begin();
+            }
+            std::vector<std::string>::const_iterator begin() const {
+                return m_vArgs.begin();
+            }
+            std::vector<std::string>::iterator end() {
+                return m_vArgs.end();
+            }
+            std::vector<std::string>::const_iterator end() const {
+                return m_vArgs.end();
+            }
+
+            bool contains(const std::string& el) {
+                for (auto& a : m_vArgs) {
+                    if (a == el)
+                        return true;
+                }
+
+                return false;
+            }
+
+          private:
+            std::vector<std::string> m_vArgs;
+        };
+    }
+}

src/string/VarList.cpp

@@ -0,0 +1,39 @@
+#include <ranges>
+#include <algorithm>
+#include <hyprutils/string/VarList.hpp>
+#include <hyprutils/string/String.hpp>
+
+using namespace Hyprutils::String;
+
+Hyprutils::String::CVarList::CVarList(const std::string& in, const size_t lastArgNo, const char delim, const bool removeEmpty) {
+    if (in.empty())
+        m_vArgs.emplace_back("");
+
+    std::string args{in};
+    size_t      idx = 0;
+    size_t      pos = 0;
+    std::ranges::replace_if(
+        args, [&](const char& c) { return delim == 's' ? std::isspace(c) : c == delim; }, 0);
+
+    for (const auto& s : args | std::views::split(0)) {
+        if (removeEmpty && s.empty())
+            continue;
+        if (++idx == lastArgNo) {
+            m_vArgs.emplace_back(trim(in.substr(pos)));
+            break;
+        }
+        pos += s.size() + 1;
+        m_vArgs.emplace_back(trim(std::string_view{s}.data()));
+    }
+}
+
+std::string Hyprutils::String::CVarList::join(const std::string& joiner, size_t from, size_t to) const {
+    size_t      last = to == 0 ? size() : to;
+
+    std::string rolling;
+    for (size_t i = from; i < last; ++i) {
+        rolling += m_vArgs[i] + (i + 1 < last ? joiner : "");
+    }
+
+    return rolling;
+}

tests/string.cpp

@@ -1,4 +1,5 @@
 #include <hyprutils/string/String.hpp>
+#include <hyprutils/string/VarList.hpp>
 #include "shared.hpp"
 
 using namespace Hyprutils::String;
@@ -29,5 +30,9 @@ int main(int argc, char** argv, char** envp) {
     EXPECT(isNumber("0.9999s", true), false);
     EXPECT(isNumber("s0.9999", true), false);
 
+    CVarList list("hello    world!", 0, 's', true);
+    EXPECT(list[0], "hello");
+    EXPECT(list[1], "world!");
+
     return ret;
 }