auxiliary.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 <concepts>
#include <sstream>
#include <type_traits>
#include <unordered_map>
#include <vector>
 
#include <seqan3/core/debug_stream/debug_stream_type.hpp>
#include <seqan3/core/detail/customisation_point.hpp>
#include <seqan3/io/stream/concept.hpp>
 
namespace seqan3::custom
{
 
template <typename t>
struct argument_parsing
{}; // forward
 
template <typename t>
struct argument_parsing<t const> : argument_parsing<t>
{};
 
template <typename t>
struct argument_parsing<t &> : argument_parsing<t>
{};
 
template <typename t>
struct argument_parsing<t const &> : argument_parsing<t>
{};
 
} // namespace seqan3::custom
 
namespace seqan3::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 : public detail::customisation_point_object<enumeration_names_cpo<option_t>, 1>
{
    using base_t = detail::customisation_point_object<enumeration_names_cpo<option_t>, 1>;
    using base_t::base_t;
 
    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 SEQAN3_CPO_OVERLOAD(priority_tag<1>)(
        /*return*/ seqan3::custom::argument_parsing<option_type>::enumeration_names /*;*/
    );
 
    template <typename option_type = option_t>
    static constexpr auto SEQAN3_CPO_OVERLOAD(priority_tag<0>)(
        /*return*/ enumeration_names(option_or_type_identity<option_type>{}) /*;*/
    );
};
 
} // namespace seqan3::detail::adl_only
 
namespace seqan3
{
 
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>{}();
 
template <typename option_type>
concept named_enumeration = requires {
                                {
                                    seqan3::enumeration_names<option_type>
                                };
                            };
 
template <typename option_type>
concept argument_parser_compatible_option =
    input_stream_over<std::istringstream, option_type> || named_enumeration<option_type>;
 
template <typename char_t, typename option_type>
    requires named_enumeration<std::remove_cvref_t<option_type>>
inline debug_stream_type<char_t> & operator<<(debug_stream_type<char_t> & s, option_type && op)
{
    for (auto & [key, value] : enumeration_names<option_type>)
    {
        if (op == value)
            return s << key;
    }
 
    return s << "<UNKNOWN_VALUE>";
}
 
enum option_spec
{
    standard = 0, 
    required = 1, 
    advanced = 2, 
    hidden = 4    
};
 
enum class update_notifications
{
    on, 
    off 
};
 
struct argument_parser_meta_data // holds all meta information
{
    std::string app_name;
    std::string version;
    std::string short_description;
    std::string author;
    std::string email;
    std::string date;
    std::string url;
    std::string short_copyright;
    std::string long_copyright;
    std::string citation;
    std::string man_page_title;
    unsigned man_page_section{1};
    std::vector<std::string> description;
    std::vector<std::string> synopsis;
    std::vector<std::string> examples;
};
 
} // namespace seqan3