SeqAn3  3.0.3
The Modern C++ library for sequence analysis.
qualified.hpp
Go to the documentation of this file.
1 // -----------------------------------------------------------------------------------------------------
2 // Copyright (c) 2006-2021, Knut Reinert & Freie Universität Berlin
3 // Copyright (c) 2016-2021, 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 
13 #pragma once
14 
18 
19 namespace seqan3
20 {
21 
57 template <writable_alphabet sequence_alphabet_t, writable_quality_alphabet quality_alphabet_t>
58 class qualified :
59  public alphabet_tuple_base<qualified<sequence_alphabet_t, quality_alphabet_t>,
60  sequence_alphabet_t, quality_alphabet_t>
61 {
62 private:
65  sequence_alphabet_t, quality_alphabet_t>;
66 
67 public:
72  using sequence_alphabet_type = sequence_alphabet_t;
77  using quality_alphabet_type = quality_alphabet_t;
78 
89 
93  constexpr qualified() noexcept = default;
94  constexpr qualified(qualified const &) noexcept = default;
95  constexpr qualified(qualified &&) noexcept = default;
96  constexpr qualified & operator =(qualified const &) noexcept = default;
97  constexpr qualified & operator =(qualified &&) noexcept = default;
98  ~qualified() noexcept = default;
99 
100  // Inherit from base:
101  using base_type::base_type; // non-default constructors
102  using base_type::alphabet_size;
103  using base_type::to_rank;
104  using base_type::operator=;
105 
107  SEQAN3_DOXYGEN_ONLY(( constexpr qualified(component_type const alph) noexcept {} ))
109  SEQAN3_DOXYGEN_ONLY(( constexpr qualified(indirect_component_type const alph) noexcept {} ))
111  SEQAN3_DOXYGEN_ONLY(( constexpr qualified & operator=(component_type const alph) noexcept {} ))
113  SEQAN3_DOXYGEN_ONLY(( constexpr qualified & operator=(indirect_component_type const alph) noexcept {} ))
115 
123  constexpr qualified & assign_char(char_type const c) noexcept
124  {
127  base_type::cummulative_alph_sizes[0]) +
128  (base_type::template to_component_rank<1>() * base_type::cummulative_alph_sizes[1]));
129 
130  // The above is noticeably faster than (no subtraction and no division):
131  // base_type::template assign_component_rank<0>(
132  // seqan3::to_rank(seqan3::assign_char_to(c, sequence_alphabet_type{})));
133  return *this;
134  }
135 
140  constexpr qualified & assign_phred(phred_type const c) noexcept
141  {
142  seqan3::assign_phred_to(c, get<1>(*this));
143  return *this;
144  }
146 
154  constexpr phred_type to_phred() const noexcept
155  {
156  return rank_to_phred[to_rank()];
157  }
158 
163  constexpr char_type to_char() const noexcept
164  {
165  return rank_to_char(to_rank());
166  }
167 
174  constexpr qualified complement() const noexcept
176  requires nucleotide_alphabet<sequence_alphabet_t>
178  {
179  return qualified{seqan3::complement(get<0>(*this)), get<1>(*this)};
180  }
182 
187  static constexpr bool char_is_valid(char_type const c) noexcept
188  {
189  return char_is_valid_for<sequence_alphabet_type>(c);
190  }
191 
192 private:
194  static std::array<char_type, alphabet_size> constexpr rank_to_char_table
195  {
196  [] () constexpr
197  {
199 
200  for (size_t i = 0; i < alphabet_size; ++i)
201  {
202  size_t seq_rank = (i / base_type::cummulative_alph_sizes[0]) %
203  seqan3::alphabet_size<quality_alphabet_type>;
204 
206  }
207 
208  return ret;
209  }()
210  };
211 
213  static std::array<char_type, alphabet_size> constexpr rank_to_phred
214  {
215  [] () constexpr
216  {
218 
219  for (size_t i = 0; i < alphabet_size; ++i)
220  {
221  size_t qual_rank = (i / base_type::cummulative_alph_sizes[1]) %
222  seqan3::alphabet_size<quality_alphabet_type>;
223 
225  }
226 
227  return ret;
228  }()
229  };
230 
232  static constexpr char_type rank_to_char(typename base_type::rank_type const rank)
233  {
234  return rank_to_char_table[rank];
235  }
236 };
237 
241 template <typename sequence_alphabet_type, typename quality_alphabet_type>
244 
245 } // namespace seqan3
Provides seqan3::nucleotide_alphabet.
Quality alphabet concept.
Provides seqan3::alphabet_tuple_base.
constexpr rank_type to_rank() const noexcept
Return the letter's numeric value (rank in the alphabet).
Definition: alphabet_base.hpp:185
detail::min_viable_uint_t< size - 1 > rank_type
The type of the alphabet when represented as a number (e.g. via to_rank()).
Definition: alphabet_base.hpp:104
static constexpr detail::min_viable_uint_t< size > alphabet_size
The size of the alphabet, i.e. the number of different values it can take.
Definition: alphabet_base.hpp:276
constexpr qualified< sequence_alphabet_t, quality_alphabet_t > & assign_rank(rank_type const c) noexcept
Assign from a numeric value.
Definition: alphabet_base.hpp:264
The CRTP base for a combined alphabet that contains multiple values of different alphabets at the sam...
Definition: alphabet_tuple_base.hpp:124
Joins an arbitrary alphabet with a quality alphabet.
Definition: qualified.hpp:61
static constexpr bool char_is_valid(char_type const c) noexcept
Validate whether a character is valid in the sequence alphabet.
Definition: qualified.hpp:187
constexpr char_type to_char() const noexcept
Return a character. This reads the internal sequence letter.
Definition: qualified.hpp:163
constexpr phred_type to_phred() const noexcept
Return the Phred score value. This reads the internal quality letter.
Definition: qualified.hpp:154
alphabet_char_t< sequence_alphabet_type > char_type
Equals the char_type of sequence_alphabet_type.
Definition: qualified.hpp:83
constexpr qualified(indirect_component_type const alph) noexcept
Construction via a value of a subtype that is assignable to one of the components.
Definition: qualified.hpp:109
constexpr qualified() noexcept=default
Defaulted.
qualified(sequence_alphabet_type &&, quality_alphabet_type &&) -> qualified< std::decay_t< sequence_alphabet_type >, std::decay_t< quality_alphabet_type >>
Type deduction guide enables usage of qualified without specifying template args.
constexpr qualified complement() const noexcept
Return a qualified where the quality is preserved, but the sequence letter is complemented.
Definition: qualified.hpp:174
quality_alphabet_t quality_alphabet_type
Second template parameter as member type.
Definition: qualified.hpp:77
alphabet_phred_t< quality_alphabet_type > phred_type
Equals the phred_type of the quality_alphabet_type.
Definition: qualified.hpp:88
sequence_alphabet_t sequence_alphabet_type
First template parameter as member type.
Definition: qualified.hpp:72
constexpr qualified & assign_phred(phred_type const c) noexcept
Assign from a Phred score value. This modifies the internal quality letter.
Definition: qualified.hpp:140
constexpr qualified & assign_char(char_type const c) noexcept
Assign from a character. This modifies the internal sequence letter.
Definition: qualified.hpp:123
constexpr auto assign_char_to
Assign a character to an alphabet object.
Definition: concept.hpp:523
constexpr auto to_char
Return the char representation of an alphabet object.
Definition: concept.hpp:384
constexpr auto assign_rank_to
Assign a rank to an alphabet object.
Definition: concept.hpp:291
decltype(seqan3::to_char(std::declval< alphabet_type const >())) alphabet_char_t
The char_type of the alphabet; defined as the return type of seqan3::to_char.
Definition: concept.hpp:396
constexpr auto to_rank
Return the rank representation of a (semi-)alphabet object.
Definition: concept.hpp:155
constexpr auto complement
Return the complement of a nucleotide object.
Definition: concept.hpp:104
constexpr auto to_phred
The public getter function for the Phred representation of a quality score.
Definition: concept.hpp:100
decltype(seqan3::to_phred(std::declval< alphabet_type >())) alphabet_phred_t
The phred_type of the alphabet; defined as the return type of seqan3::to_phred.
Definition: concept.hpp:112
constexpr auto assign_phred_to
Assign a Phred score to a quality alphabet object.
Definition: concept.hpp:231
A concept that indicates whether an alphabet represents nucleotides.
The main SeqAn3 namespace.
Definition: aligned_sequence_concept.hpp:29