search_result.hpp

Go to the documentation of this file.

// -----------------------------------------------------------------------------------------------------
// 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/seqan/seqan3/blob/master/LICENSE.md
// -----------------------------------------------------------------------------------------------------
 
#pragma once
 
#include <seqan3/std/concepts>
#include <exception>
 
#include <seqan3/core/detail/debug_stream_type.hpp>
#include <seqan3/core/detail/empty_type.hpp>
#include <seqan3/core/type_traits/template_inspection.hpp>
#include <seqan3/core/algorithm/configuration.hpp>
#include <seqan3/search/fm_index/concept.hpp>
 
namespace seqan3::detail
{
// forward declaration
template <typename search_configuration_t>
#if !SEQAN3_WORKAROUND_GCC_93467
    requires is_type_specialisation_of_v<search_configuration_t, configuration>
#endif // !SEQAN3_WORKAROUND_GCC_93467
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>) &&
             (fm_index_cursor_specialisation<cursor_type> || 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>
    #if !SEQAN3_WORKAROUND_GCC_93467
        requires detail::is_type_specialisation_of_v<search_configuration_t, configuration>
    #endif // !SEQAN3_WORKAROUND_GCC_93467
    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