auxiliary.hpp

Go to the documentation of this file.

// -----------------------------------------------------------------------------------------------------
// Copyright (c) 2006-2020, Knut Reinert & Freie Universität Berlin
// Copyright (c) 2016-2020, Knut Reinert & MPI für molekulare Genetik
// This file may be used, modified and/or redistributed under the terms of the 3-clause BSD-License
// shipped with this file and also available at: https://github.com/seqan/seqan3/blob/master/LICENSE.md
// -----------------------------------------------------------------------------------------------------
 
#pragma once
 
#include <sstream>
#include <vector>
 
#include <seqan3/core/detail/customisation_point.hpp>
#include <seqan3/core/detail/debug_stream_type.hpp>
#include <seqan3/core/type_traits/basic.hpp>
#include <seqan3/io/stream/concept.hpp>
#include <seqan3/std/concepts>
#include <seqan3/std/type_traits>
 
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>
{};
 
} // 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_fn
{
    using s_option_t = std::conditional_t<std::is_nothrow_default_constructible_v<remove_cvref_t<option_t>> &&
                                          seqan3::is_constexpr_default_constructible_v<remove_cvref_t<option_t>>,
                                          remove_cvref_t<option_t>,
                                          std::type_identity<option_t>>;
 
    SEQAN3_CPO_IMPL(1, (deferred_type_t<seqan3::custom::argument_parsing<option_t>, decltype(v)>::enumeration_names))
    SEQAN3_CPO_IMPL(0, (enumeration_names(v))) // ADL
 
    
    template <typename dummy = int> // need to make this a template to enforce deferred initialisation
        requires requires
        {
            { impl(priority_tag<1>{}, s_option_t{}, dummy{}) };
            std::same_as<decltype(impl(priority_tag<1>{}, s_option_t{}, dummy{})),
                         std::unordered_map<std::string_view, remove_cvref_t<option_t>>>;
        }
    auto operator()() const
    {
        return impl(priority_tag<1>{}, s_option_t{});
    }
};
 
} // namespace seqan3::detail::adl_only
 
namespace seqan3
{
 
template <typename option_type>
    requires requires { { detail::adl_only::enumeration_names_fn<option_type>{}() }; }
inline auto const enumeration_names = detail::adl_only::enumeration_names_fn<option_type>{}();
 
template <typename option_type>
SEQAN3_CONCEPT named_enumeration = requires
{
    { seqan3::enumeration_names<option_type> };
};
 
template <typename option_type>
SEQAN3_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<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
{
    DEFAULT  = 0, 
    REQUIRED = 1, 
    ADVANCED = 2, 
    HIDDEN   = 4, 
};
 
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