enumeration_names.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2006-2024, Knut Reinert & Freie Universität Berlin
// SPDX-FileCopyrightText: 2016-2024, Knut Reinert & MPI für molekulare Genetik
// SPDX-License-Identifier: BSD-3-Clause
 
#pragma once
 
#include <iostream>
#include <string_view>
#include <unordered_map>
 
#include <sharg/platform.hpp>
 
namespace sharg::custom
{
 
template <typename t>
struct parsing
{}; // forward
 
template <typename t>
struct parsing<t const> : parsing<t>
{};
 
template <typename t>
struct parsing<t &> : parsing<t>
{};
 
template <typename t>
struct parsing<t const &> : parsing<t>
{};
 
} // namespace sharg::custom
 
namespace sharg::detail
{
template <size_t I>
struct priority_tag
    // Doxygen fail
    : priority_tag<I - 1>
{};
 
template <>
struct priority_tag<0>
{};
 
} // namespace sharg::detail
 
namespace sharg::detail::adl_only
{
 
template <typename t>
std::unordered_map<std::string_view, t> enumeration_names(t) = delete;
 
template <typename option_t>
struct enumeration_names_cpo
{
    constexpr enumeration_names_cpo() = default;                                          
    constexpr enumeration_names_cpo(enumeration_names_cpo &&) = default;                  
    constexpr enumeration_names_cpo(enumeration_names_cpo const &) = default;             
    constexpr enumeration_names_cpo & operator=(enumeration_names_cpo &&) = default;      
    constexpr enumeration_names_cpo & operator=(enumeration_names_cpo const &) = default; 
 
    template <typename option_type>
    using option_or_type_identity =
        std::conditional_t<std::is_nothrow_default_constructible_v<std::remove_cvref_t<option_type>>,
                           std::remove_cvref_t<option_type>,
                           std::type_identity<option_type>>;
 
    template <typename option_type = option_t>
    static constexpr auto cpo_overload(sharg::detail::priority_tag<1>) noexcept(
        noexcept(sharg::custom::parsing<option_type>::enumeration_names))
        -> decltype(sharg::custom::parsing<option_type>::enumeration_names)
    {
        return sharg::custom::parsing<option_type>::enumeration_names;
    }
 
    template <typename option_type = option_t>
    static constexpr auto cpo_overload(sharg::detail::priority_tag<0>) noexcept(
        noexcept(enumeration_names(option_or_type_identity<option_type>{})))
        -> decltype(enumeration_names(option_or_type_identity<option_type>{}))
    {
        return enumeration_names(option_or_type_identity<option_type>{});
    }
 
    template <typename... args_t, typename option_type = option_t /*circumvent incomplete types*/>
    constexpr auto operator()(args_t &&... args) const
        noexcept(noexcept(cpo_overload(sharg::detail::priority_tag<1>{}, std::forward<args_t>(args)...)))
            -> decltype(cpo_overload(sharg::detail::priority_tag<1>{}, std::forward<args_t>(args)...))
    {
        return cpo_overload(sharg::detail::priority_tag<1>{}, std::forward<args_t>(args)...);
    }
};
 
} // namespace sharg::detail::adl_only
 
namespace sharg
{
 
// clang-format off
template <typename option_type>
    requires requires { { detail::adl_only::enumeration_names_cpo<option_type>{}() }; }
inline auto const enumeration_names = detail::adl_only::enumeration_names_cpo<option_type>{}();
// clang-format on
 
// clang-format off
template <typename option_type>
concept named_enumeration = requires
{
    { sharg::enumeration_names<option_type> };
};
// clang-format on
} // namespace sharg
 
namespace std
{
 
template <typename option_type>
    requires sharg::named_enumeration<remove_cvref_t<option_type>>
inline ostream & operator<<(ostream & s, option_type && op)
{
    for (auto & [key, value] : sharg::enumeration_names<option_type>)
    {
        if (op == value)
            return s << key;
    }
 
    return s << "<UNKNOWN_VALUE>";
}
 
} // namespace std