alphabet_base.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>
#include <seqan3/core/detail/int_types.hpp>
#include <seqan3/std/concepts>
#include <seqan3/std/type_traits>
 
namespace seqan3
{
 
template <typename derived_type, size_t size, typename char_t = char>
class alphabet_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 = detail::min_viable_uint_t<size - 1>;
 
public:
    constexpr alphabet_base()                                   noexcept = default; 
    constexpr alphabet_base(alphabet_base const &)              noexcept = default; 
    constexpr alphabet_base(alphabet_base &&)                   noexcept = default; 
    constexpr alphabet_base & operator=(alphabet_base const &)  noexcept = default; 
    constexpr alphabet_base & operator=(alphabet_base &&)       noexcept = default; 
    ~alphabet_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 detail::min_viable_uint_t<size> constexpr alphabet_size = size;
 
 
    friend constexpr bool operator==(derived_type const lhs, derived_type const rhs) noexcept
    {
        return seqan3::to_rank(lhs) == seqan3::to_rank(rhs);
    }
 
    friend constexpr bool operator!=(derived_type const lhs, derived_type const rhs) noexcept
    {
        return seqan3::to_rank(lhs) != seqan3::to_rank(rhs);
    }
 
    friend constexpr bool operator<(derived_type const lhs, derived_type const rhs) noexcept
    {
        return seqan3::to_rank(lhs) < seqan3::to_rank(rhs);
    }
 
    friend constexpr bool operator>(derived_type const lhs, derived_type const rhs) noexcept
    {
        return seqan3::to_rank(lhs) > seqan3::to_rank(rhs);
    }
 
    friend constexpr bool operator<=(derived_type const lhs, derived_type const rhs) noexcept
    {
        return seqan3::to_rank(lhs) <= seqan3::to_rank(rhs);
    }
 
    friend constexpr bool operator>=(derived_type const lhs, derived_type const rhs) noexcept
    {
        return seqan3::to_rank(lhs) >= seqan3::to_rank(rhs);
    }
 
private:
    rank_type rank{};
};
 
template <typename derived_type, typename char_t>
class alphabet_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 = bool;
 
public:
    constexpr alphabet_base()                                   noexcept = default; 
    constexpr alphabet_base(alphabet_base const &)              noexcept = default; 
    constexpr alphabet_base(alphabet_base &&)                   noexcept = default; 
    constexpr alphabet_base & operator=(alphabet_base const &)  noexcept = default; 
    constexpr alphabet_base & operator=(alphabet_base &&)       noexcept = default; 
    ~alphabet_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 bool 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 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:
#if SEQAN3_WORKAROUND_GCC_87113
    bool _bug_workaround{};
#endif
};
 
} // namespace seqan3