search_result.hpp

Go to the documentation of this file.

// -----------------------------------------------------------------------------------------------------
// Copyright (c) 2006-2022, Knut Reinert & Freie Universität Berlin
// Copyright (c) 2016-2022, 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 <concepts>
#include <exception>
 
#include <seqan3/core/configuration/configuration.hpp>
#include <seqan3/core/debug_stream/debug_stream_type.hpp>
#include <seqan3/core/detail/empty_type.hpp>
#include <seqan3/core/detail/template_inspection.hpp>
#include <seqan3/search/fm_index/bi_fm_index_cursor.hpp>
#include <seqan3/search/fm_index/concept.hpp>
#include <seqan3/search/fm_index/fm_index_cursor.hpp>
 
namespace seqan3::detail
{
// forward declaration
template <typename search_configuration_t>
    requires is_type_specialisation_of_v<search_configuration_t, configuration>
struct policy_search_result_builder;
} // namespace seqan3::detail
 
namespace seqan3
{
 
template <typename query_id_type,
          typename cursor_type,
          typename reference_id_type,
          typename reference_begin_position_type>
    requires (std::integral<query_id_type> || std::same_as<query_id_type, detail::empty_type>)
          && (detail::template_specialisation_of<cursor_type, fm_index_cursor>
              || detail::template_specialisation_of<cursor_type, bi_fm_index_cursor>
              || std::same_as<cursor_type, detail::empty_type>)
          && (std::integral<reference_id_type> || std::same_as<reference_id_type, detail::empty_type>)
          && (std::integral<reference_begin_position_type>
              || std::same_as<reference_begin_position_type, detail::empty_type>)
class search_result
{
private:
    query_id_type query_id_{};
    cursor_type cursor_{};
    reference_id_type reference_id_{};
    reference_begin_position_type reference_begin_position_{};
 
    // Grant the policy access to private constructors.
    template <typename search_configuration_t>
        requires detail::is_type_specialisation_of_v<search_configuration_t, configuration>
    friend struct detail::policy_search_result_builder;
 
public:
    search_result() = default;                                  
    search_result(search_result const &) = default;             
    search_result(search_result &&) = default;                  
    search_result & operator=(search_result const &) = default; 
    search_result & operator=(search_result &&) = default;      
    ~search_result() = default;                                 
 
 
    constexpr auto query_id() const noexcept
    {
        static_assert(!std::same_as<query_id_type, detail::empty_type>,
                      "You tried to access the query_id but it was not selected in the output "
                      "configuration of the search.");
 
        return query_id_;
    }
 
    constexpr auto index_cursor() const noexcept(!(std::same_as<cursor_type, detail::empty_type>))
    {
        static_assert(!std::same_as<cursor_type, detail::empty_type>,
                      "You tried to access the index cursor but it was not selected in the output "
                      "configuration of the search.");
 
        return cursor_;
    }
 
    constexpr auto reference_id() const noexcept(!(std::same_as<reference_id_type, detail::empty_type>))
    {
        static_assert(!std::same_as<reference_id_type, detail::empty_type>,
                      "You tried to access the reference id but it was not selected in the output "
                      "configuration of the search.");
 
        return reference_id_;
    }
 
    constexpr auto reference_begin_position() const
        noexcept(!(std::same_as<reference_begin_position_type, detail::empty_type>))
    {
        static_assert(!std::same_as<reference_begin_position_type, detail::empty_type>,
                      "You tried to access the reference begin position but it was not selected in the "
                      "output configuration of the search.");
 
        return reference_begin_position_;
    }
 
    friend bool operator==(search_result const & lhs, search_result const & rhs) noexcept
    {
        bool equality = lhs.query_id_ == rhs.query_id_;
        if constexpr (!std::is_same_v<cursor_type, detail::empty_type>)
            equality &= lhs.cursor_ == rhs.cursor_;
        if constexpr (!std::is_same_v<reference_id_type, detail::empty_type>)
            equality &= lhs.reference_id_ == rhs.reference_id_;
        if constexpr (!std::is_same_v<reference_begin_position_type, detail::empty_type>)
            equality &= lhs.reference_begin_position_ == rhs.reference_begin_position_;
 
        return equality;
    }
 
    friend bool operator!=(search_result const & lhs, search_result const & rhs) noexcept
    {
        return !(lhs == rhs);
    }
};
 
template <typename char_t, typename search_result_t>
    requires detail::is_type_specialisation_of_v<std::remove_cvref_t<search_result_t>, search_result>
inline debug_stream_type<char_t> & operator<<(debug_stream_type<char_t> & stream, search_result_t && result)
{
    using result_type_list = detail::transfer_template_args_onto_t<std::remove_cvref_t<search_result_t>, type_list>;
 
    stream << "<";
    if constexpr (!std::same_as<list_traits::at<0, result_type_list>, detail::empty_type>)
        stream << "query_id:" << result.query_id();
    if constexpr (!std::same_as<list_traits::at<1, result_type_list>, detail::empty_type>)
        stream << ", index cursor is present";
    if constexpr (!std::same_as<list_traits::at<2, result_type_list>, detail::empty_type>)
        stream << ", reference_id:" << result.reference_id();
    if constexpr (!std::same_as<list_traits::at<3, result_type_list>, detail::empty_type>)
        stream << ", reference_pos:" << result.reference_begin_position();
    stream << ">";
 
    return stream;
}
 
} // namespace seqan3