SeqAn3 3.4.0-rc.1
The Modern C++ library for sequence analysis.
Loading...
Searching...
No Matches
sam_tag_dictionary.hpp
Go to the documentation of this file.
1// SPDX-FileCopyrightText: 2006-2024 Knut Reinert & Freie Universität Berlin
2// SPDX-FileCopyrightText: 2016-2024 Knut Reinert & MPI für molekulare Genetik
3// SPDX-License-Identifier: BSD-3-Clause
4
10#pragma once
11
12#include <concepts>
13#include <map>
14#include <variant>
15
19
20namespace seqan3::detail
21{
24using sam_tag_variant = std::variant<char,
25 int32_t,
26 float,
36
39constexpr char sam_tag_type_char[12] = {'A', 'i', 'f', 'Z', 'H', 'B', 'B', 'B', 'B', 'B', 'B', 'B'};
42constexpr char sam_tag_type_char_extra[12] = {'\0', '\0', '\0', '\0', '\0', 'c', 'C', 's', 'S', 'i', 'I', 'f'};
43} // namespace seqan3::detail
44
45namespace seqan3
46{
47
48inline namespace literals
49{
50
70template <small_string<2> str> // TODO: better handling if too large string is provided?
71constexpr uint16_t operator""_tag()
72{
73 static_assert(str.size() == 2, "Illegal SAM tag: Exactly two characters must be given.");
74
75 constexpr char char0 = str[0];
76 constexpr char char1 = str[1];
77
78 static_assert((is_alpha(char0) && is_alnum(char1)), "Illegal SAM tag: a SAM tag must match /[A-Za-z][A-Za-z0-9]/.");
79
80 return static_cast<uint16_t>(char0) * 256 + static_cast<uint16_t>(char1);
81}
83
84} // namespace literals
85
163template <uint16_t tag_value>
169
172template <uint16_t tag_value>
174
175// clang-format off
177template <> struct sam_tag_type<"AM"_tag> { using type = int32_t; };
178template <> struct sam_tag_type<"AS"_tag> { using type = int32_t; };
179template <> struct sam_tag_type<"BC"_tag> { using type = std::string; };
180template <> struct sam_tag_type<"BQ"_tag> { using type = std::string; };
181template <> struct sam_tag_type<"BZ"_tag> { using type = std::string; };
182template <> struct sam_tag_type<"CB"_tag> { using type = std::string; };
183template <> struct sam_tag_type<"CC"_tag> { using type = std::string; };
184template <> struct sam_tag_type<"CG"_tag> { using type = std::vector<int32_t>; };
185template <> struct sam_tag_type<"CM"_tag> { using type = int32_t; };
186template <> struct sam_tag_type<"CO"_tag> { using type = std::string; };
187template <> struct sam_tag_type<"CP"_tag> { using type = int32_t; };
188template <> struct sam_tag_type<"CQ"_tag> { using type = std::string; };
189template <> struct sam_tag_type<"CR"_tag> { using type = std::string; };
190template <> struct sam_tag_type<"CS"_tag> { using type = std::string; };
191template <> struct sam_tag_type<"CT"_tag> { using type = std::string; };
192template <> struct sam_tag_type<"CY"_tag> { using type = std::string; };
193template <> struct sam_tag_type<"E2"_tag> { using type = std::string; };
194template <> struct sam_tag_type<"FI"_tag> { using type = int32_t; };
195template <> struct sam_tag_type<"FS"_tag> { using type = std::string; };
196template <> struct sam_tag_type<"FZ"_tag> { using type = std::vector<uint16_t>; };
197
198// template <> struct sam_tag_type<"GC"_tag> {};
199// template <> struct sam_tag_type<"GQ"_tag> {};
200// template <> struct sam_tag_type<"GS"_tag> {};
201
202template <> struct sam_tag_type<"H0"_tag> { using type = int32_t; };
203template <> struct sam_tag_type<"H1"_tag> { using type = int32_t; };
204template <> struct sam_tag_type<"H2"_tag> { using type = int32_t; };
205template <> struct sam_tag_type<"HI"_tag> { using type = int32_t; };
206template <> struct sam_tag_type<"IH"_tag> { using type = int32_t; };
207template <> struct sam_tag_type<"LB"_tag> { using type = std::string; };
208template <> struct sam_tag_type<"MC"_tag> { using type = std::string; };
209template <> struct sam_tag_type<"MD"_tag> { using type = std::string; };
210
211// template <> struct sam_tag_type<"MF"_tag> {};
212
213template <> struct sam_tag_type<"MI"_tag> { using type = std::string; };
214template <> struct sam_tag_type<"MQ"_tag> { using type = int32_t; };
215template <> struct sam_tag_type<"NH"_tag> { using type = int32_t; };
216template <> struct sam_tag_type<"NM"_tag> { using type = int32_t; };
217template <> struct sam_tag_type<"OC"_tag> { using type = std::string; };
218template <> struct sam_tag_type<"OP"_tag> { using type = int32_t; };
219template <> struct sam_tag_type<"OQ"_tag> { using type = std::string; };
220template <> struct sam_tag_type<"OX"_tag> { using type = std::string; };
221template <> struct sam_tag_type<"PG"_tag> { using type = std::string; };
222template <> struct sam_tag_type<"PQ"_tag> { using type = int32_t; };
223template <> struct sam_tag_type<"PT"_tag> { using type = std::string; };
224template <> struct sam_tag_type<"PU"_tag> { using type = std::string; };
225template <> struct sam_tag_type<"Q2"_tag> { using type = std::string; };
226template <> struct sam_tag_type<"QT"_tag> { using type = std::string; };
227template <> struct sam_tag_type<"QX"_tag> { using type = std::string; };
228template <> struct sam_tag_type<"R2"_tag> { using type = std::string; };
229template <> struct sam_tag_type<"RG"_tag> { using type = std::string; };
230template <> struct sam_tag_type<"RT"_tag> { using type = std::string; };
231template <> struct sam_tag_type<"RX"_tag> { using type = std::string; };
232
233// template <> struct sam_tag_type<"S2"_tag> {};
234
235template <> struct sam_tag_type<"SA"_tag> { using type = std::string; };
236template <> struct sam_tag_type<"SM"_tag> { using type = int32_t; };
237
238// template <> struct sam_tag_type<"SQ"_tag> {};
239
240template <> struct sam_tag_type<"TC"_tag> { using type = int32_t; };
241template <> struct sam_tag_type<"U2"_tag> { using type = std::string; };
242template <> struct sam_tag_type<"UQ"_tag> { using type = int32_t; };
244// clang-format on
245
326class sam_tag_dictionary : public std::map<uint16_t, detail::sam_tag_variant>
327{
328private:
331
332public:
335
352 template <uint16_t tag>
353 requires (!std::same_as<sam_tag_type_t<tag>, variant_type>)
354 auto & get() &
355 {
356 if ((*this).count(tag) == 0)
357 (*this)[tag] = sam_tag_type_t<tag>{}; // set correct type if tag is not set yet on
358
359 return std::get<sam_tag_type_t<tag>>((*this)[tag]);
360 }
361
363 template <uint16_t tag>
364 requires (!std::same_as<sam_tag_type_t<tag>, variant_type>)
365 auto && get() &&
366 {
367 if ((*this).count(tag) == 0)
368 (*this)[tag] = sam_tag_type_t<tag>{}; // set correct type if tag is not set yet on
369
370 return std::get<sam_tag_type_t<tag>>(std::move((*this)[tag]));
371 }
372
375 template <uint16_t tag>
376 requires (!std::same_as<sam_tag_type_t<tag>, variant_type>)
377 auto const & get() const &
378 {
379 return std::get<sam_tag_type_t<tag>>((*this).at(tag));
380 }
381
384 template <uint16_t tag>
385 requires (!std::same_as<sam_tag_type_t<tag>, variant_type>)
386 auto const && get() const &&
387 {
388 return std::get<sam_tag_type_t<tag>>(std::move((*this).at(tag)));
389 }
391};
392
393} // namespace seqan3
The SAM tag dictionary class that stores all optional SAM fields.
Definition sam_tag_dictionary.hpp:327
detail::sam_tag_variant variant_type
The variant type defining all valid SAM tag field types.
Definition sam_tag_dictionary.hpp:334
auto && get() &&
Uses std::map::operator[] for access and default initializes new keys.
Definition sam_tag_dictionary.hpp:365
auto & get() &
Uses std::map::operator[] for access and default initializes new keys.
Definition sam_tag_dictionary.hpp:354
auto const && get() const &&
Uses std::map::at() for access and throws when the key is unknown.
Definition sam_tag_dictionary.hpp:386
auto const & get() const &
Uses std::map::at() for access and throws when the key is unknown.
Definition sam_tag_dictionary.hpp:377
constexpr auto is_alnum
Checks whether c is a alphanumeric character.
Definition predicate.hpp:194
constexpr auto is_alpha
Checks whether c is a alphabetical character.
Definition predicate.hpp:211
The main SeqAn3 namespace.
Definition aligned_sequence_concept.hpp:26
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:165
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:167
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:173
Provides type traits for working with templates.
Hide me