SeqAn3  3.2.0-rc.1
The Modern C++ library for sequence analysis.
dna4.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 
13 #pragma once
14 
15 #include <vector>
16 
18 
19 // ------------------------------------------------------------------
20 // dna4
21 // ------------------------------------------------------------------
22 
23 namespace seqan3
24 {
25 
26 class rna4;
27 
52 class dna4 : public nucleotide_base<dna4, 4>
53 {
54 private:
57 
59  friend base_t;
61  friend base_t::base_t;
64  friend rna4;
65 
66 public:
70  constexpr dna4() noexcept = default;
71  constexpr dna4(dna4 const &) noexcept = default;
72  constexpr dna4(dna4 &&) noexcept = default;
73  constexpr dna4 & operator=(dna4 const &) noexcept = default;
74  constexpr dna4 & operator=(dna4 &&) noexcept = default;
75  ~dna4() noexcept = default;
76 
77  using base_t::base_t;
78 
86  template <std::same_as<rna4> t> // template parameter t to accept incomplete type
87  constexpr dna4(t const & r) noexcept
88  {
89  assign_rank(r.to_rank());
90  }
92 
93 private:
117  static constexpr char_type rank_to_char_table[alphabet_size]{'A', 'C', 'G', 'T'};
118 
122  static constexpr std::array<rank_type, 256> char_to_rank_table{[]() constexpr {std::array<rank_type, 256> ret{};
123 
124  // reverse mapping for characters and their lowercase
125  for (size_t rnk = 0u; rnk < alphabet_size; ++rnk)
126  {
127  ret[rank_to_char_table[rnk]] = rnk;
128  ret[to_lower(rank_to_char_table[rnk])] = rnk;
129  }
130 
131  // set U equal to T
132  ret['U'] = ret['T'];
133  ret['u'] = ret['t'];
134 
135  // iupac characters get special treatment, because there is no N
136  ret['R'] = ret['A'];
137  ret['r'] = ret['A']; // A or G
138  ret['Y'] = ret['C'];
139  ret['y'] = ret['C']; // C or T
140  ret['S'] = ret['C'];
141  ret['s'] = ret['C']; // C or G
142  ret['W'] = ret['A'];
143  ret['w'] = ret['A']; // A or T
144  ret['K'] = ret['G'];
145  ret['k'] = ret['G']; // G or T
146  ret['M'] = ret['A'];
147  ret['m'] = ret['A']; // A or T
148  ret['B'] = ret['C'];
149  ret['b'] = ret['C']; // C or G or T
150  ret['D'] = ret['A'];
151  ret['d'] = ret['A']; // A or G or T
152  ret['H'] = ret['A'];
153  ret['h'] = ret['A']; // A or C or T
154  ret['V'] = ret['A'];
155  ret['v'] = ret['A']; // A or C or G
156 
157  return ret;
158 }()
159 }; // namespace seqan3
160 
162 static constexpr rank_type rank_complement_table[alphabet_size]{
163  3, // T is complement of 'A'_dna4
164  2, // G is complement of 'C'_dna4
165  1, // C is complement of 'G'_dna4
166  0 // A is complement of 'T'_dna4
167 };
168 
173 static constexpr rank_type rank_complement(rank_type const rank)
174 {
175  return rank_complement_table[rank];
176 }
177 
182 static constexpr char_type rank_to_char(rank_type const rank)
183 {
184  return rank_to_char_table[rank];
185 }
186 
191 static constexpr rank_type char_to_rank(char_type const chr)
192 {
193  using index_t = std::make_unsigned_t<char_type>;
194  return char_to_rank_table[static_cast<index_t>(chr)];
195 }
196 }
197 ;
198 
199 // ------------------------------------------------------------------
200 // containers
201 // ------------------------------------------------------------------
202 
209 
210 inline namespace literals
211 {
212 
213 // ------------------------------------------------------------------
214 // literals
215 // ------------------------------------------------------------------
216 
232 constexpr dna4 operator""_dna4(char const c) noexcept
233 {
234  return dna4{}.assign_char(c);
235 }
236 
247 inline dna4_vector operator""_dna4(char const * s, std::size_t n)
248 {
249  dna4_vector r;
250  r.resize(n);
251 
252  for (size_t i = 0; i < n; ++i)
253  r[i].assign_char(s[i]);
254 
255  return r;
256 }
258 
259 } // namespace literals
260 
261 } // namespace seqan3
A CRTP-base that makes defining a custom alphabet easier.
Definition: alphabet_base.hpp:57
constexpr derived_type & assign_char(char_type const chr) noexcept requires(!std
Assign from a character, implicitly converts invalid characters.
Definition: alphabet_base.hpp:163
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:80
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:199
constexpr derived_type & assign_rank(rank_type const c) noexcept
Assign from a numeric value.
Definition: alphabet_base.hpp:187
std::conditional_t< std::same_as< char_t, void >, char, char_t > char_type
The char representation; conditional needed to make semi alphabet definitions legal.
Definition: alphabet_base.hpp:72
The four letter DNA alphabet of A,C,G,T.
Definition: dna4.hpp:53
constexpr dna4() noexcept=default
Defaulted.
A CRTP-base that refines seqan3::alphabet_base and is used by the nucleotides.
Definition: nucleotide_base.hpp:43
The four letter RNA alphabet of A,C,G,U.
Definition: rna4.hpp:49
The main SeqAn3 namespace.
Definition: aligned_sequence_concept.hpp:29
constexpr char_type to_lower(char_type const c) noexcept
Converts 'A'-'Z' to 'a'-'z' respectively; other characters are returned as is.
Definition: transform.hpp:83
SeqAn specific customisations in the standard namespace.
Provides seqan3::nucleotide_base.
T resize(T... args)