StringReplacer.hh

Go to the documentation of this file.

#ifndef STRING_REPLACER_HH
#define STRING_REPLACER_HH
 
// First create a 'replacer' by passing a list of replacement-pairs
// (creation can fully be evaluated at-compile-time):
//     static constexpr auto replacer = StringReplacer::create(
//         "original", "replacement",
//         ...
//         "some string", "another string");
// Then use it to replace strings:
//     assert(replacer("original") == "replacement");    // enumerate strings are replaced
//     assert(replacer("not-in-list") == "not-in-list"); // not-enumerated strings are left unchanged
//
// So this is equivalent to
//     string_view input = ...
//     if      (input == "original"  ) input = "replacement";
//     ...
//     else if (input == "some string) input = "another string";
//     else // leave 'input' unchanged
// Though (for a long list of replacement-pairs) this utility may run faster
// than a manual chain of comparisons. This is because internally uses
// perfect-hashing to speed up the string comparisons.
//
// Note: the return type of StringReplacer::create() is intentionally
// unspecified (and it can indeed be different for different inputs).
 
#include "MinimalPerfectHash.hh"
 
#include "narrow.hh"
 
#include <array>
#include <cassert>
#include <string_view>
#include <tuple>
#include <utility>
 
namespace StringReplacer {
namespace detail {
 
[[nodiscard]] constexpr unsigned fnvHash(std::string_view s)
{
        constexpr unsigned PRIME = 0x811C9DC5;
        auto hash = narrow<unsigned>(s.size());
        for (char c : s) {
                hash *= PRIME;
                hash ^= c;
        }
        return hash;
}
 
 
[[nodiscard]] constexpr auto create_simple_replacer()
{
        return [](std::string_view s) { return s; };
}
 
[[nodiscard]] constexpr auto create_simple_replacer(
    std::string_view from1, std::string_view to1)
{
        return [=](std::string_view s) {
                if (s == from1) return to1;
                return s;
        };
}
 
[[nodiscard]] constexpr auto create_simple_replacer(
        std::string_view from1, std::string_view to1,
        std::string_view from2, std::string_view to2)
{
        return [=](std::string_view s) {
                if (s == from1) return to1;
                if (s == from2) return to2;
                return s;
        };
}
 
[[nodiscard]] constexpr auto create_simple_replacer(
        std::string_view from1, std::string_view to1,
        std::string_view from2, std::string_view to2,
        std::string_view from3, std::string_view to3)
{
        return [=](std::string_view s) {
                if (s == from1) return to1;
                if (s == from2) return to2;
                if (s == from3) return to3;
                return s;
        };
}
 
[[nodiscard]] constexpr auto create_simple_replacer(
        std::string_view from1, std::string_view to1,
        std::string_view from2, std::string_view to2,
        std::string_view from3, std::string_view to3,
        std::string_view from4, std::string_view to4)
{
        return [=](std::string_view s) {
                if (s == from1) return to1;
                if (s == from2) return to2;
                if (s == from3) return to3;
                if (s == from4) return to4;
                return s;
        };
}
 
struct FromTo {
        std::string_view from;
        std::string_view to;
};
 
template<size_t N, typename PMH>
struct PmhReplacer {
        std::array<FromTo, N> map;
        PMH pmh;
 
        [[nodiscard]] constexpr std::string_view operator()(std::string_view input) const
        {
                auto idx = pmh.lookupIndex(input);
                assert(idx < map.size());
 
                if (map[idx].from == input) {
                        return map[idx].to;
                }
                return input;
        }
};
 
template<typename Tuple, size_t... Is>
[[nodiscard]] constexpr auto create_pmh_replacer(const Tuple& tuple, std::index_sequence<Is...>)
{
        constexpr size_t N = sizeof...(Is);
        std::array<FromTo, N> arr{FromTo{std::get<2 * Is>(tuple), std::get<2 * Is + 1>(tuple)}...};
 
        auto hash = [](std::string_view s) { return fnvHash(s); };
        auto getKey = [&](size_t i) { return arr[i].from; };
        auto pmh = PerfectMinimalHash::create<N>(hash, getKey);
 
        return PmhReplacer<N, decltype(pmh)>{arr, pmh};
}
 
} // namespace detail
 
template<typename ...Args>
[[nodiscard]] constexpr auto create(Args ...args)
{
        constexpr size_t N2 = sizeof...(args);
        static_assert((N2 & 1) == 0, "Must pass an even number of strings");
        if constexpr (N2 <= 2 * 4) {
                return detail::create_simple_replacer(args...);
        } else {
                return detail::create_pmh_replacer(std::tuple(args...), std::make_index_sequence<N2 / 2>());
        }
}
 
} // namespace StringReplacer
 
#endif