cigar.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 <charconv>
#include <cstdint>
#include <stdexcept>
 
#include <bio/alphabet/cigar/cigar_op.hpp>
#include <bio/alphabet/composite/tuple_base.hpp>
#include <bio/alphabet/custom/uint.hpp>
#include <bio/meta/concept/core_language.hpp>
#include <bio/ranges/container/small_string.hpp>
 
namespace bio::alphabet
{
 
// ------------------------------------------------------------------
// cigar
// ------------------------------------------------------------------
 
class cigar : public base<cigar, (1ul << 28) * size<cigar_op>,
                          void> // no char type, because this is only semi_alphabet
{
private:
    using base_t = base<cigar, (1ul << 28) * size<cigar_op>, void>;
 
    static constexpr size_t wasted_rank = 16ull - size<cigar_op>;
 
    constexpr uint32_t to_num_rank() const noexcept { return rank >> 4; }
 
    constexpr uint8_t to_op_rank() const noexcept { return rank & 0b1111; }
 
    constexpr void assign_num_rank(uint32_t r) noexcept { rank = (rank & 0b1111) | (r << 4); }
 
    constexpr void assign_op_rank(uint8_t r) noexcept { rank = (rank & ~0b1111) | r; }
 
    template <typename alphabet_type>
    class component_proxy : public proxy_base<component_proxy<alphabet_type>, alphabet_type>
    {
    private:
        using base_t = proxy_base<component_proxy<alphabet_type>, alphabet_type>;
        friend base_t;
 
        cigar * parent;
 
    public:
        //Import from base type:
        using base_t::operator=;
 
        component_proxy()                                           = delete;
        constexpr component_proxy(component_proxy const &) noexcept = default; 
        constexpr component_proxy(component_proxy &&) noexcept      = default; 
        ~component_proxy() noexcept                                 = default; 
 
        constexpr component_proxy(cigar & p) : parent{&p} {}
 
        constexpr component_proxy & operator=(component_proxy const & rhs) // NOLINT(bugprone-unhandled-self-assignment)
        {
            return assign_rank(rhs.to_rank());
        }
 
        // NOLINTNEXTLINE(bugprone-unhandled-self-assignment)
        constexpr component_proxy const & operator=(component_proxy const & rhs) const
        {
            return assign_rank(rhs.to_rank());
        }
 
        constexpr alphabet::rank_t<alphabet_type> to_rank() const noexcept
        {
            if constexpr (BIOCPP_IS_SAME(alphabet_type, uint32_t))
                return parent->to_num_rank();
            else
                return parent->to_op_rank();
        }
 
        constexpr component_proxy & assign_rank(alphabet::rank_t<alphabet_type> const r) noexcept
        {
            if constexpr (BIOCPP_IS_SAME(alphabet_type, uint32_t))
                parent->assign_num_rank(r);
            else
                parent->assign_op_rank(r);
            return *this;
        }
 
        constexpr component_proxy const & assign_rank(alphabet::rank_t<alphabet_type> const r) const noexcept
        {
            if constexpr (BIOCPP_IS_SAME(alphabet_type, uint32_t))
                parent->assign_num_rank(r);
            else
                parent->assign_op_rank(r);
            return *this;
        }
 
        friend constexpr bool operator==(cigar const lhs, component_proxy const rhs) noexcept
        {
            return get<alphabet_type>(lhs) == static_cast<alphabet_type>(rhs);
        }
 
        friend constexpr auto operator<=>(cigar const lhs, component_proxy const rhs) noexcept
        {
            return get<alphabet_type>(lhs) <=> static_cast<alphabet_type>(rhs);
        }
    };
 
public:
    constexpr cigar() noexcept                          = default; 
    constexpr cigar(cigar const &) noexcept             = default; 
    constexpr cigar(cigar &&) noexcept                  = default; 
    constexpr cigar & operator=(cigar const &) noexcept = default; 
    constexpr cigar & operator=(cigar &&) noexcept      = default; 
    ~cigar() noexcept                                   = default; 
 
    constexpr cigar(uint32_t const count, cigar_op op) noexcept : base_t{(count << 4) | op.to_rank()} {}
 
    explicit constexpr cigar(uint32_t const count) noexcept : base_t{count << 4} {}
 
    explicit constexpr cigar(cigar_op const op) noexcept : base_t{op.to_rank()} {}
 
    constexpr cigar & operator=(uint32_t const count) noexcept
    {
        assign_num_rank(count);
        return *this;
    }
 
    constexpr cigar & operator=(cigar_op const op) noexcept
    {
        assign_op_rank(op.to_rank());
        return *this;
    }
 
    constexpr uint32_t to_rank() const noexcept { return rank < 16u ? rank : rank - wasted_rank; }
 
    explicit constexpr operator uint32_t() const { return to_num_rank(); }
 
    explicit constexpr operator cigar_op() const { return alphabet::assign_rank_to(to_op_rank(), cigar_op{}); }
 
    [[nodiscard("Always check the returned string_view for the size!")]] std::string_view to_string(
      std::span<char> buffer) const noexcept
    {
        auto [ptr, errc] = std::to_chars(buffer.data(), buffer.data() + 10, operator uint32_t());
 
        // I hope this is optimised down to a single table lookup
        *ptr = operator cigar_op().to_char();
        (void)errc;
 
        return std::string_view{buffer.data(), ptr + 1};
    }
 
    ranges::small_string<10> to_string() const noexcept
    {
        ranges::small_string<10> ret{}; // maximum number of digits for uint32_t + 1 char for the cigar_op
        ret.resize(10);
 
        std::string_view s = to_string(ret);
        ret.resize(s.size());
        return ret;
    }
 
    constexpr cigar & assign_rank(uint32_t const r) noexcept
    {
        assert(r < alphabet_size);
        rank = r < 16u ? r : r + wasted_rank;
        return *this;
    }
 
    cigar & assign_string(std::string_view const s)
    {
        int64_t num{};
        auto [ptr, errc] = std::from_chars(s.data(), s.data() + s.size(), num);
 
        if ((errc != std::errc{}) || (ptr != s.data() + s.size() - 1))
        {
            throw std::invalid_argument{std::string{"Illegal string assignment to CIGAR: "} +
                                        static_cast<std::string>(s)};
        }
        else if (num < 0 || num > (2u << 28))
        {
            throw std::invalid_argument{"Only numbers between 0 and 2^28 are valid in cigars."};
        }
        else
        {
            assign_num_rank(num);
            assign_op_rank(assign_char_strictly_to(*ptr, cigar_op{}).to_rank());
        }
 
        return *this;
    }
 
    template <meta::one_of<uint32_t, cigar_op> type>
    friend constexpr type get(cigar const & l) noexcept
    {
        return l.operator type();
    }
 
    template <meta::one_of<uint32_t, cigar_op> type>
    friend constexpr auto get(cigar & l) noexcept
    {
        return component_proxy<type>{l};
    }
 
    template <size_t index>
        requires(index == 0 || index == 1)
    friend constexpr auto get(cigar const & l) noexcept
    {
        if constexpr (index == 0)
            return get<uint32_t>(l);
        else if constexpr (index == 1)
            return get<cigar_op>(l);
    }
 
    template <size_t index>
        requires(index == 0 || index == 1)
    friend constexpr auto get(cigar & l) noexcept
    {
        if constexpr (index == 0)
            return get<uint32_t>(l);
        else if constexpr (index == 1)
            return get<cigar_op>(l);
    }
};
 
static_assert(sizeof(cigar) == 4, "Something wrong with binary layout of bio::alphabet::cigar. PLEASE REPORT BUG.");
 
} // namespace bio::alphabet
 
namespace std
{
 
template <std::size_t i>
struct tuple_element<i, bio::alphabet::cigar>
{
    using type = std::conditional_t<i == 0, uint32_t, bio::alphabet::cigar_op>;
};
 
template <>
struct tuple_size<bio::alphabet::cigar> : public std::integral_constant<size_t, 2>
{};
 
} // namespace std
 
#if __has_include(<fmt/format.h>)
 
#    include <fmt/format.h>
 
template <>
struct fmt::formatter<bio::alphabet::cigar> : fmt::formatter<std::string_view>
{
    constexpr auto format(bio::alphabet::cigar const a, auto & ctx) const
    {
        auto             tmp = a.to_string();
        std::string_view v{tmp.data(), tmp.size()};
        return fmt::formatter<std::string_view>::format(v, ctx);
    }
};
#endif