bi_fm_index.hpp

Go to the documentation of this file.

// -----------------------------------------------------------------------------------------------------
// Copyright (c) 2006-2019, Knut Reinert & Freie Universität Berlin
// Copyright (c) 2016-2019, 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 <utility>

#include <seqan3/core/type_traits/range.hpp>
#include <seqan3/std/filesystem>
#include <seqan3/range/view/persist.hpp>
#include <seqan3/search/fm_index/fm_index.hpp>
#include <seqan3/search/fm_index/bi_fm_index_cursor.hpp>
#include <seqan3/std/ranges>

namespace seqan3
{

template <bool is_collection = false, detail::SdslIndex sdsl_index_type_ = default_sdsl_index_type>
class bi_fm_index
{
protected:
    size_t sigma{0};
    static constexpr bool is_collection_{is_collection};

    using sdsl_index_type = sdsl_index_type_;

    using rev_sdsl_index_type = sdsl_index_type_;

    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<is_collection_, sdsl_index_type>;

    using rev_fm_index_type = fm_index<is_collection_, sdsl_index_type>;

    fm_index_type fwd_fm;

    rev_fm_index_type rev_fm;

public:
    using size_type = typename sdsl_index_type::size_type;

    using cursor_type = bi_fm_index_cursor<bi_fm_index<is_collection_, sdsl_index_type>>;
    using fwd_cursor_type = fm_index_cursor<fm_index_type>;
    using rev_cursor_type = fm_index_cursor<rev_fm_index_type>;

    template <typename fm_index_t>
    friend class 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<decltype(text)>(text));
    }

    template <std::ranges::Range text_t>
        requires !is_collection_
    void construct(text_t && text)
    {
        static_assert(std::ranges::BidirectionalRange<text_t>, "The text must model BidirectionalRange.");
        static_assert(alphabet_size<innermost_value_type_t<text_t>> <= 256, "The alphabet is too big.");
        static_assert(dimension_v<text_t> == 1, "The input cannot be a text collection.");

        // text must not be empty
        if (std::ranges::begin(text) == std::ranges::end(text))
            throw std::invalid_argument("The text that is indexed cannot be empty.");

        auto rev_text = std::view::reverse(text);
        fwd_fm.construct(text);
        rev_fm.construct(rev_text);

        sigma = fwd_fm.sigma;
    }

    template <std::ranges::Range text_t>
        requires is_collection_
    void construct(text_t && text)
    {
        static_assert(std::ranges::BidirectionalRange<text_t>, "The text must model BidirectionalRange.");
        static_assert(std::ranges::BidirectionalRange<reference_t<text_t>>,
                      "The elements of the text collection must model BidirectionalRange.");
        static_assert(alphabet_size<innermost_value_type_t<text_t>> <= 256, "The alphabet is too big.");
        static_assert(dimension_v<text_t> == 2, "The input must be a text collection.");

        // text must not be empty
        if (std::ranges::begin(text) == std::ranges::end(text))
            throw std::invalid_argument("The text that is indexed cannot be empty.");

        auto rev_text = text | view::deep{std::view::reverse} | std::view::reverse;
        fwd_fm.construct(text);
        rev_fm.construct(rev_text);

        sigma = fwd_fm.sigma;
    }

    size_type size() const noexcept
    {
        return fwd_fm.size();
    }

    bool empty() const noexcept
    {
        return size() == 0;
    }

    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
    {
        return !(*this == rhs);
    }

    cursor_type begin() const noexcept
    {
        return {*this};
    }

    fwd_cursor_type fwd_begin() const noexcept
    {
       return {fwd_fm};
    }

    rev_cursor_type rev_begin() const noexcept
    {
       return {rev_fm};
    }

    template <CerealArchive archive_t>
    void CEREAL_SERIALIZE_FUNCTION_NAME(archive_t & archive)
    {
        archive(fwd_fm);
        archive(rev_fm);
    }
};

template <std::ranges::Range text_t>
bi_fm_index(text_t &&) -> bi_fm_index<dimension_v<text_t> != 1>;


} // namespace seqan3