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 <iostream>
#include <string>

#include <seqan3/alphabet/concept.hpp>

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

namespace seqan3::custom
{

void to_phred();
void assign_phred_to();

} // namespace seqan3::custom

// ============================================================================
// to_phred()
// ============================================================================

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

struct to_phred_fn
{
private:
    SEQAN3_CPO_IMPL(2, to_phred(v)                     ) // ADL
    SEQAN3_CPO_IMPL(1, seqan3::custom::to_phred(v)     ) // customisation namespace
    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<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
{

struct assign_phred_to_fn
{
private:
    SEQAN3_CPO_IMPL(2, (assign_phred_to(args..., v)                     )) // ADL
    SEQAN3_CPO_IMPL(1, (seqan3::custom::assign_phred_to(args..., v)     )) // customisation namespace
    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<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::QualityAlphabet
// ============================================================================

namespace seqan3
{

template <typename t>
SEQAN3_CONCEPT QualityAlphabet = Alphabet<t> && requires(t qual)
{
    { seqan3::to_phred(qual) };
};

// ============================================================================
// seqan3::WritableQualityAlphabet
// ============================================================================

template <typename t>
SEQAN3_CONCEPT WritableQualityAlphabet = WritableAlphabet<t> && QualityAlphabet<t> && requires(t qual)
{
    { seqan3::assign_phred_to(typename t::rank_type{}, qual) };
};

} // namespace seqan3