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 <optional>
#include <string>
#include <type_traits>
#include <variant>
#include <vector>

#include <range/v3/algorithm/equal.hpp>
#include <range/v3/view/zip.hpp>

#include <seqan3/alphabet/structure/all.hpp>
#include <seqan3/core/type_traits/basic.hpp>
#include <seqan3/core/type_traits/template_inspection.hpp>
#include <seqan3/core/concept/tuple.hpp>
#include <seqan3/io/stream/concept.hpp>
#include <seqan3/io/exception.hpp>
#include <seqan3/std/filesystem>
#include <seqan3/io/record.hpp>
#include <seqan3/io/detail/misc_output.hpp>
#include <seqan3/io/detail/out_file_iterator.hpp>
#include <seqan3/io/detail/record.hpp>
#include <seqan3/io/structure_file/output_format_concept.hpp>
#include <seqan3/io/structure_file/output_options.hpp>
#include <seqan3/io/structure_file/format_vienna.hpp>
#include <seqan3/range/view/convert.hpp>
#include <seqan3/range/view/get.hpp>
#include <seqan3/std/ranges>

namespace seqan3
{

// ----------------------------------------------------------------------------
// structure_file_output
// ----------------------------------------------------------------------------

template <detail::Fields selected_field_ids_ = fields<field::SEQ, field::ID, field::STRUCTURE>,
          detail::TypeListOfStructureFileOutputFormats valid_formats_ = type_list<format_vienna>,
          Char stream_char_type_ = char>
class structure_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::SEQ,
                             field::ID,
                             field::BPP,
                             field::STRUCTURE,
                             field::STRUCTURED_SEQ,
                             field::ENERGY,
                             field::REACT,
                             field::REACT_ERR,
                             field::COMMENT,
                             field::OFFSET>;

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

    static_assert([] () constexpr
                  {
                      return !(selected_field_ids::contains(field::STRUCTURED_SEQ) &&
                               (selected_field_ids::contains(field::SEQ) ||
                               (selected_field_ids::contains(field::STRUCTURE))));
                  }(), "You may not select field::STRUCTURED_SEQ and either of field::SEQ and field::STRUCTURE "
                       "at the same time.");

    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<structure_file_output>;
    using const_iterator    = void;
    using sentinel          = std::ranges::default_sentinel_t;

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

    structure_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}
    {
        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_t, StructureFileOutputFormat file_format>
    structure_file_output(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},
        secondary_stream{&stream, stream_deleter_noop},
        format{detail::structure_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_t, StructureFileOutputFormat file_format>
    structure_file_output(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},
        secondary_stream{&*primary_stream, stream_deleter_noop},
        format{detail::structure_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.");
    }

    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>; }
    {
        write_record(detail::get_or_ignore<field::SEQ>(r),
                     detail::get_or_ignore<field::ID>(r),
                     detail::get_or_ignore<field::BPP>(r),
                     detail::get_or_ignore<field::STRUCTURE>(r),
                     detail::get_or_ignore<field::STRUCTURED_SEQ>(r),
                     detail::get_or_ignore<field::ENERGY>(r),
                     detail::get_or_ignore<field::REACT>(r),
                     detail::get_or_ignore<field::REACT_ERR>(r),
                     detail::get_or_ignore<field::COMMENT>(r),
                     detail::get_or_ignore<field::OFFSET>(r));
    }

    template <typename tuple_t>
    void push_back(tuple_t && t)
        requires TupleLike<tuple_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_ignore<selected_field_ids::index_of(field::SEQ)>(t),
                     detail::get_or_ignore<selected_field_ids::index_of(field::ID)>(t),
                     detail::get_or_ignore<selected_field_ids::index_of(field::BPP)>(t),
                     detail::get_or_ignore<selected_field_ids::index_of(field::STRUCTURE)>(t),
                     detail::get_or_ignore<selected_field_ids::index_of(field::STRUCTURED_SEQ)>(t),
                     detail::get_or_ignore<selected_field_ids::index_of(field::ENERGY)>(t),
                     detail::get_or_ignore<selected_field_ids::index_of(field::REACT)>(t),
                     detail::get_or_ignore<selected_field_ids::index_of(field::REACT_ERR)>(t),
                     detail::get_or_ignore<selected_field_ids::index_of(field::COMMENT)>(t),
                     detail::get_or_ignore<selected_field_ids::index_of(field::OFFSET)>(t));
    }

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

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

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

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

    template <typename typelist, typename field_ids>
    structure_file_output & operator=(record<typelist, field_ids> const & r)
    {
        write_columns(detail::range_wrap_ignore(detail::get_or_ignore<field::SEQ>(r)),
                      detail::range_wrap_ignore(detail::get_or_ignore<field::ID>(r)),
                      detail::range_wrap_ignore(detail::get_or_ignore<field::BPP>(r)),
                      detail::range_wrap_ignore(detail::get_or_ignore<field::STRUCTURE>(r)),
                      detail::range_wrap_ignore(detail::get_or_ignore<field::STRUCTURED_SEQ>(r)),
                      detail::range_wrap_ignore(detail::get_or_ignore<field::ENERGY>(r)),
                      detail::range_wrap_ignore(detail::get_or_ignore<field::REACT>(r)),
                      detail::range_wrap_ignore(detail::get_or_ignore<field::REACT_ERR>(r)),
                      detail::range_wrap_ignore(detail::get_or_ignore<field::COMMENT>(r)),
                      detail::range_wrap_ignore(detail::get_or_ignore<field::OFFSET>(r)));
        return *this;
    }

    template <typename ... arg_types>
    structure_file_output & operator=(std::tuple<arg_types...> const & t)
    {
        // index_of might return npos, but this will be handled well by get_or_ignore (and just return ignore)
        write_columns(
           detail::range_wrap_ignore(detail::get_or_ignore<selected_field_ids::index_of(field::SEQ)>(t)),
           detail::range_wrap_ignore(detail::get_or_ignore<selected_field_ids::index_of(field::ID)>(t)),
           detail::range_wrap_ignore(detail::get_or_ignore<selected_field_ids::index_of(field::BPP)>(t)),
           detail::range_wrap_ignore(detail::get_or_ignore<selected_field_ids::index_of(field::STRUCTURE)>(t)),
           detail::range_wrap_ignore(detail::get_or_ignore<selected_field_ids::index_of(field::STRUCTURED_SEQ)>(t)),
           detail::range_wrap_ignore(detail::get_or_ignore<selected_field_ids::index_of(field::ENERGY)>(t)),
           detail::range_wrap_ignore(detail::get_or_ignore<selected_field_ids::index_of(field::REACT)>(t)),
           detail::range_wrap_ignore(detail::get_or_ignore<selected_field_ids::index_of(field::REACT_ERR)>(t)),
           detail::range_wrap_ignore(detail::get_or_ignore<selected_field_ids::index_of(field::COMMENT)>(t)),
           detail::range_wrap_ignore(detail::get_or_ignore<selected_field_ids::index_of(field::OFFSET)>(t)));
        return *this;
    }

    structure_file_output_options options;

    std::basic_ostream<stream_char_type> & get_stream()
    {
        return *secondary_stream;
    }
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::structure_file_output_format>::type;
    format_type format;

    template <typename seq_type,
              typename id_type,
              typename bpp_type,
              typename structure_type,
              typename structured_seq_type,
              typename energy_type,
              typename react_type,
              typename comment_type,
              typename offset_type>
    void write_record(seq_type && seq,
                      id_type && id,
                      bpp_type && bpp,
                      structure_type && structure,
                      structured_seq_type && structured_seq,
                      energy_type && energy,
                      react_type && react,
                      react_type && react_error,
                      comment_type && comment,
                      offset_type && offset)
    {
        static_assert(detail::decays_to_ignore_v<structured_seq_type> ||
                      (detail::decays_to_ignore_v<seq_type> && detail::decays_to_ignore_v<structure_type>),
                      "You may not select field::STRUCTURED_SEQ and either of field::SEQ and field::STRUCTURE "
                      "at the same time.");

        assert(!format.valueless_by_exception());
        std::visit([&] (auto & f)
        {
            if constexpr (!detail::decays_to_ignore_v<structured_seq_type>)
            {
                f.write(*secondary_stream,
                        options,
                        structured_seq | view::get<0>,
                        id,
                        bpp,
                        structured_seq | view::get<1>,
                        energy,
                        react,
                        react_error,
                        comment,
                        offset);
            }
            else
            {
                f.write(*secondary_stream,
                        options,
                        seq,
                        id,
                        bpp,
                        structure,
                        energy,
                        react,
                        react_error,
                        comment,
                        offset);
            }
        }, format);
    }

    template <std::ranges::InputRange seq_type,
              std::ranges::InputRange id_type,
              std::ranges::InputRange bpp_type,
              std::ranges::InputRange structure_type,
              std::ranges::InputRange structured_seq_type,
              std::ranges::InputRange energy_type,
              std::ranges::InputRange react_type,
              std::ranges::InputRange comment_type,
              std::ranges::InputRange offset_type>
    void write_columns(seq_type && seq,
                       id_type && id,
                       bpp_type && bpp,
                       structure_type && structure,
                       structured_seq_type && structured_seq,
                       energy_type && energy,
                       react_type && react,
                       react_type && react_error,
                       comment_type && comment,
                       offset_type && offset)
    {
        static_assert(!(detail::decays_to_ignore_v<reference_t<seq_type>> &&
                        detail::decays_to_ignore_v<reference_t<id_type>> &&
                        detail::decays_to_ignore_v<reference_t<bpp_type>> &&
                        detail::decays_to_ignore_v<reference_t<structure_type>> &&
                        detail::decays_to_ignore_v<reference_t<structured_seq_type>> &&
                        detail::decays_to_ignore_v<reference_t<energy_type>> &&
                        detail::decays_to_ignore_v<reference_t<react_type>> &&
                        detail::decays_to_ignore_v<reference_t<comment_type>> &&
                        detail::decays_to_ignore_v<reference_t<offset_type>>),
                      "At least one of the columns must not be set to std::ignore.");

        static_assert(detail::decays_to_ignore_v<reference_t<structured_seq_type>> ||
                      (detail::decays_to_ignore_v<reference_t<seq_type>> &&
                       detail::decays_to_ignore_v<reference_t<structure_type>>),
                      "You may not select field::STRUCTURED_SEQ and either of field::SEQ and field::STRUCTURE "
                      "at the same time.");

        assert(!format.valueless_by_exception());
        std::visit([&] (auto & f)
        {
            if constexpr (!detail::decays_to_ignore_v<reference_t<structured_seq_type>>)
            {
                auto zipped = std::view::zip(structured_seq, id, bpp, energy, react, react_error, comment, offset);

                for (auto && v : zipped)
                {
                    f.write(*secondary_stream,
                            options,
                            std::get<0>(v) | view::get<0>, // seq
                            std::get<1>(v),  // id
                            std::get<2>(v),  // bpp
                            std::get<0>(v) | view::get<1>, // structure
                            std::get<3>(v),  // energy
                            std::get<4>(v),  // react
                            std::get<5>(v),  // react_error
                            std::get<6>(v),  // comment
                            std::get<7>(v)); // offset
                }
            }
            else
            {
                auto zipped = std::view::zip(seq, id, bpp, structure, energy, react, react_error, comment, offset);

                for (auto && v : zipped)
                {
                    f.write(*secondary_stream, options, std::get<0>(v), std::get<1>(v), std::get<2>(v), std::get<3>(v),
                            std::get<4>(v), std::get<5>(v), std::get<6>(v), std::get<7>(v), std::get<8>(v));
                }
            }
        }, format);
    }

    friend iterator;
};

template <OStream2                  stream_t,
          StructureFileOutputFormat file_format,
          detail::Fields            selected_field_ids>
structure_file_output(stream_t &&, file_format const &, selected_field_ids const &)
    -> structure_file_output<selected_field_ids,
                             type_list<file_format>,
                             typename std::remove_reference_t<stream_t>::char_type>;

template <OStream2                  stream_t,
          StructureFileOutputFormat file_format,
          detail::Fields            selected_field_ids>
structure_file_output(stream_t &, file_format const &, selected_field_ids const &)
    -> structure_file_output<selected_field_ids,
                             type_list<file_format>,
                             typename std::remove_reference_t<stream_t>::char_type>;

} // namespace seqan3