SeqAn3 3.4.0-rc.1
The Modern C++ library for sequence analysis.
Loading...
Searching...
No Matches
seqan3::structure_file_output< selected_field_ids_, valid_formats_ > Class Template Reference

A class for writing structured sequence files, e.g. Stockholm, Connect, Vienna, ViennaRNA bpp matrix ... More...

#include <seqan3/io/structure_file/output.hpp>

Public Types

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 >
 The subset of seqan3::field IDs that are valid for this file.
 
Template arguments

Exposed as member types for public access.

using selected_field_ids = selected_field_ids_
 A seqan3::fields list with the fields selected for the record.
 
using valid_formats = valid_formats_
 A seqan3::type_list with the possible formats.
 
using stream_char_type = char
 Character type of the stream(s).
 
Range associated types

Most of the range associated types are void for output ranges.

using value_type = void
 The value type (void).
 
using reference = void
 The reference type (void).
 
using const_reference = void
 The const reference type (void).
 
using size_type = void
 The size type (void).
 
using difference_type = std::ptrdiff_t
 A signed integer type, usually std::ptrdiff_t.
 
using iterator = detail::out_file_iterator< structure_file_output >
 The iterator type of this view (an output iterator).
 
using const_iterator = void
 The const iterator type is void, because files are not const-iterable.
 
using sentinel = std::default_sentinel_t
 The type returned by end().
 

Public Member Functions

std::basic_ostream< stream_char_type > & get_stream ()
 Expose a reference to the secondary stream. [public, but not documented as part of the API].
 
Constructors, destructor and assignment
 structure_file_output ()=delete
 Default constructor is explicitly deleted, you need to give a stream or file name.
 
 structure_file_output (structure_file_output const &)=delete
 Copy construction is explicitly deleted, because you can't have multiple access to the same file.
 
structure_file_outputoperator= (structure_file_output const &)=delete
 Copy assignment is explicitly deleted, because you can't have multiple access to the same file.
 
 structure_file_output (structure_file_output &&)=default
 Move construction is defaulted.
 
structure_file_outputoperator= (structure_file_output &&)=default
 Move assignment is defaulted.
 
 ~structure_file_output ()=default
 Destructor is defaulted.
 
 structure_file_output (std::filesystem::path filename, selected_field_ids const &fields_tag=selected_field_ids{})
 Construct from filename.
 
template<output_stream stream_t, structure_file_output_format file_format>
requires std::same_as<typename std::remove_reference_t<stream_t>::char_type, char>
 structure_file_output (stream_t &stream, file_format const &format_tag, selected_field_ids const &fields_tag=selected_field_ids{})
 Construct from an existing stream and with specified format.
 
template<output_stream stream_t, structure_file_output_format file_format>
requires std::same_as<typename std::remove_reference_t<stream_t>::char_type, char>
 structure_file_output (stream_t &&stream, file_format const &format_tag, selected_field_ids const &fields_tag=selected_field_ids{})
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 

Public Attributes

structure_file_output_options options
 The options are public and its members can be set directly.
 

Private Member Functions

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)
 Write record to format.
 

Private Attributes

friend iterator
 Befriend iterator so it can access the buffers.
 
std::vector< char > stream_buffer {std::vector<char>(1'000'000)}
 A larger (compared to stl default) stream buffer to use when reading from a file.
 

Related Symbols

(Note that these are not member symbols.)

Type deduction guides
template<output_stream stream_t, structure_file_output_format file_format, detail::fields_specialisation 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 > >
 Deduction of the selected fields, the file format and the stream type.
 
template<output_stream stream_t, structure_file_output_format file_format, detail::fields_specialisation 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 > >
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 

Stream / file access

using stream_ptr_t = std::unique_ptr< std::basic_ostream< stream_char_type >, std::function< void(std::basic_ostream< stream_char_type > *)> >
 The type of the internal stream pointers. Allows dynamically setting ownership management.
 
using format_type = typename detail::variant_from_tags< valid_formats, detail::structure_file_output_format_exposer >::type
 Type of the format, a std::variant over the valid_formats.
 
stream_ptr_t primary_stream {nullptr, stream_deleter_noop}
 The primary stream is the user provided stream or the file stream if constructed from filename.
 
stream_ptr_t secondary_stream {nullptr, stream_deleter_noop}
 The secondary stream is a compression layer on the primary or just points to the primary (no compression).
 
format_type format
 The actual std::variant holding a pointer to the detected/selected format.
 
static void stream_deleter_noop (std::basic_ostream< stream_char_type > *)
 Stream deleter that does nothing (no ownership assumed).
 
static void stream_deleter_default (std::basic_ostream< stream_char_type > *ptr)
 Stream deleter with default behaviour (ownership assumed).
 

Range interface

Provides functions for record based writing of the file.

iterator begin () noexcept
 Returns an iterator to current position in the file.
 
sentinel end () noexcept
 Returns a sentinel for comparison with iterator.
 
template<typename record_t >
requires detail::record_like<record_t>
void push_back (record_t &&r)
 Write a seqan3::record to the file.
 
template<typename tuple_t >
requires tuple_like<tuple_t> && (!detail::record_like<tuple_t>)
void push_back (tuple_t &&t)
 Write a record in form of a std::tuple to the file.
 
template<typename arg_t , typename... arg_types>
void emplace_back (arg_t &&arg, arg_types &&... args)
 Write a record to the file by passing individual fields.
 
template<std::ranges::input_range rng_t>
requires tuple_like<std::ranges::range_reference_t<rng_t>>
structure_file_outputoperator= (rng_t &&range)
 Write a range of records (or tuples) to the file.
 
template<std::ranges::input_range rng_t>
requires tuple_like<std::ranges::range_reference_t<rng_t>>
structure_file_outputoperator| (rng_t &&range, structure_file_output &f)
 Write a range of records (or tuples) to the file.
 
template<std::ranges::input_range rng_t>
requires tuple_like<std::ranges::range_reference_t<rng_t>>
structure_file_output operator| (rng_t &&range, structure_file_output &&f)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 

Detailed Description

template<detail::fields_specialisation selected_field_ids_ = fields<field::seq, field::id, field::structure>, detail::type_list_of_structure_file_output_formats valid_formats_ = type_list<format_vienna>>
class seqan3::structure_file_output< selected_field_ids_, valid_formats_ >

A class for writing structured sequence files, e.g. Stockholm, Connect, Vienna, ViennaRNA bpp matrix ...

Template Parameters
selected_field_idsA seqan3::fields type with the list and order of fields IDs; only relevant if these can't be deduced.
valid_formatsA seqan3::type_list of the selectable formats (each must meet seqan3::structure_file_output_format).

Writing structure files

Structured sequence files contain intra-molecular interactions of RNA or protein. Usually, but not necessarily, they contain the nucleotide or amino acid sequences and descriptions as well. Interactions can be represented either as fixed secondary structure, where every character is assigned at most one interaction partner (structure of minimum free energy), or an annotated sequence, where every character is assigned a set of interaction partners with specific base pair probabilities.

The structured sequence file abstraction supports writing ten different fields:
  1. seqan3::field::seq (sequence)
  2. seqan3::field::id (identifier)
  3. seqan3::field::bpp (annotated sequence)
  4. seqan3::field::structure (secondary structure)
  5. seqan3::field::structured_seq (sequence and structure in one range)
  6. seqan3::field::energy (minimum free energy)
  7. seqan3::field::react (reactivity)
  8. seqan3::field::react_err (reactivity error)
  9. seqan3::field::comment (free text)
  10. seqan3::field::offset (index of first sequence character)
The member functions take any and either of these fields. If the field ID of an argument cannot be deduced, it is assumed to correspond to the field ID of the respective template parameter.

Construction and specialisation

This class comes with two constructors, one for construction from a file name and one for construction from an existing stream and a known format. The first one automatically picks the format based on the extension of the file name. The second can be used if you have a non-file stream, like std::cout or std::ostringstream, that you want to read from and/or if you cannot use file-extension based detection, but know that your output file has a certain format.

In most cases the template parameters are deduced completely automatically:
// SPDX-FileCopyrightText: 2006-2024 Knut Reinert & Freie Universität Berlin
// SPDX-FileCopyrightText: 2016-2024 Knut Reinert & MPI für molekulare Genetik
// SPDX-License-Identifier: CC0-1.0
#include <filesystem>
int main()
{
auto tmp_file = std::filesystem::temp_directory_path() / "my.dbn";
seqan3::structure_file_output fout{tmp_file}; // Vienna format detected, std::ofstream opened for file
}
A class for writing structured sequence files, e.g. Stockholm, Connect, Vienna, ViennaRNA bpp matrix ...
Definition io/structure_file/output.hpp:60
Provides seqan3::structure_file_output and corresponding traits classes.
T remove(T... args)
T temp_directory_path(T... args)
Writing to std::cout:
// SPDX-FileCopyrightText: 2006-2024 Knut Reinert & Freie Universität Berlin
// SPDX-FileCopyrightText: 2016-2024 Knut Reinert & MPI für molekulare Genetik
// SPDX-License-Identifier: CC0-1.0
#include <iostream>
int main()
{
using namespace seqan3::literals;
// ^ no need to specify the template arguments
fout.emplace_back("AACGUU"_rna4, "example_id", ".(())."_wuss51); // default order for vienna: SEQ, ID, STRUCTURE
}
The Vienna format (dot bracket notation) for RNA sequences with secondary structure.
Definition format_vienna.hpp:83
The SeqAn namespace for literals.
Provides seqan3::rna4, container aliases and string literals.
Provides the WUSS format for RNA structure.
Note that this is not the same as writing structure_file_output<> (with angle brackets). In the latter case they are explicitly set to their default values, in the former case automatic deduction happens which chooses different parameters depending on the constructor arguments. Prefer deduction over explicit defaults.

Writing record-wise

You can iterate over this file record-wise:
// SPDX-FileCopyrightText: 2006-2024 Knut Reinert & Freie Universität Berlin
// SPDX-FileCopyrightText: 2016-2024 Knut Reinert & MPI für molekulare Genetik
// SPDX-License-Identifier: CC0-1.0
#include <sstream>
#include <string>
#include <tuple>
#include <vector>
int main()
{
using namespace seqan3::literals;
for (int i = 0; i < 10; i++) // ...
{
std::string id{"test_id"};
seqan3::rna5_vector seq{"ACGU"_rna5};
// ...
fout.emplace_back(seq, id, structure); // as individual variables
// or:
fout.push_back(std::tie(seq, id, structure)); // as a tuple
}
}
T emplace_back(T... args)
@ structure
Fixed interactions, usually a string of structure alphabet characters.
@ seq
The "sequence", usually a range of nucleotides or amino acids.
Provides seqan3::rna5, container aliases and string literals.
T tie(T... args)
The easiest way to write to a sequence file is to use the push_back() or emplace_back() member functions. These work similarly to how they work on a std::vector. If you pass a tuple to push_back() or give arguments to emplace_back() the seqan3::field ID of the i-th tuple-element/argument is assumed to be the i-th value of selected_field_ids, i.e. by default the first is assumed to be seqan3::field::seq, the second seqan3::field::id and the third one seqan3::field::structure. You may give less fields than are selected, if the actual format you are writing to can cope with less (e.g. for Vienna it is sufficient to write seqan3::field::seq, seqan3::field::id and seqan3::field::structure, even if selected_field_ids also contains seqan3::field::energy).

You may also use the output file's iterator for writing, however, this rarely provides an advantage.

Writing record-wise (custom fields)

If you want to pass a combined object for SEQ and STRUCTURE fields to push_back() / emplace_back(), or if you want to change the order of the parameters, you can pass a non-empty fields trait object to the structure_file_output constructor to select the fields that are used for interpreting the arguments.

The following snippets demonstrates the usage of such a fields trait object.
// SPDX-FileCopyrightText: 2006-2024 Knut Reinert & Freie Universität Berlin
// SPDX-FileCopyrightText: 2016-2024 Knut Reinert & MPI für molekulare Genetik
// SPDX-License-Identifier: CC0-1.0
#include <sstream>
#include <string>
#include <tuple>
#include <vector>
int main()
{
using namespace seqan3::literals;
for (int i = 0; i < 10; i++) // ...
{
std::string id{"test_id"};
// vector of combined data structure
// ...
// note also that the order the arguments is now different, because
// you specified that `seqan3::field::id` should be first in the fields template argument
fout.emplace_back(id, structured_sequence);
// or:
fout.push_back(std::tie(id, structured_sequence));
}
}
A seqan3::alphabet_tuple_base that joins a nucleotide alphabet with an RNA structure alphabet.
Definition structured_rna.hpp:53
A class template that holds a choice of seqan3::field.
Definition record.hpp:125
Provides the composite of nucleotide with structure alphabets.
A different way of passing custom fields to the file is to pass a seqan3::record – instead of a tuple – to push_back(). The seqan3::record clearly indicates which of its elements has which seqan3::field ID so the file will use that information instead of the template argument. This is especially handy when reading from one file and writing to another, because you don't have to configure the output file to match the input file, it will just work:
// SPDX-FileCopyrightText: 2006-2024 Knut Reinert & Freie Universität Berlin
// SPDX-FileCopyrightText: 2016-2024 Knut Reinert & MPI für molekulare Genetik
// SPDX-License-Identifier: CC0-1.0
#include <sstream>
auto input = R"(> S.cerevisiae_tRNA-PHE M10740/1-73
GCGGAUUUAGCUCAGUUGGGAGAGCGCCAGACUGAAGAUUUGGAGGUCCUGUGUUCGAUCCACAGAAUUCGCA
(((((((..((((........)))).((((.........)))).....(((((.......)))))))))))). (-17.50)
> example
UUGGAGUACACAACCUGUACACUCUUUC
..(((((..(((...)))..)))))... (-3.71))";
int main()
{
bool criteria = true;
// the output doesn't have to match the configuration of the input
for (auto & r : fin)
{
if (criteria) // r fulfills some filter criterium
fout.push_back(r);
}
}
A class for reading structured sequence files, e.g. Stockholm, Connect, Vienna, ViennaRNA bpp matrix ...
Definition structure_file/input.hpp:359
Provides seqan3::structure_file_input and corresponding traits classes.

Writing record-wise in batches

You can write multiple records at once, by assigning to the file:
// SPDX-FileCopyrightText: 2006-2024 Knut Reinert & Freie Universität Berlin
// SPDX-FileCopyrightText: 2016-2024 Knut Reinert & MPI für molekulare Genetik
// SPDX-License-Identifier: CC0-1.0
#include <sstream>
#include <string>
#include <tuple>
#include <vector>
int main()
{
using namespace seqan3::literals;
{"ACGT"_rna5, "First", "...."_wuss51},
{"NATA"_rna5, "2nd", "...."_wuss51},
{"GATA"_rna5, "Third", "...."_wuss51}}; // a range of "records"
fout = range; // will iterate over the records and write them
}

File I/O pipelines

Record-wise writing in batches also works for writing from input files directly to output files, because input files are also input ranges in SeqAn. This can be combined with file-based views to create I/O pipelines:
// SPDX-FileCopyrightText: 2006-2024 Knut Reinert & Freie Universität Berlin
// SPDX-FileCopyrightText: 2016-2024 Knut Reinert & MPI für molekulare Genetik
// SPDX-License-Identifier: CC0-1.0
#include <sstream>
auto input = R"(> S.cerevisiae_tRNA-PHE M10740/1-73
GCGGAUUUAGCUCAGUUGGGAGAGCGCCAGACUGAAGAUUUGGAGGUCCUGUGUUCGAUCCACAGAAUUCGCA
(((((((..((((........)))).((((.........)))).....(((((.......)))))))))))). (-17.50)
> example
UUGGAGUACACAACCUGUACACUCUUUC
..(((((..(((...)))..)))))... (-3.71))";
int main()
{
}

Column-based writing

The record-based interface treats the file as a range of tuples (the records), but in certain situations you might have the data as columns, i.e. a tuple-of-ranges, instead of range-of-tuples.

You can use column-based writing in that case, it uses operator=() and seqan3::views::zip():
// SPDX-FileCopyrightText: 2006-2024 Knut Reinert & Freie Universität Berlin
// SPDX-FileCopyrightText: 2016-2024 Knut Reinert & MPI für molekulare Genetik
// SPDX-License-Identifier: CC0-1.0
#include <sstream>
#include <string>
#include <vector>
using namespace seqan3::literals;
struct data_storage_t
{
};
int main()
{
data_storage_t data_storage{}; // a global or globally used variable in your program
// ... in your file writing function:
fout = seqan3::views::zip(data_storage.sequences, data_storage.ids, data_storage.structures);
}
Container that stores sequences concatenated internally.
Definition concatenated_sequences.hpp:86
Provides seqan3::concatenated_sequences.
seqan::stl::views::zip zip
A view adaptor that takes several views and returns tuple-like values from every i-th element of each...
Definition zip.hpp:24
Provides seqan3::views::zip.

Formats

Currently, the only implemented format is seqan3::format_vienna. More formats will follow soon.

Remarks
For a complete overview, take a look at Structure File

Constructor & Destructor Documentation

◆ structure_file_output() [1/2]

template<detail::fields_specialisation selected_field_ids_ = fields<field::seq, field::id, field::structure>, detail::type_list_of_structure_file_output_formats valid_formats_ = type_list<format_vienna>>
seqan3::structure_file_output< selected_field_ids_, valid_formats_ >::structure_file_output ( std::filesystem::path  filename,
selected_field_ids const &  fields_tag = selected_field_ids{} 
)
inline

Construct from filename.

Parameters
[in]filenamePath to the file you wish to open.
[in]fields_tagA seqan3::fields tag. [optional]

In addition to the file name, you may specify a custom seqan3::fields type which may be easier than defining all the template parameters.

Compression

This constructor transparently applies a compression stream on top of the file stream in case the given file extension suggests the user wants this. See the section on compression and decompression for more information.

◆ structure_file_output() [2/2]

template<detail::fields_specialisation selected_field_ids_ = fields<field::seq, field::id, field::structure>, detail::type_list_of_structure_file_output_formats valid_formats_ = type_list<format_vienna>>
template<output_stream stream_t, structure_file_output_format file_format>
requires std::same_as<typename std::remove_reference_t<stream_t>::char_type, char>
seqan3::structure_file_output< selected_field_ids_, valid_formats_ >::structure_file_output ( stream_t &  stream,
file_format const &  format_tag,
selected_field_ids const &  fields_tag = selected_field_ids{} 
)
inline

Construct from an existing stream and with specified format.

Template Parameters
file_formatThe format of the file in the stream, must satisfy seqan3::structure_file_output_format.
Parameters
[in,out]streamThe stream to write to, must be derived of std::basic_ostream.
[in]format_tagThe file format tag.
[in]fields_tagA seqan3::fields tag. [optional]

Compression

This constructor does not apply compression transparently (because there is no way to know if the user wants this). However, you can just pass e.g. seqan3::contrib::gz_ostream to this constructor if you explicitly want compression. See the section on compression and decompression for more information.

Member Function Documentation

◆ begin()

template<detail::fields_specialisation selected_field_ids_ = fields<field::seq, field::id, field::structure>, detail::type_list_of_structure_file_output_formats valid_formats_ = type_list<format_vienna>>
iterator seqan3::structure_file_output< selected_field_ids_, valid_formats_ >::begin ( )
inlinenoexcept

Returns an iterator to current position in the file.

Returns
An iterator pointing to the current position in the file.

You can write to the file by assigning to the iterator, but using push_back() is usually more intuitive.

Complexity

Constant.

Exceptions

No-throw guarantee.

Example

// SPDX-FileCopyrightText: 2006-2024 Knut Reinert & Freie Universität Berlin
// SPDX-FileCopyrightText: 2016-2024 Knut Reinert & MPI für molekulare Genetik
// SPDX-License-Identifier: CC0-1.0
#include <sstream>
#include <string>
#include <tuple>
#include <vector>
int main()
{
using namespace seqan3::literals;
auto it = fout.begin();
for (int i = 0; i < 10; i++) // ...
{
std::string id{"test_id"};
seqan3::rna5_vector seq{"AGGGUU"_rna5};
// ...
// assign to iterator
*it = std::tie(seq, id, structure);
// is the same as:
fout.push_back(std::tie(seq, id, structure));
}
}

◆ emplace_back()

template<detail::fields_specialisation selected_field_ids_ = fields<field::seq, field::id, field::structure>, detail::type_list_of_structure_file_output_formats valid_formats_ = type_list<format_vienna>>
template<typename arg_t , typename... arg_types>
void seqan3::structure_file_output< selected_field_ids_, valid_formats_ >::emplace_back ( arg_t &&  arg,
arg_types &&...  args 
)
inline

Write a record to the file by passing individual fields.

Template Parameters
arg_tType of the first field.
arg_typesTypes of further fields.
Parameters
[in]argThe first field to write.
[in]argsFurther fields.

The fields are assumed to correspond to the field IDs given in selected_field_ids, however passing less is accepted if the format does not require all of them.

Complexity

Constant. TODO linear in the size of the written sequences?

Exceptions

Basic exception safety.

Example

// SPDX-FileCopyrightText: 2006-2024 Knut Reinert & Freie Universität Berlin
// SPDX-FileCopyrightText: 2016-2024 Knut Reinert & MPI für molekulare Genetik
// SPDX-License-Identifier: CC0-1.0
#include <sstream>
#include <string>
#include <vector>
int main()
{
using namespace seqan3::literals;
for (int i = 0; i < 10; i++) // ...
{
std::string id{"test_id"};
seqan3::rna5_vector seq{"AGGGUU"_rna5};
// ...
}
}

◆ end()

template<detail::fields_specialisation selected_field_ids_ = fields<field::seq, field::id, field::structure>, detail::type_list_of_structure_file_output_formats valid_formats_ = type_list<format_vienna>>
sentinel seqan3::structure_file_output< selected_field_ids_, valid_formats_ >::end ( )
inlinenoexcept

Returns a sentinel for comparison with iterator.

Returns
An end that is never reached.

This element acts as a placeholder; attempting to dereference it results in undefined behaviour. It always compares false against an iterator.

Complexity

Constant.

Exceptions

No-throw guarantee.

◆ operator=()

template<detail::fields_specialisation selected_field_ids_ = fields<field::seq, field::id, field::structure>, detail::type_list_of_structure_file_output_formats valid_formats_ = type_list<format_vienna>>
template<std::ranges::input_range rng_t>
requires tuple_like<std::ranges::range_reference_t<rng_t>>
structure_file_output & seqan3::structure_file_output< selected_field_ids_, valid_formats_ >::operator= ( rng_t &&  range)
inline

Write a range of records (or tuples) to the file.

Template Parameters
rng_tType of the range, must satisfy std::ranges::output_range and have a reference type that satisfies seqan3::tuple_like.
Parameters
[in]rangeThe range to write.

This function simply iterates over the argument and calls push_back() on each element.

Complexity

Linear in the number of records.

Exceptions

Basic exception safety.

Example

// SPDX-FileCopyrightText: 2006-2024 Knut Reinert & Freie Universität Berlin
// SPDX-FileCopyrightText: 2016-2024 Knut Reinert & MPI für molekulare Genetik
// SPDX-License-Identifier: CC0-1.0
#include <sstream>
#include <string>
#include <tuple>
#include <vector>
int main()
{
using namespace seqan3::literals;
{"ACGT"_rna5, "First", "...."_wuss51},
{"NATA"_rna5, "2nd", "...."_wuss51},
{"GATA"_rna5, "Third", "...."_wuss51}}; // a range of "records"
fout = range; // will iterate over the records and write them
}

◆ push_back() [1/2]

template<detail::fields_specialisation selected_field_ids_ = fields<field::seq, field::id, field::structure>, detail::type_list_of_structure_file_output_formats valid_formats_ = type_list<format_vienna>>
template<typename record_t >
requires detail::record_like<record_t>
void seqan3::structure_file_output< selected_field_ids_, valid_formats_ >::push_back ( record_t &&  r)
inline

Write a seqan3::record to the file.

Template Parameters
record_tType of the record, a specialisation of seqan3::record.
Parameters
[in]rThe record to write.

Complexity

Constant. TODO linear in the size of the written sequences?

Exceptions

Basic exception safety.

Example

// SPDX-FileCopyrightText: 2006-2024 Knut Reinert & Freie Universität Berlin
// SPDX-FileCopyrightText: 2016-2024 Knut Reinert & MPI für molekulare Genetik
// SPDX-License-Identifier: CC0-1.0
#include <sstream>
auto input = R"(> S.cerevisiae_tRNA-PHE M10740/1-73
GCGGAUUUAGCUCAGUUGGGAGAGCGCCAGACUGAAGAUUUGGAGGUCCUGUGUUCGAUCCACAGAAUUCGCA
(((((((..((((........)))).((((.........)))).....(((((.......)))))))))))). (-17.50)
> example
UUGGAGUACACAACCUGUACACUCUUUC
..(((((..(((...)))..)))))... (-3.71))";
int main()
{
bool criteria = true;
// the output doesn't have to match the configuration of the input
for (auto & r : fin)
{
if (criteria) // r fulfills some filter criterium
fout.push_back(r);
}
}

◆ push_back() [2/2]

template<detail::fields_specialisation selected_field_ids_ = fields<field::seq, field::id, field::structure>, detail::type_list_of_structure_file_output_formats valid_formats_ = type_list<format_vienna>>
template<typename tuple_t >
requires tuple_like<tuple_t> && (!detail::record_like<tuple_t>)
void seqan3::structure_file_output< selected_field_ids_, valid_formats_ >::push_back ( tuple_t &&  t)
inline

Write a record in form of a std::tuple to the file.

Template Parameters
tuple_tType of the record, a specialisation of std::tuple.
Parameters
[in]tThe record to write.

The fields in the tuple are assumed to correspond to the field IDs given in selected_field_ids, however passing less is accepted if the format does not require all of them.

Complexity

Constant. TODO linear in the size of the written sequences?

Exceptions

Basic exception safety.

Example

// SPDX-FileCopyrightText: 2006-2024 Knut Reinert & Freie Universität Berlin
// SPDX-FileCopyrightText: 2016-2024 Knut Reinert & MPI für molekulare Genetik
// SPDX-License-Identifier: CC0-1.0
#include <sstream>
#include <string>
#include <tuple>
#include <vector>
int main()
{
using namespace seqan3::literals;
for (int i = 0; i < 10; i++) // ...
{
std::string id{"test_id"};
seqan3::rna5_vector seq{"AGGGUU"_rna5};
// ...
}
}
T push_back(T... args)

Friends And Related Symbol Documentation

◆ operator|

template<detail::fields_specialisation selected_field_ids_ = fields<field::seq, field::id, field::structure>, detail::type_list_of_structure_file_output_formats valid_formats_ = type_list<format_vienna>>
template<std::ranges::input_range rng_t>
requires tuple_like<std::ranges::range_reference_t<rng_t>>
structure_file_output & operator| ( rng_t &&  range,
structure_file_output< selected_field_ids_, valid_formats_ > &  f 
)
friend

Write a range of records (or tuples) to the file.

Template Parameters
rng_tType of the range, must satisfy std::ranges::input_range and have a reference type that satisfies seqan3::tuple_like.
Parameters
[in]rangeThe range to write.
[in]fThe file being written to.

This operator enables structure_file_output to be at the end of a piping operation. It just calls operator=() internally.

Complexity

Linear in the number of records.

Exceptions

Basic exception safety.

Example

// SPDX-FileCopyrightText: 2006-2024 Knut Reinert & Freie Universität Berlin
// SPDX-FileCopyrightText: 2016-2024 Knut Reinert & MPI für molekulare Genetik
// SPDX-License-Identifier: CC0-1.0
#include <sstream>
#include <string>
#include <tuple>
#include <vector>
int main()
{
using namespace seqan3::literals;
{"ACGT"_rna5, "First", "...."_wuss51},
{"NATA"_rna5, "2nd", "...."_wuss51},
{"GATA"_rna5, "Third", "...."_wuss51}}; // a range of "records"
range | fout;
// the same as:
fout = range;
}

This is especially useful in combination with file-based filters:

// SPDX-FileCopyrightText: 2006-2024 Knut Reinert & Freie Universität Berlin
// SPDX-FileCopyrightText: 2016-2024 Knut Reinert & MPI für molekulare Genetik
// SPDX-License-Identifier: CC0-1.0
#include <sstream>
auto input = R"(> S.cerevisiae_tRNA-PHE M10740/1-73
GCGGAUUUAGCUCAGUUGGGAGAGCGCCAGACUGAAGAUUUGGAGGUCCUGUGUUCGAUCCACAGAAUUCGCA
(((((((..((((........)))).((((.........)))).....(((((.......)))))))))))). (-17.50)
> example
UUGGAGUACACAACCUGUACACUCUUUC
..(((((..(((...)))..)))))... (-3.71))";
int main()
{
}

The documentation for this class was generated from the following file:
Hide me