input.hpp

Go to the documentation of this file.

// -----------------------------------------------------------------------------------------------------
// Copyright (c) 2006-2019, Knut Reinert & Freie Universität Berlin
// Copyright (c) 2016-2019, Knut Reinert & MPI für molekulare Genetik
// This file may be used, modified and/or redistributed under the terms of the 3-clause BSD-License
// shipped with this file and also available at: https://github.com/seqan/seqan3/blob/master/LICENSE.md
// -----------------------------------------------------------------------------------------------------

#pragma once

#include <cassert>
#include <fstream>
#include <string>
#include <variant>
#include <vector>

#include <seqan3/alphabet/adaptation/char.hpp>
#include <seqan3/alphabet/aminoacid/aa27.hpp>
#include <seqan3/alphabet/nucleotide/all.hpp>
#include <seqan3/alphabet/quality/phred42.hpp>
#include <seqan3/alphabet/quality/qualified.hpp>
#include <seqan3/core/concept/tuple.hpp>
#include <seqan3/core/type_traits/basic.hpp>
#include <seqan3/core/type_traits/transformation_trait_or.hpp>
#include <seqan3/io/alignment_file/input_format_concept.hpp>
#include <seqan3/io/alignment_file/format_bam.hpp>
#include <seqan3/io/alignment_file/format_sam.hpp>
#include <seqan3/io/alignment_file/misc.hpp>
#include <seqan3/io/detail/in_file_iterator.hpp>
#include <seqan3/io/detail/misc_input.hpp>
#include <seqan3/io/detail/record.hpp>
#include <seqan3/io/exception.hpp>
#include <seqan3/io/record.hpp>
#include <seqan3/io/stream/concept.hpp>
#include <seqan3/range/container/concatenated_sequences.hpp>
#include <seqan3/range/decorator/gap_decorator.hpp>
#include <seqan3/range/view/repeat_n.hpp>
#include <seqan3/range/view/slice.hpp>
#include <seqan3/std/concepts>
#include <seqan3/std/filesystem>
#include <seqan3/std/ranges>

namespace seqan3
{

// ---------------------------------------------------------------------------------------------------------------------
// AlignmentFileInputTraits
// ---------------------------------------------------------------------------------------------------------------------

template <typename t>
SEQAN3_CONCEPT AlignmentFileInputTraits = requires (t v)
{
    // field::SEQ
    requires WritableAlphabet<typename t::sequence_alphabet>;
    requires WritableAlphabet<typename t::sequence_legal_alphabet>;
    requires ExplicitlyConvertibleTo<typename t::sequence_legal_alphabet, typename t::sequence_alphabet>;
    requires SequenceContainer<typename t::template sequence_container<typename t::sequence_alphabet>>;

    // field::ID
    requires WritableAlphabet<typename t::id_alphabet>;
    requires SequenceContainer<typename t::template id_container<typename t::id_alphabet>>;

    // field::QUAL
    requires WritableQualityAlphabet<typename t::quality_alphabet>;
    requires SequenceContainer<typename t::template quality_container<typename t::quality_alphabet>>;

    // field::REF_SEQ
    // either ref_info_not_given or a range over ranges over Alphabet (e.g. std::vector<dna4_vector>)
    requires std::Same<typename t::ref_sequences, ref_info_not_given> ||
         (std::ranges::ForwardRange<typename t::ref_sequences> &&
         std::ranges::ForwardRange<detail::transformation_trait_or_t<reference<typename t::ref_sequences>, dna4_vector>> &&
         Alphabet<reference_t<detail::transformation_trait_or_t<reference<typename t::ref_sequences>, dna4_vector>>>);

    // field::REF_ID
    requires Alphabet<reference_t<reference_t<typename t::ref_ids>>> &&
             (!std::Same<typename t::ref_sequences, ref_info_not_given> ||
              WritableAlphabet<reference_t<reference_t<typename t::ref_ids>>>);
    requires std::ranges::ForwardRange<reference_t<typename t::ref_ids>>;
    requires std::ranges::ForwardRange<typename t::ref_ids>;

    // field::OFFSET is fixed to int32_t
    // field::REF_OFFSET is fixed to std::optional<int32_t>
    // field::FLAG is fixed to uint16_t
    // field::MAPQ is fixed to uint8_t
    // field::EVALUE is fixed to double
    // field::BITSCORE is fixed to double
    // field::MATE is fixed to std::tuple<ref_id_container<ref_id_alphabet>, ref_offset_type, int32_t>

    // field::ALIGNMENT
    // the alignment type cannot be configured.
    // Type of tuple entry 1 (reference) is set to
    // 1) a std::ranges::subrange over value_type_t<typename t::ref_sequences> if reference information was given
    // or 2) a "dummy" sequence type:
    // view::repeat_n(sequence_alphabet{}, size_t{}) | std::view::transform(detail::access_restrictor_fn{})
    // Type of tuple entry 2 (query) is set to
    // 1) a std::ranges::subrange over value_type_t<typename t::ref_sequences> if reference information was given
    // or 2) a "dummy" sequence type:
};

// ---------------------------------------------------------------------------------------------------------------------
// alignment_file_input_default_traits
// ---------------------------------------------------------------------------------------------------------------------

template <typename ref_sequences_t = ref_info_not_given, typename ref_ids_t = std::deque<std::string>>
struct alignment_file_input_default_traits
{
    using sequence_alphabet                     = dna5;

    using sequence_legal_alphabet               = dna15;

    template <typename _sequence_alphabet>
    using sequence_container                    = std::vector<_sequence_alphabet>;

    using id_alphabet                           = char;

    template <typename _id_alphabet>
    using id_container                          = std::basic_string<_id_alphabet>;

    using quality_alphabet                      = phred42;

    template <typename _quality_alphabet>
    using quality_container                     = std::vector<_quality_alphabet>;

    using ref_sequences                         = ref_sequences_t;

    using ref_ids                               = ref_ids_t;
};

// ---------------------------------------------------------------------------------------------------------------------
// alignment_file_input
// ---------------------------------------------------------------------------------------------------------------------

template <
    AlignmentFileInputTraits                     traits_type_        = alignment_file_input_default_traits<>,
    detail::Fields                               selected_field_ids_ = fields<field::SEQ,
                                                                              field::ID,
                                                                              field::OFFSET,
                                                                              field::REF_SEQ,
                                                                              field::REF_ID,
                                                                              field::REF_OFFSET,
                                                                              field::ALIGNMENT,
                                                                              field::MAPQ,
                                                                              field::QUAL,
                                                                              field::FLAG,
                                                                              field::MATE,
                                                                              field::TAGS,
                                                                              field::EVALUE,
                                                                              field::BIT_SCORE,
                                                                              field::HEADER_PTR>,
    detail::TypeListOfAlignmentFileInputFormats  valid_formats_    = type_list<format_sam, format_bam>,
    std::Integral                                stream_char_type_ = char>
class alignment_file_input
{
public:
    using traits_type           = traits_type_;
    using selected_field_ids    = selected_field_ids_;
    using valid_formats         = valid_formats_;
    using stream_char_type      = stream_char_type_;

private:
    using dummy_ref_type = decltype(view::repeat_n(typename traits_type::sequence_alphabet{}, size_t{}) |
                                    std::view::transform(detail::access_restrictor_fn{}));
public:
    using sequence_type            = typename traits_type::template sequence_container<
                                         typename traits_type::sequence_alphabet>;
    using id_type                  = typename traits_type::template id_container<
                                         typename traits_type::id_alphabet>;
    using offset_type              = int32_t;
    using ref_sequence_type = std::conditional_t<std::Same<typename traits_type::ref_sequences, ref_info_not_given>,
                                                 dummy_ref_type,
                                                 decltype(std::declval<
                                                     detail::transformation_trait_or_t<
                                                        seqan3::reference<typename traits_type::ref_sequences const>,
                                                        dummy_ref_type> /* does not matter as type is not chosen */
                                                     >() | view::slice(0, 0))>;
    using ref_id_type              = std::optional<int32_t>;
    using ref_offset_type          = std::optional<int32_t>;
    using mapq_type                = uint8_t;
    using quality_type             = typename traits_type::template quality_container<
                                         typename traits_type::quality_alphabet>;
    using flag_type                = uint16_t;
    using mate_type                = std::tuple<ref_id_type, ref_offset_type, int32_t>;
    using e_value_type             = double;
    using bitscore_type            = double;
    using header_type              = alignment_file_header<typename traits_type::ref_ids>;

private:
    using alignment_query_type = std::conditional_t<
                                     selected_field_ids::contains(field::SEQ),
                                     gap_decorator<
                                         decltype(std::declval<sequence_type &>() | view::slice(0, 0))>,
                                     typename traits_type::template sequence_container<
                                         gapped<typename traits_type::sequence_alphabet>>>;

public:
    using alignment_type = std::tuple<gap_decorator<ref_sequence_type>, alignment_query_type>;

    using field_types = type_list<sequence_type,
                                  id_type,
                                  offset_type,
                                  ref_sequence_type,
                                  ref_id_type,
                                  ref_offset_type,
                                  alignment_type,
                                  mapq_type,
                                  quality_type,
                                  flag_type,
                                  mate_type,
                                  sam_tag_dictionary,
                                  e_value_type,
                                  bitscore_type,
                                  header_type *>;

    using field_ids = fields<field::SEQ,
                             field::ID,
                             field::OFFSET,
                             field::REF_SEQ,
                             field::REF_ID,
                             field::REF_OFFSET,
                             field::ALIGNMENT,
                             field::MAPQ,
                             field::QUAL,
                             field::FLAG,
                             field::MATE,
                             field::TAGS,
                             field::EVALUE,
                             field::BIT_SCORE,
                             field::HEADER_PTR>;

    static_assert([] () constexpr
                  {
                      for (field f : selected_field_ids::as_array)
                          if (!field_ids::contains(f))
                              return false;
                      return true;
                  }(),
                  "You selected a field that is not valid for aligment files, please refer to the documentation "
                  "of alignment_file_input::field_ids for the accepted values.");

    using record_type = record<detail::select_types_with_ids_t<field_types, field_ids, selected_field_ids>,
                               selected_field_ids>;

    using value_type        = record_type;
    using reference         = record_type &;
    using const_reference   = void;
    using size_type         = size_t;
    using difference_type   = std::make_signed_t<size_t>;
    using iterator          = detail::in_file_iterator<alignment_file_input>;
    using const_iterator    = void;
    using sentinel          = std::ranges::default_sentinel_t;

    alignment_file_input() = delete;
    alignment_file_input(alignment_file_input const &) = delete;
    alignment_file_input & operator=(alignment_file_input const &) = delete;
    alignment_file_input(alignment_file_input &&) = default;
    alignment_file_input & operator=(alignment_file_input &&) = default;
    ~alignment_file_input() = default;

    alignment_file_input(std::filesystem::path filename,
                         selected_field_ids const & SEQAN3_DOXYGEN_ONLY(fields_tag) = selected_field_ids{}) :
        primary_stream{new std::ifstream{filename, std::ios_base::in | std::ios::binary}, stream_deleter_default}
    {
        init(filename);
    }

    template <IStream2 stream_t, AlignmentFileInputFormat file_format>
    alignment_file_input(stream_t                 & stream,
                         file_format        const & SEQAN3_DOXYGEN_ONLY(format_tag),
                         selected_field_ids const & SEQAN3_DOXYGEN_ONLY(fields_tag) = selected_field_ids{}) :
        primary_stream{&stream, stream_deleter_noop}
    {
        init(file_format{});
    }

    template <IStream2 stream_t, AlignmentFileInputFormat file_format>
    alignment_file_input(stream_t                && stream,
                         file_format        const & SEQAN3_DOXYGEN_ONLY(format_tag),
                         selected_field_ids const & SEQAN3_DOXYGEN_ONLY(fields_tag) = selected_field_ids{}) :
        primary_stream{new stream_t{std::move(stream)}, stream_deleter_default}
    {
        init(file_format{});
    }

    alignment_file_input(std::filesystem::path filename,
                         typename traits_type::ref_ids & ref_ids,
                         typename traits_type::ref_sequences & ref_sequences,
                         selected_field_ids const & SEQAN3_DOXYGEN_ONLY(fields_tag) = selected_field_ids{}) :
        primary_stream{new std::ifstream{filename, std::ios_base::in | std::ios::binary}, stream_deleter_default}
    {
        // initialize reference information
        set_references(ref_ids, ref_sequences);

        init(filename);
    }

    template <IStream2 stream_t, AlignmentFileInputFormat file_format>
    alignment_file_input(stream_t & stream,
                         typename traits_type::ref_ids & ref_ids,
                         typename traits_type::ref_sequences & ref_sequences,
                         file_format const & SEQAN3_DOXYGEN_ONLY(format_tag),
                         selected_field_ids const & SEQAN3_DOXYGEN_ONLY(fields_tag) = selected_field_ids{}) :
        primary_stream{&stream, stream_deleter_noop}
    {
        // initialize reference information
        set_references(ref_ids, ref_sequences);

        init(file_format{});
    }

    template <IStream2 stream_t, AlignmentFileInputFormat file_format>
    alignment_file_input(stream_t && stream,
                         typename traits_type::ref_ids & ref_ids,
                         typename traits_type::ref_sequences & ref_sequences,
                         file_format const & SEQAN3_DOXYGEN_ONLY(format_tag),
                         selected_field_ids const & SEQAN3_DOXYGEN_ONLY(fields_tag) = selected_field_ids{}) :
        primary_stream{new stream_t{std::move(stream)}, stream_deleter_default}
    {
        // initialize reference information
        set_references(ref_ids, ref_sequences);

        init(file_format{});
    }

    // explicitly delete rvalues for reference information
    alignment_file_input(std::filesystem::path,
                         typename traits_type::ref_ids &&,
                         typename traits_type::ref_sequences &&,
                         selected_field_ids const &) = delete;

    template <IStream2 stream_t, AlignmentFileInputFormat file_format>
    alignment_file_input(stream_t &&,
                         typename traits_type::ref_ids &&,
                         typename traits_type::ref_sequences &&,
                         file_format const &,
                         selected_field_ids const &) = delete;

    iterator begin() noexcept
    {
        return {*this};
    }

    sentinel end() noexcept
    {
        return {};
    }

    reference front() noexcept
    {
        return record_buffer;
    }

    alignment_file_input_options<typename traits_type::sequence_legal_alphabet> options;

    header_type & header()
    {
        return *header_ptr;
    }

protected:

    void init(std::filesystem::path & filename)
    {
        // open stream
        if (!primary_stream->good())
            throw file_open_error{"Could not open file " + filename.string() + " for reading."};

        secondary_stream = detail::make_secondary_istream(*primary_stream, filename);
        detail::set_format(format, filename);

        // buffer first record
        read_next_record();
    }

    template <typename format_type>
    void init(format_type const &)
    {
        static_assert(meta::in<valid_formats, format_type>::value,
                      "You selected a format that is not in the valid_formats of this file.");

        format = detail::alignment_file_input_format<format_type>{};
        secondary_stream = detail::make_secondary_istream(*primary_stream);

        // buffer first record
        read_next_record();
    }

    std::unique_ptr<header_type> header_ptr{new header_type{}};

    record_type record_buffer;

    using stream_ptr_t = std::unique_ptr<std::basic_istream<stream_char_type>,
                                         std::function<void(std::basic_istream<stream_char_type>*)>>;
    static void stream_deleter_noop(std::basic_istream<stream_char_type> *) {}
    static void stream_deleter_default(std::basic_istream<stream_char_type> * ptr) { delete ptr; }

    stream_ptr_t primary_stream{nullptr, stream_deleter_noop};
    stream_ptr_t secondary_stream{nullptr, stream_deleter_noop};

    bool at_end{false};

    using format_type = typename detail::variant_from_tags<valid_formats, detail::alignment_file_input_format>::type;

    format_type format;

    typename traits_type::ref_sequences const * reference_sequences_ptr{nullptr};

    template <std::ranges::ForwardRange ref_sequences_t>
    void set_references(typename traits_type::ref_ids & ref_ids, ref_sequences_t && ref_sequences)
    {
        assert(std::ranges::size(ref_ids) == std::ranges::size(ref_sequences));

        header_ptr = std::unique_ptr<header_type>{std::make_unique<header_type>(ref_ids)};
        reference_sequences_ptr = &ref_sequences;

        // initialise reference map and ref_dict if ref_ids are non-empty
        for (size_t idx = 0; idx < ref_ids.size(); ++idx)
        {
            header_ptr->ref_id_info.emplace_back(std::ranges::size(ref_sequences[idx]), "");
            header_ptr->ref_dict[header_ptr->ref_ids()[idx]] = idx;
        }
    }

    void read_next_record()
    {
        // clear the record
        record_buffer.clear();
        detail::get_or_ignore<field::HEADER_PTR>(record_buffer) = header_ptr.get();

        // at end if we could not read further
        if (std::istreambuf_iterator<stream_char_type>{*secondary_stream} ==
            std::istreambuf_iterator<stream_char_type>{})
        {
            at_end = true;
            return;
        }

        auto call_read_func = [this] (auto & ref_seq_info)
        {
            std::visit([&] (auto & f)
            {
                f.read(*secondary_stream,
                       options,
                       ref_seq_info,
                       *header_ptr,
                       detail::get_or_ignore<field::SEQ>(record_buffer),
                       detail::get_or_ignore<field::QUAL>(record_buffer),
                       detail::get_or_ignore<field::ID>(record_buffer),
                       detail::get_or_ignore<field::OFFSET>(record_buffer),
                       detail::get_or_ignore<field::REF_SEQ>(record_buffer),
                       detail::get_or_ignore<field::REF_ID>(record_buffer),
                       detail::get_or_ignore<field::REF_OFFSET>(record_buffer),
                       detail::get_or_ignore<field::ALIGNMENT>(record_buffer),
                       detail::get_or_ignore<field::FLAG>(record_buffer),
                       detail::get_or_ignore<field::MAPQ>(record_buffer),
                       detail::get_or_ignore<field::MATE>(record_buffer),
                       detail::get_or_ignore<field::TAGS>(record_buffer),
                       detail::get_or_ignore<field::EVALUE>(record_buffer),
                       detail::get_or_ignore<field::BIT_SCORE>(record_buffer));

            }, format);
        };

        assert(!format.valueless_by_exception());

        if constexpr (!std::Same<typename traits_type::ref_sequences, ref_info_not_given>)
            call_read_func(*reference_sequences_ptr);
        else
            call_read_func(std::ignore);
    }

    friend iterator;
};

template <IStream2                 stream_type,
          AlignmentFileInputFormat file_format,
          detail::Fields           selected_field_ids>
alignment_file_input(stream_type && stream,
                     file_format const &,
                     selected_field_ids const &)
    -> alignment_file_input<typename alignment_file_input<>::traits_type,       // actually use the default
                            selected_field_ids,
                            type_list<file_format>,
                            typename std::remove_reference_t<stream_type>::char_type>;

template <IStream2                 stream_type,
          AlignmentFileInputFormat file_format,
          detail::Fields           selected_field_ids>
alignment_file_input(stream_type & stream,
                     file_format const &,
                     selected_field_ids const &)
    -> alignment_file_input<typename alignment_file_input<>::traits_type,       // actually use the default
                            selected_field_ids,
                            type_list<file_format>,
                            typename std::remove_reference_t<stream_type>::char_type>;

template <IStream2                 stream_type,
          AlignmentFileInputFormat file_format>
alignment_file_input(stream_type && stream,
                     file_format const &)
    -> alignment_file_input<typename alignment_file_input<>::traits_type,        // actually use the default
                            typename alignment_file_input<>::selected_field_ids, // actually use the default
                            type_list<file_format>,
                            typename std::remove_reference_t<stream_type>::char_type>;

template <IStream2                 stream_type,
          AlignmentFileInputFormat file_format>
alignment_file_input(stream_type & stream,
                     file_format const &)
    -> alignment_file_input<typename alignment_file_input<>::traits_type,        // actually use the default
                            typename alignment_file_input<>::selected_field_ids, // actually use the default
                            type_list<file_format>,
                            typename std::remove_reference_t<stream_type>::char_type>;

template <std::ranges::ForwardRange           ref_ids_t,
          std::ranges::ForwardRange           ref_sequences_t,
          detail::Fields                      selected_field_ids>
alignment_file_input(std::filesystem::path path,
                     ref_ids_t &,
                     ref_sequences_t &,
                     selected_field_ids const &)
    -> alignment_file_input<alignment_file_input_default_traits<std::remove_reference_t<ref_sequences_t>,
                                                                std::remove_reference_t<ref_ids_t>>,
                            selected_field_ids,
                            typename alignment_file_input<>::valid_formats,      // actually use the default
                            typename alignment_file_input<>::stream_char_type>;  // actually use the default

template <std::ranges::ForwardRange ref_ids_t,
          std::ranges::ForwardRange ref_sequences_t>
alignment_file_input(std::filesystem::path path,
                     ref_ids_t &,
                     ref_sequences_t &)
    -> alignment_file_input<alignment_file_input_default_traits<std::remove_reference_t<ref_sequences_t>,
                                                                std::remove_reference_t<ref_ids_t>>,
                            typename alignment_file_input<>::selected_field_ids, // actually use the default
                            typename alignment_file_input<>::valid_formats,      // actually use the default
                            typename alignment_file_input<>::stream_char_type>;  // actually use the default

template <IStream2                  stream_type,
          std::ranges::ForwardRange ref_ids_t,
          std::ranges::ForwardRange ref_sequences_t,
          AlignmentFileInputFormat  file_format,
          detail::Fields            selected_field_ids>
alignment_file_input(stream_type && stream,
                     ref_ids_t &,
                     ref_sequences_t &,
                     file_format const &,
                     selected_field_ids const &)
    -> alignment_file_input<alignment_file_input_default_traits<std::remove_reference_t<ref_sequences_t>,
                                                                std::remove_reference_t<ref_ids_t>>,
                            selected_field_ids,
                            type_list<file_format>,
                            typename std::remove_reference_t<stream_type>::char_type>;

template <IStream2                  stream_type,
          std::ranges::ForwardRange ref_ids_t,
          std::ranges::ForwardRange ref_sequences_t,
          AlignmentFileInputFormat  file_format,
          detail::Fields            selected_field_ids>
alignment_file_input(stream_type & stream,
                     ref_ids_t &,
                     ref_sequences_t &,
                     file_format const &,
                     selected_field_ids const &)
    -> alignment_file_input<alignment_file_input_default_traits<std::remove_reference_t<ref_sequences_t>,
                                                                std::remove_reference_t<ref_ids_t>>,
                            selected_field_ids,
                            type_list<file_format>,
                            typename std::remove_reference_t<stream_type>::char_type>;

template <IStream2                  stream_type,
          std::ranges::ForwardRange ref_ids_t,
          std::ranges::ForwardRange ref_sequences_t,
          AlignmentFileInputFormat  file_format>
alignment_file_input(stream_type && stream,
                     ref_ids_t &,
                     ref_sequences_t &,
                     file_format const &)
    -> alignment_file_input<alignment_file_input_default_traits<std::remove_reference_t<ref_sequences_t>,
                                                                std::remove_reference_t<ref_ids_t>>,
                            typename alignment_file_input<>::selected_field_ids, // actually use the default
                            type_list<file_format>,
                            typename std::remove_reference_t<stream_type>::char_type>;

template <IStream2                  stream_type,
          std::ranges::ForwardRange ref_ids_t,
          std::ranges::ForwardRange ref_sequences_t,
          AlignmentFileInputFormat  file_format>
alignment_file_input(stream_type & stream,
                     ref_ids_t &,
                     ref_sequences_t &,
                     file_format const &)
    -> alignment_file_input<alignment_file_input_default_traits<std::remove_reference_t<ref_sequences_t>,
                                                                std::remove_reference_t<ref_ids_t>>,
                            typename alignment_file_input<>::selected_field_ids, // actually use the default
                            type_list<file_format>,
                            typename std::remove_reference_t<stream_type>::char_type>;

} // namespace seqan3

// ------------------------------------------------------------------
// std-overloads for the tuple-like interface
// ------------------------------------------------------------------

namespace std
{

template <seqan3::AlignmentFileInputTraits                    traits_type,
          seqan3::detail::Fields                              selected_field_ids,
          seqan3::detail::TypeListOfAlignmentFileInputFormats valid_formats,
          std::Integral                                       stream_char_t>
struct tuple_size<seqan3::alignment_file_input<traits_type, selected_field_ids, valid_formats, stream_char_t>>
{
    static constexpr size_t value = selected_field_ids::as_array.size();
};

template <size_t                                              elem_no,
          seqan3::AlignmentFileInputTraits                    traits_type,
          seqan3::detail::Fields                              selected_field_ids,
          seqan3::detail::TypeListOfAlignmentFileInputFormats valid_formats,
          std::Integral                                       stream_char_t>
struct tuple_element<elem_no, seqan3::alignment_file_input<traits_type, selected_field_ids, valid_formats, stream_char_t>>
    : tuple_element<elem_no, typename seqan3::alignment_file_input<traits_type,
                                                               selected_field_ids,
                                                               valid_formats,
                                                               stream_char_t>::file_as_tuple_type>
{};

} // namespace std