format_sam.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 <iterator>
#include <string>
#include <string_view>
#include <vector>

#include <seqan3/io/alignment_file/format_sam.hpp>
#include <seqan3/io/sequence_file/input_format_concept.hpp>
#include <seqan3/io/sequence_file/input_options.hpp>
#include <seqan3/io/sequence_file/output_format_concept.hpp>
#include <seqan3/io/sequence_file/output_options.hpp>

namespace seqan3::detail
{

template <>
class sequence_file_input_format<format_sam>
{
public:
    using format_tag = format_sam;

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

    template <typename stream_type,     // constraints checked by file
              typename seq_legal_alph_type, bool seq_qual_combined,
              typename seq_type,        // other constraints checked inside function
              typename id_type,
              typename qual_type>
    void read(stream_type                                                               & stream,
              sequence_file_input_options<seq_legal_alph_type, seq_qual_combined> const & SEQAN3_DOXYGEN_ONLY(options),
              seq_type                                                                  & sequence,
              id_type                                                                   & id,
              qual_type                                                                 & qualities)
    {
        alignment_file_input_options<seq_legal_alph_type> align_options;

        if constexpr (seq_qual_combined)
        {
            tmp_qual.clear();
            align_format.read(stream, align_options, std::ignore, default_header, sequence, tmp_qual, id,
                              std::ignore, std::ignore, std::ignore, std::ignore, std::ignore,
                              std::ignore, std::ignore, std::ignore, std::ignore, std::ignore, std::ignore);

            for (auto sit = tmp_qual.begin(), dit = std::ranges::begin(sequence); sit != tmp_qual.end(); ++sit, ++dit)
                get<1>(*dit).assign_char(*sit);
        }
        else
        {
            align_format.read(stream, align_options, std::ignore, default_header, sequence, qualities, id,
                              std::ignore, std::ignore, std::ignore, std::ignore, std::ignore,
                              std::ignore, std::ignore, std::ignore, std::ignore, std::ignore, std::ignore);
        }

        if constexpr (!detail::decays_to_ignore_v<seq_type>)
            if (std::distance(std::ranges::begin(sequence), std::ranges::end(sequence)) == 0)
                throw format_error{"The sequence information must not be empty."};
        if constexpr (!detail::decays_to_ignore_v<id_type>)
            if (std::distance(std::ranges::begin(id), std::ranges::end(id)) == 0)
                throw format_error{"The sequence information must not be empty."};
    }

private:
    alignment_file_input_format<format_sam> align_format{};

    alignment_file_header<> default_header{};

    std::string tmp_qual{};
};

template <>
class sequence_file_output_format<format_sam>
{
public:
    using format_tag = format_sam;

    sequence_file_output_format()                                                noexcept = default; 
    sequence_file_output_format(sequence_file_output_format const &)                      = delete;
    sequence_file_output_format & operator=(sequence_file_output_format const &)          = delete;
    sequence_file_output_format(sequence_file_output_format &&)                  noexcept = default; 
    sequence_file_output_format & operator=(sequence_file_output_format &&)      noexcept = default; 
    ~sequence_file_output_format()                                               noexcept = default; 

    template <typename stream_type,     // constraints checked by file
              typename seq_type,        // other constraints checked inside function
              typename id_type,
              typename qual_type>
    void write(stream_type                        & stream,
               sequence_file_output_options const & SEQAN3_DOXYGEN_ONLY(options),
               seq_type                           && sequence,
               id_type                            && id,
               qual_type                          && qualities)
    {
        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>;

        alignment_file_output_options output_options;

        align_format.write(stream, output_options, std::ignore,
                           default_or(sequence), default_or(qualities), default_or(id),
                           0, std::string_view{}, std::string_view{}, -1, default_align_t{}, 0, 0,
                           default_mate_t{}, sam_tag_dictionary{}, 0, 0);
    }

private:
    alignment_file_output_format<format_sam> align_format{};

    static constexpr std::string_view dummy{};

    std::string_view const & default_or(detail::ignore_t) const noexcept
    {
        return dummy;
    }

    template <typename t>
    decltype(auto) default_or(t && v) const noexcept
    {
        return std::forward<t>(v);
    }
};

} // namespace seqan3::detail