SeqAn3  3.2.0-rc.1
The Modern C++ library for sequence analysis.
alignment_result.hpp
Go to the documentation of this file.
1 // -----------------------------------------------------------------------------------------------------
2 // Copyright (c) 2006-2022, Knut Reinert & Freie Universität Berlin
3 // Copyright (c) 2016-2022, Knut Reinert & MPI für molekulare Genetik
4 // This file may be used, modified and/or redistributed under the terms of the 3-clause BSD-License
5 // shipped with this file and also available at: https://github.com/seqan/seqan3/blob/master/LICENSE.md
6 // -----------------------------------------------------------------------------------------------------
7 
14 #pragma once
15 
16 #include <optional>
17 
21 
22 namespace seqan3::detail
23 {
24 
25 // forward declaration for friend declaration in alignment_result.
26 template <typename configuration_t>
27  requires is_type_specialisation_of_v<configuration_t, configuration>
28 class policy_alignment_result_builder;
29 
42 template <typename sequence1_id_t,
43  typename sequence2_id_t,
44  typename score_t,
45  typename end_positions_t = std::nullopt_t *,
46  typename begin_positions_t = std::nullopt_t *,
47  typename alignment_t = std::nullopt_t *,
48  typename score_debug_matrix_t = std::nullopt_t *,
49  typename trace_debug_matrix_t = std::nullopt_t *>
50 struct alignment_result_value_type
51 {
53  sequence1_id_t sequence1_id{};
55  sequence2_id_t sequence2_id{};
57  score_t score{};
59  end_positions_t end_positions{};
61  begin_positions_t begin_positions{};
63  alignment_t alignment{};
64 
66  score_debug_matrix_t score_debug_matrix{};
68  trace_debug_matrix_t trace_debug_matrix{};
69 };
70 
76 alignment_result_value_type()->alignment_result_value_type<std::nullopt_t *, std::nullopt_t *, std::nullopt_t *>;
77 
79 template <typename sequence1_id_t, typename sequence2_id_t, typename score_t>
80 alignment_result_value_type(sequence1_id_t, sequence2_id_t, score_t)
81  -> alignment_result_value_type<sequence1_id_t, sequence2_id_t, score_t>;
82 
84 template <typename sequence1_id_t, typename sequence2_id_t, typename score_t, typename end_positions_t>
85 alignment_result_value_type(sequence1_id_t, sequence2_id_t, score_t, end_positions_t)
86  -> alignment_result_value_type<sequence1_id_t, sequence2_id_t, score_t, end_positions_t>;
87 
89 template <typename sequence1_id_t,
90  typename sequence2_id_t,
91  typename score_t,
92  typename end_positions_t,
93  typename begin_positions_t>
94 alignment_result_value_type(sequence1_id_t, sequence2_id_t, score_t, end_positions_t, begin_positions_t)
95  -> alignment_result_value_type<sequence1_id_t, sequence2_id_t, score_t, end_positions_t, begin_positions_t>;
96 
98 template <typename sequence1_id_t,
99  typename sequence2_id_t,
100  typename score_t,
101  typename end_positions_t,
102  typename begin_positions_t,
103  typename alignment_t>
104 alignment_result_value_type(sequence1_id_t, sequence2_id_t, score_t, end_positions_t, begin_positions_t, alignment_t)
105  -> alignment_result_value_type<sequence1_id_t,
106  sequence2_id_t,
107  score_t,
108  end_positions_t,
109  begin_positions_t,
110  alignment_t>;
112 
114 template <typename result_t>
115 struct alignment_result_value_type_accessor;
117 } // namespace seqan3::detail
118 
119 namespace seqan3
120 {
121 
145 template <typename alignment_result_value_t>
146  requires detail::is_type_specialisation_of_v<alignment_result_value_t, detail::alignment_result_value_type>
148 {
149 private:
151  alignment_result_value_t data{};
152 
158  using sequence1_id_t = decltype(data.sequence1_id);
160  using sequence2_id_t = decltype(data.sequence2_id);
162  using score_t = decltype(data.score);
164  using end_positions_t = decltype(data.end_positions);
166  using begin_positions_t = decltype(data.begin_positions);
168  using alignment_t = decltype(data.alignment);
170 
172  template <typename configuration_t>
173  requires detail::is_type_specialisation_of_v<configuration_t, configuration>
174  friend class detail::policy_alignment_result_builder;
175 
176 public:
182 
185  alignment_result(alignment_result_value_t value) : data(std::move(value))
186  {}
187 
189  alignment_result() = default;
190  alignment_result(alignment_result const &) = default;
194  ~alignment_result() = default;
195 
197 
206  constexpr sequence1_id_t sequence1_id() const noexcept
207  {
208  static_assert(!std::is_same_v<sequence1_id_t, std::nullopt_t *>,
209  "Trying to access the id of the first sequence, although it was not requested in the"
210  " alignment configuration.");
211  return data.sequence1_id;
212  }
213 
217  constexpr sequence2_id_t sequence2_id() const noexcept
218  {
219  static_assert(!std::is_same_v<sequence2_id_t, std::nullopt_t *>,
220  "Trying to access the id of the second sequence, although it was not requested in the"
221  " alignment configuration.");
222  return data.sequence2_id;
223  }
224 
228  constexpr score_t score() const noexcept
229  {
230  static_assert(!std::is_same_v<score_t, std::nullopt_t *>,
231  "Trying to access the score, although it was not requested in the alignment configuration.");
232  return data.score;
233  }
234 
241  constexpr auto sequence1_end_position() const noexcept
242  {
243  static_assert(!std::is_same_v<end_positions_t, std::nullopt_t *>,
244  "Trying to access the end position of the first sequence, although it was not requested in the"
245  " alignment configuration.");
246  return data.end_positions.first;
247  }
248 
255  constexpr auto sequence2_end_position() const noexcept
256  {
257  static_assert(!std::is_same_v<end_positions_t, std::nullopt_t *>,
258  "Trying to access the end position of the second sequence, although it was not requested in the"
259  " alignment configuration.");
260  return data.end_positions.second;
261  }
262 
273  constexpr auto sequence1_begin_position() const noexcept
274  {
275  static_assert(!std::is_same_v<begin_positions_t, std::nullopt_t *>,
276  "Trying to access the begin position of the first sequence, although it was not requested in the"
277  " alignment configuration.");
278  return data.begin_positions.first;
279  }
280 
291  constexpr auto sequence2_begin_position() const noexcept
292  {
293  static_assert(!std::is_same_v<begin_positions_t, std::nullopt_t *>,
294  "Trying to access the begin position of the second sequence, although it was not requested in the"
295  " alignment configuration.");
296  return data.begin_positions.second;
297  }
298 
305  constexpr alignment_t const & alignment() const noexcept
306  {
307  static_assert(!std::is_same_v<alignment_t, std::nullopt_t *>,
308  "Trying to access the alignment, although it was not requested in the alignment configuration.");
309  return data.alignment;
310  }
312 
314 
325  constexpr auto const & score_matrix() const noexcept
326  {
327  static_assert(
328  !std::is_same_v<decltype(data.score_debug_matrix), std::nullopt_t *>,
329  "Trying to access the score matrix, although it was not requested in the alignment configuration.");
330  return data.score_debug_matrix;
331  }
332 
344  constexpr auto const & trace_matrix() const noexcept
345  {
346  static_assert(
347  !std::is_same_v<decltype(data.trace_debug_matrix), std::nullopt_t *>,
348  "Trying to access the trace matrix, although it was not requested in the alignment configuration.");
349  return data.trace_debug_matrix;
350  }
352 };
353 } // namespace seqan3
354 
355 namespace seqan3::detail
356 {
367 template <typename result_value_t>
368 struct alignment_result_value_type_accessor<alignment_result<result_value_t>>
369 {
371  using type = result_value_t;
372 };
373 
374 } // namespace seqan3::detail
375 
376 namespace seqan3
377 {
387 template <typename char_t, typename alignment_result_t>
388  requires detail::is_type_specialisation_of_v<std::remove_cvref_t<alignment_result_t>, alignment_result>
389 inline debug_stream_type<char_t> & operator<<(debug_stream_type<char_t> & stream, alignment_result_t && result)
390 {
391  using disabled_t = std::nullopt_t *;
392  using result_data_t =
393  typename detail::alignment_result_value_type_accessor<std::remove_cvref_t<alignment_result_t>>::type;
394 
395  constexpr bool has_sequence1_id = !std::is_same_v<decltype(std::declval<result_data_t>().sequence1_id), disabled_t>;
396  constexpr bool has_sequence2_id = !std::is_same_v<decltype(std::declval<result_data_t>().sequence2_id), disabled_t>;
397  constexpr bool has_score = !std::is_same_v<decltype(std::declval<result_data_t>().score), disabled_t>;
398  constexpr bool has_end_positions =
399  !std::is_same_v<decltype(std::declval<result_data_t>().end_positions), disabled_t>;
400  constexpr bool has_begin_positions =
401  !std::is_same_v<decltype(std::declval<result_data_t>().begin_positions), disabled_t>;
402  constexpr bool has_alignment = !std::is_same_v<decltype(std::declval<result_data_t>().alignment), disabled_t>;
403 
404  bool prepend_comma = false;
405  auto append_to_stream = [&](auto &&... args)
406  {
407  ((stream << (prepend_comma ? std::string{", "} : std::string{})) << ... << std::forward<decltype(args)>(args));
408  prepend_comma = true;
409  };
410 
411  stream << '{';
412  if constexpr (has_sequence1_id)
413  append_to_stream("sequence1 id: ", result.sequence1_id());
414  if constexpr (has_sequence2_id)
415  append_to_stream("sequence2 id: ", result.sequence2_id());
416  if constexpr (has_score)
417  append_to_stream("score: ", result.score());
418  if constexpr (has_begin_positions)
419  append_to_stream("begin: (", result.sequence1_begin_position(), ",", result.sequence2_begin_position(), ")");
420  if constexpr (has_end_positions)
421  append_to_stream("end: (", result.sequence1_end_position(), ",", result.sequence2_end_position(), ")");
422  if constexpr (has_alignment)
423  append_to_stream("\nalignment:\n", result.alignment());
424  stream << '}';
425 
426  return stream;
427 }
428 } // namespace seqan3
Stores the alignment results and gives access to score, alignment and the front and end positionss.
Definition: alignment_result.hpp:148
constexpr sequence2_id_t sequence2_id() const noexcept
Returns the alignment identifier of the second sequence.
Definition: alignment_result.hpp:217
constexpr alignment_t const & alignment() const noexcept
Returns the actual alignment, i.e. the base pair matching.
Definition: alignment_result.hpp:305
alignment_result & operator=(alignment_result &&)=default
Defaulted.
constexpr sequence1_id_t sequence1_id() const noexcept
Returns the alignment identifier of the first sequence.
Definition: alignment_result.hpp:206
constexpr auto sequence2_end_position() const noexcept
Returns the end position of the second sequence of the alignment.
Definition: alignment_result.hpp:255
constexpr auto sequence1_begin_position() const noexcept
Returns the begin position of the first sequence of the alignment.
Definition: alignment_result.hpp:273
alignment_result(alignment_result const &)=default
Defaulted.
constexpr auto sequence2_begin_position() const noexcept
Returns the begin position of the second sequence of the alignment.
Definition: alignment_result.hpp:291
~alignment_result()=default
Defaulted.
constexpr score_t score() const noexcept
Returns the alignment score.
Definition: alignment_result.hpp:228
constexpr auto sequence1_end_position() const noexcept
Returns the end position of the first sequence of the alignment.
Definition: alignment_result.hpp:241
alignment_result & operator=(alignment_result const &)=default
Defaulted.
alignment_result(alignment_result &&)=default
Defaulted.
A "pretty printer" for most SeqAn data structures and related types.
Definition: debug_stream_type.hpp:78
Provides seqan3::configuration and utility functions.
Provides seqan3::debug_stream and related types.
requires requires
The rank_type of the semi-alphabet; defined as the return type of seqan3::to_rank....
Definition: alphabet/concept.hpp:164
T is_same_v
The main SeqAn3 namespace.
Definition: aligned_sequence_concept.hpp:29
requires detail::debug_stream_range_guard< alignment_matrix_t > &&detail::matrix< alignment_matrix_t > debug_stream_type< char_t > & operator<<(debug_stream_type< char_t > &s, alignment_matrix_t &&matrix)
This is an overloaded member function, provided for convenience. It differs from the above function o...
Definition: debug_matrix.hpp:496
Provides type traits for working with templates.