concept.hpp

Go to the documentation of this file.

// -----------------------------------------------------------------------------------------------------
// Copyright (c) 2006-2019, Knut Reinert & Freie Universität Berlin
// Copyright (c) 2016-2019, 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>

// ============================================================================
// forwards
// ============================================================================

namespace seqan3::custom
{

void is_pair_open();
void is_pair_close();
void is_unpaired();
void max_pseudoknot_depth();
void pseudoknot_id();

} // namespace seqan3::custom

// ============================================================================
// is_pair_open()
// ============================================================================

namespace seqan3::detail::adl::only
{

struct is_pair_open_fn
{
private:
    SEQAN3_CPO_IMPL(2, is_pair_open(v)                     ) // ADL
    SEQAN3_CPO_IMPL(1, seqan3::custom::is_pair_open(v)     ) // customisation namespace
    SEQAN3_CPO_IMPL(0, v.is_pair_open()                    ) // member

public:
    template <typename rna_structure_t>
        requires requires (rna_structure_t const chr) { { impl(priority_tag<2>{}, chr) }; }
    constexpr auto operator()(rna_structure_t const chr) const noexcept
    {
        static_assert(noexcept(impl(priority_tag<2>{}, chr)),
            "Only overloads that are marked noexcept are picked up by seqan3::is_pair_open().");
        static_assert(std::Same<bool, decltype(impl(priority_tag<2>{}, chr))>,
            "The return type of your is_pair_open() implementation must be 'bool'.");

        return impl(priority_tag<2>{}, chr);
    }
};

} // namespace seqan3::detail::adl::only

namespace seqan3
{

inline constexpr auto is_pair_open = detail::adl::only::is_pair_open_fn{};

} // namespace seqan3

// ============================================================================
// is_pair_close()
// ============================================================================

namespace seqan3::detail::adl::only
{

struct is_pair_close_fn
{
private:
    SEQAN3_CPO_IMPL(2, is_pair_close(v)                     ) // ADL
    SEQAN3_CPO_IMPL(1, seqan3::custom::is_pair_close(v)     ) // customisation namespace
    SEQAN3_CPO_IMPL(0, v.is_pair_close()                    ) // member

public:
    template <typename rna_structure_t>
        requires requires (rna_structure_t const chr) { { impl(priority_tag<2>{}, chr) }; }
    constexpr auto operator()(rna_structure_t const chr) const noexcept
    {
        static_assert(noexcept(impl(priority_tag<2>{}, chr)),
            "Only overloads that are marked noexcept are picked up by seqan3::is_pair_close().");
        static_assert(std::Same<bool, decltype(impl(priority_tag<2>{}, chr))>,
            "The return type of your is_pair_close() implementation must be 'bool'.");

        return impl(priority_tag<2>{}, chr);
    }
};

} // namespace seqan3::detail::adl::only

namespace seqan3
{

inline constexpr auto is_pair_close = detail::adl::only::is_pair_close_fn{};

} // namespace seqan3

// ============================================================================
// is_unpaired()
// ============================================================================

namespace seqan3::detail::adl::only
{

struct is_unpaired_fn
{
private:
    SEQAN3_CPO_IMPL(2, is_unpaired(v)                     ) // ADL
    SEQAN3_CPO_IMPL(1, seqan3::custom::is_unpaired(v)     ) // customisation namespace
    SEQAN3_CPO_IMPL(0, v.is_unpaired()                    ) // member

public:
    template <typename rna_structure_t>
        requires requires (rna_structure_t const chr) { { impl(priority_tag<2>{}, chr) }; }
    constexpr auto operator()(rna_structure_t const chr) const noexcept
    {
        static_assert(noexcept(impl(priority_tag<2>{}, chr)),
            "Only overloads that are marked noexcept are picked up by seqan3::is_unpaired().");
        static_assert(std::Same<bool, decltype(impl(priority_tag<2>{}, chr))>,
            "The return type of your is_unpaired() implementation must be 'bool'.");

        return impl(priority_tag<2>{}, chr);
    }
};

} // namespace seqan3::detail::adl::only

namespace seqan3
{

inline constexpr auto is_unpaired = detail::adl::only::is_unpaired_fn{};

} // namespace seqan3

// ============================================================================
// max_pseudoknot_depth
// ============================================================================

namespace seqan3::detail::adl::only
{

template <typename alph_t,
          typename s_alph_t = std::conditional_t<std::is_nothrow_default_constructible_v<remove_cvref_t<alph_t>> &&
                                                 seqan3::is_constexpr_default_constructible_v<remove_cvref_t<alph_t>>,
                                                 remove_cvref_t<alph_t>,
                                                 std::type_identity<alph_t>>>
struct max_pseudoknot_depth_fn
{
private:
    SEQAN3_CPO_IMPL(2, (max_pseudoknot_depth(v)                                                    )) // ADL
    SEQAN3_CPO_IMPL(1, (seqan3::custom::max_pseudoknot_depth(v)                                    )) // custom nsp
    SEQAN3_CPO_IMPL(0, (deferred_type_t<remove_cvref_t<alph_t>, decltype(v)>::max_pseudoknot_depth )) // member

public:
    template <typename dummy = int>
        requires requires { { impl(priority_tag<2>{}, s_alph_t{}, dummy{}) }; }
    constexpr auto operator()() const noexcept
    {
        static_assert(noexcept(impl(priority_tag<2>{}, s_alph_t{})),
            "Only overloads that are marked noexcept are picked up by seqan3::max_pseudoknot_depth.");
        static_assert(std::Constructible<size_t, decltype(impl(priority_tag<2>{}, s_alph_t{}))>,
            "The return type of your max_pseudoknot_depth implementation must be convertible to size_t.");
        static_assert(SEQAN3_IS_CONSTEXPR(impl(priority_tag<2>{}, s_alph_t{})),
            "Only overloads that are marked constexpr are picked up by seqan3::max_pseudoknot_depth.");

        return impl(priority_tag<2>{}, s_alph_t{});
    }
};

// required to prevent https://gcc.gnu.org/bugzilla/show_bug.cgi?id=89953
template <typename alph_t>
    requires requires { { max_pseudoknot_depth_fn<alph_t>{} }; }
inline constexpr auto max_pseudoknot_depth_obj = max_pseudoknot_depth_fn<alph_t>{};

} // namespace seqan3::detail::adl::only

namespace seqan3
{

template <typename alph_t>
    requires requires { { detail::adl::only::max_pseudoknot_depth_fn<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>();

} // namespace seqan3

// ============================================================================
// pseudoknot_id()
// ============================================================================

namespace seqan3::detail::adl::only
{

struct pseudoknot_id_fn
{
private:
    SEQAN3_CPO_IMPL(2, pseudoknot_id(v)                     ) // ADL
    SEQAN3_CPO_IMPL(1, seqan3::custom::pseudoknot_id(v)     ) // customisation namespace
    SEQAN3_CPO_IMPL(0, v.pseudoknot_id()                    ) // member

public:
    template <typename rna_structure_t>
        requires requires (rna_structure_t const chr) { { impl(priority_tag<2>{}, chr) }; }
    constexpr auto operator()(rna_structure_t const chr) const noexcept
    {
        static_assert(noexcept(impl(priority_tag<2>{}, chr)),
            "Only overloads that are marked noexcept are picked up by seqan3::pseudoknot_id().");
        static_assert(std::Constructible<std::optional<size_t>, decltype(impl(priority_tag<2>{}, chr))>,
            "The return type of your pseudoknot_id() implementation must be convertible to std::optional<size_t>.");

        return impl(priority_tag<2>{}, chr);
    }
};

} // namespace seqan3::detail::adl::only

namespace seqan3
{

inline constexpr auto pseudoknot_id = detail::adl::only::pseudoknot_id_fn{};

} // namespace seqan3

// ============================================================================
// RnaStructureAlphabet concept
// ============================================================================

namespace seqan3
{
template <typename t>
SEQAN3_CONCEPT RnaStructureAlphabet = 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