bitpacked_sequence.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2006-2025 Knut Reinert & Freie Universität Berlin
// SPDX-FileCopyrightText: 2016-2025 Knut Reinert & MPI für molekulare Genetik
// SPDX-License-Identifier: BSD-3-Clause
 
#pragma once
 
#include <concepts>
#include <iterator>
#include <ranges>
#include <type_traits>
 
#include <seqan3/alphabet/detail/alphabet_proxy.hpp>
#include <seqan3/alphabet/views/to_char.hpp>
#include <seqan3/alphabet/views/to_rank.hpp>
#include <seqan3/contrib/sdsl-lite.hpp>
#include <seqan3/core/concept/cereal.hpp>
#include <seqan3/core/range/detail/random_access_iterator.hpp>
#include <seqan3/utility/math.hpp>
#include <seqan3/utility/views/convert.hpp>
 
namespace seqan3
{
 
template <writable_semialphabet alphabet_type>
    requires std::regular<alphabet_type>
class bitpacked_sequence
{
private:
    static constexpr size_t bits_per_letter = detail::ceil_log2(alphabet_size<alphabet_type>);
 
    static_assert(bits_per_letter <= 64, "alphabet must be representable in at most 64bit.");
 
    using data_type = seqan3::contrib::sdsl::int_vector<bits_per_letter>;
 
    data_type data;
 
    class reference_proxy_type : public alphabet_proxy<reference_proxy_type, alphabet_type>
    {
    private:
        using base_t = alphabet_proxy<reference_proxy_type, alphabet_type>;
        friend base_t;
 
        std::ranges::range_reference_t<data_type> internal_proxy;
 
        constexpr void on_update() noexcept
        {
            internal_proxy = base_t::to_rank();
        }
 
    public:
        // Import from base:
        using base_t::operator=;
 
        reference_proxy_type() = delete;
        constexpr reference_proxy_type(reference_proxy_type const &) noexcept = default;             
        constexpr reference_proxy_type(reference_proxy_type &&) noexcept = default;                  
        constexpr reference_proxy_type & operator=(reference_proxy_type const &) noexcept = default; 
        constexpr reference_proxy_type & operator=(reference_proxy_type &&) noexcept = default;      
        ~reference_proxy_type() noexcept = default;                                                  
 
        reference_proxy_type(std::ranges::range_reference_t<data_type> const internal) noexcept :
            internal_proxy{internal}
        {
            // Call alphabet_base's assign_rank to prevent calling on_update() during construction
            // which is not necessary, because internal_proxy is already correctly initialised!
            base_t::base_t::assign_rank(static_cast<alphabet_rank_t<alphabet_type>>(internal));
        }
    };
 
    static_assert(writable_alphabet<reference_proxy_type>);
    //NOTE(h-2): it is entirely unclear to me why we need this
    template <typename t>
        requires std::is_same_v<std::ranges::range_value_t<std::remove_cvref_t<t>>, alphabet_type>
    static constexpr bool has_same_value_type_v = true;
 
public:
    using value_type = alphabet_type;
    using reference = reference_proxy_type;
    using const_reference = alphabet_type;
    using iterator = detail::random_access_iterator<bitpacked_sequence>;
    using const_iterator = detail::random_access_iterator<bitpacked_sequence const>;
    using difference_type = std::ranges::range_difference_t<data_type>;
    using size_type = std::ranges::range_size_t<data_type>;
 
    bitpacked_sequence() = default;                                                 
    constexpr bitpacked_sequence(bitpacked_sequence const &) = default;             
    constexpr bitpacked_sequence(bitpacked_sequence &&) = default;                  
    constexpr bitpacked_sequence & operator=(bitpacked_sequence const &) = default; 
    constexpr bitpacked_sequence & operator=(bitpacked_sequence &&) = default;      
    ~bitpacked_sequence() = default;                                                
 
    template <typename other_range_t>
        requires (!std::same_as<bitpacked_sequence, std::remove_cvref_t<other_range_t>>)
              && std::ranges::input_range<other_range_t> && has_same_value_type_v<other_range_t>
    explicit bitpacked_sequence(other_range_t && range) :
        bitpacked_sequence{std::ranges::begin(range), std::ranges::end(range)}
    {}
    explicit bitpacked_sequence(other_range_t && range) : {…}
 
    bitpacked_sequence(size_type const count, value_type const value) : data(count, to_rank(value))
    {}
    bitpacked_sequence(size_type const count, value_type const value) : data(count, to_rank(value)) {…}
 
    template <std::forward_iterator begin_iterator_type, typename end_iterator_type>
    bitpacked_sequence(begin_iterator_type begin_it, end_iterator_type end_it)
        requires std::sentinel_for<end_iterator_type, begin_iterator_type>
              && std::common_reference_with<std::iter_value_t<begin_iterator_type>, value_type>
    {
        insert(cend(), begin_it, end_it);
    }
    bitpacked_sequence(begin_iterator_type begin_it, end_iterator_type end_it) {…}
 
    bitpacked_sequence(std::initializer_list<value_type> ilist) : bitpacked_sequence(std::begin(ilist), std::end(ilist))
    {}
    bitpacked_sequence(std::initializer_list<value_type> ilist) : bitpacked_sequence(std::begin(ilist), std::end(ilist)) {…}
 
    bitpacked_sequence & operator=(std::initializer_list<value_type> ilist)
    {
        assign(std::begin(ilist), std::end(ilist));
        return *this;
    }
    bitpacked_sequence & operator=(std::initializer_list<value_type> ilist) {…}
 
    template <std::ranges::input_range other_range_t>
    void assign(other_range_t && range)
        requires std::common_reference_with<std::ranges::range_value_t<other_range_t>, value_type>
    {
        bitpacked_sequence rhs{std::forward<other_range_t>(range)};
        swap(rhs);
    }
    void assign(other_range_t && range) {…}
 
    void assign(size_type const count, value_type const value)
    {
        bitpacked_sequence rhs{count, value};
        swap(rhs);
    }
    void assign(size_type const count, value_type const value) {…}
 
    template <std::forward_iterator begin_iterator_type, typename end_iterator_type>
    void assign(begin_iterator_type begin_it, end_iterator_type end_it)
        requires std::sentinel_for<end_iterator_type, begin_iterator_type>
              && std::common_reference_with<std::iter_value_t<begin_iterator_type>, value_type>
    {
        bitpacked_sequence rhs{begin_it, end_it};
        swap(rhs);
    }
    void assign(begin_iterator_type begin_it, end_iterator_type end_it) {…}
 
    void assign(std::initializer_list<value_type> ilist)
    {
        assign(std::begin(ilist), std::end(ilist));
    }
    void assign(std::initializer_list<value_type> ilist) {…}
 
 
    iterator begin() noexcept
    {
        return iterator{*this};
    }
    iterator begin() noexcept {…}
 
    const_iterator begin() const noexcept
    {
        return const_iterator{*this};
    }
    const_iterator begin() const noexcept {…}
 
    const_iterator cbegin() const noexcept
    {
        return const_iterator{*this};
    }
    const_iterator cbegin() const noexcept {…}
 
    iterator end() noexcept
    {
        return iterator{*this, size()};
    }
    iterator end() noexcept {…}
 
    const_iterator end() const noexcept
    {
        return const_iterator{*this, size()};
    }
    const_iterator end() const noexcept {…}
 
    const_iterator cend() const noexcept
    {
        return const_iterator{*this, size()};
    }
    const_iterator cend() const noexcept {…}
 
    reference at(size_type const i)
    {
        if (i >= size()) // [[unlikely]]
        {
            throw std::out_of_range{"Trying to access element behind the last in bitpacked_sequence."};
        }
        return (*this)[i];
    }
    reference at(size_type const i) {…}
 
    const_reference at(size_type const i) const
    {
        if (i >= size()) // [[unlikely]]
        {
            throw std::out_of_range{"Trying to access element behind the last in bitpacked_sequence."};
        }
        return (*this)[i];
    }
    const_reference at(size_type const i) const {…}
 
    reference operator[](size_type const i) noexcept
    {
        assert(i < size());
        return data[i];
    }
    reference operator[](size_type const i) noexcept {…}
 
    const_reference operator[](size_type const i) const noexcept
    {
        assert(i < size());
        return assign_rank_to(data[i], const_reference{});
    }
    const_reference operator[](size_type const i) const noexcept {…}
 
    reference front() noexcept
    {
        assert(size() > 0);
        return (*this)[0];
    }
    reference front() noexcept {…}
 
    const_reference front() const noexcept
    {
        assert(size() > 0);
        return (*this)[0];
    }
    const_reference front() const noexcept {…}
 
    reference back() noexcept
    {
        assert(size() > 0);
        return (*this)[size() - 1];
    }
    reference back() noexcept {…}
 
    const_reference back() const noexcept
    {
        assert(size() > 0);
        return (*this)[size() - 1];
    }
    const_reference back() const noexcept {…}
 
    constexpr data_type & raw_data() noexcept
    {
        return data;
    }
    constexpr data_type & raw_data() noexcept {…}
 
    constexpr data_type const & raw_data() const noexcept
    {
        return data;
    }
    constexpr data_type const & raw_data() const noexcept {…}
 
    bool empty() const noexcept
    {
        return size() == 0;
    }
    bool empty() const noexcept {…}
 
    size_type size() const noexcept
    {
        return data.size();
    }
    size_type size() const noexcept {…}
 
    size_type max_size() const noexcept
    {
        return data.max_size();
    }
    size_type max_size() const noexcept {…}
 
    size_type capacity() const noexcept
    {
        return data.capacity();
    }
    size_type capacity() const noexcept {…}
 
    void reserve(size_type const new_cap)
    {
        data.reserve(new_cap);
    }
    void reserve(size_type const new_cap) {…}
 
    void shrink_to_fit()
    {
        data.shrink_to_fit();
    }
    void shrink_to_fit() {…}
 
    void clear() noexcept
    {
        data.clear();
    }
    void clear() noexcept {…}
 
    iterator insert(const_iterator pos, value_type const value)
    {
        return insert(pos, 1, value);
    }
    iterator insert(const_iterator pos, value_type const value) {…}
 
    iterator insert(const_iterator pos, size_type const count, value_type const value)
    {
        auto const pos_as_num = std::distance(cbegin(), pos); // we want to insert BEFORE this position
 
        data.insert(data.begin() + pos_as_num, count, to_rank(value));
 
        return begin() + pos_as_num;
    }
    iterator insert(const_iterator pos, size_type const count, value_type const value) {…}
 
    template <std::forward_iterator begin_iterator_type, typename end_iterator_type>
    iterator insert(const_iterator pos, begin_iterator_type begin_it, end_iterator_type end_it)
        requires std::sentinel_for<end_iterator_type, begin_iterator_type>
              && std::common_reference_with<std::iter_value_t<begin_iterator_type>, value_type>
    {
        auto const pos_as_num = std::distance(cbegin(), pos);
 
        auto v = std::ranges::subrange<begin_iterator_type, end_iterator_type>{begin_it, end_it}
               | views::convert<value_type> | views::to_rank;
        data.insert(data.begin() + pos_as_num, std::ranges::begin(v), std::ranges::end(v));
 
        return begin() + pos_as_num;
    }
    iterator insert(const_iterator pos, begin_iterator_type begin_it, end_iterator_type end_it) {…}
 
    iterator insert(const_iterator pos, std::initializer_list<value_type> const & ilist)
    {
        return insert(pos, ilist.begin(), ilist.end());
    }
    iterator insert(const_iterator pos, std::initializer_list<value_type> const & ilist) {…}
 
    iterator erase(const_iterator begin_it, const_iterator end_it)
    {
        if (begin_it >= end_it) // [[unlikely]]
            return begin() + std::distance(cbegin(), end_it);
 
        auto const begin_it_pos = std::distance(cbegin(), begin_it);
        auto const end_it_pos = std::distance(cbegin(), end_it);
 
        data.erase(data.cbegin() + begin_it_pos, data.cbegin() + end_it_pos);
 
        return begin() + begin_it_pos;
    }
    iterator erase(const_iterator begin_it, const_iterator end_it) {…}
 
    iterator erase(const_iterator pos)
    {
        return erase(pos, pos + 1);
    }
    iterator erase(const_iterator pos) {…}
 
    void push_back(value_type const value)
    {
        data.push_back(to_rank(value));
    }
    void push_back(value_type const value) {…}
 
    void pop_back()
    {
        assert(size() > 0);
        data.pop_back();
    }
    void pop_back() {…}
 
    void resize(size_type const count)
    {
        assert(count < max_size());
        data.resize(count);
    }
    void resize(size_type const count) {…}
 
    void resize(size_type const count, value_type const value)
    {
        assert(count < max_size());
        data.resize(count, to_rank(value));
    }
    void resize(size_type const count, value_type const value) {…}
 
    constexpr void swap(bitpacked_sequence & rhs) noexcept
    {
        std::swap(data, rhs.data);
    }
    constexpr void swap(bitpacked_sequence & rhs) noexcept {…}
 
    constexpr void swap(bitpacked_sequence && rhs) noexcept
    {
        std::swap(data, rhs.data);
    }
    constexpr void swap(bitpacked_sequence && rhs) noexcept {…}
 
    friend constexpr void swap(bitpacked_sequence & lhs, bitpacked_sequence & rhs) noexcept
    {
        std::swap(lhs, rhs);
    }
    friend constexpr void swap(bitpacked_sequence & lhs, bitpacked_sequence & rhs) noexcept {…};
 
    friend constexpr void swap(bitpacked_sequence && lhs, bitpacked_sequence && rhs) noexcept
    {
        std::swap(lhs, rhs);
    }
    friend constexpr void swap(bitpacked_sequence && lhs, bitpacked_sequence && rhs) noexcept {…};
 
    constexpr bool operator==(bitpacked_sequence const & rhs) const noexcept
    {
        return data == rhs.data;
    }
    constexpr bool operator==(bitpacked_sequence const & rhs) const noexcept {…}
 
    constexpr bool operator!=(bitpacked_sequence const & rhs) const noexcept
    {
        return data != rhs.data;
    }
    constexpr bool operator!=(bitpacked_sequence const & rhs) const noexcept {…}
 
    constexpr bool operator<(bitpacked_sequence const & rhs) const noexcept
    {
        return data < rhs.data;
    }
    constexpr bool operator<(bitpacked_sequence const & rhs) const noexcept {…}
 
    constexpr bool operator>(bitpacked_sequence const & rhs) const noexcept
    {
        return data > rhs.data;
    }
    constexpr bool operator>(bitpacked_sequence const & rhs) const noexcept {…}
 
    constexpr bool operator<=(bitpacked_sequence const & rhs) const noexcept
    {
        return data <= rhs.data;
    }
    constexpr bool operator<=(bitpacked_sequence const & rhs) const noexcept {…}
 
    constexpr bool operator>=(bitpacked_sequence const & rhs) const noexcept
    {
        return data >= rhs.data;
    }
    constexpr bool operator>=(bitpacked_sequence const & rhs) const noexcept {…}
 
    template <cereal_archive archive_t>
    void CEREAL_SERIALIZE_FUNCTION_NAME(archive_t & archive)
    {
        archive(data);
    }
};
class bitpacked_sequence {…};
 
} // namespace seqan3