root_wrapper.hpp

// 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
 
#ifndef AR_ENABLE_CPP20_STRINGS
 
#    include "arg_router/basic_types.hpp"
#    include "arg_router/utility/tuple_iterator.hpp"
 
#    include <variant>
 
namespace arg_router::multi_lang
{
template <typename Fn, typename... SupportedISOLanguageCodes>
class root_wrapper_t
{
    constexpr static auto num_supported_codes = sizeof...(SupportedISOLanguageCodes);
    static_assert(num_supported_codes > 1, "Must be more than one language provided");
 
    using supported_codes = std::tuple<SupportedISOLanguageCodes...>;
    static_assert(num_supported_codes == std::tuple_size_v<boost::mp11::mp_unique<supported_codes>>,
                  "Supported ISO language codes must be unique");
 
    template <std::size_t... I>
    constexpr static auto indicies_to_variant(std::index_sequence<I...>) -> std::variant<
        std::decay_t<decltype(std::declval<Fn>()(traits::integral_constant<I>{}))>...>;
 
    using root_variant_t =
        decltype(indicies_to_variant(std::make_index_sequence<num_supported_codes>{}));
    using supported_iso_languages = std::tuple<SupportedISOLanguageCodes...>;
 
public:
    [[deprecated("Superceded by multi_lang::root_t, will be removed in v2")]]  //
    explicit root_wrapper_t(std::string_view iso_language, Fn&& f)
    {
        utility::tuple_type_iterator<boost::mp11::mp_iota_c<num_supported_codes>>([&](auto I) {
            if (root_ ||
                (iso_language != std::tuple_element_t<I, supported_iso_languages>::get())) {
                return;
            }
 
            root_.emplace(root_variant_t{f(I)});
        });
 
        // No match, so fall back to the default (the first language)
        if (!root_) {
            root_.emplace(root_variant_t{f(traits::integral_constant<std::size_t{0}>{})});
        }
    }
 
    void parse(int argc, char** argv) const
    {
        std::visit([&](const auto& root) { root.parse(argc, argv); }, *root_);
    }
 
    void help(std::ostream& stream) const
    {
        std::visit([&](const auto& root) { root.help(stream); }, *root_);
    }
 
    [[nodiscard]] string help() const
    {
        return std::visit([](const auto& root) { root.help(); }, *root_);
    }
 
private:
    // Only optional due to the delayed initialisation
    std::optional<root_variant_t> root_;
};
 
template <typename... SupportedISOLanguageCodes, typename Fn>
[[nodiscard, deprecated("Superceded by multi_lang::root, will be removed in v2")]] //
auto root_wrapper(std::string_view iso_language, Fn&& f)
{
    return root_wrapper_t<Fn, SupportedISOLanguageCodes...>{iso_language, std::forward<Fn>(f)};
}
}  // namespace arg_router::multi_lang
 
#endif