Loading...
Searching...
No Matches
Class List
Here are the classes, structs, unions and interfaces with brief descriptions:

seqan3 | The main SeqAn3 namespace
align_cfg | A special sub namespace for the alignment configurations
detail |
result_type | Configuration element capturing the configured seqan3::alignment_result for the alignment algorithm
band_fixed_size | Configuration element for setting a fixed size band
extension_score | A strong type of underlying type int32_t that represents the score (usually negative) of any character against a gap character
free_end_gaps_sequence1_leading | A strong type representing free_end_gaps_sequence1_leading of the seqan3::align_cfg::method_global
free_end_gaps_sequence1_trailing | A strong type representing free_end_gaps_sequence1_trailing of the seqan3::align_cfg::method_global
free_end_gaps_sequence2_leading | A strong type representing free_end_gaps_sequence2_leading of the seqan3::align_cfg::method_global
free_end_gaps_sequence2_trailing | A strong type representing free_end_gaps_sequence2_trailing of the seqan3::align_cfg::method_global
gap_cost_affine | A configuration element for the affine gap cost scheme
lower_diagonal | A strong type representing the lower diagonal of the seqan3::align_cfg::band_fixed_size
method_global | Sets the global alignment method
method_local | Sets the local alignment method
min_score | Sets the minimal score (maximal errors) allowed during an distance computation e.g. edit distance
on_result | Configuration element to provide a user defined callback function for the alignment
open_score | A strong type of underlying type int32_t that represents a score (usually negative) that is incurred once per stretch of consecutive gaps
output_alignment | Configures the alignment result to output the alignment
output_begin_position | Configures the alignment result to output the begin positions
output_end_position | Configures the alignment result to output the end position
output_score | Configures the alignment result to output the score
output_sequence1_id | Configures the alignment result to output the id of the first sequence
output_sequence2_id | Configures the alignment result to output the id of the second sequence
score_type | A configuration element to set the score type used in the alignment algorithm
scoring_scheme | Sets the scoring scheme for the alignment algorithm
upper_diagonal | A strong type representing the upper diagonal of the seqan3::align_cfg::band_fixed_size
vectorised | Enables the vectorised alignment computation if possible for the current configuration
custom | A namespace for third party and standard library specialisations of SeqAn customisation points
alphabet | A type that can be specialised to provide customisation point implementations so that third party types model alphabet concepts
alphabet< char_type > | Alphabet specific customisations for builtin char types
alphabet< uint_type > | Alphabet specific customisations for unsigned integral types
argument_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
exposition_only | A namespace for SeqAn entities that are intended for documentation purposes only
cigar_operation | The actual implementation of seqan3::cigar::operation for documentation purposes only
search_cfg | A special sub namespace for the search configurations
detail |
result_type | Configuration element storing the configured seqan3::search_result for the search algorithm
error_count | A strong type of underlying type uint8_t that represents the number of errors
error_rate | A strong type of underlying type double that represents the rate of errors
hit | A dynamic configuration element to configure the hit strategy at runtime
hit_all | Configuration element to receive all hits within the error bounds
hit_all_best | Configuration element to receive all hits with the lowest number of errors within the error bounds
hit_single_best | Configuration element to receive a single best hit with the lowest number of errors within the error bounds
hit_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'
max_error_deletion | Configuration element that represents the number or rate of deletion errors
max_error_insertion | Configuration element that represents the number or rate of insertion errors
max_error_substitution | Configuration element that represents the number or rate of substitution errors
max_error_total | Configuration element that represents the number or rate of total errors
on_result | Configuration element to provide a user defined callback function for the search
output_index_cursor | Include the index_cursor in the seqan3::search_result returned by a call to seqan3::search
output_query_id | Include the query_id in the seqan3::search_result returned by a call to seqan3::search
output_reference_begin_position | Include the reference_begin_position in the seqan3::search_result returned by a call to seqan3::search
output_reference_id | Include the reference_id in the seqan3::search_result returned by a call to seqan3::search
views | The SeqAn namespace for views
deep | A wrapper type around an existing view adaptor that enables "deep view" behaviour for that view
aa10li | The reduced Li amino acid alphabet
aa10murphy | The reduced Murphy amino acid alphabet
aa20 | The canonical amino acid alphabet
aa27 | The twenty-seven letter amino acid alphabet
advanceable_alignment_coordinate_printer |
advanceable_alignment_coordinate_printer< detail::advanceable_alignment_coordinate< state_t > > | The printer for seqan3::detail::advanceable_alignment_coordinate
algorithm_result_generator_range | An input range over the algorithm results generated by the underlying algorithm executor
algorithm_range_iterator | The iterator of seqan3::detail::algorithm_result_generator_range
aligned_allocator | Allocates uninitialized storage whose memory-alignment is specified by alignment
rebind | The aligned_allocator member template class aligned_allocator::rebind provides a way to obtain an allocator for a different type
alignment_matrix_printer |
alignment_matrix_printer< alignment_matrix_t > | The printer for alignment scoring and trace matrices
alignment_printer |
alignment_printer< alignment_t > | The printer for alignment
alignment_result | Stores the alignment results and gives access to score, alignment and the front and end positions
alignment_result_printer |
alignment_result_printer< alignment_result< result_value_t > > | The printer used for formatted output of the alignment result
alphabet_base | A CRTP-base that makes defining a custom alphabet easier
alphabet_printer |
alphabet_printer< alphabet_t > | The printer used for formatted output of seqan3::alphabet types
alphabet_proxy | A CRTP-base that eases the definition of proxy types returned in place of regular alphabets
alphabet_tuple_base | The CRTP base for a combined alphabet that contains multiple values of different alphabets at the same time.
alphabet_variant | A combined alphabet that can hold values of either of its alternatives.
aminoacid_base | A CRTP-base that refines seqan3::alphabet_base and is used by the amino acids
aminoacid_empty_base | This is an empty base class that can be inherited by types that shall model seqan3::aminoacid_alphabet
aminoacid_scoring_scheme | A data structure for managing and computing the score of two amino acids
argument_parser | The SeqAn command line parser
argument_parser_error | Argument parser exception that is thrown whenever there is an error while parsing the command line arguments
argument_parser_meta_data | Stores all parser related meta information of the seqan3::argument_parser
arithmetic_range_validator | A validator that checks whether a number is inside a given range
bi_fm_index | The SeqAn Bidirectional FM Index
bi_fm_index_cursor | The SeqAn Bidirectional FM Index Cursor
bin_count | A strong type that represents the number of bins for the seqan3::interleaved_bloom_filter
bin_index | A strong type that represents the bin index for the seqan3::interleaved_bloom_filter
bin_literal | A strong type of underlying type uint64_t that represents the shape in binary representation
bin_size | A strong type that represents the number of bits for each bin in the seqan3::interleaved_bloom_filter
bitpacked_sequence | A space-optimised version of std::vector that compresses multiple letters into a single byte
bloom_filter | The Bloom Filter. A data structure that efficiently answers set-membership queries
char_sequence_printer |
char_sequence_printer< char_sequence_t > | A printer for character sequences
cigar | The seqan3::cigar semialphabet pairs a counter with a seqan3::cigar::operation letter
cigar_clipped_bases | Helper struct to specialise soft and hard clipping when using seqan3::cigar_from_alignment
cigar_printer |
cigar_printer< cigar > | The printer used for formatted output of the cigar alphabets
concatenated_sequences | Container that stores sequences concatenated internally
configuration | Collection of elements to configure an algorithm
counting_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
debug_stream_printer |
debug_stream_printer< value_t > | A struct that provides a debug stream printer for a specific value type
debug_stream_type | A "pretty printer" for most SeqAn data structures and related types
default_printer | The default printer that is used by seqan3::debug_stream
design_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)
dna15 | The 15 letter DNA alphabet, containing all IUPAC smybols minus the gap
dna16sam | A 16 letter DNA alphabet, containing all IUPAC symbols minus the gap and plus an equality sign ('=')
dna3bs | The three letter reduced DNA alphabet for bisulfite sequencing mode (A,G,T(=C))
dna4 | The four letter DNA alphabet of A,C,G,T
dna5 | The five letter DNA alphabet of A,C,G,T and the unknown character N
dot_bracket3 | The three letter RNA structure alphabet of the characters ".()"
dssp9 | The protein structure alphabet of the characters "HGIEBTSCX"
dynamic_bitset | A constexpr bitset implementation with dynamic size at compile time
dynamic_bitset_printer |

dynamic_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.

enumeration_printer |
enumeration_printer< enum_t > | A type (e.g. an enum) can be made debug streamable by customizing the seqan3::enumeration_names
fields | A class template that holds a choice of seqan3::field
file_open_error | Thrown if there is an unspecified filesystem or stream error while opening, e.g. permission problem
file_validator_base | An abstract base class for the file and directory validators
fm_index | The SeqAn FM Index
fm_index_cursor | The SeqAn FM Index Cursor
format_bam | The BAM format
format_embl | The EMBL format
format_error | Thrown if information given to output format didn't match expectations
format_fasta | The FASTA format
format_fastq | The FASTQ format
format_genbank | The GenBank format
format_sam | The SAM format (tag)
format_vienna | The Vienna format (dot bracket notation) for RNA sequences with secondary structure
function_traits< std::function< return_t(args_t...)> > | A traits class to provide a uniform interface to the properties of a function type
gap | The alphabet of a gap character '-'
gap_decorator | A gap decorator allows the annotation of sequences with gap symbols while leaving the underlying sequence unmodified
gap_erase_failure | Thrown in function seqan3::erase_gap, if a position does not contain a gap
hamming_scoring_scheme | A scoring scheme that assigns a score of 0 to matching letters and -1 to mismatching letters
hash_function_count | A strong type that represents the number of hash functions for the seqan3::interleaved_bloom_filter
input_directory_validator | A validator that checks if a given path is a valid input directory
input_file_validator | A validator that checks if a given path is a valid input file
input_range_printer |
input_range_printer< rng_t > | A printer for arbitrary input ranges
integer_sequence_printer |
integer_sequence_printer< integer_sequence_t > | A printer for integer sequences
integral_printer |
integral_printer< integral_t > | The printer for integral types
interleaved_bloom_filter | The IBF binning directory. A data structure that efficiently answers set-membership queries for multiple bins
counting_agent_type | Manages counting ranges of values for the seqan3::interleaved_bloom_filter
membership_agent_type | Manages membership queries for the seqan3::interleaved_bloom_filter
binning_bitvector | A bitvector representing the result of a call to bulk_contains of the seqan3::interleaved_bloom_filter
invalid_alignment_configuration | Thrown if the configuration of the alignment algorithm is invalid
invalid_char_assignment | An exception typically thrown by seqan3::alphabet::assign_char_strict
io_error | Thrown if there is an io error in low level io operations such as in std::basic_streambuf operations
is_constexpr_default_constructible | Whether a type std::is_default_constructible in constexpr-context (unary_type_trait specialisation)
mask | Implementation of a masked alphabet to be used for tuple composites
mask_printer |
mask_printer< mask_t > | The printer used for formatted output of seqan3::mask alphabet
masked | Implementation of a masked composite, which extends a given alphabet with a mask
match_score | A strong type of underlying type score_type that represents the score of two matching characters
mismatch_score | A strong type of underlying type score_type that represents the score two different characters
no_printer_found | A tag that indicates that no printer was found for the given type
nucleotide_base | A CRTP-base that refines seqan3::alphabet_base and is used by the nucleotides
nucleotide_scoring_scheme | A data structure for managing and computing the score of two nucleotides
option_declared_multiple_times | Argument parser exception thrown when a non-list option is declared multiple times
optional_printer |
optional_printer< std::nullopt_t > | Printer for formatted output of std::nullopt_t
optional_printer< std::optional< T > > | Printer for formatted output of a std::optional
output_directory_validator | A validator that checks if a given path is a valid output directory
output_file_validator | A validator that checks if a given path is a valid output file
parse_error | Thrown if there is a parse error, such as reading an unexpected character from an input stream
phred42 | Quality type for traditional Sanger and modern Illumina Phred scores
phred63 | Quality type for traditional Sanger and modern Illumina Phred scores
phred68solexa | Quality type for Solexa and deprecated Illumina formats
phred94 | Quality type for PacBio Phred scores of HiFi reads
phred_base | A CRTP-base that refines seqan3::alphabet_base and is used by the quality alphabets
pipeable_config_element | Adds pipe interface to configuration elements
pod_tuple |
pod_tuple< type0 > | Recursion anchor for seqan3::pod_tuple
pod_tuple< type0, types... > | Behaves like std::tuple but is an aggregate PODType
printer_order | The printer_order is a variadic template that defines the order of the printers
qualified | Joins an arbitrary alphabet with a quality alphabet
range_innermost_value | Recursively determines the value_type on containers and/or iterators
record | The class template that file records are based on; behaves like a std::tuple
ref_info_not_given | Type tag which indicates that no reference information has been passed to the SAM file on construction
regex_validator | A validator that checks if a matches a regular expression pattern
remove_rvalue_reference | Return the input type with && removed, but lvalue references preserved
required_option_missing | Argument parser exception thrown when a required option is missing
rna15 | The 15 letter RNA alphabet, containing all IUPAC smybols minus the gap
rna4 | The four letter RNA alphabet of A,C,G,U
rna5 | The five letter RNA alphabet of A,C,G,U and the unknown character N
sam_file_header | Stores the header information of SAM/BAM files
sam_file_input | A class for reading SAM files, both SAM and its binary representation BAM are supported
sam_file_input_default_traits | The default traits for seqan3::sam_file_input
sam_file_input_format | The generic concept for alignment file input formats
sam_file_input_options | The options type defines various option members that influence the behaviour of all or some formats
sam_file_output | A class for writing SAM files, both SAM and its binary representation BAM are supported
sam_file_output_format | The generic concept for alignment file out formats
sam_file_output_options | The options type defines various option members that influence the behavior of all or some formats
sam_file_program_info_t | Stores information of the program/tool that was used to create a SAM/BAM file
sam_flag_printer |
sam_flag_printer< sam_flag > | A sam_flag can be printed as an integer value
sam_record | The record type of seqan3::sam_file_input
sam_tag_dictionary | The SAM tag dictionary class that stores all optional SAM fields
sam_tag_type | The generic base class
scoring_scheme_base | A CRTP base class for scoring schemes
search_result | The result class generated by the seqan3::seach algorithm
search_result_printer |
search_result_printer< search_result< specs_t... > > | The printer used for formatted output of the search result
seed | Strong_type for seed
semialphabet_any | A semi-alphabet that type erases all other semi-alphabets of the same size
sequence_file_input | A class for reading sequence files, e.g. FASTA, FASTQ ..
sequence_file_input_default_traits_aa | A traits type that specifies input as amino acids
sequence_file_input_default_traits_dna | The default traits for seqan3::sequence_file_input
sequence_file_input_format | The generic concept for sequence file in formats
sequence_file_input_options | The options type defines various option members that influence the behaviour of all or some formats
sequence_file_output | A class for writing sequence files, e.g. FASTA, FASTQ ..
sequence_file_output_format | The generic concept for sequence file out formats
sequence_file_output_options | The options type defines various option members that influence the behaviour of all or some formats
sequence_printer |
sequence_printer< sequence_t > | A printer for (biological) sequences
sequence_record | The record type of seqan3::sequence_file_input
shape | A class that defines which positions of a pattern to hash
simd_printer |
small_string | Implements a small string that can be used for compile time computations
small_vector | A constexpr vector implementation with dynamic size at compile time
std_byte_printer |
std_byte_printer< std::byte > | A std::byte can be printed by printing its value as integer
std_printer |
std_printer< type_t > | The printer for standard output streams
std_variant_printer |
std_variant_printer< std::variant< variant_ts... > > | A std::variant can be printed by visiting the stream operator for the corresponding type
strong_type_printer |
strong_type_printer< strong_type_t > | A strong type can be printed by printing its underlying value
structure_file_input | A class for reading structured sequence files, e.g. Stockholm, Connect, Vienna, ViennaRNA bpp matrix ..
structure_file_input_default_traits_aa | A traits type that specifies input as amino acids
structure_file_input_default_traits_rna | The default traits for seqan3::structure_file_input
structure_file_input_format | The generic concept for structure file in formats
structure_file_input_options | The options type defines various option members that influence the behaviour of all or some formats
structure_file_output | A class for writing structured sequence files, e.g. Stockholm, Connect, Vienna, ViennaRNA bpp matrix ..
structure_file_output_format | The generic concept for structure file out formats
structure_file_output_options | The options type defines various option members that influence the behaviour of all or some formats
structure_record | The record type of seqan3::structure_file_input
structured_aa | A seqan3::alphabet_tuple_base that joins an aminoacid alphabet with a protein structure alphabet
structured_rna | A seqan3::alphabet_tuple_base that joins a nucleotide alphabet with an RNA structure alphabet
suffix_array_interval | The underlying suffix array interval
too_few_arguments | Argument parser exception thrown when too few arguments are provided
too_many_arguments | Argument parser exception thrown when too many arguments are provided
trace_directions_printer |
trace_directions_printer< detail::trace_directions > | Prints trace_directions as ascii or as utf8 to output stream
tuple_printer |
tuple_printer< tuple_t > | Printer for formatted output of tuple like objects
type_list | Type that contains multiple types
unexpected_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
ungapped | A strong type of underlying type uint8_t that represents the ungapped shape size
unhandled_extension_error | Thrown if there is no format that accepts a given file extension
unknown_option | Argument parser exception thrown when encountering unknown option
user_input_error | Argument parser exception thrown when an incorrect argument is given as (positional) option value
validation_error | Argument parser exception thrown when an argument could not be casted to the according type
value_list_validator | A validator that checks whether a value is inside a list of valid values
window_size | Strong_type for the window_size
wuss | The WUSS structure alphabet of the characters .<>:,-_~;()[]{}AaBbCcDd..
std | SeqAn specific customisations in the standard namespace
hash< alphabet_t > | Struct for hashing a character
hash< seqan3::dynamic_bitset< cap > > | Struct for hashing a seqan3::dynamic_bitset
hash< urng_t > | Struct for hashing a range of characters
tuple_element< elem_no, seqan3::record< field_types, field_ids > > | Obtains the type of the specified element
tuple_element< elem_no, seqan3::sam_record< field_types, field_ids > > | Obtains the type of the specified element
tuple_element< elem_no, seqan3::sequence_record< field_types, field_ids > > | Obtains the type of the specified element
tuple_element< elem_no, seqan3::structure_record< field_types, field_ids > > | Obtains the type of the specified element
tuple_element< i, t< types... > > | Obtains the type of the specified element
tuple_element< i, tuple_t > | Obtains the type of the specified element
tuple_size< seqan3::record< field_types, field_ids > > | Provides access to the number of elements in a tuple as a compile-time constant expression
tuple_size< seqan3::sam_record< field_types, field_ids > > | Provides access to the number of elements in a tuple as a compile-time constant expression
tuple_size< seqan3::sequence_record< field_types, field_ids > > | Provides access to the number of elements in a tuple as a compile-time constant expression
tuple_size< seqan3::structure_record< field_types, field_ids > > | Provides access to the number of elements in a tuple as a compile-time constant expression
tuple_size< t< types... > > | Provides access to the number of elements in a tuple as a compile-time constant expression
tuple_size< tuple_t > | Provides access to the number of elements in a tuple as a compile-time constant expression
aligned_sequence | The generic concept for an aligned sequence
alphabet | The generic alphabet concept that covers most data types used in ranges
aminoacid_alphabet | A concept that indicates whether an alphabet represents amino acids
argument_parser_compatible_option | Checks whether the the type can be used in an add_(positional_)option call on the argument parser
arithmetic | A type that satisfies std::is_arithmetic_v<t>
builtin_character | This concept encompasses exactly the types char, signed char, unsigned char, wchar_t, char16_t and char32_t
cereal_archive | All archives of the Cereal library satisfy this
cereal_input_archive | All input archives of the Cereal library satisfy this
cereal_output_archive | All output archives of the Cereal library satisfy this
cereal_text_archive | All text archives of the Cereal library satisfy this
cerealisable | Specifies the requirements for types that are serialisable via Cereal
const_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
container | The (most general) container concept as defined by the standard library
enum_bitwise_operators | You can expect these functions on all types that overload seqan3::add_enum_bitwise_operators
explicitly_convertible_to | Checks whether from can be explicitly converted to to
implicitly_convertible_to | Checks whether from can be implicityly converted to to
input_stream_over | Concept for input streams
named_enumeration | Checks whether the free function seqan3::enumeration_names can be called on the type
nonrecursive_range | A concept that checks whether a range is non-recursive
nucleotide_alphabet | A concept that indicates whether an alphabet represents nucleotides
output_stream_over | Concept for output streams
pair_like | Whether a type behaves like a tuple with exactly two elements
printable_with | The concept for a printable object
pseudo_random_access_iterator | This concept checks if an iterator type models pseudo random access
pseudo_random_access_range | This concept checks if a type models a pseudo random access range
quality_alphabet | A concept that indicates whether an alphabet represents quality scores
random_access_container | A more refined container concept than seqan3::sequence_container
reservible_container | A more refined container concept than seqan3::random_access_container
rna_structure_alphabet | A concept that indicates whether an alphabet represents RNA structure
sam_file_input_traits | The requirements a traits_type for seqan3::sam_file_input must meet
scoring_scheme_for | A concept that requires that type be able to score two letters
semialphabet | The basis for seqan3::alphabet, but requires only rank interface (not char)
sequence | The generic concept for a (biological) sequence
sequence_container | A more refined container concept than seqan3::container
sequence_file_input_traits | The requirements a traits_type for seqan3::sequence_file_input must meet
standard_layout | Resolves to std::is_standard_layout_v<t>
structure_file_input_traits | The requirements a traits_type for seqan3::structure_file_input must meet
transformation_trait | Concept for a transformation trait
trivial | A type that satisfies seqan3::trivially_copyable and seqan3::trivially_destructible
trivially_copyable | A type that satisfies std::is_trivially_copyable_v<t>
trivially_destructible | A type that satisfies std::is_trivially_destructible_v<t>
tuple_like | Whether a type behaves like a tuple
unary_type_trait | Concept for a unary traits type
validator | The concept for option validators passed to add_option/positional_option
weakly_assignable_from | Resolves to std::is_assignable_v<t>
writable_aligned_sequence | The generic concept for an aligned sequence that is writable
writable_alphabet | Refines seqan3::alphabet and adds assignability
writable_quality_alphabet | A concept that indicates whether a writable alphabet represents quality scores
writable_semialphabet | A refinement of seqan3::semialphabet that adds assignability

Hide me