From 6dd2ad47922694d2ab84bad4dac9dd442c5df617 Mon Sep 17 00:00:00 2001
From: Ryan Ofsky <ryan@ofsky.org>
Date: Wed, 6 Dec 2023 15:37:49 -0500
Subject: [PATCH] util: move spanparsing.h Split functions to string.h

This will help move the miniscript / descriptor parsing functions out of the
util library in an upcoming commit, so they are not exposed to libbitcoinkernel
applications. Moving the Split functions should also make them more
discoverable since they now close to related functions like Join.

The functions are moved verbatim without any changes.
---
 src/test/descriptor_tests.cpp |  2 +-
 src/util/spanparsing.h        | 41 ++++-----------------------------
 src/util/string.h             | 43 ++++++++++++++++++++++++++++++++---
 3 files changed, 46 insertions(+), 40 deletions(-)

diff --git a/src/test/descriptor_tests.cpp b/src/test/descriptor_tests.cpp
index c779bf6f739..8556d4e2182 100644
--- a/src/test/descriptor_tests.cpp
+++ b/src/test/descriptor_tests.cpp
@@ -7,6 +7,7 @@
 #include <script/sign.h>
 #include <test/util/setup_common.h>
 #include <util/strencodings.h>
+#include <util/string.h>
 
 #include <boost/test/unit_test.hpp>
 
@@ -400,7 +401,6 @@ void CheckInferDescriptor(const std::string& script_hex, const std::string& expe
         provider.pubkeys.emplace(origin_pubkey.GetID(), origin_pubkey);
 
         if (!origin_str.empty()) {
-            using namespace spanparsing;
             KeyOriginInfo info;
             Span<const char> origin_sp{origin_str};
             std::vector<Span<const char>> origin_split = Split(origin_sp, "/");
diff --git a/src/util/spanparsing.h b/src/util/spanparsing.h
index 765fe13acaa..71006ae151b 100644
--- a/src/util/spanparsing.h
+++ b/src/util/spanparsing.h
@@ -6,10 +6,9 @@
 #define BITCOIN_UTIL_SPANPARSING_H
 
 #include <span.h>
+#include <util/string.h>
 
 #include <string>
-#include <string_view>
-#include <vector>
 
 namespace spanparsing {
 
@@ -37,41 +36,11 @@ bool Func(const std::string& str, Span<const char>& sp);
  */
 Span<const char> Expr(Span<const char>& sp);
 
-/** Split a string on any char found in separators, returning a vector.
- *
- * If sep does not occur in sp, a singleton with the entirety of sp is returned.
- *
- * Note that this function does not care about braces, so splitting
- * "foo(bar(1),2),3) on ',' will return {"foo(bar(1)", "2)", "3)"}.
- */
-template <typename T = Span<const char>>
-std::vector<T> Split(const Span<const char>& sp, std::string_view separators)
+/** Split alias for backwards compatibility */
+template <typename... Args>
+auto Split(Args&&... args)
 {
-    std::vector<T> ret;
-    auto it = sp.begin();
-    auto start = it;
-    while (it != sp.end()) {
-        if (separators.find(*it) != std::string::npos) {
-            ret.emplace_back(start, it);
-            start = it + 1;
-        }
-        ++it;
-    }
-    ret.emplace_back(start, it);
-    return ret;
-}
-
-/** Split a string on every instance of sep, returning a vector.
- *
- * If sep does not occur in sp, a singleton with the entirety of sp is returned.
- *
- * Note that this function does not care about braces, so splitting
- * "foo(bar(1),2),3) on ',' will return {"foo(bar(1)", "2)", "3)"}.
- */
-template <typename T = Span<const char>>
-std::vector<T> Split(const Span<const char>& sp, char sep)
-{
-    return Split<T>(sp, std::string_view{&sep, 1});
+    return ::Split(std::forward<Args>(args)...);
 }
 
 } // namespace spanparsing
diff --git a/src/util/string.h b/src/util/string.h
index dab92942fbc..7060a4822df 100644
--- a/src/util/string.h
+++ b/src/util/string.h
@@ -5,7 +5,7 @@
 #ifndef BITCOIN_UTIL_STRING_H
 #define BITCOIN_UTIL_STRING_H
 
-#include <util/spanparsing.h>
+#include <span.h>
 
 #include <array>
 #include <cstdint>
@@ -18,14 +18,51 @@
 
 void ReplaceAll(std::string& in_out, const std::string& search, const std::string& substitute);
 
+/** Split a string on any char found in separators, returning a vector.
+ *
+ * If sep does not occur in sp, a singleton with the entirety of sp is returned.
+ *
+ * Note that this function does not care about braces, so splitting
+ * "foo(bar(1),2),3) on ',' will return {"foo(bar(1)", "2)", "3)"}.
+ */
+template <typename T = Span<const char>>
+std::vector<T> Split(const Span<const char>& sp, std::string_view separators)
+{
+    std::vector<T> ret;
+    auto it = sp.begin();
+    auto start = it;
+    while (it != sp.end()) {
+        if (separators.find(*it) != std::string::npos) {
+            ret.emplace_back(start, it);
+            start = it + 1;
+        }
+        ++it;
+    }
+    ret.emplace_back(start, it);
+    return ret;
+}
+
+/** Split a string on every instance of sep, returning a vector.
+ *
+ * If sep does not occur in sp, a singleton with the entirety of sp is returned.
+ *
+ * Note that this function does not care about braces, so splitting
+ * "foo(bar(1),2),3) on ',' will return {"foo(bar(1)", "2)", "3)"}.
+ */
+template <typename T = Span<const char>>
+std::vector<T> Split(const Span<const char>& sp, char sep)
+{
+    return Split<T>(sp, std::string_view{&sep, 1});
+}
+
 [[nodiscard]] inline std::vector<std::string> SplitString(std::string_view str, char sep)
 {
-    return spanparsing::Split<std::string>(str, sep);
+    return Split<std::string>(str, sep);
 }
 
 [[nodiscard]] inline std::vector<std::string> SplitString(std::string_view str, std::string_view separators)
 {
-    return spanparsing::Split<std::string>(str, separators);
+    return Split<std::string>(str, separators);
 }
 
 [[nodiscard]] inline std::string_view TrimStringView(std::string_view str, std::string_view pattern = " \f\n\r\t\v")