concept.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 <seqan3/std/concepts>
#include <functional>
#include <type_traits>
 
#include <meta/meta.hpp>
 
#include <seqan3/core/detail/template_inspection.hpp>
 
namespace seqan3
{
// Forward declarations
template <typename derived_t, typename value_t = void>
struct pipeable_config_element;
}
 
namespace seqan3::detail
{
 
// ----------------------------------------------------------------------------
// compatibility_table
// ----------------------------------------------------------------------------
 
template <typename algorithm_id_type>
inline constexpr std::array<std::array<void *, 0>, 0> compatibility_table{};
 
// ----------------------------------------------------------------------------
// Concept config_element
// ----------------------------------------------------------------------------
 
#if SEQAN3_WORKAROUND_GCC_PIPEABLE_CONFIG_CONCEPT
struct config_id_accessor
{
private:
    template <typename config_t>
    static constexpr int32_t as_int = static_cast<int32_t>(std::remove_cvref_t<config_t>::id);
 
    template <typename config_t>
    static constexpr auto has_id_member(int) -> decltype((static_cast<void>(config_t::id), true))
    {
        return true;
    }
 
    template <typename config_t>
    static constexpr bool has_id_member(...)
    {
        return false;
    }
 
public:
    template <typename config_t>
    using id_type = std::remove_cvref_t<decltype(config_t::id)>;
 
    template <typename config1_t, typename config2_t>
    static constexpr auto is_compatible()
    {
        if constexpr (has_id_member<config1_t>(0) && has_id_member<config2_t>(0)) // needed for gcc <= 9
        {
            using config1_id_t = id_type<config1_t>;
            using config2_id_t = id_type<config2_t>;
 
            if constexpr (std::same_as<config1_id_t, config2_id_t>)
                return std::bool_constant<compatibility_table<config1_id_t>[as_int<config1_t>][as_int<config2_t>]>{};
            else
                return std::false_type{};
        }
        else
        {
            return std::false_type{};
        }
    }
 
    template <typename config_t>
    static constexpr bool has_id = has_id_member<config_t>(0);
};
#endif // SEQAN3_WORKAROUND_GCC_PIPEABLE_CONFIG_CONCEPT
 
template <typename config_t>
SEQAN3_CONCEPT config_element = requires
{
    requires std::is_base_of_v<seqan3::pipeable_config_element<config_t>, config_t>;
    requires std::semiregular<config_t>;
#if SEQAN3_WORKAROUND_GCC_PIPEABLE_CONFIG_CONCEPT
    requires config_id_accessor::has_id<config_t>;
#else // ^^^ workaround / no workaround vvv
    { config_t::id };
#endif // SEQAN3_WORKAROUND_GCC_PIPEABLE_CONFIG_CONCEPT
};
 
template <typename config1_t, typename config2_t>
SEQAN3_CONCEPT config_element_pipeable_with =
    config_element<config1_t> &&
    config_element<config2_t> &&
#if SEQAN3_WORKAROUND_GCC_PIPEABLE_CONFIG_CONCEPT
    std::same_as<config_id_accessor::id_type<config1_t>, config_id_accessor::id_type<config2_t>> &&
    decltype(config_id_accessor::is_compatible<config1_t, config2_t>())::value;
#else // ^^^ workaround / no workaround vvv
    std::same_as<std::remove_cvref_t<decltype(config1_t::id)>, std::remove_cvref_t<decltype(config2_t::id)>> &&
    compatibility_table<std::remove_cvref_t<decltype(config1_t::id)>>[static_cast<int32_t>(config1_t::id)]
                                                                     [static_cast<int32_t>(config2_t::id)];
#endif // SEQAN3_WORKAROUND_GCC_PIPEABLE_CONFIG_CONCEPT
 
} // namespace seqan3::detail
 
namespace seqan3
{
// Forward declaration.
template <detail::config_element ... configs_t>
class configuration;
 
template <typename config1_t, typename config2_t>
inline constexpr bool is_config_element_combineable_v = detail::config_element_pipeable_with<config1_t, config2_t>;
 
// Specialised for config2_t == seqan3::configuration
template <typename config1_t, typename ...configs2_t>
inline constexpr bool is_config_element_combineable_v<config1_t, configuration<configs2_t...>> =
    (detail::config_element_pipeable_with<config1_t, configs2_t> && ...);
 
// Specialised for config1_t == seqan3::configuration
template <typename ...configs1_t, typename config2_t>
inline constexpr bool is_config_element_combineable_v<configuration<configs1_t...>, config2_t> =
    (detail::config_element_pipeable_with<configs1_t, config2_t> && ...);
 
// Specialised for config1_t == seqan3::configuration && config2_t == seqan3::configuration
template <typename ...configs1_t, typename ...configs2_t>
inline constexpr bool is_config_element_combineable_v<configuration<configs1_t...>, configuration<configs2_t...>> =
    (is_config_element_combineable_v<configs1_t, configuration<configs2_t...>> && ...);
 
} // namespace seqan3