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 <cassert>
#include <concepts>
#include <type_traits>
 
#include <bio/alphabet/concept.hpp>
#include <bio/meta/detail/int_types.hpp>
 
namespace bio::alphabet
{
 
template <typename derived_type, size_t size, typename char_t = char>
class base
{
protected:
    static_assert(size != 0, "alphabet size must be >= 1"); // == 1 is handled below in separate specialisation
 
    using char_type = std::conditional_t<std::same_as<char_t, void>, char, char_t>;
    using rank_type = meta::detail::min_viable_uint_t<size - 1>;
 
    friend derived_type;
 
    explicit constexpr base(rank_type r) noexcept : rank{r} {}
 
public:
    constexpr base() noexcept                         = default; 
    constexpr base(base const &) noexcept             = default; 
    constexpr base(base &&) noexcept                  = default; 
    constexpr base & operator=(base const &) noexcept = default; 
    constexpr base & operator=(base &&) noexcept      = default; 
    ~base() noexcept                                  = default; 
 
    constexpr char_type to_char() const noexcept
        requires(!std::same_as<char_t, void>)
    {
        return derived_type::rank_to_char[rank];
    }
 
    constexpr rank_type to_rank() const noexcept { return rank; }
 
    constexpr derived_type & assign_char(char_type const c) noexcept
        requires(!std::same_as<char_t, void>)
    {
        using index_t = std::make_unsigned_t<char_type>;
        rank          = derived_type::char_to_rank[static_cast<index_t>(c)];
        return static_cast<derived_type &>(*this);
    }
 
    constexpr derived_type & assign_rank(rank_type const c) noexcept
    {
        assert(static_cast<size_t>(c) < static_cast<size_t>(alphabet_size));
        rank = c;
        return static_cast<derived_type &>(*this);
    }
 
    static constexpr size_t alphabet_size = size;
 
 
    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();
    }
 
private:
    rank_type rank;
 
    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, rank_type const r, derived_type & 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 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 size;
    }
 
    friend consteval auto tag_invoke(custom::size, std::type_identity<derived_type>) noexcept
        requires(!meta::constexpr_default_initializable<derived_type>)
    {
        return size;
    }
};
 
template <typename derived_type, typename char_t>
class base<derived_type, 1ul, char_t>
{
protected:
    using char_type = std::conditional_t<std::same_as<char_t, void>, char, char_t>;
    using rank_type = uint8_t;
 
public:
    constexpr base() noexcept                         = default; 
    constexpr base(base const &) noexcept             = default; 
    constexpr base(base &&) noexcept                  = default; 
    constexpr base & operator=(base const &) noexcept = default; 
    constexpr base & operator=(base &&) noexcept      = default; 
    ~base() noexcept                                  = default; 
 
    constexpr char_type to_char() const noexcept
        requires(!std::same_as<char_t, void>)
    {
        return derived_type::char_value;
    }
 
    constexpr rank_type to_rank() const noexcept { return 0; }
 
    constexpr derived_type & assign_char(char_type const) noexcept
        requires(!std::same_as<char_t, void>)
    {
        return static_cast<derived_type &>(*this);
    }
 
    constexpr derived_type & assign_rank(rank_type const) noexcept { return static_cast<derived_type &>(*this); }
 
    static constexpr size_t alphabet_size = 1;
 
 
    friend constexpr bool operator==(derived_type const, derived_type const) noexcept { return true; }
 
    friend constexpr bool operator<(derived_type const, derived_type const) noexcept { return false; }
 
    friend constexpr bool operator>(derived_type const, derived_type const) noexcept { return false; }
 
    friend constexpr bool operator<=(derived_type const, derived_type const) noexcept { return true; }
 
    friend constexpr bool operator>=(derived_type const, derived_type const) noexcept { return true; }
private:
    friend constexpr rank_type tag_invoke(custom::to_rank, derived_type) noexcept { return 0; }
 
    friend constexpr derived_type & tag_invoke(custom::assign_rank_to, rank_type const, derived_type & a) noexcept
    {
        return a;
    }
 
    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;
    }
 
    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)
            };
        } && std::is_nothrow_default_constructible_v<derived_type>)
    {
        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)
            };
        } && !std::is_nothrow_default_constructible_v<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;
    }
};
 
} // namespace bio::alphabet