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 <named_enumeration enum_t>
struct enumeration_printer<enum_t>
{
    template <typename stream_t>
    constexpr void operator()(stream_t & stream, enum_t const arg) const
    {
        for (auto & [label, enumerator] : enumeration_names<enum_t>)
        {
            if (arg == enumerator)
            {
                stream << label;
                return;
            }
        }
 
        stream << "<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