refactor: replace remaining boost::split with SplitString #25057

            std::vector<std::string> whitelist_split = SplitString(strWhitelist, ", ");

nit: for new code snake_case ?

nit: Maybe also fuzz this? Untested diff:

diff --git a/src/test/fuzz/string.cpp b/src/test/fuzz/string.cpp
index e6064d19b6..94399faf04 100644
--- a/src/test/fuzz/string.cpp
+++ b/src/test/fuzz/string.cpp
@@ -224,7 +224,12 @@ FUZZ_TARGET(string)
         int64_t amount_out;
         (void)ParseFixedPoint(random_string_1, fuzzed_data_provider.ConsumeIntegralInRange<int>(0, 1024), &amount_out);
     }
-    (void)SplitString(random_string_1, fuzzed_data_provider.ConsumeIntegral<char>());
+    {
+        const auto single_split{SplitString(random_string_1, fuzzed_data_provider.ConsumeIntegral<char>())};
+        assert(single_split.size() >= 1);
+        const auto any_split{SplitString(random_string_1, random_string_2)};
+        assert(any_split.size() >= 1);
+    }
     {
         (void)Untranslated(random_string_1);
         const bilingual_str bs1{random_string_1, random_string_2};

nit: Add include for string_view

I have no experience with fuzzing, would it make sense to add stronger asserts? E.g. check that the sum of all split string length plus number of splits minus 1 should give exactly the input string length:

const auto single_split{SplitString(random_string_1, fuzzed_data_provider.ConsumeIntegral<char>())};
size_t sum = 0;
for (auto const& split : single_split) {
    sum += split.size();
}
assert(sum + single_split.size() - 1 == random_string_1.size());

const auto any_split{SplitString(random_string_1, random_string_2)};
sum = 0;
for (auto const& split : any_split) {
    sum += split.size();
}
assert(sum + any_split.size() - 1 == random_string_1.size());

Sure, just like with other tests, there is no limit to how much can be tested

This is doing full scan of the iterators for each input character, thus the overall complexity is O(input_length * number_of_separators). It can be optimized to O(input_length + number_of_separators) if a map of the separators is built beforehand that would allow checking whether a given character is a separator in a constant time.

This is mostly theoretical because it would matter if lots of separators are used and currently we only use a few. Anyway, out of curiosity, I tried that and compared the performance - in the current variant it is 734 ns/op while with the map it is 130 ns/op for 10 separators.

<details> <summary>optimize Split()</summary>

 template <typename T = Span<const char>>
 std::vector<T> Split(const Span<const char>& sp, std::string_view separators)
 {
+    std::bitset<256> m;
+    for (const auto& sep : separators) {
+        m[static_cast<unsigned char>(sep)] = true;
+    }
     std::vector<T> ret;
     auto it = sp.begin();
     auto start = it;
     while (it != sp.end()) {
-        if (separators.find(*it) != std::string::npos) {
+        if (m[static_cast<unsigned char>(*it)]) {
             ret.emplace_back(start, it);
             start = it + 1;
         }
         ++it;
     }
     ret.emplace_back(start, it);

</details>

<details> <summary>benchmark</summary>

static void Split(benchmark::Bench& bench)
{
    bench.run([&] {
        (void)spanparsing::Split(
            "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
            "bcdefghijk"
        );
    });
}

BENCHMARK(Split);

</details>

Feel free to ignore.