output.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 <string_view>
#include <variant>
#include <vector>

#include <seqan3/core/concept/tuple.hpp>
#include <seqan3/core/type_traits/basic.hpp>
#include <seqan3/core/type_traits/template_inspection.hpp>
#include <seqan3/io/alignment_file/format_bam.hpp>
#include <seqan3/io/alignment_file/format_sam.hpp>
#include <seqan3/io/alignment_file/header.hpp>
#include <seqan3/io/alignment_file/misc.hpp>
#include <seqan3/io/alignment_file/output_format_concept.hpp>
#include <seqan3/io/alignment_file/output_options.hpp>
#include <seqan3/io/detail/out_file_iterator.hpp>
#include <seqan3/io/detail/misc_output.hpp>
#include <seqan3/io/detail/record.hpp>
#include <seqan3/io/exception.hpp>
#include <seqan3/std/filesystem>
#include <seqan3/io/record.hpp>
#include <seqan3/io/stream/concept.hpp>
#include <seqan3/std/ranges>

namespace seqan3
{

// ----------------------------------------------------------------------------
// alignment_file_output
// ----------------------------------------------------------------------------

template <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::TypeListOfAlignmentFileOutputFormats valid_formats_ = type_list<format_sam, format_bam>,
          Char stream_char_type_ = char,
          typename ref_ids_type = ref_info_not_given>
class alignment_file_output
{
public:
    using selected_field_ids    = selected_field_ids_;
    using valid_formats         = valid_formats_;
    using stream_char_type      = stream_char_type_;

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

    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 alignment files, "
                  "please refer to the documentation of "
                  "seqan3::alignment_file_output::field_ids for the accepted values.");

    using value_type        = void;
    using reference         = void;
    using const_reference   = void;
    using size_type         = void;
    using difference_type   = std::ptrdiff_t;
    using iterator          = detail::out_file_iterator<alignment_file_output>;
    using const_iterator    = void;
    using sentinel          = std::ranges::default_sentinel_t;

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

    alignment_file_output(std::filesystem::path filename,
                          selected_field_ids const & SEQAN3_DOXYGEN_ONLY(fields_tag) = selected_field_ids{}) :
        primary_stream{new std::ofstream{filename, std::ios_base::out | std::ios::binary}, stream_deleter_default}
    {
        // open stream
        if (!primary_stream->good())
            throw file_open_error{"Could not open file " + filename.string() + " for writing."};

        // possibly add intermediate compression stream
        secondary_stream = detail::make_secondary_ostream(*primary_stream, filename);

        // initialise format handler or throw if format is not found
        detail::set_format(format, filename);
    }

    template <OStream2 stream_type, AlignmentFileOutputFormat file_format>
    alignment_file_output(stream_type              & 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},
        secondary_stream{&stream, stream_deleter_noop},
        format{detail::alignment_file_output_format<file_format>{}}
    {
        static_assert(meta::in<valid_formats, file_format>::value,
                      "You selected a format that is not in the valid_formats of this file.");
    }

    template <OStream2 stream_type, AlignmentFileOutputFormat file_format>
    alignment_file_output(stream_type             && 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_type{std::move(stream)}, stream_deleter_default},
        secondary_stream{&*primary_stream, stream_deleter_noop},
        format{detail::alignment_file_output_format<file_format>{}}
    {
        static_assert(meta::in<valid_formats, file_format>::value,
                      "You selected a format that is not in the valid_formats of this file.");
    }

    template <typename ref_ids_type_, std::ranges::ForwardRange ref_lengths_type>
        requires std::Same<std::remove_reference_t<ref_ids_type_>, ref_ids_type>
    alignment_file_output(std::filesystem::path const & filename,
                          ref_ids_type_              && ref_ids,
                          ref_lengths_type           && ref_lengths,
                          selected_field_ids    const & SEQAN3_DOXYGEN_ONLY(fields_tag) = selected_field_ids{}) :
        alignment_file_output{filename, selected_field_ids{}}

    {
        assert(std::ranges::size(ref_ids) == std::ranges::size(ref_lengths));

        header_ptr = std::make_unique<alignment_file_header<ref_ids_type>>(std::forward<ref_ids_type_>(ref_ids));

        // fill ref_dict
        for (size_t idx = 0; idx < std::ranges::size(ref_ids); ++idx)
        {
            header_ptr->ref_id_info.push_back({ref_lengths[idx], ""});
            header_ptr->ref_dict[(header_ptr->ref_ids()[idx])] = idx;
        }
    }

    template <OStream2 stream_type,
              AlignmentFileOutputFormat file_format,
              typename ref_ids_type_, // generic type to capture lvalue references
              std::ranges::ForwardRange ref_lengths_type>
        requires std::Same<std::remove_reference_t<ref_ids_type_>, ref_ids_type>
    alignment_file_output(stream_type             && stream,
                          ref_ids_type_           && ref_ids,
                          ref_lengths_type        && ref_lengths,
                          file_format        const & SEQAN3_DOXYGEN_ONLY(format_tag),
                          selected_field_ids const & SEQAN3_DOXYGEN_ONLY(fields_tag) = selected_field_ids{}) :
        alignment_file_output{std::forward<stream_type>(stream), file_format{}, selected_field_ids{}}
    {
        assert(std::ranges::size(ref_ids) == std::ranges::size(ref_lengths));

        header_ptr = std::make_unique<alignment_file_header<ref_ids_type>>(std::forward<ref_ids_type_>(ref_ids));

        // fill ref_dict
        for (uint32_t idx = 0; idx < std::ranges::size(ref_ids); ++idx)
        {
            header_ptr->ref_id_info.emplace_back(ref_lengths[idx], "");
            header_ptr->ref_dict[header_ptr->ref_ids()[idx]] = idx;
        }
    }

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

    sentinel end() noexcept
    {
        return {};
    }

    template <typename record_t>
    void push_back(record_t && r)
        requires TupleLike<record_t> &&
                 requires { requires detail::is_type_specialisation_of_v<remove_cvref_t<record_t>, record>; }
    {
        using default_align_t = std::pair<std::span<gapped<char>>, std::span<gapped<char>>>;
        using default_mate_t  = std::tuple<std::string_view, std::optional<int32_t>, int32_t>;

        write_record(detail::get_or<field::HEADER_PTR>(r, nullptr),
                     detail::get_or<field::SEQ>(r, std::string_view{}),
                     detail::get_or<field::QUAL>(r, std::string_view{}),
                     detail::get_or<field::ID>(r, std::string_view{}),
                     detail::get_or<field::OFFSET>(r, 0u),
                     detail::get_or<field::REF_SEQ>(r, std::string_view{}),
                     detail::get_or<field::REF_ID>(r, std::ignore),
                     detail::get_or<field::REF_OFFSET>(r, std::optional<int32_t>{}),
                     detail::get_or<field::ALIGNMENT>(r, default_align_t{}),
                     detail::get_or<field::FLAG>(r, 0u),
                     detail::get_or<field::MAPQ>(r, 0u),
                     detail::get_or<field::MATE>(r, default_mate_t{}),
                     detail::get_or<field::TAGS>(r, sam_tag_dictionary{}),
                     detail::get_or<field::EVALUE>(r, 0u),
                     detail::get_or<field::BIT_SCORE>(r, 0u));
    }

    template <typename tuple_t>
    void push_back(tuple_t && t)
        requires TupleLike<tuple_t>
    {
        using default_align_t = std::pair<std::span<gapped<char>>, std::span<gapped<char>>>;
        using default_mate_t  = std::tuple<std::string_view, std::optional<int32_t>, int32_t>;

        // index_of might return npos, but this will be handled well by get_or_ignore (and just return ignore)
        write_record(detail::get_or<selected_field_ids::index_of(field::HEADER_PTR)>(t, nullptr),
                     detail::get_or<selected_field_ids::index_of(field::SEQ)>(t, std::string_view{}),
                     detail::get_or<selected_field_ids::index_of(field::QUAL)>(t, std::string_view{}),
                     detail::get_or<selected_field_ids::index_of(field::ID)>(t, std::string_view{}),
                     detail::get_or<selected_field_ids::index_of(field::OFFSET)>(t, 0u),
                     detail::get_or<selected_field_ids::index_of(field::REF_SEQ)>(t, std::string_view{}),
                     detail::get_or<selected_field_ids::index_of(field::REF_ID)>(t, std::ignore),
                     detail::get_or<selected_field_ids::index_of(field::REF_OFFSET)>(t, std::optional<int32_t>{}),
                     detail::get_or<selected_field_ids::index_of(field::ALIGNMENT)>(t, default_align_t{}),
                     detail::get_or<selected_field_ids::index_of(field::FLAG)>(t, 0u),
                     detail::get_or<selected_field_ids::index_of(field::MAPQ)>(t, 0u),
                     detail::get_or<selected_field_ids::index_of(field::MATE)>(t, default_mate_t{}),
                     detail::get_or<selected_field_ids::index_of(field::TAGS)>(t, sam_tag_dictionary{}),
                     detail::get_or<selected_field_ids::index_of(field::EVALUE)>(t, 0u),
                     detail::get_or<selected_field_ids::index_of(field::BIT_SCORE)>(t, 0u));
    }

    template <typename arg_t, typename ... arg_types>
    void emplace_back(arg_t && arg, arg_types && ... args)
    {
        push_back(std::tie(arg, args...));
    }

    template <typename rng_t>
    alignment_file_output & operator=(rng_t && range)
        requires std::ranges::InputRange<rng_t> && TupleLike<reference_t<rng_t>>
    {
        for (auto && record : range)
            push_back(std::forward<decltype(record)>(record));
        return *this;
    }

    template <typename rng_t>
    friend alignment_file_output & operator|(rng_t && range, alignment_file_output & f)
        requires std::ranges::InputRange<rng_t> && TupleLike<reference_t<rng_t>>
    {
        f = range;
        return f;
    }

    template <typename rng_t>
    friend alignment_file_output operator|(rng_t && range, alignment_file_output && f)
        requires std::ranges::InputRange<rng_t> && TupleLike<reference_t<rng_t>>
    {
        f = range;
        return std::move(f);
    }

    alignment_file_output_options options;

    std::basic_ostream<stream_char_type> & get_stream()
    {
        return *secondary_stream;
    }

    auto & header()
    {
        if constexpr (std::Same<ref_ids_type, ref_info_not_given>)
            throw std::logic_error{"Please construct your file with reference id and length information in order "
                                   "to properly initialise the header before accessing it."};

        return *header_ptr;
    }

protected:

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

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

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

    format_type format;

    using header_type = alignment_file_header<std::conditional_t<std::Same<ref_ids_type, ref_info_not_given>,
                                              std::vector<std::string>,
                                              ref_ids_type>>;

    std::unique_ptr<header_type> header_ptr;

    template <typename record_header_ptr_t, typename ...pack_type>
    void write_record(record_header_ptr_t && record_header_ptr, pack_type && ...remainder)
    {
        static_assert((sizeof...(pack_type) == 14), "Wrong parameter list passed to write_record.");

        assert(!format.valueless_by_exception());

        std::visit([&] (auto & f)
        {
            // use header from record if explicitly given, e.g. file_output = file_input
            if constexpr (!std::Same<record_header_ptr_t, std::nullptr_t>)
                f.write(*secondary_stream, options, *record_header_ptr, std::forward<pack_type>(remainder)...);
            else if constexpr (std::Same<ref_ids_type, ref_info_not_given>)
                f.write(*secondary_stream, options, std::ignore, std::forward<pack_type>(remainder)...);
            else
                f.write(*secondary_stream, options, *header_ptr, std::forward<pack_type>(remainder)...);
        }, format);
    }

    friend iterator;
};

template <detail::Fields    selected_field_ids>
alignment_file_output(std::filesystem::path, selected_field_ids const &)
    -> alignment_file_output<selected_field_ids,
                             typename alignment_file_output<>::valid_formats,
                             typename alignment_file_output<>::stream_char_type,
                             ref_info_not_given>;

template <OStream2                  stream_type,
          AlignmentFileOutputFormat file_format,
          detail::Fields            selected_field_ids>
alignment_file_output(stream_type &&, file_format const &, selected_field_ids const &)
    -> alignment_file_output<selected_field_ids,
                             type_list<file_format>,
                             typename std::remove_reference_t<stream_type>::char_type,
                             ref_info_not_given>;

template <OStream2                  stream_type,
          AlignmentFileOutputFormat file_format,
          detail::Fields            selected_field_ids>
alignment_file_output(stream_type &, file_format const &, selected_field_ids const &)
    -> alignment_file_output<selected_field_ids,
                             type_list<file_format>,
                             typename std::remove_reference_t<stream_type>::char_type,
                             ref_info_not_given>;

template <OStream2                  stream_type,
          AlignmentFileOutputFormat file_format>
alignment_file_output(stream_type &&, file_format const &)
    -> alignment_file_output<typename alignment_file_output<>::selected_field_ids,
                             type_list<file_format>,
                             typename std::remove_reference_t<stream_type>::char_type,
                             ref_info_not_given>;

template <OStream2                  stream_type,
          AlignmentFileOutputFormat file_format>
alignment_file_output(stream_type &, file_format const &)
    -> alignment_file_output<typename alignment_file_output<>::selected_field_ids,
                             type_list<file_format>,
                             typename std::remove_reference_t<stream_type>::char_type,
                             ref_info_not_given>;

template <detail::Fields    selected_field_ids,
          std::ranges::ForwardRange ref_ids_type,
          std::ranges::ForwardRange ref_lengths_type>
alignment_file_output(std::filesystem::path const &,
                      ref_ids_type &&,
                      ref_lengths_type &&,
                      selected_field_ids const &)
    -> alignment_file_output<selected_field_ids,
                             typename alignment_file_output<>::valid_formats,
                             typename alignment_file_output<>::stream_char_type,
                             std::remove_reference_t<ref_ids_type>>;

template <std::ranges::ForwardRange ref_ids_type,
          std::ranges::ForwardRange ref_lengths_type>
alignment_file_output(std::filesystem::path const &,
                      ref_ids_type &&,
                      ref_lengths_type &&)
    -> alignment_file_output<typename alignment_file_output<>::selected_field_ids,
                             typename alignment_file_output<>::valid_formats,
                             typename alignment_file_output<>::stream_char_type,
                             std::remove_reference_t<ref_ids_type>>;

template <OStream2                  stream_type,
          std::ranges::ForwardRange ref_ids_type,
          std::ranges::ForwardRange ref_lengths_type,
          AlignmentFileOutputFormat file_format,
          detail::Fields            selected_field_ids>
alignment_file_output(stream_type &&,
                      ref_ids_type &&,
                      ref_lengths_type &&,
                      file_format const &,
                      selected_field_ids const &)
    -> alignment_file_output<selected_field_ids,
                             type_list<file_format>,
                             typename std::remove_reference_t<stream_type>::char_type,
                             std::remove_reference_t<ref_ids_type>>;

template <OStream2                  stream_type,
          std::ranges::ForwardRange ref_ids_type,
          std::ranges::ForwardRange ref_lengths_type,
          AlignmentFileOutputFormat file_format,
          detail::Fields            selected_field_ids>
alignment_file_output(stream_type &,
                      ref_ids_type &&,
                      ref_lengths_type &&,
                      file_format const &,
                      selected_field_ids const &)
    -> alignment_file_output<selected_field_ids,
                             type_list<file_format>,
                             typename std::remove_reference_t<stream_type>::char_type,
                             std::remove_reference_t<ref_ids_type>>;

template <OStream2                  stream_type,
          std::ranges::ForwardRange ref_ids_type,
          std::ranges::ForwardRange ref_lengths_type,
          AlignmentFileOutputFormat file_format>
alignment_file_output(stream_type &&,
                      ref_ids_type &&,
                      ref_lengths_type &&,
                      file_format const &)
    -> alignment_file_output<typename alignment_file_output<>::selected_field_ids,
                             type_list<file_format>,
                             typename std::remove_reference_t<stream_type>::char_type,
                             std::remove_reference_t<ref_ids_type>>;

template <OStream2                  stream_type,
          std::ranges::ForwardRange ref_ids_type,
          std::ranges::ForwardRange ref_lengths_type,
          AlignmentFileOutputFormat file_format>
alignment_file_output(stream_type &,
                      ref_ids_type &&,
                      ref_lengths_type &&,
                      file_format const &)
    -> alignment_file_output<typename alignment_file_output<>::selected_field_ids,
                             type_list<file_format>,
                             typename std::remove_reference_t<stream_type>::char_type,
                             std::remove_reference_t<ref_ids_type>>;

} // namespace seqan3