| ►Nseqan3 | The main SeqAn3 namespace |
| ►Nalign_cfg | A special sub namespace for the alignment configurations |
| ►Ndetail | |
| Cresult_type | Configuration element capturing the configured seqan3::alignment_result for the alignment algorithm |
| 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 |
| ►Nexposition_only | A namespace for SeqAn entities that are intended for documentation purposes only |
| Ccigar_operation | The actual implementation of seqan3::cigar::operation for documentation purposes only |
| ►Nsearch_cfg | A special sub namespace for the search configurations |
| ►Ndetail | |
| Cresult_type | Configuration element storing the configured seqan3::search_result for the search algorithm |
| 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 |
| Cadvanceable_alignment_coordinate_printer | |
| Cadvanceable_alignment_coordinate_printer< detail::advanceable_alignment_coordinate< state_t > > | The printer for seqan3::detail::advanceable_alignment_coordinate |
| ►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_matrix_printer | |
| Calignment_matrix_printer< alignment_matrix_t > | The printer for alignment scoring and trace matrices |
| Calignment_printer | |
| Calignment_printer< alignment_t > | The printer for alignment |
| Calignment_result | Stores the alignment results and gives access to score, alignment and the front and end positions |
| Calignment_result_printer | |
| Calignment_result_printer< alignment_result< result_value_t > > | The printer used for formatted output of the alignment result |
| Calphabet_base | A CRTP-base that makes defining a custom alphabet easier |
| Calphabet_printer | |
| Calphabet_printer< alphabet_t > | The printer used for formatted output of seqan3::alphabet types |
| 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 |
| Cbitpacked_sequence | A space-optimised version of std::vector that compresses multiple letters into a single byte |
| Cbloom_filter | The Bloom Filter. A data structure that efficiently answers set-membership queries |
| Cchar_sequence_printer | |
| Cchar_sequence_printer< char_sequence_t > | A printer for character sequences |
| Ccigar | The seqan3::cigar semialphabet pairs a counter with a seqan3::cigar::operation letter |
| Ccigar_clipped_bases | Helper struct to specialise soft and hard clipping when using seqan3::cigar_from_alignment |
| Ccigar_printer | |
| Ccigar_printer< cigar > | The printer used for formatted output of the cigar alphabets |
| Cconcatenated_sequences | Container that stores sequences concatenated internally |
| Cconfiguration | Collection of elements to configure an algorithm |
| 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_type::bulk_contains |
| Cdebug_stream_printer | |
| Cdebug_stream_printer< value_t > | A struct that provides a debug stream printer for a specific value type |
| Cdebug_stream_type | A "pretty printer" for most SeqAn data structures and related types |
| Cdefault_printer | The default printer that is used by seqan3::debug_stream |
| 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) |
| Cdna15 | The 15 letter DNA alphabet, containing all IUPAC smybols minus the gap |
| Cdna16sam | A 16 letter DNA alphabet, containing all IUPAC symbols minus the gap and plus an equality sign ('=') |
| 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 |
| Cdynamic_bitset_printer | |
| Cdynamic_bitset_printer< dynamic_bitset< bit_capacity > > | Prints seqan3::dynamic_bitset. This entity is experimental and subject to change in the future. Experimental since version 3.1. |
| Cenumeration_printer | |
| Cenumeration_printer< enum_t > | A type (e.g. an enum) can be made debug streamable by customizing the seqan3::enumeration_names |
| 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_erase_failure | Thrown in function seqan3::erase_gap, if a position does not contain a gap |
| Chamming_scoring_scheme | A scoring scheme that assigns a score of 0 to matching letters and -1 to mismatching letters |
| 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 |
| Cinput_range_printer | |
| Cinput_range_printer< rng_t > | A printer for arbitrary input ranges |
| Cinteger_sequence_printer | |
| Cinteger_sequence_printer< integer_sequence_t > | A printer for integer sequences |
| Cintegral_printer | |
| Cintegral_printer< integral_t > | The printer for integral types |
| ►Cinterleaved_bloom_filter | The IBF binning directory. A data structure that efficiently answers set-membership queries for multiple bins |
| Ccounting_agent_type | Manages counting ranges of values for the seqan3::interleaved_bloom_filter |
| ►Cmembership_agent_type | 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 (unary_type_trait specialisation) |
| Cmask | Implementation of a masked alphabet to be used for tuple composites |
| Cmask_printer | |
| Cmask_printer< mask_t > | The printer used for formatted output of seqan3::mask alphabet |
| 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 |
| Cno_printer_found | A tag that indicates that no printer was found for the given type |
| 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 |
| Coptional_printer | |
| Coptional_printer< std::nullopt_t > | Printer for formatted output of std::nullopt_t |
| Coptional_printer< std::optional< T > > | Printer for formatted output of a std::optional |
| 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 |
| Cparse_error | Thrown if there is a parse error, such as reading an unexpected character from an input stream |
| Cphred42 | Quality type for traditional Sanger and modern Illumina Phred scores |
| Cphred63 | Quality type for traditional Sanger and modern Illumina Phred scores |
| Cphred68solexa | Quality type for Solexa and deprecated Illumina formats |
| Cphred94 | Quality type for PacBio Phred scores of HiFi reads |
| Cphred_base | A CRTP-base that refines seqan3::alphabet_base and is used by the quality alphabets |
| Cpipeable_config_element | Adds pipe interface to configuration elements |
| Cpod_tuple | |
| Cpod_tuple< type0 > | Recursion anchor for seqan3::pod_tuple |
| Cpod_tuple< type0, types... > | Behaves like std::tuple but is an aggregate PODType |
| Cprinter_order | The printer_order is a variadic template that defines the order of the printers |
| Cqualified | Joins an arbitrary alphabet with a quality alphabet |
| 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 a std::tuple |
| Cref_info_not_given | Type tag which indicates that no reference information has been passed to the SAM file on construction |
| 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 |
| Csam_file_header | Stores the header information of SAM/BAM files |
| Csam_file_input | A class for reading SAM files, both SAM and its binary representation BAM are supported |
| Csam_file_input_default_traits | The default traits for seqan3::sam_file_input |
| Csam_file_input_format | The generic concept for alignment file input formats |
| Csam_file_input_options | The options type defines various option members that influence the behaviour of all or some formats |
| Csam_file_output | A class for writing SAM files, both SAM and its binary representation BAM are supported |
| Csam_file_output_format | The generic concept for alignment file out formats |
| Csam_file_output_options | The options type defines various option members that influence the behavior of all or some formats |
| Csam_file_program_info_t | Stores information of the program/tool that was used to create a SAM/BAM file |
| Csam_flag_printer | |
| Csam_flag_printer< sam_flag > | A sam_flag can be printed as an integer value |
| Csam_record | The record type of seqan3::sam_file_input |
| 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 |
| Csearch_result_printer | |
| Csearch_result_printer< search_result< specs_t... > > | The printer used for formatted output of the search result |
| 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_format | The generic concept for sequence file in formats |
| 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_format | The generic concept for sequence file out formats |
| Csequence_file_output_options | The options type defines various option members that influence the behaviour of all or some formats |
| Csequence_printer | |
| Csequence_printer< sequence_t > | A printer for (biological) sequences |
| Csequence_record | The record type of seqan3::sequence_file_input |
| Cshape | A class that defines which positions of a pattern to hash |
| Csimd_printer | |
| 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 |
| Cstd_byte_printer | |
| Cstd_byte_printer< std::byte > | A std::byte can be printed by printing its value as integer |
| Cstd_printer | |
| Cstd_printer< type_t > | The printer for standard output streams |
| Cstd_variant_printer | |
| Cstd_variant_printer< std::variant< variant_ts... > > | A std::variant can be printed by visiting the stream operator for the corresponding type |
| Cstrong_type_printer | |
| 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_format | The generic concept for structure file in formats |
| 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_format | The generic concept for structure file out formats |
| Cstructure_file_output_options | The options type defines various option members that influence the behaviour of all or some formats |
| Cstructure_record | The record type of seqan3::structure_file_input |
| 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 |
| Csuffix_array_interval | The underlying suffix array interval |
| 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 |
| Ctrace_directions_printer | |
| Ctrace_directions_printer< detail::trace_directions > | Prints trace_directions as ascii or as utf8 to output stream |
| Ctuple_printer | |
| Ctuple_printer< tuple_t > | Printer for formatted output of tuple like objects |
| Ctype_list | Type that contains multiple types |
| 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 |
| 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 |
| Cvalue_list_validator | A validator that checks whether a value is inside a list of valid values |
| 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::sam_record< field_types, field_ids > > | Obtains the type of the specified element |
| Ctuple_element< elem_no, seqan3::sequence_record< field_types, field_ids > > | Obtains the type of the specified element |
| Ctuple_element< elem_no, seqan3::structure_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::sam_record< field_types, field_ids > > | Provides access to the number of elements in a tuple as a compile-time constant expression |
| Ctuple_size< seqan3::sequence_record< field_types, field_ids > > | Provides access to the number of elements in a tuple as a compile-time constant expression |
| Ctuple_size< seqan3::structure_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 |
| 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> |
| 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 |
| Cenum_bitwise_operators | You can expect these functions on all types that overload seqan3::add_enum_bitwise_operators |
| Cexplicitly_convertible_to | Checks whether from can be explicitly converted to to |
| Cimplicitly_convertible_to | Checks whether from can be implicityly converted to to |
| Cinput_stream_over | Concept for input streams |
| Cnamed_enumeration | Checks whether the free function seqan3::enumeration_names can be called on the type |
| Cnonrecursive_range | A concept that checks whether a range is non-recursive |
| 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 |
| Cprintable_with | The concept for a printable object |
| 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 |
| 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 |
| Csam_file_input_traits | The requirements a traits_type for seqan3::sam_file_input must meet |
| 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 (biological) sequence |
| Csequence_container | A more refined container concept than seqan3::container |
| Csequence_file_input_traits | The requirements a traits_type for seqan3::sequence_file_input must meet |
| Cstandard_layout | Resolves to std::is_standard_layout_v<t> |
| Cstructure_file_input_traits | The requirements a traits_type for seqan3::structure_file_input must meet |
| 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.9.8 