proxy_base.hpp

Go to the documentation of this file.

// -----------------------------------------------------------------------------------------------------
// Copyright (c) 2022 deCODE Genetics
// 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/biocpp/biocpp-core/blob/main/LICENSE.md
// -----------------------------------------------------------------------------------------------------
 
#pragma once
 
#include <concepts>
 
#include <bio/alphabet/base.hpp>
#include <bio/alphabet/nucleotide/concept.hpp>
#include <bio/alphabet/quality/concept.hpp>
#include <bio/meta/concept/core_language.hpp>
#include <bio/meta/type_traits/basic.hpp>
#include <bio/meta/type_traits/template_inspection.hpp>
 
namespace bio::alphabet
{
 
template <typename derived_type, writable_semialphabet alphabet_type>
    requires std::regular<alphabet_type>
class proxy_base
{
private:
    using char_type = meta::valid_template_spec_or_t<char, char_t, alphabet_type>;
 
    using phred_type = meta::valid_template_spec_or_t<int8_t, phred_t, alphabet_type>;
 
private:
    constexpr proxy_base() noexcept                          = default; 
    constexpr proxy_base(proxy_base const &)                 = default; 
    constexpr proxy_base(proxy_base &&) noexcept             = default; 
    constexpr proxy_base & operator=(proxy_base const &)     = delete;  
    constexpr proxy_base & operator=(proxy_base &&) noexcept = delete;  
    ~proxy_base()                                            = default; 
 
    constexpr derived_type & operator=(derived_type const & c) noexcept
    {
        static_cast<derived_type &>(*this).assign_rank(c.to_rank()); // <- this invokes the actual proxy
        return static_cast<derived_type &>(*this);
    }
 
    constexpr derived_type const & operator=(derived_type const & c) const noexcept
    {
        static_cast<derived_type const &>(*this).assign_rank(c.to_rank()); // <- this invokes the actual proxy
        return static_cast<derived_type const &>(*this);
    }
 
    constexpr derived_type & operator=(alphabet_type const & c) noexcept
    {
        static_cast<derived_type &>(*this).assign_rank(bio::alphabet::to_rank(c)); // <- this invokes the actual proxy
        return static_cast<derived_type &>(*this);
    }
 
    constexpr derived_type const & operator=(alphabet_type const & c) const noexcept
    {
        static_cast<derived_type const &>(*this).assign_rank(
          bio::alphabet::to_rank(c)); // <- this invokes the actual proxy
        return static_cast<derived_type const &>(*this);
    }
 
    template <typename indirect_assignable_type>
    constexpr derived_type & operator=(indirect_assignable_type const & c) const noexcept
        requires meta::weakly_assignable_from<alphabet_type, indirect_assignable_type>
    {
        alphabet_type a;
        a = c;
        return operator=(a);
    }
 
    friend derived_type;
 
public:
    static constexpr auto alphabet_size = bio::alphabet::size<alphabet_type>;
 
    constexpr derived_type & assign_char(char_type const c) noexcept
        requires writable_alphabet<alphabet_type>
    {
        alphabet_type tmp;
        assign_char_to(c, tmp);
        return operator=(tmp);
    }
 
    constexpr derived_type const & assign_char(char_type const c) const noexcept
        requires writable_alphabet<alphabet_type>
    {
        alphabet_type tmp;
        assign_char_to(c, tmp);
        return operator=(tmp);
    }
 
    constexpr derived_type & assign_phred(phred_type const c) noexcept
        requires writable_quality<alphabet_type>
    {
        alphabet_type tmp;
        assign_phred_to(c, tmp);
        return operator=(tmp);
    }
 
    constexpr derived_type const & assign_phred(phred_type const c) const noexcept
        requires writable_quality<alphabet_type>
    {
        alphabet_type tmp;
        assign_phred_to(c, tmp);
        return operator=(tmp);
    }
 
    constexpr operator alphabet_type() const noexcept
    {
        return alphabet::assign_rank_to(static_cast<derived_type const &>(*this).to_rank(), alphabet_type{});
 
        /* Instead of static_cast'ing to the alphabet_type which also considers the constructors of the alphabet_type,
         * we explicitly invoke this operator in various places.
         * This prevents errors associated with using alphabet_type's constructors.
         *
         * This is one of error cases:
         * The tuple composite bio::alphabet::qualified returns a component_proxy which inherits from proxy_base_base.
         * The qualified alphabet itself inherits from quality_base.
         * Now when accessing get<1>(seq_qual_alph) we want to call to_phred at some point because we want the quality,
         * therefore the to_phred function from proxy_base is called, but this function did a static_cast to the
         * derived type which is calling the constructor from quality_base. Unfortunately now, the generic quality_base
         * constructor uses `assign_phred_to(to_phred(other), static_cast<derived_type &>(*this))`; (here) which again
         * tries to call to_phred of the proxy_base => infinite loop :boom:
         */
    }
 
    template <typename other_t>
        requires(std::convertible_to<alphabet_type, other_t>)
    constexpr operator other_t() const noexcept
    {
        return operator alphabet_type();
    }
 
    constexpr auto to_char() const noexcept
        requires alphabet<alphabet_type>
    {
        return bio::alphabet::to_char(operator alphabet_type());
    }
 
    constexpr auto to_phred() const noexcept
        requires quality<alphabet_type>
    {
        return bio::alphabet::to_phred(operator alphabet_type());
    }
 
    constexpr alphabet_type complement() const noexcept
        requires nucleotide<alphabet_type>
    {
        return bio::alphabet::complement(operator alphabet_type());
    }
 
    static constexpr bool char_is_valid(char_type const c) noexcept
        requires writable_alphabet<alphabet_type>
    {
        return char_is_valid_for<alphabet_type>(c);
    }
 
    friend constexpr void swap(derived_type const & lhs, derived_type const & rhs)
    {
        alphabet_type lhs_value = lhs.operator alphabet_type();
        alphabet_type rhs_value = rhs.operator alphabet_type();
        lhs                     = rhs_value;
        rhs                     = lhs_value;
    }
 
    friend constexpr void swap(derived_type & lhs, derived_type & rhs)
    {
        alphabet_type lhs_value = lhs.operator alphabet_type();
        alphabet_type rhs_value = rhs.operator alphabet_type();
        lhs                     = rhs_value;
        rhs                     = lhs_value;
    }
 
    friend constexpr bool operator==(derived_type const lhs, derived_type const rhs)
    {
        return lhs.to_rank() == rhs.to_rank();
    }
 
    friend constexpr auto operator<=>(derived_type const lhs, derived_type const rhs)
    {
        return lhs.to_rank() <=> rhs.to_rank();
    }
 
    template <meta::different_from<derived_type> t>
        requires(meta::weakly_equality_comparable_with<alphabet_type, t>)
    friend constexpr bool operator==(derived_type const lhs, t const rhs) noexcept
    {
        return (lhs.operator alphabet_type() == rhs);
    }
 
    template <meta::different_from<derived_type> t>
        requires(meta::weakly_equality_comparable_with<alphabet_type, t>)
    friend constexpr bool operator==(t const lhs, derived_type const rhs) noexcept
    {
        return (rhs == lhs);
    }
 
private:
    friend constexpr auto tag_invoke(custom::to_rank, derived_type const a) noexcept { return a.to_rank(); }
 
    friend constexpr derived_type & tag_invoke(custom::assign_rank_to, auto const r, derived_type & a) noexcept
        requires(requires {
            {
                a.assign_rank(r)
            };
        })
    {
        return a.assign_rank(r);
    }
 
    friend constexpr derived_type const & tag_invoke(custom::assign_rank_to,
                                                     auto const           r,
                                                     derived_type const & a) noexcept
        requires(requires {
            {
                a.assign_rank(r)
            };
        })
    {
        return a.assign_rank(r);
    }
 
    friend constexpr auto tag_invoke(custom::to_char, derived_type const a) noexcept
        requires(requires {
            {
                a.to_char()
            };
        })
    {
        return a.to_char();
    }
 
    friend constexpr derived_type & tag_invoke(custom::assign_char_to, char_type const c, derived_type & a) noexcept
        requires(requires {
            {
                a.assign_char(c)
            };
        })
    {
        return a.assign_char(c);
    }
 
    friend constexpr derived_type const & tag_invoke(custom::assign_char_to,
                                                     char_type const      c,
                                                     derived_type const & a) noexcept
        requires(requires {
            {
                a.assign_char(c)
            };
        })
    {
        return a.assign_char(c);
    }
 
    friend constexpr bool tag_invoke(custom::char_is_valid_for, char_type const c, derived_type) noexcept
        requires(requires {
            {
                derived_type::char_is_valid(c)
            };
        })
    {
        return derived_type::char_is_valid(c);
    }
 
    friend constexpr bool tag_invoke(custom::char_is_valid_for,
                                     char_type const c,
                                     std::type_identity<derived_type>) noexcept
        requires(requires {
            {
                derived_type::char_is_valid(c)
            };
        } && !meta::constexpr_default_initializable<derived_type>)
    {
        return derived_type::char_is_valid(c);
    }
 
    friend consteval auto tag_invoke(custom::size, derived_type) noexcept
        requires meta::constexpr_default_initializable<derived_type>
    {
        return alphabet_size;
    }
 
    friend consteval auto tag_invoke(custom::size, std::type_identity<derived_type>) noexcept
        requires(!meta::constexpr_default_initializable<derived_type>)
    {
        return alphabet_size;
    }
 
    friend constexpr auto tag_invoke(custom::complement, derived_type const a) noexcept
        requires(requires {
            {
                a.complement()
            };
        })
    {
        return a.complement();
    }
 
    friend constexpr phred_type tag_invoke(custom::to_phred, derived_type const a) noexcept
        requires(requires {
            {
                a.to_phred()
            };
        })
    {
        return a.to_phred();
    }
 
    friend constexpr derived_type & tag_invoke(custom::assign_phred_to, phred_type const p, derived_type & a) noexcept
        requires(requires {
            {
                a.assign_phred(p)
            };
        })
    {
        return a.assign_phred(p);
    }
 
    friend constexpr derived_type const & tag_invoke(custom::assign_phred_to,
                                                     phred_type const     p,
                                                     derived_type const & a) noexcept
        requires(requires {
            {
                a.assign_phred(p)
            };
        })
    {
        return a.assign_phred(p);
    }
};
 
} // namespace bio::alphabet