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

#include <seqan3/io/structure_file/input.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; order corresponds to the types in field_types.

Template arguments
Exposed as member types for public access.
using	traits_type = traits_type_
	A traits type that defines aliases and template for storage of the fields.

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 = stream_char_type_
	Character type of the stream(s), usually `char`.

Field types and record type
These types are relevant for record/row-based reading; they may be manipulated via the traits_type to achieve different storage behaviour.
using	seq_type = typename traits_type::template seq_container< typename traits_type::seq_alphabet >
	The type of the sequence field (default std::vector of seqan3::rna5).

using	id_type = typename traits_type::template id_container< typename traits_type::id_alphabet >
	The type of the ID field (default std::string).

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 > >>
	The type of the base pair probabilies (default std::vector of std::set<std::pair<double, size_t>>).

using	structure_type = typename traits_type::template structure_container< typename traits_type::structure_alphabet >
	The type of the structure field (default std::vector of seqan3::wuss51).

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 > >
	The type of the sequence-structure field (default std::vector of structured_rna<rna5, wuss51>).

using	energy_type = typename traits_type::energy_type
	The type of the energy field (default double).

using	react_type = typename traits_type::template react_container< typename traits_type::react_type >
	The type of the reactivity and reactivity error fields (default double).

using	comment_type = typename traits_type::template comment_container< typename traits_type::comment_alphabet >
	The type of the comment field (default double).

using	offset_type = typename traits_type::offset_type
	The type of the offset field (default size_t).

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 >
	The previously defined types aggregated in a seqan3::type_list.

using	record_type = record< detail::select_types_with_ids_t< field_types, field_ids, selected_field_ids >, selected_field_ids >
	The type of the record, a specialisation of seqan3::record; acts as a tuple of the selected field types.

Field column types and tuple type
These types are relevant for field/column-wise reading; they may be manipulated via the traits_type to achieve different storage behaviour.
using	seq_column_type = typename traits_type::template seq_container_container< seq_type >
	Column type of field::SEQ (seqan3::concatenated_sequences<seq_type> by default).

using	id_column_type = typename traits_type::template id_container_container< id_type >
	Column type of field::ID (seqan3::concatenated_sequences<id_type> by default).

using	bpp_column_type = typename traits_type::template bpp_container_container< bpp_type >
	Column type of field::BPP (std::vector<bpp_type> by default).

using	structure_column_type = typename traits_type::template structure_container_container< structure_type >
	Column type of field::STRUCTURE (seqan3::concatenated_sequences<structure_type> by default).

using	structured_seq_column_type = typename traits_type::template structured_seq_container_container< structured_seq_type >
	Column type of field::STRUCTURED_SEQ (seqan3::concatenated_sequences<structured_seq_type> by default).

using	energy_column_type = typename traits_type::template energy_container< energy_type >
	Column type of field::ENERGY (std::vector<energy_type> by default).

using	react_column_type = typename traits_type::template react_container_container< react_type >
	Column type of field::REACT and field::REACT_ERR (std::vector<react_type> by default).

using	comment_column_type = typename traits_type::template comment_container_container< comment_type >
	Column type of field::COMMENT (seqan3::concatenated_sequences<comment_type> by default).

using	offset_column_type = typename traits_type::template offset_container< offset_type >
	Column type of field::OFFSET (std::vector<offset_type> by default).

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 >
	The previously defined types aggregated in a seqan3::type_list.

using	file_as_tuple_type = record< detail::select_types_with_ids_t< field_column_types, field_ids, selected_field_ids >, selected_field_ids >
	The type emulated by the file when read column-wise.

Range associated types
The types necessary to facilitate the behaviour of an input range (used in record-wise reading).
using	value_type = record_type
	The value_type is the record_type.

using	reference = record_type &
	The reference type.

using	const_reference = void
	The const_reference type is void, because files are not const-iterable.

using	size_type = size_t
	An unsigned integer type, usually std::size_t.

using	difference_type = std::make_signed_t< size_t >
	A signed integer type, usually std::ptrdiff_t.

using	iterator = detail::in_file_iterator< structure_file_input >
	The iterator type of this view (an input iterator).

using	const_iterator = void
	The const iterator type is void, because files are not const-iterable.

using	sentinel = std::ranges::default_sentinel_t
	The type returned by end().

Public Member Functions
Constructors, destructor and assignment
	structure_file_input ()=delete
	Default constructor is explicitly deleted, you need to give a stream or file name.

	structure_file_input (structure_file_input const &)=delete
	Copy construction is explicitly deleted, because you cannot have multiple access to the same file.

structure_file_input &	operator= (structure_file_input const &)=delete
	Copy assignment is explicitly deleted, because you cannot have multiple access to the same file.

	structure_file_input (structure_file_input &&)=default
	Move construction is defaulted.

structure_file_input &	operator= (structure_file_input &&)=default
	Move assignment is defaulted.

	~structure_file_input ()=default
	Destructor is defaulted.

	structure_file_input (std::filesystem::path filename, selected_field_ids const &fields_tag=selected_field_ids{})
	Construct from filename. More...

template<IStream2 stream_t, StructureFileInputFormat file_format>
	structure_file_input (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. More...

template<IStream2 stream_t, StructureFileInputFormat file_format>
	structure_file_input (stream_t &&stream, file_format const &format_tag, selected_field_ids const &fields_tag=selected_field_ids{})

Range interface
Provides functions for record based reading of the file.
iterator	begin () noexcept
	Returns an iterator to current position in the file. More...

sentinel	end () noexcept
	Returns a sentinel for comparison with iterator. More...

reference	front () noexcept
	Return the record we are currently at in the file. More...

Public Attributes
structure_file_input_options< typename traits_type::seq_legal_alphabet, selected_field_ids::contains(field::STRUCTURED_SEQ)>	options
	The options are public and its members can be set directly.

Friends
Tuple interface
Provides functions for field-based ("column"-based) reading.
template<field f>
auto &	get (structure_file_input &file)
	Read the entire file into internal buffers and retrieve the specified column.

template<field f>
auto &&	get (structure_file_input &&file)
	Read the entire file into internal buffers and retrieve the specified column. More...

template<size_t i>
auto &	get (structure_file_input &file)
	Read the entire file into internal buffers and retrieve the specified column. More...

template<size_t i>
auto &&	get (structure_file_input &&file)
	Read the entire file into internal buffers and retrieve the specified column. More...

template<typename t >
auto &	get (structure_file_input &file)
	Read the entire file into internal buffers and retrieve the specified column. More...

template<typename t >
auto &&	get (structure_file_input &&file)
	Read the entire file into internal buffers and retrieve the specified column. More...

Related Functions
(Note that these are not member functions.)
Type deduction guides
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, selected_field_ids, type_list< file_format >, typename std::remove_reference_t< stream_type >::char_type >
	Deduction of the selected fields, the file format and the stream 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, selected_field_ids, type_list< file_format >, typename std::remove_reference_t< stream_type >::char_type >

Detailed Description

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 seqan3::structure_file_input< traits_type_, selected_field_ids_, valid_formats_, stream_char_type_ >

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

Template Parameters

traits_type	An auxiliary type that defines certain member types and constants, must satisfy seqan3::StructureFileInputTraits.
selected_field_ids	A seqan3::fields type with the list and order of desired record entries; all fields must be in seqan3::structure_file_input::field_ids.
valid_formats	A seqan3::type_list of the selectable formats (each must meet seqan3::StructureFileInputFormat).
stream_char_type	The type of the underlying stream device(s); must model seqan3::Char.

Introduction

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 reading ten different fields:

seqan3::field::SEQ (sequence)
seqan3::field::ID (identifier)
seqan3::field::BPP (annotated sequence)
seqan3::field::STRUCTURE (secondary structure)
seqan3::field::STRUCTURED_SEQ (sequence and structure in one range)
seqan3::field::ENERGY (minimum free energy)
seqan3::field::REACT (reactivity)
seqan3::field::REACT_ERR (reactivity error)
seqan3::field::COMMENT (free text)
seqan3::field::OFFSET (index of first sequence character)

The first three fields are retrieved by default (and in that order). The seqan3::field::STRUCTURED_SEQ may be selected to have sequence and structure directly stored in a more memory-efficient combined container. If you select this field you must not select seqan3::field::SEQ or seqan3::field::STRUCTURE.

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::cin or std::istringstream, that you want to read from and/or if you cannot use file-extension based detection, but know that your input file has a certain format.

In most cases the template parameters are deduced completely automatically:

structure_file_input sf{tmp_dir/"input.dbn"}; // Vienna with RNA sequences assumed, use regular std::ifstream as stream

Reading from an std::istringstream:

std::string const input
{
    ">S.cerevisiae_tRNA-PHE M10740/1-73\n"
    "GCGGAUUUAGCUCAGUUGGGAGAGCGCCAGACUGAAGAUUUGGAGGUCCUGUGUUCGAUCCACAGAAUUCGCA\n"
    "(((((((..((((........)))).((((.........)))).....(((((.......)))))))))))). (-17.50)\n"
    "> example\n"
    "UUGGAGUACACAACCUGUACACUCUUUC\n"
    "..(((((..(((...)))..)))))... (-3.71)\n"
};
std::istringstream iss(input);
structure_file_input fin{iss, format_vienna{}};
//                 ^ no need to specify the template arguments

Note that this is not the same as writing structure_file_input<> (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. For opening from file, structure_file_input<> would have also worked, but for opening from stream it would not have.

In some cases, you do need to specify the arguments, e.g. if you want to read amino acids:

structure_file_input<structure_file_input_default_traits_rna> fin{tmp_dir/"input.dbn"};

You can define your own traits type to further customise the types used by and returned by this class, see seqan3::structure_file_default_traits_rna for more details. As mentioned above, specifying at least one template parameter yourself means that you loose automatic deduction so if you want to read amino acids and want to read from a string stream you need to give all types yourself:

// ... input had amino acid sequences
std::istringstream iss(input);
structure_file_input<structure_file_input_default_traits_aa,
                     fields<field::SEQ, field::ID, field::STRUCTURE>,
                     type_list<format_vienna>,
                     char> fin{iss, format_vienna{}};

Reading record-wise

You can iterate over this file record-wise:

structure_file_input<structure_file_input_default_traits_aa,
                     fields<field::SEQ, field::ID, field::STRUCTURE>,
                     type_list<format_vienna>> fin{tmp_dir/"input_aa.dbn"};
for (auto & rec : fin)
{
    debug_stream << "ID: " << get<field::ID>(rec) << '\n';
    debug_stream << "SEQ: " << (get<field::SEQ>(rec) | view::to_char) << '\n'; // sequence is converted to char on-the-fly
    debug_stream << "STRUCTURE: " << (get<field::STRUCTURE>(rec) | view::to_char) << '\n';
}

In the above example, rec has the type record_type which is a specialisation of seqan3::record and behaves like an std::tuple (that's why we can access it via get). Instead of using the seqan3::field based interface on the record, you could also use std::get<0> or even std::get<rna4_vector> to retrieve the sequence, but it is not recommended, because it is more error-prone.

Note: It is important to write auto & and not just auto, otherwise you will copy the record on every iteration. Since the buffer gets "refilled" on every iteration, you can also move the data out of the record if you want to store it somewhere without copying:

structure_file_input fin{tmp_dir/"input.dbn"};
using record_type = typename decltype(fin)::record_type;
std::vector<record_type> records;
for (auto & rec : fin)
    records.push_back(std::move(rec));

Reading record-wise (decomposed records)

Instead of using get on the record, you can also use structured bindings to decompose the record into its elements:

structure_file_input<structure_file_input_default_traits_aa,
                     fields<field::SEQ, field::ID, field::STRUCTURE>,
                     type_list<format_vienna>> fin{tmp_dir/"input_aa.dbn"};
for (auto & [ seq, id, structure ] : fin)
{
    debug_stream << "ID: " << id << '\n';
    debug_stream << "SEQ: " << (seq | view::to_char) << '\n'; // sequence is converted to char on-the-fly
    debug_stream << "STRUCTURE: " << (structure | view::to_char) << '\n';
}

In this case you immediately get the three elements of the tuple: seq of seq_type, id of id_type and structure of structure_type. But beware: with structured bindings you do need to get the order of elements correctly!

Reading record-wise (custom fields)

If you want to skip specific fields from the record you can pass a non-empty fields trait object to the structure_file_input constructor to select the fields that should be read from the input. For example to choose a combined field for SEQ and STRUCTURE (see above). Or to never actually read the STRUCTURE, if you don't need it. The following snippets demonstrate the usage of such a fields trait object.

structure_file_input fin{tmp_dir/"input.dbn", fields<field::ID, field::STRUCTURED_SEQ>{}};
// note that the order is now different, "id" comes first, because it was specified first
for (auto & [ id, structured_seq ] : fin)
{
    debug_stream << "ID: " << id << '\n';
    // sequence and structure are part of the same vector, of type std::vector<structured_rna<rna5, wuss51>>
    debug_stream << "SEQ: "  << (structured_seq | view::get<0> | view::to_char) << '\n'; // sequence string is extracted and converted to char on-the-fly
    debug_stream << "STRUCTURE: " << (structured_seq | view::get<1> | view::to_char) << '\n'; // structure string is extracted and converted to char on-the-fly
}

When reading a file, all fields not present in the file (but requested implicitly or via the selected_field_ids parameter) are ignored.

Views on files

Since SeqAn files are ranges, you can also create views over files. A useful example is to filter the records based on certain criteria, e.g. minimum length of the sequence field:

structure_file_input fin{tmp_dir/"input.dbn"};
auto minimum_length5_filter = std::view::filter([] (auto const & rec)
{
    return size(get<field::SEQ>(rec)) >= 5;
});
for (auto & rec : fin | minimum_length5_filter) // only record with sequence length >= 5 will "appear"
{
    debug_stream << (get<0>(rec) | view::to_char) << '\n';
}

End of file

You can check whether a file is at end by comparing begin() and end() (if they are the same, the file is at end).

Column-based reading

The record-based interface treats the file as a range of tuples (the records), but in certain situations it is desirable to read the file by field, i.e. column wise (tuple-of-ranges, instead of range-of-tuples).

This interface is less flexible, but can save you copy operations in certain scenarios, given that you have sufficient memory to load the entire file at once:

struct data_storage_t
{
    concatenated_sequences<rna5_vector>         sequences;
    concatenated_sequences<std::string>         ids;
    concatenated_sequences<std::vector<wuss51>> structures;
};
data_storage_t data_storage; // a global or globally used variable in your program

// ... in your file reading function:
structure_file_input fin{tmp_dir/"input.dbn"};
data_storage.sequences  = std::move(get<field::SEQ>(fin));       // we move the buffer directly into our storage
data_storage.ids        = std::move(get<field::ID>(fin));        // we move the buffer directly into our storage
data_storage.structures = std::move(get<field::STRUCTURE>(fin)); // we move the buffer directly into our storage

Note that for this to make sense, your storage data types need to be identical to the corresponding column types of the file. If you require different column types you can specify you own traits, see seqan3::StructureFileInputTraits.

Formats

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

Constructor & Destructor Documentation

◆ structure_file_input() [1/3]

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>

seqan3::structure_file_input< traits_type_, selected_field_ids_, valid_formats_, stream_char_type_ >::structure_file_input	(	std::filesystem::path	filename,
		selected_field_ids const &	fields_tag = `selected_field_ids{}`
	)

inline

Construct from filename.

Parameters

[in]	filename	Path to the file you wish to open.
[in]	fields_tag	A seqan3::fields tag. [optional]

Exceptions

seqan3::file_open_error if the file could not be opened, e.g. non-existent, non-readable, unknown format.

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

Decompression

This constructor transparently applies a decompression stream on top of the file stream in case the file is detected as being compressed. See the section on compression and decompression for more information.

◆ structure_file_input() [2/3]

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>

template<IStream2 stream_t, StructureFileInputFormat file_format>

seqan3::structure_file_input< traits_type_, selected_field_ids_, valid_formats_, stream_char_type_ >::structure_file_input	(	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_format The format of the file in the stream, must satisfy seqan3::StructureFileInputFormat.

Parameters

[in]	stream	The stream to operate on; must be derived of std::basic_istream.
[in]	format_tag	The file format tag.
[in]	fields_tag	A seqan3::fields tag. [optional]

Decompression

This constructor transparently applies a decompression stream on top of the stream in case the file is detected as being compressed. See the section on compression and decompression for more information.

◆ structure_file_input() [3/3]

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>

template<IStream2 stream_t, StructureFileInputFormat file_format>

seqan3::structure_file_input< traits_type_, selected_field_ids_, valid_formats_, stream_char_type_ >::structure_file_input	(	stream_t &&	stream,
		file_format const &	format_tag,
		selected_field_ids const &	fields_tag = `selected_field_ids{}`
	)

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Member Function Documentation

◆ begin()

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>

iterator seqan3::structure_file_input< traits_type_, selected_field_ids_, valid_formats_, stream_char_type_ >::begin ( )

inlinenoexcept

Returns an iterator to current position in the file.

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

Equals end() if the file is at end.

Complexity

Constant.

Exceptions

No-throw guarantee.

◆ end()

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>

sentinel seqan3::structure_file_input< traits_type_, selected_field_ids_, valid_formats_, stream_char_type_ >::end ( )

inlinenoexcept

Returns a sentinel for comparison with iterator.

Returns: Iterator to the first element.

This element acts as a placeholder; attempting to dereference it results in undefined behaviour.

Complexity

Constant.

Exceptions

No-throw guarantee.

◆ front()

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>

reference seqan3::structure_file_input< traits_type_, selected_field_ids_, valid_formats_, stream_char_type_ >::front ( )

inlinenoexcept

Return the record we are currently at in the file.

Returns: A reference to the currently buffered record.

This function returns a reference to the currently buffered record, it is identical to dereferencing begin(), but begin also always points to the current record on single pass input ranges:

structure_file_input fin{tmp_dir/"input.dbn"};
auto it = begin(fin);
// the following are equivalent:
auto & rec0 = *it;
auto & rec1 = fin.front();
// both become invalid after incrementing "it"!

It most situations using the iterator interface or a range-based for-loop are preferable to using front(), because you can only move to the next record via the iterator.

In any case, don't forget the reference! If you want to save the data from the record elsewhere, use move:

structure_file_input fin{tmp_dir/"input.dbn"};
auto rec0 = std::move(fin.front());

Complexity

Constant.

Exceptions

No-throw guarantee.

Friends And Related Function Documentation

◆ get [1/5]

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>

template<field f>

auto&& get ( structure_file_input< traits_type_, selected_field_ids_, valid_formats_, stream_char_type_ > && file )

friend

Read the entire file into internal buffers and retrieve the specified column.

◆ get [2/5]

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>

template<size_t i>

auto& get ( structure_file_input< traits_type_, selected_field_ids_, valid_formats_, stream_char_type_ > & file )

friend

Read the entire file into internal buffers and retrieve the specified column.

◆ get [3/5]

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>

template<size_t i>

auto&& get ( structure_file_input< traits_type_, selected_field_ids_, valid_formats_, stream_char_type_ > && file )

friend

Read the entire file into internal buffers and retrieve the specified column.

◆ get [4/5]

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>

template<typename t >

auto& get ( structure_file_input< traits_type_, selected_field_ids_, valid_formats_, stream_char_type_ > & file )

friend

Read the entire file into internal buffers and retrieve the specified column.

◆ get [5/5]

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>

template<typename t >

auto&& get ( structure_file_input< traits_type_, selected_field_ids_, valid_formats_, stream_char_type_ > && file )

friend

Read the entire file into internal buffers and retrieve the specified column.

◆ structure_file_input()

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, selected_field_ids, type_list< file_format >, typename std::remove_reference_t< stream_type >::char_type >

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

seqan3/io/structure_file/input.hpp

Public Types

Public Member Functions

Public Attributes

Friends

Related Functions

Detailed Description

Introduction

Construction and specialisation

Reading record-wise

Reading record-wise (decomposed records)

Reading record-wise (custom fields)

Views on files

End of file

Column-based reading

Formats

Constructor & Destructor Documentation

◆ structure_file_input() [1/3]

Decompression

◆ structure_file_input() [2/3]

Decompression

◆ structure_file_input() [3/3]

Member Function Documentation

◆ begin()

Complexity

Exceptions

◆ end()

Complexity

Exceptions

◆ front()

Complexity

Exceptions

Friends And Related Function Documentation

◆ get [1/5]

◆ get [2/5]

◆ get [3/5]

◆ get [4/5]

◆ get [5/5]

◆ structure_file_input()