compile_time_string.hpp

Go to the documentation of this file.

// Copyright (C) 2022-2023 by Camden Mannett.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE or copy at https://www.boost.org/LICENSE_1_0.txt)
 
#pragma once
 
#include "arg_router/config.hpp"
#include "arg_router/math.hpp"
 
#include <array>
 
#ifdef AR_ENABLE_CPP20_STRINGS
#    include <algorithm>
#    include <span>
#    include <string_view>
 
namespace arg_router
{
namespace utility
{
namespace detail
{
template <std::size_t N>
class compile_time_string_storage
{
public:
    constexpr compile_time_string_storage() = default;
 
    // We need all the constructors to support implicit conversion, because that's kind of the
    // point of this class...
    // NOLINTNEXTLINE(google-explicit-constructor,hicpp-explicit-conversions)
    constexpr compile_time_string_storage(std::array<char, N> str) : value(str) {}
 
    // NOLINTNEXTLINE(google-explicit-constructor,hicpp-explicit-conversions)
    constexpr compile_time_string_storage(std::span<const char, N> str)
    {
        std::copy(str.begin(), str.end(), value.begin());
    }
 
    // NOLINTNEXTLINE(google-explicit-constructor,hicpp-explicit-conversions,*-c-arrays)
    constexpr compile_time_string_storage(const char (&str)[N])
    {
        std::copy_n(&str[0], N, value.begin());
    }
 
    // NOLINTNEXTLINE(google-explicit-constructor,hicpp-explicit-conversions)
    constexpr compile_time_string_storage(char c) : value{c} {}
 
    std::array<char, N> value;
};
 
// This looks pointless - that's because it is!  It's a workaround for a MSVC bug:
// https://developercommunity.visualstudio.com/t/Uninitialized-read-of-symbol-in-std::arr/10404384
template <>
class compile_time_string_storage<0>
{
public:
    struct empty_t {
        constexpr std::size_t size() const { return 0; }
        constexpr const char* data() const { return nullptr; }
        constexpr char operator[](std::size_t) const { return '\n'; }
    };
 
    constexpr compile_time_string_storage() = default;
 
    // NOLINTNEXTLINE(google-explicit-constructor,hicpp-explicit-conversions)
    constexpr compile_time_string_storage(std::array<char, 0>) {}
 
    // NOLINTNEXTLINE(google-explicit-constructor,hicpp-explicit-conversions)
    constexpr compile_time_string_storage(std::span<const char, 0>) {}
 
    // NOLINTNEXTLINE(google-explicit-constructor,hicpp-explicit-conversions,*-c-arrays)
    constexpr compile_time_string_storage(const char (&)[0]) {}
 
    empty_t value;
};
 
compile_time_string_storage()->compile_time_string_storage<0>;
compile_time_string_storage(char)->compile_time_string_storage<1>;
}  // namespace detail
 
template <detail::compile_time_string_storage S = detail::compile_time_string_storage<0>{}>
class str
{
public:
    [[nodiscard]] constexpr static std::size_t size() noexcept { return size_; }
 
    [[nodiscard]] constexpr static bool empty() noexcept { return size() == 0; }
 
    [[nodiscard]] constexpr static std::string_view get() noexcept
    {
        return {S.value.data(), size()};
    }
 
    template <detail::compile_time_string_storage S2>
    [[nodiscard]] constexpr auto operator+([[maybe_unused]] const str<S2>& other) const noexcept
    {
        return []<std::size_t... LIs, std::size_t... RIs>(std::index_sequence<LIs...>,
                                                          std::index_sequence<RIs...>)
        {
            return str<std::array{S.value[LIs]..., S2.value[RIs]..., '\0'}>{};
        }
        (std::make_index_sequence<size()>{}, std::make_index_sequence<str<S2>::size()>{});
    }
 
    template <std::size_t Pos, std::size_t Count>
    [[nodiscard]] constexpr static auto substr() noexcept
    {
        static_assert((Pos + Count) < size_, "Pos+Count must be less than string size");
 
        return substr_impl<Pos>(std::make_index_sequence<Count>{});
    }
 
    template <typename T>
    struct append;
 
    template <detail::compile_time_string_storage S2>
    struct append<str<S2>> {
        using type = std::decay_t<decltype(str{} + str<S2>{})>;
    };
 
    template <typename T>
    using append_t = typename append<T>::type;
 
private:
    // This is a necessary evil, as we can't use std::char_traits<char>::length(..) in a
    // constant expression
    constexpr static std::size_t calculate_size() noexcept
    {
        auto count = std::size_t{0};
        for (; count < S.value.size(); ++count) {
            if (S.value[count] == '\0') {
                break;
            }
        }
        return count;
    }
 
    template <std::size_t Pos, std::size_t... Is>
    constexpr static auto substr_impl([[maybe_unused]] std::index_sequence<Is...> seq)
    {
        return str<std::array{S.value[Pos + Is]..., '\0'}>{};
    }
 
    constexpr static std::size_t size_ = calculate_size();
};
 
template <typename S1, typename S2>
using str_concat = typename S1::template append_t<S2>;
 
template <std::size_t N, char C>
class create_sequence_cts
{
    template <std::size_t>
    [[nodiscard]] constexpr static char get() noexcept
    {
        return C;
    }
 
    template <std::size_t... Is>
    [[nodiscard]] constexpr static std::array<char, N> builder(
        [[maybe_unused]] std::index_sequence<Is...> seq) noexcept
    {
        return {get<Is>()...};
    }
 
public:
    using type = str<builder(std::make_index_sequence<N>{})>;
};
 
template <std::size_t N, char C>
using create_sequence_cts_t = typename create_sequence_cts<N, C>::type;
 
template <auto Value>
struct convert_integral_to_cts {
private:
    static_assert(std::is_integral_v<decltype(Value)>, "Value must be an integral");
 
    template <typename Str, auto NewValue>
    [[nodiscard]] constexpr static auto build() noexcept
    {
        constexpr auto num_digits = math::num_digits(NewValue);
        constexpr auto power10 = math::pow<10>(num_digits - 1);
        constexpr auto digit = NewValue / power10;
 
        using digit_str = str<'0' + digit>;
 
        if constexpr (num_digits != 1) {
            constexpr auto next_value = NewValue % power10;
            return build<typename Str::template append_t<digit_str>, next_value>();
        } else {
            return typename Str::template append_t<digit_str>{};
        }
    }
 
    using digit_str = decltype(build<str<>, math::abs(Value)>());
 
public:
    using type = std::conditional_t<(Value < 0), str<'-'>::template append_t<digit_str>, digit_str>;
};
 
template <auto Value>
using convert_integral_to_cts_t = typename convert_integral_to_cts<Value>::type;
}  // namespace utility
 
template <utility::detail::compile_time_string_storage S>
using str = utility::str<S>;
 
namespace traits
{
template <typename T>
struct is_compile_time_string_like : std::false_type {
};
 
template <auto S>
struct is_compile_time_string_like<utility::str<S>> : std::true_type {
};
 
template <typename T>
constexpr bool is_compile_time_string_like_v = is_compile_time_string_like<T>::value;
}  // namespace traits
}  // namespace arg_router
 
// A function macro common between utility::str and S_, which allows us to use the same method to
// construct strings internally between versions.  NOT for user consumption!
#    define AR_STRING(tok) arg_router::utility::str<tok>
#    define AR_STRING_SV(tok) arg_router::utility::str<std::span<const char, tok.size()>{tok}>
 
#else
 
#    include "arg_router/traits.hpp"
 
#    include <boost/mp11/algorithm.hpp>
#    include <boost/preprocessor/repetition/enum.hpp>
 
namespace arg_router
{
namespace utility
{
template <char... Cs>
class compile_time_string;
 
template <char... Cs>
class compile_time_string
{
public:
    using array_type = std::tuple<traits::integral_constant<Cs>...>;
 
    [[nodiscard]] constexpr static std::size_t size() noexcept { return sizeof...(Cs); }
 
    [[nodiscard]] constexpr static bool empty() noexcept { return size() == 0; }
 
    [[nodiscard]] constexpr static std::string_view get() noexcept
    {
        return {sv_.data(), sv_.size()};
    }
 
    template <typename T>
    struct append;
 
    template <char... OtherCs>
    struct append<compile_time_string<OtherCs...>> {
        using type = compile_time_string<Cs..., OtherCs...>;
    };
 
    template <typename T>
    using append_t = typename append<T>::type;
 
    template <char... OtherCs>
    [[nodiscard]] constexpr auto operator+(
        [[maybe_unused]] const compile_time_string<OtherCs...>& other) const noexcept
    {
        return append_t<compile_time_string<OtherCs...>>{};
    }
 
private:
    constexpr static auto sv_ = std::array<char, sizeof...(Cs)>{Cs...};
};
 
template <std::size_t N, char C>
class create_sequence_cts
{
    using seq = boost::mp11::mp_repeat_c<std::tuple<traits::integral_constant<C>>, N>;
 
    template <typename T>
    struct converter {
    };
 
    template <typename... Cs>
    struct converter<std::tuple<Cs...>> {
        using type = compile_time_string<Cs::value...>;
    };
 
public:
    using type = typename converter<seq>::type;
};
 
template <std::size_t N, char C>
using create_sequence_cts_t = typename create_sequence_cts<N, C>::type;
 
template <typename T>
struct convert_to_cts;
 
template <template <typename...> typename Array, typename... Cs>
struct convert_to_cts<Array<Cs...>> {
    using type = utility::compile_time_string<Cs::value...>;
};
 
template <typename T>
using convert_to_cts_t = typename convert_to_cts<T>::type;
 
template <auto Value>
struct convert_integral_to_cts {
private:
    static_assert(std::is_integral_v<decltype(Value)>, "Value must be an integral");
 
    template <typename Str, auto NewValue>
    [[nodiscard]] constexpr static auto build() noexcept
    {
        constexpr auto num_digits = math::num_digits(NewValue);
        constexpr auto power10 = math::pow<10>(num_digits - 1);
        constexpr auto digit = NewValue / power10;
 
        using digit_str = typename Str::template append_t<compile_time_string<'0' + digit>>;
 
        if constexpr (num_digits != 1) {
            constexpr auto next_value = NewValue % power10;
            return build<digit_str, next_value>();
        } else {
            return digit_str{};
        }
    }
 
    using digit_str = decltype(build<compile_time_string<>, math::abs(Value)>());
 
public:
    using type = std::conditional_t<(Value < 0),
                                    compile_time_string<'-'>::template append_t<digit_str>,
                                    digit_str>;
};
 
template <auto Value>
using convert_integral_to_cts_t = typename convert_integral_to_cts<Value>::type;
 
namespace cts_detail
{
template <int N>
// NOLINTNEXTLINE(*-avoid-c-arrays)
[[nodiscard]] constexpr char get(const char (&str)[N], std::size_t i) noexcept
{
    return i < N ? str[i] : '\0';
}
 
[[nodiscard]] constexpr char get(std::string_view str, std::size_t i) noexcept
{
    return i < str.size() ? str[i] : '\0';
}
 
[[nodiscard]] constexpr char get(char c, std::size_t i) noexcept
{
    return i < 1 ? c : '\0';
}
 
// Required so that the extra nulls S_ adds can be removed before defining the compile_time_string.
// Otherwise any compiler warnings you hit are just walls of null template args...
template <char... Cs>
struct builder {
    struct is_null_char {
        template <typename T>
        using fn = std::is_same<std::integral_constant<char, '\0'>, T>;
    };
 
    using strip_null =
        boost::mp11::mp_remove_if_q<boost::mp11::mp_list_c<char, Cs...>, is_null_char>;
 
    static_assert(std::tuple_size_v<strip_null> < AR_MAX_CTS_SIZE,
                  "Compile-time string limit reached, consider increasing AR_MAX_CTS_SIZE");
 
    template <char... StrippedCs>
    [[nodiscard]] constexpr static auto list_to_string(
        [[maybe_unused]] boost::mp11::mp_list_c<char, StrippedCs...> chars) noexcept
    {
        return compile_time_string<StrippedCs...>{};
    }
 
    using type = decltype(list_to_string(strip_null{}));
};
 
template <char... Cs>
using builder_t = typename builder<Cs...>::type;
}  // namespace cts_detail
}  // namespace utility
 
namespace traits
{
template <typename T>
struct is_compile_time_string_like : std::false_type {
};
 
template <char... Cs>
struct is_compile_time_string_like<utility::compile_time_string<Cs...>> : std::true_type {
};
 
template <typename T>
constexpr bool is_compile_time_string_like_v = is_compile_time_string_like<T>::value;
}  // namespace traits
}  // namespace arg_router
 
#    define AR_STR_CHAR(z, n, tok) arg_router::utility::cts_detail::get(tok, n)
 
#    define AR_STR_N(n, tok) \
        arg_router::utility::cts_detail::builder_t<BOOST_PP_ENUM(n, AR_STR_CHAR, tok)>
 
#    define S_(tok) AR_STR_N(AR_MAX_CTS_SIZE, tok)
 
// A function macro common between utility::str and S_, which allows us to use the same method to
// construct strings internally between versions.  NOT for user consumption!
#    define AR_STRING(tok) S_(tok)
#    define AR_STRING_SV(tok) S_(tok)
#endif