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

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

#include <seqan3/alphabet/adaptation/char.hpp>
#include <seqan3/alphabet/aminoacid/all.hpp>
#include <seqan3/alphabet/nucleotide/rna15.hpp>
#include <seqan3/alphabet/nucleotide/rna5.hpp>
#include <seqan3/alphabet/structure/all.hpp>
#include <seqan3/core/type_traits/basic.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/in_file_iterator.hpp>
#include <seqan3/io/detail/misc_input.hpp>
#include <seqan3/io/detail/record.hpp>
#include <seqan3/io/structure_file/input_format_concept.hpp>
#include <seqan3/io/structure_file/input_options.hpp>
#include <seqan3/io/structure_file/format_vienna.hpp>
#include <seqan3/range/container/concatenated_sequences.hpp>

namespace seqan3
{
// ----------------------------------------------------------------------------
// StructureFileInputTraits
// ----------------------------------------------------------------------------

template<typename t>
SEQAN3_CONCEPT StructureFileInputTraits = requires(t v)
{
    // TODO(joergi-w) The expensive concept checks are currently omitted. Check again when compiler has improved.
    // sequence
    requires WritableAlphabet<typename t::seq_alphabet>;
    requires WritableAlphabet<typename t::seq_legal_alphabet>;
    requires ExplicitlyConvertibleTo<typename t::seq_legal_alphabet, typename t::seq_alphabet>;
    requires SequenceContainer<typename t::template seq_container<typename t::seq_alphabet>>;
//    requires SequenceContainer
//        <typename t::template seq_container_container
//            <typename t::template seq_container
//                <typename t::seq_alphabet>>>;

    // id
    requires WritableAlphabet<typename t::id_alphabet>;
    requires SequenceContainer<typename t::template id_container<typename t::id_alphabet>>;
//    requires SequenceContainer
//        <typename t::template id_container_container
//            <typename t::template id_container
//                <typename t::id_alphabet>>>;

    // bpp
    requires std::is_floating_point_v<typename t::bpp_prob>;
    requires std::numeric_limits<typename t::bpp_partner>::is_integer;

//    requires Container // TODO check Associative Container Concept when implemented
//        <typename t::template bpp_queue
//            <typename t::template bpp_item
//                <typename t::bpp_prob, typename t::bpp_partner>>>
//        && requires(typename t::template bpp_queue // TODO maybe implement also a version that allows emplace_back
//            <typename t::template bpp_item
//                <typename t::bpp_prob, typename t::bpp_partner>> value) { value.emplace(1.0, 1); };
//    requires SequenceContainer
//        <typename t::template bpp_container
//            <typename t::template bpp_queue
//                 <typename t::template bpp_item
//                      <typename t::bpp_prob, typename t::bpp_partner>>>>;
//    requires SequenceContainer
//        <typename t::template bpp_container_container
//            <typename t::template bpp_container
//                <typename t::template bpp_queue
//                    <typename t::template bpp_item
//                        <typename t::bpp_prob, typename t::bpp_partner>>>>>;

    // structure
    requires std::is_same_v<typename t::structure_alphabet, dssp9> // TODO(joergi-w) add aa_structure_concept
          || RnaStructureAlphabet<typename t::structure_alphabet>;
    requires SequenceContainer<typename t::template structure_container<typename t::structure_alphabet>>;
//    requires SequenceContainer
//        <typename t::template structure_container_container
//            <typename t::template structure_container
//                <typename t::structure_alphabet>>>;

    // structured sequence: tuple composites of seq and structure
    requires std::is_base_of_v<alphabet_tuple_base
        <typename t::template structured_seq_alphabet
            <typename t::seq_alphabet, typename t::structure_alphabet>,
             typename t::seq_alphabet, typename t::structure_alphabet>,
        typename t::template structured_seq_alphabet<typename t::seq_alphabet, typename t::structure_alphabet>>;
//    requires SequenceContainer
//        <typename t::template structured_seq_container
//            <typename t::template structured_seq_alphabet
//                <typename t::seq_alphabet, typename t::structure_alphabet>>>;
//    requires SequenceContainer
//        <typename t::template structured_seq_container_container
//            <typename t::template structured_seq_container
//                <typename t::template structured_seq_alphabet
//                    <typename t::seq_alphabet, typename t::structure_alphabet>>>>;

    // energy: std::optional of floating point number
    requires std::is_floating_point_v<typename t::energy_type::value_type>;
    requires SequenceContainer<typename t::template energy_container<typename t::energy_type>>;

    // reactivity [error]
    requires std::is_floating_point_v<typename t::react_type>;
    requires SequenceContainer<typename t::template react_container<typename t::react_type>>;
//    requires SequenceContainer
//        <typename t::template react_container_container
//            <typename t::template react_container
//                <typename t::react_type>>>;

    // comment
    requires WritableAlphabet<typename t::comment_alphabet>;
    requires SequenceContainer<typename t::template comment_container<typename t::comment_alphabet>>;
//    requires SequenceContainer
//        <typename t::template comment_container_container
//            <typename t::template comment_container
//                <typename t::comment_alphabet>>>;

    // offset
    requires std::numeric_limits<typename t::offset_type>::is_integer;
    requires SequenceContainer<typename t::template offset_container<typename t::offset_type>>;
};

// ----------------------------------------------------------------------------
// structure_file_input_default_traits
// ----------------------------------------------------------------------------

struct structure_file_input_default_traits_rna
{
    // sequence

    using seq_alphabet                       = rna5;

    using seq_legal_alphabet                 = rna15;

    template<typename _seq_alphabet>
    using seq_container                      = std::vector<_seq_alphabet>;

    template<typename _seq_container>
    using seq_container_container            = concatenated_sequences<_seq_container>;

    // id

    using id_alphabet                        = char;

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

    template<typename _id_container>
    using id_container_container             = concatenated_sequences<_id_container>;

    // base pair probability structure

    using bpp_prob                           = double;

    using bpp_partner                        = size_t;

    template<typename _bpp_prob, typename _bpp_partner>
    using bpp_item                           = std::pair<_bpp_prob, _bpp_partner>;

    template<typename _bpp_item>
    using bpp_queue                          = std::set<_bpp_item>;

    template<typename _bpp_queue>
    using bpp_container                      = std::vector<_bpp_queue>;

    template<typename _bpp_container>
    using bpp_container_container            = std::vector<_bpp_container>;

    // fixed structure

    using structure_alphabet                 = wuss51;

    template<typename _structure_alphabet>
    using structure_container                = std::vector<_structure_alphabet>;

    template<typename _structure_container>
    using structure_container_container      = concatenated_sequences<_structure_container>;

    // combined sequence and structure

    template<typename _seq_alphabet, typename _structure_alphabet>
    using structured_seq_alphabet            = structured_rna<_seq_alphabet, _structure_alphabet>;

    template<typename _structured_seq_alphabet>
    using structured_seq_container           = std::vector<_structured_seq_alphabet>;

    template<typename _structured_seq_container>
    using structured_seq_container_container = concatenated_sequences<_structured_seq_container>;

    // energy

    using energy_type                        = std::optional<double>;

    template<typename _energy_type>
    using energy_container                   = std::vector<_energy_type>;

    // reactivity [error]

    using react_type                         = double;

    template<typename _react_type>
    using react_container                    = std::vector<_react_type>;

    template<typename _react_container>
    using react_container_container          = std::vector<_react_container>;

    // comment

    using comment_alphabet                   = char;

    template<typename _comment_alphabet>
    using comment_container                  = std::basic_string<_comment_alphabet>;

    template<typename _comment_container>
    using comment_container_container        = concatenated_sequences<_comment_container>;

    // offset

    using offset_type                        = size_t;

    template<typename _offset_type>
    using offset_container                   = std::vector<_offset_type>;
};

struct structure_file_input_default_traits_aa : structure_file_input_default_traits_rna
{
    using seq_alphabet             = aa27;
    using seq_legal_alphabet       = aa27;
    using structure_alphabet       = dssp9;
    template<typename _seq_alphabet, typename _structure_alphabet>
    using structured_seq_alphabet  = structured_aa<_seq_alphabet, _structure_alphabet>;
};

// ----------------------------------------------------------------------------
// structure_file_input
// ----------------------------------------------------------------------------

template<StructureFileInputTraits traits_type_ = structure_file_input_default_traits_rna,
         detail::Fields selected_field_ids_ = fields<field::SEQ, field::ID, field::STRUCTURE>,
         detail::TypeListOfStructureFileInputFormats valid_formats_
             = type_list<format_vienna>,
         Char stream_char_type_ = char>
class structure_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_;

    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_input::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 seq_type            = typename traits_type::template seq_container<typename traits_type::seq_alphabet>;
    using id_type             = typename traits_type::template id_container<typename traits_type::id_alphabet>;
    using bpp_type            = typename traits_type::template bpp_container
        <typename traits_type::template bpp_queue
            <typename traits_type::template bpp_item
                <typename traits_type::bpp_prob, typename traits_type::bpp_partner>>>;
    using structure_type      = typename traits_type::template structure_container
        <typename traits_type::structure_alphabet>;
    using structured_seq_type = typename traits_type::template structured_seq_container
        <typename traits_type::template structured_seq_alphabet
            <typename traits_type::seq_alphabet, typename traits_type::structure_alphabet>>;
    using energy_type         = typename traits_type::energy_type;
    using react_type          = typename traits_type::template react_container<typename traits_type::react_type>;
    using comment_type        = typename traits_type::template comment_container
        <typename traits_type::comment_alphabet>;
    using offset_type         = typename traits_type::offset_type;

    using field_types    = type_list<seq_type, id_type, bpp_type, structure_type, structured_seq_type, energy_type,
                                     react_type, react_type, comment_type, offset_type>;

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

    using seq_column_type            = typename traits_type::template seq_container_container<seq_type>;
    using id_column_type             = typename traits_type::template id_container_container<id_type>;
    using bpp_column_type            = typename traits_type::template bpp_container_container<bpp_type>;
    using structure_column_type      = typename traits_type::template structure_container_container<structure_type>;
    using structured_seq_column_type = typename traits_type::template structured_seq_container_container
        <structured_seq_type>;
    using energy_column_type         = typename traits_type::template energy_container<energy_type>;
    using react_column_type          = typename traits_type::template react_container_container<react_type>;
    using comment_column_type        = typename traits_type::template comment_container_container<comment_type>;
    using offset_column_type         = typename traits_type::template offset_container<offset_type>;

    using field_column_types         = type_list<seq_column_type,
                                                 id_column_type,
                                                 bpp_column_type,
                                                 structure_column_type,
                                                 structured_seq_column_type,
                                                 energy_column_type,
                                                 react_column_type,
                                                 react_column_type,
                                                 comment_column_type,
                                                 offset_column_type>;
    using file_as_tuple_type     = record<detail::select_types_with_ids_t<field_column_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<structure_file_input>;
    using const_iterator  = void;
    using sentinel        = std::ranges::default_sentinel_t;

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

    structure_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}
    {
        if (!primary_stream->good())
            throw file_open_error{"Could not open file " + filename.string() + " for reading."};

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

        // initialise format handler
        detail::set_format(format, filename);

        // buffer first record
        read_next_record();
    }

    template<IStream2 stream_t, StructureFileInputFormat file_format>
    structure_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},
        format{detail::structure_file_input_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.");

        // possibly add intermediate decompression stream
        secondary_stream = detail::make_secondary_istream(*primary_stream);

        // buffer first record
        read_next_record();
    }

    template<IStream2 stream_t, StructureFileInputFormat file_format>
    structure_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},
        format{detail::structure_file_input_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.");

        // possibly add intermediate compression stream
        secondary_stream = detail::make_secondary_istream(*primary_stream);

        // buffer first record
        read_next_record();
    }

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

    sentinel end() noexcept
    {
        return {};
    }

    reference front() noexcept
    {
        return record_buffer;
    }

    template<field f>
    friend auto & get(structure_file_input & file)
    {
        static_assert(structure_file_input::selected_field_ids::contains(f),
                      "You requested a field via get that was not selected for the file.");

        file.read_columns();

        return seqan3::get<f>(file.columns_buffer);
    }

    template<field f>
    friend auto && get(structure_file_input && file)
    {
        return std::move(get<f>(file));
    }

    template<size_t i>
    friend auto & get(structure_file_input & file)
    {
        static_assert(i < structure_file_input::selected_field_ids::as_array.size(),
                      "You requested a field number larger than the number of selected fields for the file.");
        file.read_columns();

        return std::get<i>(file.columns_buffer);
    }

    template<size_t i>
    friend auto && get(structure_file_input && file)
    {
        return std::move(get<i>(file));
    }

    template<typename t>
    friend auto & get(structure_file_input & file)
    {
        file.read_columns();

        return std::get<t>(file.columns_buffer);
    }

    template<typename t>
    friend auto && get(structure_file_input && file)
    {
        return std::move(get<t>(file));
    }

    structure_file_input_options<typename traits_type::seq_legal_alphabet,
                                 selected_field_ids::contains(field::STRUCTURED_SEQ)> options;

protected:

    record_type record_buffer;
    file_as_tuple_type columns_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::structure_file_input_format>::type;
    format_type format;

    void read_next_record()
    {
        // clear the record
        record_buffer.clear();

        // 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;
        }

        assert(!format.valueless_by_exception());
        std::visit([&] (auto & f)
        {
            // read new record
            if constexpr (selected_field_ids::contains(field::STRUCTURED_SEQ))
            {
                static_assert(!selected_field_ids::contains(field::STRUCTURE),
                              "You may not select field::STRUCTURED_SEQ and field::STRUCTURE at the same time.");
                static_assert(!selected_field_ids::contains(field::SEQ),
                              "You may not select field::STRUCTURED_SEQ and field::SEQ at the same time.");
                f.read(*secondary_stream,
                       options,
                       detail::get_or_ignore<field::STRUCTURED_SEQ>(record_buffer), // seq
                       detail::get_or_ignore<field::ID>(record_buffer),
                       detail::get_or_ignore<field::BPP>(record_buffer),
                       detail::get_or_ignore<field::STRUCTURED_SEQ>(record_buffer), // structure
                       detail::get_or_ignore<field::ENERGY>(record_buffer),
                       detail::get_or_ignore<field::REACT>(record_buffer),
                       detail::get_or_ignore<field::REACT_ERR>(record_buffer),
                       detail::get_or_ignore<field::COMMENT>(record_buffer),
                       detail::get_or_ignore<field::OFFSET>(record_buffer));
            }
            else
            {
                f.read(*secondary_stream,
                       options,
                       detail::get_or_ignore<field::SEQ>(record_buffer),
                       detail::get_or_ignore<field::ID>(record_buffer),
                       detail::get_or_ignore<field::BPP>(record_buffer),
                       detail::get_or_ignore<field::STRUCTURE>(record_buffer),
                       detail::get_or_ignore<field::ENERGY>(record_buffer),
                       detail::get_or_ignore<field::REACT>(record_buffer),
                       detail::get_or_ignore<field::REACT_ERR>(record_buffer),
                       detail::get_or_ignore<field::COMMENT>(record_buffer),
                       detail::get_or_ignore<field::OFFSET>(record_buffer));
            }
        }, format);
    }

    void read_columns()
    {
        //TODO don't do multiple visits
        //TODO create specialised version for concatenated_sequences where we append on the concat
        auto & seq_column_buffer            = detail::get_or_ignore<field::SEQ>(columns_buffer);
        auto & id_column_buffer             = detail::get_or_ignore<field::ID>(columns_buffer);
        auto & bpp_column_buffer            = detail::get_or_ignore<field::BPP>(columns_buffer);
        auto & structure_column_buffer      = detail::get_or_ignore<field::STRUCTURE>(columns_buffer);
        auto & structured_seq_column_buffer = detail::get_or_ignore<field::STRUCTURED_SEQ>(columns_buffer);
        auto & energy_column_buffer         = detail::get_or_ignore<field::ENERGY>(columns_buffer);
        auto & react_column_buffer          = detail::get_or_ignore<field::REACT>(columns_buffer);
        auto & react_err_column_buffer      = detail::get_or_ignore<field::REACT_ERR>(columns_buffer);
        auto & comment_column_buffer        = detail::get_or_ignore<field::COMMENT>(columns_buffer);
        auto & offset_column_buffer         = detail::get_or_ignore<field::OFFSET>(columns_buffer);

        // read the remaining records and split into column buffers
        for (auto & rec : *this)
        {
            if constexpr (selected_field_ids::contains(field::SEQ))
                seq_column_buffer.push_back(std::move(seqan3::get<field::SEQ>(rec)));
            if constexpr (selected_field_ids::contains(field::ID))
                id_column_buffer.push_back(std::move(seqan3::get<field::ID>(rec)));
            if constexpr (selected_field_ids::contains(field::BPP))
                bpp_column_buffer.push_back(std::move(seqan3::get<field::BPP>(rec)));
            if constexpr (selected_field_ids::contains(field::STRUCTURE))
                structure_column_buffer.push_back(std::move(seqan3::get<field::STRUCTURE>(rec)));
            if constexpr (selected_field_ids::contains(field::STRUCTURED_SEQ))
                structured_seq_column_buffer.push_back(std::move(seqan3::get<field::STRUCTURED_SEQ>(rec)));
            if constexpr (selected_field_ids::contains(field::ENERGY))
                energy_column_buffer.push_back(std::move(seqan3::get<field::ENERGY>(rec)));
            if constexpr (selected_field_ids::contains(field::REACT))
                react_column_buffer.push_back(std::move(seqan3::get<field::REACT>(rec)));
            if constexpr (selected_field_ids::contains(field::REACT_ERR))
                react_err_column_buffer.push_back(std::move(seqan3::get<field::REACT_ERR>(rec)));
            if constexpr (selected_field_ids::contains(field::COMMENT))
                comment_column_buffer.push_back(std::move(seqan3::get<field::COMMENT>(rec)));
            if constexpr (selected_field_ids::contains(field::OFFSET))
                offset_column_buffer.push_back(std::move(seqan3::get<field::OFFSET>(rec)));
        }
    }

    friend iterator;
};

template <IStream2                 stream_type,
          StructureFileInputFormat file_format,
          detail::Fields           selected_field_ids>
structure_file_input(stream_type && stream, file_format const &, selected_field_ids const &)
    -> structure_file_input<typename structure_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,
          StructureFileInputFormat file_format,
          detail::Fields           selected_field_ids>
structure_file_input(stream_type & stream, file_format const &, selected_field_ids const &)
    -> structure_file_input<typename structure_file_input<>::traits_type,       // actually use the default
                            selected_field_ids,
                            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::StructureFileInputTraits                    traits_type,
         seqan3::detail::Fields                              selected_field_ids,
         seqan3::detail::TypeListOfStructureFileInputFormats valid_formats,
         seqan3::Char                                        stream_char_t>
struct tuple_size<seqan3::structure_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::StructureFileInputTraits                    traits_type,
         seqan3::detail::Fields                              selected_field_ids,
         seqan3::detail::TypeListOfStructureFileInputFormats valid_formats,
         seqan3::Char                                        stream_char_t>
struct tuple_element<elem_no,
                     seqan3::structure_file_input<traits_type, selected_field_ids, valid_formats, stream_char_t>>
    : tuple_element<elem_no, typename seqan3::structure_file_input<traits_type,
                                                                   selected_field_ids,
                                                                   valid_formats,
                                                                   stream_char_t>::file_as_tuple_type>
{};

} // namespace std