| ►Nseqan3 | The main SeqAn3 namespace |
| ►Nalign_cfg | A special sub namespace for the alignment configurations |
| Cband_fixed_size | Configuration element for setting a fixed size band |
| Cextension_score | A strong type of underlying type int32_t that represents the score (usually negative) of any character against a gap character |
| Cfree_end_gaps_sequence1_leading | A strong type representing free_end_gaps_sequence1_leading of the seqan3::align_cfg::method_global |
| Cfree_end_gaps_sequence1_trailing | A strong type representing free_end_gaps_sequence1_trailing of the seqan3::align_cfg::method_global |
| Cfree_end_gaps_sequence2_leading | A strong type representing free_end_gaps_sequence2_leading of the seqan3::align_cfg::method_global |
| Cfree_end_gaps_sequence2_trailing | A strong type representing free_end_gaps_sequence2_trailing of the seqan3::align_cfg::method_global |
| Cgap_cost_affine | A configuration element for the affine gap cost scheme |
| Clower_diagonal | A strong type representing the lower diagonal of the seqan3::align_cfg::band_fixed_size |
| Cmethod_global | Sets the global alignment method |
| Cmethod_local | Sets the local alignment method |
| Cmin_score | Sets the minimal score (maximal errors) allowed during an distance computation e.g. edit distance |
| Con_result | Configuration element to provide a user defined callback function for the alignment |
| Copen_score | A strong type of underlying type int32_t that represents a score (usually negative) that is incurred once per stretch of consecutive gaps |
| Coutput_alignment | Configures the alignment result to output the alignment |
| Coutput_begin_position | Configures the alignment result to output the begin positions |
| Coutput_end_position | Configures the alignment result to output the end position |
| Coutput_score | Configures the alignment result to output the score |
| Coutput_sequence1_id | Configures the alignment result to output the id of the first sequence |
| Coutput_sequence2_id | Configures the alignment result to output the id of the second sequence |
| Cscore_type | A configuration element to set the score type used in the alignment algorithm |
| Cscoring_scheme | Sets the scoring scheme for the alignment algorithm |
| Cupper_diagonal | A strong type representing the upper diagonal of the seqan3::align_cfg::band_fixed_size |
| Cvectorised | Enables the vectorised alignment computation if possible for the current configuration |
| ►Ncustom | A namespace for third party and standard library specialisations of SeqAn customisation points |
| Calphabet | A type that can be specialised to provide customisation point implementations so that third party types model alphabet concepts |
| Calphabet< char_type > | Alphabet specific customisations for builtin char types |
| Calphabet< uint_type > | Alphabet specific customisations for unsigned integral types |
| Cargument_parsing | A type that can be specialised to provide customisation point implementations for the seqan3::argument_parser such that third party types may be adapted |
| ►Nsearch_cfg | A special sub namespace for the search configurations |
| Cerror_count | A strong type of underlying type uint8_t that represents the number of errors |
| Cerror_rate | A strong type of underlying type double that represents the rate of errors |
| Chit | A dynamic configuration element to configure the hit strategy at runtime |
| Chit_all | Configuration element to receive all hits within the error bounds |
| Chit_all_best | Configuration element to receive all hits with the lowest number of errors within the error bounds |
| Chit_single_best | Configuration element to receive a single best hit with the lowest number of errors within the error bounds |
| Chit_strata | Configuration element to receive all hits with the best number of errors plus the given stratum. All hits are found with the fewest number of errors plus 'stratum' |
| Cmax_error_deletion | Configuration element that represents the number or rate of deletion errors |
| Cmax_error_insertion | Configuration element that represents the number or rate of insertion errors |
| Cmax_error_substitution | Configuration element that represents the number or rate of substitution errors |
| Cmax_error_total | Configuration element that represents the number or rate of total errors |
| Con_result | Configuration element to provide a user defined callback function for the search |
| Coutput_index_cursor | Include the index_cursor in the seqan3::search_result returned by a call to seqan3::search |
| Coutput_query_id | Include the query_id in the seqan3::search_result returned by a call to seqan3::search |
| Coutput_reference_begin_position | Include the reference_begin_position in the seqan3::search_result returned by a call to seqan3::search |
| Coutput_reference_id | Include the reference_id in the seqan3::search_result returned by a call to seqan3::search |
| ►Nviews | The SeqAn namespace for views |
| Cdeep | A wrapper type around an existing view adaptor that enables "deep view" behaviour for that view |
| Caa10li | The reduced Li amino acid alphabet |
| Caa10murphy | The reduced Murphy amino acid alphabet |
| Caa20 | The canonical amino acid alphabet |
| Caa27 | The twenty-seven letter amino acid alphabet |
| ►Calgorithm_result_generator_range | An input range over the algorithm results generated by the underlying algorithm executor |
| Calgorithm_range_iterator | The iterator of seqan3::detail::algorithm_result_generator_range |
| ►Caligned_allocator | Allocates uninitialized storage whose memory-alignment is specified by alignment |
| Crebind | The aligned_allocator member template class aligned_allocator::rebind provides a way to obtain an allocator for a different type |
| Calignment_coordinate | Represents the begin/end of the pairwise alignment in the respective sequences |
| ►Calignment_file_header | Stores the header information of alignment files |
| Cprogram_info_t | Stores information of the program/tool that was used to create the file |
| Calignment_file_input | A class for reading alignment files, e.g. SAM, BAM, BLAST .. |
| Calignment_file_input_default_traits | The default traits for seqan3::alignment_file_input |
| Calignment_file_input_options | The options type defines various option members that influence the behaviour of all or some formats |
| Calignment_file_output | A class for writing alignment files, e.g. SAM, BAL, BLAST, .. |
| Calignment_file_output_options | The options type defines various option members that influence the behavior of all or some formats |
| Calignment_result | Stores the alignment results and gives access to score, alignment and the front and end positionss |
| Calphabet_base | A CRTP-base that makes defining a custom alphabet easier |
| Calphabet_base< derived_type, 1ul, char_t > | Specialisation of seqan3::alphabet_base for alphabets of size 1 |
| Calphabet_proxy | A CRTP-base that eases the definition of proxy types returned in place of regular alphabets |
| Calphabet_tuple_base | The CRTP base for a combined alphabet that contains multiple values of different alphabets at the same time |
| Calphabet_variant | A combined alphabet that can hold values of either of its alternatives |
| Caminoacid_base | A CRTP-base that refines seqan3::alphabet_base and is used by the amino acids |
| Caminoacid_empty_base | This is an empty base class that can be inherited by types that shall model seqan3::aminoacid_alphabet |
| Caminoacid_scoring_scheme | A data structure for managing and computing the score of two amino acids |
| Cargument_parser | The SeqAn command line parser |
| Cargument_parser_error | Argument parser exception that is thrown whenever there is an error while parsing the command line arguments |
| Cargument_parser_meta_data | Stores all parser related meta information of the seqan3::argument_parser |
| Carithmetic_range_validator | A validator that checks whether a number is inside a given range |
| Cbi_fm_index | The SeqAn Bidirectional FM Index |
| Cbi_fm_index_cursor | The SeqAn Bidirectional FM Index Cursor |
| Cbin_count | A strong type that represents the number of bins for the seqan3::interleaved_bloom_filter |
| Cbin_index | A strong type that represents the bin index for the seqan3::interleaved_bloom_filter |
| Cbin_literal | A strong type of underlying type uint64_t that represents the shape in binary representation |
| Cbin_size | A strong type that represents the number of bits for each bin in the seqan3::interleaved_bloom_filter |
| Cbitcompressed_vector | A space-optimised version of std::vector that compresses multiple letters into a single byte |
| Ccigar | The cigar semialphabet pairs a counter with a seqan3::cigar_op letter |
| Ccigar_op | The (extended) cigar operation alphabet of M,D,I,H,N,P,S,X,= |
| Cconcatenated_sequences | Container that stores sequences concatenated internally |
| Cconfiguration | Collection of elements to configure an algorithm |
| Cconst_reference | Exposes the const_reference of another type |
| Ccounting_vector | A data structure that behaves like a std::vector and can be used to consolidate the results of multiple calls to seqan3::interleaved_bloom_filter::membership_agent::bulk_contains |
| Cdebug_stream_type | A "pretty printer" for most SeqAn data structures and related types |
| Cdesign_error | Argument parser exception that is thrown whenever there is an design error directed at the developer of the application (e.g. Reuse of option) |
| Cdifference_type | Exposes the difference_type of another type |
| Cdna15 | The 15 letter DNA alphabet, containing all IUPAC smybols minus the gap |
| Cdna3bs | The three letter reduced DNA alphabet for bisulfite sequencing mode (A,G,T(=C)) |
| Cdna4 | The four letter DNA alphabet of A,C,G,T |
| Cdna5 | The five letter DNA alphabet of A,C,G,T and the unknown character N |
| Cdot_bracket3 | The three letter RNA structure alphabet of the characters ".()" |
| Cdssp9 | The protein structure alphabet of the characters "HGIEBTSCX" |
| Cdynamic_bitset | A constexpr bitset implementation with dynamic size at compile time |
| Cfields | A class template that holds a choice of seqan3::field |
| Cfile_open_error | Thrown if there is an unspecified filesystem or stream error while opening, e.g. permission problem |
| Cfile_validator_base | An abstract base class for the file and directory validators |
| Cfm_index | The SeqAn FM Index |
| Cfm_index_cursor | The SeqAn FM Index Cursor |
| Cformat_bam | The BAM format |
| Cformat_embl | The EMBL format |
| Cformat_error | Thrown if information given to output format didn't match expectations |
| Cformat_fasta | The FastA format |
| Cformat_fastq | The FastQ format |
| Cformat_genbank | The GenBank format |
| Cformat_sam | The SAM format (tag) |
| Cformat_vienna | The Vienna format (dot bracket notation) for RNA sequences with secondary structure |
| Cfunction_traits< std::function< return_t(args_t...)> > | A traits class to provide a uniform interface to the properties of a function type |
| Cgap | The alphabet of a gap character '-' |
| ►Cgap_decorator | A gap decorator allows the annotation of sequences with gap symbols while leaving the underlying sequence unmodified |
| Cgap_decorator_iterator | The iterator type over a seqan3::gap_decorator |
| Cgap_erase_failure | Thrown in function seqan3::erase_gap, if a position does not contain a gap |
| Cgap_open_score | A strong type of underlying type score_type that represents an additional score (usually negative) that is incurred once additionaly per stretch of consecutive gaps |
| Cgap_scheme | A scheme for representing and computing scores against gap characters |
| Cgap_score | A strong type of underlying type score_type that represents the score of any character against a gap character |
| Chash_function_count | A strong type that represents the number of hash functions for the seqan3::interleaved_bloom_filter |
| Cinput_directory_validator | A validator that checks if a given path is a valid input directory |
| Cinput_file_validator | A validator that checks if a given path is a valid input file |
| ►Cinterleaved_bloom_filter | The IBF binning directory. A data structure that efficiently answers set-membership queries for multiple bins |
| ►Cmembership_agent | Manages membership queries for the seqan3::interleaved_bloom_filter |
| Cbinning_bitvector | A bitvector representing the result of a call to bulk_contains of the seqan3::interleaved_bloom_filter |
| Cinvalid_alignment_configuration | Thrown if the configuration of the alignment algorithm is invalid |
| Cinvalid_char_assignment | An exception typically thrown by seqan3::alphabet::assign_char_strict |
| Cio_error | Thrown if there is an io error in low level io operations such as in std::basic_streambuf operations |
| Cis_constexpr_default_constructible | Whether a type std::is_default_constructible in constexpr-context |
| Cis_constexpr_default_constructible< t > | Whether a type std::is_default_constructible in constexpr-context (unary_type_trait specialisation) |
| Cis_execution_policy | Test whether a class represents an execution policy |
| Clower_bound | Type for a lower boundary |
| Cmask | Implementation of a masked alphabet to be used for tuple composites |
| Cmasked | Implementation of a masked composite, which extends a given alphabet with a mask |
| Cmatch_score | A strong type of underlying type score_type that represents the score of two matching characters |
| Cmismatch_score | A strong type of underlying type score_type that represents the score two different characters |
| Cnucleotide_base | A CRTP-base that refines seqan3::alphabet_base and is used by the nucleotides |
| Cnucleotide_scoring_scheme | A data structure for managing and computing the score of two nucleotides |
| Coption_declared_multiple_times | Argument parser exception thrown when a non-list option is declared multiple times |
| Coutput_directory_validator | A validator that checks if a given path is a valid output directory |
| Coutput_file_validator | A validator that checks if a given path is a valid output file |
| Coverflow_error_on_conversion | This class is deprecated |
| Cparallel_policy | Parallel execution policy |
| Cparallel_unsequenced_policy | Parallel and unsequenced execution policy |
| Cparse_error | Thrown if there is a parse error, such as reading an unexpected character from an input stream |
| Cparser_design_error | This class is deprecated |
| Cparser_invalid_argument | This class is deprecated |
| Cphred42 | Quality type for traditional Sanger and modern Illumina Phred scores (typical range) |
| Cphred63 | Quality type for traditional Sanger and modern Illumina Phred scores (full range) |
| Cphred68legacy | Quality type for Solexa and deprecated Illumina formats |
| Cpipeable_config_element< derived_t > | Adds pipe interface to configuration elements |
| Cpod_tuple | Cond |
| Cpod_tuple< type0 > | Recursion anchor for pod_tuple |
| Cpod_tuple< type0, types... > | Behaves like std::tuple but is an aggregate PODType |
| Cqualified | Joins an arbitrary alphabet with a quality alphabet |
| Cquality_base | A CRTP-base that refines seqan3::alphabet_base and is used by the quality alphabets |
| Crange_innermost_value | Recursively determines the value_type on containers and/or iterators |
| Crecord | The class template that file records are based on; behaves like an std::tuple |
| Cref_info_not_given | Type tag which indicates that no reference information has been passed to the alignment file on construction |
| Creference | Exposes the reference of another type |
| Cregex_validator | A validator that checks if a matches a regular expression pattern |
| Cremove_rvalue_reference | Return the input type with && removed, but lvalue references preserved |
| Crequired_option_missing | Argument parser exception thrown when a required option is missing |
| Crna15 | The 15 letter RNA alphabet, containing all IUPAC smybols minus the gap |
| Crna4 | The four letter RNA alphabet of A,C,G,U |
| Crna5 | The five letter RNA alphabet of A,C,G,U and the unknown character N |
| Crvalue_reference | Exposes the rvalue_reference of another type |
| Csam_dna16 | A 16 letter DNA alphabet, containing all IUPAC symbols minus the gap and plus an equality sign ('=') |
| Csam_tag_dictionary | The SAM tag dictionary class that stores all optional SAM fields |
| Csam_tag_type | The generic base class |
| Cscoring_scheme_base | A CRTP base class for scoring schemes |
| Csearch_result | The result class generated by the seqan3::seach algorithm |
| Cseed | Strong_type for seed |
| Csemialphabet_any | A semi-alphabet that type erases all other semi-alphabets of the same size |
| Csequence_file_input | A class for reading sequence files, e.g. FASTA, FASTQ .. |
| Csequence_file_input_default_traits_aa | A traits type that specifies input as amino acids |
| Csequence_file_input_default_traits_dna | The default traits for seqan3::sequence_file_input |
| Csequence_file_input_options | The options type defines various option members that influence the behaviour of all or some formats |
| Csequence_file_output | A class for writing sequence files, e.g. FASTA, FASTQ .. |
| Csequence_file_output_options | The options type defines various option members that influence the behaviour of all or some formats |
| Csequenced_policy | Sequenced execution policy |
| Cshape | A class that defines which positions of a pattern to hash |
| Csize_type | Exposes the size_type of another type |
| Csmall_string | Implements a small string that can be used for compile time computations |
| Csmall_vector | A constexpr vector implementation with dynamic size at compile time |
| Cstatic_band | Data structure for a static band |
| Cstructure_file_input | A class for reading structured sequence files, e.g. Stockholm, Connect, Vienna, ViennaRNA bpp matrix .. |
| Cstructure_file_input_default_traits_aa | A traits type that specifies input as amino acids |
| Cstructure_file_input_default_traits_rna | The default traits for seqan3::structure_file_input |
| Cstructure_file_input_options | The options type defines various option members that influence the behaviour of all or some formats |
| Cstructure_file_output | A class for writing structured sequence files, e.g. Stockholm, Connect, Vienna, ViennaRNA bpp matrix .. |
| Cstructure_file_output_options | The options type defines various option members that influence the behaviour of all or some formats |
| Cstructured_aa | A seqan3::alphabet_tuple_base that joins an aminoacid alphabet with a protein structure alphabet |
| Cstructured_rna | A seqan3::alphabet_tuple_base that joins a nucleotide alphabet with an RNA structure alphabet |
| Ctoo_few_arguments | Argument parser exception thrown when too few arguments are provided |
| Ctoo_many_arguments | Argument parser exception thrown when too many arguments are provided |
| Ctype_conversion_failed | This class is deprecated |
| Cunexpected_end_of_input | Thrown if I/O was expecting more input (e.g. a delimiter or a new line), but the end of input was reached |
| Cungapped | A strong type of underlying type uint8_t that represents the ungapped shape size |
| Cunhandled_extension_error | Thrown if there is no format that accepts a given file extension |
| Cunknown_option | Argument parser exception thrown when encountering unknown option |
| Cunsequenced_policy | Unsequenced execution policy |
| Cupper_bound | Type for an upper boundary |
| Cuser_input_error | Argument parser exception thrown when an incorrect argument is given as (positional) option value |
| Cvalidation_error | Argument parser exception thrown when an argument could not be casted to the according type |
| Cvalidation_failed | This class is deprecated |
| Cvalue_list_validator | A validator that checks whether a value is inside a list of valid values |
| Cvalue_type | Exposes the value_type of another type |
| Cwindow_size | Strong_type for the window_size |
| Cwuss | The WUSS structure alphabet of the characters .<>:,-_~;()[]{}AaBbCcDd.. |
| ►Nstd | SeqAn specific customisations in the standard namespace |
| Chash< alphabet_t > | Struct for hashing a character |
| Chash< seqan3::dynamic_bitset< cap > > | Struct for hashing a seqan3::dynamic_bitset |
| Chash< urng_t > | Struct for hashing a range of characters |
| Ctuple_element< elem_no, seqan3::alignment_file_input< traits_type, selected_field_ids, valid_formats > > | Obtains the type of the specified element |
| Ctuple_element< elem_no, seqan3::record< field_types, field_ids > > | Obtains the type of the specified element |
| Ctuple_element< i, t< types... > > | Obtains the type of the specified element |
| Ctuple_element< i, tuple_t > | Obtains the type of the specified element |
| Ctuple_size< seqan3::alignment_file_input< traits_type, selected_field_ids, valid_formats > > | Provides access to the number of elements in a tuple as a compile-time constant expression |
| Ctuple_size< seqan3::record< field_types, field_ids > > | Provides access to the number of elements in a tuple as a compile-time constant expression |
| Ctuple_size< t< types... > > | Provides access to the number of elements in a tuple as a compile-time constant expression |
| Ctuple_size< tuple_t > | Provides access to the number of elements in a tuple as a compile-time constant expression |
| Caligned_sequence | The generic concept for an aligned sequence |
| Calignment_file_input_format | The generic concept for alignment file input formats |
| Calignment_file_input_traits | The requirements a traits_type for seqan3::alignment_file_input must meet |
| Calignment_file_output_format | The generic concept for alignment file out formats |
| Calphabet | The generic alphabet concept that covers most data types used in ranges |
| Caminoacid_alphabet | A concept that indicates whether an alphabet represents amino acids |
| Cargument_parser_compatible_option | Checks whether the the type can be used in an add_(positional_)option call on the argument parser |
| Carithmetic | A type that satisfies std::is_arithmetic_v<t> |
| Cbi_fm_index_cursor_specialisation | Concept for bidirectional FM index cursors |
| Cbi_fm_index_specialisation | Concept for bidirectional FM indices |
| Cbuiltin_character | This concept encompasses exactly the types char, signed char, unsigned char, wchar_t, char16_t and char32_t |
| Ccereal_archive | All archives of the Cereal library satisfy this |
| Ccereal_input_archive | All input archives of the Cereal library satisfy this |
| Ccereal_output_archive | All output archives of the Cereal library satisfy this |
| Ccereal_text_archive | All text archives of the Cereal library satisfy this |
| Ccerealisable | Specifies the requirements for types that are serialisable via Cereal |
| Cconst_iterable_range | Specifies requirements of an input range type for which the const version of that type satisfies the same strength input range concept as the non-const version |
| Ccontainer | The (most general) container concept as defined by the standard library |
| Cexplicitly_convertible_to | Resolves to std::ranges::explicitly_convertible_to<type1, type2>() |
| Cfloating_point | An arithmetic type that also satisfies std::is_floating_point_v<t> |
| Cfm_index_cursor_specialisation | Concept for unidirectional FM index cursors |
| Cfm_index_specialisation | Concept for unidirectional FM indices |
| Cimplicitly_convertible_to | Resolves to std::ranges::implicitly_convertible_to<type1, type2>() |
| Cinput_stream_over | Concept for input streams |
| Cnamed_enumeration | Checks whether the free function seqan3::enumeration_names can be called on the type |
| Cnucleotide_alphabet | A concept that indicates whether an alphabet represents nucleotides |
| Coutput_stream_over | Concept for output streams |
| Cpair_like | Whether a type behaves like a tuple with exactly two elements |
| Cpseudo_random_access_iterator | This concept checks if an iterator type models pseudo random access |
| Cpseudo_random_access_range | This concept checks if a type models a pseudo random access range |
| Cquality_alphabet | A concept that indicates whether an alphabet represents quality scores |
| Crandom_access_container | A more refined container concept than seqan3::sequence_container |
| Crange_compatible | Two types are "compatible" if their seqan3::range_dimension_v and their seqan3::range_innermost_value_t are the same |
| Creservible_container | A more refined container concept than seqan3::random_access_container |
| Crna_structure_alphabet | A concept that indicates whether an alphabet represents RNA structure |
| Cscoring_scheme_for | A concept that requires that type be able to score two letters |
| Csemialphabet | The basis for seqan3::alphabet, but requires only rank interface (not char) |
| Csequence | The generic concept for a sequence |
| Csequence_container | A more refined container concept than seqan3::container |
| Csequence_file_input_format | The generic concept for sequence file in formats |
| Csequence_file_input_traits | The requirements a traits_type for seqan3::sequence_file_input must meet |
| Csequence_file_output_format | The generic concept for sequence file out formats |
| Cstandard_layout | Resolves to std::is_standard_layout_v<t> |
| Cstream_REMOVEME | Concept for i/o streams permitting both directions |
| Cstructure_file_input_format | The generic concept for structure file in formats |
| Cstructure_file_input_traits | The requirements a traits_type for seqan3::structure_file_input must meet |
| Cstructure_file_output_format | The generic concept for structure file out formats |
| Ctransformation_trait | Concept for a transformation trait |
| Ctrivial | A type that satisfies seqan3::trivially_copyable and seqan3::trivially_destructible |
| Ctrivially_copyable | A type that satisfies std::is_trivially_copyable_v<t> |
| Ctrivially_destructible | A type that satisfies std::is_trivially_destructible_v<t> |
| Ctuple_like | Whether a type behaves like a tuple |
| Cunary_type_trait | Concept for a unary traits type |
| Cvalidator | The concept for option validators passed to add_option/positional_option |
| Cweakly_assignable_from | Resolves to std::is_assignable_v<t> |
| Cwritable_aligned_sequence | The generic concept for an aligned sequence that is writable |
| Cwritable_alphabet | Refines seqan3::alphabet and adds assignability |
| Cwritable_quality_alphabet | A concept that indicates whether a writable alphabet represents quality scores |
| Cwritable_semialphabet | A refinement of seqan3::semialphabet that adds assignability |
1.8.20