SeqAn3  3.1.0
The Modern C++ library for sequence analysis.
output.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 
15 #include <cassert>
16 #include <seqan3/std/filesystem>
17 #include <fstream>
18 #include <seqan3/std/ranges>
19 #include <string>
20 #include <string_view>
21 #include <variant>
22 #include <vector>
23 
26 #include <seqan3/io/detail/record.hpp>
28 #include <seqan3/io/exception.hpp>
29 #include <seqan3/io/record.hpp>
39 
40 namespace seqan3
41 {
42 
43 // ----------------------------------------------------------------------------
44 // sam_file_output
45 // ----------------------------------------------------------------------------
46 
60 template <detail::fields_specialisation selected_field_ids_ =
61  fields<field::seq,
62  field::id,
74  detail::type_list_of_sam_file_output_formats valid_formats_ = type_list<format_sam, format_bam>,
75  typename ref_ids_type = ref_info_not_given>
77 {
78 public:
84  using selected_field_ids = selected_field_ids_;
86  using valid_formats = valid_formats_;
88  using stream_char_type = char;
90 
93  field::id,
100  field::flag,
101  field::qual,
102  field::mate,
103  field::tags,
105 
106  static_assert([] () constexpr
107  {
108  for (field f : selected_field_ids::as_array)
109  if (!field_ids::contains(f))
110  return false;
111  return true;
112  }(),
113  "You selected a field that is not valid for alignment files, "
114  "please refer to the documentation of "
115  "seqan3::sam_file_output::field_ids for the accepted values.");
116 
123  using value_type = void;
125  using reference = void;
127  using const_reference = void;
129  using size_type = void;
133  using iterator = detail::out_file_iterator<sam_file_output>;
135  using const_iterator = void;
137  using sentinel = std::default_sentinel_t;
139 
144  sam_file_output() = delete;
146  sam_file_output(sam_file_output const &) = delete;
154  ~sam_file_output() = default;
155 
182  selected_field_ids const & SEQAN3_DOXYGEN_ONLY(fields_tag) = selected_field_ids{}) :
183  primary_stream{new std::ofstream{}, stream_deleter_default}
184  {
185  primary_stream->rdbuf()->pubsetbuf(stream_buffer.data(), stream_buffer.size());
186  static_cast<std::basic_ofstream<char> *>(primary_stream.get())->open(filename,
187  std::ios_base::out | std::ios::binary);
188 
189  // open stream
190  if (!primary_stream->good())
191  throw file_open_error{"Could not open file " + filename.string() + " for writing."};
192 
193  // possibly add intermediate compression stream
194  secondary_stream = detail::make_secondary_ostream(*primary_stream, filename);
195 
196  // initialise format handler or throw if format is not found
197  detail::set_format(format, filename);
198  }
199 
216  template <output_stream stream_type, sam_file_output_format file_format>
218  requires std::same_as<typename std::remove_reference_t<stream_type>::char_type, stream_char_type>
220  sam_file_output(stream_type & stream,
221  file_format const & SEQAN3_DOXYGEN_ONLY(format_tag),
222  selected_field_ids const & SEQAN3_DOXYGEN_ONLY(fields_tag) = selected_field_ids{}) :
223  primary_stream{&stream, stream_deleter_noop},
224  secondary_stream{&stream, stream_deleter_noop},
225  format{detail::sam_file_output_format_exposer<file_format>{}}
226  {
227  static_assert(list_traits::contains<file_format, valid_formats>,
228  "You selected a format that is not in the valid_formats of this file.");
229  }
230 
232  template <output_stream stream_type, sam_file_output_format file_format>
234  requires std::same_as<typename std::remove_reference_t<stream_type>::char_type, stream_char_type>
236  sam_file_output(stream_type && stream,
237  file_format const & SEQAN3_DOXYGEN_ONLY(format_tag),
238  selected_field_ids const & SEQAN3_DOXYGEN_ONLY(fields_tag) = selected_field_ids{}) :
239  primary_stream{new stream_type{std::move(stream)}, stream_deleter_default},
240  secondary_stream{&*primary_stream, stream_deleter_noop},
241  format{detail::sam_file_output_format_exposer<file_format>{}}
242  {
243  static_assert(list_traits::contains<file_format, valid_formats>,
244  "You selected a format that is not in the valid_formats of this file.");
245  }
246 
277  template <typename ref_ids_type_, std::ranges::forward_range ref_lengths_type>
279  requires std::same_as<std::remove_reference_t<ref_ids_type_>, ref_ids_type>
282  ref_ids_type_ && ref_ids,
283  ref_lengths_type && ref_lengths,
284  selected_field_ids const & SEQAN3_DOXYGEN_ONLY(fields_tag) = selected_field_ids{}) :
286 
287  {
288  initialise_header_information(ref_ids, ref_lengths);
289  }
290 
312  template <output_stream stream_type,
313  sam_file_output_format file_format,
314  typename ref_ids_type_, // generic type to capture lvalue references
315  std::ranges::forward_range ref_lengths_type>
317  requires std::same_as<std::remove_reference_t<ref_ids_type_>, ref_ids_type>
319  sam_file_output(stream_type && stream,
320  ref_ids_type_ && ref_ids,
321  ref_lengths_type && ref_lengths,
322  file_format const & SEQAN3_DOXYGEN_ONLY(format_tag),
323  selected_field_ids const & SEQAN3_DOXYGEN_ONLY(fields_tag) = selected_field_ids{}) :
324  sam_file_output{std::forward<stream_type>(stream), file_format{}, selected_field_ids{}}
325  {
326  initialise_header_information(ref_ids, ref_lengths);
327  }
329 
351  iterator begin() noexcept
352  {
353  return {*this};
354  }
355 
370  sentinel end() noexcept
371  {
372  return {};
373  }
374 
393  template <typename record_t>
394  void push_back(record_t && r)
396  requires detail::record_like<record_t>
398  {
399  using default_align_t = std::pair<std::span<gapped<char>>, std::span<gapped<char>>>;
400  using default_mate_t = std::tuple<std::string_view, std::optional<int32_t>, int32_t>;
401 
402  write_record(detail::get_or<field::header_ptr>(r, nullptr),
403  detail::get_or<field::seq>(r, std::string_view{}),
404  detail::get_or<field::qual>(r, std::string_view{}),
405  detail::get_or<field::id>(r, std::string_view{}),
406  detail::get_or<field::offset>(r, 0u),
407  detail::get_or<field::ref_seq>(r, std::string_view{}),
408  detail::get_or<field::ref_id>(r, std::ignore),
409  detail::get_or<field::ref_offset>(r, std::optional<int32_t>{}),
410  detail::get_or<field::alignment>(r, default_align_t{}),
411  detail::get_or<field::cigar>(r, std::vector<cigar>{}),
412  detail::get_or<field::flag>(r, sam_flag::none),
413  detail::get_or<field::mapq>(r, 0u),
414  detail::get_or<field::mate>(r, default_mate_t{}),
415  detail::get_or<field::tags>(r, sam_tag_dictionary{}),
416  detail::get_or<field::evalue>(r, 0u),
417  detail::get_or<field::bit_score>(r, 0u));
418  }
419 
441  template <typename tuple_t>
442  void push_back(tuple_t && t)
444  requires tuple_like<tuple_t> && (!detail::record_like<tuple_t>)
446  {
447  using default_align_t = std::pair<std::span<gapped<char>>, std::span<gapped<char>>>;
448  using default_mate_t = std::tuple<std::string_view, std::optional<int32_t>, int32_t>;
449 
450  // index_of might return npos, but this will be handled well by get_or_ignore (and just return ignore)
451  write_record(detail::get_or<selected_field_ids::index_of(field::header_ptr)>(t, nullptr),
452  detail::get_or<selected_field_ids::index_of(field::seq)>(t, std::string_view{}),
453  detail::get_or<selected_field_ids::index_of(field::qual)>(t, std::string_view{}),
454  detail::get_or<selected_field_ids::index_of(field::id)>(t, std::string_view{}),
455  detail::get_or<selected_field_ids::index_of(field::offset)>(t, 0u),
456  detail::get_or<selected_field_ids::index_of(field::ref_seq)>(t, std::string_view{}),
457  detail::get_or<selected_field_ids::index_of(field::ref_id)>(t, std::ignore),
458  detail::get_or<selected_field_ids::index_of(field::ref_offset)>(t, std::optional<int32_t>{}),
459  detail::get_or<selected_field_ids::index_of(field::alignment)>(t, default_align_t{}),
460  detail::get_or<selected_field_ids::index_of(field::cigar)>(t, std::vector<cigar>{}),
461  detail::get_or<selected_field_ids::index_of(field::flag)>(t, sam_flag::none),
462  detail::get_or<selected_field_ids::index_of(field::mapq)>(t, 0u),
463  detail::get_or<selected_field_ids::index_of(field::mate)>(t, default_mate_t{}),
464  detail::get_or<selected_field_ids::index_of(field::tags)>(t, sam_tag_dictionary{}),
465  detail::get_or<selected_field_ids::index_of(field::evalue)>(t, 0u),
466  detail::get_or<selected_field_ids::index_of(field::bit_score)>(t, 0u));
467  }
468 
492  template <typename arg_t, typename ...arg_types>
494  requires (sizeof...(arg_types) + 1 <= selected_field_ids::size)
496  void emplace_back(arg_t && arg, arg_types && ... args)
497  {
498  push_back(std::tie(arg, args...));
499  }
500 
522  template <typename rng_t>
523  sam_file_output & operator=(rng_t && range)
525  requires std::ranges::input_range<rng_t> && tuple_like<std::ranges::range_reference_t<rng_t>>
527  {
528  for (auto && record : range)
529  push_back(std::forward<decltype(record)>(record));
530  return *this;
531  }
532 
561  template <typename rng_t>
562  friend sam_file_output & operator|(rng_t && range, sam_file_output & f)
564  requires std::ranges::input_range<rng_t> && tuple_like<std::ranges::range_reference_t<rng_t>>
566  {
567  f = range;
568  return f;
569  }
570 
572  template <typename rng_t>
573  friend sam_file_output operator|(rng_t && range, sam_file_output && f)
575  requires std::ranges::input_range<rng_t> && tuple_like<std::ranges::range_reference_t<rng_t>>
577  {
578  f = range;
579  return std::move(f);
580  }
582 
585 
590  {
591  return *secondary_stream;
592  }
594 
605  auto & header()
606  {
607  if constexpr (std::same_as<ref_ids_type, ref_info_not_given>)
608  throw std::logic_error{"Please construct your file with reference id and length information in order "
609  "to properly initialise the header before accessing it."};
610 
611  return *header_ptr;
612  }
613 
614 protected:
617  std::vector<char> stream_buffer{std::vector<char>(1'000'000)};
618 
626  static void stream_deleter_noop(std::basic_ostream<stream_char_type> *) {}
628  static void stream_deleter_default(std::basic_ostream<stream_char_type> * ptr) { delete ptr; }
629 
631  stream_ptr_t primary_stream{nullptr, stream_deleter_noop};
633  stream_ptr_t secondary_stream{nullptr, stream_deleter_noop};
634 
636  using format_type = typename detail::variant_from_tags<valid_formats,
637  detail::sam_file_output_format_exposer>::type;
638 
640  format_type format;
642 
644  using header_type = sam_file_header<std::conditional_t<std::same_as<ref_ids_type, ref_info_not_given>,
646  ref_ids_type>>;
647 
649  std::unique_ptr<header_type> header_ptr;
650 
652  template <typename ref_ids_type_, typename ref_lengths_type>
653  void initialise_header_information(ref_ids_type_ && ref_ids, ref_lengths_type && ref_lengths)
654  {
655  assert(std::ranges::size(ref_ids) == std::ranges::size(ref_lengths));
656 
657  header_ptr = std::make_unique<sam_file_header<ref_ids_type>>(std::forward<ref_ids_type_>(ref_ids));
658 
659  for (int32_t idx = 0; idx < std::ranges::distance(ref_ids); ++idx)
660  {
661  header_ptr->ref_id_info.emplace_back(ref_lengths[idx], "");
662 
663  if constexpr (std::ranges::contiguous_range<std::ranges::range_reference_t<ref_ids_type_>> &&
664  std::ranges::sized_range<std::ranges::range_reference_t<ref_ids_type_>> &&
665  std::ranges::borrowed_range<std::ranges::range_reference_t<ref_ids_type_>>)
666  {
667  auto && id = header_ptr->ref_ids()[idx];
668  header_ptr->ref_dict[std::span{std::ranges::data(id), std::ranges::size(id)}] = idx;
669  }
670  else
671  {
672  header_ptr->ref_dict[header_ptr->ref_ids()[idx]] = idx;
673  }
674  }
675  }
676 
678  template <typename record_header_ptr_t, typename ...pack_type>
679  void write_record(record_header_ptr_t && record_header_ptr, pack_type && ...remainder)
680  {
681  static_assert((sizeof...(pack_type) == 15), "Wrong parameter list passed to write_record.");
682 
683  assert(!format.valueless_by_exception());
684 
685  std::visit([&] (auto & f)
686  {
687  // use header from record if explicitly given, e.g. file_output = file_input
688  if constexpr (!std::same_as<record_header_ptr_t, std::nullptr_t>)
689  {
690  f.write_alignment_record(*secondary_stream,
691  options,
692  *record_header_ptr,
693  std::forward<pack_type>(remainder)...);
694  }
695  else if constexpr (std::same_as<ref_ids_type, ref_info_not_given>)
696  {
697  f.write_alignment_record(*secondary_stream,
698  options,
699  std::ignore,
700  std::forward<pack_type>(remainder)...);
701  }
702  else
703  {
704  f.write_alignment_record(*secondary_stream,
705  options,
706  *header_ptr,
707  std::forward<pack_type>(remainder)...);
708  }
709  }, format);
710  }
711 
713  friend iterator;
714 };
715 
724 template <detail::fields_specialisation selected_field_ids>
727 
731 template <output_stream stream_type,
732  sam_file_output_format file_format,
733  detail::fields_specialisation selected_field_ids>
734 sam_file_output(stream_type &&, file_format const &, selected_field_ids const &)
736 
740 template <output_stream stream_type,
741  sam_file_output_format file_format,
742  detail::fields_specialisation selected_field_ids>
743 sam_file_output(stream_type &, file_format const &, selected_field_ids const &)
745 
749 template <output_stream stream_type,
750  sam_file_output_format file_format>
751 sam_file_output(stream_type &&, file_format const &)
753 
757 template <output_stream stream_type,
758  sam_file_output_format file_format>
759 sam_file_output(stream_type &, file_format const &)
761 
763 template <detail::fields_specialisation selected_field_ids,
764  std::ranges::forward_range ref_ids_type,
765  std::ranges::forward_range ref_lengths_type>
766 sam_file_output(std::filesystem::path const &, ref_ids_type &&, ref_lengths_type &&, selected_field_ids const &)
770 
772 template <std::ranges::forward_range ref_ids_type,
773  std::ranges::forward_range ref_lengths_type>
774 sam_file_output(std::filesystem::path const &, ref_ids_type &&, ref_lengths_type &&)
778 
780 template <output_stream stream_type,
781  std::ranges::forward_range ref_ids_type,
782  std::ranges::forward_range ref_lengths_type,
783  sam_file_output_format file_format,
784  detail::fields_specialisation selected_field_ids>
785 sam_file_output(stream_type &&, ref_ids_type &&, ref_lengths_type &&, file_format const &, selected_field_ids const &)
787 
789 template <output_stream stream_type,
790  std::ranges::forward_range ref_ids_type,
791  std::ranges::forward_range ref_lengths_type,
792  sam_file_output_format file_format,
793  detail::fields_specialisation selected_field_ids>
794 sam_file_output(stream_type &, ref_ids_type &&, ref_lengths_type &&, file_format const &, selected_field_ids const &)
796 
798 template <output_stream stream_type,
799  std::ranges::forward_range ref_ids_type,
800  std::ranges::forward_range ref_lengths_type,
801  sam_file_output_format file_format>
802 sam_file_output(stream_type &&, ref_ids_type &&, ref_lengths_type &&, file_format const &)
806 
808 template <output_stream stream_type,
809  std::ranges::forward_range ref_ids_type,
810  std::ranges::forward_range ref_lengths_type,
811  sam_file_output_format file_format>
812 sam_file_output(stream_type &, ref_ids_type &&, ref_lengths_type &&, file_format const &)
817 
818 } // namespace seqan3
A class for writing alignment files, e.g. SAM, BAL, BLAST, ...
Definition: output.hpp:77
void const_reference
The const reference type (void).
Definition: output.hpp:127
sam_file_output(stream_type &&stream, ref_ids_type_ &&ref_ids, ref_lengths_type &&ref_lengths, file_format const &format_tag, selected_field_ids const &fields_tag=selected_field_ids{})
Construct from an existing stream and with specified format.
Definition: output.hpp:319
sam_file_output(stream_type &, ref_ids_type &&, ref_lengths_type &&, file_format const &, selected_field_ids const &) -> sam_file_output< selected_field_ids, type_list< file_format >, std::remove_reference_t< ref_ids_type >>
Deduces selected_field_ids, the valid format, and the ref_ids_type from input.
void size_type
The size type (void).
Definition: output.hpp:129
sam_file_output(stream_type &&stream, file_format const &format_tag, selected_field_ids const &fields_tag=selected_field_ids{})
This is an overloaded member function, provided for convenience. It differs from the above function o...
Definition: output.hpp:236
sam_file_output(sam_file_output const &)=delete
Copy construction is explicitly deleted, because you can't have multiple access to the same file.
friend sam_file_output & operator|(rng_t &&range, sam_file_output &f)
Write a range of records (or tuples) to the file.
Definition: output.hpp:562
sam_file_output()=delete
Default constructor is explicitly deleted, you need to give a stream or file name.
detail::out_file_iterator< sam_file_output > iterator
The iterator type of this view (an output iterator).
Definition: output.hpp:133
sam_file_output & operator=(rng_t &&range)
Write a range of records (or tuples) to the file.
Definition: output.hpp:523
sam_file_output & operator=(sam_file_output const &)=delete
Copy assignment is explicitly deleted, because you can't have multiple access to the same file.
sam_file_output(std::filesystem::path const &, ref_ids_type &&, ref_lengths_type &&) -> sam_file_output< typename sam_file_output<>::selected_field_ids, typename sam_file_output<>::valid_formats, std::remove_reference_t< ref_ids_type >>
Deduces ref_ids_type from input. Valid formats, and selected_field_ids are set to the default.
auto & header()
Access the file's header.
Definition: output.hpp:605
std::default_sentinel_t sentinel
The type returned by end().
Definition: output.hpp:137
char stream_char_type
Character type of the stream(s).
Definition: output.hpp:88
sam_file_output(stream_type &stream, file_format const &format_tag, selected_field_ids const &fields_tag=selected_field_ids{})
Construct from an existing stream and with specified format.
Definition: output.hpp:220
iterator begin() noexcept
Returns an iterator to current position in the file.
Definition: output.hpp:351
sam_file_output(std::filesystem::path const &, ref_ids_type &&, ref_lengths_type &&, selected_field_ids const &) -> sam_file_output< selected_field_ids, typename sam_file_output<>::valid_formats, std::remove_reference_t< ref_ids_type >>
Deduces selected_field_ids and ref_ids_type from input. valid_formats is set to the default.
sentinel end() noexcept
Returns a sentinel for comparison with iterator.
Definition: output.hpp:370
sam_file_output(std::filesystem::path, selected_field_ids const &) -> sam_file_output< selected_field_ids, typename sam_file_output<>::valid_formats, ref_info_not_given >
Deduces selected_field_ids from input and sets sam_file_output::ref_ids_type to seqan3::detail::ref_i...
void emplace_back(arg_t &&arg, arg_types &&... args)
Write a record to the file by passing individual fields.
Definition: output.hpp:496
void push_back(record_t &&r)
Write a seqan3::record to the file.
Definition: output.hpp:394
selected_field_ids_ selected_field_ids
A seqan3::fields list with the fields selected for the record.
Definition: output.hpp:84
sam_file_output & operator=(sam_file_output &&)=default
Move assignment is defaulted.
valid_formats_ valid_formats
A seqan3::type_list with the possible formats.
Definition: output.hpp:86
void reference
The reference type (void).
Definition: output.hpp:125
sam_file_output(stream_type &, ref_ids_type &&, ref_lengths_type &&, file_format const &) -> sam_file_output< typename sam_file_output<>::selected_field_ids, type_list< file_format >, std::remove_reference_t< ref_ids_type >>
Deduces the valid format, and the ref_ids_type from input. selected_field_ids set to the default.
sam_file_output(stream_type &&, file_format const &) -> sam_file_output< typename sam_file_output<>::selected_field_ids, type_list< file_format >, ref_info_not_given >
Deduces the valid format from input and sets sam_file_output::ref_ids_type to seqan3::detail::ref_inf...
sam_file_output(std::filesystem::path filename, selected_field_ids const &fields_tag=selected_field_ids{})
Construct from filename.
Definition: output.hpp:181
sam_file_output(stream_type &&, ref_ids_type &&, ref_lengths_type &&, file_format const &) -> sam_file_output< typename sam_file_output<>::selected_field_ids, type_list< file_format >, std::remove_reference_t< ref_ids_type >>
Deduces the valid format, and the ref_ids_type from input. selected_field_ids set to the default.
void push_back(tuple_t &&t)
Write a record in form of a std::tuple to the file.
Definition: output.hpp:442
void value_type
The value type (void).
Definition: output.hpp:123
~sam_file_output()=default
Destructor is defaulted.
sam_file_output_options options
The options are public and its members can be set directly.
Definition: output.hpp:584
sam_file_output(stream_type &&, ref_ids_type &&, ref_lengths_type &&, file_format const &, selected_field_ids const &) -> sam_file_output< selected_field_ids, type_list< file_format >, std::remove_reference_t< ref_ids_type >>
Deduces selected_field_ids, the valid format, and the ref_ids_type from input.
sam_file_output(sam_file_output &&)=default
Move construction is defaulted.
sam_file_output(stream_type &, file_format const &, selected_field_ids const &) -> sam_file_output< selected_field_ids, type_list< file_format >, ref_info_not_given >
Deduces selected_field_ids, and the valid format from input and sets sam_file_output::ref_ids_type to...
sam_file_output(stream_type &&, file_format const &, selected_field_ids const &) -> sam_file_output< selected_field_ids, type_list< file_format >, ref_info_not_given >
Deduces selected_field_ids, and the valid format from input and sets sam_file_output::ref_ids_type to...
sam_file_output(std::filesystem::path const &filename, ref_ids_type_ &&ref_ids, ref_lengths_type &&ref_lengths, selected_field_ids const &fields_tag=selected_field_ids{})
Construct from filename.
Definition: output.hpp:281
friend sam_file_output operator|(rng_t &&range, sam_file_output &&f)
This is an overloaded member function, provided for convenience. It differs from the above function o...
Definition: output.hpp:573
void const_iterator
The const iterator type is void, because files are not const-iterable.
Definition: output.hpp:135
sam_file_output(stream_type &, file_format const &) -> sam_file_output< typename sam_file_output<>::selected_field_ids, type_list< file_format >, ref_info_not_given >
Deduces the valid format from input and sets sam_file_output::ref_ids_type to seqan3::detail::ref_inf...
The SAM tag dictionary class that stores all optional SAM fields.
Definition: sam_tag_dictionary.hpp:337
T data(T... args)
The <filesystem> header from C++17's standard library.
Provides the seqan3::format_bam.
Provides the seqan3::format_sam.
T forward(T... args)
T get(T... args)
@ none
None of the flags below are set.
field
An enumerator for the fields used in file formats.
Definition: record.hpp:63
@ flag
The alignment flag (bit information), uint16_t value.
@ ref_offset
Sequence (seqan3::field::ref_seq) relative start position (0-based), unsigned value.
@ ref_seq
The (reference) "sequence" information, usually a range of nucleotides or amino acids.
@ alignment
The (pairwise) alignment stored in an object that models seqan3::detail::pairwise_alignment.
@ cigar
The cigar vector (std::vector<seqan3::cigar>) representing the alignment in SAM/BAM format.
@ mapq
The mapping quality of the seqan3::field::seq alignment, usually a Phred-scaled score.
@ bit_score
The bit score (statistical significance indicator), unsigned value.
@ offset
Sequence (seqan3::field::seq) relative start position (0-based), unsigned value.
@ mate
The mate pair information given as a std::tuple of reference name, offset and template length.
@ header_ptr
A pointer to the seqan3::sam_file_header object storing header information.
@ ref_id
The identifier of the (reference) sequence that seqan3::field::seq was aligned to.
@ evalue
The e-value (length normalized bit score), double value.
@ id
The identifier, usually a string.
@ tags
The optional tags in the SAM format, stored in a dictionary.
@ seq
The "sequence", usually a range of nucleotides or amino acids.
@ qual
The qualities, usually in Phred score notation.
constexpr size_t size
The size of a type pack.
Definition: traits.hpp:151
Provides the seqan3::sam_file_header class.
The generic concept for alignment file out formats.
Whether a type behaves like a tuple.
Provides exceptions used in the I/O module.
Stream concepts.
Provides various utility functions required only for output.
The main SeqAn3 namespace.
Definition: aligned_sequence_concept.hpp:29
Provides the seqan3::detail::out_file_iterator class template.
The <ranges> header from C++20's standard library.
Provides the seqan3::record template and the seqan3::field enum.
Provides seqan3::detail::record_like.
Provides seqan3::sam_file_output_format and auxiliary classes.
Provides seqan3::sam_file_output_options.
Provides helper data structures for the seqan3::sam_file_output.
T size(T... args)
A class template that holds a choice of seqan3::field.
Definition: record.hpp:128
The class template that file records are based on; behaves like a std::tuple.
Definition: record.hpp:191
Type tag which indicates that no reference information has been passed to the alignment file on const...
Definition: sam_flag.hpp:24
The options type defines various option members that influence the behavior of all or some formats.
Definition: output_options.hpp:26
Type that contains multiple types.
Definition: type_list.hpp:29
T tie(T... args)
Provides traits for seqan3::type_list.
Provides seqan3::tuple_like.
T visit(T... args)