root.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
 
#include "arg_router/multi_lang/translation.hpp"
#include "arg_router/parsing/token_type.hpp"
#include "arg_router/utility/tuple_iterator.hpp"
 
#include <variant>
 
namespace arg_router::multi_lang
{
template <typename RootFactory, typename DefaultLanguageID, typename... SupportedLanguageIDs>
class root_t
{
    using supported_language_ids = std::tuple<DefaultLanguageID, SupportedLanguageIDs...>;
    constexpr static auto num_supported_ids = std::tuple_size_v<supported_language_ids>;
 
    static_assert(num_supported_ids > 1, "Must be more than one language supported");
    static_assert(num_supported_ids ==
                      std::tuple_size_v<boost::mp11::mp_unique<supported_language_ids>>,
                  "Supported languages must be unique");
 
    using root_variant_t =
        std::variant<std::decay_t<decltype(std::declval<RootFactory>()(
                         std::declval<translation<DefaultLanguageID>>()))>,
                     std::decay_t<decltype(std::declval<RootFactory>()(
                         std::declval<translation<SupportedLanguageIDs>>()))>...>;
 
public:
    explicit root_t(std::string_view language_id, const RootFactory& f)
    {
        utility::tuple_type_iterator<supported_language_ids>([&](auto I) {
            using id = std::tuple_element_t<I, supported_language_ids>;
 
            if (root_ || (language_id != id::get())) {
                return;
            }
 
            root_.emplace(root_variant_t{f(translation<id>{})});
        });
 
        // No match, so fall back to the default (the first language)
        if (!root_) {
            root_.emplace(root_variant_t{f(translation<DefaultLanguageID>{})});
        }
    }
 
    void parse(vector<parsing::token_type> args) const
    {
        std::visit([&](const auto& root) { root.parse(std::move(args)); }, *root_);
    }
 
    template <typename Iter, typename = std::enable_if_t<!std::is_same_v<std::decay_t<Iter>, int>>>
    void parse(Iter begin, Iter end) const
    {
        std::visit([&](const auto& root) { root.parse(begin, end); }, *root_);
    }
 
    template <typename Container,
              typename = std::enable_if_t<
                  !std::is_same_v<std::decay_t<Container>, vector<parsing::token_type>>>>
    void parse(const Container& c) const
    {
        std::visit([&](const auto& root) { root.parse(c); }, *root_);
    }
 
    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 DefaultLanguageID, typename... SupportedLanguageIDs, typename RootFactory>
auto root(std::string_view language_id, const RootFactory& f)
{
    return root_t<RootFactory, DefaultLanguageID, SupportedLanguageIDs...>{language_id, f};
}
}  // namespace arg_router::multi_lang