The SeqAn Cookbook

Table of Contents

• Read sequence files
• Construction and assignment of alphabet symbols
• Reverse complement and the six-frame translation of a string using views
• Reading records
• Reading records in chunks
• Applying a filter to a file
• Reading paired-end reads
• Storing records in a std::vector
• Writing records
• File conversion
• Define a custom scoring scheme
• Calculate edit distance for a set of sequences
• Searching for matches
• Reading the CIGAR information from a SAM file and constructing an alignment
• Map reads and write output to SAM file
• Constructing a basic argument parser
• Constructing a subcommand argument parser
• Serialise data structures with cereal
• Converting a range of an alphabet
• A custom dna4 alphabet that converts all unknown characters to A
• Controlling threads of (de-)compression streams
• Auto vectorized dna4 complement
• All SeqAn documentation snippets

This document provides example recipes on how to carry out particular tasks using the SeqAn functionalities in C++. Please note that these recipes are not ordered. You can use the links in the table of contents or the search function of your browser to navigate them.

It will take some time, but we hope to expand this document into containing numerous great examples. If you have suggestions for how to improve the Cookbook and/or examples you would like included, please feel free to contact us.

Read sequence files

#include <string>
 
#include <seqan3/core/debug_stream.hpp>      // for debug_stream
#include <seqan3/io/sequence_file/input.hpp> // for sequence_file_input
 
int main()
{
    std::filesystem::path tmp_dir = std::filesystem::temp_directory_path(); // get the tmp directory
 
    // Initialise a file input object with a FASTA file.
    seqan3::sequence_file_input file_in{tmp_dir / "seq.fasta"};
 
    // Retrieve the sequences and ids.
    for (auto & [seq, id, qual] : file_in)
    {
        seqan3::debug_stream << "ID:     " << id << '\n';
        seqan3::debug_stream << "SEQ:    " << seq << '\n';
        seqan3::debug_stream << "Empty Qual." << qual << '\n'; // qual is empty for FASTA files
    }
 
    return 0;
}

Construction and assignment of alphabet symbols

#include <seqan3/alphabet/all.hpp> // for working with alphabets directly
 
int main()
{
    using namespace seqan3::literals;
 
    // Two objects of seqan3::dna4 alphabet constructed with a char literal.
    seqan3::dna4 ade = 'A'_dna4;
    seqan3::dna4 gua = 'G'_dna4;
 
    // Two additional objects assigned explicitly from char or rank.
    seqan3::dna4 cyt, thy;
    cyt.assign_char('C');
    thy.assign_rank(3);
 
    // Further code here...

    return 0;
}

    // Get the rank type of the alphabet (here uint8_t).
    using rank_type = seqan3::alphabet_rank_t<seqan3::dna4>;
 
    // Retrieve the numerical representation (rank) of the objects.
    rank_type rank_a = ade.to_rank(); // => 0
    rank_type rank_g = gua.to_rank(); // => 2

Reverse complement and the six-frame translation of a string using views

This recipe creates a small program that

1. reads a string from the command line (first argument to the program)
2. "converts" the string to a range of seqan3::dna5 (Bonus: throws an exception if loss of information occurs)
3. prints the string and its reverse complement
4. prints the six-frame translation of the string

#include <ranges> // include all of the standard library's views
 
#include <seqan3/alphabet/views/all.hpp>  // include all of SeqAn's views
#include <seqan3/argument_parser/all.hpp> // optional: include the argument_parser
#include <seqan3/core/debug_stream.hpp>
 
int main(int argc, char ** argv)
{
    // We use the seqan3::argument_parser which was introduced in the second chapter
    // of the tutorial: "Parsing command line arguments with SeqAn".
    seqan3::argument_parser myparser{"Assignment-3", argc, argv}; // initialize
    std::string s{};
 
    myparser.add_positional_option(s, "Please specify the DNA string.");
 
    try
    {
        myparser.parse();
    }
    catch (seqan3::argument_parser_error const & ext) // the user did something wrong
    {
        std::cerr << "[PARSER ERROR]" << ext.what() << '\n'; // you can customize your error message
        return 0;
    }
 
    auto s_as_dna = s | seqan3::views::char_to<seqan3::dna5>;
    // Bonus:
    //auto s_as_dna = s | std::views::transform([] (char const c)
    //{
    //    return seqan3::assign_char_strictly_to(c, seqan3::dna5{});
    //});
 
    seqan3::debug_stream << "Original: " << s_as_dna << '\n';
    seqan3::debug_stream << "RevComp:  " << (s_as_dna | std::views::reverse | seqan3::views::complement) << '\n';
    seqan3::debug_stream << "Frames:   " << (s_as_dna | seqan3::views::translate) << '\n';
}

Reading records

After construction, you can now read the sequence records. Our file object behaves like a range, you can use a range-based for loop to conveniently iterate over the file:

#include <sstream>
 
#include <seqan3/core/debug_stream.hpp>
#include <seqan3/io/sequence_file/input.hpp>
 
auto input = R"(>TEST1
ACGT
>Test2
AGGCTGA
>Test3
GGAGTATAATATATATATATATAT)";
 
int main()
{
    seqan3::sequence_file_input fin{std::istringstream{input}, seqan3::format_fasta{}};
 
    for (auto & record : fin)
    {
        seqan3::debug_stream << "ID:  " << record.id() << '\n';
        seqan3::debug_stream << "SEQ: " << record.sequence() << '\n';
        // a quality field also exists, but is not printed, because we know it's empty for FASTA files.
    }
}

Attention

An input file is a single input range, which means you can only iterate over it once!

Note

It is important to write auto & and not just auto, otherwise you will copy the record on every iteration.

You can also use structured binding, i.e. for (auto & [seq, id, qual] : fin) But beware: with structured bindings you do need to get the order of elements correct!

You can also read a file in chunks:

Reading records in chunks

#include <seqan3/io/sequence_file/all.hpp>
#include <seqan3/utility/views/chunk.hpp>
 
int main()
{
    seqan3::sequence_file_input fin{std::filesystem::current_path() / "my.fastq"};
 
    // `&&` is important because seqan3::views::chunk returns temporaries!
    for (auto && records : fin | seqan3::views::chunk(10))
    {
        // `records` contains 10 elements (or less at the end)
        seqan3::debug_stream << "Taking the next 10 sequences:\n";
        seqan3::debug_stream << "ID:  " << (*records.begin()).id() << '\n'; // prints first ID in batch
    }

The example above will iterate over the file by reading 10 records at a time. If no 10 records are available anymore, it will just print the remaining records.

Applying a filter to a file

On some occasions you are only interested in sequence records that fulfill a certain criterion, e.g. having a minimum sequence length or a minimum average quality.

This recipe can be used to filter the sequences in your file by a custom criterion.

#include <numeric> // std::accumulate
#include <ranges>
 
#include <seqan3/core/debug_stream.hpp>
#include <seqan3/io/sequence_file/all.hpp>
 
int main()
{
    seqan3::sequence_file_input fin{std::filesystem::current_path() / "my.fastq"};
 
    // std::views::filter takes a function object (a lambda in this case) as input that returns a boolean
    auto minimum_quality_filter = std::views::filter(
        [](auto const & rec)
        {
            auto qualities = rec.base_qualities()
                           | std::views::transform(
                                 [](auto quality)
                                 {
                                     return seqan3::to_phred(quality);
                                 });
 
            auto sum = std::accumulate(qualities.begin(), qualities.end(), 0);
            return sum / std::ranges::size(qualities) >= 40; // minimum average quality >= 40
        });
 
    for (auto & rec : fin | minimum_quality_filter)
    {
        seqan3::debug_stream << "ID: " << rec.id() << '\n';
    }
}

Reading paired-end reads

In modern Next Generation Sequencing experiments you often have paired-end read data which is split into two files. The read pairs are identified by their identical name/id and position in the two files.

This recipe can be used to handle one pair of reads at a time.

#include <seqan3/io/sequence_file/all.hpp>
#include <seqan3/utility/views/zip.hpp>
 
int main()
{
    // for simplicity we take the same file
    seqan3::sequence_file_input fin1{std::filesystem::current_path() / "my.fastq"};
    seqan3::sequence_file_input fin2{std::filesystem::current_path() / "my.fastq"};
 
    for (auto && [rec1, rec2] : seqan3::views::zip(fin1, fin2)) // && is important!
    {                                                           // because seqan3::views::zip returns temporaries
        if (rec1.id() != rec2.id())
            throw std::runtime_error("Your pairs don't match.");
    }
}

Storing records in a std::vector

This recipe creates a small program that reads in a FASTA file and stores all the records in a std::vector.

#include <filesystem>
#include <ranges> // std::ranges::copy
 
#include <seqan3/core/debug_stream.hpp>
#include <seqan3/io/sequence_file/all.hpp>
 
int main()
{
    std::filesystem::path current_path = std::filesystem::current_path();
 
    seqan3::sequence_file_input fin{current_path / "my.fasta"};
 
    using record_type = decltype(fin)::record_type;
    std::vector<record_type> records{};
 
    // You can use a for loop:
    for (auto & record : fin)
    {
        records.push_back(std::move(record));
    }
 
    // But you can also do this:
    std::ranges::copy(fin, std::back_inserter(records));
 
    seqan3::debug_stream << records << '\n';
}

Note that you can move the record out of the file if you want to store it somewhere without copying.

#include <seqan3/io/sequence_file/all.hpp>
 
int main()
{
    seqan3::sequence_file_input fin{std::filesystem::current_path() / "my.fastq"};
    using record_type = typename decltype(fin)::record_type;
 
    record_type rec = std::move(*fin.begin()); // avoid copying
}

Writing records

The easiest way to write to a sequence file is to use the seqan3::sequence_file_output::push_back() or seqan3::sequence_file_output::emplace_back() member functions. These work similarly to how they work on a std::vector.

#include <string>
 
#include <seqan3/alphabet/nucleotide/dna5.hpp>
#include <seqan3/io/sequence_file/output.hpp>
#include <seqan3/io/sequence_file/record.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::sequence_file_output fout{std::cout, seqan3::format_fasta{}};
 
    using types = seqan3::type_list<std::vector<seqan3::dna5>, std::string>;
    using fields = seqan3::fields<seqan3::field::seq, seqan3::field::id>;
    using sequence_record_type = seqan3::sequence_record<types, fields>;
 
    for (int i = 0; i < 5; ++i) // ...
    {
        std::string id{"test_id"};
        seqan3::dna5_vector sequence{"ACGT"_dna5};
 
        sequence_record_type record{std::move(sequence), std::move(id)};
 
        fout.push_back(record);
    }
}

File conversion

#include <seqan3/io/sequence_file/all.hpp>
 
int main()
{
    auto current_path = std::filesystem::current_path();
 
    seqan3::sequence_file_output{current_path / "output.fasta"} =
        seqan3::sequence_file_input{current_path / "my.fastq"};
}

Define a custom scoring scheme

#include <seqan3/alignment/scoring/aminoacid_scoring_scheme.hpp>
#include <seqan3/alignment/scoring/nucleotide_scoring_scheme.hpp>

        using namespace seqan3::literals;
 
        // Define a simple scoring scheme with match and mismatch cost and get the score.
        seqan3::nucleotide_scoring_scheme nc_scheme{seqan3::match_score{4}, seqan3::mismatch_score{-5}};
        auto sc_nc = nc_scheme.score('A'_dna4, 'C'_dna4); // sc_nc == -5.
 
        // Define a amino acid similarity matrix and get the score.
        seqan3::aminoacid_scoring_scheme aa_scheme{};
        aa_scheme.set_similarity_matrix(seqan3::aminoacid_similarity_matrix::blosum30);
        auto sc_aa = aa_scheme.score('M'_aa27, 'K'_aa27); // sc_aa == 2.

Attention

SeqAn's alignment algorithm computes the maximal similarity score, thus the match score must be set to a positive value and the scores for mismatch and gap must be negative in order to maximize over the matching letters.

Calculate edit distance for a set of sequences

This recipe can be used to calculate the edit distance for all six pairwise combinations. Here we only allow at most 7 errors and filter all alignments with 6 or fewer errors.

#include <ranges>
#include <utility>
#include <vector>
 
#include <seqan3/alignment/pairwise/align_pairwise.hpp>
#include <seqan3/alignment/scoring/nucleotide_scoring_scheme.hpp>
#include <seqan3/alphabet/nucleotide/dna4.hpp>
#include <seqan3/core/debug_stream.hpp>
#include <seqan3/utility/views/pairwise_combine.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    std::vector vec{"ACGTGACTGACT"_dna4, "ACGAAGACCGAT"_dna4, "ACGTGACTGACT"_dna4, "AGGTACGAGCGACACT"_dna4};
 
    // Configure the alignment kernel.
    auto config = seqan3::align_cfg::method_global{} | seqan3::align_cfg::edit_scheme | seqan3::align_cfg::min_score{-7}
                | seqan3::align_cfg::output_score{};
 
    auto alignment_results = seqan3::align_pairwise(seqan3::views::pairwise_combine(vec), config);
    auto filter_v = std::views::filter(
        [](auto && res)
        {
            return res.score() >= -6;
        });
 
    for (auto const & result : alignment_results | filter_v)
    {
        seqan3::debug_stream << "Score: " << result.score() << '\n';
    }
}

Searching for matches

This recipe can be used to search for all occurrences of a substring and print the number of hits and the positions in an ascending ordering.

#include <seqan3/alphabet/nucleotide/dna4.hpp>
#include <seqan3/core/debug_stream.hpp>
#include <seqan3/search/fm_index/fm_index.hpp>
#include <seqan3/search/search.hpp>
 
using namespace seqan3::literals;
 
void run_text_single()
{
    seqan3::dna4_vector text{
        "CGCTGTCTGAAGGATGAGTGTCAGCCAGTGTAACCCGATGAGCTACCCAGTAGTCGAACTGGGCCAGACAACCCGGCGCTAATGCACTCA"_dna4};
    seqan3::fm_index index{text};
 
    seqan3::debug_stream << "=====   Running on a single text   =====\n"
                         << "The following hits were found:\n";
 
    for (auto && result : search("GCT"_dna4, index))
        seqan3::debug_stream << result << '\n';
}
 
void run_text_collection()
{
    std::vector<seqan3::dna4_vector> text{"CGCTGTCTGAAGGATGAGTGTCAGCCAGTGTA"_dna4,
                                          "ACCCGATGAGCTACCCAGTAGTCGAACTG"_dna4,
                                          "GGCCAGACAACCCGGCGCTAATGCACTCA"_dna4};
    seqan3::fm_index index{text};
 
    seqan3::debug_stream << "===== Running on a text collection =====\n"
                         << "The following hits were found:\n";
 
    for (auto && result : search("GCT"_dna4, index))
        seqan3::debug_stream << result << '\n';
}
 
int main()
{
    run_text_single();
    seqan3::debug_stream << '\n';
    run_text_collection();
}

If you want to allow errors in your query, you need to configure the approximate search with the following search configuration objects:

• seqan3::search_cfg::max_error_total: Maximum number of total errors
• seqan3::search_cfg::max_error_substitution: Maximum number of substitutions
• seqan3::search_cfg::max_error_insertion: Maximum number of insertions
• seqan3::search_cfg::max_error_deletion: Maximum number of deletions These are constructed with absolute numbers or rates:
• seqan3::search_cfg::error_count: Absolute number of errors
• seqan3::search_cfg::error_rate: Rate of errors \(\in[0,1]\)

To search for either 1 insertion or 1 deletion you can use the seqan3::search_cfg::error_count:

        std::string text{"Garfield the fat cat without a hat."};
        seqan3::fm_index index{text};
        seqan3::configuration const cfg = seqan3::search_cfg::max_error_total{seqan3::search_cfg::error_count{1}}
                                        | seqan3::search_cfg::max_error_substitution{seqan3::search_cfg::error_count{0}}
                                        | seqan3::search_cfg::max_error_insertion{seqan3::search_cfg::error_count{1}}
                                        | seqan3::search_cfg::max_error_deletion{seqan3::search_cfg::error_count{1}};
        seqan3::debug_stream << search("cat"s, index, cfg) << '\n';
        // prints: [<query_id:0, reference_id:0, reference_pos:14>,
        //          <query_id:0, reference_id:0, reference_pos:17>,
        //          <query_id:0, reference_id:0, reference_pos:18>,
        //          <query_id:0, reference_id:0, reference_pos:32>]

Reading the CIGAR information from a SAM file and constructing an alignment

This recipe can be used to:

1. Read in a FASTA file with the reference and a SAM file with the alignment
2. Filter the alignment records and only take those with a mapping quality >= 30.
3. For the resulting alignments, print which read was mapped against with reference id and the number of seqan3::gap's involved in the alignment (either in aligned reference or in read sequence).

#include <algorithm> // std::ranges::count
#include <filesystem>
#include <ranges>
#include <string>
#include <vector>
 
#include <seqan3/alignment/cigar_conversion/alignment_from_cigar.hpp>
#include <seqan3/alphabet/gap/gap.hpp>
#include <seqan3/alphabet/nucleotide/dna5.hpp>
#include <seqan3/core/debug_stream.hpp>
#include <seqan3/io/record.hpp>
#include <seqan3/io/sam_file/input.hpp>
#include <seqan3/io/sequence_file/input.hpp>
 
int main()
{
    std::filesystem::path current_path = std::filesystem::current_path();
 
    // read in reference information
    seqan3::sequence_file_input reference_file{current_path / "reference.fasta"};
 
    std::vector<std::string> reference_ids{};
    std::vector<seqan3::dna5_vector> reference_sequences{};
 
    for (auto && record : reference_file)
    {
        reference_ids.push_back(std::move(record.id()));
        reference_sequences.push_back(std::move(record.sequence()));
    }
 
    // filter out alignments
    seqan3::sam_file_input mapping_file{current_path / "mapping.sam", reference_ids, reference_sequences};
 
    auto mapq_filter = std::views::filter(
        [](auto & record)
        {
            return record.mapping_quality() >= 30;
        });
 
    for (auto & record : mapping_file | mapq_filter)
    {
        auto alignment = seqan3::alignment_from_cigar(record.cigar_sequence(),
                                                      reference_sequences[record.reference_id().value()],
                                                      record.reference_position().value(),
                                                      record.sequence());
 
        // as loop
        size_t sum_reference{};
        for (auto const & char_reference : std::get<0>(alignment))
            if (char_reference == seqan3::gap{})
                ++sum_reference;
 
        // or via std::ranges::count
        size_t sum_read = std::ranges::count(std::get<1>(alignment), seqan3::gap{});
 
        // The reference_id is ZERO based and an optional. -1 is represented by std::nullopt (= reference not known).
        std::optional reference_id = record.reference_id();
 
        seqan3::debug_stream << record.id() << " mapped against "
                             << (reference_id ? std::to_string(reference_id.value()) : "unknown reference") << " with "
                             << sum_read << " gaps in the read sequence and " << sum_reference
                             << " gaps in the reference sequence.\n";
    }
}

Map reads and write output to SAM file

For a full recipe on creating your own readmapper, see the very end of the tutorial Implementing your own read mapper with SeqAn.

void map_reads(std::filesystem::path const & query_path,
               std::filesystem::path const & index_path,
               std::filesystem::path const & sam_path,
               reference_storage_t & storage,
               uint8_t const errors)
{
    // we need the alphabet and text layout before loading
    seqan3::bi_fm_index<seqan3::dna5, seqan3::text_layout::collection> index;
    {
        std::ifstream is{index_path, std::ios::binary};
        cereal::BinaryInputArchive iarchive{is};
        iarchive(index);
    }
 
    seqan3::sequence_file_input query_file_in{query_path};
 
    seqan3::sam_file_output sam_out{sam_path,
                                    seqan3::fields<seqan3::field::seq,
                                                   seqan3::field::id,
                                                   seqan3::field::ref_id,
                                                   seqan3::field::ref_offset,
                                                   seqan3::field::cigar,
                                                   seqan3::field::qual,
                                                   seqan3::field::mapq>{}};
 
    seqan3::configuration const search_config =
        seqan3::search_cfg::max_error_total{seqan3::search_cfg::error_count{errors}}
        | seqan3::search_cfg::hit_all_best{};
 
    seqan3::configuration const align_config =
        seqan3::align_cfg::method_global{seqan3::align_cfg::free_end_gaps_sequence1_leading{true},
                                         seqan3::align_cfg::free_end_gaps_sequence2_leading{false},
                                         seqan3::align_cfg::free_end_gaps_sequence1_trailing{true},
                                         seqan3::align_cfg::free_end_gaps_sequence2_trailing{false}}
        | seqan3::align_cfg::edit_scheme | seqan3::align_cfg::output_alignment{}
        | seqan3::align_cfg::output_begin_position{} | seqan3::align_cfg::output_score{};
 
    for (auto && record : query_file_in)
    {
        auto & query = record.sequence();
        for (auto && result : search(query, index, search_config))
        {
            size_t start = result.reference_begin_position() ? result.reference_begin_position() - 1 : 0;
            std::span text_view{std::data(storage.seqs[result.reference_id()]) + start, query.size() + 1};
 
            for (auto && alignment : seqan3::align_pairwise(std::tie(text_view, query), align_config))
            {
                auto cigar = seqan3::cigar_from_alignment(alignment.alignment());
                size_t ref_offset = alignment.sequence1_begin_position() + 2 + start;
                size_t map_qual = 60u + alignment.score();
 
                sam_out.emplace_back(query,
                                     record.id(),
                                     storage.ids[result.reference_id()],
                                     ref_offset,
                                     cigar,
                                     record.base_qualities(),
                                     map_qual);
            }
        }
    }
}

Constructing a basic argument parser

#include <seqan3/argument_parser/all.hpp>
#include <seqan3/core/debug_stream.hpp>
 
void run_program(std::filesystem::path const & reference_path, std::filesystem::path const & index_path)
{
    seqan3::debug_stream << "reference_file_path: " << reference_path << '\n';
    seqan3::debug_stream << "index_path           " << index_path << '\n';
}
 
struct cmd_arguments
{
    std::filesystem::path reference_path{};
    std::filesystem::path index_path{"out.index"};
};
 
void initialise_argument_parser(seqan3::argument_parser & parser, cmd_arguments & args)
{
    parser.info.author = "E. coli";
    parser.info.short_description = "Creates an index over a reference.";
    parser.info.version = "1.0.0";
    parser.add_option(args.reference_path,
                      'r',
                      "reference",
                      "The path to the reference.",
                      seqan3::option_spec::required,
                      seqan3::input_file_validator{{"fa", "fasta"}});
    parser.add_option(args.index_path,
                      'o',
                      "output",
                      "The output index file path.",
                      seqan3::option_spec::standard,
                      seqan3::output_file_validator{seqan3::output_file_open_options::create_new, {"index"}});
}
 
int main(int argc, char const ** argv)
{
    seqan3::argument_parser parser("Indexer", argc, argv);
    cmd_arguments args{};
 
    initialise_argument_parser(parser, args);
 
    try
    {
        parser.parse();
    }
    catch (seqan3::argument_parser_error const & ext)
    {
        std::cerr << "[PARSER ERROR] " << ext.what() << '\n';
        return -1;
    }
 
    run_program(args.reference_path, args.index_path);
 
    return 0;
}

Constructing a subcommand argument parser

#include <seqan3/argument_parser/all.hpp>
#include <seqan3/core/debug_stream.hpp>
 
// =====================================================================================================================
// pull
// =====================================================================================================================
 
struct pull_arguments
{
    std::string repository{};
    std::string branch{};
    bool progress{false};
};
 
int run_git_pull(seqan3::argument_parser & parser)
{
    pull_arguments args{};
 
    parser.add_positional_option(args.repository, "The repository name to pull from.");
    parser.add_positional_option(args.branch, "The branch name to pull from.");
 
    try
    {
        parser.parse();
    }
    catch (seqan3::argument_parser_error const & ext)
    {
        seqan3::debug_stream << "[Error git pull] " << ext.what() << "\n";
        return -1;
    }
 
    seqan3::debug_stream << "Git pull with repository " << args.repository << " and branch " << args.branch << '\n';
 
    return 0;
}
 
// =====================================================================================================================
// push
// =====================================================================================================================
 
struct push_arguments
{
    std::string repository{};
    std::vector<std::string> branches{};
    bool push_all{false};
};
 
int run_git_push(seqan3::argument_parser & parser)
{
    push_arguments args{};
 
    parser.add_positional_option(args.repository, "The repository name to push to.");
    parser.add_positional_option(args.branches, "The branch names to push (if none are given, push current).");
 
    try
    {
        parser.parse();
    }
    catch (seqan3::argument_parser_error const & ext)
    {
        seqan3::debug_stream << "[Error git push] " << ext.what() << "\n";
        return -1;
    }
 
    seqan3::debug_stream << "Git push with repository " << args.repository << " and branches " << args.branches << '\n';
 
    return 0;
}
 
// =====================================================================================================================
// main
// =====================================================================================================================
 
int main(int argc, char const ** argv)
{
    seqan3::argument_parser top_level_parser{"mygit", argc, argv, seqan3::update_notifications::on, {"push", "pull"}};
 
    // Add information and flags, but no (positional) options to your top-level parser.
    // Because of ambiguity, we do not allow any (positional) options for the top-level parser.
    top_level_parser.info.description.push_back("You can push or pull from a remote repository.");
    // A flag's default value must be false.
    bool flag{false};
    top_level_parser.add_flag(flag, 'f', "flag", "some flag");
 
    try
    {
        top_level_parser.parse(); // trigger command line parsing
    }
    catch (seqan3::argument_parser_error const & ext) // catch user errors
    {
        seqan3::debug_stream << "[Error] " << ext.what() << "\n"; // customise your error message
        return -1;
    }
 
    seqan3::argument_parser & sub_parser = top_level_parser.get_sub_parser(); // hold a reference to the sub_parser
 
    std::cout << "Proceed to sub parser.\n";
 
    if (sub_parser.info.app_name == std::string_view{"mygit-pull"})
        return run_git_pull(sub_parser);
    else if (sub_parser.info.app_name == std::string_view{"mygit-push"})
        return run_git_push(sub_parser);
    else
        std::cout << "Unhandled subparser named " << sub_parser.info.app_name << '\n';
    // Note: Arriving in this else branch means you did not handle all sub_parsers in the if branches above.
 
    return 0;
}

Serialise data structures with cereal

#include <fstream>
#include <vector>
 
#include <seqan3/core/debug_stream.hpp>
#include <seqan3/test/tmp_directory.hpp>
 
#include <cereal/archives/binary.hpp> // includes the cereal::BinaryInputArchive and cereal::BinaryOutputArchive
#include <cereal/types/vector.hpp> // includes cerealisation support for std::vector
 
// Written for std::vector, other types also work.
void load(std::vector<int16_t> & data, std::filesystem::path const & tmp_file)
{
    std::ifstream is(tmp_file, std::ios::binary); // Where input can be found.
    cereal::BinaryInputArchive archive(is);       // Create an input archive from the input stream.
    archive(data);                                // Load data.
}
 
// Written for std::vector, other types also work.
void store(std::vector<int16_t> const & data, std::filesystem::path const & tmp_file)
{
    std::ofstream os(tmp_file, std::ios::binary); // Where output should be stored.
    cereal::BinaryOutputArchive archive(os);      // Create an output archive from the output stream.
    archive(data);                                // Store data.
}
 
int main()
{
    // The following example is for a std::vector but any seqan3 data structure that is documented as serialisable
    // could be used, e.g. seqan3::fm_index.
    seqan3::test::tmp_directory tmp{};
    auto tmp_file = tmp.path() / "data.out"; // This is a temporary file name, use any other filename.
 
    std::vector<int16_t> vec{1, 2, 3, 4};
    store(vec, tmp_file); // Calls store on a std::vector.
    // This vector is needed to load the information into it.
    std::vector<int16_t> vec2;
    load(vec2, tmp_file); // Calls load on a std::vector.
 
    seqan3::debug_stream << vec2 << '\n'; // Prints [1,2,3,4].
 
    return 0;
}

Converting a range of an alphabet

#include <seqan3/alphabet/nucleotide/dna4.hpp>
#include <seqan3/alphabet/nucleotide/dna5.hpp>
#include <seqan3/alphabet/quality/aliases.hpp>
#include <seqan3/alphabet/quality/phred42.hpp>
#include <seqan3/alphabet/quality/qualified.hpp>
#include <seqan3/core/debug_stream.hpp>
 
using seqan3::operator""_dna4;
using seqan3::operator""_dna5;
using seqan3::operator""_phred42;
 
int main()
{
    // A vector of combined sequence and quality information.
    std::vector<seqan3::dna4q> sequence1{{'A'_dna4, '!'_phred42},
                                         {'C'_dna4, 'A'_phred42},
                                         {'G'_dna4, '6'_phred42},
                                         {'T'_dna4, '&'_phred42}};
    // A vector of dna5.
    std::vector<seqan3::dna5> sequence2{"AGNCGTNNCAN"_dna5};
 
    // Convert dna4q to dna4.
    // Since `sequence1` is an lvalue, we capture `in` via const &. When unsure, use the general case below.
    auto view1 = sequence1
               | std::views::transform(
                     [](auto const & in)
                     {
                         return static_cast<seqan3::dna4>(in);
                     });
    seqan3::debug_stream << view1 << '\n'; // ACGT
 
    // Convert dna5 to dna4.
    // General case: Perfect forward.
    auto view2 = sequence2 | std::views::take(8)
               | std::views::transform(
                     [](auto && in)
                     {
                         return static_cast<seqan3::dna4>(std::forward<decltype(in)>(in));
                     });
    seqan3::debug_stream << view2 << '\n'; // AGACGTAA
 
    return 0;
}

A custom dna4 alphabet that converts all unknown characters to A

When assigning from char or converting from a larger nucleotide alphabet to a smaller one, loss of information can occur since obviously some bases are not available. When converting to seqan3::dna5 or seqan3::rna5, non-canonical bases (letters other than A, C, G, T, U) are converted to 'N' to preserve ambiguity at that position. For seqan3::dna4 and seqan3::rna4 there is no letter 'N' to represent ambiguity, so the conversion from char for IUPAC characters tries to choose the best fitting alternative (see seqan3::dna4 for more details).

If you would like to always convert unknown characters to A instead, you can create your own alphabet with a respective char conversion table very easily like this:

#include <seqan3/alphabet/nucleotide/nucleotide_base.hpp>
#include <seqan3/core/debug_stream.hpp>
 
// clang-format off
// We inherit from seqan3::nucleotide_base s.t. we do not need to implement the full nucleotide interface
// but it is sufficient to define `rank_to_char`, `char_to_rank`, and `complement_table`.
class my_dna4 : public seqan3::nucleotide_base<my_dna4, 4 /*alphabet size is 4*/>
{
public:
    using nucleotide_base<my_dna4, 4>::nucleotide_base; // Use constructors of the base class.
 
private:
    // Returns the character representation of rank. This is where rank conversion for to_char() is handled!
    static constexpr char_type rank_to_char(rank_type const rank)
    {
        return rank_to_char_table[rank];
    }
 
    // Returns the rank representation of character. This is where char conversion for assign_char() is handled!
    static constexpr rank_type char_to_rank(char_type const chr)
    {
        using index_t = std::make_unsigned_t<char_type>;
        return char_to_rank_table[static_cast<index_t>(chr)];
    }
 
    // Returns the complement by rank. This is where complement is handled and with this, my_dna4 models
    // seqan3::nucleotide_alphabet.
    static constexpr rank_type rank_complement(rank_type const rank)
    {
        return rank_complement_table[rank];
    }
 
private:
    // === lookup-table implementation detail ===
 
    // Value to char conversion table.
    static constexpr char_type rank_to_char_table[alphabet_size]{'A', 'C', 'G', 'T'}; // rank 0,1,2,3
 
    // Char-to-value conversion table.
    static constexpr std::array<rank_type, 256> char_to_rank_table
    {
        [] () constexpr
        {
            // By default, everything has rank 0 which equals `A`.
            std::array<rank_type, 256> conversion_table{};
 
            conversion_table['C'] = conversion_table['c'] = 1;
            conversion_table['G'] = conversion_table['g'] = 2;
            conversion_table['T'] = conversion_table['t'] = 3;
            conversion_table['U'] = conversion_table['T']; // set U equal to T
            conversion_table['u'] = conversion_table['t']; // set u equal to t
 
            return conversion_table;
        }()
    };
 
    // The rank complement table.
    static constexpr rank_type rank_complement_table[alphabet_size]
    {
        3, // T is complement of 'A'_dna4
        2, // G is complement of 'C'_dna4
        1, // C is complement of 'G'_dna4
        0  // A is complement of 'T'_dna4
    };
 
    friend nucleotide_base<my_dna4, 4>; // Grant seqan3::nucleotide_base access to private/protected members.
    friend nucleotide_base<my_dna4, 4>::base_t; // Grant seqan3::alphabet_base access to private/protected members.
};
// clang-format on
 
// Defines the `_my_dna4` *char literal* so you can write `'C'_my_dna4` instead of `my_dna4{}.assign_char('C')`.
constexpr my_dna4 operator""_my_dna4(char const c) noexcept
{
    return my_dna4{}.assign_char(c);
}
 
int main()
{
    my_dna4 my_letter{'C'_my_dna4};
 
    my_letter.assign_char('S'); // Characters other than A,C,G,T are implicitly converted to `A`.
 
    seqan3::debug_stream << my_letter << "\n";                     // "A";
    seqan3::debug_stream << seqan3::complement(my_letter) << "\n"; // "T";
}

If you are interested in custom alphabets, also take a look at our tutorial How to write your own alphabet.

Controlling threads of (de-)compression streams

When reading or writing compressed files, parallelisation is automatically applied when using BGZF-compressed files, e.g., BAM files. This will use 4 threads by default and can be adjusted by setting seqan3::contrib::bgzf_thread_count to the desired value:

#    include <seqan3/io/all.hpp>
 
// The `bgzf_thread_count` is a variable that can only be changed during the runtime of a program.
// The following does not work, the value must be overwritten within a function:
// seqan3::contrib::bgzf_thread_count = 1u; // Does not work.
 
int main()
{
    // Here, we change the number of threads to `1`.
    // This is a global change and will affect every future bgzf (de-)compression.
    // However, running (de-)compressions will not be affected.
    // `bgzf_thread_count` may be overwritten multiple times during the runtime of a program, in which case
    // the latest modification will determine the value.
    seqan3::contrib::bgzf_thread_count = 1u;
 
    // Read/Write compressed files.
    // ...
    return 0;
}

Auto vectorized dna4 complement

Our alphabet seqan3::dna4 cannot be easily auto-vectorized by the compiler.

See this discussion for more details.

You can add your own alphabet that is auto-vectorizable in some use cases. Here is an example for a dna4-like alphabet:

class simd_dna4 : public seqan3::nucleotide_base<simd_dna4, 256>
{
private:
    using base_t = seqan3::nucleotide_base<simd_dna4, 256>;
 
    friend base_t;         // nucleotide_base
    friend base_t::base_t; // alphabet_base
    friend seqan3::rna4;
 
public:
    constexpr simd_dna4() noexcept = default;
    constexpr simd_dna4(simd_dna4 const &) noexcept = default;
    constexpr simd_dna4(simd_dna4 &&) noexcept = default;
    constexpr simd_dna4 & operator=(simd_dna4 const &) noexcept = default;
    constexpr simd_dna4 & operator=(simd_dna4 &&) noexcept = default;
    ~simd_dna4() noexcept = default;
 
    template <std::same_as<seqan3::rna4> t> // template parameter t to accept incomplete type
    constexpr simd_dna4(t const r) noexcept
    {
        assign_rank(r.to_rank());
    }
 
    using base_t::assign_rank;
    using base_t::base_t;
    using base_t::to_rank;
 
    static constexpr uint8_t alphabet_size = 4;
 
    constexpr simd_dna4 & assign_char(char_type const c) noexcept
    {
        char_type const upper_case_char = c & 0b0101'1111;
        rank_type rank = (upper_case_char == 'T') * 3 + (upper_case_char == 'G') * 2 + (upper_case_char == 'C');
        return assign_rank(rank);
    }
 
    constexpr char_type to_char() const noexcept
    {
        rank_type const rank = to_rank();
        switch (rank)
        {
        case 0u:
            return 'A';
        case 1u:
            return 'C';
        case 2u:
            return 'G';
        default:
            return 'T';
        }
    }
 
    constexpr simd_dna4 complement() const noexcept
    {
        rank_type rank{to_rank()};
        rank ^= 0b11;
        simd_dna4 ret{};
        return ret.assign_rank(rank);
    }
 
    static constexpr bool char_is_valid(char_type const c) noexcept
    {
        char_type const upper_case_char = c & 0b0101'1111;
        return (upper_case_char == 'A') || (upper_case_char == 'C') || (upper_case_char == 'G')
            || (upper_case_char == 'T');
    }
};

All SeqAn documentation snippets

The following lists all snippets that appear in our documentation. Search for keywords with Strg + F.

#include <seqan3/alignment/cigar_conversion/alignment_from_cigar.hpp>
#include <seqan3/alphabet/cigar/cigar.hpp>
#include <seqan3/alphabet/nucleotide/dna5.hpp>
#include <seqan3/core/debug_stream.hpp>
 
using namespace seqan3::literals;
 
int main()
{
    // CIGAR string = 2M1D2M
    std::vector<seqan3::cigar> cigar_vector{{2, 'M'_cigar_operation},
                                            {1, 'D'_cigar_operation},
                                            {2, 'M'_cigar_operation}};
 
    uint32_t reference_start_position{0}; // The read is aligned at the start of the reference.
    seqan3::dna5_vector reference = "ACTGATCGAGAGGATCTAGAGGAGATCGTAGGAC"_dna5;
    seqan3::dna5_vector query = "ACGA"_dna5;
 
    auto alignment = alignment_from_cigar(cigar_vector, reference, reference_start_position, query);
 
    seqan3::debug_stream << alignment << '\n'; // prints (ACTGA,AC-GA)
}

#include <seqan3/alignment/cigar_conversion/alignment_from_cigar.hpp>
#include <seqan3/core/debug_stream.hpp>
#include <seqan3/io/sam_file/all.hpp>
 
using namespace seqan3::literals;
 
auto sam_file_raw = R"(@HD  VN:1.6
@SQ SN:ref  LN:34
read1   41  ref 1   61  1S1M1D1M1I  ref 10  300 ACGT    !##$    AS:i:2  NM:i:7
read2   42  ref 2   62  1H7M1D1M1S2H    ref 10  300 AGGCTGNAG   !##$&'()*   xy:B:S,3,4,5
read3   43  ref 3   63  1S1M1P1M1I1M1I1D1M1S    ref 10  300 GGAGTATA    !!*+,-./
)";
 
int main()
{
    // The reference sequence might be read from a different file.
    seqan3::dna5_vector reference = "ACTGATCGAGAGGATCTAGAGGAGATCGTAGGAC"_dna5;
 
    seqan3::sam_file_input fin{std::istringstream{sam_file_raw}, seqan3::format_sam{}};
    // You will probably read it from a file, e.g., like this:
    // seqan3::sam_file_input fin{"test.sam"};
 
    for (auto && rec : fin)
    {
        auto alignment =
            alignment_from_cigar(rec.cigar_sequence(), reference, rec.reference_position().value(), rec.sequence());
        seqan3::debug_stream << alignment << '\n';
    }
 
    // prints:
    // (ACT-,C-GT)
    // (CTGATCGAG,AGGCTGN-A)
    // (T-G-A-TC,G-AGTA-T)
}

#include <seqan3/alignment/aligned_sequence/aligned_sequence_concept.hpp>
#include <seqan3/alignment/cigar_conversion/cigar_from_alignment.hpp>
#include <seqan3/alignment/decorator/gap_decorator.hpp>
#include <seqan3/alphabet/gap/gapped.hpp>
#include <seqan3/alphabet/nucleotide/dna5.hpp>
#include <seqan3/core/debug_stream.hpp>
#include <seqan3/utility/views/slice.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::dna5_vector reference = "ATGGCGTAGAGCTTCCCCCCCCCCCCCCCCC"_dna5;
    seqan3::dna5_vector read = "ATGCCCCGTTGCTT"_dna5; // length 14
 
    // Align the full query against the first 14 bases of the reference.
    seqan3::gap_decorator aligned_reference{reference | seqan3::views::slice(0, 14)};
    seqan3::gap_decorator aligned_read{read};
    // Insert gaps to represent the alignment:
    seqan3::insert_gap(aligned_read, aligned_read.begin() + 11, 2);
    seqan3::insert_gap(aligned_reference, aligned_reference.begin() + 4, 2);
 
    seqan3::debug_stream << aligned_reference << '\n' << aligned_read << '\n';
    // prints:
    // ATGG--CGTAGAGCTT
    // ATGCCCCGTTG--CTT
 
    auto cigar_sequence = seqan3::cigar_from_alignment(std::tie(aligned_reference, aligned_read));
 
    seqan3::debug_stream << cigar_sequence << '\n'; // prints [4M,2I,5M,2D,3M]
}

#include <seqan3/alignment/aligned_sequence/aligned_sequence_concept.hpp>
#include <seqan3/alignment/cigar_conversion/cigar_from_alignment.hpp>
#include <seqan3/alignment/decorator/gap_decorator.hpp>
#include <seqan3/alphabet/gap/gapped.hpp>
#include <seqan3/alphabet/nucleotide/dna5.hpp>
#include <seqan3/core/debug_stream.hpp>
#include <seqan3/utility/views/slice.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::dna5_vector reference = "ATGGCGTAGAGCTTCCCCCCCCCCCCCCCCC"_dna5;
    seqan3::dna5_vector read = "ATGCCCCGTTGCTT"_dna5; // length 14
 
    // Let's say, we want to ignore the last 2 bases of the query because the quality is low.
    // We thus only align the first 12 bases, the last two will be soft-clipped bases in the CIGAR string.
    seqan3::gap_decorator aligned_reference{reference | seqan3::views::slice(0, 12)};
    seqan3::gap_decorator aligned_query{read | seqan3::views::slice(0, 12)};
    // insert gaps
    seqan3::insert_gap(aligned_reference, aligned_reference.begin() + 4, 2);
    seqan3::insert_gap(aligned_query, aligned_query.begin() + 11, 2);
 
    auto cigar_sequence =
        seqan3::cigar_from_alignment(std::tie(aligned_reference, aligned_query),
                                     {.hard_front = 1, .hard_back = 0, .soft_front = 0, .soft_back = 2});
 
    seqan3::debug_stream << cigar_sequence << '\n'; // prints [1H,4M,2I,5M,2D,1M,2S]
}

#include <seqan3/alignment/configuration/align_config_band.hpp>
 
int main()
{
    // A symmetric band around the main diagonal.
    seqan3::align_cfg::band_fixed_size band_cfg{seqan3::align_cfg::lower_diagonal{-4},
                                                seqan3::align_cfg::upper_diagonal{4}};
 
    // A band starting with the main diagonal shifted by 3 cells to the right.
    seqan3::align_cfg::band_fixed_size band_cfg_hi{seqan3::align_cfg::lower_diagonal{3},
                                                   seqan3::align_cfg::upper_diagonal{7}};
 
    // A band starting with the main diagonal shifted by 3 cells down.
    seqan3::align_cfg::band_fixed_size band_cfg_lo{seqan3::align_cfg::lower_diagonal{-7},
                                                   seqan3::align_cfg::upper_diagonal{-3}};
 
    // An invalid band configuration.
    // Using this band as a configuration in seqan3::align_pairwise would cause the algorithm to throw an exception.
    seqan3::align_cfg::band_fixed_size band_cfg_invalid{seqan3::align_cfg::lower_diagonal{7},
                                                        seqan3::align_cfg::upper_diagonal{3}};
}

#include <seqan3/alignment/configuration/align_config_edit.hpp>
#include <seqan3/alignment/configuration/align_config_method.hpp>
#include <seqan3/alignment/configuration/align_config_min_score.hpp>
 
int main()
{
    // Computes semi global edit distance using fast-bit vector algorithm.
    auto cfg_fast = seqan3::align_cfg::method_global{seqan3::align_cfg::free_end_gaps_sequence1_leading{true},
                                                     seqan3::align_cfg::free_end_gaps_sequence2_leading{false},
                                                     seqan3::align_cfg::free_end_gaps_sequence1_trailing{true},
                                                     seqan3::align_cfg::free_end_gaps_sequence2_trailing{false}}
                  | seqan3::align_cfg::edit_scheme;
 
    // Computes semi global edit distance using slower standard pairwise algorithm.
    auto cfg_slow = seqan3::align_cfg::method_global{seqan3::align_cfg::free_end_gaps_sequence1_leading{false},
                                                     seqan3::align_cfg::free_end_gaps_sequence2_leading{true},
                                                     seqan3::align_cfg::free_end_gaps_sequence1_trailing{false},
                                                     seqan3::align_cfg::free_end_gaps_sequence2_trailing{true}}
                  | seqan3::align_cfg::edit_scheme;
 
    // Computes global distance allowing a minimal score of 3 (Default: edit distance).
    auto cfg_errors =
        seqan3::align_cfg::method_global{} | seqan3::align_cfg::edit_scheme | seqan3::align_cfg::min_score{-3};
}

#include <iostream>
 
#include <seqan3/alignment/configuration/align_config_gap_cost_affine.hpp>
 
int main()
{
    // Configuration with linear gap costs.
    seqan3::align_cfg::gap_cost_affine linear_cfg{seqan3::align_cfg::open_score{0},
                                                  seqan3::align_cfg::extension_score{-1}};
 
    // Configuration with affine gap costs. Score for opening a gap during the alignment algorithm will be -11.
    seqan3::align_cfg::gap_cost_affine affine_cfg{seqan3::align_cfg::open_score{-1},
                                                  seqan3::align_cfg::extension_score{-10}};
 
    // Accessing the members of the gap scheme
    int open = affine_cfg.open_score;
    int extension = affine_cfg.extension_score;
    std::cout << open << '\n';      // -1
    std::cout << extension << '\n'; // -10
}

#include <seqan3/alignment/configuration/align_config_method.hpp>
#include <seqan3/alignment/configuration/align_config_scoring_scheme.hpp>
#include <seqan3/alignment/pairwise/align_pairwise.hpp>
#include <seqan3/alignment/scoring/nucleotide_scoring_scheme.hpp>
#include <seqan3/alphabet/nucleotide/dna4.hpp>
#include <seqan3/core/debug_stream.hpp>
 
using namespace seqan3::literals;
 
int main()
{
    // configure a global alignment for DNA sequences
    auto min_cfg = seqan3::align_cfg::method_global{}
                 | seqan3::align_cfg::scoring_scheme{
                     seqan3::nucleotide_scoring_scheme{seqan3::match_score{4}, seqan3::mismatch_score{-5}}};
 
    auto seq1 = "TCGT"_dna4;
    auto seq2 = "ACGA"_dna4;
    for (auto res : seqan3::align_pairwise(std::tie(seq1, seq2), min_cfg))
        seqan3::debug_stream << res.score() << '\n'; // print out the alignment score
}

#include <seqan3/alignment/configuration/align_config_method.hpp>
#include <seqan3/alignment/configuration/align_config_scoring_scheme.hpp>
#include <seqan3/alignment/pairwise/align_pairwise.hpp>
#include <seqan3/alignment/scoring/nucleotide_scoring_scheme.hpp>
#include <seqan3/alphabet/nucleotide/dna4.hpp>
#include <seqan3/core/debug_stream.hpp>
 
using namespace seqan3::literals;
 
int main()
{
    // configure a local alignment for DNA sequences
    auto min_cfg = seqan3::align_cfg::method_local{}
                 | seqan3::align_cfg::scoring_scheme{
                     seqan3::nucleotide_scoring_scheme{seqan3::match_score{4}, seqan3::mismatch_score{-5}}};
 
    auto seq1 = "TCGT"_dna4;
    auto seq2 = "ACGA"_dna4;
    for (auto res : seqan3::align_pairwise(std::tie(seq1, seq2), min_cfg))
        seqan3::debug_stream << res.score() << '\n'; // print out the alignment score
}

#include <seqan3/alignment/configuration/align_config_min_score.hpp>
#include <seqan3/core/configuration/configuration.hpp>
 
int main()
{
    // Allow a minimal score of -5, i.e. at most 5 edit operations.
    seqan3::configuration config = seqan3::align_cfg::min_score{-5};
    auto min_score = std::get<seqan3::align_cfg::min_score>(config);
    min_score.score = -5;
}

#include <seqan3/alignment/configuration/align_config_on_result.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    seqan3::align_cfg::on_result cfg{[](auto && result)
                                     {
                                         seqan3::debug_stream << result << '\n';
                                     }};
}

#include <seqan3/alignment/configuration/align_config_output.hpp>
 
int main()
{
    // Compute only the alignment.
    seqan3::configuration cfg = seqan3::align_cfg::output_alignment{};
}

#include <seqan3/alignment/configuration/align_config_output.hpp>
 
int main()
{
    // Compute only the begin position of the aligned sequences.
    seqan3::configuration cfg = seqan3::align_cfg::output_begin_position{};
}

#include <seqan3/alignment/configuration/align_config_output.hpp>
 
int main()
{
    // Compute only the end position of the aligned sequences.
    seqan3::configuration cfg = seqan3::align_cfg::output_end_position{};
}

#include <vector>
 
#include <seqan3/alignment/configuration/align_config_edit.hpp>
#include <seqan3/alignment/pairwise/align_pairwise.hpp>
#include <seqan3/alphabet/nucleotide/dna4.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    // Basic alignment algorithm configuration.
    auto config = seqan3::align_cfg::method_global{} | seqan3::align_cfg::edit_scheme;
 
    std::pair p{"ACGTAGC"_dna4, "AGTACGACG"_dna4};
 
    // Compute only the score:
    for (auto res : seqan3::align_pairwise(p, config | seqan3::align_cfg::output_score{}))
        seqan3::debug_stream << res << "\n"; // prints: {score: -4}
 
    // Compute only the alignment:
    for (auto res : seqan3::align_pairwise(p, config | seqan3::align_cfg::output_alignment{}))
        seqan3::debug_stream << res << "\n"; // prints: {alignment: (ACGTA-G-C-,A-GTACGACG)}
 
    // Compute the score and the alignment:
    for (auto res :
         seqan3::align_pairwise(p, config | seqan3::align_cfg::output_score{} | seqan3::align_cfg::output_alignment{}))
        seqan3::debug_stream << res << "\n"; // prints: {score: -4, alignment: (ACGTA-G-C-,A-GTACGACG)}
 
    // By default compute everything:
    for (auto res : seqan3::align_pairwise(p, config))
        seqan3::debug_stream
            << res << "\n"; // prints {id: 0, score: -4, begin: (0,0), end: (7,9) alignment: (ACGTA-G-C-,A-GTACGACG)}
}

#include <seqan3/alignment/configuration/align_config_output.hpp>
 
int main()
{
    // Compute only the score.
    seqan3::configuration cfg = seqan3::align_cfg::output_score{};
}

#include <seqan3/alignment/configuration/align_config_output.hpp>
 
int main()
{
    // Output only the id of the first sequence.
    seqan3::configuration cfg = seqan3::align_cfg::output_sequence1_id{};
}

#include <seqan3/alignment/configuration/align_config_output.hpp>
 
int main()
{
    // Output only the id of the second sequence.
    seqan3::configuration cfg = seqan3::align_cfg::output_sequence2_id{};
}

#include <thread>
 
#include <seqan3/alignment/configuration/align_config_parallel.hpp>
 
int main()
{
    // Enables parallel computation with two threads.
    seqan3::align_cfg::parallel cfg_2{2};
 
    // Enables parallel computation with the number of concurrent threads supported by the current architecture.
    seqan3::align_cfg::parallel cfg_n{std::thread::hardware_concurrency()};
    ;
}

#include <seqan3/alignment/configuration/align_config_score_type.hpp>
#include <seqan3/core/configuration/configuration.hpp>
 
int main()
{
    // Compute only the score.
    seqan3::configuration cfg1 =
        seqan3::align_cfg::score_type<int16_t>{};                        // Now the alignment computes 16 bit integers.
    seqan3::configuration cfg2 = seqan3::align_cfg::score_type<float>{}; // Now the alignment computes float scores.
}

#include <seqan3/alignment/configuration/align_config_vectorised.hpp>
 
int main()
{
    // Enable SIMD vectorised alignment computation.
    auto cfg = seqan3::align_cfg::vectorised{};
}

#include <seqan3/alignment/configuration/align_config_method.hpp>
#include <seqan3/alignment/configuration/align_config_scoring_scheme.hpp>
#include <seqan3/alignment/pairwise/align_pairwise.hpp>
#include <seqan3/alignment/scoring/nucleotide_scoring_scheme.hpp>
#include <seqan3/alphabet/nucleotide/dna4.hpp>
#include <seqan3/core/debug_stream.hpp>
 
using namespace seqan3::literals;
 
int main()
{
    auto min_cfg = seqan3::align_cfg::method_global{}
                 | seqan3::align_cfg::scoring_scheme{
                     seqan3::nucleotide_scoring_scheme{seqan3::match_score{4}, seqan3::mismatch_score{-5}}};
 
    auto seq1 = "ACGT"_dna4;
    auto seq2 = "ACCT"_dna4;
    for (auto res : align_pairwise(std::tie(seq1, seq2), min_cfg))
        seqan3::debug_stream << res.score() << '\n';
}

#include <span>
#include <vector>
 
#include <seqan3/alignment/matrix/detail/alignment_matrix_column_major_range_base.hpp>
#include <seqan3/core/debug_stream.hpp>
 
class my_matrix : public seqan3::detail::alignment_matrix_column_major_range_base<my_matrix>
{
public:
    // Alias the base class
    using base_t = seqan3::detail::alignment_matrix_column_major_range_base<my_matrix>;
 
    friend base_t;
 
    // Inherit the alignment column type defined in the base class. This type is returned in initialise_column.
    using typename base_t::alignment_column_type;
 
    // The following types are required by the base type since they cannot be inferred within the base.
 
    using column_data_view_type = std::span<int>; //This type is the underlying view over the actual memory location.
    using value_type = int;                       // The actual value type.
    using reference = int &;                      // The actual reference type.
 
    my_matrix() = default;
    my_matrix(my_matrix const &) = default;
    my_matrix(my_matrix &&) = default;
    my_matrix & operator=(my_matrix const &) = default;
    my_matrix & operator=(my_matrix &&) = default;
    ~my_matrix() = default;
 
    my_matrix(size_t const num_rows, size_t const num_cols) : num_rows{num_rows}, num_cols{num_cols}
    {
        data.resize(num_rows * num_cols);
    }
 
protected:
    std::vector<int> data{};
    size_t num_rows{};
    size_t num_cols{};
 
    //Required for the base class. Initialises the current column given the column index.
    alignment_column_type initialise_column(size_t const column_index) noexcept
    {
        return alignment_column_type{*this,
                                     column_data_view_type{std::addressof(data[num_rows * column_index]), num_rows}};
    }
 
    //Required for the base class. Initialises the proxy for the current iterator over the current column.
    template <std::random_access_iterator iter_t>
    constexpr reference make_proxy(iter_t iter) noexcept
    {
        return *iter;
    }
};
 
int main()
{
    my_matrix matrix{3, 5};
 
    // Fill the matrix with
    int val = 0;
    for (auto col : matrix)     // Iterate over the columns
        for (auto & cell : col) // Iterate over the cells in one column.
            cell = val++;
 
    // Print the matrix column by column
    for (auto col : matrix)
        seqan3::debug_stream << col << '\n';
}

#include <iostream>
 
#include <seqan3/alignment/matrix/detail/debug_matrix.hpp>
#include <seqan3/alphabet/nucleotide/dna4.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    using seqan3::detail::debug_matrix;
    using namespace seqan3::literals;
 
    std::vector<seqan3::dna4> database = "AACCGGTT"_dna4;
    std::vector<seqan3::dna4> query = "ACGT"_dna4;
 
    seqan3::detail::row_wise_matrix<int> score_matrix{
        seqan3::detail::number_rows{5u},
        seqan3::detail::number_cols{9u},
        std::vector{-0, -1, -2, -3, -4, -5, -6, -7, -8, -1, -0, -1, -2, -3, -4, -5, -6, -7, -2, -1, -1, -1, -2,
                    -3, -4, -5, -6, -3, -2, -2, -2, -2, -2, -3, -4, -5, -4, -3, -3, -3, -3, -3, -3, -3, -4}};
 
    seqan3::debug_stream << "database:\t" << database << '\n';
    seqan3::debug_stream << "query:\t\t" << query << '\n';
    seqan3::debug_stream << '\n';
 
    seqan3::debug_stream << "score_matrix: " << score_matrix.cols() << " columns and " << score_matrix.rows()
                         << " rows\n";
 
    // Prints out the matrix in a convenient way
    seqan3::debug_stream << score_matrix << '\n';                                                   // without sequences
    seqan3::debug_stream << debug_matrix{score_matrix, database, query} << '\n';                    // with sequences
    seqan3::debug_stream << seqan3::fmtflags2::utf8 << debug_matrix{score_matrix, database, query}; // as utf8
 
    return 0;
}

#include <iostream>
 
#include <seqan3/alignment/matrix/detail/debug_matrix.hpp>
#include <seqan3/alphabet/nucleotide/dna4.hpp>
#include <seqan3/alphabet/views/to_char.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    using seqan3::detail::debug_matrix;
    using namespace seqan3::literals;
    using seqan3::operator|;
 
    std::vector<seqan3::dna4> database = "AACCGGTT"_dna4;
    std::vector<seqan3::dna4> query = "ACGT"_dna4;
 
    auto N = seqan3::detail::trace_directions::none;
    auto D = seqan3::detail::trace_directions::diagonal;
    auto U = seqan3::detail::trace_directions::up;
    auto L = seqan3::detail::trace_directions::left;
 
    seqan3::detail::row_wise_matrix<seqan3::detail::trace_directions> trace_matrix{
        seqan3::detail::number_rows{5u},
        seqan3::detail::number_cols{9u},
        std::vector{N,     L, L, L,     L, L, L, L,     L,     U,     D,     D | L, L, L, L,
                    L,     L, L, U,     U, D, D, D | L, L,     L,     L,     L,     U, U, D | U,
                    D | U, D, D, D | L, L, L, U, U,     D | U, D | U, D | U, D | U, D, D, D | L}};
 
    seqan3::debug_stream << "database:\t" << database << '\n';
    seqan3::debug_stream << "query:\t\t" << query << '\n';
    seqan3::debug_stream << '\n';
 
    seqan3::debug_stream << "trace_matrix: " << trace_matrix.cols() << " columns and " << trace_matrix.rows()
                         << " rows\n";
 
    // Prints out the matrix in a convenient way
    seqan3::debug_stream << trace_matrix << '\n';                                                   // without sequences
    seqan3::debug_stream << debug_matrix{trace_matrix, database, query} << '\n';                    // with sequences
    seqan3::debug_stream << seqan3::fmtflags2::utf8 << debug_matrix{trace_matrix, database, query}; // as utf8
    return 0;
}

 
#include <vector>
 
#include <seqan3/alignment/configuration/align_config_edit.hpp>
#include <seqan3/alignment/pairwise/align_pairwise.hpp>
#include <seqan3/alphabet/nucleotide/dna4.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    // Configure the alignment kernel.
    auto config = seqan3::align_cfg::method_global{} | seqan3::align_cfg::edit_scheme;
 
    {
        std::pair p{"ACGTAGC"_dna4, "AGTACGACG"_dna4};
        auto result = seqan3::align_pairwise(p, config);
    }
 
    {
        std::vector vec{"ACCA"_dna4, "ATTA"_dna4};
        auto result = seqan3::align_pairwise(std::tie(vec[0], vec[1]), config);
    }
 
    std::vector vec{std::pair{"AGTGCTACG"_dna4, "ACGTGCGACTAG"_dna4},
                    std::pair{"AGTAGACTACG"_dna4, "ACGTACGACACG"_dna4},
                    std::pair{"AGTTACGAC"_dna4, "AGTAGCGATCG"_dna4}};
 
    // Compute the alignment of a single pair.
    auto edit_config = seqan3::align_cfg::method_global{} | seqan3::align_cfg::edit_scheme;
 
    for (auto const & res : seqan3::align_pairwise(std::tie(vec[0].first, vec[0].second), edit_config))
        seqan3::debug_stream << "The score: " << res.score() << "\n";
 
    // Compute the alignment over a range of pairs.
    for (auto const & res : seqan3::align_pairwise(vec, edit_config))
        seqan3::debug_stream << "The score: " << res.score() << "\n";
}

#include <ranges>
#include <vector>
 
#include <seqan3/alignment/configuration/all.hpp>
#include <seqan3/alignment/pairwise/align_pairwise.hpp>
#include <seqan3/alphabet/nucleotide/dna4.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    std::vector data1{"AGTGCTACG"_dna4, "AGTAGACTACG"_dna4, "AGTTACGAC"_dna4};
    std::vector data2{"ACGTGCGACTAG"_dna4, "ACGTACGACACG"_dna4, "AGTAGCGATCG"_dna4};
 
    // Configure the alignment kernel.
    auto config =
        seqan3::align_cfg::method_global{} | seqan3::align_cfg::scoring_scheme{seqan3::nucleotide_scoring_scheme{}};
 
    // Compute the alignment over a range of pairs.
    for (auto const & res : seqan3::align_pairwise(seqan3::views::zip(data1, data2), config))
        seqan3::debug_stream << "The score: " << res.score() << "\n";
}

#include <seqan3/alignment/pairwise/alignment_configurator.hpp>
 
int main()
{
    using sequences_t = std::vector<std::pair<std::string, std::string>>;
    using config_t = decltype(seqan3::align_cfg::method_global{} | seqan3::align_cfg::edit_scheme
                              | seqan3::align_cfg::output_score{});
 
    using first_seq_t = std::tuple_element_t<0, std::ranges::range_value_t<sequences_t>>;
    using second_seq_t = std::tuple_element_t<1, std::ranges::range_value_t<sequences_t>>;
 
    // Select the result type based on the sequences and the configuration.
    using result_t =
        seqan3::alignment_result<typename seqan3::detail::align_result_selector<std::remove_reference_t<first_seq_t>,
                                                                                std::remove_reference_t<second_seq_t>,
                                                                                config_t>::type>;
    // Define the function wrapper type.
    using function_wrapper_t = std::function<result_t(first_seq_t &, second_seq_t &)>;
 
    static_assert(seqan3::detail::is_type_specialisation_of_v<function_wrapper_t, std::function>);
}

#include <mutex>
#include <vector>
 
#include <seqan3/alignment/configuration/all.hpp>
#include <seqan3/alignment/pairwise/align_pairwise.hpp>
#include <seqan3/alphabet/nucleotide/dna4.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    // Generate some sequences.
    using namespace seqan3::literals;
    using sequence_pair_t = std::pair<seqan3::dna4_vector, seqan3::dna4_vector>;
    std::vector<sequence_pair_t> sequences{100, {"AGTGCTACG"_dna4, "ACGTGCGACTAG"_dna4}};
 
    // Use edit distance with 4 threads.
    auto const alignment_config =
        seqan3::align_cfg::method_global{} | seqan3::align_cfg::edit_scheme | seqan3::align_cfg::parallel{4};
 
    // Compute the alignments in parallel and output them in order based on the input.
    for (auto && result : seqan3::align_pairwise(sequences, alignment_config))
        seqan3::debug_stream << result << '\n';
 
    seqan3::debug_stream << '\n';
    // prints:
    // [id: 0 score: -4]
    // [id: 1 score: -4]
    // [id: 2 score: -4]
    // [id: 3 score: -4]
    // [id: 4 score: -4]
    // [id: 5 score: -4]
    // ...
    // [id: 98 score: -4]
    // [id: 99 score: -4]
 
    // Compute the alignments in parallel and output them unordered using the callback (order is not deterministic).
    std::mutex write_to_debug_stream{}; // Need mutex to synchronise the output.
    auto const alignment_config_with_callback =
        alignment_config
        | seqan3::align_cfg::on_result{[&](auto && result)
                                       {
                                           std::lock_guard sync{write_to_debug_stream}; // critical section
                                           seqan3::debug_stream << result << '\n';
                                       }};
    seqan3::align_pairwise(sequences, alignment_config_with_callback); // seqan3::align_pairwise is now declared void.
 
    // might print:
    // [id: 0 score: -4]
    // [id: 1 score: -4]
    // [id: 2 score: -4]
    // [id: 6 score: -4]
    // [id: 7 score: -4]
    // [id: 3 score: -4]
    // ...
    // [id: 99 score: -4]
    // [id: 92 score: -4]
}

#include <seqan3/alignment/scoring/aminoacid_scoring_scheme.hpp>
#include <seqan3/alphabet/aminoacid/aa27.hpp>
#include <seqan3/alphabet/aminoacid/all.hpp>
#include <seqan3/core/debug_stream.hpp>
#include <seqan3/utility/views/zip.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::aminoacid_scoring_scheme scheme{seqan3::aminoacid_similarity_matrix::blosum62};
    // How to score two letters:
    seqan3::debug_stream << "blosum62 score for T and S: " << (int)scheme.score('T'_aa27, 'S'_aa27) << "\n"; // == 1
 
    scheme.set_similarity_matrix(seqan3::aminoacid_similarity_matrix::blosum80);
    // You can also score aa20 against aa27:
    seqan3::debug_stream << "blosum80 score for 'T'_aa27 and 'S'_aa20: " << (int)scheme.score('T'_aa27, 'S'_aa20)
                         << "\n"; // == 2
    scheme.set_hamming_distance();
    seqan3::debug_stream << "Hamming distance between T and S: " << (int)scheme.score('T'_aa27, 'S'_aa20)
                         << "\n"; // == -1
    seqan3::debug_stream << "Hamming distance between T and T: " << (int)scheme.score('T'_aa27, 'T'_aa20)
                         << "\n"; // == 0
 
    seqan3::aminoacid_scoring_scheme scheme2{seqan3::aminoacid_similarity_matrix::blosum80};
    // You can "edit" a given matrix directly:
    seqan3::debug_stream << "blosum80 score between T and S: " << (int)scheme2.score('T'_aa27, 'S'_aa27)
                         << "\n"; // == 2
    auto & cell = scheme2.score('T'_aa27, 'S'_aa27);
    cell = 3;
    seqan3::debug_stream << "New score after editing entry: " << (int)scheme2.score('T'_aa27, 'S'_aa27) << "\n"; // == 3
 
    std::vector<seqan3::aa27> one = "ALIGATOR"_aa27;
    std::vector<seqan3::aa27> two = "ANIMATOR"_aa27;
 
    seqan3::aminoacid_scoring_scheme scheme3{seqan3::aminoacid_similarity_matrix::blosum62};
    // You can also score two sequences:
    int score = 0;
    for (auto pair : seqan3::views::zip(one, two))
        score += scheme3.score(std::get<0>(pair), std::get<1>(pair));
    seqan3::debug_stream << "Score: " << score << "\n"; // 4 + -3 + 4 + -3 + 4 + 5 + -1 + 5 = 15
}

#include <seqan3/alignment/scoring/nucleotide_scoring_scheme.hpp>
#include <seqan3/alphabet/nucleotide/dna5.hpp>
#include <seqan3/alphabet/nucleotide/rna15.hpp>
#include <seqan3/core/debug_stream.hpp>
#include <seqan3/utility/views/zip.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    // You can score two letters:
    seqan3::nucleotide_scoring_scheme scheme; // hamming is default
    seqan3::debug_stream << "Score between DNA5 A and G: " << (int)scheme.score('A'_dna5, 'G'_dna5) << "\n"; // == -1
    seqan3::debug_stream << "Score between DNA5 A and A: " << (int)scheme.score('A'_dna5, 'A'_dna5) << "\n"; // == 0
 
    // You can also score differenct nucleotides:
    scheme.set_simple_scheme(seqan3::match_score{3}, seqan3::mismatch_score{-2});
    seqan3::debug_stream << "Score between DNA5 A and RNA15 G: " << (int)scheme.score('A'_dna5, 'G'_rna15)
                         << "\n"; // == -2
    seqan3::debug_stream << "Score between DNA5 A and RNA15 A: " << (int)scheme.score('A'_dna5, 'A'_rna15)
                         << "\n"; // == 3
 
    // You can "edit" a given matrix directly:
    seqan3::nucleotide_scoring_scheme scheme2; // hamming distance is default
    seqan3::debug_stream << "Score between DNA A and G before edit: " << (int)scheme2.score('A'_dna15, 'G'_dna15)
                         << "\n"; // == -1
    scheme2.score('A'_dna15, 'G'_dna15) = 3;
    seqan3::debug_stream << "Score after editing: " << (int)scheme2.score('A'_dna15, 'G'_dna15) << "\n"; // == 3
 
    // You can score two sequences:
    std::vector<seqan3::dna15> one = "AGAATA"_dna15;
    std::vector<seqan3::dna15> two = "ATACTA"_dna15;
    seqan3::nucleotide_scoring_scheme scheme3; // hamming distance is default
 
    int score = 0;
    for (auto pair : seqan3::views::zip(one, two))
        score += scheme3.score(std::get<0>(pair), std::get<1>(pair));
    seqan3::debug_stream << "Score: " << score << "\n"; // == 0 - 1 + 0 - 1 + 0 + 0 = -2
}

#include <seqan3/alphabet/nucleotide/dna4.hpp>
 
int main()
{
    // does not work:
    // seqan3::dna4 my_letter{0};      // we want to set the default, an A
    // seqan3::dna4 my_letter{'A'};    // we also want to set an A, but we are setting value 65
 
    // std::cout << my_letter;         // you expect 'A', but how would you access the number?
}

#include <seqan3/alphabet/nucleotide/dna4.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::dna4 letter = 'A'_dna4;             // identical to assign_char_to('A', letter);
    seqan3::dna4_vector sequence = "ACGT"_dna4; // identical to calling assign_char for each element
}

#include <seqan3/alphabet/nucleotide/dna4.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    seqan3::dna4 my_letter;
    seqan3::assign_rank_to(0, my_letter);   // assign an A via rank interface
    seqan3::assign_char_to('A', my_letter); // assign an A via char interface
 
    std::cout << seqan3::to_char(my_letter) << '\n';           // prints 'A'
    std::cout << (unsigned)seqan3::to_rank(my_letter) << '\n'; // prints 0
    // we have to add the cast here, because uint8_t is also treated as a char type by default :(
 
    // Using SeqAn's debug_stream:
    seqan3::debug_stream << seqan3::to_char(my_letter) << '\n'; // prints 'A'
    seqan3::debug_stream << my_letter << '\n';                  // prints 'A' (calls to_char() automatically!)
    seqan3::debug_stream << seqan3::to_rank(my_letter) << '\n'; // prints 0 (casts uint8_t to unsigned automatically!)
}

#include <seqan3/alphabet/alphabet_base.hpp>
#include <seqan3/alphabet/concept.hpp>
#include <seqan3/utility/char_operations/transform.hpp> // seqan3::to_lower
 
class ab : public seqan3::alphabet_base<ab, 2>
{
private:
    // make the base class a friend so it can access the tables:
    friend alphabet_base<ab, 2>;
 
    // This function is expected by seqan3::alphabet_base
    static constexpr char_type rank_to_char(rank_type const rank)
    {
        // via a lookup table
        return rank_to_char_table[rank];
        // or via an arithmetic expression
        return rank == 1 ? 'B' : 'A';
    }
 
    // This function is expected by seqan3::alphabet_base
    static constexpr rank_type char_to_rank(char_type const chr)
    {
        // via a lookup table
        using index_t = std::make_unsigned_t<char_type>;
        return char_to_rank_table[static_cast<index_t>(chr)];
        // or via an arithmetic expression
        return seqan3::to_lower(chr) == 'b' ? 1 : 0;
    }
 
private:
    // === lookup-table implementation detail ===
 
    // map 0 -> A and 1 -> B
    static constexpr std::array<char_type, alphabet_size> rank_to_char_table{'A', 'B'};
 
    // map every letter to rank zero, except Bs
    static constexpr std::array<rank_type, 256> char_to_rank_table{
        // initialise with an immediately evaluated lambda expression:
        []()
        {
            std::array<rank_type, 256> ret{}; // initialise all values with 0 / 'A'
 
            // only 'b' and 'B' result in rank 1
            ret['b'] = 1;
            ret['B'] = 1;
 
            return ret;
        }()};
};
 
// The class ab satisfies the alphabet concept.
static_assert(seqan3::alphabet<ab>);
static_assert(seqan3::writable_alphabet<ab>);

#include <iostream>
 
#include <seqan3/alphabet/adaptation/char.hpp>
#include <seqan3/alphabet/nucleotide/dna5.hpp>
 
int main()
{
    auto sigma_char = seqan3::alphabet_size<char>; // calls seqan3::custom::alphabet_size(char{})
    static_assert(std::same_as<decltype(sigma_char), uint16_t>);
    std::cout << sigma_char << '\n'; // 256
 
    auto sigma_dna5 = seqan3::alphabet_size<seqan3::dna5>; // returns dna5::alphabet_size
    static_assert(std::same_as<decltype(sigma_dna5), uint8_t>);
    std::cout << static_cast<uint16_t>(sigma_dna5) << '\n'; // 5
}

#include <seqan3/alphabet/aminoacid/aa10li.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::aa10li letter{'A'_aa10li};
 
    letter.assign_char('C');
    seqan3::debug_stream << letter << '\n'; // prints "C"
 
    letter.assign_char('?');                // Unknown characters are implicitly converted to A.
    seqan3::debug_stream << letter << '\n'; // prints "A"
}

#include <seqan3/alphabet/aminoacid/aa10li.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::aa10li letter1{'A'_aa10li};
    auto letter2 = 'A'_aa10li;
}

#include <seqan3/alphabet/aminoacid/aa10li.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::aa10li_vector sequence1{"ACGTTA"_aa10li};
    seqan3::aa10li_vector sequence2 = "ACGTTA"_aa10li;
    auto sequence3 = "ACGTTA"_aa10li;
}

#include <seqan3/alphabet/aminoacid/aa10murphy.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::aa10murphy letter{'A'_aa10murphy};
 
    letter.assign_char('C');
    seqan3::debug_stream << letter << '\n'; // prints "C"
 
    letter.assign_char('?');                // Unknown characters are implicitly converted to S.
    seqan3::debug_stream << letter << '\n'; // prints "S"
}

#include <seqan3/alphabet/aminoacid/aa10murphy.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::aa10murphy letter1{'A'_aa10murphy};
    auto letter2 = 'A'_aa10murphy;
}

#include <seqan3/alphabet/aminoacid/aa10murphy.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::aa10murphy_vector sequence1{"ACGTTA"_aa10murphy};
    seqan3::aa10murphy_vector sequence2 = "ACGTTA"_aa10murphy;
    auto sequence3 = "ACGTTA"_aa10murphy;
}

#include <seqan3/alphabet/aminoacid/aa20.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::aa20 letter{'A'_aa20};
 
    letter.assign_char('C');
    seqan3::debug_stream << letter << '\n'; // prints "C"
 
    letter.assign_char('?');                // Unknown characters are implicitly converted to S.
    seqan3::debug_stream << letter << '\n'; // prints "S"
}

#include <seqan3/alphabet/aminoacid/aa20.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::aa20 letter1{'A'_aa20};
    auto letter2 = 'A'_aa20;
}

#include <seqan3/alphabet/aminoacid/aa20.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::aa20_vector sequence1{"ACGTTA"_aa20};
    seqan3::aa20_vector sequence2 = "ACGTTA"_aa20;
    auto sequence3 = "ACGTTA"_aa20;
}

#include <seqan3/alphabet/aminoacid/aa27.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::aa27 letter{'A'_aa27};
 
    letter.assign_char('C');
    seqan3::debug_stream << letter << '\n'; // prints "C"
 
    letter.assign_char('?');                // Unknown characters are implicitly converted to X.
    seqan3::debug_stream << letter << '\n'; // prints "X"
}

#include <seqan3/alphabet/aminoacid/aa27.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::aa27 letter1{'A'_aa27};
    auto letter2 = 'A'_aa27;
}

#include <seqan3/alphabet/aminoacid/aa27.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::aa27_vector sequence1{"ACGTTA"_aa27};
    seqan3::aa27_vector sequence2 = "ACGTTA"_aa27;
    auto sequence3 = "ACGTTA"_aa27;
}

#include <seqan3/alphabet/aminoacid/concept.hpp>
 
namespace your_namespace
{
 
// your own aminoacid definition
struct your_aa : seqan3::aminoacid_empty_base
{
    //...
};
 
} // namespace your_namespace
 
static_assert(seqan3::enable_aminoacid<your_namespace::your_aa> == true);
 
/***** OR *****/
 
namespace your_namespace2
{
 
// your own aminoacid definition
struct your_aa
{
    //...
};
 
constexpr bool enable_aminoacid(your_aa) noexcept
{
    return true;
}
 
} // namespace your_namespace2
 
static_assert(seqan3::enable_aminoacid<your_namespace2::your_aa> == true);

#include <seqan3/alphabet/adaptation/char.hpp>
#include <seqan3/alphabet/concept.hpp>
#include <seqan3/alphabet/nucleotide/dna5.hpp>
 
int main()
{
    char c = '!';
    seqan3::assign_char_strictly_to('?', c); // calls seqan3::custom::assign_char_strictly_to('A', c)
 
    seqan3::dna5 d{};
    seqan3::assign_char_strictly_to('A', d); // calls .assign_char('A') member
 
    // also works for temporaries:
    seqan3::dna5 d2 = seqan3::assign_char_strictly_to('A', seqan3::dna5{});
}

#include <seqan3/alphabet/adaptation/char.hpp>
#include <seqan3/alphabet/concept.hpp>
#include <seqan3/alphabet/nucleotide/dna5.hpp>
 
int main()
{
    char c = '!';
    seqan3::assign_char_to('?', c); // calls seqan3::custom::assign_char_to('A', c)
 
    seqan3::dna5 d{};
    seqan3::assign_char_to('A', d); // calls .assign_char('A') member
 
    // also works for temporaries:
    seqan3::dna5 d2 = seqan3::assign_char_to('A', seqan3::dna5{});
 
    // invalid/unknown characters are converted:
    seqan3::dna5 d3 = seqan3::assign_char_to('!', seqan3::dna5{}); // == 'N'_dna5
}

#include <seqan3/alphabet/adaptation/char.hpp>
#include <seqan3/alphabet/concept.hpp>
#include <seqan3/alphabet/nucleotide/dna5.hpp>
 
int main()
{
    char c = '!';
    seqan3::assign_rank_to(66, c); // calls seqan3::custom::assign_rank_to(66, c); == 'B'
 
    seqan3::dna5 d{};
    seqan3::assign_rank_to(2, d); // calls .assign_rank(2) member; == 'G'_dna5
 
    // also works for temporaries:
    seqan3::dna5 d2 = seqan3::assign_rank_to(2, seqan3::dna5{});
 
    // too-large ranks are undefined behaviour:
    // seqan3::dna5 d3 = seqan3::assign_rank_to(50, seqan3::dna5{});
}

#include <seqan3/alphabet/adaptation/char.hpp>
#include <seqan3/alphabet/nucleotide/dna5.hpp>
 
int main()
{
    // calls seqan3::custom::char_is_valid_for<char>('A')
    std::cout << std::boolalpha << seqan3::char_is_valid_for<char>('A') << '\n'; // always 'true'
 
    // calls dna5::char_is_valid('A') member
    std::cout << std::boolalpha << seqan3::char_is_valid_for<seqan3::dna5>('A') << '\n'; // true
 
    // for some alphabets, characters that are not uniquely mappable are still valid:
    std::cout << std::boolalpha << seqan3::char_is_valid_for<seqan3::dna5>('a') << '\n'; // true
}

#include <seqan3/alphabet/cigar/cigar.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::cigar letter{12, 'M'_cigar_operation};
 
    letter.assign_string("10D");
    seqan3::debug_stream << letter << '\n'; // prints "10D"
 
    letter.assign_string("20Z");            // Unknown strings are implicitly converted to 0P.
    seqan3::debug_stream << letter << '\n'; // prints "0P"
}

#include <seqan3/alphabet/cigar/cigar.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    std::string cigar_str{"4S134M"}; // input
 
    seqan3::cigar letter1{};
    seqan3::cigar letter2{};
 
    // Assign from string
    // convenient but creates an unnecessary string copy "4S"
    letter1.assign_string(cigar_str.substr(0, 2));
    letter2.assign_string(cigar_str.substr(2, 4));
    seqan3::debug_stream << letter1 << '\n'; // prints 4S
    seqan3::debug_stream << letter2 << '\n'; // prints 134M
 
    // Assign from std::string_view (No extra string copies)
    // Version 1
    letter1.assign_string(std::string_view{cigar_str}.substr(0, 2));
    letter2.assign_string(std::string_view{cigar_str}.substr(2, 4));
    seqan3::debug_stream << letter1 << '\n'; // prints 4S
    seqan3::debug_stream << letter2 << '\n'; // prints 134M
    // No extra string copiesersion 2
    letter1.assign_string(/*std::string_view*/ {cigar_str.data(), 2});
    letter2.assign_string(/*std::string_view*/ {cigar_str.data() + 2, 4});
    seqan3::debug_stream << letter1 << '\n'; // prints 4S
    seqan3::debug_stream << letter2 << '\n'; // prints 134M
 
    // Assign from char array
    letter2.assign_string("40S");
    seqan3::debug_stream << letter2 << '\n'; // prints 40S
 
    // Assign from seqan3::small_string
    letter2.assign_string(letter1.to_string());
    seqan3::debug_stream << letter2 << '\n'; // prints 4S
}

#include <seqan3/alphabet/cigar/cigar.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    using seqan3::get;
    using namespace seqan3::literals;
 
    seqan3::cigar letter{10, 'M'_cigar_operation};
 
    // Note that this is equivalent to get<uint32_t>(letter)
    uint32_t size{get<0>(letter)};
 
    // Note that this is equivalent to get<seqan3::cigar::operation>(letter)
    seqan3::cigar::operation cigar_char{get<1>(letter)};
 
    seqan3::debug_stream << "Size is " << size << '\n';
    seqan3::debug_stream << "Cigar char is " << cigar_char << '\n'; // seqan3::debug_stream converts to char on the fly.
}

#include <seqan3/alphabet/cigar/cigar.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    using seqan3::get;
    using namespace seqan3::literals;
 
    seqan3::cigar letter{10, 'M'_cigar_operation};
 
    // Note that this is equivalent to get<0>(letter)
    uint32_t size{get<uint32_t>(letter)};
 
    // Note that this is equivalent to get<1>(letter)
    seqan3::cigar::operation cigar_char{get<seqan3::cigar::operation>(letter)};
 
    seqan3::debug_stream << "Size is " << size << '\n';
    seqan3::debug_stream << "Cigar char is " << cigar_char << '\n'; // seqan3::debug_stream converts to char on the fly.
}

#include <seqan3/alphabet/cigar/cigar.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::cigar::operation letter{'M'_cigar_operation};
 
    letter.assign_char('D');
    seqan3::debug_stream << letter << '\n'; // prints "D"
 
    letter.assign_char('Z');                // Unknown characters are implicitly converted to M.
    seqan3::debug_stream << letter << '\n'; // prints "M"
}

#include <seqan3/alphabet/cigar/cigar.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::cigar::operation letter1{'M'_cigar_operation};
    auto letter2 = 'M'_cigar_operation;
}

#include <seqan3/alphabet/cigar/cigar.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::cigar letter{10, 'I'_cigar_operation};
    seqan3::debug_stream << "letter: " << letter << '\n'; // 10I
 
    letter = 'D'_cigar_operation;
    seqan3::debug_stream << "letter: " << letter << '\n'; // 10D
 
    letter = 20;
    seqan3::debug_stream << "letter: " << letter << '\n'; // 20D
}

#include <seqan3/alphabet/cigar/cigar.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    // creates 10M, as the cigar_op field is not provided.
    seqan3::cigar letter1{10};
    seqan3::debug_stream << "letter1: " << letter1 << '\n'; // 10M
 
    // creates 0I, as the integer field is not provided.
    seqan3::cigar letter2{'I'_cigar_operation};
    seqan3::debug_stream << "letter2: " << letter2 << '\n'; // 0I
 
    // creates 10I, as both fields are explicitly given.
    seqan3::cigar letter3{10, 'I'_cigar_operation};
    seqan3::debug_stream << "letter3: " << letter3 << '\n'; // 10I
}

#include <seqan3/alphabet/nucleotide/all.hpp>
#include <seqan3/alphabet/quality/phred42.hpp>
#include <seqan3/alphabet/quality/qualified.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::qualified<seqan3::dna4, seqan3::phred42> letter1{'T'_dna4, '"'_phred42};
 
    letter1 = 'C'_rna4; // yields {'C'_dna4, '"'_phred42}
}

#include <seqan3/alphabet/nucleotide/all.hpp>
#include <seqan3/alphabet/quality/phred42.hpp>
#include <seqan3/alphabet/quality/qualified.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    // The following creates {'C'_dna4, '!'_phred42}
    seqan3::qualified<seqan3::dna4, seqan3::phred42> letter1{'C'_dna4};
    // The following also creates {'C'_dna4, '!'_phred42}, since rna4 assignable to dna4
    seqan3::qualified<seqan3::dna4, seqan3::phred42> letter2{'C'_rna4};
 
    if (letter1 == letter2)
        seqan3::debug_stream << "yeah\n"; // yeah
}

#include <seqan3/alphabet/nucleotide/dna4.hpp>
#include <seqan3/alphabet/quality/phred42.hpp>
#include <seqan3/alphabet/quality/qualified.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::qualified<seqan3::dna4, seqan3::phred42> letter1{'T'_dna4, '"'_phred42};
 
    letter1 = 'C'_dna4;    // yields {'C'_dna4, '"'_phred42}
    letter1 = '#'_phred42; // yields {'C'_dna4, '#'_phred42}
}

#include <seqan3/alphabet/nucleotide/dna4.hpp>
#include <seqan3/alphabet/quality/phred42.hpp>
#include <seqan3/alphabet/quality/qualified.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::qualified<seqan3::dna4, seqan3::phred42> letter1{'C'_dna4};    // creates {'C'_dna4, '!'_phred42}
    seqan3::qualified<seqan3::dna4, seqan3::phred42> letter2{'"'_phred42}; // creates {'A'_dna4, '"'_phred42}
 
    if (letter1 == letter2)
        seqan3::debug_stream << "yeah\n"; // yeah
}

#include <seqan3/alphabet/composite/alphabet_variant.hpp>
#include <seqan3/alphabet/gap/gap.hpp>
#include <seqan3/alphabet/nucleotide/all.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::alphabet_variant<seqan3::dna5, seqan3::gap> letter{};          // implicitly 'A'_dna5
    seqan3::alphabet_variant<seqan3::dna5, seqan3::gap> letter2{'C'_dna5}; // constructed from alternative (== 'C'_dna5)
    seqan3::alphabet_variant<seqan3::dna5, seqan3::gap> letter3{
        'U'_rna5}; // constructed from type that alternative is constructible from (== 'T'_dna5)
 
    letter2.assign_char('T'); // == 'T'_dna5
    letter2.assign_char('-'); // == gap{}
    letter2.assign_char('K'); // unknown characters map to the default/unknown
                              // character of the first alternative type (== 'N'_dna5)
 
    letter2 = seqan3::gap{}; // assigned from alternative (== gap{})
    letter2 = 'U'_rna5;      // assigned from type that alternative is assignable from (== 'T'_dna5)
 
    seqan3::dna5 letter4 = letter2.convert_to<seqan3::dna5>();
}

#include <seqan3/alphabet/composite/alphabet_variant.hpp>
#include <seqan3/alphabet/nucleotide/all.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::alphabet_variant<seqan3::dna4, seqan3::dna5> var;
    var.assign_char('A'); // will be in the "dna4-state"
    var = 'A'_dna5;       // will be in the "dna5-state"
}

#include <seqan3/alphabet/composite/alphabet_variant.hpp>
#include <seqan3/alphabet/gap/gap.hpp>
#include <seqan3/alphabet/nucleotide/all.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::alphabet_variant<seqan3::dna4, seqan3::gap> letter1{'C'_rna4};
    seqan3::alphabet_variant<seqan3::dna4, seqan3::gap> letter2 = 'C'_rna4;
}

#include <seqan3/alphabet/composite/alphabet_variant.hpp>
#include <seqan3/alphabet/gap/gap.hpp>
#include <seqan3/alphabet/nucleotide/all.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    // possible:
    seqan3::alphabet_variant<seqan3::dna4, seqan3::gap> letter1{'C'_dna5};
    // not possible:
    // seqan3::alphabet_variant<seqan3::dna4, seqan3::gap> letter2 = 'C'_dna5;
}

#include <gtest/gtest.h>
 
#include <seqan3/alphabet/composite/alphabet_variant.hpp>
#include <seqan3/alphabet/gap/gap.hpp>
#include <seqan3/alphabet/nucleotide/all.hpp>
 
int main()
{
    using variant_t = seqan3::alphabet_variant<seqan3::dna5, seqan3::gap>;
 
    static_assert(variant_t::is_alternative<seqan3::dna5>(), "dna5 is an alternative of variant_t");
    static_assert(!variant_t::is_alternative<seqan3::dna4>(), "dna4 is not an alternative of variant_t");
    static_assert(variant_t::is_alternative<seqan3::gap>(), "gap is an alternative of variant_t");
}

#include <seqan3/alphabet/composite/alphabet_variant.hpp>
#include <seqan3/alphabet/gap/gap.hpp>
#include <seqan3/alphabet/nucleotide/all.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::alphabet_variant<seqan3::dna4, seqan3::gap> letter1{};
    letter1 = 'C'_rna4;
}

#include <seqan3/alphabet/composite/alphabet_variant.hpp>
#include <seqan3/alphabet/gap/gap.hpp>
#include <seqan3/alphabet/nucleotide/all.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::alphabet_variant<seqan3::dna4, seqan3::gap> letter1{'C'_dna4}; // or
    seqan3::alphabet_variant<seqan3::dna4, seqan3::gap> letter2 = seqan3::gap{};
}

// This example illustrates how we can reduce the usage of templates (or the amount of different instantiations) via
// type erasure. Having only one function generated for `algorithm()` is the only benefit of using `semialphabet_any`
// here. Of course this only makes sense for your application if the part of the program that is agnostic of the
// character representation (your equivalent of `algorithm()`) is substantially larger than the specific parts – and
// if compile-time and/or size of the exectuble are a concern.
 
#include <iostream>
 
#include <seqan3/alphabet/aminoacid/all.hpp>
#include <seqan3/alphabet/composite/semialphabet_any.hpp>
#include <seqan3/core/debug_stream.hpp>
#include <seqan3/utility/range/to.hpp>
 
using namespace seqan3::literals;
 
// Print is a template and gets instantiated two times because the behaviour is different for both types
template <typename rng_t>
void print(rng_t && r)
{
    seqan3::debug_stream << r << '\n';
}
 
// Algorithm is not a template, only one instance is generated by the compiler
// Type information is encoded via a run-time parameter
void algorithm(std::vector<seqan3::semialphabet_any<10>> & r, bool is_murphy)
{
    // Algorithm example that replaces rank 0 with rank 1
    for (auto & v : r)
        if (seqan3::to_rank(v) == 0)
            seqan3::assign_rank_to(1, v);
 
    // Here we reify the type for printing
    if (is_murphy)
        print(r
              | std::views::transform(
                  [](auto const & in)
                  {
                      return static_cast<seqan3::aa10murphy>(in);
                  }));
    else
        print(r
              | std::views::transform(
                  [](auto const & in)
                  {
                      return static_cast<seqan3::aa10li>(in);
                  }));
}
 
// Two instances of algo_pre exist
// They type erase the different arguments to the same type and encode the type information as a run-time parameter
void algo_pre(seqan3::aa10li_vector const & v)
{
    std::vector<seqan3::semialphabet_any<10>> tmp = v
                                                  | std::views::transform(
                                                        [](auto const & in)
                                                        {
                                                            return static_cast<seqan3::semialphabet_any<10>>(in);
                                                        })
                                                  | seqan3::ranges::to<std::vector>();
    algorithm(tmp, false);
}
 
void algo_pre(seqan3::aa10murphy_vector const & v)
{
    std::vector<seqan3::semialphabet_any<10>> tmp = v
                                                  | std::views::transform(
                                                        [](auto const & in)
                                                        {
                                                            return static_cast<seqan3::semialphabet_any<10>>(in);
                                                        })
                                                  | seqan3::ranges::to<std::vector>();
    algorithm(tmp, true);
}
 
int main()
{
    seqan3::aa10li_vector v1{"AVRSTXOUB"_aa10li};
    algo_pre(v1); // BIKBBBKCB
 
    seqan3::aa10murphy_vector v2{"AVRSTXOUB"_aa10murphy};
    algo_pre(v2); // BIKSSSKCB
}

#include <vector>
 
#include <seqan3/alphabet/container/bitpacked_sequence.hpp>
#include <seqan3/alphabet/nucleotide/dna4.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    std::vector<seqan3::dna4> v0{"ACGT"_dna4};                // data occupies 4 bytes in memory
    seqan3::bitpacked_sequence<seqan3::dna4> v1{"ACGT"_dna4}; // data occupies 1 byte in memory
}

#include <vector>
 
#include <seqan3/alphabet/container/concatenated_sequences.hpp>
#include <seqan3/alphabet/nucleotide/dna4.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::concatenated_sequences<seqan3::dna4_vector> concat1{"ACGT"_dna4, "GAGGA"_dna4};
    seqan3::debug_stream << concat1[0] << '\n'; // "ACGT"
 
    std::vector<seqan3::dna4_vector> concat2{"ACTA"_dna4, "AGGA"_dna4};
 
    concat1 = concat2; // you can assign from other ranges
 
    concat2[0] = "ATTA"_dna4;                   // this works for vector of vector
    concat1[0][1] = 'T'_dna4;                   // and this works for concatenated_sequences
    seqan3::debug_stream << concat1[0] << '\n'; // "ATTA"
 
    // if you know that you will be adding ten vectors of length ten:
    std::vector<seqan3::dna4> vector_of_length10{"ACGTACGTAC"_dna4};
 
    concat1.reserve(10);
    concat1.concat_reserve(10 * vector_of_length10.size());
    while (concat1.size() < 10)
    {
        // ...
        concat1.push_back(vector_of_length10);
    }
}

#include <seqan3/alphabet/container/concatenated_sequences.hpp>
#include <seqan3/alphabet/nucleotide/dna4.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::concatenated_sequences<seqan3::dna4_vector> foobar;
    foobar.insert(foobar.end(), "ACGT"_dna4);
    seqan3::debug_stream << foobar[0] << '\n'; // "ACGT"
}

#include <seqan3/alphabet/container/concatenated_sequences.hpp>
#include <seqan3/alphabet/nucleotide/dna4.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::concatenated_sequences<seqan3::dna4_vector> foobar;
    foobar.insert(foobar.end(), 2, "ACGT"_dna4);
    seqan3::debug_stream << foobar[0] << '\n'; // "ACGT"
    seqan3::debug_stream << foobar[1] << '\n'; // "ACGT"
}

#include <iostream>
 
#include <seqan3/alphabet/gap/gap.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    seqan3::gap my_gap = seqan3::gap{};
    seqan3::gap another_gap{};
    another_gap.assign_char('A'); // this does not change anything
 
    seqan3::debug_stream << my_gap.to_char(); // outputs '-'
    if (my_gap.to_char() == another_gap.to_char())
        seqan3::debug_stream << "Both gaps are the same!\n";
}

#include <seqan3/alphabet/gap/gapped.hpp>
#include <seqan3/alphabet/nucleotide/dna4.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::gapped<seqan3::dna4> gapped_letter{};
    seqan3::gapped<seqan3::dna4> converted_letter{'C'_dna4};
    seqan3::gapped<seqan3::dna4> gap_letter{seqan3::gap{}};
 
    seqan3::gapped<seqan3::dna4>{}.assign_char('C');
    seqan3::gapped<seqan3::dna4>{}.assign_char('-'); // gap character
    seqan3::gapped<seqan3::dna4>{}.assign_char('K'); // unknown characters map to the default/unknown
                                                     // character of the given alphabet type (i.e. A of dna4)
}

#include <seqan3/alphabet/mask/mask.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    seqan3::mask my_mask = seqan3::mask::masked;
    seqan3::mask another_mask{};
 
    my_mask.assign_rank(false);  // will assign my_mask the value mask::unmasked
    another_mask.assign_rank(0); // will also assign another_mask the value mask::unmasked
 
    if (my_mask.to_rank() == another_mask.to_rank())
        seqan3::debug_stream << "Both are UNMASKED!\n";
}

#include <seqan3/alphabet/mask/masked.hpp>
#include <seqan3/alphabet/nucleotide/dna4.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::masked<seqan3::dna4> dna4_masked{};
    seqan3::masked<seqan3::dna4> dna4_another_masked{'A'_dna4, seqan3::mask::unmasked};
    // create a dna4 masked alphabet with an unmasked A
 
    dna4_masked.assign_char('a'); // assigns a masked 'A'_dna4
 
    if (dna4_masked.to_char() != dna4_another_masked.to_char())
    {
        seqan3::debug_stream << dna4_masked.to_char() << " is not the same as " << dna4_another_masked.to_char()
                             << "\n";
    }
}

#include <seqan3/alphabet/nucleotide/concept.hpp>
#include <seqan3/alphabet/nucleotide/rna5.hpp>
 
using namespace seqan3::literals;
 
int main()
{
    auto r1 = 'A'_rna5.complement();        // calls member function rna5::complement(); r1 == 'U'_rna5
    auto r2 = seqan3::complement('A'_rna5); // calls global complement() function on the rna5 object; r2 == 'U'_rna5
}

#include <seqan3/alphabet/nucleotide/dna15.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::dna15 letter{'A'_dna15};
 
    letter.assign_char('C');
    seqan3::debug_stream << letter << '\n'; // prints "C"
 
    letter.assign_char('F');                // Unknown characters are implicitly converted to N.
    seqan3::debug_stream << letter << '\n'; // prints "N"
}

// generated from test/snippet/alphabet/nucleotide/@target_alphabet@_char_literal.cpp.in
 
#include <seqan3/alphabet/nucleotide/dna15.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::dna15 letter1{'A'_dna15};
    auto letter2 = 'A'_dna15;
}

// generated from test/snippet/alphabet/nucleotide/@target_alphabet@_implicit_conversion_from_@source_alphabet@.cpp.in
 
#include <seqan3/alphabet/nucleotide/dna15.hpp>
#include <seqan3/alphabet/nucleotide/rna15.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::dna15 letter1 = 'C'_rna15; // implicitly converted
    seqan3::dna15 letter2{};
    letter2 = 'C'_rna15; // implicitly converted
}

// generated from test/snippet/alphabet/nucleotide/@target_alphabet@_implicit_conversion_from_@source_alphabet@_inherit.cpp.in
 
#include <seqan3/alphabet/nucleotide/dna15.hpp>
#include <seqan3/alphabet/nucleotide/rna15.hpp>
 
struct my_dna15 : public seqan3::dna15
{
    // using seqan3::dna15::dna15; // uncomment to import implicit conversion shown by letter1
};
 
struct my_rna15 : public seqan3::rna15
{};
 
int main()
{
    using namespace seqan3::literals;
 
    // my_dna15 letter1 = 'C'_rna15; // NO automatic implicit conversion!
    // seqan3::dna15 letter2 = my_rna15{}; // seqan3::dna15 only allows implicit conversion from seqan3::rna15!
}
 
#include <seqan3/utility/concept.hpp>
 
static_assert(seqan3::implicitly_convertible_to<seqan3::rna15, seqan3::dna15>);
static_assert(!seqan3::implicitly_convertible_to<seqan3::rna15, my_dna15>);
static_assert(!seqan3::implicitly_convertible_to<my_rna15, seqan3::dna15>);

// generated from test/snippet/alphabet/nucleotide/@target_alphabet@_implicit_conversion_from_@source_alphabet@_vector.cpp.in
 
#include <vector>
 
#include <seqan3/alphabet/nucleotide/dna15.hpp>
#include <seqan3/alphabet/nucleotide/rna15.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::dna15_vector vector{'A'_rna15, 'C'_rna15, 'G'_rna15}; // (element-wise) implicit conversion
 
    // but this won't work:
    // seqan3::dna15_vector dna15_vector{"ACGT"_rna15};
 
    // as a workaround you can use:
    // side note: this would also work without the implicit conversion.
    seqan3::rna15_vector rna15_vector = "ACGT"_rna15;
    seqan3::dna15_vector dna15_vector{rna15_vector.begin(), rna15_vector.end()};
}

// generated from test/snippet/alphabet/nucleotide/@target_alphabet@_implicit_conversion_from_@source_alphabet@_views.cpp.in
 
#include <vector>
 
#include <seqan3/alphabet/nucleotide/dna15.hpp>
#include <seqan3/alphabet/nucleotide/rna15.hpp>
#include <seqan3/utility/views/convert.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::dna15_vector vector = "ACG"_dna15;
 
    auto rna15_view = vector | seqan3::views::convert<seqan3::rna15>;
 
    for (auto && chr : rna15_view) // converts lazily on-the-fly
    {
        static_assert(std::same_as<decltype(chr), seqan3::rna15 &&>);
    }
}

// generated from test/snippet/alphabet/nucleotide/@target_alphabet@_literal.cpp.in
 
#include <seqan3/alphabet/nucleotide/dna15.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::dna15_vector sequence1{"ACGTTA"_dna15};
    seqan3::dna15_vector sequence2 = "ACGTTA"_dna15;
    auto sequence3 = "ACGTTA"_dna15;
}

#include <seqan3/alphabet/nucleotide/dna16sam.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::dna16sam letter{'A'_dna16sam};
 
    letter.assign_char('=');
    seqan3::debug_stream << letter << '\n'; // prints "="
 
    letter.assign_char('F');                // Unknown characters are implicitly converted to N.
    seqan3::debug_stream << letter << '\n'; // "N";
}

// generated from test/snippet/alphabet/nucleotide/@target_alphabet@_char_literal.cpp.in
 
#include <seqan3/alphabet/nucleotide/dna16sam.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::dna16sam letter1{'A'_dna16sam};
    auto letter2 = 'A'_dna16sam;
}

// generated from test/snippet/alphabet/nucleotide/@target_alphabet@_literal.cpp.in
 
#include <seqan3/alphabet/nucleotide/dna16sam.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::dna16sam_vector sequence1{"ACGTTA"_dna16sam};
    seqan3::dna16sam_vector sequence2 = "ACGTTA"_dna16sam;
    auto sequence3 = "ACGTTA"_dna16sam;
}

#include <seqan3/alphabet/nucleotide/dna3bs.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::dna3bs letter{'A'_dna3bs};
 
    letter.assign_char('C');                // All C will be converted to T.
    seqan3::debug_stream << letter << '\n'; // prints "T"
 
    letter.assign_char('F');                // Unknown characters are implicitly converted to A.
    seqan3::debug_stream << letter << '\n'; // prints "A"
}

// generated from test/snippet/alphabet/nucleotide/@target_alphabet@_char_literal.cpp.in
 
#include <seqan3/alphabet/nucleotide/dna3bs.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::dna3bs letter1{'A'_dna3bs};
    auto letter2 = 'A'_dna3bs;
}

// generated from test/snippet/alphabet/nucleotide/@target_alphabet@_literal.cpp.in
 
#include <seqan3/alphabet/nucleotide/dna3bs.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::dna3bs_vector sequence1{"ACGTTA"_dna3bs};
    seqan3::dna3bs_vector sequence2 = "ACGTTA"_dna3bs;
    auto sequence3 = "ACGTTA"_dna3bs;
}

#include <seqan3/alphabet/nucleotide/dna4.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::dna4 letter{'C'_dna4};
 
    letter.assign_char('F');                // Characters other than IUPAC characters are implicitly converted to A.
    seqan3::debug_stream << letter << '\n'; // prints "A"
 
    // IUPAC characters are implicitly converted to their best fitting representative
    seqan3::debug_stream << letter.assign_char('R') << '\n'; // prints "A"
    seqan3::debug_stream << letter.assign_char('Y') << '\n'; // prints "C"
    seqan3::debug_stream << letter.assign_char('S') << '\n'; // prints "C"
    seqan3::debug_stream << letter.assign_char('W') << '\n'; // prints "A"
    seqan3::debug_stream << letter.assign_char('K') << '\n'; // prints "G"
    seqan3::debug_stream << letter.assign_char('M') << '\n'; // prints "A"
    seqan3::debug_stream << letter.assign_char('B') << '\n'; // prints "C"
    seqan3::debug_stream << letter.assign_char('D') << '\n'; // prints "A"
    seqan3::debug_stream << letter.assign_char('H') << '\n'; // prints "A"
    seqan3::debug_stream << letter.assign_char('V') << '\n'; // prints "A"
 
    letter.assign_char('a');                // Lower case letters are the same as their upper case equivalent.
    seqan3::debug_stream << letter << '\n'; // prints "A"
}

// generated from test/snippet/alphabet/nucleotide/@target_alphabet@_char_literal.cpp.in
 
#include <seqan3/alphabet/nucleotide/dna4.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::dna4 letter1{'A'_dna4};
    auto letter2 = 'A'_dna4;
}

// generated from test/snippet/alphabet/nucleotide/@target_alphabet@_implicit_conversion_from_@source_alphabet@.cpp.in
 
#include <seqan3/alphabet/nucleotide/dna4.hpp>
#include <seqan3/alphabet/nucleotide/rna4.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::dna4 letter1 = 'C'_rna4; // implicitly converted
    seqan3::dna4 letter2{};
    letter2 = 'C'_rna4; // implicitly converted
}

// generated from test/snippet/alphabet/nucleotide/@target_alphabet@_implicit_conversion_from_@source_alphabet@_inherit.cpp.in
 
#include <seqan3/alphabet/nucleotide/dna4.hpp>
#include <seqan3/alphabet/nucleotide/rna4.hpp>
 
struct my_dna4 : public seqan3::dna4
{
    // using seqan3::dna4::dna4; // uncomment to import implicit conversion shown by letter1
};
 
struct my_rna4 : public seqan3::rna4
{};
 
int main()
{
    using namespace seqan3::literals;
 
    // my_dna4 letter1 = 'C'_rna4; // NO automatic implicit conversion!
    // seqan3::dna4 letter2 = my_rna4{}; // seqan3::dna4 only allows implicit conversion from seqan3::rna4!
}
 
#include <seqan3/utility/concept.hpp>
 
static_assert(seqan3::implicitly_convertible_to<seqan3::rna4, seqan3::dna4>);
static_assert(!seqan3::implicitly_convertible_to<seqan3::rna4, my_dna4>);
static_assert(!seqan3::implicitly_convertible_to<my_rna4, seqan3::dna4>);

// generated from test/snippet/alphabet/nucleotide/@target_alphabet@_implicit_conversion_from_@source_alphabet@_vector.cpp.in
 
#include <vector>
 
#include <seqan3/alphabet/nucleotide/dna4.hpp>
#include <seqan3/alphabet/nucleotide/rna4.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::dna4_vector vector{'A'_rna4, 'C'_rna4, 'G'_rna4}; // (element-wise) implicit conversion
 
    // but this won't work:
    // seqan3::dna4_vector dna4_vector{"ACGT"_rna4};
 
    // as a workaround you can use:
    // side note: this would also work without the implicit conversion.
    seqan3::rna4_vector rna4_vector = "ACGT"_rna4;
    seqan3::dna4_vector dna4_vector{rna4_vector.begin(), rna4_vector.end()};
}

// generated from test/snippet/alphabet/nucleotide/@target_alphabet@_implicit_conversion_from_@source_alphabet@_views.cpp.in
 
#include <vector>
 
#include <seqan3/alphabet/nucleotide/dna4.hpp>
#include <seqan3/alphabet/nucleotide/rna4.hpp>
#include <seqan3/utility/views/convert.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::dna4_vector vector = "ACG"_dna4;
 
    auto rna4_view = vector | seqan3::views::convert<seqan3::rna4>;
 
    for (auto && chr : rna4_view) // converts lazily on-the-fly
    {
        static_assert(std::same_as<decltype(chr), seqan3::rna4 &&>);
    }
}

// generated from test/snippet/alphabet/nucleotide/@target_alphabet@_literal.cpp.in
 
#include <seqan3/alphabet/nucleotide/dna4.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::dna4_vector sequence1{"ACGTTA"_dna4};
    seqan3::dna4_vector sequence2 = "ACGTTA"_dna4;
    auto sequence3 = "ACGTTA"_dna4;
}

#include <seqan3/alphabet/nucleotide/dna5.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::dna5 letter{'A'_dna5};
 
    letter.assign_char('C');
    seqan3::debug_stream << letter << '\n'; // prints "C"
 
    letter.assign_char('F');                // Unknown characters are implicitly converted to N.
    seqan3::debug_stream << letter << '\n'; // prints "N"
}

// generated from test/snippet/alphabet/nucleotide/@target_alphabet@_char_literal.cpp.in
 
#include <seqan3/alphabet/nucleotide/dna5.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::dna5 letter1{'A'_dna5};
    auto letter2 = 'A'_dna5;
}

// generated from test/snippet/alphabet/nucleotide/@target_alphabet@_implicit_conversion_from_@source_alphabet@.cpp.in
 
#include <seqan3/alphabet/nucleotide/dna5.hpp>
#include <seqan3/alphabet/nucleotide/rna5.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::dna5 letter1 = 'C'_rna5; // implicitly converted
    seqan3::dna5 letter2{};
    letter2 = 'C'_rna5; // implicitly converted
}

// generated from test/snippet/alphabet/nucleotide/@target_alphabet@_implicit_conversion_from_@source_alphabet@_inherit.cpp.in
 
#include <seqan3/alphabet/nucleotide/dna5.hpp>
#include <seqan3/alphabet/nucleotide/rna5.hpp>
 
struct my_dna5 : public seqan3::dna5
{
    // using seqan3::dna5::dna5; // uncomment to import implicit conversion shown by letter1
};
 
struct my_rna5 : public seqan3::rna5
{};
 
int main()
{
    using namespace seqan3::literals;
 
    // my_dna5 letter1 = 'C'_rna5; // NO automatic implicit conversion!
    // seqan3::dna5 letter2 = my_rna5{}; // seqan3::dna5 only allows implicit conversion from seqan3::rna5!
}
 
#include <seqan3/utility/concept.hpp>
 
static_assert(seqan3::implicitly_convertible_to<seqan3::rna5, seqan3::dna5>);
static_assert(!seqan3::implicitly_convertible_to<seqan3::rna5, my_dna5>);
static_assert(!seqan3::implicitly_convertible_to<my_rna5, seqan3::dna5>);

// generated from test/snippet/alphabet/nucleotide/@target_alphabet@_implicit_conversion_from_@source_alphabet@_vector.cpp.in
 
#include <vector>
 
#include <seqan3/alphabet/nucleotide/dna5.hpp>
#include <seqan3/alphabet/nucleotide/rna5.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::dna5_vector vector{'A'_rna5, 'C'_rna5, 'G'_rna5}; // (element-wise) implicit conversion
 
    // but this won't work:
    // seqan3::dna5_vector dna5_vector{"ACGT"_rna5};
 
    // as a workaround you can use:
    // side note: this would also work without the implicit conversion.
    seqan3::rna5_vector rna5_vector = "ACGT"_rna5;
    seqan3::dna5_vector dna5_vector{rna5_vector.begin(), rna5_vector.end()};
}

// generated from test/snippet/alphabet/nucleotide/@target_alphabet@_implicit_conversion_from_@source_alphabet@_views.cpp.in
 
#include <vector>
 
#include <seqan3/alphabet/nucleotide/dna5.hpp>
#include <seqan3/alphabet/nucleotide/rna5.hpp>
#include <seqan3/utility/views/convert.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::dna5_vector vector = "ACG"_dna5;
 
    auto rna5_view = vector | seqan3::views::convert<seqan3::rna5>;
 
    for (auto && chr : rna5_view) // converts lazily on-the-fly
    {
        static_assert(std::same_as<decltype(chr), seqan3::rna5 &&>);
    }
}

// generated from test/snippet/alphabet/nucleotide/@target_alphabet@_literal.cpp.in
 
#include <seqan3/alphabet/nucleotide/dna5.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::dna5_vector sequence1{"ACGTTA"_dna5};
    seqan3::dna5_vector sequence2 = "ACGTTA"_dna5;
    auto sequence3 = "ACGTTA"_dna5;
}

#include <seqan3/alphabet/nucleotide/rna15.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::rna15 letter{'A'_rna15};
 
    letter.assign_char('C');
    seqan3::debug_stream << letter << '\n'; // prints "C"
 
    letter.assign_char('F');                // Unknown characters are implicitly converted to N.
    seqan3::debug_stream << letter << '\n'; // prints "N"
}

// generated from test/snippet/alphabet/nucleotide/@target_alphabet@_char_literal.cpp.in
 
#include <seqan3/alphabet/nucleotide/rna15.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::rna15 letter1{'A'_rna15};
    auto letter2 = 'A'_rna15;
}

// generated from test/snippet/alphabet/nucleotide/@target_alphabet@_implicit_conversion_from_@source_alphabet@.cpp.in
 
#include <seqan3/alphabet/nucleotide/dna15.hpp>
#include <seqan3/alphabet/nucleotide/rna15.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::rna15 letter1 = 'C'_dna15; // implicitly converted
    seqan3::rna15 letter2{};
    letter2 = 'C'_dna15; // implicitly converted
}

// generated from test/snippet/alphabet/nucleotide/@target_alphabet@_implicit_conversion_from_@source_alphabet@_inherit.cpp.in
 
#include <seqan3/alphabet/nucleotide/dna15.hpp>
#include <seqan3/alphabet/nucleotide/rna15.hpp>
 
struct my_rna15 : public seqan3::rna15
{
    // using seqan3::rna15::rna15; // uncomment to import implicit conversion shown by letter1
};
 
struct my_dna15 : public seqan3::dna15
{};
 
int main()
{
    using namespace seqan3::literals;
 
    // my_rna15 letter1 = 'C'_dna15; // NO automatic implicit conversion!
    // seqan3::rna15 letter2 = my_dna15{}; // seqan3::rna15 only allows implicit conversion from seqan3::dna15!
}
 
#include <seqan3/utility/concept.hpp>
 
static_assert(seqan3::implicitly_convertible_to<seqan3::dna15, seqan3::rna15>);
static_assert(!seqan3::implicitly_convertible_to<seqan3::dna15, my_rna15>);
static_assert(!seqan3::implicitly_convertible_to<my_dna15, seqan3::rna15>);

// generated from test/snippet/alphabet/nucleotide/@target_alphabet@_implicit_conversion_from_@source_alphabet@_vector.cpp.in
 
#include <vector>
 
#include <seqan3/alphabet/nucleotide/dna15.hpp>
#include <seqan3/alphabet/nucleotide/rna15.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::rna15_vector vector{'A'_dna15, 'C'_dna15, 'G'_dna15}; // (element-wise) implicit conversion
 
    // but this won't work:
    // seqan3::rna15_vector rna15_vector{"ACGT"_dna15};
 
    // as a workaround you can use:
    // side note: this would also work without the implicit conversion.
    seqan3::dna15_vector dna15_vector = "ACGT"_dna15;
    seqan3::rna15_vector rna15_vector{dna15_vector.begin(), dna15_vector.end()};
}

// generated from test/snippet/alphabet/nucleotide/@target_alphabet@_implicit_conversion_from_@source_alphabet@_views.cpp.in
 
#include <vector>
 
#include <seqan3/alphabet/nucleotide/dna15.hpp>
#include <seqan3/alphabet/nucleotide/rna15.hpp>
#include <seqan3/utility/views/convert.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::rna15_vector vector = "ACG"_rna15;
 
    auto dna15_view = vector | seqan3::views::convert<seqan3::dna15>;
 
    for (auto && chr : dna15_view) // converts lazily on-the-fly
    {
        static_assert(std::same_as<decltype(chr), seqan3::dna15 &&>);
    }
}

// generated from test/snippet/alphabet/nucleotide/@target_alphabet@_literal.cpp.in
 
#include <seqan3/alphabet/nucleotide/rna15.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::rna15_vector sequence1{"ACGTTA"_rna15};
    seqan3::rna15_vector sequence2 = "ACGTTA"_rna15;
    auto sequence3 = "ACGTTA"_rna15;
}

#include <seqan3/alphabet/nucleotide/rna4.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::rna4 letter{'A'_rna4};
 
    letter.assign_char('C');
    seqan3::debug_stream << letter << '\n'; // prints "C"
 
    letter.assign_char('F');                // Unknown characters are implicitly converted to A.
    seqan3::debug_stream << letter << '\n'; // prints "A"
}

// generated from test/snippet/alphabet/nucleotide/@target_alphabet@_char_literal.cpp.in
 
#include <seqan3/alphabet/nucleotide/rna4.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::rna4 letter1{'A'_rna4};
    auto letter2 = 'A'_rna4;
}

// generated from test/snippet/alphabet/nucleotide/@target_alphabet@_implicit_conversion_from_@source_alphabet@.cpp.in
 
#include <seqan3/alphabet/nucleotide/dna4.hpp>
#include <seqan3/alphabet/nucleotide/rna4.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::rna4 letter1 = 'C'_dna4; // implicitly converted
    seqan3::rna4 letter2{};
    letter2 = 'C'_dna4; // implicitly converted
}

// generated from test/snippet/alphabet/nucleotide/@target_alphabet@_implicit_conversion_from_@source_alphabet@_inherit.cpp.in
 
#include <seqan3/alphabet/nucleotide/dna4.hpp>
#include <seqan3/alphabet/nucleotide/rna4.hpp>
 
struct my_rna4 : public seqan3::rna4
{
    // using seqan3::rna4::rna4; // uncomment to import implicit conversion shown by letter1
};
 
struct my_dna4 : public seqan3::dna4
{};
 
int main()
{
    using namespace seqan3::literals;
 
    // my_rna4 letter1 = 'C'_dna4; // NO automatic implicit conversion!
    // seqan3::rna4 letter2 = my_dna4{}; // seqan3::rna4 only allows implicit conversion from seqan3::dna4!
}
 
#include <seqan3/utility/concept.hpp>
 
static_assert(seqan3::implicitly_convertible_to<seqan3::dna4, seqan3::rna4>);
static_assert(!seqan3::implicitly_convertible_to<seqan3::dna4, my_rna4>);
static_assert(!seqan3::implicitly_convertible_to<my_dna4, seqan3::rna4>);

// generated from test/snippet/alphabet/nucleotide/@target_alphabet@_implicit_conversion_from_@source_alphabet@_vector.cpp.in
 
#include <vector>
 
#include <seqan3/alphabet/nucleotide/dna4.hpp>
#include <seqan3/alphabet/nucleotide/rna4.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::rna4_vector vector{'A'_dna4, 'C'_dna4, 'G'_dna4}; // (element-wise) implicit conversion
 
    // but this won't work:
    // seqan3::rna4_vector rna4_vector{"ACGT"_dna4};
 
    // as a workaround you can use:
    // side note: this would also work without the implicit conversion.
    seqan3::dna4_vector dna4_vector = "ACGT"_dna4;
    seqan3::rna4_vector rna4_vector{dna4_vector.begin(), dna4_vector.end()};
}

// generated from test/snippet/alphabet/nucleotide/@target_alphabet@_implicit_conversion_from_@source_alphabet@_views.cpp.in
 
#include <vector>
 
#include <seqan3/alphabet/nucleotide/dna4.hpp>
#include <seqan3/alphabet/nucleotide/rna4.hpp>
#include <seqan3/utility/views/convert.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::rna4_vector vector = "ACG"_rna4;
 
    auto dna4_view = vector | seqan3::views::convert<seqan3::dna4>;
 
    for (auto && chr : dna4_view) // converts lazily on-the-fly
    {
        static_assert(std::same_as<decltype(chr), seqan3::dna4 &&>);
    }
}

// generated from test/snippet/alphabet/nucleotide/@target_alphabet@_literal.cpp.in
 
#include <seqan3/alphabet/nucleotide/rna4.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::rna4_vector sequence1{"ACGTTA"_rna4};
    seqan3::rna4_vector sequence2 = "ACGTTA"_rna4;
    auto sequence3 = "ACGTTA"_rna4;
}

#include <seqan3/alphabet/nucleotide/rna5.hpp>
#include <seqan3/core/debug_stream.hpp>
int main()
{
    using namespace seqan3::literals;
 
    seqan3::rna5 letter{'A'_rna5};
 
    letter.assign_char('C');
    seqan3::debug_stream << letter << '\n'; // prints "C"
 
    letter.assign_char('F');                // Unknown characters are implicitly converted to N.
    seqan3::debug_stream << letter << '\n'; // prints "N"
}

// generated from test/snippet/alphabet/nucleotide/@target_alphabet@_char_literal.cpp.in
 
#include <seqan3/alphabet/nucleotide/rna5.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::rna5 letter1{'A'_rna5};
    auto letter2 = 'A'_rna5;
}

// generated from test/snippet/alphabet/nucleotide/@target_alphabet@_implicit_conversion_from_@source_alphabet@.cpp.in
 
#include <seqan3/alphabet/nucleotide/dna5.hpp>
#include <seqan3/alphabet/nucleotide/rna5.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::rna5 letter1 = 'C'_dna5; // implicitly converted
    seqan3::rna5 letter2{};
    letter2 = 'C'_dna5; // implicitly converted
}

// generated from test/snippet/alphabet/nucleotide/@target_alphabet@_implicit_conversion_from_@source_alphabet@_inherit.cpp.in
 
#include <seqan3/alphabet/nucleotide/dna5.hpp>
#include <seqan3/alphabet/nucleotide/rna5.hpp>
 
struct my_rna5 : public seqan3::rna5
{
    // using seqan3::rna5::rna5; // uncomment to import implicit conversion shown by letter1
};
 
struct my_dna5 : public seqan3::dna5
{};
 
int main()
{
    using namespace seqan3::literals;
 
    // my_rna5 letter1 = 'C'_dna5; // NO automatic implicit conversion!
    // seqan3::rna5 letter2 = my_dna5{}; // seqan3::rna5 only allows implicit conversion from seqan3::dna5!
}
 
#include <seqan3/utility/concept.hpp>
 
static_assert(seqan3::implicitly_convertible_to<seqan3::dna5, seqan3::rna5>);
static_assert(!seqan3::implicitly_convertible_to<seqan3::dna5, my_rna5>);
static_assert(!seqan3::implicitly_convertible_to<my_dna5, seqan3::rna5>);

// generated from test/snippet/alphabet/nucleotide/@target_alphabet@_implicit_conversion_from_@source_alphabet@_vector.cpp.in
 
#include <vector>
 
#include <seqan3/alphabet/nucleotide/dna5.hpp>
#include <seqan3/alphabet/nucleotide/rna5.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::rna5_vector vector{'A'_dna5, 'C'_dna5, 'G'_dna5}; // (element-wise) implicit conversion
 
    // but this won't work:
    // seqan3::rna5_vector rna5_vector{"ACGT"_dna5};
 
    // as a workaround you can use:
    // side note: this would also work without the implicit conversion.
    seqan3::dna5_vector dna5_vector = "ACGT"_dna5;
    seqan3::rna5_vector rna5_vector{dna5_vector.begin(), dna5_vector.end()};
}

// generated from test/snippet/alphabet/nucleotide/@target_alphabet@_implicit_conversion_from_@source_alphabet@_views.cpp.in
 
#include <vector>
 
#include <seqan3/alphabet/nucleotide/dna5.hpp>
#include <seqan3/alphabet/nucleotide/rna5.hpp>
#include <seqan3/utility/views/convert.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::rna5_vector vector = "ACG"_rna5;
 
    auto dna5_view = vector | seqan3::views::convert<seqan3::dna5>;
 
    for (auto && chr : dna5_view) // converts lazily on-the-fly
    {
        static_assert(std::same_as<decltype(chr), seqan3::dna5 &&>);
    }
}

// generated from test/snippet/alphabet/nucleotide/@target_alphabet@_literal.cpp.in
 
#include <seqan3/alphabet/nucleotide/rna5.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::rna5_vector sequence1{"ACGTTA"_rna5};
    seqan3::rna5_vector sequence2 = "ACGTTA"_rna5;
    auto sequence3 = "ACGTTA"_rna5;
}

#include <seqan3/alphabet/quality/phred42.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::phred42 letter{'@'_phred42};
 
    letter.assign_char('!');
    seqan3::debug_stream << letter.to_phred() << '\n'; // prints "0"
    seqan3::debug_stream << letter.to_char() << '\n';  // prints "!"
 
    letter.assign_phred(49); // Values exceeding the maximum are implicitly limited to the maximum phred value.
    seqan3::debug_stream << letter.to_phred() << '\n'; // prints "41"
}

#include <seqan3/alphabet/quality/phred42.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::phred42 letter1{'!'_phred42};
    auto letter2 = '!'_phred42;
}

#include <seqan3/alphabet/quality/phred42.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    std::vector<seqan3::phred42> sequence1{"##!!##"_phred42};
    std::vector<seqan3::phred42> sequence2 = "##!!##"_phred42;
    auto sequence3 = "##!!##"_phred42;
}

#include <seqan3/alphabet/quality/phred63.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::phred63 letter{'@'_phred63};
 
    letter.assign_char('!');
    seqan3::debug_stream << letter.to_phred() << '\n'; // prints "0"
    seqan3::debug_stream << letter.to_char() << '\n';  // prints "!"
 
    letter.assign_phred(72); // Values exceeding the maximum are implicitly limited to the maximum phred value.
    seqan3::debug_stream << letter.to_phred() << '\n'; // prints "62"
}

#include <seqan3/alphabet/quality/phred63.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::phred63 letter1{'!'_phred63};
    auto letter2 = '!'_phred63;
}

#include <seqan3/alphabet/quality/phred63.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    std::vector<seqan3::phred63> sequence1{"##!!##"_phred63};
    std::vector<seqan3::phred63> sequence2 = "##!!##"_phred63;
    auto sequence3 = "##!!##"_phred63;
}

#include <seqan3/alphabet/quality/phred68solexa.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::phred68solexa letter{'@'_phred68solexa};
 
    letter.assign_char(';');
    seqan3::debug_stream << letter.to_phred() << '\n'; // prints "-5"
    seqan3::debug_stream << letter.to_char() << '\n';  // prints ";"
 
    letter.assign_phred(72); // Values exceeding the maximum are implicitly limited to the maximum phred value.
    seqan3::debug_stream << letter.to_phred() << '\n'; // prints "62"
}

#include <seqan3/alphabet/quality/phred68solexa.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::phred68solexa letter1{'!'_phred68solexa};
    auto letter2 = '!'_phred68solexa;
}

#include <seqan3/alphabet/quality/phred68solexa.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    std::vector<seqan3::phred68solexa> sequence1{"##!!##"_phred68solexa};
    std::vector<seqan3::phred68solexa> sequence2 = "##!!##"_phred68solexa;
    auto sequence3 = "##!!##"_phred68solexa;
}

#include <seqan3/alphabet/quality/phred94.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::phred94 letter{'@'_phred94};
 
    letter.assign_char('!');
    seqan3::debug_stream << letter.to_phred() << '\n'; // prints "0"
    seqan3::debug_stream << letter.to_char() << '\n';  // prints "!"
 
    letter.assign_phred(99); // Values exceeding the maximum are implicitly limited to the maximum phred value.
    seqan3::debug_stream << letter.to_phred() << '\n'; // prints "93"
}

#include <seqan3/alphabet/quality/phred94.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::phred94 letter1{'!'_phred94};
    auto letter2 = '!'_phred94;
}

#include <seqan3/alphabet/quality/phred94.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    std::vector<seqan3::phred94> sequence1{"##!!##"_phred94};
    std::vector<seqan3::phred94> sequence2 = "##!!##"_phred94;
    auto sequence3 = "##!!##"_phred94;
}

#include <seqan3/alphabet/nucleotide/dna4.hpp>
#include <seqan3/alphabet/quality/phred42.hpp>
#include <seqan3/alphabet/quality/qualified.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    using namespace seqan3::literals;
    using seqan3::get;
 
    seqan3::qualified<seqan3::dna4, seqan3::phred42> letter{'A'_dna4, '('_phred42};
 
    seqan3::debug_stream << seqan3::to_rank(letter) << ' '           // 7
                         << seqan3::to_rank(get<0>(letter)) << ' '   // 0
                         << seqan3::to_rank(get<1>(letter)) << '\n'; // 7
 
    seqan3::debug_stream << seqan3::to_char(letter) << ' '           // A
                         << seqan3::to_char(get<0>(letter)) << ' '   // A
                         << seqan3::to_char(get<1>(letter)) << '\n'; // (
 
    seqan3::debug_stream << seqan3::to_phred(letter) << ' '           // 7
                         << seqan3::to_phred(get<1>(letter)) << '\n'; // 7
 
    // Modify:
    get<0>(letter) = 'G'_dna4;
    seqan3::debug_stream << seqan3::to_char(letter) << '\n'; // G
}

#include <seqan3/alphabet/structure/dot_bracket3.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::dot_bracket3 letter{'.'_db3};
 
    letter.assign_char('(');
    seqan3::debug_stream << letter << '\n'; // prints "("
 
    letter.assign_char('F');                // Unknown characters are implicitly converted to '.'.
    seqan3::debug_stream << letter << '\n'; // prints "."
}

#include <seqan3/alphabet/structure/dot_bracket3.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::dot_bracket3 letter1{'('_db3};
    auto letter2 = '('_db3;
}

#include <seqan3/alphabet/structure/dot_bracket3.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    std::vector<seqan3::dot_bracket3> sequence1{".(..)."_db3};
    std::vector<seqan3::dot_bracket3> sequence2 = ".(..)."_db3;
    auto sequence3 = ".(..)."_db3;
}

#include <seqan3/alphabet/structure/dssp9.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::dssp9 letter{'H'_dssp9};
 
    letter.assign_char('B');
    seqan3::debug_stream << letter << '\n'; // prints "B"
 
    letter.assign_char('F');                // Unknown characters are implicitly converted to 'X'.
    seqan3::debug_stream << letter << '\n'; // prints "X"
}

#include <seqan3/alphabet/structure/dssp9.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::dssp9 letter1{'('_dssp9};
    auto letter2 = '('_dssp9;
}

#include <seqan3/alphabet/structure/dssp9.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    std::vector<seqan3::dssp9> sequence1{"EHHHHT"_dssp9};
    std::vector<seqan3::dssp9> sequence2 = "EHHHHT"_dssp9;
    auto sequence3 = "EHHHHT"_dssp9;
}

#include <seqan3/alphabet/aminoacid/aa27.hpp>
#include <seqan3/alphabet/structure/dssp9.hpp>
#include <seqan3/alphabet/structure/structured_aa.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    using namespace seqan3::literals;
    using seqan3::get;
 
    seqan3::structured_aa<seqan3::aa27, seqan3::dssp9> letter{'W'_aa27, 'B'_dssp9};
 
    seqan3::debug_stream << seqan3::to_rank(letter) << ' '           // 199
                         << seqan3::to_rank(get<0>(letter)) << ' '   // 22
                         << seqan3::to_rank(get<1>(letter)) << '\n'; // 1
 
    seqan3::debug_stream << seqan3::to_char(letter) << ' '           // W
                         << seqan3::to_char(get<0>(letter)) << ' '   // W
                         << seqan3::to_char(get<1>(letter)) << '\n'; // B
 
    // Modify:
    get<0>(letter) = 'V'_aa27;
    seqan3::debug_stream << seqan3::to_char(letter) << '\n'; // V
}

#include <seqan3/alphabet/nucleotide/rna4.hpp>
#include <seqan3/alphabet/structure/dot_bracket3.hpp>
#include <seqan3/alphabet/structure/structured_rna.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    using namespace seqan3::literals;
    using seqan3::get;
 
    seqan3::structured_rna<seqan3::rna4, seqan3::dot_bracket3> letter{'G'_rna4, '('_db3};
 
    seqan3::debug_stream << seqan3::to_rank(letter) << ' '           // 7
                         << seqan3::to_rank(get<0>(letter)) << ' '   // 2
                         << seqan3::to_rank(get<1>(letter)) << '\n'; // 1
 
    seqan3::debug_stream << seqan3::to_char(letter) << ' '           // G
                         << seqan3::to_char(get<0>(letter)) << ' '   // G
                         << seqan3::to_char(get<1>(letter)) << '\n'; // (
 
    // Modify:
    get<0>(letter) = 'U'_rna4;
    seqan3::debug_stream << seqan3::to_char(letter) << '\n'; // U
}

#include <seqan3/alphabet/structure/wuss.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::wuss51 letter{':'_wuss51};
 
    letter.assign_char('~');
    seqan3::debug_stream << letter << '\n'; // prints "~"
 
    letter.assign_char('#');                // Unknown characters are implicitly converted to ';'.
    seqan3::debug_stream << letter << '\n'; // prints ";"
}

#include <seqan3/alphabet/structure/wuss.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::wuss51 letter1{'('_wuss51};
    auto letter2 = '('_wuss51;
}

#include <iostream>
 
#include <seqan3/alphabet/structure/wuss.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    bool is_closing_char_member = '}'_wuss51.is_pair_close();
    bool is_closing_char_free = seqan3::is_pair_close('.'_wuss51);
 
    std::cout << std::boolalpha << is_closing_char_member << '\n'; // true
    std::cout << std::boolalpha << is_closing_char_free << '\n';   // false
}

#include <iostream>
 
#include <seqan3/alphabet/structure/wuss.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    bool is_opening_char_member = '{'_wuss51.is_pair_open();
    bool is_opening_char_free = seqan3::is_pair_open('.'_wuss51);
 
    std::cout << std::boolalpha << is_opening_char_member << '\n'; // true
    std::cout << std::boolalpha << is_opening_char_free << '\n';   // false
}

#include <iostream>
 
#include <seqan3/alphabet/structure/wuss.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    bool is_unpaired_char_member = '.'_wuss51.is_unpaired();
    bool is_unpaired_char_free = seqan3::is_unpaired('{'_wuss51);
 
    std::cout << std::boolalpha << is_unpaired_char_member << '\n'; // true
    std::cout << std::boolalpha << is_unpaired_char_free << '\n';   // false
}

#include <seqan3/alphabet/structure/wuss.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    std::vector<seqan3::wuss51> sequence1{".<..>."_wuss51};
    std::vector<seqan3::wuss51> sequence2 = ".<..>."_wuss51;
    auto sequence3 = ".<..>."_wuss51;
}

#include <iostream>
 
#include <seqan3/alphabet/structure/wuss.hpp>
 
int main()
{
    uint8_t max_depth_member = seqan3::wuss51::max_pseudoknot_depth;
    uint8_t max_depth_meta = seqan3::max_pseudoknot_depth<seqan3::wuss51>;
    std::cout << static_cast<uint16_t>(max_depth_member) << '\n'; // 22
    std::cout << static_cast<uint16_t>(max_depth_meta) << '\n';   // 22
}

#include <seqan3/alphabet/structure/wuss.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    auto pk_opt = '.'_wuss51.pseudoknot_id();   // std::optional -> false
    pk_opt = seqan3::pseudoknot_id('{'_wuss51); // std::optional -> true: 3
 
    if (pk_opt)
        seqan3::debug_stream << *pk_opt << '\n'; // 3
}

#include <seqan3/alphabet/nucleotide/dna4.hpp>
#include <seqan3/alphabet/views/char_strictly_to.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    std::string_view str{"ACTTTGATAN"};
    try
    {
        seqan3::debug_stream << (str | seqan3::views::char_strictly_to<seqan3::dna4>); // ACTTTGATA
    }
    catch (seqan3::invalid_char_assignment const &)
    {
        seqan3::debug_stream << "\n[ERROR] Invalid char!\n"; // Will throw on parsing 'N'
    }
}

#include <seqan3/alphabet/nucleotide/dna4.hpp>
#include <seqan3/alphabet/nucleotide/dna5.hpp>
#include <seqan3/alphabet/views/char_to.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    std::string str{"ACTTTGATAN"};
    seqan3::debug_stream << (str | seqan3::views::char_to<seqan3::dna4>) << '\n'; // ACTTTGATAA
    seqan3::debug_stream << (str | seqan3::views::char_to<seqan3::dna5>) << '\n'; // ACTTTGATAN
}

#include <seqan3/alphabet/nucleotide/dna5.hpp>
#include <seqan3/alphabet/views/complement.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::dna5_vector foo{"ACGTA"_dna5};
 
    // pipe notation
    auto v = foo | seqan3::views::complement;
    seqan3::debug_stream << v << '\n'; // TGCAT
 
    // function notation
    auto v2(seqan3::views::complement(foo));
    seqan3::debug_stream << v2 << '\n'; // TGCAT
 
    // generate the reverse complement:
    auto v3 = foo | seqan3::views::complement | std::views::reverse;
    seqan3::debug_stream << v3 << '\n'; // TACGT
}

#include <vector>
 
#include <seqan3/alphabet/nucleotide/dna4.hpp>
#include <seqan3/alphabet/quality/aliases.hpp> // includes seqan3::dna4q
#include <seqan3/alphabet/quality/phred42.hpp>
#include <seqan3/alphabet/views/to_char.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::dna4_vector vec = "ACTTTGATA"_dna4;
    auto v = vec | seqan3::views::to_char;
    seqan3::debug_stream << v << '\n'; // [A,C,T,T,T,G,A,T,A]
 
    std::vector<seqan3::phred42> qvec{seqan3::phred42{}.assign_phred(0),
                                      seqan3::phred42{}.assign_phred(7),
                                      seqan3::phred42{}.assign_phred(5),
                                      seqan3::phred42{}.assign_phred(3),
                                      seqan3::phred42{}.assign_phred(7),
                                      seqan3::phred42{}.assign_phred(4),
                                      seqan3::phred42{}.assign_phred(30),
                                      seqan3::phred42{}.assign_phred(16),
                                      seqan3::phred42{}.assign_phred(23)};
    auto v3 = qvec | seqan3::views::to_char;
    seqan3::debug_stream << v3 << '\n'; // [!,(,&,$,(,%,?,1,8]
 
    std::vector<seqan3::dna4q> qcvec{{'C'_dna4, '!'_phred42},
                                     {'A'_dna4, '('_phred42},
                                     {'G'_dna4, '&'_phred42},
                                     {'T'_dna4, '$'_phred42},
                                     {'G'_dna4, '('_phred42},
                                     {'A'_dna4, '%'_phred42},
                                     {'C'_dna4, '?'_phred42},
                                     {'T'_dna4, '1'_phred42},
                                     {'A'_dna4, '8'_phred42}};
    auto v4 = qcvec | seqan3::views::to_char;
    seqan3::debug_stream << v4 << '\n'; // [C,A,G,T,G,A,C,T,A]
}

#include <vector>
 
#include <seqan3/alphabet/nucleotide/dna4.hpp>
#include <seqan3/alphabet/quality/aliases.hpp>
#include <seqan3/alphabet/quality/phred42.hpp>
#include <seqan3/alphabet/views/to_rank.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::dna4_vector vec = "ACTTTGATA"_dna4;
    auto v = vec | seqan3::views::to_rank;
    seqan3::debug_stream << v << '\n'; // [0,1,3,3,3,2,0,3,0]
 
    std::vector<seqan3::phred42> qvec{seqan3::phred42{}.assign_phred(0),
                                      seqan3::phred42{}.assign_phred(7),
                                      seqan3::phred42{}.assign_phred(5),
                                      seqan3::phred42{}.assign_phred(3),
                                      seqan3::phred42{}.assign_phred(7),
                                      seqan3::phred42{}.assign_phred(4),
                                      seqan3::phred42{}.assign_phred(30),
                                      seqan3::phred42{}.assign_phred(16),
                                      seqan3::phred42{}.assign_phred(23)};
 
    auto v3 = qvec | seqan3::views::to_rank;
    seqan3::debug_stream << v3 << '\n'; // [0,7,5,3,7,4,30,16,23]
 
    std::vector<seqan3::dna4q> qcvec{{'C'_dna4, '!'_phred42},
                                     {'A'_dna4, '('_phred42},
                                     {'G'_dna4, '&'_phred42},
                                     {'T'_dna4, '$'_phred42},
                                     {'G'_dna4, '('_phred42},
                                     {'A'_dna4, '%'_phred42},
                                     {'C'_dna4, '?'_phred42},
                                     {'T'_dna4, '1'_phred42},
                                     {'A'_dna4, '8'_phred42}};
    auto v4 = qcvec | seqan3::views::to_rank;
    seqan3::debug_stream << v4 << '\n'; // [42,7,89,129,91,4,72,142,23]
}

#include <vector>
 
#include <seqan3/alphabet/nucleotide/dna4.hpp>
#include <seqan3/alphabet/nucleotide/dna5.hpp>
#include <seqan3/alphabet/views/rank_to.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    std::vector<int> vec{0, 1, 3, 3, 3, 2, 0, 3, 0};
    seqan3::debug_stream << (vec | seqan3::views::rank_to<seqan3::dna4>) << '\n'; // ACTTTGATA
    seqan3::debug_stream << (vec | seqan3::views::rank_to<seqan3::dna5>) << '\n'; // ACNNNGANA
}

#include <iostream>
 
#include <seqan3/alphabet/adaptation/char.hpp>
#include <seqan3/alphabet/nucleotide/dna5.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    auto char_to_char = seqan3::to_char('A');      // calls seqan3::custom::to_char('A')
    auto dna5_to_char = seqan3::to_char('A'_dna5); // calls .to_char() member
    std::cout << char_to_char << '\n';             // A
    std::cout << dna5_to_char << '\n';             // A
}

#include <iostream>
 
#include <seqan3/alphabet/adaptation/char.hpp>
#include <seqan3/alphabet/nucleotide/dna5.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    auto char_to_rank = seqan3::to_rank('A'); // calls seqan3::custom::to_rank('A')
    static_assert(std::same_as<decltype(char_to_rank), uint8_t>);
    std::cout << static_cast<uint16_t>(char_to_rank) << '\n'; // 65
 
    auto dna5_to_rank = seqan3::to_rank('A'_dna5); // calls .to_char() member
    static_assert(std::same_as<decltype(dna5_to_rank), uint8_t>);
    std::cout << static_cast<uint16_t>(dna5_to_rank) << '\n'; // 0
}

#include <seqan3/alphabet/nucleotide/dna5.hpp>
#include <seqan3/alphabet/views/complement.hpp>
#include <seqan3/alphabet/views/translate.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::dna5_vector vec{"ACGTACGTACGTA"_dna5};
 
    // Default (first forward frame)
    auto v1 = vec | seqan3::views::translate_single;
    // == [T,Y,V,R]
    seqan3::debug_stream << v1[1] << '\n';
 
    // First forward frame
    auto v2 = vec | seqan3::views::translate_single(seqan3::translation_frames::forward_frame0);
    // == [T,Y,V,R]
 
    // First reverse frame
    auto v3 = vec | seqan3::views::translate_single(seqan3::translation_frames::reverse_frame0);
    // == [Y,V,R,T]
 
    // Second forward frame
    auto v4 = vec | seqan3::views::translate_single(seqan3::translation_frames::forward_frame1);
    // == [R,T,Y,V]
 
    // Second reverse frame
    auto v5 = vec | seqan3::views::translate_single(seqan3::translation_frames::reverse_frame1);
    // == [T,Y,V,R]
 
    // Third forward frame
    auto v6 = vec | seqan3::views::translate_single(seqan3::translation_frames::forward_frame2);
    // == [V,R,T]
 
    // Third reverse frame
    auto v7 = vec | seqan3::views::translate_single(seqan3::translation_frames::reverse_frame2);
    // == [R,T,Y]
 
    // function syntax
    auto v8 = seqan3::views::translate_single(vec, seqan3::translation_frames::forward_frame0);
    // == [T,Y,V,R]
 
    // combinability
    auto v9 =
        vec | seqan3::views::complement | seqan3::views::translate_single(seqan3::translation_frames::reverse_frame0);
    // == [M,H,A,C]
 
    // combinability with default parameter
    auto v10 = vec | seqan3::views::complement | seqan3::views::translate_single;
    // == [C,M,H,A]
 
    // combinability with default parameter
    auto v11 = vec | seqan3::views::complement | seqan3::views::translate_single();
    // == [C,M,H,A]
}

 
#include <iostream>
 
#include <seqan3/alphabet/nucleotide/dna4.hpp>
#include <seqan3/alphabet/views/char_to.hpp>
#include <seqan3/alphabet/views/translate_join.hpp>
#include <seqan3/core/debug_stream.hpp>
 
using namespace seqan3::literals;
 
int main()
{
    // Input range needs to be two-dimensional
    std::vector<std::vector<seqan3::dna4>> vec{"ACGTACGTACGTA"_dna4, "TCGAGAGCTTTAGC"_dna4};
 
    // Translation with default parameters
    auto v1 = vec | seqan3::views::translate_join;
    seqan3::debug_stream << v1 << "\n"; // [TYVR,RTYV,VRT,YVRT,TYVR,RTY,SRAL,REL*,ESFS,AKAL,LKLS,*SSR]
 
    // Access the third forward frame (index_frame 2) of the second input sequence (index_seq 1)
    // Required frames per sequence s = 6
    // n = (index_seq * s) + j
    //   = 1 * 6 + 2
    //   = 8
 
    auto third_frame_second_seq = v1[1 * 6 + 2];
    seqan3::debug_stream << third_frame_second_seq << "\n"; // ESFS
 
    // Translation with custom translation frame
    auto v2 = vec | seqan3::views::translate_join(seqan3::translation_frames::forward_frame0);
    seqan3::debug_stream << v2 << "\n"; // [TYVR,SRAL]
 
    return 0;
}

#include <seqan3/alphabet/nucleotide/dna5.hpp>
#include <seqan3/alphabet/views/complement.hpp>
#include <seqan3/alphabet/views/translate.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::dna5_vector vec{"ACGTACGTACGTA"_dna5};
 
    // default frame translation
    auto v1 = vec | seqan3::views::translate;
    seqan3::debug_stream << v1 << '\n'; // [TYVR,RTYV,VRT,YVRT,TYVR,RTY]
 
    // single frame translation
    auto v2 = vec | seqan3::views::translate(seqan3::translation_frames::forward_frame0);
    seqan3::debug_stream << v2 << '\n'; // [TYVR]
 
    // reverse translation
    auto v3 = vec | seqan3::views::translate(seqan3::translation_frames::forward_reverse0);
    seqan3::debug_stream << v3 << '\n'; // [TYVR,YVRT]
 
    // forward frames translation
    auto v4 = vec | seqan3::views::translate(seqan3::translation_frames::forward_frames);
    seqan3::debug_stream << v4 << '\n'; // [TYVR,RTYV,VRT]
 
    // six frame translation
    auto v5 = vec | seqan3::views::translate(seqan3::translation_frames::six_frames);
    seqan3::debug_stream << v5 << '\n'; // [TYVR,RTYV,VRT,YVRT,TYVR,RTY]
 
    // function syntax
    auto v6 = seqan3::views::translate(vec, seqan3::translation_frames::forward_reverse0);
    seqan3::debug_stream << v6 << '\n'; // [TYVR,YVRT]
 
    // combinability
    auto v7 = vec | seqan3::views::complement | seqan3::views::translate(seqan3::translation_frames::forward_reverse0);
    seqan3::debug_stream << v7 << '\n'; // [CMHA,MHAC]
}

#include <string>
#include <vector>
 
#include <seqan3/alphabet/nucleotide/dna5.hpp>
#include <seqan3/alphabet/quality/aliases.hpp>
#include <seqan3/alphabet/quality/phred42.hpp>
#include <seqan3/alphabet/views/to_char.hpp>
#include <seqan3/alphabet/views/trim_quality.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    std::vector<seqan3::dna5q> vec{{'A'_dna5, 'I'_phred42},
                                   {'G'_dna5, 'I'_phred42},
                                   {'G'_dna5, '?'_phred42},
                                   {'A'_dna5, '5'_phred42},
                                   {'T'_dna5, '+'_phred42}};
 
    // trim by phred_value
    auto v1 = vec | seqan3::views::trim_quality(20u);
    seqan3::debug_stream << v1 << '\n'; // AGGA
 
    // trim by quality character; in this case the nucleotide part of the character is irrelevant
    auto v2 = vec | seqan3::views::trim_quality(seqan3::dna5q{'C'_dna5, '5'_phred42});
    seqan3::debug_stream << v2 << '\n'; // AGGA
 
    // combinability
    auto v3 = seqan3::views::trim_quality(vec, 20u) | seqan3::views::to_char;
    seqan3::debug_stream << v3 << '\n'; // AGGA
}

#include <string>
#include <vector>
 
#include <seqan3/alphabet/quality/phred42.hpp>
#include <seqan3/alphabet/views/to_char.hpp>
#include <seqan3/alphabet/views/trim_quality.hpp>
#include <seqan3/core/debug_stream.hpp>
 
using namespace seqan3::literals;
 
int main()
{
    std::vector<seqan3::phred42> vec{"II?5+"_phred42};
 
    // trim by phred_value
    auto v1 = vec | seqan3::views::trim_quality(20u);
    seqan3::debug_stream << v1 << '\n'; // II?5
 
    // trim by quality character
    auto v2 = vec | seqan3::views::trim_quality('I'_phred42);
    seqan3::debug_stream << v2 << '\n'; // II
 
    // function syntax
    auto v3 = seqan3::views::trim_quality(vec, '5'_phred42);
    seqan3::debug_stream << v3 << '\n'; // II?5
 
    // combinability
    auto v4 = seqan3::views::trim_quality(vec, 20u) | seqan3::views::to_char;
    seqan3::debug_stream << v4 << '\n'; // II?5
}

#include <seqan3/alphabet/nucleotide/dna4.hpp>
#include <seqan3/alphabet/views/validate_char_for.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    std::string_view str{"ACTTTGATAN"};
    try
    {
        seqan3::debug_stream << (str | seqan3::views::validate_char_for<seqan3::dna4>); // ACTTTGATA
    }
    catch (seqan3::invalid_char_assignment const &)
    {
        seqan3::debug_stream << "\n[ERROR] Invalid char!\n"; // Will throw on parsing 'N'
    }
}

#include <seqan3/argument_parser/all.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main(int argc, char ** argv)
{
    seqan3::argument_parser myparser{"Grade-Average", argc, argv}; // initialize
 
    std::string name{"Max Muster"}; // define default values directly in the variable.
    bool bonus{false};
    std::vector<double> grades{}; // you can also specify a vector that is treated as a list option.
 
    myparser.add_option(name, 'n', "name", "Please specify your name.");
    myparser.add_flag(bonus, 'b', "bonus", "Please specify if you got the bonus.");
    myparser.add_positional_option(grades, "Please specify your grades.");
 
    try
    {
        myparser.parse();
    }
    catch (seqan3::argument_parser_error const & ext) // the user did something wrong
    {
        std::cerr << "[PARSER ERROR] " << ext.what() << '\n'; // customize your error message
        return -1;
    }
 
    if (bonus)
        grades.push_back(1.0); // extra good grade
 
    double avg{0};
    for (auto g : grades)
        avg += g;
 
    avg = avg / grades.size();
 
    seqan3::debug_stream << name << " has an average grade of " << avg << '\n';
 
    return 0;
}

#include <seqan3/argument_parser/all.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main(int argc, char ** argv)
{
    seqan3::argument_parser myparser{"The-Age-App", argc, argv}; // initialize
 
    int age{30}; // define default values directly in the variable
 
    myparser.add_option(age, 'a', "user-age", "Please specify your age.");
 
    try
    {
        myparser.parse();
    }
    catch (seqan3::argument_parser_error const & ext) // the user did something wrong
    {
        std::cerr << "The-Age-App - [PARSER ERROR] " << ext.what() << '\n'; // customize your error message
        return -1;
    }
 
    seqan3::debug_stream << "integer given by user: " << age << '\n';
    return 0;
}

#include <seqan3/argument_parser/all.hpp>
 
int main(int argc, char ** argv)
{
    seqan3::argument_parser myparser{"Penguin_Parade", argc, argv}; // initialize
 
    myparser.info.version = "2.0.0";
    myparser.info.date = "12.01.2017";
    myparser.info.short_description = "Organize your penguin parade";
    myparser.info.description.push_back("First Paragraph.");
    myparser.info.description.push_back("Second Paragraph.");
    myparser.info.examples.push_back("./penguin_parade Skipper Kowalski Rico Private -d 10 -m 02 -y 2017");
 
    int d{01};   // day
    int m{01};   // month
    int y{2050}; // year
 
    myparser.add_option(d, 'd', "day", "Please specify your preferred day.");
    myparser.add_option(m, 'm', "month", "Please specify your preferred month.");
    myparser.add_option(y, 'y', "year", "Please specify your preferred year.");
 
    std::vector<std::string> penguin_names;
 
    myparser.add_positional_option(penguin_names, "Specify the names of the penguins.");
 
    try
    {
        myparser.parse();
    }
    catch (seqan3::argument_parser_error const & ext) // the user did something wrong
    {
        std::cerr << ext.what() << "\n";
        return -1;
    }
 
    // organize ...
 
    return 0;
}

#include <seqan3/argument_parser/all.hpp>
 
int main(int argc, char const ** argv)
{
    seqan3::argument_parser myparser{"Test", argc, argv};
    std::string myvar{"Example"};
    myparser.add_option(myvar, 's', "special-op", "You know what you doin'?", seqan3::option_spec::advanced);
}

#include <ranges>
#include <system_error>
 
#include <seqan3/argument_parser/all.hpp>
 
namespace seqan3::custom
{
// Specialise the seqan3::custom::argument_parsing data structure to enable parsing of std::errc.
template <>
struct argument_parsing<std::errc>
{
    // Specialise a mapping from an identifying string to the respective value of your type Foo.
    static inline std::unordered_map<std::string_view, std::errc> const enumeration_names{
        {"no_error", std::errc{}},
        {"timed_out", std::errc::timed_out},
        {"invalid_argument", std::errc::invalid_argument},
        {"io_error", std::errc::io_error}};
};
 
} // namespace seqan3::custom
 
int main(int argc, char const * argv[])
{
    std::errc value{};
 
    seqan3::argument_parser parser{"my_program", argc, argv};
 
    // Because of the argument_parsing struct and
    // the static member function enumeration_names
    // you can now add an option that takes a value of type std::errc:
    parser.add_option(value,
                      'e',
                      "errc",
                      "Give me a std::errc value.",
                      seqan3::option_spec::standard,
                      seqan3::value_list_validator{(seqan3::enumeration_names<std::errc> | std::views::values)});
 
    try
    {
        parser.parse();
    }
    catch (seqan3::argument_parser_error const & ext) // the user did something wrong
    {
        std::cerr << "[PARSER ERROR] " << ext.what() << "\n"; // customize your error message
        return -1;
    }
 
    return 0;
}

#include <seqan3/argument_parser/all.hpp>
 
namespace foo
{
 
enum class bar
{
    one,
    two,
    three
};
 
// Specialise a mapping from an identifying string to the respective value of your type bar.
auto enumeration_names(bar)
{
    return std::unordered_map<std::string_view, bar>{{"one", bar::one}, {"two", bar::two}, {"three", bar::three}};
}
 
} // namespace foo
 
int main(int argc, char const * argv[])
{
    foo::bar value{};
 
    seqan3::argument_parser parser{"my_program", argc, argv};
 
    // Because of the enumeration_names function
    // you can now add an option that takes a value of type bar:
    parser.add_option(value,
                      'f',
                      "foo",
                      "Give me a foo value.",
                      seqan3::option_spec::standard,
                      seqan3::value_list_validator{(seqan3::enumeration_names<foo::bar> | std::views::values)});
 
    try
    {
        parser.parse();
    }
    catch (seqan3::argument_parser_error const & ext) // the user did something wrong
    {
        std::cerr << "[PARSER ERROR] " << ext.what() << "\n"; // customize your error message
        return -1;
    }
}

#include <seqan3/argument_parser/all.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main(int argc, char ** argv)
{
    seqan3::argument_parser myparser{"awesome-app", argc, argv}; // initialize
 
    int a{3};
    myparser.add_option(a, 'a', "awesome-parameter", "Please specify an integer.");
 
    try
    {
        myparser.parse();
    }
    catch (seqan3::argument_parser_error const & ext) // the user did something wrong
    {
        std::cerr << "[PARSER ERROR] " << ext.what() << '\n'; // customize your error message
        return -1;
    }
 
    if (myparser.is_option_set('a'))
        seqan3::debug_stream << "The user set option -a on the command line.\n";
 
    if (myparser.is_option_set("awesome-parameter"))
        seqan3::debug_stream << "The user set option --awesome-parameter on the command line.\n";
 
    // Asking for an option identifier that was not used before throws an error:
    // myparser.is_option_set("foo"); // throws seqan3::design_error
 
    return 0;
}

#include <seqan3/argument_parser/all.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main(int argc, char const ** argv)
{
    seqan3::argument_parser myparser{"Test", argc, argv}; // initialize
 
    int myint;
    seqan3::arithmetic_range_validator my_validator{2, 10};
 
    myparser.add_option(myint, 'i', "integer", "Give me a number.", seqan3::option_spec::standard, my_validator);
 
    // an exception will be thrown if the user specifies an integer
    // that is not in range [2,10] (e.g. "./test_app -i 15")
    try
    {
        myparser.parse();
    }
    catch (seqan3::argument_parser_error const & ext) // the user did something wrong
    {
        std::cerr << "[PARSER ERROR] " << ext.what() << "\n"; // customize your error message
        return -1;
    }
 
    seqan3::debug_stream << "integer given by user passed validation: " << myint << "\n";
    return 0;
}

#include <seqan3/argument_parser/all.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main(int argc, char const ** argv)
{
    seqan3::argument_parser myparser{"Test", argc, argv}; // initialize
 
    int myint;
    seqan3::value_list_validator my_validator{2, 4, 6, 8, 10};
 
    myparser.add_option(myint, 'i', "integer", "Give me a number.", seqan3::option_spec::standard, my_validator);
 
    // an exception will be thrown if the user specifies an integer
    // that is not one of [2,4,6,8,10] (e.g. "./test_app -i 3")
    try
    {
        myparser.parse();
    }
    catch (seqan3::argument_parser_error const & ext) // the user did something wrong
    {
        std::cerr << "[PARSER ERROR] " << ext.what() << "\n"; // customize your error message
        return -1;
    }
 
    seqan3::debug_stream << "integer given by user passed validation: " << myint << "\n";
    return 0;
}

#include <filesystem>
 
#include <seqan3/argument_parser/all.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main(int argc, char const ** argv)
{
    seqan3::argument_parser myparser{"Test", argc, argv}; // initialize
 
    std::filesystem::path myfile;
 
    myparser.add_option(myfile,
                        'f',
                        "file",
                        "Give me a filename.",
                        seqan3::option_spec::standard,
                        seqan3::input_file_validator{{"fa", "fasta"}});
 
    // an exception will be thrown if the user specifies a filename
    // that does not have one of the extensions ["fa","fasta"],
    // does not exists, or is not readable.
    try
    {
        myparser.parse();
    }
    catch (seqan3::argument_parser_error const & ext) // the user did something wrong
    {
        std::cerr << "[PARSER ERROR] " << ext.what() << "\n"; // customize your error message
        return -1;
    }
 
    seqan3::debug_stream << "filename given by user passed validation: " << myfile << "\n";
    return 0;
}

#include <seqan3/argument_parser/all.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main(int argc, char const ** argv)
{
    seqan3::argument_parser myparser{"Test", argc, argv}; // initialize
 
    std::string my_string;
    seqan3::regex_validator my_validator{"[a-zA-Z]+@[a-zA-Z]+\\.com"};
 
    myparser.add_option(my_string, 's', "str", "Give me a string.", seqan3::option_spec::standard, my_validator);
 
    // an exception will be thrown if the user specifies a string
    // that is no email address ending on .com
    try
    {
        myparser.parse();
    }
    catch (seqan3::argument_parser_error const & ext) // the user did something wrong
    {
        std::cerr << "[PARSER ERROR] " << ext.what() << "\n"; // customize your error message
        return -1;
    }
 
    seqan3::debug_stream << "email address given by user passed validation: " << my_string << "\n";
    return 0;
}

#include <filesystem>
 
#include <seqan3/argument_parser/all.hpp>
 
int main(int argc, char const ** argv)
{
    seqan3::argument_parser myparser{"Test", argc, argv}; // initialize
 
    std::string file_name;
 
    seqan3::regex_validator absolute_path_validator{"(/[^/]+)+/.*\\.[^/\\.]+$"};
    seqan3::input_file_validator my_file_ext_validator{{"sa", "so"}};
 
    myparser.add_option(file_name,
                        'f',
                        "file",
                        "Give me a file name with an absolute path.",
                        seqan3::option_spec::standard,
                        absolute_path_validator | my_file_ext_validator);
 
    // an exception will be thrown if the user specifies a file name
    // that is not an absolute path or does not have one of the file extension [sa,so]
    try
    {
        myparser.parse();
    }
    catch (seqan3::argument_parser_error const & ext) // the user did something wrong
    {
        std::cerr << "[PARSER ERROR] " << ext.what() << "\n"; // customize your error message
        return -1;
    }
 
    std::cout << "filename given by user passed validation: " << file_name << "\n";
    return 0;
}

#include <filesystem>
 
#include <seqan3/argument_parser/all.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main(int argc, char const ** argv)
{
    seqan3::argument_parser myparser{"Test", argc, argv}; // initialize
 
    std::filesystem::path mydir{};
 
    myparser.add_option(mydir,
                        'd',
                        "dir",
                        "The directory containing the input files.",
                        seqan3::option_spec::standard,
                        seqan3::input_directory_validator{});
 
    // an exception will be thrown if the user specifies a directory that does not exists or has insufficient
    // read permissions.
    try
    {
        myparser.parse();
    }
    catch (seqan3::argument_parser_error const & ext) // the user did something wrong
    {
        std::cerr << "[PARSER ERROR] " << ext.what() << "\n"; // customize your error message
        return -1;
    }
 
    seqan3::debug_stream << "directory given by user passed validation: " << mydir << "\n";
    return 0;
}

#include <filesystem>
 
#include <seqan3/argument_parser/all.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main(int argc, char const ** argv)
{
    seqan3::argument_parser myparser{"Test", argc, argv}; // initialize
 
    std::filesystem::path myfile{};
 
    myparser.add_option(myfile,
                        'f',
                        "file",
                        "The input file containing the sequences.",
                        seqan3::option_spec::standard,
                        seqan3::input_file_validator{{"fa", "fasta"}});
 
    // an exception will be thrown if the user specifies a filename
    // that does not have one of the extensions ["fa","fasta"] or if the file does not exist/is not readable.
    try
    {
        myparser.parse();
    }
    catch (seqan3::argument_parser_error const & ext) // the user did something wrong
    {
        std::cerr << "[PARSER ERROR] " << ext.what() << "\n"; // customize your error message
        return -1;
    }
 
    seqan3::debug_stream << "filename given by user passed validation: " << myfile << "\n";
    return 0;
}

#include <seqan3/argument_parser/validators.hpp>
#include <seqan3/core/debug_stream.hpp>
#include <seqan3/io/sequence_file/input.hpp>
 
int main()
{
    // Default constructed validator has an empty extension list.
    seqan3::input_file_validator validator1{};
    seqan3::debug_stream << validator1.get_help_page_message() << '\n';
 
    // Specify your own extensions for the input file.
    seqan3::input_file_validator validator2{std::vector{std::string{"exe"}, std::string{"fasta"}}};
    seqan3::debug_stream << validator2.get_help_page_message() << '\n';
 
    // Give the seqan3 file type as a template argument to get all valid extensions for this file.
    seqan3::input_file_validator<seqan3::sequence_file_input<>> validator3{};
    seqan3::debug_stream << validator3.get_help_page_message() << '\n';
 
    return 0;
}

#include <filesystem>
 
#include <seqan3/argument_parser/all.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main(int argc, char const ** argv)
{
    seqan3::argument_parser myparser{"Test", argc, argv}; // initialize
 
    std::filesystem::path mydir{};
 
    myparser.add_option(mydir,
                        'd',
                        "dir",
                        "The output directory for storing the files.",
                        seqan3::option_spec::standard,
                        seqan3::output_directory_validator{});
 
    // an exception will be thrown if the user specifies a directory that cannot be created by the filesystem either
    // because the parent path does not exists or the path has insufficient write permissions.
    try
    {
        myparser.parse();
    }
    catch (seqan3::argument_parser_error const & ext) // the user did something wrong
    {
        std::cerr << "[PARSER ERROR] " << ext.what() << "\n"; // customize your error message
        return -1;
    }
 
    seqan3::debug_stream << "directory given by user passed validation: " << mydir << "\n";
    return 0;
}

#include <filesystem>
 
#include <seqan3/argument_parser/all.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main(int argc, char const ** argv)
{
    seqan3::argument_parser myparser{"Test", argc, argv}; // initialize
 
    std::filesystem::path myfile{};
 
    // Use the seqan3::output_file_open_options to indicate that you allow overwriting existing output files, ...
    myparser.add_option(
        myfile,
        'f',
        "file",
        "Output file containing the processed sequences.",
        seqan3::option_spec::standard,
        seqan3::output_file_validator{seqan3::output_file_open_options::open_or_create, {"fa", "fasta"}});
 
    // ... or that you will throw a seqan3::validation_error if the user specified output file already exists
    myparser.add_option(myfile,
                        'g',
                        "file2",
                        "Output file containing the processed sequences.",
                        seqan3::option_spec::standard,
                        seqan3::output_file_validator{seqan3::output_file_open_options::create_new, {"fa", "fasta"}});
 
    // an exception will be thrown if the user specifies a filename
    // that does not have one of the extensions ["fa","fasta"],
    // if the file already exists, or if the file is not writable.
    try
    {
        myparser.parse();
    }
    catch (seqan3::argument_parser_error const & ext) // the user did something wrong
    {
        std::cerr << "[PARSER ERROR] " << ext.what() << "\n"; // customize your error message
        return -1;
    }
 
    seqan3::debug_stream << "filename given by user passed validation: " << myfile << "\n";
    return 0;
}

#include <seqan3/argument_parser/validators.hpp>
#include <seqan3/core/debug_stream.hpp>
#include <seqan3/io/sequence_file/output.hpp>
 
int main()
{
    // Default constructed validator has an empty extension list.
    seqan3::output_file_validator validator1{seqan3::output_file_open_options::create_new};
    seqan3::debug_stream << validator1.get_help_page_message() << '\n';
 
    // Specify your own extensions for the output file.
    seqan3::output_file_validator validator2{seqan3::output_file_open_options::create_new,
                                             std::vector{std::string{"exe"}, std::string{"fasta"}}};
    seqan3::debug_stream << validator2.get_help_page_message() << '\n';
 
    // Give the seqan3 file type as a template argument to get all valid extensions for this file.
    seqan3::output_file_validator<seqan3::sequence_file_output<>> validator3{
        seqan3::output_file_open_options::create_new};
    seqan3::debug_stream << validator3.get_help_page_message() << '\n';
 
    return 0;
}

#include <iostream>
 
#include <seqan3/core/add_enum_bitwise_operators.hpp>
 
enum class my_enum
{
    VAL1 = 1,
    VAL2 = 2,
    COMB = 3
};
 
template <>
constexpr bool seqan3::add_enum_bitwise_operators<my_enum> = true;
 
int main()
{
    using seqan3::operator|;
 
    my_enum e = my_enum::VAL1;
    my_enum e2 = e | my_enum::VAL2;
 
    std::cout << std::boolalpha << (e2 == my_enum::COMB) << '\n'; // true
}

#if SEQAN3_WITH_CEREAL
#    include <fstream>
#    include <vector>
 
#    include <seqan3/core/debug_stream.hpp>
#    include <seqan3/test/tmp_directory.hpp>
 
#    include <cereal/archives/binary.hpp> // includes the cereal::BinaryInputArchive and cereal::BinaryOutputArchive
#    include <cereal/types/vector.hpp>    // includes cerealisation support for std::vector
 
// Written for std::vector, other types also work.
void load(std::vector<int16_t> & data, std::filesystem::path const & tmp_file)
{
    std::ifstream is(tmp_file, std::ios::binary); // Where input can be found.
    cereal::BinaryInputArchive archive(is);       // Create an input archive from the input stream.
    archive(data);                                // Load data.
}
 
// Written for std::vector, other types also work.
void store(std::vector<int16_t> const & data, std::filesystem::path const & tmp_file)
{
    std::ofstream os(tmp_file, std::ios::binary); // Where output should be stored.
    cereal::BinaryOutputArchive archive(os);      // Create an output archive from the output stream.
    archive(data);                                // Store data.
}
 
int main()
{
    // The following example is for a std::vector but any seqan3 data structure that is documented as serialisable
    // could be used, e.g. fm_index.
    seqan3::test::tmp_directory tmp{};
    auto tmp_file = tmp.path() / "data.out"; // this is a temporary file path, use any other filename.
 
    std::vector<int16_t> vec{1, 2, 3, 4};
    store(vec, tmp_file); // Calls store on a std::vector.
    // This vector is needed to load the information into it.
    std::vector<int16_t> vec2;
    load(vec2, tmp_file); // Calls load on a std::vector.
 
    seqan3::debug_stream << vec << '\n'; // Prints [1,2,3,4].
 
    return 0;
}
#endif

#include <seqan3/alignment/configuration/align_config_band.hpp>
#include <seqan3/alignment/configuration/align_config_method.hpp>
#include <seqan3/core/configuration/configuration.hpp>
#include <seqan3/core/configuration/pipeable_config_element.hpp>
 
int main()
{
    // Here we use the global and banded alignment configurations to show how they can be combined.
    seqan3::configuration my_cfg = seqan3::align_cfg::method_global{}
                                 | seqan3::align_cfg::band_fixed_size{seqan3::align_cfg::lower_diagonal{-4},
                                                                      seqan3::align_cfg::upper_diagonal{4}};
}

#include <seqan3/core/configuration/configuration.hpp>
 
enum struct my_id : int
{
    bar_id,
    foo_id
};
 
namespace seqan3::detail
{
template <>
inline constexpr std::array<std::array<int, 2>, 2> compatibility_table<my_id>{{{0, 1}, {1, 0}}};
} // namespace seqan3::detail

#include <seqan3/alignment/configuration/align_config_band.hpp>
#include <seqan3/alignment/configuration/align_config_gap_cost_affine.hpp>
#include <seqan3/core/configuration/configuration.hpp>
#include <seqan3/core/configuration/pipeable_config_element.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    using seqan3::get;
 
    seqan3::configuration my_cfg =
        seqan3::align_cfg::gap_cost_affine{seqan3::align_cfg::open_score{-10}, seqan3::align_cfg::extension_score{-1}}
        | seqan3::align_cfg::band_fixed_size{seqan3::align_cfg::lower_diagonal{-4},
                                             seqan3::align_cfg::upper_diagonal{4}};
    // my_cfg is now of type configuration<gap_cost_affine, band_fixed_size>
 
    seqan3::debug_stream << get<1>(my_cfg).lower_diagonal << '\n';                                   // prints -4
    seqan3::debug_stream << get<seqan3::align_cfg::band_fixed_size>(my_cfg).upper_diagonal << '\n';  // prints 4
    seqan3::debug_stream << get<seqan3::align_cfg::gap_cost_affine>(my_cfg).extension_score << '\n'; // prints -1
}

#include <seqan3/core/configuration/configuration.hpp>
#include <seqan3/core/configuration/pipeable_config_element.hpp>
#include <seqan3/core/debug_stream.hpp>
 
// Initial setup used in the actual example:
enum struct my_id : int
{
    bar_id,
    foo_id
};
 
struct bar : private seqan3::pipeable_config_element
{
public:
    float value{};
 
    bar() = default;
    bar(bar const &) = default;
    bar(bar &&) = default;
    bar & operator=(bar const &) = default;
    bar & operator=(bar &&) = default;
    ~bar() = default;
 
    bar(float v) : value{v}
    {}
 
    static constexpr my_id id{my_id::bar_id};
};
 
template <typename t>
class foo : private seqan3::pipeable_config_element
{
public:
    t value{};
 
    foo() = default;
    foo(foo const &) = default;
    foo(foo &&) = default;
    foo & operator=(foo const &) = default;
    foo & operator=(foo &&) = default;
    ~foo() = default;
 
    foo(t v) : value{std::move(v)}
    {}
 
    static constexpr my_id id{my_id::foo_id};
};
 
template <typename t>
foo(t) -> foo<t>;
 
int main()
{
    seqan3::configuration my_cfg{foo{1}};                                           // Only foo<int> is present.
    seqan3::debug_stream << my_cfg.get_or(foo{std::string{"hello"}}).value << '\n'; // finds foo<int> -> prints: 1
    seqan3::debug_stream << my_cfg.get_or(bar{2.4}).value << '\n';                  // bar not present -> prints: 2.4
}

#include <seqan3/core/configuration/configuration.hpp>
#include <seqan3/core/configuration/pipeable_config_element.hpp>
 
enum struct my_id : int
{
    bar_id,
    foo_id
};
 
class bar : private seqan3::pipeable_config_element
{
public:
    bar() = default;
    bar(bar const &) = default;
    bar(bar &&) = default;
    bar & operator=(bar const &) = default;
    bar & operator=(bar &&) = default;
    ~bar() = default;
 
    static constexpr my_id id{my_id::bar_id};
};
 
template <typename t>
struct foo : private seqan3::pipeable_config_element
{
public:
    foo() = default;
    foo(foo const &) = default;
    foo(foo &&) = default;
    foo & operator=(foo const &) = default;
    foo & operator=(foo &&) = default;
    ~foo() = default;
 
    static constexpr my_id id{my_id::foo_id};
};
 
template <typename t>
foo(t) -> foo<t>;

#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    uint8_t i = 71;
    seqan3::debug_stream << '\'' << i << "'\n";                          // prints '71' (because flag is set by default)
    seqan3::debug_stream.unsetf(seqan3::fmtflags2::small_int_as_number); // unsets the flag
    seqan3::debug_stream << '\'' << i << "'\n";                          // prints 'G'
    seqan3::debug_stream << seqan3::fmtflags2::small_int_as_number << '\'' << i << "'\n"; // prints '71' again
    // instead of formatting the stream "inline", one can also call .setf()
}

#include <sstream>
 
#include <seqan3/alphabet/nucleotide/dna5.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    std::ostringstream o;
    seqan3::debug_stream.set_underlying_stream(o);
 
    seqan3::debug_stream << "ACGT"_dna5;
 
    o.flush();
    seqan3::debug_stream << o.str(); // prints the string stream's buffer: "ACGT"
}

#include <sstream>
 
#include <seqan3/alphabet/nucleotide/dna5.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    std::ostringstream o;
    seqan3::debug_stream_type my_stream{o};
 
    my_stream << "ACGT"_dna5;
 
    o.flush();
    seqan3::debug_stream << o.str() << '\n'; // prints the string stream's buffer: "ACGT"
}

#include <iostream>
 
#include <seqan3/alphabet/nucleotide/dna5.hpp>
#include <seqan3/alphabet/views/to_rank.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    // The alphabet normally needs to be converted to char explicitly:
    std::cout << seqan3::to_char('C'_dna5) << '\n'; // prints 'C'
 
    // The debug_stream, on the other hand, does this automatically:
    seqan3::debug_stream << 'C'_dna5 << '\n'; // prints 'C'
 
    // The debug_stream can also print all types that model std::ranges::input_range:
    std::vector<seqan3::dna5> vec{"ACGT"_dna5};
    seqan3::debug_stream << vec << '\n'; // prints "ACGT"
 
    // ranges of non-alphabets are printed comma-separated:
    seqan3::debug_stream << (vec | seqan3::views::to_rank) << '\n'; // prints "[0,1,2,3]"
}

#include <seqan3/core/debug_stream.hpp>
#include <seqan3/core/detail/copyable_wrapper.hpp>
 
int main()
{
    int outer{};
    // Might be used for non-copyable lambdas. In this example, the lambda would be copyable even without the wrapper.
    seqan3::detail::copyable_wrapper wrapper{[&outer](int const x)
                                             {
                                                 outer += x;
                                                 return outer;
                                             }};
    auto wrapper_2 = wrapper;                     // Would not work with non-copyable lambda.
    seqan3::debug_stream << wrapper(2) << '\n';   // 2
    seqan3::debug_stream << wrapper_2(4) << '\n'; // 6
}

#include <concepts>
#include <vector>
 
#include <seqan3/core/detail/customisation_point.hpp>
 
namespace seqan3::detail::adl_only
{
// Poison-pill overload to prevent non-ADL forms of unqualified lookup.
template <typename... args_t>
void begin(args_t...) = delete;
 
struct begin_cpo : public detail::customisation_point_object<begin_cpo, 1>
{
    using base_t = detail::customisation_point_object<begin_cpo, 1>;
    // Only this class is allowed to import the constructors from base_t. (CRTP safety idiom)
    using base_t::base_t;
 
    // range.begin(), member access
    template <typename range_t>
        requires true // further constraints
    static constexpr auto SEQAN3_CPO_OVERLOAD(seqan3::detail::priority_tag<1>, range_t && range)(
        /*return*/ std::forward<range_t>(range).begin() /*;*/
    );
 
    // begin(range), ADL access
    template <typename range_t>
    static constexpr auto SEQAN3_CPO_OVERLOAD(seqan3::detail::priority_tag<0>, range_t && range)(
        /*return*/ begin(std::forward<range_t>(range)) /*;*/
    );
};
 
} // namespace seqan3::detail::adl_only
 
namespace seqan3
{
// CPO is a normal function object that can be called via seqan3::begin(...)
inline constexpr auto begin = detail::adl_only::begin_cpo{};
} // namespace seqan3
 
namespace other_library
{
struct foo
{
    friend int begin(foo const &) // ADL begin, as friend
    {
        return 0;
    }
};
} // namespace other_library
 
// seqan3::begin CPO that will call the "begin" member function
std::vector<int> vec{};
 
static_assert(std::same_as<decltype(seqan3::begin(vec)), decltype(vec.begin())>); // same iterator type
 
static_assert(noexcept(vec.begin()));                                 // is noexcept
static_assert(noexcept(seqan3::begin(vec)) == noexcept(vec.begin())); // perfect noexcept-forwarding
 
// seqan3::begin CPO that will call the "begin" function per ADL
other_library::foo foo{};
 
static_assert(std::same_as<decltype(seqan3::begin(foo)), decltype(begin(foo))>); // same value type
 
static_assert(!noexcept(begin(foo)));                                // isn't noexcept
static_assert(noexcept(seqan3::begin(foo)) == noexcept(begin(foo))); // perfect noexcept-forwarding
 
auto cpo_is_sfinae_friendly(...) -> void;
 
template <typename range_t>
auto cpo_is_sfinae_friendly(range_t && range) -> decltype(seqan3::begin(range));
 
// seqan3::begin itself is SFINAE friendly, i.e. no-hard compiler errors, if no cpo overload matches
static_assert(std::same_as<decltype(cpo_is_sfinae_friendly(0)), void>);
 
static_assert(std::same_as<decltype(cpo_is_sfinae_friendly(vec)), decltype(vec.begin())>);

#include <string>
#include <type_traits>
 
#include <seqan3/core/detail/deferred_crtp_base.hpp>
 
// Defines a crtp_base class with an additional value type.
template <typename derived_t, int value>
class base1
{
public:
    int func1() const
    {
        return value;
    }
};
 
// Defines a crtp_base class with an additional value type and a parameter type.
template <typename derived_t, typename value_t, typename parameter_t>
class base2
{
public:
    value_t func2(parameter_t const p) const
    {
        return static_cast<value_t>(p);
    }
};
 
// The derived class that inherits from a variadic crtp pattern, which are augmented with additional trait types.
// These types must be wrapped in a deferred layer, otherwise the compilation fails as incomplete types are not allowed.
// But during the definition of the base classes, the derived class cannot be known.
// In addition the deferred type must be invoked with the derived class using the `invoke_deferred_crtp_base` helper
// template to instantiate the correct crtp base type.
// Note that it is possible to define base classes with type template parameters (see base2) or
// non-type template parameters (see base1), but non-type and type template parameters cannot be mixed in one
// base class definition.
template <typename... deferred_bases_t>
class derived : public seqan3::detail::invoke_deferred_crtp_base<deferred_bases_t, derived<deferred_bases_t...>>...
{};
 
int main()
{
    // Define deferred base with non-type template parameter
    using deferred_base1 = seqan3::detail::deferred_crtp_base_vargs<base1, 10>;
    // Define deferred base with type template parameter.
    using deferred_base2 = seqan3::detail::deferred_crtp_base<base2, uint8_t, uint32_t>;
 
    // Instantiate the derived class with the deferred crtp base classes.
    derived<deferred_base1, deferred_base2> d{};
    // Check the inherited interfaces.
    static_assert(std::is_same_v<decltype(d.func1()), int>, "Return type must be int");
    static_assert(std::is_same_v<decltype(d.func2(10u)), uint8_t>, "Return type must be uint8_t");
}

#include <type_traits>
 
#include <seqan3/alignment/aligned_sequence/aligned_sequence_concept.hpp>
#include <seqan3/core/debug_stream.hpp>
#include <seqan3/core/detail/is_class_template_declarable.hpp>
 
template <typename t>
    requires std::is_integral_v<t>
struct foo
{
    t value;
};
 
// foo is declarable with int, i.e. foo<int> is a valid expression
static_assert(seqan3::detail::is_class_template_declarable_with_v<foo, int>);
// foo is not declarable with double, because it does not fulfil the requires clause of foo.
static_assert(!seqan3::detail::is_class_template_declarable_with_v<foo, double>);
 
// This also works with std::enable_if and producing a substitution failure.
template <typename t, typename = std::enable_if_t<std::is_same_v<t, int>>>
struct bar
{
    t value;
};
 
// bar is declarable with int, i.e. bar<int> is a valid expression
static_assert(seqan3::detail::is_class_template_declarable_with_v<bar, int>);
// bar is not declarable with double, because it produces an substitution failure (SFINAE).
static_assert(!seqan3::detail::is_class_template_declarable_with_v<bar, double>);
 
// is_class_template_declarable_with_v works well with lazy_conditional_t
template <typename t>
using maybe_foo_t = seqan3::detail::
    lazy_conditional_t<seqan3::detail::is_class_template_declarable_with_v<foo, t>, seqan3::detail::lazy<foo, t>, t>;
 
int main()
{
    foo<int> a = maybe_foo_t<int>{10};                // foo is instantiable with int, thus use foo<int>
    seqan3::debug_stream << "a: " << a.value << '\n'; // prints 10
    float b = maybe_foo_t<float>{0.4f};               // foo is not instantiable with float, thus use float directly
    seqan3::debug_stream << "b: " << b << '\n';       // prints 0.4
    return 0;
}

#include <seqan3/core/detail/strong_type.hpp>
 
using seqan3::operator|;
 
struct error :
    seqan3::detail::strong_type<uint8_t,
                                error,
                                seqan3::detail::strong_type_skill::decrement
                                    | seqan3::detail::strong_type_skill::increment>
{
    using seqan3::detail::strong_type<uint8_t,
                                      error,
                                      seqan3::detail::strong_type_skill::decrement
                                          | seqan3::detail::strong_type_skill::increment>::strong_type;
};
 
int main()
{
    error e{4u};
    --e;
    ++e;
}

#include <seqan3/core/detail/strong_type.hpp>
 
struct error : seqan3::detail::strong_type<uint8_t, error>
{
    using seqan3::detail::strong_type<uint8_t, error>::strong_type;
};
 
struct window_size : seqan3::detail::strong_type<uint8_t, window_size>
{
    using seqan3::detail::strong_type<uint8_t, window_size>::strong_type;
};

#include <ranges>
#include <vector>
 
#include <seqan3/alphabet/nucleotide/dna4.hpp>
#include <seqan3/core/detail/strong_type.hpp>
 
struct error : seqan3::detail::strong_type<unsigned, error>
{
    using seqan3::detail::strong_type<unsigned, error>::strong_type;
};
 
struct window_size : seqan3::detail::strong_type<unsigned, window_size>
{
    using seqan3::detail::strong_type<unsigned, window_size>::strong_type;
};
 
namespace detail
{
 
template <std::ranges::forward_range fwd_rng_type>
bool do_find(fwd_rng_type const &, uint8_t const, uint8_t const)
{
    return true;
}
 
} // namespace detail
 
template <std::ranges::forward_range fwd_rng_type>
bool search(fwd_rng_type const & rng, window_size const window_size, error const error)
{
    return detail::do_find(rng, window_size.get(), error.get());
}
 
int main()
{
    using namespace seqan3::literals;
 
    std::vector<seqan3::dna4> range = "ACGTT"_dna4;
    search(range, window_size{4u}, error{2u});
 
    return 0;
}

#include <ranges>
#include <vector>
 
#include <seqan3/alphabet/nucleotide/dna4.hpp>
 
namespace detail
{
 
template <std::ranges::forward_range fwd_rng_type>
bool do_find(fwd_rng_type const &, uint8_t const, uint8_t const)
{
    return true;
}
 
} // namespace detail
 
template <std::ranges::forward_range fwd_rng_type>
bool search(fwd_rng_type const & rng, uint8_t const window_size, uint8_t const error)
{
    return detail::do_find(rng, window_size, error);
}
 
int main()
{
    using namespace seqan3::literals;
 
    std::vector<seqan3::dna4> range = "ACGTT"_dna4;
    search(range, 4u, 2u);
 
    return 0;
}

#include <seqan3/core/detail/template_inspection.hpp>
#include <seqan3/utility/type_list/type_list.hpp>
 
int main()
{
    using list_to_transfer = seqan3::type_list<int, char, double>;
    using resulting_t = seqan3::detail::transfer_template_args_onto_t<list_to_transfer, std::tuple>;
 
    static_assert(std::same_as<resulting_t, std::tuple<int, char, double>>);
}

#include <vector>
 
#include <seqan3/core/detail/template_inspection.hpp>
 
int main()
{
    using my_type = std::vector<int>;
 
    if constexpr (seqan3::detail::is_type_specialisation_of_v<my_type, std::vector>) // Note: std::vector has no <> !
    {
        // ...
    }
}

#include <vector>
 
#include <seqan3/core/detail/template_inspection.hpp>
 
int main()
{
    using my_type = std::vector<int>;
 
    if constexpr (seqan3::detail::template_specialisation_of<my_type, std::vector>) // Note: std::vector has no <> !
    {
        // ...
    }
}

#include <string>
#include <vector>
 
#include <seqan3/alphabet/nucleotide/dna4.hpp>
#include <seqan3/alphabet/quality/phred42.hpp>
#include <seqan3/io/detail/record.hpp>
#include <seqan3/utility/type_list/type_list.hpp>
 
int main()
{
    using types = seqan3::type_list<std::string, seqan3::dna4_vector, std::vector<seqan3::phred42>>;
    using types_as_ids = seqan3::fields<seqan3::field::id, seqan3::field::seq, seqan3::field::qual>;
    using selected_ids = seqan3::fields<seqan3::field::qual, seqan3::field::id>;
 
    using selected_types = seqan3::detail::select_types_with_ids_t<types, types_as_ids, selected_ids>;
    // resolves to type_list<std::vector<phred42>, std::string>
    static_assert(std::same_as<selected_types, seqan3::type_list<std::vector<seqan3::phred42>, std::string>>);
}

#include <sstream>
 
#include <seqan3/io/stream/detail/fast_ostreambuf_iterator.hpp>
 
int main()
{
    std::string id{"seq1"};
    std::string sequence{"ACTGACTGACTGACTAGCATGACTAGCATGC"};
 
    // construct iterator from stream buffer
    std::ostringstream ostr{};
    auto stream_it = seqan3::detail::fast_ostreambuf_iterator{*ostr.rdbuf()};
 
    // You can do anything you could do with a regular std::ostreambuf_iterator
    stream_it = '>';  // writes '>' to stream
    *stream_it = ' '; // writes ' ' to stream
 
    // Additionally, there is an efficient write_range member function
 
    // Example 1: Write a range completely
    stream_it.write_range(id); // return value can be ignored
 
    // Example 2: Write a range in chunks of 10
    auto it = std::ranges::begin(sequence);
    while (it != std::ranges::end(sequence))
    {
        /* Note that you need cannot use stream_it.write_range(rng | std::views::take(10)) here
         * because the returned iterator is not of the correct type.
         */
        auto current_end = it;
        size_t steps = std::ranges::advance(current_end, 10u, std::ranges::end(sequence));
        using subrange_t =
            std::ranges::subrange<decltype(it), decltype(current_end), std::ranges::subrange_kind::sized>;
        // Be aware that your range_type must model std::ranges::borrowed_range in order to use the return value!
        it = stream_it.write_range(subrange_t{it, current_end, 10u - steps});
        stream_it = ' ';
    }
}

#include <filesystem>
#include <fstream>
 
#include <seqan3/io/detail/safe_filesystem_entry.hpp>
 
int main()
{
    std::filesystem::path my_file = std::filesystem::temp_directory_path() / "dummy.txt";
 
    std::ifstream file{my_file};                               // Create the file.
    seqan3::detail::safe_filesystem_entry file_guard{my_file}; // Safe cleanup in case of errors.
 
    // Do something on the file, that can possibly throw.
    // If an unhandled exception is thrown, the file guard destructor safely removes the file from the filesystem.
 
    file_guard.remove(); // Explicitly remove the file.
}

#include <sstream>
 
#include <seqan3/core/debug_stream.hpp>
#include <seqan3/io/record.hpp>
#include <seqan3/io/sequence_file/input.hpp>
#include <seqan3/io/sequence_file/output.hpp>
 
auto input = R"(> TEST1
ACGT
> Test2
AGGCTGA
> Test3
GGAGTATAATATATATATATATAT)";
 
int main()
{
    // specify custom field combination/order to file:
    seqan3::sequence_file_input fin{std::istringstream{input},
                                    seqan3::format_fasta{},
                                    seqan3::fields<seqan3::field::id, seqan3::field::seq>{}};
 
    auto record = fin.front(); // get current record, in this case the first
 
    auto & id = record.id();
    seqan3::debug_stream << id << '\n'; // TEST1
    auto & seq = record.sequence();
    seqan3::debug_stream << seq << '\n'; // ACGT
}

#include <string>
#include <vector>
 
#include <seqan3/alphabet/nucleotide/dna4.hpp>
#include <seqan3/alphabet/quality/phred42.hpp>
#include <seqan3/io/record.hpp>
#include <seqan3/utility/type_list/type_list.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    // The order of the types below represent a mapping between the type and the key.
    using types = seqan3::type_list<seqan3::dna4_vector, std::string, std::vector<seqan3::phred42>>;
    using types_as_ids = seqan3::fields<seqan3::field::seq, seqan3::field::id, seqan3::field::qual>;
    using record_type = seqan3::record<types, types_as_ids>;
    // record_type now mimics std::tuple<std::string, dna4_vector, std::vector<phred42>>,
    // the order also depends on selected_ids
 
    record_type my_record{};
    std::get<1>(my_record) = "the most important sequence in the database";            // access via index
    std::get<std::string>(my_record) = "the least important sequence in the database"; // access via type
}

#include <sstream>
#include <string>
#include <tuple>
 
#include <seqan3/alphabet/nucleotide/dna5.hpp>
#include <seqan3/io/sam_file/output.hpp>
 
int main()
{
    seqan3::sam_file_output fout{std::ostringstream{}, seqan3::format_sam{}};
 
    auto stream_it = fout.begin();
 
    std::string id;
    seqan3::dna5_vector seq;
 
    // ...
 
    // assign to file iterator
    *stream_it = std::tie(seq, id);
    // is the same as:
    fout.push_back(std::tie(seq, id));
}

#include <sstream>
 
#include <seqan3/io/sam_file/output.hpp>
 
int main()
{
    // I only want to print the mapping position (field::ref_offset) and flag:
    seqan3::sam_file_output fout{std::ostringstream{},
                                 seqan3::format_sam{},
                                 seqan3::fields<seqan3::field::ref_offset, seqan3::field::flag>{}};
 
    unsigned mapping_pos{1300};
    seqan3::sam_flag flag{seqan3::sam_flag::none};
 
    // ...
 
    fout.emplace_back(mapping_pos, flag); // note that the order the arguments is now different, because
    // or:                                    you specified that REF_OFFSET should be first
    fout.push_back(std::tie(mapping_pos, flag));
}

#include <sstream>
#include <string>
 
#include <seqan3/io/sam_file/output.hpp>
#include <seqan3/utility/type_list/type_list.hpp>
 
int main()
{
    seqan3::sam_file_output fout{std::ostringstream{}, seqan3::format_sam{}};
 
    seqan3::record<seqan3::type_list<uint32_t, std::string>, seqan3::fields<seqan3::field::mapq, seqan3::field::id>> r;
 
    // ...
 
    fout.push_back(r);
}

#include <sstream>
#include <string>
#include <tuple>
 
#include <seqan3/alphabet/nucleotide/dna5.hpp>
#include <seqan3/io/sam_file/output.hpp>
 
int main()
{
    seqan3::sam_file_output fout{std::ostringstream{}, seqan3::format_sam{}};
 
    std::string id;
    seqan3::dna5_vector seq;
 
    // ...
 
    fout.push_back(std::tie(seq, id));
}

#include <sstream>
#include <string>
#include <vector>
 
#include <seqan3/alphabet/nucleotide/dna5.hpp>
#include <seqan3/io/sam_file/output.hpp>
#include <seqan3/utility/type_list/type_list.hpp>
 
int main()
{
    seqan3::sam_file_output fout{std::ostringstream{}, seqan3::format_sam{}};
 
    std::string ref_id;
    std::string read_id;
 
    std::vector<seqan3::dna5> read;
 
    // ... e.g. compute and alignment
 
    using alignment_type =
        std::pair<std::vector<seqan3::gapped<seqan3::dna5>>, std::vector<seqan3::gapped<seqan3::dna5>>>;
 
    alignment_type dummy_alignment{}; // an empty dummy alignment
 
    using types = seqan3::type_list<std::vector<seqan3::dna5>, std::string, alignment_type>;
    using types_as_ids = seqan3::fields<seqan3::field::seq, seqan3::field::id, seqan3::field::alignment>;
    // the record type specifies the fields we want to write
    using record_type = seqan3::record<types, types_as_ids>;
 
    // initialize record
    record_type rec{read, ref_id, dummy_alignment};
 
    // Write the record
    fout.push_back(rec);
 
    // same as
    fout.push_back(record_type{read, ref_id, dummy_alignment});
 
    // as all our fields are empty so this would print an
}

#include <filesystem>
#include <sstream>
#include <tuple>
 
#include <seqan3/io/sam_file/output.hpp>
 
int main()
{
    // I only want to print the mapping position (field::ref_offset) and flag:
    seqan3::sam_file_output fout{std::ostringstream{},
                                 seqan3::format_sam{},
                                 seqan3::fields<seqan3::field::ref_offset, seqan3::field::flag>{}};
 
    unsigned mapping_pos{1300};
    seqan3::sam_flag flag{seqan3::sam_flag::none};
 
    // ...
 
    fout.emplace_back(mapping_pos, flag); // note that the order the arguments is now different, because
    // or:                                    you specified that REF_OFFSET should be first
    fout.push_back(std::tie(mapping_pos, flag));
}

#include <sstream>
 
#include <seqan3/io/sam_file/input.hpp>
 
auto sam_file_raw = R"(@HD  VN:1.6  SO:coordinate   GO:none
@SQ SN:ref  LN:45
r001    99  ref 7   30  8M2I4M1D3M  =   37  39  TTAGATAAAGGATACTG   *
r003    0   ref 29  30  5S6M    *   0   0   GCCTAAGCTAA *   SA:Z:ref,29,-,6H5M,17,0;
r003    2064    ref 29  17  6H5M    *   0   0   TAGGC   *   SA:Z:ref,9,+,5S6M,30,1;
r001    147 ref 237 30  9M  =   7   -39 CAGCGGCAT   *   NM:i:1
)";
 
int main()
{
    seqan3::sam_file_input fin{std::istringstream{sam_file_raw}, seqan3::format_sam{}};
 
    auto it = fin.begin();
 
    // the following are equivalent:
    auto & rec0 = *it;
    auto & rec1 = fin.front();
    std::cout << std::boolalpha << (rec0.id() == rec1.id()) << '\n'; // true
    // Note: both become invalid after incrementing "it"!
}

#include <filesystem>
#include <sstream>
 
#include <seqan3/io/sam_file/input.hpp>
 
auto sam_file_raw = R"(@HD  VN:1.6  SO:coordinate   GO:none
@SQ SN:ref  LN:45
r001    99  ref 7   30  8M2I4M1D3M  =   37  39  TTAGATAAAGGATACTG   *
r003    0   ref 29  30  5S6M    *   0   0   GCCTAAGCTAA *   SA:Z:ref,29,-,6H5M,17,0;
r003    2064    ref 29  17  6H5M    *   0   0   TAGGC   *   SA:Z:ref,9,+,5S6M,30,1;
r001    147 ref 237 30  9M  =   7   -39 CAGCGGCAT   *   NM:i:1
)";
 
int main()
{
    // Create the temporary file.
    auto tmp_file = std::filesystem::temp_directory_path() / "my.sam";
    std::ofstream tmp_stream{tmp_file};
    tmp_stream << sam_file_raw;
    tmp_stream.close();
 
    seqan3::sam_file_input fin{tmp_file}; // SAM format assumed, regular std::ifstream taken as stream
    std::filesystem::remove(tmp_file);
}

#include <sstream>
 
#include <seqan3/io/sam_file/input.hpp>
 
auto input = R"(@HD VN:1.6  SO:coordinate
r001    99  ref 7   30  8M2I4M1D3M  =   37  39  TTAGATAAAGGATACTG   *)";
 
int main()
{
    seqan3::sam_file_input fin{std::istringstream{input}, seqan3::format_sam{}};
    //                          ^ no need to specify the template arguments
}

#include <sstream>
 
#include <seqan3/io/sam_file/input.hpp>
#include <seqan3/utility/type_list/type_list.hpp>
 
auto input = R"(@HD VN:1.6  SO:coordinate
r001    99  ref 7   30  8M2I4M1D3M  =   37  39  TTAGATAAAGGATACTG   *)";
 
int main()
{
    // The default types; you can adjust this list if you don't want to read all this data.
    using default_fields = seqan3::fields<seqan3::field::seq,
                                          seqan3::field::id,
                                          seqan3::field::ref_id,
                                          seqan3::field::ref_offset,
                                          seqan3::field::cigar,
                                          seqan3::field::mapq,
                                          seqan3::field::qual,
                                          seqan3::field::flag,
                                          seqan3::field::mate,
                                          seqan3::field::tags,
                                          seqan3::field::header_ptr>;
 
    // The expected format:
    using sam_file_input_t = seqan3::sam_file_input<seqan3::sam_file_input_default_traits<>,
                                                    default_fields,
                                                    // Which formats are allowed:
                                                    seqan3::type_list<seqan3::format_sam>>;
 
    sam_file_input_t fin{std::istringstream{input}, seqan3::format_sam{}};
}

#include <sstream>
 
#include <seqan3/io/sam_file/input.hpp>
 
auto sam_file_raw = R"(@HD  VN:1.6  SO:coordinate   GO:none
@SQ SN:ref  LN:45
r001    99  ref 7   30  8M2I4M1D3M  =   37  39  TTAGATAAAGGATACTG   *
r003    0   ref 29  30  5S6M    *   0   0   GCCTAAGCTAA *   SA:Z:ref,29,-,6H5M,17,0;
r003    2064    ref 29  17  6H5M    *   0   0   TAGGC   *   SA:Z:ref,9,+,5S6M,30,1;
r001    147 ref 237 30  9M  =   7   -39 CAGCGGCAT   *   NM:i:1
)";
 
int main()
{
    seqan3::sam_file_input fin{std::istringstream{sam_file_raw}, seqan3::format_sam{}};
 
    auto rec = std::move(fin.front()); // rec now stores the data permanently
}

#include <sstream>
 
#include <seqan3/core/debug_stream.hpp>
#include <seqan3/io/sam_file/input.hpp>
#include <seqan3/utility/type_list/type_list.hpp>
 
auto sam_file_raw = R"(@HD  VN:1.6  SO:coordinate   GO:none
@SQ SN:ref  LN:45
r001    99  ref 7   30  8M2I4M1D3M  =   37  39  TTAGATAAAGGATACTG   *
r003    0   ref 29  30  5S6M    *   0   0   GCCTAAGCTAA *   SA:Z:ref,29,-,6H5M,17,0;
r003    2064    ref 29  17  6H5M    *   0   0   TAGGC   *   SA:Z:ref,9,+,5S6M,30,1;
r001    147 ref 237 30  9M  =   7   -39 CAGCGGCAT   *   NM:i:1
)";
 
int main()
{
    seqan3::sam_file_input fin{std::istringstream{sam_file_raw}, seqan3::format_sam{}};
 
    // access the header information
    seqan3::debug_stream << fin.header().format_version << '\n'; // 1.6
    seqan3::debug_stream << fin.header().ref_dict << '\n'; // [(ref,(45,))] (this only works with seqan3::debug_stream!)
}

#include <sstream>
 
#include <seqan3/alphabet/container/bitpacked_sequence.hpp>
#include <seqan3/alphabet/nucleotide/dna4.hpp>
#include <seqan3/io/sam_file/input.hpp>
#include <seqan3/utility/type_list/type_list.hpp>
 
struct my_traits : seqan3::sam_file_input_default_traits<>
{
    using sequence_alphabet = seqan3::dna4; // instead of dna5
 
    template <typename alph>
    using sequence_container = seqan3::bitpacked_sequence<alph>; // must be defined as a template!
};
 
auto sam_file_raw = R"(@HD  VN:1.6  SO:coordinate   GO:none
@SQ SN:ref  LN:45
r001    99  ref 7   30  8M2I4M1D3M  =   37  39  TTAGATAAAGGATACTG   *
r003    0   ref 29  30  5S6M    *   0   0   GCCTAAGCTAA *   SA:Z:ref,29,-,6H5M,17,0;
r003    2064    ref 29  17  6H5M    *   0   0   TAGGC   *   SA:Z:ref,9,+,5S6M,30,1;
r001    147 ref 237 30  9M  =   7   -39 CAGCGGCAT   *   NM:i:1
)";
 
// ... within main you can then use:
int main()
{
    seqan3::sam_file_input<my_traits> fin{std::istringstream{sam_file_raw}, seqan3::format_sam{}};
}

#include <sstream>
 
#include <seqan3/core/debug_stream.hpp>
#include <seqan3/io/sam_file/input.hpp>
#include <seqan3/utility/type_list/type_list.hpp>
 
auto sam_file_raw = R"(@HD  VN:1.6  SO:coordinate   GO:none
@SQ SN:ref  LN:45
r001    99  ref 7   30  8M2I4M1D3M  =   37  39  TTAGATAAAGGATACTG   *
r003    0   ref 29  30  5S6M    *   0   0   GCCTAAGCTAA *   SA:Z:ref,29,-,6H5M,17,0;
r003    2064    ref 29  17  6H5M    *   0   0   TAGGC   *   SA:Z:ref,9,+,5S6M,30,1;
r001    147 ref 237 30  9M  =   7   -39 CAGCGGCAT   *   NM:i:1
)";
 
int main()
{
    seqan3::sam_file_input fin{std::istringstream{sam_file_raw},
                               seqan3::format_sam{},
                               seqan3::fields<seqan3::field::flag, seqan3::field::mapq>{}};
 
    for (auto & rec : fin)
    {
        seqan3::debug_stream << "flag:  " << rec.flag() << '\n';
        seqan3::debug_stream << "mapping quality:  " << rec.mapping_quality() << '\n';
    }
}

#include <ranges>
#include <sstream>
 
#include <seqan3/core/debug_stream.hpp>
#include <seqan3/io/sam_file/input.hpp>
#include <seqan3/utility/type_list/type_list.hpp>
 
auto sam_file_raw = R"(@HD  VN:1.6  SO:coordinate   GO:none
@SQ SN:ref  LN:45
r001    99  ref 7   30  8M2I4M1D3M  =   37  39  TTAGATAAAGGATACTG   *
r003    0   ref 29  30  5S6M    *   0   0   GCCTAAGCTAA *   SA:Z:ref,29,-,6H5M,17,0;
r003    2064    ref 29  17  6H5M    *   0   0   TAGGC   *   SA:Z:ref,9,+,5S6M,30,1;
r001    147 ref 237 30  9M  =   7   -39 CAGCGGCAT   *   NM:i:1
)";
 
int main()
{
    seqan3::sam_file_input fin{std::istringstream{sam_file_raw}, seqan3::format_sam{}};
 
    auto minimum_length10_filter = std::views::filter(
        [](auto const & rec)
        {
            return std::ranges::size(rec.sequence()) >= 10;
        });
 
    for (auto & rec : fin | minimum_length10_filter) // only records with sequence length >= 10 will "appear"
        seqan3::debug_stream << rec.id() << '\n';
}

#include <sstream>
#include <utility>
#include <vector>
 
#include <seqan3/io/sam_file/input.hpp>
#include <seqan3/utility/type_list/type_list.hpp>
 
auto sam_file_raw = R"(@HD  VN:1.6  SO:coordinate   GO:none
@SQ SN:ref  LN:45
r001    99  ref 7   30  8M2I4M1D3M  =   37  39  TTAGATAAAGGATACTG   *
r003    0   ref 29  30  5S6M    *   0   0   GCCTAAGCTAA *   SA:Z:ref,29,-,6H5M,17,0;
r003    2064    ref 29  17  6H5M    *   0   0   TAGGC   *   SA:Z:ref,9,+,5S6M,30,1;
r001    147 ref 237 30  9M  =   7   -39 CAGCGGCAT   *   NM:i:1
)";
 
int main()
{
    seqan3::sam_file_input fin{std::istringstream{sam_file_raw}, seqan3::format_sam{}};
 
    using record_type = typename decltype(fin)::record_type;
    std::vector<record_type> records{}; // store all my records in a vector
 
    for (auto & rec : fin)
        records.push_back(std::move(rec));
}

#include <sstream>
 
#include <seqan3/core/debug_stream.hpp>
#include <seqan3/io/sam_file/input.hpp>
#include <seqan3/utility/type_list/type_list.hpp>
 
auto sam_file_raw = R"(@HD  VN:1.6  SO:coordinate   GO:none
@SQ SN:ref  LN:45
r001    99  ref 7   30  8M2I4M1D3M  =   37  39  TTAGATAAAGGATACTG   *
r003    0   ref 29  30  5S6M    *   0   0   GCCTAAGCTAA *   SA:Z:ref,29,-,6H5M,17,0;
r003    2064    ref 29  17  6H5M    *   0   0   TAGGC   *   SA:Z:ref,9,+,5S6M,30,1;
r001    147 ref 237 30  9M  =   7   -39 CAGCGGCAT   *   NM:i:1
)";
 
int main()
{
    seqan3::sam_file_input fin{std::istringstream{sam_file_raw}, seqan3::format_sam{}};
 
    for (auto & rec : fin)
    {
        seqan3::debug_stream << "id:  " << rec.id() << '\n';
        seqan3::debug_stream << "read sequence: " << rec.sequence() << '\n';
        seqan3::debug_stream << "mapping position: " << rec.reference_position() << '\n';
        seqan3::debug_stream << "mapping quality: " << rec.mapping_quality() << '\n';
 
        // there are more fields read on default
    }
}

#include <sstream>
 
#include <seqan3/core/debug_stream.hpp>
#include <seqan3/io/sam_file/input.hpp>
#include <seqan3/utility/type_list/type_list.hpp>
 
auto sam_file_raw = R"(@HD  VN:1.6  SO:coordinate   GO:none
@SQ SN:ref  LN:45
r001    99  ref 7   30  8M2I4M1D3M  =   37  39  TTAGATAAAGGATACTG   *
r003    0   ref 29  30  5S6M    *   0   0   GCCTAAGCTAA *   SA:Z:ref,29,-,6H5M,17,0;
r003    2064    ref 29  17  6H5M    *   0   0   TAGGC   *   SA:Z:ref,9,+,5S6M,30,1;
r001    147 ref 237 30  9M  =   7   -39 CAGCGGCAT   *   NM:i:1
)";
 
int main()
{
    seqan3::sam_file_input fin{std::istringstream{sam_file_raw},
                               seqan3::format_sam{},
                               seqan3::fields<seqan3::field::flag, seqan3::field::mapq>{}};
 
    for (auto & [flag, mapq] : fin) // the order is the same as specified in fields!
    {
        seqan3::debug_stream << "flag:  " << flag << '\n';
        seqan3::debug_stream << "mapping quality:  " << mapq << '\n';
    }
}

#include <iostream>
 
#include <seqan3/io/sam_file/output.hpp>
 
int main()
{
    seqan3::sam_file_output fout{std::cout, seqan3::format_sam{}};
}

#include <filesystem>
#include <sstream>
 
#include <seqan3/io/sam_file/all.hpp>
 
auto sam_file_raw = R"(@HD  VN:1.6  SO:coordinate   GO:none
@SQ SN:ref  LN:45
r001    99  ref 7   30  8M2I4M1D3M  =   37  39  TTAGATAAAGGATACTG   *
r003    0   ref 29  30  5S6M    *   0   0   GCCTAAGCTAA *   SA:Z:ref,29,-,6H5M,17,0;
r003    2064    ref 29  17  6H5M    *   0   0   TAGGC   *   SA:Z:ref,9,+,5S6M,30,1;
r001    147 ref 237 30  9M  =   7   -39 CAGCGGCAT   *   NM:i:1
)";
 
int main()
{
    // fin uses custom fields, fout uses the default fields.
    seqan3::sam_file_input fin{std::istringstream{sam_file_raw},
                               seqan3::format_sam{},
                               seqan3::fields<seqan3::field::ref_offset, seqan3::field::flag>{}};
    // output doesn't have to match the configuration of the input
    seqan3::sam_file_output fout{std::ostringstream{}, seqan3::format_sam{}};
 
    for (auto & r : fin)
        fout.push_back(r); // copy all the records.
}

#include <filesystem>
 
#include <seqan3/io/sam_file/output.hpp>
 
int main()
{
    auto tmp_file = std::filesystem::temp_directory_path() / "my.sam";
 
    seqan3::sam_file_output fout{tmp_file}; // SAM format detected, std::ofstream opened for file
 
    std::filesystem::remove(tmp_file);
}

#include <filesystem>
#include <string>
#include <vector>
 
#include <seqan3/io/sam_file/output.hpp>
 
int main()
{
    auto tmp_file = std::filesystem::temp_directory_path() / "my.sam";
 
    std::vector<std::string> ref_ids{"ref1", "ref2"};
    std::vector<size_t> ref_lengths{1234, 5678};
 
    seqan3::sam_file_output fout{tmp_file, ref_ids, ref_lengths};
    std::filesystem::remove(tmp_file);
}

#include <sstream>
 
#include <seqan3/io/sam_file/output.hpp>
 
int main()
{
    // no need to specify the template arguments <...> for format specialization:
    seqan3::sam_file_output fout{std::ostringstream{}, seqan3::format_sam{}, seqan3::fields<seqan3::field::mapq>{}};
}

#include <sstream>
 
#include <seqan3/io/sam_file/all.hpp>
 
auto sam_file_raw = R"(First    0   *   0   0   *   *   0   0   ACGT    *
2nd 0   *   0   0   *   *   0   0   NATA    *
Third   0   *   0   0   *   *   0   0   GATA    *
)";
 
int main()
{
    // copying a file in one line:
    seqan3::sam_file_output{std::ostringstream{}, seqan3::format_sam{}} =
        seqan3::sam_file_input{std::istringstream{sam_file_raw}, seqan3::format_sam{}};
 
    // with seqan3::sam_file_output as a variable:
    seqan3::sam_file_output fout{std::ostringstream{}, seqan3::format_sam{}};
    seqan3::sam_file_input fin{std::istringstream{sam_file_raw}, seqan3::format_sam{}};
    fout = fin;
 
    // or in pipe notation:
    seqan3::sam_file_input{std::istringstream{sam_file_raw}, seqan3::format_sam{}}
        | seqan3::sam_file_output{std::ostringstream{}, seqan3::format_sam{}};
}

#include <seqan3/core/platform.hpp>
 
#include <ranges>
#include <sstream>
 
#include <seqan3/io/sam_file/all.hpp>
 
auto sam_file_raw = R"(@HD  VN:1.6  SO:coordinate   GO:none
@SQ SN:ref  LN:45
r001    99  ref 7   30  *   =   37  39  TTAGATAAAGGATACTG   *
r003    0   ref 29  30  *   *   0   0   GCCTAAGCTAA *   SA:Z:ref,29,-,6H5M,17,0;
r003    2064    ref 29  17  *   *   0   0   TAGGC   *   SA:Z:ref,9,+,5S6M,30,1;
r001    147 ref 237 30  *   =   7   -39 CAGCGGCAT   *   NM:i:1
)";
 
int main()
{
    auto input_file = seqan3::sam_file_input{std::istringstream{sam_file_raw}, seqan3::format_sam{}};
    input_file | std::views::take(3) // take only the first 3 records
        | seqan3::sam_file_output{std::ostringstream{}, seqan3::format_sam{}};
}

#include <sstream>
#include <string>
#include <vector>
 
#include <seqan3/io/sam_file/output.hpp>
 
int main()
{
    std::vector<std::string> ref_ids{"ref1", "ref2"};
    std::vector<size_t> ref_lengths{1234, 5678};
 
    // always give reference information if you want to have your header properly initialised
    seqan3::sam_file_output fout{std::ostringstream{}, ref_ids, ref_lengths, seqan3::format_sam{}};
 
    // add information to the header of the file.
    fout.header().comments.push_back("This is a comment");
}

#include <sstream>
#include <string>
#include <tuple>
#include <vector>
 
#include <seqan3/alphabet/nucleotide/dna5.hpp>
#include <seqan3/io/sam_file/output.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::sam_file_output fout{std::ostringstream{}, seqan3::format_sam{}};
 
    std::vector<std::tuple<seqan3::dna5_vector, std::string>> range{{"ACGT"_dna5, "First"},
                                                                    {"NATA"_dna5, "2nd"},
                                                                    {"GATA"_dna5, "Third"}}; // a range of "records"
 
    fout = range; // will iterate over the records and write them
    // equivalent to:
    range | fout;
}

#include <iostream>
#include <sstream>
 
#include <seqan3/io/sam_file/all.hpp>
 
auto sam_file_raw = R"(@HD  VN:1.6  SO:coordinate   GO:none
@SQ SN:ref  LN:45
r001    99  ref 7   30  8M2I4M1D3M  =   37  39  TTAGATAAAGGATACTG   !!!!!!!!!!!!!!!!!
r003    0   ref 29  30  5S6M    *   0   0   GCCTAAGCTAA !!!!!!!!!!! SA:Z:ref,29,-,6H5M,17,0;
r003    4   *   29  17  *   *   0   0   TAGGC   @@@@@   SA:Z:ref,9,+,5S6M,30,1;
r001    147 ref 237 30  9M  =   7   -39 CAGCGGCAT   !!!!!!!!!   NM:i:1
)";
 
int main()
{
    seqan3::sam_file_input fin{std::istringstream{sam_file_raw}, seqan3::format_sam{}};
 
    for (auto & rec : fin)
    {
        // Check if a certain flag value (bit) is set:
        if (static_cast<bool>(rec.flag() & seqan3::sam_flag::unmapped))
            std::cout << "Read " << rec.id() << " is unmapped\n";
 
        if (rec.base_qualities()[0] < seqan3::assign_char_to('@', seqan3::phred42{})) // low quality
        {
            // Set a flag value (bit):
            rec.flag() |= seqan3::sam_flag::failed_filter;
            // Note that this does not affect other flag values (bits),
            // e.g. `rec.flag() & seqan3::sam_flag::unmapped` may still be true
        }
 
        // Unset a flag value (bit):
        rec.flag() &= ~seqan3::sam_flag::duplicate; // not marked as a duplicate anymore
    }
}

#include <seqan3/core/debug_stream.hpp>
#include <seqan3/io/sam_file/sam_tag_dictionary.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::sam_tag_dictionary dict{}; // initialise empty dictionary
 
    dict.get<"NM"_tag>() = 3;         // set SAM tag 'NM' to 3 (integer type)
    dict.get<"CO"_tag>() = "comment"; // set SAM tag 'CO' to "comment" (string type)
 
    auto nm = dict.get<"NM"_tag>(); // get SAM tag 'NM' (note: type is int32_t)
    auto co = dict.get<"CO"_tag>(); // get SAM tag 'CO' (note: type is std::string)
 
    seqan3::debug_stream << nm << '\n'; // will print '3'
    seqan3::debug_stream << co << '\n'; // will print "comment"
}

 
#include <seqan3/io/sam_file/sam_tag_dictionary.hpp>
 
using namespace seqan3::literals;
 
template <>                           // no template parameter since the tag is known
struct seqan3::sam_tag_type<"XX"_tag> // here comes your tag
{
    using type = int32_t; // specify the type of your tag
};
 
#include <seqan3/io/sam_file/sam_tag_dictionary.hpp>
 
using namespace seqan3::literals;
 
// ...
 
uint16_t tag_id = "NM"_tag; // tag_id = 10061
 
#include <seqan3/io/sam_file/sam_tag_dictionary.hpp>
 
using namespace seqan3::literals;
 
// ...
 
using nm_tag_type = seqan3::sam_tag_type_t<"NM"_tag>;
 
#include <seqan3/io/sam_file/sam_tag_dictionary.hpp>
 
using namespace seqan3::literals;
 
// ...
 
using nm_tag_type2 = seqan3::sam_tag_type<"NM"_tag>::type;

#include <variant> // for std::visit
 
#include <seqan3/core/debug_stream.hpp>
#include <seqan3/io/sam_file/sam_tag_dictionary.hpp>
#include <seqan3/utility/container/concept.hpp> // for the seqan3::container
 
// a lambda helper function that prints every type in the std::variant<...allowed SAM tag types...>
auto print_fn = [](auto && arg)
{
    using T = std::remove_cvref_t<decltype(arg)>; // the type T of arg.
 
    if constexpr (!seqan3::container<T>) // If T is not a container,
    {
        seqan3::debug_stream << arg << '\n'; // just print arg directly.
    }
    else // If T is a container,
    {
        for (auto const & arg_v : arg) // print every value in arg.
            seqan3::debug_stream << arg_v << ",";
        seqan3::debug_stream << '\n';
    }
};
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::sam_tag_dictionary dict{}; // initialise empty dictionary
 
    // ! there is no get function for unknown tags !
    // dict.get<"XZ"_tag>() = 3;
    // but you can use the operator[]
    dict["XZ"_tag] = 3; // set unknown SAM tag 'XZ' to 3 (type int32_t)
 
    // ! there is no get function for unknown tags !
    // auto nm = dict.get<"XZ"_tag>();
    // but you can use the operator[] again
    auto xz = dict["XZ"_tag]; // get SAM tag 'XZ' (type std::variant<...allowed SAM tag types...>)
 
    // ! you cannot print a std::variant directly !
    // seqan3::debug_stream << nm << '\n';
    // but you can use visit:
    std::visit(print_fn, xz); // prints 3
}

#include <sstream>
 
#include <seqan3/io/sequence_file/input.hpp>
 
auto input = R"(>TEST1
ACGT
>Test2
AGGCTGA
>Test3
GGAGTATAATATATATATATATAT)";
 
int main()
{
    seqan3::sequence_file_input<seqan3::sequence_file_input_default_traits_aa> fin{std::istringstream{input},
                                                                                   seqan3::format_fasta{}};
}

#include <sstream>
#include <utility>
#include <vector>
 
#include <seqan3/io/sequence_file/input.hpp>
 
auto input = R"(>TEST1
ACGT
>Test2
AGGCTGA
>Test3
GGAGTATAATATATATATATATAT)";
 
int main()
{
    seqan3::sequence_file_input fin{std::istringstream{input}, seqan3::format_fasta{}};
 
    using record_type = typename decltype(fin)::record_type;
    std::vector<record_type> records{};
 
    for (auto & rec : fin)
        records.push_back(std::move(rec));
}

#include <sstream>
#include <vector>
 
#include <seqan3/core/debug_stream.hpp>
#include <seqan3/io/sequence_file/input.hpp>
 
auto input = R"(>TEST1
ACGT
>Test2
AGGCTGA
>Test3
GGAGTATAATATATATATATATAT)";
 
int main()
{
    using seqan3::get;
 
    seqan3::sequence_file_input fin{std::istringstream{input},
                                    seqan3::format_fasta{},
                                    seqan3::fields<seqan3::field::id, seqan3::field::seq, seqan3::field::qual>{}};
 
    for (auto & [id, seq, qual] : fin) // the order is now different, "id" comes first, because it was specified first
    {
        seqan3::debug_stream << "ID:  " << id << '\n';
        seqan3::debug_stream << "SEQ: " << seq << '\n';
        seqan3::debug_stream << "QUAL: " << qual << '\n';
    }
}

#include <seqan3/core/debug_stream.hpp>
#include <seqan3/io/sequence_file/input.hpp>
 
auto input = R"(>TEST1
ACGT
>Test2
AGGCTGA
>Test3
GGAGTATAATATATATATATATAT)";
 
int main()
{
    seqan3::sequence_file_input fin{std::istringstream{input}, seqan3::format_fasta{}};
 
    for (auto & [sequence, id, quality] : fin)
    {
        seqan3::debug_stream << "ID: " << id << '\n';
        seqan3::debug_stream << "SEQ: " << sequence << '\n';
        seqan3::debug_stream << "EMPTY QUAL." << quality << '\n'; // quality is empty for FASTA files
    }
}

#include <ranges>
#include <sstream>
 
#include <seqan3/core/debug_stream.hpp>
#include <seqan3/io/sequence_file/input.hpp>
 
auto input = R"(>TEST1
ACGT
>Test2
AGGCTGA
>Test3
GGAGTATAATATATATATATATAT)";
 
int main()
{
    seqan3::sequence_file_input fin{std::istringstream{}, seqan3::format_fasta{}};
 
    auto minimum_length5_filter = std::views::filter(
        [](auto const & rec)
        {
            return std::ranges::size(rec.sequence()) >= 5;
        });
 
    for (auto & rec : fin | minimum_length5_filter) // only record with sequence length >= 5 will "appear"
    {
        seqan3::debug_stream << "IDs of seq_length >= 5: " << rec.id() << '\n';
        // ...
    }
}

#include <sstream>
#include <utility>
 
#include <seqan3/io/sequence_file/input.hpp>
 
auto input = R"(>TEST1
ACGT
>Test2
AGGCTGA
>Test3
GGAGTATAATATATATATATATAT)";
 
int main()
{
    seqan3::sequence_file_input fin{std::istringstream{input}, seqan3::format_fasta{}};
    //                         ^ no need to specify the template arguments
}

#include <sstream>
 
#include <seqan3/core/debug_stream.hpp>
#include <seqan3/io/sequence_file/input.hpp>
 
auto input = R"(>TEST1
ACGT
>Test2
AGGCTGA
>Test3
GGAGTATAATATATATATATATAT)";
 
int main()
{
    seqan3::sequence_file_input fin{std::istringstream{input}, seqan3::format_fasta{}};
 
    for (auto & record : fin)
    {
        seqan3::debug_stream << "ID:  " << record.id() << '\n';
        seqan3::debug_stream << "SEQ: " << record.sequence() << '\n';
        // a quality field also exists, but is not printed, because we know it's empty for FASTA files.
    }
}

#include <sstream>
#include <utility>
 
#include <seqan3/io/sequence_file/input.hpp>
 
auto input = R"(>TEST1
ACGT
>Test2
AGGCTGA
>Test3
GGAGTATAATATATATATATATAT)";
 
int main()
{
    seqan3::sequence_file_input fin{std::istringstream{input}, seqan3::format_fasta{}};
 
    auto rec0 = std::move(fin.front());
}

#include <sstream>
 
#include <seqan3/io/sequence_file/input.hpp>
 
auto input = R"(>TEST1
ACGT
>Test2
AGGCTGA
>Test3
GGAGTATAATATATATATATATAT)";
 
int main()
{
    seqan3::sequence_file_input fin{std::istringstream{input}, seqan3::format_fasta{}};
    auto it = std::ranges::begin(fin);
 
    // the following are equivalent:
    auto & rec0 = *it;
    auto & rec1 = fin.front();
    std::cout << std::boolalpha << (rec0.id() == rec1.id()) << '\n'; // true
    // Note: rec0 and rec1 are references and become invalid after incrementing "it"!
}

#include <seqan3/test/snippet/create_temporary_snippet_file.hpp>
// std::filesystem::current_path() / "my.fasta" will be deleted after the execution
seqan3::test::create_temporary_snippet_file my_fasta{"my.fasta", ""};
 
#include <filesystem>
 
#include <seqan3/alphabet/nucleotide/dna4.hpp>
#include <seqan3/io/sequence_file/input.hpp>
#include <seqan3/io/sequence_file/output.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    auto fasta_file = std::filesystem::current_path() / "my.fasta";
 
    {
        // Create a ./my.fasta file.
        seqan3::sequence_file_output fout{fasta_file};
        fout.emplace_back("ACGT"_dna4, "TEST1");
        fout.emplace_back("AGGCTGA"_dna4, "Test2");
        fout.emplace_back("GGAGTATAATATATATATATATAT"_dna4, "Test3");
    }
 
    // FASTA with DNA sequences assumed, regular std::ifstream taken as stream
    seqan3::sequence_file_input fin{fasta_file};
}

#include <sstream>
 
#include <seqan3/io/sequence_file/input.hpp>
#include <seqan3/utility/type_list/type_list.hpp>
 
// ... input had amino acid sequences
auto input = R"(>TEST1
FQTWE
>Test2
KYRTW
>Test3
EEYQTWEEFARAAEKLYLTDPMKV)";
 
int main()
{ // Use amino acid traits below
    using sequence_file_input_type =
        seqan3::sequence_file_input<seqan3::sequence_file_input_default_traits_aa,
                                    seqan3::fields<seqan3::field::seq, seqan3::field::id, seqan3::field::qual>,
                                    seqan3::type_list<seqan3::format_fasta>>;
    sequence_file_input_type fin{std::istringstream{input}, seqan3::format_fasta{}};
}

#include <sstream>
 
#include <seqan3/alphabet/container/bitpacked_sequence.hpp>
#include <seqan3/alphabet/nucleotide/dna4.hpp>
#include <seqan3/io/sequence_file/input.hpp>
 
auto input = R"(>TEST1
ACGT
>Test2
AGGCTGA
>Test3
GGAGTATAATATATATATATATAT)";
 
struct my_traits : seqan3::sequence_file_input_default_traits_dna
{
    using sequence_alphabet = seqan3::dna4; // instead of dna5
 
    template <typename alph>
    using sequence_container = seqan3::bitpacked_sequence<alph>; // must be defined as a template!
};
 
int main()
{
    seqan3::sequence_file_input<my_traits> fin{std::istringstream{input}, seqan3::format_fasta{}};
}

#include <sstream>
#include <string>
#include <tuple>
#include <vector>
 
#include <seqan3/alphabet/nucleotide/dna5.hpp>
#include <seqan3/io/sequence_file/output.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::sequence_file_output fout{std::ostringstream{}, seqan3::format_fasta{}};
 
    std::vector<std::tuple<seqan3::dna5_vector, std::string>> range{{"ACGT"_dna5, "First"},
                                                                    {"NATA"_dna5, "2nd"},
                                                                    {"GATA"_dna5, "Third"}}; // a range of "records"
 
    fout = range;
    // the same as:
    range | fout;
}

#include <sstream>
#include <string>
 
#include <seqan3/alphabet/container/concatenated_sequences.hpp>
#include <seqan3/alphabet/nucleotide/dna4.hpp>
#include <seqan3/io/sequence_file/format_fasta.hpp>
#include <seqan3/io/sequence_file/output.hpp>
#include <seqan3/utility/views/zip.hpp>
 
using namespace seqan3::literals;
 
struct data_storage_t
{
    seqan3::concatenated_sequences<seqan3::dna4_vector> sequences{"ACGT"_dna4, "AAA"_dna4};
    seqan3::concatenated_sequences<std::string> ids{std::string{"ID1"}, std::string{"ID2"}};
};
 
int main()
{
    data_storage_t data_storage{};
 
    // ... in your file writing function:
 
    seqan3::sequence_file_output fout{std::ostringstream{}, seqan3::format_fasta{}};
 
    fout = seqan3::views::zip(data_storage.sequences, data_storage.ids);
}

#include <seqan3/io/sequence_file/output.hpp>
 
int main()
{
    seqan3::sequence_file_output fout{std::cout, seqan3::format_fasta{}};
    //                          ^ no need to specify the template arguments
}

#include <filesystem>
#include <sstream>
 
#include <seqan3/io/sequence_file/input.hpp>
#include <seqan3/io/sequence_file/output.hpp>
 
auto input = R"(@TEST1
ACGT
+
##!#
@Test2
AGGCTGA
+
##!#!!!
@Test3
GGAGTATAATATATATATATATAT
+
##!###!###!###!###!###!#)";
 
int main()
{
    // file format conversion in one line:
    seqan3::sequence_file_output{std::ostringstream{}, seqan3::format_fasta{}} =
        seqan3::sequence_file_input{std::istringstream{input}, seqan3::format_fastq{}};
 
    // with seqan3::sequence_file_output as a variable:
    seqan3::sequence_file_output fout{std::ostringstream{}, seqan3::format_fasta{}};
    seqan3::sequence_file_input fin{std::istringstream{input}, seqan3::format_fastq{}};
    fout = fin;
 
    // or in pipe notation:
    seqan3::sequence_file_input{std::istringstream{input}, seqan3::format_fastq{}}
        | seqan3::sequence_file_output{std::ostringstream{}, seqan3::format_fasta{}};
}

#include <sstream>
#include <string>
 
#include <seqan3/alphabet/nucleotide/dna5.hpp>
#include <seqan3/io/sequence_file/output.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::sequence_file_output fout{std::ostringstream{}, seqan3::format_fasta{}};
 
    for (int i = 0; i < 5; ++i) // some criteria
    {
        std::string id{"test_id"};
        seqan3::dna5_vector seq{"ACGT"_dna5};
 
        // ...
 
        fout.emplace_back(seq, id);
    }
}

#include <sstream>
#include <string>
#include <tuple>
#include <vector>
 
#include <seqan3/alphabet/nucleotide/dna5.hpp>
#include <seqan3/alphabet/quality/phred42.hpp>
#include <seqan3/alphabet/quality/qualified.hpp>
#include <seqan3/io/sequence_file/output.hpp>
#include <seqan3/utility/views/elements.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::sequence_file_output fout{std::ostringstream{},
                                      seqan3::format_fastq{},
                                      seqan3::fields<seqan3::field::id, seqan3::field::seq, seqan3::field::qual>{}};
 
    for (int i = 0; i < 5; i++)
    {
        std::string id{"test_id"};
        // vector of combined data structure:
        std::vector<seqan3::qualified<seqan3::dna5, seqan3::phred42>> seq_qual{{'N'_dna5, '7'_phred42},
                                                                               {'A'_dna5, '1'_phred42},
                                                                               {'C'_dna5, '3'_phred42}};
 
        auto view_on_seq = seqan3::views::elements<0>(seq_qual);
        auto view_on_qual = seqan3::views::elements<1>(seq_qual);
 
        // ...
 
        // Note that the order of the arguments is different from the default `seq, id, qual`,
        // because you specified that ID should be first in the fields template argument.
        fout.emplace_back(id, view_on_seq, view_on_qual);
 
        // or:
        fout.push_back(std::tie(id, view_on_seq, view_on_qual));
    }
}

#include <sstream>
 
#include <seqan3/io/sequence_file/input.hpp>
#include <seqan3/io/sequence_file/output.hpp>
 
auto input = R"(@TEST1
ACGT
+
##!#
@Test2
AGGCTGA
+
##!#!!!
@Test3
GGAGTATAATATATATATATATAT
+
##!###!###!###!###!###!#)";
 
int main()
{
    seqan3::sequence_file_input fin{std::istringstream{input},
                                    seqan3::format_fastq{},
                                    seqan3::fields<seqan3::field::seq, seqan3::field::id, seqan3::field::qual>{}};
    seqan3::sequence_file_output fout{std::ostringstream{},
                                      seqan3::format_fastq{}}; // doesn't have to match the configuration
 
    for (auto & r : fin)
    {
        if (true) // r fulfills some criterium
            fout.push_back(r);
    }
}

#include <sstream>
#include <string>
 
#include <seqan3/alphabet/nucleotide/dna5.hpp>
#include <seqan3/io/sequence_file/output.hpp>
#include <seqan3/utility/type_list/type_list.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::sequence_file_output fout{std::ostringstream{}, seqan3::format_fasta{}};
    for (int i = 0; i < 5; ++i) // some criteria
    {
        seqan3::record<seqan3::type_list<seqan3::dna5_vector, std::string>,
                       seqan3::fields<seqan3::field::seq, seqan3::field::id>>
            r{"ACGT"_dna5, "ID1"};
 
        // ...
 
        fout.push_back(r);
    }
}

#include <sstream>
#include <string>
#include <tuple>
 
#include <seqan3/alphabet/nucleotide/dna5.hpp>
#include <seqan3/io/sequence_file/output.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::sequence_file_output fout{std::ostringstream{}, seqan3::format_fasta{}};
 
    for (int i = 0; i < 5; ++i) // some criteria
    {
        std::string id{"test_id"};
        seqan3::dna5_vector seq{"ACGT"_dna5};
 
        // ...
 
        fout.push_back(std::tie(seq, id));
    }
}

#include <sstream>
#include <string>
#include <tuple>
 
#include <seqan3/alphabet/nucleotide/dna5.hpp>
#include <seqan3/io/sequence_file/output.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::sequence_file_output fout{std::ostringstream{}, seqan3::format_fasta{}};
 
    auto it = fout.begin();
 
    for (int i = 0; i < 5; ++i) // some criteria
    {
        std::string id{"test_id"};
        seqan3::dna5_vector seq{"ACGT"_dna5};
 
        // ...
 
        // assign to iterator
        *it = std::tie(seq, id);
        // is the same as:
        fout.push_back(std::tie(seq, id));
    }
}

#include <sstream>
#include <string>
#include <tuple>
 
#include <seqan3/alphabet/nucleotide/dna5.hpp>
#include <seqan3/io/sequence_file/output.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::sequence_file_output fout{std::ostringstream{}, seqan3::format_fasta{}};
 
    for (int i = 0; i < 5; ++i) // ...
    {
        std::string id{"test_id"};
        seqan3::dna5_vector seq{"ACGT"_dna5};
 
        // ...
 
        fout.emplace_back(seq, id); // as individual variables
        // or:
        fout.push_back(std::tie(seq, id)); // as a tuple
    }
}

#include <seqan3/test/snippet/create_temporary_snippet_file.hpp>
// std::filesystem::current_path() / "my.fasta" will be deleted after the execution
seqan3::test::create_temporary_snippet_file my_fasta{"my.fasta", ""};
 
#include <filesystem>
 
#include <seqan3/io/sequence_file/output.hpp>
 
int main()
{
    auto fasta_file = std::filesystem::current_path() / "my.fasta";
 
    // FASTA format detected, std::ofstream opened for file
    seqan3::sequence_file_output fin{fasta_file};
}

#include <seqan3/core/platform.hpp>
 
#if !SEQAN3_WORKAROUND_GCC_96070
#    include <iterator>
#    include <ranges>
#    include <sstream>
 
#    include <seqan3/io/sequence_file/input.hpp>
#    include <seqan3/io/sequence_file/output.hpp>
 
auto input = R"(@TEST1
ACGT
+
##!#
@Test2
AGGCTGA
+
##!#!!!
@Test3
GGAGTATAATATATATATATATAT
+
##!###!###!###!###!###!#)";
 
int main()
{
    // minimum_average_quality_filter and minimum_sequence_length_filter need to be implemented first
    auto minimum_sequence_length_filter = std::views::filter(
        [](auto rec)
        {
            return std::ranges::distance(rec.sequence()) >= 50;
        });
 
    auto minimum_average_quality_filter = std::views::filter(
        [](auto const & record)
        {
            double qual_sum{0}; // summation of the qualities
            for (auto chr : record.base_qualities())
                qual_sum += seqan3::to_phred(chr);
 
            // check if average quality is greater than 20.
            return qual_sum / (std::ranges::distance(record.base_qualities())) >= 20;
        });
 
    auto input_file = seqan3::sequence_file_input{std::istringstream{input}, seqan3::format_fastq{}};
    input_file | minimum_average_quality_filter | minimum_sequence_length_filter | std::views::take(3)
        | seqan3::sequence_file_output{std::ostringstream{}, seqan3::format_fasta{}};
}
#endif // !SEQAN3_WORKAROUND_GCC_96070

#include <sstream>
 
#include <seqan3/io/structure_file/input.hpp>
 
auto input = R"(> S.cerevisiae_tRNA-PHE M10740/1-73
GCGGAUUUAGCUCAGUUGGGAGAGCGCCAGACUGAAGAUUUGGAGGUCCUGUGUUCGAUCCACAGAAUUCGCA
(((((((..((((........)))).((((.........)))).....(((((.......)))))))))))). (-17.50)
> example
UUGGAGUACACAACCUGUACACUCUUUC
..(((((..(((...)))..)))))... (-3.71))";
 
int main()
{
    seqan3::structure_file_input<seqan3::structure_file_input_default_traits_rna> fin{std::istringstream{input},
                                                                                      seqan3::format_vienna{}};
}

#include <filesystem>
#include <sstream>
 
#include <seqan3/alphabet/nucleotide/rna4.hpp>
#include <seqan3/alphabet/structure/wuss.hpp>
#include <seqan3/io/structure_file/input.hpp>
#include <seqan3/io/structure_file/output.hpp>
 
auto input = R"(> S.cerevisiae_tRNA-PHE M10740/1-73
GCGGAUUUAGCUCAGUUGGGAGAGCGCCAGACUGAAGAUUUGGAGGUCCUGUGUUCGAUCCACAGAAUUCGCA
(((((((..((((........)))).((((.........)))).....(((((.......)))))))))))). (-17.50)
> example
UUGGAGUACACAACCUGUACACUCUUUC
..(((((..(((...)))..)))))... (-3.71))";
 
int main()
{
    auto tmp_file = std::filesystem::temp_directory_path() / "my.dbn";
 
    using namespace seqan3::literals;
 
    // First, make /tmp/input.dbn
    {
        seqan3::structure_file_output fout{tmp_file};
        fout.emplace_back("GCGGAUUUAGCUCAGUUGGGAGAGCGCCAGACUGAAGAUUUGGAGGUCCUGUGUUCGAUCCACAGAAUUCGCA"_rna4,
                          "S.cerevisiae_tRNA-PHE M10740/1-73",
                          "(((((((..((((........)))).((((.........)))).....(((((.......))))))))))))."_wuss51);
        fout.emplace_back("UUGGAGUACACAACCUGUACACUCUUUC"_rna4, "example", "..(((((..(((...)))..)))))..."_wuss51);
    }
 
    seqan3::structure_file_input sf{tmp_file}; // Vienna with RNA sequences assumed, use regular std::ifstream as stream
 
    seqan3::structure_file_input fin{std::istringstream{input}, seqan3::format_vienna{}};
    //                          ^ no need to specify the template arguments
 
    std::filesystem::remove(tmp_file);
}

#include <sstream>
#include <utility>
#include <vector>
 
#include <seqan3/io/structure_file/input.hpp>
 
auto input = R"(> S.cerevisiae_tRNA-PHE M10740/1-73
GCGGAUUUAGCUCAGUUGGGAGAGCGCCAGACUGAAGAUUUGGAGGUCCUGUGUUCGAUCCACAGAAUUCGCA
(((((((..((((........)))).((((.........)))).....(((((.......)))))))))))). (-17.50)
> example
UUGGAGUACACAACCUGUACACUCUUUC
..(((((..(((...)))..)))))... (-3.71))";
 
int main()
{
    seqan3::structure_file_input fin{std::istringstream{input}, seqan3::format_vienna{}};
 
    using record_type = typename decltype(fin)::record_type;
    std::vector<record_type> records;
 
    for (auto & rec : fin)
        records.push_back(std::move(rec));
}

#include <ranges>
#include <sstream>
 
#include <seqan3/alphabet/views/to_char.hpp>
#include <seqan3/core/debug_stream.hpp>
#include <seqan3/io/structure_file/input.hpp>
 
auto input = R"(> S.cerevisiae_tRNA-PHE M10740/1-73
GCGGAUUUAGCUCAGUUGGGAGAGCGCCAGACUGAAGAUUUGGAGGUCCUGUGUUCGAUCCACAGAAUUCGCA
(((((((..((((........)))).((((.........)))).....(((((.......)))))))))))). (-17.50)
> example
UUGGAGUACACAACCUGUACACUCUUUC
..(((((..(((...)))..)))))... (-3.71))";
 
int main()
{
    seqan3::structure_file_input fin{std::istringstream{input}, seqan3::format_vienna{}};
 
    auto minimum_length5_filter = std::views::filter(
        [](auto const & rec)
        {
            return std::ranges::size(rec.sequence()) >= 5;
        });
 
    for (auto & rec : fin | minimum_length5_filter) // only record with sequence length >= 5 will "appear"
        seqan3::debug_stream << (rec.sequence() | seqan3::views::to_char) << '\n';
}

#include <sstream>
 
#include <seqan3/alphabet/nucleotide/rna4.hpp>
#include <seqan3/core/debug_stream.hpp>
#include <seqan3/io/structure_file/input.hpp>
 
// Define custom traits
struct my_traits : seqan3::structure_file_input_default_traits_rna
{
    using seq_alphabet = seqan3::rna4; // instead of rna5
};
 
auto input = R"(> S.cerevisiae_tRNA-PHE M10740/1-73
GCGGAUUUAGCUCAGUUGGGAGAGCGCCAGACUGAAGAUUUGGAGGUCCUGUGUUCGAUCCACAGAAUUCGCA
(((((((..((((........)))).((((.........)))).....(((((.......)))))))))))). (-17.50)
> example
UUGGAGUACACAACCUGUACACUCUUUC
..(((((..(((...)))..)))))... (-3.71))";
 
int main()
{
    seqan3::structure_file_input<my_traits> fin{std::istringstream{input}, seqan3::format_vienna{}};
}

#include <sstream>
#include <utility>
 
#include <seqan3/io/structure_file/input.hpp>
 
auto input = R"(> S.cerevisiae_tRNA-PHE M10740/1-73
GCGGAUUUAGCUCAGUUGGGAGAGCGCCAGACUGAAGAUUUGGAGGUCCUGUGUUCGAUCCACAGAAUUCGCA
(((((((..((((........)))).((((.........)))).....(((((.......)))))))))))). (-17.50)
> example
UUGGAGUACACAACCUGUACACUCUUUC
..(((((..(((...)))..)))))... (-3.71))";
 
int main()
{
    seqan3::structure_file_input fin{std::istringstream{input}, seqan3::format_vienna{}};
 
    auto rec0 = std::move(fin.front());
}

#include <sstream>
 
#include <seqan3/alphabet/views/to_char.hpp>
#include <seqan3/core/debug_stream.hpp>
#include <seqan3/io/structure_file/input.hpp>
#include <seqan3/utility/type_list/type_list.hpp>
 
auto input = R"(> S.cerevisiae_tRNA-PHE M10740/1-73
ACEWACEW
HGEBHHHH
> example
ACEWACEWACEWACEW
HGEBHHHHHGEBHHHH)";
 
int main()
{
    using structure_file_input_t =
        seqan3::structure_file_input<seqan3::structure_file_input_default_traits_aa,
                                     seqan3::fields<seqan3::field::seq, seqan3::field::id, seqan3::field::structure>,
                                     seqan3::type_list<seqan3::format_vienna>>;
 
    structure_file_input_t fin{std::istringstream{input}, seqan3::format_vienna{}};
 
    for (auto & rec : fin)
    {
        seqan3::debug_stream << "ID: " << rec.id() << '\n';
        // sequence and structure are converted to char on-the-fly
        seqan3::debug_stream << "SEQ: " << (rec.sequence() | seqan3::views::to_char) << '\n';
        seqan3::debug_stream << "STRUCTURE: " << (rec.sequence_structure() | seqan3::views::to_char) << '\n';
    }
}

#include <sstream>
 
#include <seqan3/io/structure_file/input.hpp>
 
auto input = R"(> S.cerevisiae_tRNA-PHE M10740/1-73
GCGGAUUUAGCUCAGUUGGGAGAGCGCCAGACUGAAGAUUUGGAGGUCCUGUGUUCGAUCCACAGAAUUCGCA
(((((((..((((........)))).((((.........)))).....(((((.......)))))))))))). (-17.50)
> example
UUGGAGUACACAACCUGUACACUCUUUC
..(((((..(((...)))..)))))... (-3.71))";
 
int main()
{
    seqan3::structure_file_input fin{std::istringstream{input}, seqan3::format_vienna{}};
    auto it = std::ranges::begin(fin);
 
    // the following are equivalent:
    auto & rec0 = *it;
    auto & rec1 = fin.front();
    std::cout << std::boolalpha << (rec0.id() == rec1.id()) << '\n'; // true
    // both become invalid after incrementing "it"!
}

#include <sstream>
 
#include <seqan3/alphabet/views/to_char.hpp>
#include <seqan3/core/debug_stream.hpp>
#include <seqan3/io/structure_file/input.hpp>
#include <seqan3/utility/views/elements.hpp>
 
auto input = R"(> S.cerevisiae_tRNA-PHE M10740/1-73
GCGGAUUUAGCUCAGUUGGGAGAGCGCCAGACUGAAGAUUUGGAGGUCCUGUGUUCGAUCCACAGAAUUCGCA
(((((((..((((........)))).((((.........)))).....(((((.......)))))))))))). (-17.50)
> example
UUGGAGUACACAACCUGUACACUCUUUC
..(((((..(((...)))..)))))... (-3.71))";
 
int main()
{
    using seqan3::get;
 
    seqan3::structure_file_input fin{std::istringstream{input},
                                     seqan3::format_vienna{},
                                     seqan3::fields<seqan3::field::id, seqan3::field::structured_seq>{}};
 
    // note that the order is now different, "id" comes first, because it was specified first
    for (auto & [id, struc_seq] : fin)
    {
        seqan3::debug_stream << "ID: " << id << '\n';
        // sequence and structure are part of the same vector, of type std::vector<structured_rna<rna5, wuss51>>
        // sequence and structure strings are extracted and converted to char on-the-fly
        seqan3::debug_stream << "SEQ: " << (struc_seq | seqan3::views::elements<0> | seqan3::views::to_char) << '\n';
        seqan3::debug_stream << "STRUCTURE: " << (struc_seq | seqan3::views::elements<1> | seqan3::views::to_char)
                             << '\n';
    }
}

#include <sstream>
 
#include <seqan3/alphabet/views/to_char.hpp>
#include <seqan3/core/debug_stream.hpp>
#include <seqan3/io/structure_file/input.hpp>
#include <seqan3/utility/type_list/type_list.hpp>
 
auto input = R"(> S.cerevisiae_tRNA-PHE M10740/1-73
ACEWACEW
HGEBHHHH
> example
ACEWACEWACEWACEW
HGEBHHHHHGEBHHHH)";
 
int main()
{
    using seqan3::get;
 
    using structure_file_input_t =
        seqan3::structure_file_input<seqan3::structure_file_input_default_traits_aa,
                                     seqan3::fields<seqan3::field::seq, seqan3::field::id, seqan3::field::structure>,
                                     seqan3::type_list<seqan3::format_vienna>>;
 
    structure_file_input_t fin{std::istringstream{input}, seqan3::format_vienna{}};
 
    for (auto & [seq, id, structure] : fin)
    {
        seqan3::debug_stream << "ID: " << id << '\n';
        // sequence and structure are converted to char on-the-fly
        seqan3::debug_stream << "SEQ: " << (seq | seqan3::views::to_char) << '\n';
        seqan3::debug_stream << "STRUCTURE: " << (structure | seqan3::views::to_char) << '\n';
    }
}

#include <sstream>
 
#include <seqan3/io/structure_file/input.hpp>
#include <seqan3/utility/type_list/type_list.hpp>
 
auto input = R"(> S.cerevisiae_tRNA-PHE M10740/1-73
ACEWACEW
HGEBHHHH
> example
ACEWACEWACEWACEW
HGEBHHHHHGEBHHHH)";
 
int main()
{
    // ... input had amino acid sequences
    seqan3::structure_file_input<seqan3::structure_file_input_default_traits_aa,
                                 seqan3::fields<seqan3::field::seq, seqan3::field::id, seqan3::field::structure>,
                                 seqan3::type_list<seqan3::format_vienna>>
        fin{std::istringstream{input}, seqan3::format_vienna{}};
}

#include <sstream>
#include <string>
#include <vector>
 
#include <seqan3/alphabet/container/concatenated_sequences.hpp>
#include <seqan3/alphabet/nucleotide/rna5.hpp>
#include <seqan3/alphabet/structure/wuss.hpp>
#include <seqan3/io/structure_file/output.hpp>
#include <seqan3/utility/views/zip.hpp>
 
using namespace seqan3::literals;
 
struct data_storage_t
{
    seqan3::concatenated_sequences<seqan3::rna5_vector> sequences{"AACGUU"_rna5};
    seqan3::concatenated_sequences<std::string> ids{std::string{"seq1"}};
    seqan3::concatenated_sequences<std::vector<seqan3::wuss51>> structures{".(())."_wuss51};
};
 
int main()
{
    data_storage_t data_storage{}; // a global or globally used variable in your program
 
    // ... in your file writing function:
 
    seqan3::structure_file_output fout{std::ostringstream{}, seqan3::format_vienna{}};
 
    fout = seqan3::views::zip(data_storage.sequences, data_storage.ids, data_storage.structures);
}

#include <sstream>
#include <string>
#include <vector>
 
#include <seqan3/alphabet/nucleotide/rna5.hpp>
#include <seqan3/alphabet/structure/wuss.hpp>
#include <seqan3/io/structure_file/output.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::structure_file_output fout{std::ostringstream{}, seqan3::format_vienna{}};
 
    for (int i = 0; i < 10; i++) // ...
    {
        std::string id{"test_id"};
        seqan3::rna5_vector seq{"AGGGUU"_rna5};
        std::vector<seqan3::wuss51> structure{"..().."_wuss51};
 
        // ...
 
        fout.emplace_back(seq, id, structure);
    }
}

#include <sstream>
#include <string>
#include <tuple>
#include <vector>
 
#include <seqan3/alphabet/nucleotide/rna5.hpp>
#include <seqan3/alphabet/structure/wuss.hpp>
#include <seqan3/io/structure_file/output.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::structure_file_output fout{std::ostringstream{}, seqan3::format_vienna{}};
 
    std::vector<std::tuple<seqan3::rna5_vector, std::string, std::vector<seqan3::wuss51>>> range{
        {"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
}

#include <sstream>
#include <string>
#include <tuple>
#include <vector>
 
#include <seqan3/alphabet/nucleotide/rna5.hpp>
#include <seqan3/alphabet/structure/wuss.hpp>
#include <seqan3/io/structure_file/output.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::structure_file_output fout{std::ostringstream{}, seqan3::format_vienna{}};
 
    for (int i = 0; i < 10; i++) // ...
    {
        std::string id{"test_id"};
        seqan3::rna5_vector seq{"ACGU"_rna5};
        std::vector<seqan3::wuss51> structure{".()."_wuss51};
 
        // ...
 
        fout.emplace_back(seq, id, structure); // as individual variables
        // or:
        fout.push_back(std::tie(seq, id, structure)); // as a tuple
    }
}

#include <sstream>
#include <string>
#include <tuple>
#include <vector>
 
#include <seqan3/alphabet/nucleotide/rna5.hpp>
#include <seqan3/alphabet/structure/wuss.hpp>
#include <seqan3/io/structure_file/output.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::structure_file_output fout{std::ostringstream{}, seqan3::format_vienna{}};
 
    std::vector<std::tuple<seqan3::rna5_vector, std::string, std::vector<seqan3::wuss51>>> range{
        {"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
}

#include <sstream>
 
#include <seqan3/io/structure_file/input.hpp>
#include <seqan3/io/structure_file/output.hpp>
 
auto input = R"(> S.cerevisiae_tRNA-PHE M10740/1-73
GCGGAUUUAGCUCAGUUGGGAGAGCGCCAGACUGAAGAUUUGGAGGUCCUGUGUUCGAUCCACAGAAUUCGCA
(((((((..((((........)))).((((.........)))).....(((((.......)))))))))))). (-17.50)
> example
UUGGAGUACACAACCUGUACACUCUUUC
..(((((..(((...)))..)))))... (-3.71))";
 
int main()
{
    bool criteria = true;
    seqan3::structure_file_input fin{std::istringstream{input},
                                     seqan3::format_vienna{},
                                     seqan3::fields<seqan3::field::id, seqan3::field::seq, seqan3::field::structure>{}};
    // the output doesn't have to match the configuration of the input
    seqan3::structure_file_output fout{std::ostringstream{}, seqan3::format_vienna{}};
 
    for (auto & r : fin)
    {
        if (criteria) // r fulfills some filter criterium
            fout.push_back(r);
    }
}

#include <sstream>
#include <string>
#include <tuple>
#include <vector>
 
#include <seqan3/alphabet/nucleotide/rna5.hpp>
#include <seqan3/alphabet/structure/wuss.hpp>
#include <seqan3/io/structure_file/output.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::structure_file_output fout{std::ostringstream{}, seqan3::format_vienna{}};
 
    std::vector<std::tuple<seqan3::rna5_vector, std::string, std::vector<seqan3::wuss51>>> range{
        {"ACGT"_rna5, "First", "...."_wuss51},
        {"NATA"_rna5, "2nd", "...."_wuss51},
        {"GATA"_rna5, "Third", "...."_wuss51}}; // a range of "records"
 
    range | fout;
    // the same as:
    fout = range;
}

#include <sstream>
 
#include <seqan3/io/structure_file/input.hpp>
#include <seqan3/io/structure_file/output.hpp>
 
auto input = R"(> S.cerevisiae_tRNA-PHE M10740/1-73
GCGGAUUUAGCUCAGUUGGGAGAGCGCCAGACUGAAGAUUUGGAGGUCCUGUGUUCGAUCCACAGAAUUCGCA
(((((((..((((........)))).((((.........)))).....(((((.......)))))))))))). (-17.50)
> example
UUGGAGUACACAACCUGUACACUCUUUC
..(((((..(((...)))..)))))... (-3.71))";
 
int main()
{
    seqan3::structure_file_input my_in{std::istringstream{input}, seqan3::format_vienna{}};
    my_in | std::views::take(2) | seqan3::structure_file_output{std::ostringstream{}, seqan3::format_vienna{}};
}

#include <sstream>
#include <string>
#include <tuple>
#include <vector>
 
#include <seqan3/alphabet/nucleotide/rna5.hpp>
#include <seqan3/alphabet/structure/wuss.hpp>
#include <seqan3/io/structure_file/output.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::structure_file_output fout{std::ostringstream{}, seqan3::format_vienna{}};
 
    auto it = fout.begin();
 
    for (int i = 0; i < 10; i++) // ...
    {
        std::string id{"test_id"};
        seqan3::rna5_vector seq{"AGGGUU"_rna5};
        std::vector<seqan3::wuss51> structure{"..().."_wuss51};
 
        // ...
 
        // assign to iterator
        *it = std::tie(seq, id, structure);
        // is the same as:
        fout.push_back(std::tie(seq, id, structure));
    }
}

#include <sstream>
#include <string>
#include <tuple>
#include <vector>
 
#include <seqan3/alphabet/nucleotide/rna5.hpp>
#include <seqan3/alphabet/structure/wuss.hpp>
#include <seqan3/io/structure_file/output.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::structure_file_output fout{std::ostringstream{}, seqan3::format_vienna{}};
 
    for (int i = 0; i < 10; i++) // ...
    {
        std::string id{"test_id"};
        seqan3::rna5_vector seq{"AGGGUU"_rna5};
        std::vector<seqan3::wuss51> structure{"..().."_wuss51};
 
        // ...
 
        fout.push_back(std::tie(seq, id, structure));
    }
}

#include <filesystem>
 
#include <seqan3/io/structure_file/output.hpp>
 
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
 
    std::filesystem::remove(tmp_file);
}

#include <sstream>
#include <string>
#include <tuple>
#include <vector>
 
#include <seqan3/alphabet/nucleotide/rna5.hpp>
#include <seqan3/alphabet/structure/structured_rna.hpp>
#include <seqan3/alphabet/structure/wuss.hpp>
#include <seqan3/io/structure_file/output.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::structured_rna<seqan3::rna5, seqan3::wuss51> sr{'G'_rna5, '.'_wuss51};
 
    seqan3::structure_file_output fout{std::ostringstream{},
                                       seqan3::format_vienna{},
                                       seqan3::fields<seqan3::field::id, seqan3::field::structured_seq>{}};
 
    for (int i = 0; i < 10; i++) // ...
    {
        std::string id{"test_id"};
        // vector of combined data structure
        std::vector<seqan3::structured_rna<seqan3::rna5, seqan3::wuss51>> structured_sequence{sr, sr, sr, sr};
 
        // ...
 
        // 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));
    }
}

#include <iostream>
 
#include <seqan3/alphabet/nucleotide/rna4.hpp>
#include <seqan3/alphabet/structure/wuss.hpp>
#include <seqan3/io/structure_file/output.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::structure_file_output fout{std::cout, seqan3::format_vienna{}};
    //                           ^ no need to specify the template arguments
 
    fout.emplace_back("AACGUU"_rna4, "example_id", ".(())."_wuss51); // default order for vienna: SEQ, ID, STRUCTURE
}

#include <cstdlib> // std::rand
#include <future>  // std::async
#include <string>  // std::string
 
#include <seqan3/core/debug_stream.hpp>           // seqan3::debug_stream
#include <seqan3/io/sequence_file/input.hpp>      // seqan3::sequence_file_input
#include <seqan3/io/views/async_input_buffer.hpp> // seqan3::views::async_input_buffer
 
std::string fasta_file =
    R"(> seq1
ACGACTACGACGATCATCGATCGATCGATCGATCGATCGATCGATCGTACTACGATCGATCG
> seq2
ACGACTACGACGATCATCGATCGATCGATCGATCGATCGATCGATCGTACTACGATCGATCG
> seq3
ACGACTACGACGATCATCGATCGATCGATCGATCGATCGATCGATCGTACTACGATCGATCG
> seq4
ACGACTACGACGATCATCGATCGATCGATCGATCGATCGATCGATCGTACTACGATCGATCG
> seq5
ACGACTACGACGATCATCGATCGATCGATCGATCGATCGATCGATCGTACTACGATCGATCG
> seq6
ACGACTACGACGATCATCGATCGATCGATCGATCGATCGATCGATCGTACTACGATCGATCG
> seq7
ACGACTACGACGATCATCGATCGATCGATCGATCGATCGATCGATCGTACTACGATCGATCG
> seq8
ACGACTACGACGATCATCGATCGATCGATCGATCGATCGATCGATCGTACTACGATCGATCG
> seq9
ACGACTACGACGATCATCGATCGATCGATCGATCGATCGATCGATCGTACTACGATCGATCG
> seq10
ACGACTACGACGATCATCGATCGATCGATCGATCGATCGATCGATCGTACTACGATCGATCG
> seq11
ACGACTACGACGATCATCGATCGATCGATCGATCGATCGATCGATCGTACTACGATCGATCG
> seq12
ACGACTACGACGATCATCGATCGATCGATCGATCGATCGATCGATCGTACTACGATCGATCG
)";
 
int main()
{
    // initialise random number generator, only needed for demonstration purposes
    std::srand(std::time(nullptr));
 
    // create an input file from the string above
    seqan3::sequence_file_input fin{std::istringstream{fasta_file}, seqan3::format_fasta{}};
 
    // create the async buffer around the input file
    // spawns a background thread that tries to keep four records in the buffer
    auto v = fin | seqan3::views::async_input_buffer(4);
 
    // create a lambda function that iterates over the async buffer when called
    // (the buffer gets dynamically refilled as soon as possible)
    auto worker = [&v]()
    {
        for (auto & record : v)
        {
            // pretend we are doing some work
            std::this_thread::sleep_for(std::chrono::milliseconds(std::rand() % 1000));
            // print current thread and sequence ID
            seqan3::debug_stream << "Thread: " << std::this_thread::get_id() << '\t' << "Seq:    " << record.id()
                                 << '\n';
        }
    };
 
    // launch two threads and pass the lambda function to both
    auto f0 = std::async(std::launch::async, worker);
    auto f1 = std::async(std::launch::async, worker);
}

#include <string>
 
#include <seqan3/core/debug_stream.hpp>
#include <seqan3/io/views/detail/take_exactly_view.hpp>
 
int main()
{
    std::string vec{"foobar"};
    auto v = vec | seqan3::detail::take_exactly(3);       // or seqan3::detail::take_exactly_or_throw
    seqan3::debug_stream << v << '\n';                    // "foo"
    seqan3::debug_stream << std::ranges::size(v) << '\n'; // 3
 
    auto v2 = vec | seqan3::detail::take_exactly(9);
    seqan3::debug_stream << std::ranges::size(v2) << '\n'; // 9 <- here be dragons! (undefined behaviour)
}

#include <ranges>
#include <string>
 
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    std::views::take_while(
        [](auto const & l)
        {
            return (l != '\r') && (l != '\n');
        });
}

#include <string>
 
#include <seqan3/core/debug_stream.hpp>
#include <seqan3/io/views/detail/take_line_view.hpp>
 
int main()
{
    std::string vec{"foo\nbar"};