concept.hpp

Go to the documentation of this file.

// -----------------------------------------------------------------------------------------------------
// Copyright (c) 2006-2021, Knut Reinert & Freie Universität Berlin
// Copyright (c) 2016-2021, 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 <optional>
 
#include <seqan3/alphabet/concept.hpp>
#include <seqan3/core/detail/customisation_point.hpp>
#include <seqan3/std/concepts>
#include <seqan3/std/type_traits>
 
// ============================================================================
// is_pair_open()
// ============================================================================
 
namespace seqan3::detail::adl_only
{
 
template <typename ...args_t>
void is_pair_open(args_t ...) = delete;
 
struct is_pair_open_cpo : public detail::customisation_point_object<is_pair_open_cpo, 2>
{
    using base_t = detail::customisation_point_object<is_pair_open_cpo, 2>;
    using base_t::base_t;
 
    template <typename alphabet_t>
    static constexpr auto SEQAN3_CPO_OVERLOAD(priority_tag<2>, alphabet_t && alphabet)
    (
        /*return*/ seqan3::custom::alphabet<alphabet_t>::is_pair_open(std::forward<alphabet_t>(alphabet)) == true /*;*/
    );
 
    template <typename alphabet_t>
    static constexpr auto SEQAN3_CPO_OVERLOAD(priority_tag<1>, alphabet_t && alphabet)
    (
        /*return*/ is_pair_open(std::forward<alphabet_t>(alphabet)) == true /*;*/
    );
 
    template <typename alphabet_t>
    static constexpr auto SEQAN3_CPO_OVERLOAD(priority_tag<0>, alphabet_t && alphabet)
    (
        /*return*/ std::forward<alphabet_t>(alphabet).is_pair_open() == true /*;*/
    );
};
 
} // namespace seqan3::detail::adl_only
 
namespace seqan3
{
 
inline constexpr auto is_pair_open = detail::adl_only::is_pair_open_cpo{};
 
} // namespace seqan3
 
// ============================================================================
// is_pair_close()
// ============================================================================
 
namespace seqan3::detail::adl_only
{
 
template <typename ...args_t>
void is_pair_close(args_t ...) = delete;
 
struct is_pair_close_cpo : public detail::customisation_point_object<is_pair_close_cpo, 2>
{
    using base_t = detail::customisation_point_object<is_pair_close_cpo, 2>;
    using base_t::base_t;
 
    template <typename alphabet_t>
    static constexpr auto SEQAN3_CPO_OVERLOAD(priority_tag<2>, alphabet_t && alphabet)
    (
        /*return*/ seqan3::custom::alphabet<alphabet_t>::is_pair_close(std::forward<alphabet_t>(alphabet)) == true /*;*/
    );
 
    template <typename alphabet_t>
    static constexpr auto SEQAN3_CPO_OVERLOAD(priority_tag<1>, alphabet_t && alphabet)
    (
        /*return*/ is_pair_close(std::forward<alphabet_t>(alphabet)) == true /*;*/
    );
 
    template <typename alphabet_t>
    static constexpr auto SEQAN3_CPO_OVERLOAD(priority_tag<0>, alphabet_t && alphabet)
    (
        /*return*/ std::forward<alphabet_t>(alphabet).is_pair_close() == true /*;*/
    );
};
 
} // namespace seqan3::detail::adl_only
 
namespace seqan3
{
 
inline constexpr auto is_pair_close = detail::adl_only::is_pair_close_cpo{};
 
} // namespace seqan3
 
// ============================================================================
// is_unpaired()
// ============================================================================
 
namespace seqan3::detail::adl_only
{
 
template <typename ...args_t>
void is_unpaired(args_t ...) = delete;
 
struct is_unpaired_cpo : public detail::customisation_point_object<is_unpaired_cpo, 2>
{
    using base_t = detail::customisation_point_object<is_unpaired_cpo, 2>;
    using base_t::base_t;
 
    template <typename alphabet_t>
    static constexpr auto SEQAN3_CPO_OVERLOAD(priority_tag<2>, alphabet_t && alphabet)
    (
        /*return*/ seqan3::custom::alphabet<alphabet_t>::is_unpaired(std::forward<alphabet_t>(alphabet)) == true /*;*/
    );
 
    template <typename alphabet_t>
    static constexpr auto SEQAN3_CPO_OVERLOAD(priority_tag<1>, alphabet_t && alphabet)
    (
        /*return*/ is_unpaired(std::forward<alphabet_t>(alphabet)) == true /*;*/
    );
 
    template <typename alphabet_t>
    static constexpr auto SEQAN3_CPO_OVERLOAD(priority_tag<0>, alphabet_t && alphabet)
    (
        /*return*/ std::forward<alphabet_t>(alphabet).is_unpaired() == true /*;*/
    );
};
 
} // namespace seqan3::detail::adl_only
 
namespace seqan3
{
 
inline constexpr auto is_unpaired = detail::adl_only::is_unpaired_cpo{};
 
} // namespace seqan3
 
// ============================================================================
// max_pseudoknot_depth
// ============================================================================
 
namespace seqan3::detail::adl_only
{
 
template <typename ...args_t>
void max_pseudoknot_depth(args_t ...) = delete;
 
template <typename alphabet_t>
struct max_pseudoknot_depth_cpo : public detail::customisation_point_object<max_pseudoknot_depth_cpo<alphabet_t>, 2>
{
    using base_t = detail::customisation_point_object<max_pseudoknot_depth_cpo<alphabet_t>, 2>;
    using base_t::base_t;
 
    template <typename alphabet_type>
    using alphabet_or_type_identity
        = std::conditional_t<std::is_nothrow_default_constructible_v<std::remove_cvref_t<alphabet_type>> &&
                             seqan3::is_constexpr_default_constructible_v<std::remove_cvref_t<alphabet_type>>,
                             std::remove_cvref_t<alphabet_type>,
                             std::type_identity<alphabet_type>>;
 
    template <typename alphabet_type = alphabet_t>
    static constexpr auto SEQAN3_CPO_OVERLOAD(priority_tag<2>)
    (
        /*return*/ seqan3::custom::alphabet<alphabet_type>::max_pseudoknot_depth /*;*/
    );
 
    template <typename alphabet_type = alphabet_t>
    static constexpr auto SEQAN3_CPO_OVERLOAD(priority_tag<1>)
    (
        /*return*/ max_pseudoknot_depth(alphabet_or_type_identity<alphabet_type>{}) /*;*/
    );
 
    template <typename alphabet_type = alphabet_t>
    static constexpr auto SEQAN3_CPO_OVERLOAD(priority_tag<0>)
    (
        /*return*/ std::remove_cvref_t<alphabet_type>::max_pseudoknot_depth /*;*/
    );
};
 
#if SEQAN3_WORKAROUND_GCC_89953
template <typename alph_t>
    requires requires { { max_pseudoknot_depth_cpo<alph_t>{} }; }
inline constexpr auto max_pseudoknot_depth_obj = max_pseudoknot_depth_cpo<alph_t>{};
#endif // SEQAN3_WORKAROUND_GCC_89953
 
} // namespace seqan3::detail::adl_only
 
namespace seqan3
{
 
#if SEQAN3_WORKAROUND_GCC_89953
template <typename alph_t>
    requires requires { { detail::adl_only::max_pseudoknot_depth_cpo<alph_t>{} }; } &&
             requires { { detail::adl_only::max_pseudoknot_depth_obj<alph_t>() }; }
inline constexpr auto max_pseudoknot_depth = detail::adl_only::max_pseudoknot_depth_obj<alph_t>();
#else // ^^^ workaround / no workaround vvv
template <typename alph_t>
    requires requires { { detail::adl_only::max_pseudoknot_depth_cpo<alph_t>{}() }; }
inline constexpr auto max_pseudoknot_depth = detail::adl_only::max_pseudoknot_depth_cpo<alph_t>{}();
#endif // SEQAN3_WORKAROUND_GCC_89953
 
} // namespace seqan3
 
// ============================================================================
// pseudoknot_id()
// ============================================================================
 
namespace seqan3::detail::adl_only
{
 
template <typename ...args_t>
void pseudoknot_id(args_t ...) = delete;
 
struct pseudoknot_id_cpo : public detail::customisation_point_object<pseudoknot_id_cpo, 2>
{
    using base_t = detail::customisation_point_object<pseudoknot_id_cpo, 2>;
    using base_t::base_t;
 
    template <typename alphabet_t>
    static constexpr auto SEQAN3_CPO_OVERLOAD(priority_tag<2>, alphabet_t && alphabet)
    (
        /*return*/ seqan3::custom::alphabet<alphabet_t>::pseudoknot_id(std::forward<alphabet_t>(alphabet)) /*;*/
    );
 
    template <typename alphabet_t>
    static constexpr auto SEQAN3_CPO_OVERLOAD(priority_tag<1>, alphabet_t && alphabet)
    (
        /*return*/ pseudoknot_id(std::forward<alphabet_t>(alphabet)) /*;*/
    );
 
    template <typename alphabet_t>
    static constexpr auto SEQAN3_CPO_OVERLOAD(priority_tag<0>, alphabet_t && alphabet)
    (
        /*return*/ std::forward<alphabet_t>(alphabet).pseudoknot_id() /*;*/
    );
};
 
} // namespace seqan3::detail::adl_only
 
namespace seqan3
{
 
inline constexpr auto pseudoknot_id = detail::adl_only::pseudoknot_id_cpo{};
 
} // namespace seqan3
 
// ============================================================================
// rna_structure_alphabet concept
// ============================================================================
 
namespace seqan3
{
template <typename t>
SEQAN3_CONCEPT rna_structure_alphabet = seqan3::alphabet<t> && requires(t val)
{
    { seqan3::is_pair_open(val) };
    { seqan3::is_pair_close(val) };
    { seqan3::is_unpaired(val) };
    { seqan3::pseudoknot_id(val) };
 
    // this is delegated to a static class variable, which must not be 0
    requires seqan3::max_pseudoknot_depth<t> > 0;
};
 
} // namespace seqan3