bi_fm_index.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 <filesystem>
#include <ranges>
#include <utility>
 
#include <seqan3/core/range/type_traits.hpp>
#include <seqan3/search/fm_index/bi_fm_index_cursor.hpp>
#include <seqan3/search/fm_index/fm_index.hpp>
 
namespace seqan3
{
 
template <semialphabet alphabet_t,
          text_layout text_layout_mode_,
          detail::sdsl_index sdsl_index_type_ = default_sdsl_index_type>
class bi_fm_index
{
private:
    using sdsl_index_type = sdsl_index_type_;
 
    using rev_sdsl_index_type =
        seqan3::contrib::sdsl::csa_wt<sdsl_wt_index_type::wavelet_tree_type, // Wavelet tree type
                                      10'000'000,                            // Sampling rate of the suffix array
                                      10'000'000, // Sampling rate of the inverse suffix array
                                      seqan3::contrib::sdsl::sa_order_sa_sampling<>, // Text or SA based sampling for SA
                                      seqan3::contrib::sdsl::isa_sampling<>, // Text or ISA based sampling for ISA
                                      sdsl_wt_index_type::alphabet_type>;    // How to represent the alphabet
 
    using sdsl_char_type = typename sdsl_index_type::alphabet_type::char_type;
 
    using sdsl_sigma_type = typename sdsl_index_type::alphabet_type::sigma_type;
 
    using fm_index_type = fm_index<alphabet_t, text_layout_mode_, sdsl_index_type>;
 
    using rev_fm_index_type = detail::reverse_fm_index<alphabet_t, text_layout_mode_, rev_sdsl_index_type>;
 
    fm_index_type fwd_fm;
 
    rev_fm_index_type rev_fm;
 
    template <std::ranges::range text_t>
    void construct(text_t && text)
    {
        detail::fm_index_validator::validate<alphabet_t, text_layout_mode_>(text);
 
        fwd_fm = fm_index_type{text};
        rev_fm = rev_fm_index_type{text};
    }
 
public:
    static constexpr text_layout text_layout_mode = text_layout_mode_;
 
    using alphabet_type = typename fm_index_type::alphabet_type;
    using size_type = typename sdsl_index_type::size_type;
 
    using cursor_type = bi_fm_index_cursor<bi_fm_index>;
    using fwd_cursor_type = fm_index_cursor<fm_index_type>;
 
 
    template <typename bi_fm_index_t>
    friend class bi_fm_index_cursor;
 
    bi_fm_index() = default;                                
    bi_fm_index(bi_fm_index const &) = default;             
    bi_fm_index & operator=(bi_fm_index const &) = default; 
    bi_fm_index(bi_fm_index &&) = default;                  
    bi_fm_index & operator=(bi_fm_index &&) = default;      
    ~bi_fm_index() = default;                               
 
    template <std::ranges::range text_t>
    bi_fm_index(text_t && text)
    {
        construct(std::forward<text_t>(text));
    }
    bi_fm_index(text_t && text) {…}
 
    size_type size() const noexcept
    {
        return fwd_fm.size();
    }
    size_type size() const noexcept {…}
 
    bool empty() const noexcept
    {
        return size() == 0;
    }
    bool empty() const noexcept {…}
 
    bool operator==(bi_fm_index const & rhs) const noexcept
    {
        return std::tie(fwd_fm, rev_fm) == std::tie(rhs.fwd_fm, rhs.rev_fm);
    }
    bool operator==(bi_fm_index const & rhs) const noexcept {…}
 
    bool operator!=(bi_fm_index const & rhs) const noexcept
    {
        return !(*this == rhs);
    }
    bool operator!=(bi_fm_index const & rhs) const noexcept {…}
 
    cursor_type cursor() const noexcept
    {
        return {*this};
    }
    cursor_type cursor() const noexcept {…}
 
    fwd_cursor_type fwd_cursor() const noexcept
    {
        return {fwd_fm};
    }
    fwd_cursor_type fwd_cursor() const noexcept {…}
 
    template <cereal_archive archive_t>
    void CEREAL_SERIALIZE_FUNCTION_NAME(archive_t & archive)
    {
        archive(fwd_fm);
        archive(rev_fm);
    }
};
class bi_fm_index {…};
 
template <std::ranges::range text_t>
bi_fm_index(text_t &&) -> bi_fm_index<range_innermost_value_t<text_t>, text_layout{range_dimension_v<text_t> != 1}>;
 
} // namespace seqan3