23namespace seqan3::detail
42constexpr char sam_tag_type_char[12] = {
'A',
'i',
'f',
'Z',
'H',
'B',
'B',
'B',
'B',
'B',
'B',
'B'};
45constexpr char sam_tag_type_char_extra[12] = {
'\0',
'\0',
'\0',
'\0',
'\0',
'c',
'C',
's',
'S',
'i',
'I',
'f'};
51inline namespace literals
73template <small_
string<2> str>
74constexpr uint16_t
operator""_tag()
76 static_assert(str.size() == 2,
"Illegal SAM tag: Exactly two characters must be given.");
78 constexpr char char0 = str[0];
79 constexpr char char1 = str[1];
81 static_assert((
is_alpha(char0) &&
is_alnum(char1)),
"Illegal SAM tag: a SAM tag must match /[A-Za-z][A-Za-z0-9]/.");
83 return static_cast<uint16_t
>(char0) * 256 +
static_cast<uint16_t
>(char1);
166template <u
int16_t tag_value>
175template <u
int16_t tag_value>
182template <>
struct sam_tag_type<
"BC"_tag> {
using type =
std::string; };
183template <>
struct sam_tag_type<
"BQ"_tag> {
using type =
std::string; };
184template <>
struct sam_tag_type<
"BZ"_tag> {
using type =
std::string; };
185template <>
struct sam_tag_type<
"CB"_tag> {
using type =
std::string; };
186template <>
struct sam_tag_type<
"CC"_tag> {
using type =
std::string; };
188template <>
struct sam_tag_type<
"CM"_tag> {
using type = int32_t; };
189template <>
struct sam_tag_type<
"CO"_tag> {
using type =
std::string; };
190template <>
struct sam_tag_type<
"CP"_tag> {
using type = int32_t; };
191template <>
struct sam_tag_type<
"CQ"_tag> {
using type =
std::string; };
192template <>
struct sam_tag_type<
"CR"_tag> {
using type =
std::string; };
193template <>
struct sam_tag_type<
"CS"_tag> {
using type =
std::string; };
194template <>
struct sam_tag_type<
"CT"_tag> {
using type =
std::string; };
195template <>
struct sam_tag_type<
"CY"_tag> {
using type =
std::string; };
196template <>
struct sam_tag_type<
"E2"_tag> {
using type =
std::string; };
197template <>
struct sam_tag_type<
"FI"_tag> {
using type = int32_t; };
198template <>
struct sam_tag_type<
"FS"_tag> {
using type =
std::string; };
205template <>
struct sam_tag_type<
"H0"_tag> {
using type = int32_t; };
206template <>
struct sam_tag_type<
"H1"_tag> {
using type = int32_t; };
207template <>
struct sam_tag_type<
"H2"_tag> {
using type = int32_t; };
208template <>
struct sam_tag_type<
"HI"_tag> {
using type = int32_t; };
209template <>
struct sam_tag_type<
"IH"_tag> {
using type = int32_t; };
210template <>
struct sam_tag_type<
"LB"_tag> {
using type =
std::string; };
211template <>
struct sam_tag_type<
"MC"_tag> {
using type =
std::string; };
212template <>
struct sam_tag_type<
"MD"_tag> {
using type =
std::string; };
216template <>
struct sam_tag_type<
"MI"_tag> {
using type =
std::string; };
217template <>
struct sam_tag_type<
"MQ"_tag> {
using type = int32_t; };
218template <>
struct sam_tag_type<
"NH"_tag> {
using type = int32_t; };
219template <>
struct sam_tag_type<
"NM"_tag> {
using type = int32_t; };
220template <>
struct sam_tag_type<
"OC"_tag> {
using type =
std::string; };
221template <>
struct sam_tag_type<
"OP"_tag> {
using type = int32_t; };
222template <>
struct sam_tag_type<
"OQ"_tag> {
using type =
std::string; };
223template <>
struct sam_tag_type<
"OX"_tag> {
using type =
std::string; };
224template <>
struct sam_tag_type<
"PG"_tag> {
using type =
std::string; };
225template <>
struct sam_tag_type<
"PQ"_tag> {
using type = int32_t; };
226template <>
struct sam_tag_type<
"PT"_tag> {
using type =
std::string; };
227template <>
struct sam_tag_type<
"PU"_tag> {
using type =
std::string; };
228template <>
struct sam_tag_type<
"Q2"_tag> {
using type =
std::string; };
229template <>
struct sam_tag_type<
"QT"_tag> {
using type =
std::string; };
230template <>
struct sam_tag_type<
"QX"_tag> {
using type =
std::string; };
231template <>
struct sam_tag_type<
"R2"_tag> {
using type =
std::string; };
232template <>
struct sam_tag_type<
"RG"_tag> {
using type =
std::string; };
233template <>
struct sam_tag_type<
"RT"_tag> {
using type =
std::string; };
234template <>
struct sam_tag_type<
"RX"_tag> {
using type =
std::string; };
238template <>
struct sam_tag_type<
"SA"_tag> {
using type =
std::string; };
239template <>
struct sam_tag_type<
"SM"_tag> {
using type = int32_t; };
243template <>
struct sam_tag_type<
"TC"_tag> {
using type = int32_t; };
244template <>
struct sam_tag_type<
"U2"_tag> {
using type =
std::string; };
245template <>
struct sam_tag_type<
"UQ"_tag> {
using type = int32_t; };
355 template <u
int16_t tag>
356 requires (!std::same_as<sam_tag_type_t<tag>,
variant_type>)
359 if ((*this).count(tag) == 0)
360 (*
this)[tag] = sam_tag_type_t<tag>{};
362 return std::get<sam_tag_type_t<tag>>((*this)[tag]);
366 template <u
int16_t tag>
367 requires (!std::same_as<sam_tag_type_t<tag>,
variant_type>)
370 if ((*this).count(tag) == 0)
371 (*
this)[tag] = sam_tag_type_t<tag>{};
373 return std::get<sam_tag_type_t<tag>>(std::move((*
this)[tag]));
378 template <u
int16_t tag>
379 requires (!std::same_as<sam_tag_type_t<tag>,
variant_type>)
380 auto const &
get()
const &
382 return std::get<sam_tag_type_t<tag>>((*this).at(tag));
387 template <u
int16_t tag>
388 requires (!std::same_as<sam_tag_type_t<tag>,
variant_type>)
389 auto const &&
get()
const &&
391 return std::get<sam_tag_type_t<tag>>(std::move((*this).at(tag)));
The SAM tag dictionary class that stores all optional SAM fields.
Definition sam_tag_dictionary.hpp:330
detail::sam_tag_variant variant_type
The variant type defining all valid SAM tag field types.
Definition sam_tag_dictionary.hpp:337
auto && get() &&
Uses std::map::operator[] for access and default initializes new keys.
Definition sam_tag_dictionary.hpp:368
auto & get() &
Uses std::map::operator[] for access and default initializes new keys.
Definition sam_tag_dictionary.hpp:357
auto const && get() const &&
Uses std::map::at() for access and throws when the key is unknown.
Definition sam_tag_dictionary.hpp:389
auto const & get() const &
Uses std::map::at() for access and throws when the key is unknown.
Definition sam_tag_dictionary.hpp:380
constexpr auto is_alnum
Checks whether c is a alphanumeric character.
Definition predicate.hpp:197
constexpr auto is_alpha
Checks whether c is a alphabetical character.
Definition predicate.hpp:214
The main SeqAn3 namespace.
Definition aligned_sequence_concept.hpp:29
Provides character predicates for tokenisation.
A constexpr string implementation to manipulate string literals at compile time.
The generic base class.
Definition sam_tag_dictionary.hpp:168
detail::sam_tag_variant type
The type for all unknown tags with no extra overload defaults to a std::variant.
Definition sam_tag_dictionary.hpp:170
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:176
Provides type traits for working with templates.