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/alphabet/concept.hpp>
 
// ============================================================================
// to_phred()
// ============================================================================
 
namespace seqan3::detail::adl_only
{
 
template <typename ...args_t>
void to_phred(args_t ...) = delete;
 
struct to_phred_fn
{
public:
    SEQAN3_CPO_IMPL(2, seqan3::custom::alphabet<decltype(v)>::to_phred(v)) // explicit customisation
    SEQAN3_CPO_IMPL(1, to_phred(v)                                       ) // ADL
    SEQAN3_CPO_IMPL(0, v.to_phred()                                      ) // member
 
public:
    template <typename alph_t>
        requires requires (alph_t const chr) { { impl(priority_tag<2>{}, chr) }; }
    constexpr auto operator()(alph_t const chr) const noexcept
    {
        static_assert(noexcept(impl(priority_tag<2>{}, chr)),
            "Only overloads that are marked noexcept are picked up by seqan3::to_phred().");
        static_assert(std::constructible_from<size_t, decltype(impl(priority_tag<2>{}, chr))>,
            "The return type of your to_phred() implementation must be convertible to size_t.");
 
        return impl(priority_tag<2>{}, chr);
    }
};
 
} // namespace seqan3::detail::adl_only
 
namespace seqan3
{
 
inline constexpr auto to_phred = detail::adl_only::to_phred_fn{};
 
template <typename alphabet_type>
    requires requires { { seqan3::to_phred(std::declval<alphabet_type>()) }; }
using alphabet_phred_t = decltype(seqan3::to_phred(std::declval<alphabet_type>()));
 
} // namespace seqan3
 
// ============================================================================
// assign_phred_to()
// ============================================================================
 
namespace seqan3::detail::adl_only
{
 
template <typename ...args_t>
void assign_phred_to(args_t ...) = delete;
 
struct assign_phred_to_fn
{
public:
    SEQAN3_CPO_IMPL(2, (seqan3::custom::alphabet<decltype(v)>::assign_phred_to(args..., v))) // explicit customisation
    SEQAN3_CPO_IMPL(1, (assign_phred_to(args..., v)                                       )) // ADL
    SEQAN3_CPO_IMPL(0, (v.assign_phred(args...)                                           )) // member
 
public:
    template <typename alph_t>
        requires requires (seqan3::alphabet_phred_t<alph_t> const p, alph_t & a)
            { { impl(priority_tag<2>{}, a, p) }; }
    constexpr alph_t & operator()(seqan3::alphabet_phred_t<alph_t> const p, alph_t & a) const noexcept
    {
        static_assert(noexcept(impl(priority_tag<2>{}, a, p)),
            "Only overloads that are marked noexcept are picked up by seqan3::assign_phred_to().");
        static_assert(std::same_as<alph_t &, decltype(impl(priority_tag<2>{}, a, p))>,
            "The return type of your assign_phred_to() implementation must be 'alph_t &'.");
 
        return impl(priority_tag<2>{}, a, p);
    }
 
    template <typename alph_t>
        requires requires (seqan3::alphabet_phred_t<alph_t> const p, alph_t & a)
            { { impl(priority_tag<2>{}, a, p) }; } && (!std::is_lvalue_reference_v<alph_t>)
    constexpr alph_t operator()(seqan3::alphabet_phred_t<alph_t> const p, alph_t && a) const noexcept
    {
        return (*this)(p, a); // call above function but return by value
    }
};
 
} // namespace seqan3::detail::adl_only
 
namespace seqan3
{
 
inline constexpr auto assign_phred_to = detail::adl_only::assign_phred_to_fn{};
 
} // namespace seqan3
 
// ============================================================================
// seqan3::quality_alphabet
// ============================================================================
 
namespace seqan3
{
 
template <typename t>
SEQAN3_CONCEPT quality_alphabet = alphabet<t> && requires(t qual)
{
    { seqan3::to_phred(qual) };
};
 
// ============================================================================
// seqan3::writable_quality_alphabet
// ============================================================================
 
template <typename t>
SEQAN3_CONCEPT writable_quality_alphabet = writable_alphabet<t> &&
                                         quality_alphabet<t> &&
                                         requires(t v, alphabet_phred_t<t> c)
{
    { seqan3::assign_phred_to(c, v) };
};
 
} // namespace seqan3