54 using sam_tag_variant = std::variant<char, int32_t, float, std::string,
55 std::vector<int8_t>, std::vector<uint8_t>,
56 std::vector<int16_t>, std::vector<uint16_t>,
57 std::vector<int32_t>, std::vector<uint32_t>,
61 char constexpr sam_tag_type_char[11] = {
'A',
'i',
'f',
'Z',
'B',
'B',
'B',
'B',
'B',
'B',
'B'};
63 char constexpr sam_tag_type_char_extra[11] = {
'\0',
'\0',
'\0',
'\0',
'c',
'C',
's',
'S',
'i',
'I',
'f'};
88 template <
typename char_t, char_t ...s>
89 constexpr uint16_t
operator""_tag()
92 static_assert((
sizeof...(s) == 2),
"Illegal SAM tag: Exactly two characters must be given.");
94 char constexpr str[
sizeof...(s)] = {s...};
95 char constexpr char0 = str[0];
96 char constexpr char1 = str[1];
99 "Illegal SAM tag: a SAM tag must match /[A-Za-z][A-Za-z0-9]/.");
101 return static_cast<uint16_t
>(char0) * 256 + static_cast<uint16_t>(char1);
180 template <u
int16_t tag_value>
184 using type = detail::sam_tag_variant;
189 template <u
int16_t tag_value>
193 template <>
struct sam_tag_type<"AM"_tag> {
using type = int32_t; };
194 template <>
struct sam_tag_type<"AS"_tag> {
using type = int32_t; };
195 template <>
struct sam_tag_type<"BC"_tag> {
using type = std::string; };
196 template <>
struct sam_tag_type<"BQ"_tag> {
using type = std::string; };
197 template <>
struct sam_tag_type<"BZ"_tag> {
using type = std::string; };
198 template <>
struct sam_tag_type<"CB"_tag> {
using type = std::string; };
199 template <>
struct sam_tag_type<"CC"_tag> {
using type = std::string; };
200 template <>
struct sam_tag_type<"CG"_tag> {
using type = std::vector<int32_t>; };
201 template <>
struct sam_tag_type<"CM"_tag> {
using type = int32_t; };
202 template <>
struct sam_tag_type<"CO"_tag> {
using type = std::string; };
203 template <>
struct sam_tag_type<"CP"_tag> {
using type = int32_t; };
204 template <>
struct sam_tag_type<"CQ"_tag> {
using type = std::string; };
205 template <>
struct sam_tag_type<"CR"_tag> {
using type = std::string; };
206 template <>
struct sam_tag_type<"CS"_tag> {
using type = std::string; };
207 template <>
struct sam_tag_type<"CT"_tag> {
using type = std::string; };
208 template <>
struct sam_tag_type<"CY"_tag> {
using type = std::string; };
209 template <>
struct sam_tag_type<"E2"_tag> {
using type = std::string; };
210 template <>
struct sam_tag_type<"FI"_tag> {
using type = int32_t; };
211 template <>
struct sam_tag_type<"FS"_tag> {
using type = std::string; };
212 template <>
struct sam_tag_type<"FZ"_tag> {
using type = std::vector<uint16_t>; };
218 template <>
struct sam_tag_type<"H0"_tag> {
using type = int32_t; };
219 template <>
struct sam_tag_type<"H1"_tag> {
using type = int32_t; };
220 template <>
struct sam_tag_type<"H2"_tag> {
using type = int32_t; };
221 template <>
struct sam_tag_type<"HI"_tag> {
using type = int32_t; };
222 template <>
struct sam_tag_type<"IH"_tag> {
using type = int32_t; };
223 template <>
struct sam_tag_type<"LB"_tag> {
using type = std::string; };
224 template <>
struct sam_tag_type<"MC"_tag> {
using type = std::string; };
225 template <>
struct sam_tag_type<"MD"_tag> {
using type = std::string; };
229 template <>
struct sam_tag_type<"MI"_tag> {
using type = std::string; };
230 template <>
struct sam_tag_type<"MQ"_tag> {
using type = int32_t; };
231 template <>
struct sam_tag_type<"NH"_tag> {
using type = int32_t; };
232 template <>
struct sam_tag_type<"NM"_tag> {
using type = int32_t; };
233 template <>
struct sam_tag_type<"OC"_tag> {
using type = std::string; };
234 template <>
struct sam_tag_type<"OP"_tag> {
using type = int32_t; };
235 template <>
struct sam_tag_type<"OQ"_tag> {
using type = std::string; };
236 template <>
struct sam_tag_type<"OX"_tag> {
using type = std::string; };
237 template <>
struct sam_tag_type<"PG"_tag> {
using type = std::string; };
238 template <>
struct sam_tag_type<"PQ"_tag> {
using type = int32_t; };
239 template <>
struct sam_tag_type<"PT"_tag> {
using type = std::string; };
240 template <>
struct sam_tag_type<"PU"_tag> {
using type = std::string; };
241 template <>
struct sam_tag_type<"Q2"_tag> {
using type = std::string; };
242 template <>
struct sam_tag_type<"QT"_tag> {
using type = std::string; };
243 template <>
struct sam_tag_type<"QX"_tag> {
using type = std::string; };
244 template <>
struct sam_tag_type<"R2"_tag> {
using type = std::string; };
245 template <>
struct sam_tag_type<"RG"_tag> {
using type = std::string; };
246 template <>
struct sam_tag_type<"RT"_tag> {
using type = std::string; };
247 template <>
struct sam_tag_type<"RX"_tag> {
using type = std::string; };
251 template <>
struct sam_tag_type<"SA"_tag> {
using type = std::string; };
252 template <>
struct sam_tag_type<"SM"_tag> {
using type = int32_t; };
256 template <>
struct sam_tag_type<"TC"_tag> {
using type = int32_t; };
257 template <>
struct sam_tag_type<"U2"_tag> {
using type = std::string; };
258 template <>
struct sam_tag_type<"UQ"_tag> {
using type = int32_t; };
343 using base_type = std::map<uint16_t, detail::sam_tag_variant>;
364 template <u
int16_t tag>
371 if ((*this).count(tag) == 0)
374 return std::get<sam_tag_type_t<tag>>((*this)[tag]);
378 template <u
int16_t tag>
384 if ((*this).count(tag) == 0)
387 return std::get<sam_tag_type_t<tag>>(std::move((*
this)[tag]));
392 template <u
int16_t tag>
396 auto const &
get()
const &
398 return std::get<sam_tag_type_t<tag>>((*this).at(tag));
403 template <u
int16_t tag>
407 auto const &&
get()
const &&
409 return std::get<sam_tag_type_t<tag>>(std::move((*this).at(tag)));
Provides concepts for core language types and relations that don't have concepts in C++20 (yet)...
auto constexpr is_alnum
Checks whether c is a alphanumeric character.
Definition: parse_condition.hpp:245
typename sam_tag_type< tag_value >::type sam_tag_type_t
Short cut helper for seqan3::sam_tag_type::type.
Definition: sam_tag_dictionary.hpp:190
Provides seqan3::type_list and auxiliary metafunctions.
The main SeqAn3 namespace.
Definition: aligned_sequence_concept.hpp:58
detail::sam_tag_variant variant_type
The variant type defining all valid SAM tag field types.
Definition: sam_tag_dictionary.hpp:347
auto constexpr is_alpha
Checks whether c is a alphabetical character.
Definition: parse_condition.hpp:264
The concept std::Same<T, U> is satisfied if and only if T and U denote the same type.
detail::sam_tag_variant type
The type for all unknown tags with no extra overload defaults to an std::variant. ...
Definition: sam_tag_dictionary.hpp:184
Definition: aligned_sequence_concept.hpp:288
Provides parse conditions for tokenization.
The generic base class.
Definition: sam_tag_dictionary.hpp:181
The SAM tag dictionary class that stores all optional SAM fields.
Definition: sam_tag_dictionary.hpp:339