|
| struct | access_restrictor_fn |
| | A functor that always throws when calling operator() (needed for the alignment "dummy" sequence). More...
|
| |
| class | adaptor_base |
| | CRTP-base to simplify the definition of range adaptor closure objects and similar types. More...
|
| |
| class | adaptor_for_view_without_args |
| | Template for range adaptor closure objects that store no arguments and always delegate to the view constructor. More...
|
| |
| class | adaptor_from_functor |
| | Template for range adaptor closure objects that store arguments and wrap a proto-adaptor. More...
|
| |
| class | advanceable_alignment_coordinate |
| | Implements an internal alignment coordinate that can be used as an argument to the std::ranges::iota_view. More...
|
| |
| class | affine_cell_proxy |
| | A proxy for an affine score matrix cell. More...
|
| |
| class | affine_gap_init_policy |
| | The CRTP-policy that implements the initialisation of the dynamic programming matrix with affine gaps. More...
|
| |
| class | affine_gap_policy |
| | The CRTP-policy that computes a single cell in the alignment matrix. More...
|
| |
| class | algorithm_executor_blocking |
| | A blocking algorithm executor for algorithms. More...
|
| |
| struct | align_result_selector |
| | Helper metafunction to select the alignment result type based on the configuration. More...
|
| |
| class | aligned_sequence_builder |
| | Builds the alignment for a given pair of sequences and the respective trace. More...
|
| |
| class | alignment_algorithm |
| | The alignment algorithm type to compute standard pairwise alignment using dynamic programming. More...
|
| |
| struct | alignment_algorithm_state |
| | Local state for the standard alignment algorithm. More...
|
| |
| struct | alignment_configuration_traits |
| | A traits type for the alignment algorithm that exposes static information stored within the alignment configuration object. More...
|
| |
| struct | alignment_configurator |
| | Configures the alignment algorithm given the sequences and the configuration object. More...
|
| |
| struct | alignment_contract |
| | Provides several contracts to test when configuring the alignment algorithm. More...
|
| |
| struct | alignment_function_traits |
| | A traits class to provide a uniform access to the properties of the wrapped alignment algorithm. More...
|
| |
| class | alignment_matrix_column_major_range_base |
| | Provides a range interface for alignment matrices. More...
|
| |
| class | alignment_matrix_policy |
| | Manages the alignment and score matrix. More...
|
| |
| struct | alignment_optimum |
| | Stores the current optimum of the alignment algorithm. More...
|
| |
| struct | alignment_result_value_type |
| | A struct that contains the actual alignment result data. More...
|
| |
| struct | alignment_result_value_type_accessor< alignment_result< result_value_t > > |
| | Transformation trait to access the hidden result value type of the seqan3::alignment_result class. More...
|
| |
| class | alignment_score_matrix_one_column |
| | An alignment score matrix storing only a single column for the computation. More...
|
| |
| class | alignment_score_matrix_one_column_banded |
| | A banded alignment score matrix storing only a single banded column for the computation. More...
|
| |
| struct | alignment_score_matrix_one_column_base |
| | A base class for alignment score matrices using only one column to compute the matrix. More...
|
| |
| struct | alignment_score_matrix_proxy |
| | A proxy type for a unified access to the score matrix during alignment computation. More...
|
| |
| struct | alignment_trace_matrix_base |
| | A crtp-base class for alignment traceback matrices. More...
|
| |
| class | alignment_trace_matrix_full |
| | An alignment traceback matrix storing the entire traceback matrix. More...
|
| |
| class | alignment_trace_matrix_full_banded |
| | An alignment traceback matrix storing the entire banded traceback matrix. More...
|
| |
| struct | alignment_trace_matrix_proxy |
| | A proxy type for a unified access to the traceback matrix during alignment computation. More...
|
| |
| struct | assignable_from |
| | 'Callable' helper class that is invokable by meta::invoke.Returns a std::true_type if the type is assignable from T. More...
|
| |
| struct | async_input_buffer_fn |
| | Definition of the range adaptor object type for seqan3::views::async_input_buffer. More...
|
| |
| class | async_input_buffer_view |
| | The type returned by seqan3::views::async_input_buffer. More...
|
| |
| class | basic_iterator |
| | Forward declaration. More...
|
| |
| class | basic_iterator< single_pass_input_view< view_type > > |
| | An input_iterator over the associated range. More...
|
| |
| struct | bgzf_compression |
| | A tag signifying a bgzf compressed file. More...
|
| |
| struct | builtin_simd |
| | A class that holds the type of a simd implementation called [vector extension] (https://gcc.gnu.org/onlinedocs/gcc/Vector-Extensions.html) (formerly known as "seqan simd" in seqan2). More...
|
| |
| struct | builtin_simd< scalar_t, length > |
| | A class that holds the type of a simd implementation called [vector extension] (https://gcc.gnu.org/onlinedocs/gcc/Vector-Extensions.html) (formerly known as "seqan simd" in seqan2). More...
|
| |
| struct | builtin_simd_traits_helper |
| | Helper struct for seqan3::detail::is_builtin_simd. More...
|
| |
| struct | builtin_simd_traits_helper< builtin_simd_t > |
| | Helper struct for seqan3::detail::is_builtin_simd. More...
|
| |
| struct | bz2_compression |
| | A tag signifying a bz2 compressed file. More...
|
| |
| struct | char_predicate_base |
| | An abstract CRTP base class for parse conditions to add logical disjunction and negation operator. More...
|
| |
| struct | char_predicate_disjunction |
| | Logical disjunction operator for parse conditions. More...
|
| |
| struct | char_predicate_negator |
| | Logical not operator for a parse condition. More...
|
| |
| struct | chunked_indexed_sequence_pairs |
| | A transformation trait to retrieve the chunked range over indexed sequence pairs. More...
|
| |
| struct | column_index_type |
| | A strong type for designated initialisation of the column index of a matrix. More...
|
| |
| class | combined_adaptor |
| | Template for range adaptor closure objects that consist of two other range adaptor closure objects. More...
|
| |
| class | combined_score_and_trace_matrix |
| | An alignment matrix that combines a score matrix with a trace matrix into a common interface. More...
|
| |
| class | constexpr_pseudo_bitset |
| | A data structure that implements a subset of std::bitset as constexpr. More...
|
| |
| struct | constructible_from |
| | 'Callable' helper class that is invokable by meta::invoke.Returns a std::true_type if the type is constructable from T. More...
|
| |
| class | coordinate_matrix |
| | A matrix over coordinates. More...
|
| |
| class | copyable_wrapper |
| | Utility wrapper that behaves like std::optional but makes the type conform with the std::copyable concept. More...
|
| |
| class | copyable_wrapper< t > |
| | Utility wrapper that behaves like std::optional but makes the type conform with the std::copyable concept. More...
|
| |
| class | counted_simd_iterator |
| | Implements a special version of a counted iterator over a simd vector. More...
|
| |
| struct | customisation_point_object |
| | A CRTP base-class that defines a customisation_point_object (CPO). More...
|
| |
| class | debug_matrix |
| | A debug matrix to wrap alignment matrices and sequences and make them printable together. More...
|
| |
| class | debug_mode |
| | A global configuration type used to enabled debugging of algorithms. More...
|
| |
| struct | default_edit_distance_trait_type |
| | The default traits type for the edit distance algorithm. More...
|
| |
| struct | default_validator |
| | Validator that always returns true. More...
|
| |
| struct | deferred_crtp_base |
| | An invocable wrapper that defers the instantiation of a crtp_base class. More...
|
| |
| struct | deferred_crtp_base_vargs |
| | An invocable wrapper that defers the instantiation of a crtp_base class. More...
|
| |
| struct | deferred_type |
| | Return the type identity; further arguments are ignored, but can make this type dependent if they are. More...
|
| |
| class | edit_distance_algorithm |
| | This algorithm unifies different edit distance implementations and uses the appropriate one depending on the given configuration. More...
|
| |
| class | edit_distance_score_matrix_full |
| | The underlying data structure of seqan3::detail::edit_distance_unbanded that represents the score matrix. More...
|
| |
| class | edit_distance_trace_matrix_full |
| | The underlying data structure of seqan3::detail::edit_distance_unbanded that represents the trace matrix. More...
|
| |
| class | edit_distance_unbanded |
| | This calculates an alignment using the edit distance and without a band. More...
|
| |
| class | edit_distance_unbanded_global_policy |
| | Only available when default_edit_distance_trait_type::is_global is true. More...
|
| |
| class | edit_distance_unbanded_max_errors_policy |
| | Only available when default_edit_distance_trait_type::use_max_errors is true. More...
|
| |
| class | edit_distance_unbanded_score_matrix_policy |
| | Only available when default_edit_distance_trait_type::compute_score_matrix is true. More...
|
| |
| class | edit_distance_unbanded_semi_global_policy |
| | Only available when default_edit_distance_trait_type::is_semi_global is true. More...
|
| |
| class | edit_distance_unbanded_trace_matrix_policy |
| | Only available when default_edit_distance_trait_type::compute_trace_matrix is true. More...
|
| |
| struct | empty_state |
| | Store no state for state_t. More...
|
| |
| struct | empty_type |
| | An empty class type used in meta programming. More...
|
| |
| class | execution_handler_parallel |
| | Handles the parallel execution of algorithms. More...
|
| |
| struct | execution_handler_sequential |
| | Handles the sequential execution of algorithms. More...
|
| |
| class | fast_istreambuf_iterator |
| | Functionally the same as std::istreambuf_iterator, but faster. More...
|
| |
| class | fast_ostreambuf_iterator |
| | Functionally the same as std::ostreambuf_iterator, but offers writing a range more efficiently. More...
|
| |
| class | find_optimum_policy |
| | The CRTP-policy to determine the optimum of the dynamic programming matrix. More...
|
| |
| struct | fm_index_cursor_node |
| | Internal representation of the node of an FM index cursor. More...
|
| |
| struct | fm_index_validator |
| | Class used to validate the requirements on the input text of the fm_index. More...
|
| |
| class | format_base |
| | The format that contains all helper functions needed in all formats. More...
|
| |
| class | format_copyright |
| | The format that prints the copyright information to std::cout. More...
|
| |
| class | format_help |
| | The format that prints the help page to std::cout. More...
|
| |
| class | format_help_base |
| | The format that contains all helper functions needed in all formats for printing the interface description of the application (to std::cout). More...
|
| |
| class | format_html |
| | The format that prints the help page as html to std::cout. More...
|
| |
| class | format_man |
| | The format that prints the help page information formatted for a man page to std::cout. More...
|
| |
| class | format_parse |
| | The format that organizes the actual parsing of command line arguments. More...
|
| |
| class | format_sam_base |
| | The alignment base format. More...
|
| |
| class | format_short_help |
| | The format that prints a short help message to std::cout. More...
|
| |
| class | format_version |
| | The format that prints the version to std::cout. More...
|
| |
| struct | gz_compression |
| | A tag signifying a gz compressed file. More...
|
| |
| class | ignore_output_iterator |
| | An output iterator that emulates writing to a null-stream in order to dispose the output. More...
|
| |
| struct | implicitly_convertible_from |
| | 'Callable' helper class that is invokable by meta::invoke.Returns a std::true_type if the T is implicitly convertible to type. More...
|
| |
| class | in_file_iterator |
| | Input iterator necessary for providing a range-like interface in input file. More...
|
| |
| class | inherited_iterator_base |
| | A CRTP base template for creating iterators that inherit from other iterators. More...
|
| |
| struct | instantiate |
| | A transformation trait that instantiates seqan3::lazy types. Base template is the identity transformation. More...
|
| |
| struct | instantiate< lazy< template_t, spec_t... > > |
| | A transformation trait that instantiates seqan3::lazy types. More...
|
| |
| struct | instantiate_if |
| | A transformation trait that instantiates seqan3::lazy types given a boolean condition. Base template is std::false_type. More...
|
| |
| struct | instantiate_if< lazy< template_t, spec_t... >, true > |
| | A transformation trait that instantiates seqan3::lazy types given a boolean condition. If condition is true and parameter is lazy, the instantiated type. More...
|
| |
| struct | instantiate_if< t, true > |
| | A transformation trait that instantiates seqan3::lazy types given a boolean condition. If condition is true and parameter is not lazy, the type identity. More...
|
| |
| struct | interleave_fn |
| | views::interleave's range adaptor object type (non-closure). More...
|
| |
| class | iota_simd_view |
| | The simd iota view. More...
|
| |
| struct | iota_simd_view_fn |
| | The view adaptor returning the seqan3::detail::iota_simd_view. More...
|
| |
| struct | is_builtin_simd |
| | This class inherits from std::true_type, iff seqan3::detail::builtin_simd<scalar_t, length>::type is a builtin simd type. More...
|
| |
| struct | is_char_type |
| | Parse condition that checks if a given value is equal to char_v. More...
|
| |
| struct | is_class_template_declarable_with |
| | An unary type trait that tests whether a template class can be declared with the given template type parameters. More...
|
| |
| struct | is_derived_from_record |
| | Helper struct to implement seqan3::detail::record_like. More...
|
| |
| struct | is_in_interval_type |
| | Parse condition that checks if a given value is in the range of rng_beg and interval_last. More...
|
| |
| struct | is_native_builtin_simd |
| | This class inherits from std::true_type, iff the builtin simd type is supported by the current architecture. More...
|
| |
| struct | is_same_configuration_f |
| | Helper meta function to check if a template type is contained in a seqan3::configuration. More...
|
| |
| struct | is_span |
| | Helper to determine whether a type is a std::span. More...
|
| |
| struct | is_type_specialisation_of |
| | Determines whether a source_type is a specialisation of another template. More...
|
| |
| struct | is_type_specialisation_of< source_t, target_template > |
| | This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
|
| |
| struct | is_value_specialisation_of< source_t, target_template > |
| | Determines whether a source_type is a specialisation of another template. More...
|
| |
| struct | istreambuf_fn |
| | View adaptor/factory definition for views::istream. More...
|
| |
| struct | iter_pointer |
| | This is like std::iter_value_t, but for the pointer type. More...
|
| |
| struct | kmer_hash_fn |
| | views::kmer_hash's range adaptor object type (non-closure). More...
|
| |
| class | kmer_hash_view |
| | The type returned by seqan3::views::kmer_hash. More...
|
| |
| class | latch |
| | A single-use synchronisation point to coordinate concurrent threads. More...
|
| |
| struct | lazy |
| | An empty type whose only purpose is to hold an uninstantiated template plus its arguments. More...
|
| |
| struct | lazy_conditional |
| | Behaves like std::conditional, but instantiates types wrapped in seqan3::lazy. More...
|
| |
| struct | make_aligned_sequence_type |
| | A transformation trait that returns the correct aligned sequence type for a given sequence type. More...
|
| |
| struct | make_pairwise_alignment_type |
| | A transformation trait that returns the correct pairwise alignment type for two given sequence types. More...
|
| |
| interface | matrix |
| | Defines the requirements of a matrix (e.g. score matrices, trace matrices). More...
|
| |
| struct | matrix_index |
| | A representation of a location or offset within a two-dimensional matrix. More...
|
| |
| struct | max_score_banded_updater |
| | A function object that compares and possibly updates the alignment optimum with the current cell. More...
|
| |
| struct | max_score_updater |
| | A function object that compares and possibly updates the alignment optimum with the current cell. More...
|
| |
| struct | max_score_updater_simd_global |
| | Function object that compares and updates the alignment optimum for the vectorised global alignment algorithm. More...
|
| |
| struct | maybe_inherited_iterator_category |
| | This handles more cases than maybe_iterator_category if you inherit the underling_iterator_t. More...
|
| |
| struct | maybe_iterator_category |
| | Defines iterator_category member if underlying_iterator_t has a valid std::iterator_traits::iterator_category overload. More...
|
| |
| struct | minimiser_fn |
| | seqan3::views::minimiser's range adaptor object type (non-closure). More...
|
| |
| struct | minimiser_hash_fn |
| | seqan3::views::minimiser_hash's range adaptor object type (non-closure). More...
|
| |
| class | minimiser_view |
| | The type returned by seqan3::views::minimiser. More...
|
| |
| struct | multi_invocable |
| | A type that can conveniently inherit multiple invocables and acts as a union over them. More...
|
| |
| class | non_propagating_cache |
| | A helper that enables an input view to temporarily cache values as it is iterated over. More...
|
| |
| struct | number_cols |
| | Strong type for setting the column dimension of a matrix. More...
|
| |
| struct | number_rows |
| | Strong type for setting the row dimension of a matrix. More...
|
| |
| class | out_file_iterator |
| | Output iterator necessary for providing a range-like interface in output file. More...
|
| |
| class | pairwise_alignment_algorithm |
| | The alignment algorithm type to compute standard pairwise alignment using dynamic programming. More...
|
| |
| class | pairwise_alignment_algorithm_banded |
| | The alignment algorithm type to compute the banded standard pairwise alignment using dynamic programming. More...
|
| |
| class | pairwise_combine_view |
| | Generates all pairwise combinations of the elements in the underlying range. More...
|
| |
| class | parallel_mode |
| | A global configuration type used to enable parallel execution of algorithms. More...
|
| |
| class | policy_affine_gap_recursion |
| | Implements the alignment recursion function for the alignment algorithm using affine gap costs. More...
|
| |
| class | policy_affine_gap_recursion_banded |
| | Implements the alignment recursion function for the banded alignment algorithm using affine gap costs. More...
|
| |
| class | policy_affine_gap_with_trace_recursion |
| | Implements the alignment recursion function for the alignment algorithm using affine gap costs with trace information. More...
|
| |
| class | policy_affine_gap_with_trace_recursion_banded |
| | Implements the alignment recursion function for the banded alignment algorithm using affine gap costs with trace information. More...
|
| |
| class | policy_alignment_matrix |
| | A policy that provides a common interface to acquire the correct alignment matrices. More...
|
| |
| class | policy_alignment_result_builder |
| | Implements the alignment result builder. More...
|
| |
| struct | policy_max_error |
| | Provides the function max_error_counts if inherited by a search algorithm. More...
|
| |
| class | policy_optimum_tracker |
| | Implements the tracker to store the global optimum for a particular alignment computation. More...
|
| |
| class | policy_optimum_tracker_simd |
| | Implements the tracker to store the global optimum for a particular alignment computation. More...
|
| |
| class | policy_scoring_scheme |
| | Stores the configured scoring scheme used for this algorithm. More...
|
| |
| struct | policy_search_result_builder |
| | Provides the function make_results if inherited by a search algorithm. More...
|
| |
| struct | priority_tag |
| | A tag that allows controlled overload resolution via implicit base conversion rules. More...
|
| |
| struct | priority_tag< 0 > |
| | Recursion anchor for seqan3::detail::priority_tag. More...
|
| |
| class | proxy_reference |
| | The same as value_t & but it is default constructible and is re-assignable. More...
|
| |
| struct | pseudo_random_access_fn |
| | View adaptor definition for seqan3::views::enforce_random_access. More...
|
| |
| class | random_access_iterator |
| | A generic random access iterator that delegates most operations to the range. More...
|
| |
| class | random_access_iterator_base |
| | A CRTP base template for creating random access iterators. More...
|
| |
| struct | reader_count |
| | A strong type to set the reader count of a seqan3::detail::reader_writer_manager. More...
|
| |
| class | reader_writer_manager |
| | A single-use synchronisation point for closable concurrent data structures. More...
|
| |
| struct | recursive_required_types |
| | Like seqan3::detail::required_types, but recursive. More...
|
| |
| struct | recursive_required_types< t > |
| | Like seqan3::detail::required_types, but recursive. More...
|
| |
| struct | repeat_fn |
| | View factory definition for views::repeat. More...
|
| |
| struct | repeat_n_fn |
| | The underlying type of seqan3::views::repeat_n. More...
|
| |
| class | repeat_view |
| | The type returned by seqan3::views::repeat. More...
|
| |
| struct | required_types |
| | A seqan3::type_list with types that the given type depends on. More...
|
| |
| struct | required_types< t > |
| | A seqan3::type_list with types that the given type depends on. [specialisation for seqan3::alphabet_variant and derivates of seqan3::alphabet_tuple_base]. More...
|
| |
| class | reverse_fm_index |
| | An FM Index specialisation that handles reversing the given text. More...
|
| |
| struct | row_index_type |
| | A strong type for designated initialisation of the row index of a matrix. More...
|
| |
| class | safe_filesystem_entry |
| | A safe guard to manage a filesystem entry, e.g. a file or a directory. More...
|
| |
| struct | sam_file_input_format_exposer |
| | Internal class used to expose the actual format interface to read SAM records from the file. More...
|
| |
| struct | sam_file_output_format_exposer |
| | Internal class used to expose the actual format interface to write SAM/BAM records into the file. More...
|
| |
| class | score_matrix_single_column |
| | Score matrix for the pairwise alignment using only a single column. More...
|
| |
| class | scoring_scheme_policy |
| | The CRTP-policy that stores the scoring scheme used for this alignment algorithm. More...
|
| |
| struct | search |
| | Object storing information for a search (of a search scheme). More...
|
| |
| struct | search_configuration_validator |
| | Class used to validate the search configuration. More...
|
| |
| class | search_configurator |
| | Class used to update the search configuration, e.g. add defaults. More...
|
| |
| struct | search_dyn |
| | Object storing information for a search (of a search scheme). More...
|
| |
| struct | search_param |
| | Object grouping numbers of errors for different kind of error types. More...
|
| |
| class | search_scheme_algorithm |
| | The algorithm that performs a bidirectional search on a bidirectional FM index using (optimal) search schemes. More...
|
| |
| struct | search_traits |
| | A collection of traits extracted from the search configuration. More...
|
| |
| struct | select_types_with_ids |
| | Exposes a subset of types as a seqan3::type_list selected based on their IDs. More...
|
| |
| struct | selector |
| | The same as std::conditional but for template template parameters. More...
|
| |
| struct | sequence_file_input_format_exposer |
| | Internal class used to expose the actual format interface to read sequence records from the file. More...
|
| |
| struct | sequence_file_output_format_exposer |
| | Internal class used to expose the actual format interface to write sequence records into the file. More...
|
| |
| class | simd_affine_gap_policy |
| | The CRTP-policy that computes a batch of cells in the alignment matrix using simd instructions. More...
|
| |
| class | simd_find_optimum_policy |
| | The CRTP-policy to determine the optimum of the dynamic programming matrix. More...
|
| |
| struct | simd_global_alignment_state |
| | A state that is only used for global alignments. More...
|
| |
| class | simd_match_mismatch_scoring_scheme |
| | A vectorised scoring scheme handling matches and mismatches only. More...
|
| |
| class | simd_matrix_scoring_scheme |
| | A vectorised scoring scheme to handle scoring matrices using gather strategy. More...
|
| |
| class | single_pass_input_view |
| | Adds single_pass_input behavior to the underlying range. More...
|
| |
| struct | slice_fn |
| | View adaptor definition for views::slice. More...
|
| |
| class | spin_delay |
| | A delay for threads waiting for a shared resource. More...
|
| |
| struct | stream_buffer_exposer |
| | Functionally the same as std::basic_streambuf<char_t, traits_t_>, but exposes protected members as public. More...
|
| |
| class | strong_type |
| | CRTP base class to declare a strong typedef for a regular type to avoid ambiguous parameter settings in function calls. More...
|
| |
| struct | structure_file_input_format_exposer |
| | Internal class used to expose the actual format interface to read structure records from the file. More...
|
| |
| struct | structure_file_output_format_exposer |
| | Internal class used to expose the actual format interface to write structure records into the file. More...
|
| |
| struct | take_exactly_fn |
| | View adaptor definition for views::take and views::take_or_throw. More...
|
| |
| struct | take_until_fn |
| | View adaptor definition for detail::take_until and detail::take_until_or_throw. More...
|
| |
| struct | to_simd_fn |
| | views::to_simd's range adaptor closure object type. More...
|
| |
| class | trace_iterator |
| | A trace iterator an unbanded trace matrix. More...
|
| |
| class | trace_iterator_banded |
| | A trace iterator for banded trace matrices. More...
|
| |
| class | trace_iterator_base |
| | A CRTP-base class for trace iterator implementations for the alignment algorithms. More...
|
| |
| class | trace_matrix_full |
| | Trace matrix for the pairwise alignment using the full trace matrix. More...
|
| |
| struct | transfer_template_args_onto< source_template< source_arg_types... >, target_template > |
| | Extracts a type template's type arguments and specialises another template with them. More...
|
| |
| struct | transfer_template_vargs_onto< source_template< source_varg_types... >, target_template > |
| | Extracts a type template's non-type arguments and specialises another template with them. More...
|
| |
| struct | transfer_type_modifier_onto |
| | Transfers the type modifier &, && and const (and any combination) to the target type. More...
|
| |
| struct | translate_fn |
| | Definition of the range adaptor object type for seqan3::views::translate and seqan3::views::translate_single. More...
|
| |
| struct | translate_join_fn |
| | Definition of the range adaptor object type for seqan3::views::translate_join. More...
|
| |
| struct | translation_table |
| | Generic translation table for canonical genetic code. More...
|
| |
| struct | translation_table< dna15, seqan3::genetic_code::canonical, void_type > |
| | Translation table for canonical genetic code and dna15 alphabet. More...
|
| |
| struct | trim_fn |
| | The underlying type of seqan3::views::trim_quality. More...
|
| |
| struct | tuple_type_list |
| | Transformation trait to expose the tuple element types as seqan3::type_list. More...
|
| |
| class | two_dimensional_matrix |
| | A two dimensional matrix used inside of alignment algorithms. More...
|
| |
| interface | two_dimensional_matrix_iterator |
| | A concept for iterators over a two dimensional matrix, e.g. seqan3::detail::two_dimensional_matrix. More...
|
| |
| class | two_dimensional_matrix_iterator_base |
| | A crtp-base class for iterators over seqan3::detail::two_dimensional_matrix. More...
|
| |
| struct | type_list_expander< type_list_t< args_t... > > |
| | Helper class to invoke a meta algorithm on the types contained in a seqan3::type_list. More...
|
| |
| class | type_reduce_fn |
| | View adaptor definition for views::type_reduce. More...
|
| |
| struct | unaligned_seq |
| | Default transformation trait that shall expose the unaligned sequence type of t when specialised. More...
|
| |
| struct | unaligned_seq< t > |
| | Exposes the unaligned sequence type given an aligned sequence container type. More...
|
| |
| class | unidirectional_search_algorithm |
| | The algorithm that performs a unidirectional search on an FM index using trivial backtracking. More...
|
| |
| struct | valid_template_spec_or |
| | Exposes templ_t<spec_t...> if that is valid, otherwise fallback_t. More...
|
| |
| struct | valid_template_spec_or< fallback_t, templ_t, spec_t... > |
| | This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
|
| |
| class | validator_chain_adaptor |
| | A helper struct to chain validators recursively via the pipe operator. More...
|
| |
| struct | variant_from_tags |
| | Base class to deduce the std::variant type from format tags. More...
|
| |
| struct | variant_from_tags< type_list< ts... >, output_t > |
| | Transfers a list of format tags (...ts) onto a std::variant by specialising output_t with each. More...
|
| |
| class | version_checker |
| | A functor whose operator() performs the server http request and version checks. More...
|
| |
| class | view_enforce_random_access |
| | View to force random access range iterator for seqan3::pseudo_random_access_range. More...
|
| |
| struct | view_equality_fn |
| | Comparator that is able two compare two views. More...
|
| |
| class | view_interleave |
| | The type returned by seqan3::views::interleave. More...
|
| |
| class | view_take_exactly |
| | The type returned by seqan3::views::take, seqan3::detail::take_exactly and seqan3::detail::take_exactly_or_throw. More...
|
| |
| class | view_take_until |
| | The type returned by seqan3::detail::take_until and seqan3::detail::take_until_or_throw. More...
|
| |
| class | view_to_simd |
| | Transforms a range of ranges into chunks of seqan3::simd vectors. More...
|
| |
| class | view_translate |
| | The return type of seqan3::views::translate. More...
|
| |
| class | view_translate_join |
| | The return type of seqan3::views::translate_join. More...
|
| |
| class | view_translate_single |
| | The return type of seqan3::views::translate_single. More...
|
| |
| struct | weakly_equality_comparable_with_ |
| | 'Callable' helper class that is invokable by meta::invoke.Returns a std::true_type if the type is weakly equality comparable to T. More...
|
| |
| struct | weakly_equality_comparable_with_trait |
| | Binary type trait that behaves like the seqan3::detail::weakly_equality_comparable_with concept. More...
|
| |
| struct | weakly_ordered_with_ |
| | 'Callable' helper class that is invokable by meta::invoke.Returns a std::true_type if the type is comparable via <,<=,>,>= to T. More...
|
| |
| struct | weakly_ordered_with_trait |
| | Binary type trait that behaves like the seqan3::detail::weakly_ordered_with concept. More...
|
| |
| struct | writer_count |
| | A strong type to set the writer count of a seqan3::detail::reader_writer_manager. More...
|
| |
| struct | zstd_compression |
| | A tag signifying a zstd compressed file. More...
|
| |
|
| using | all = seqan::stl::views::all |
| | Returns a view that includes all elements of the range argument.
|
| |
|
using | all_t = seqan::stl::views::all_t |
| | Returns the type that results from appying seqan3::detail::all to a range.
|
| |
|
using | compression_formats = pack_traits::drop_front< void > |
| | A seqan3::type_list containing the available compression formats.
|
| |
| template<typename t > |
| using | copyable_wrapper_t = copyable_wrapper< std::remove_reference_t< t > > |
| | Utility transformation trait to get a wrapper type that models std::copyable.
|
| |
| template<typename scalar_t , size_t length> |
| using | default_simd_backend = builtin_simd< scalar_t, length > |
| | seqan3::detail::default_simd_backend is the default used implementation of seqan3::simd::simd_type.
|
| |
| template<typename t , typename... dependent_ts> |
| using | deferred_type_t = typename deferred_type< t, dependent_ts... >::type |
| | Return the type identity; further arguments are ignored, but can make this type dependent if they are (transformation_trait shortcut).
|
| |
|
template<bool enable_policy, template< typename... > typename policy_t, typename edit_traits , typename derived_t > |
| using | edit_distance_base = invoke_deferred_crtp_base< deferred_crtp_base< selector< enable_policy, policy_t, empty_state >::template select, edit_traits >, derived_t > |
| | A base class for edit_distance_unbanded.
|
| |
|
template<bool enabled, typename state_t > |
| using | enable_state_t = std::conditional_t< enabled, state_t, empty_state< state_t > > |
| | If enabled is true state_t will be added to state_type.
|
| |
|
using | ignore_t = std::remove_cvref_t< decltype(std::ignore)> |
| | Return the type of std::ignore with const, volatile and references removed (type trait).
|
| |
| template<typename deferred_crtp_base_t , typename derived_t > |
| using | invoke_deferred_crtp_base = typename deferred_crtp_base_t::template invoke< derived_t > |
| | Template alias to instantiate the deferred crtp base with the derived class.
|
| |
| template<typename it_t > |
| using | iter_pointer_t = typename iter_pointer< it_t >::type |
| | Return the pointer type of the input type (transformation_trait shortcut).
|
| |
| template<typename it_t > |
| using | iterator_concept_tag_t = std::conditional_t< std::contiguous_iterator< it_t >, std::contiguous_iterator_tag, std::conditional_t< std::random_access_iterator< it_t >, std::random_access_iterator_tag, std::conditional_t< std::bidirectional_iterator< it_t >, std::bidirectional_iterator_tag, std::conditional_t< std::forward_iterator< it_t >, std::forward_iterator_tag, std::conditional_t< std::input_iterator< it_t >, std::input_iterator_tag, std::output_iterator_tag > > > > > |
| | Exposes the iterator_concept from the modelled concept.
|
| |
|
using | matrix_offset = matrix_index< std::ptrdiff_t > |
| | An offset type to move a matrix iterator in two-dimensional space.
|
| |
|
template<bool const_range, typename range_t > |
| using | maybe_const_iterator_t = std::ranges::iterator_t< maybe_const_range_t< const_range, range_t > > |
| | Returns the const iterator of range_t if const_range is true; otherwise the non-const iterator.
|
| |
|
template<bool const_range, typename range_t > |
| using | maybe_const_range_t = std::conditional_t< const_range, range_t const, range_t > |
| | Makes range_t const if const_range is true; otherwise keeps range_t as is.
|
| |
|
template<bool const_v, typename range_t > |
| using | maybe_const_sentinel_t = std::ranges::sentinel_t< maybe_const_range_t< const_v, range_t > > |
| | Returns the const sentinel of range_t if const_range is true; otherwise the non-const sentinel.
|
| |
|
template<uint64_t value> |
| using | min_viable_uint_t = std::conditional_t< value<=1ull, bool, std::conditional_t< value<=255ull, uint8_t, std::conditional_t< value<=65535ull, uint16_t, std::conditional_t< value<=4294967295ull, uint32_t, uint64_t > > > > |
| | Given a value, return the smallest unsigned integer that can hold it.
|
| |
| using | owning_view = seqan::stl::ranges::owning_view |
| | A move-only view that takes unique ownership of a range.
|
| |
| template<typename value_t > |
| using | row_wise_matrix = two_dimensional_matrix< value_t > |
| | A matrix represented in a one-dimensional std::vector accessing the data in row-major-order.
|
| |
|
using | sam_tag_variant = std::variant< char, int32_t, float, std::string, std::vector< std::byte >, std::vector< int8_t >, std::vector< uint8_t >, std::vector< int16_t >, std::vector< uint16_t >, std::vector< int32_t >, std::vector< uint32_t >, std::vector< float > > |
| | std::variant of allowed types for optional tag fields of the SAM format.
|
| |
|
using | search_scheme_dyn_type = std::vector< search_dyn > |
| | Type for storing search schemes. Number of blocks do not have to be known at compile time.
|
| |
|
template<uint8_t nbr_searches, uint8_t nbr_blocks> |
| using | search_scheme_type = std::array< search< nbr_blocks >, nbr_searches > |
| | Type for storing search schemes. Number of blocks have to be known at compile time.
|
| |
| template<simd_index index_t> |
| using | simd_matrix_coordinate = matrix_index< index_t > |
| | A coordinate type to access an element inside of a two-dimensional simd vector matrix.
|
| |
| template<typename type > |
| using | strip_cereal_wrapper_t = type |
| | Removes type-mangling that Cereal does with certain types on loading.
|
| |
| template<typename t > |
| using | strip_type_identity_t = std::conditional_t< is_type_specialisation_of_v< t, std::type_identity >, transformation_trait_or_t< t, void >, t > |
| | A transformation trait shortcut that returns the type inside a std::type_identity or the type itself.
|
| |
| template<typename source_type , template< typename... > typename target_template> |
| using | transfer_template_args_onto_t = typename transfer_template_args_onto< source_type, target_template >::type |
| | Shortcut for seqan3::detail::transfer_template_args_onto (transformation_trait shortcut).
|
| |
| template<typename source_type , template< auto... > typename target_template> |
| using | transfer_template_vargs_onto_t = typename transfer_template_vargs_onto< source_type, target_template >::type |
| | Shortcut for seqan3::detail::transfer_template_vargs_onto (transformation_trait shortcut).
|
| |
| template<typename type_t , typename default_t > |
| using | transformation_trait_or = std::conditional_t< transformation_trait< type_t >, type_t, std::type_identity< default_t > > |
| | This gives a fallback type if type_t::type is not defined.
|
| |
| template<typename type_t , typename default_t > |
| using | transformation_trait_or_t = typename transformation_trait_or< type_t, default_t >::type |
| | Helper type of seqan3::detail::transformation_trait_or (transformation_trait shortcut).
|
| |
| template<detail::tuple_size tuple_t> |
| using | tuple_type_list_t = typename tuple_type_list< tuple_t >::type |
| | Helper type for seqan3::detail::tuple_type_list.
|
| |
|
template<typename t > |
| using | unaligned_seq_t = typename unaligned_seq< t >::type |
| | Helper type that delegates to seqan3::detail::unaligned_seq::type.
|
| |
| template<typename fallback_t , template< typename... > typename templ_t, typename... spec_t> |
| using | valid_template_spec_or_t = typename valid_template_spec_or< fallback_t, templ_t, spec_t... >::type |
| | Helper for seqan3::detail::valid_template_spec_or (transformation_trait shortcut).
|
| |
|
|
template<typename... elements_t> |
| constexpr auto | all_elements_model_totally_ordered (seqan3::type_list< elements_t... >) -> std::bool_constant<(std::totally_ordered< elements_t > &&... &&true)> |
| | Helper type function to check for std::totally_ordered on all elements of the given tuple type.
|
| |
template<typename type_list_t , typename unary_predicate_t >
requires template_specialisation_of<type_list_t, seqan3::type_list> |
| constexpr bool | all_of (unary_predicate_t &&fn) |
| | Tests whether a given predicate evaluates to true for each type in a seqan3::type_list.
|
| |
template<typename unary_predicate_t , typename... pack_t>
requires (std::predicate<unary_predicate_t, pack_t> && ...) |
| constexpr bool | all_of (unary_predicate_t &&fn, pack_t &&... args) |
| | Tests whether a given predicate evaluates to true for each element in the function parameter pack.
|
| |
| template<typename structure_alph_type , typename bpp_type , std::ranges::range structure_type> |
| void | bpp_from_rna_structure (bpp_type &bpp, structure_type const &structure, double weight=1.) |
| | Transforms a structure annotation string into a base pair probability matrix.
|
| |
| void | call_server (std::string const &command, std::promise< bool > prom) |
| | Writes a timestamp file and performs the server call to get the newest version information.
|
| |
| template<std::unsigned_integral unsigned_t> |
| constexpr unsigned_t | ceil_log2 (unsigned_t const n) noexcept |
| | Computes the ceil of the logarithm to the base of two for unsigned integers.
|
| |
| std::vector< search_dyn > | compute_ss (uint8_t const min_error, uint8_t const max_error) |
| | Computes a (non-optimal) search scheme. Currently the generated search scheme represents trivial backtracking.
|
| |
| template<std::ranges::input_range rng_t> |
| constexpr void | consume (rng_t &&rng) |
| | Iterate over a range.
|
| |
| template<uint8_t index, simd::simd_concept simd_t> |
| constexpr simd_t | extract_eighth (simd_t const &src) |
| | Extracts one eighth of the given simd vector and stores it in the lower eighth of the target vector.
|
| |
| template<uint8_t index, simd::simd_concept simd_t> |
| constexpr simd_t | extract_eighth_avx2 (simd_t const &src) |
| | Extracts one eighth of the given simd vector and stores it in the lower eighth of the target vector.
|
| |
| template<uint8_t index, simd::simd_concept simd_t> |
| constexpr simd_t | extract_eighth_avx512 (simd_t const &src) |
| | Extracts one eighth of the given simd vector and stores it in the lower eighth of the target vector.
|
| |
| template<uint8_t index, simd::simd_concept simd_t> |
| constexpr simd_t | extract_eighth_sse4 (simd_t const &src) |
| | Extracts one eighth of the given simd vector and stores it in the lower eighth of the target vector.
|
| |
| template<uint8_t index, simd::simd_concept simd_t> |
| constexpr simd_t | extract_half (simd_t const &src) |
| | Extracts one half of the given simd vector and stores the result in the lower half of the target vector.
|
| |
| template<uint8_t index, simd::simd_concept simd_t> |
| constexpr simd_t | extract_half_avx2 (simd_t const &src) |
| | Extracts one half of the given simd vector and stores the result in the lower half of the target vector.
|
| |
| template<uint8_t index, simd::simd_concept simd_t> |
| constexpr simd_t | extract_half_avx512 (simd_t const &src) |
| | Extracts one half of the given simd vector and stores the result in the lower half of the target vector.
|
| |
| template<uint8_t index, simd::simd_concept simd_t> |
| constexpr simd_t | extract_half_sse4 (simd_t const &src) |
| | Extracts one half of the given simd vector and stores the result in the lower half of the target vector.
|
| |
| template<size_t divisor, simd_concept simd_t> |
| constexpr simd_t | extract_impl (simd_t const &src, uint8_t const mask) |
| | Helper function to extract a part of the given simd vector.
|
| |
| template<uint8_t index, simd::simd_concept simd_t> |
| constexpr simd_t | extract_quarter (simd_t const &src) |
| | Extracts one quarter of the given simd vector and stores it in the lower quarter of the target vector.
|
| |
| template<uint8_t index, simd::simd_concept simd_t> |
| constexpr simd_t | extract_quarter_avx2 (simd_t const &src) |
| | Extracts one quarter of the given simd vector and stores it in the lower quarter of the target vector.
|
| |
| template<uint8_t index, simd::simd_concept simd_t> |
| constexpr simd_t | extract_quarter_avx512 (simd_t const &src) |
| | Extracts one quarter of the given simd vector and stores it in the lower quarter of the target vector.
|
| |
| template<uint8_t index, simd::simd_concept simd_t> |
| constexpr simd_t | extract_quarter_sse4 (simd_t const &src) |
| | Extracts one quarter of the given simd vector and stores it in the lower quarter of the target vector.
|
| |
|
template<simd::simd_concept simd_t, size_t... I> |
| constexpr simd_t | fill_impl (typename simd_traits< simd_t >::scalar_type const scalar, std::index_sequence< I... >) noexcept |
| | Helper function for seqan3::simd::fill.
|
| |
| template<std::unsigned_integral unsigned_t> |
| constexpr unsigned_t | floor_log2 (unsigned_t const n) noexcept |
| | Computes the floor of the logarithm to the base of two for unsigned integers.
|
| |
template<typename type_list_t , typename unary_function_t >
requires template_specialisation_of<type_list_t, seqan3::type_list> |
| constexpr void | for_each (unary_function_t &&fn) |
| | Applies a function element wise to all types of a type list.
|
| |
template<typename unary_function_t , typename... pack_t>
requires (std::invocable<unary_function_t, pack_t> && ...) |
| constexpr void | for_each (unary_function_t &&fn, pack_t &&... args) |
| | Applies a function to each element of the given function parameter pack.
|
| |
| template<seqan3::aligned_sequence ref_seq_type, seqan3::aligned_sequence query_seq_type> |
| std::string | get_cigar_string (ref_seq_type &&ref_seq, query_seq_type &&query_seq, uint32_t const query_start_pos=0, uint32_t const query_end_pos=0, bool const extended_cigar=false) |
| | Transforms an alignment represented by two seqan3::aligned_sequence's into the corresponding cigar string.
|
| |
| std::string | get_cigar_string (std::vector< cigar > const &cigar_vector) |
| | Transforms a vector of cigar elements into a string representation.
|
| |
|
template<field f, typename field_types , typename field_ids , typename or_type > |
| decltype(auto) | get_or (record< field_types, field_ids > &r, or_type &&or_value) |
| | Access an element in a std::tuple or seqan3::record; return or_value if not contained.
|
| |
| template<field f, typename field_types , typename field_ids , typename or_type > |
| decltype(auto) | get_or (record< field_types, field_ids > const &r, or_type &&or_value) |
| | Access an element in a std::tuple or seqan3::record; return or_value if not contained.
|
| |
| template<size_t i, typename or_type , typename... types> |
| decltype(auto) | get_or (std::tuple< types... > &t, or_type &&or_value) |
| | Access an element in a std::tuple or seqan3::record; return or_value if not contained.
|
| |
| template<size_t i, typename or_type , typename... types> |
| decltype(auto) | get_or (std::tuple< types... > const &t, or_type &&or_value) |
| | Access an element in a std::tuple or seqan3::record; return or_value if not contained.
|
| |
|
template<field f, typename field_types , typename field_ids > |
| auto & | get_or_ignore (record< field_types, field_ids > &r) |
| | Access an element in a std::tuple or seqan3::record; return reference to std::ignore if not contained.
|
| |
| template<field f, typename field_types , typename field_ids > |
| auto const & | get_or_ignore (record< field_types, field_ids > const &r) |
| | Access an element in a std::tuple or seqan3::record; return reference to std::ignore if not contained.
|
| |
| template<size_t i, tuple_like tuple_t> |
| auto & | get_or_ignore (tuple_t &t) |
| | Access an element in a std::tuple or seqan3::record; return reference to std::ignore if not contained.
|
| |
| template<size_t i, tuple_like tuple_t> |
| auto const & | get_or_ignore (tuple_t const &t) |
| | Access an element in a std::tuple or seqan3::record; return reference to std::ignore if not contained.
|
| |
| unsigned | get_terminal_width () |
| | Retrieve size of terminal.
|
| |
|
template<simd::simd_concept simd_t, typename scalar_t , scalar_t... I> |
| constexpr simd_t | iota_impl (scalar_t const offset, std::integer_sequence< scalar_t, I... >) |
| | Helper function for seqan3::simd::iota.
|
| |
| bool | is_terminal () |
| | Check whether we are printing to a terminal.
|
| |
|
template<std::ranges::viewable_range rng_t> |
| | kmer_hash_view (rng_t &&, shape const &shape_) -> kmer_hash_view< std::views::all_t< rng_t > > |
| | A deduction guide for the view class template.
|
| |
| template<simd::simd_concept simd_t> |
| constexpr simd_t | load_avx2 (void const *mem_addr) |
| | Load simd_t size bits of integral data from memory.
|
| |
| template<simd::simd_concept simd_t> |
| constexpr simd_t | load_avx512 (void const *mem_addr) |
| | Load simd_t size bits of integral data from memory.
|
| |
| template<simd::simd_concept simd_t> |
| constexpr simd_t | load_sse4 (void const *mem_addr) |
| | Load simd_t size bits of integral data from memory.
|
| |
| std::string | make_printable (char const c) |
| | Returns a printable value for the given character c.
|
| |
|
template<builtin_character char_t> |
| auto | make_secondary_istream (std::basic_istream< char_t > &primary_stream) |
| | This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
|
| |
| template<builtin_character char_t> |
| auto | make_secondary_istream (std::basic_istream< char_t > &primary_stream, std::filesystem::path &filename) -> std::unique_ptr< std::basic_istream< char_t >, std::function< void(std::basic_istream< char_t > *)> > |
| | Depending on the magic bytes of the given stream, return a decompression stream or forward the primary stream.
|
| |
| template<builtin_character char_t> |
| auto | make_secondary_ostream (std::basic_ostream< char_t > &primary_stream, std::filesystem::path &filename) -> std::unique_ptr< std::basic_ostream< char_t >, std::function< void(std::basic_ostream< char_t > *)> > |
| | Depending on the given filename/extension, create a compression stream or just forward the primary stream.
|
| |
|
template<std::ranges::viewable_range rng1_t, std::ranges::viewable_range rng2_t> |
| | minimiser_view (rng1_t &&, rng2_t &&, size_t const window_size) -> minimiser_view< std::views::all_t< rng1_t >, std::views::all_t< rng2_t > > |
| | A deduction guide for the view class template.
|
| |
|
template<std::ranges::viewable_range rng1_t> |
| | minimiser_view (rng1_t &&, size_t const window_size) -> minimiser_view< std::views::all_t< rng1_t > > |
| | A deduction guide for the view class template.
|
| |
|
template<typename... invocable_ts> |
| | multi_invocable (invocable_ts...) -> multi_invocable< invocable_ts... > |
| | Deduction guides for seqan3::detail::multi_invocable.
|
| |
| constexpr std::vector< cigar > | parse_cigar (std::string_view const cigar_str) |
| | Parses a cigar string into a vector of operation-count pairs (e.g. (M, 3)).
|
| |
|
template<typename char_t , typename tuple_t , std::size_t... I> |
| void | print_tuple (debug_stream_type< char_t > &s, tuple_t &&t, std::index_sequence< I... > const &) |
| | Helper function to print elements of a tuple separately.
|
| |
| auto | range_wrap_ignore (ignore_t const &) |
| | If the argument is std::ignore, return an infinite range of std::ignore values.
|
| |
|
template<std::ranges::input_range rng_t> |
| auto & | range_wrap_ignore (rng_t &range) |
| | Pass through the reference to the argument in case the argument satisfies std::ranges::input_range.
|
| |
template<template< typename... > typename container_type, template< typename... > typename allocator_type, typename seq_alph_t , typename... rest_t>
requires container<container_type<gapped<seq_alph_t>, allocator_type<gapped<seq_alph_t>>, rest_t...>> |
| constexpr auto | remove_gap_from_value_type (container_type< gapped< seq_alph_t >, allocator_type< gapped< seq_alph_t > >, rest_t... >) -> container_type< seq_alph_t, allocator_type< seq_alph_t >, rest_t... > |
| | This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
|
| |
template<template< typename... > typename container_type, typename seq_alph_t , typename... rest_t>
requires container<container_type<gapped<seq_alph_t>, rest_t...>> |
| constexpr auto | remove_gap_from_value_type (container_type< gapped< seq_alph_t >, rest_t... >) -> container_type< seq_alph_t, rest_t... > |
| | Helper function to deduce the unaligned sequence type from an aligned sequence container.
|
| |
| template<typename search_scheme_t > |
| auto | search_scheme_block_info (search_scheme_t const &search_scheme, size_t const query_length) |
| | Returns for each search the cumulative length of blocks in the order of blocks in each search and the starting position of the first block in the query sequence.
|
| |
| template<bool abort_on_hit, typename cursor_t , typename query_t , typename search_t , typename blocks_length_t , typename delegate_t > |
| bool | search_ss (cursor_t cur, query_t &query, typename cursor_t::size_type const lb, typename cursor_t::size_type const rb, uint8_t const errors_spent, uint8_t const block_id, bool const go_right, search_t const &search, blocks_length_t const &blocks_length, search_param const error_left, delegate_t &&delegate) |
| | Searches a query sequence in a bidirectional index using a single search of a search schemes.
|
| |
| template<bool abort_on_hit, typename index_t , typename query_t , typename search_scheme_t , typename delegate_t > |
| void | search_ss (index_t const &index, query_t &query, search_param const error_left, search_scheme_t const &search_scheme, delegate_t &&delegate) |
| | Searches a query sequence in a bidirectional index using search schemes.
|
| |
| template<bool abort_on_hit, typename cursor_t , typename query_t , typename search_t , typename blocks_length_t , typename delegate_t > |
| bool | search_ss_children (cursor_t cur, query_t &query, typename cursor_t::size_type const lb, typename cursor_t::size_type const rb, uint8_t const errors_spent, uint8_t const block_id, bool const go_right, uint8_t const min_error_left_in_block, search_t const &search, blocks_length_t const &blocks_length, search_param const error_left, delegate_t &&delegate) |
| | Searches a query sequence in a bidirectional index using a single search of a search schemes. Sub-function for approximate search step (iterating over all children in a conceptual suffix tree).
|
| |
| template<bool abort_on_hit, typename cursor_t , typename query_t , typename search_t , typename blocks_length_t , typename delegate_t > |
| bool | search_ss_deletion (cursor_t cur, query_t &query, typename cursor_t::size_type const lb, typename cursor_t::size_type const rb, uint8_t const errors_spent, uint8_t const block_id, bool const go_right, search_t const &search, blocks_length_t const &blocks_length, search_param const error_left, delegate_t &&delegate) |
| | Searches a query sequence in a bidirectional index using a single search of a search schemes. Sub-function for deletions at the end of a block.
|
| |
| template<bool abort_on_hit, typename cursor_t , typename query_t , typename search_t , typename blocks_length_t , typename delegate_t > |
| bool | search_ss_exact (cursor_t cur, query_t &query, typename cursor_t::size_type const lb, typename cursor_t::size_type const rb, uint8_t const errors_spent, uint8_t const block_id, bool const go_right, search_t const &search, blocks_length_t const &blocks_length, search_param const error_left, delegate_t &&delegate) |
| | Searches a query sequence in a bidirectional index using a single search of a search scheme. Sub-function for searching the remaining part of the current block without any errors.
|
| |
| template<typename format_variant_type > |
| void | set_format (format_variant_type &format, std::filesystem::path const &file_name) |
| | Sets the file format according to the file name extension.
|
| |
template<std::ranges::forward_range ref_t, std::ranges::forward_range query_t>
requires std::equality_comparable_with<std::ranges::range_reference_t<ref_t>, std::ranges::range_reference_t<query_t>> |
| bool | starts_with (ref_t &&reference, query_t &&query) |
| | Check whether the query range is a prefix of the reference range.
|
| |
| template<simd::simd_concept simd_t> |
| constexpr void | store_avx2 (void *mem_addr, simd_t const &simd_vec) |
| | Store simd_t size bits of integral data into memory.
|
| |
| template<simd::simd_concept simd_t> |
| constexpr void | store_avx512 (void *mem_addr, simd_t const &simd_vec) |
| | Store simd_t size bits of integral data into memory.
|
| |
| template<simd::simd_concept simd_t> |
| constexpr void | store_sse4 (void *mem_addr, simd_t const &simd_vec) |
| | Store simd_t size bits of integral data into memory.
|
| |
| template<typename char_t , tuple_like alignment_t, size_t... idx> |
| void | stream_alignment (debug_stream_type< char_t > &stream, alignment_t const &align, std::index_sequence< idx... > const &) |
| | Create the formatted alignment output and add it to the provided debug_stream.
|
| |
| template<std::integral type> |
| constexpr type | to_little_endian (type const in) noexcept |
| | Convert the byte encoding of integer values to little-endian byte order.
|
| |
| template<typename... value_type> |
| std::string | to_string (value_type &&... values) |
| | Streams all parameters via the seqan3::debug_stream and returns a concatenated string.
|
| |
| template<simd::simd_concept simd_t> |
| void | transpose_matrix_avx2 (std::array< simd_t, simd_traits< simd_t >::length > &matrix) |
| | Transposes the given simd vector matrix.
|
| |
| template<simd::simd_concept simd_t> |
| void | transpose_matrix_avx512 (std::array< simd_t, simd_traits< simd_t >::length > &matrix) |
| | Transposes the given simd vector matrix.
|
| |
| template<simd::simd_concept simd_t> |
| void | transpose_matrix_sse4 (std::array< simd_t, simd_traits< simd_t >::length > &matrix) |
| | Transposes the given simd vector matrix.
|
| |
template<size_t beg, template< typename... > typename tuple_t, size_t... Is, typename... ts>
requires tuple_like<tuple_t<ts...>> && tuple_like<tuple_t<>> |
| constexpr auto | tuple_split (tuple_t< ts... > &&t, std::index_sequence< Is... > const &idx) |
| | Helper function for seqan3::tuple_split.
|
| |
template<size_t beg, template< typename... > typename tuple_t, size_t... Is, typename... ts>
requires tuple_like<tuple_t<ts...>> && tuple_like<tuple_t<>> |
| constexpr auto | tuple_split (tuple_t< ts... > const &t, std::index_sequence< Is... > const &idx) |
| | Helper function for seqan3::tuple_split.
|
| |
| template<simd::simd_concept target_simd_t, simd::simd_concept source_simd_t> |
| constexpr target_simd_t | upcast_signed (source_simd_t const &src) |
| | Upcasts the given vector into the target vector using signed extension of packed values.
|
| |
| template<simd::simd_concept target_simd_t, simd::simd_concept source_simd_t> |
| constexpr target_simd_t | upcast_signed_avx2 (source_simd_t const &src) |
| | Upcasts the given vector into the target vector using signed extension of packed values.
|
| |
| template<simd::simd_concept target_simd_t, simd::simd_concept source_simd_t> |
| constexpr target_simd_t | upcast_signed_avx512 (source_simd_t const &src) |
| | Upcasts the given vector into the target vector using signed extension of packed values.
|
| |
| template<simd::simd_concept target_simd_t, simd::simd_concept source_simd_t> |
| constexpr target_simd_t | upcast_signed_sse4 (source_simd_t const &src) |
| | Upcasts the given vector into the target vector using signed extension of packed values.
|
| |
| template<simd::simd_concept target_simd_t, simd::simd_concept source_simd_t> |
| constexpr target_simd_t | upcast_unsigned (source_simd_t const &src) |
| | Upcasts the given vector into the target vector using unsigned extension of packed values.
|
| |
| template<simd::simd_concept target_simd_t, simd::simd_concept source_simd_t> |
| constexpr target_simd_t | upcast_unsigned_avx2 (source_simd_t const &src) |
| | Upcasts the given vector into the target vector using unsigned extension of packed values.
|
| |
| template<simd::simd_concept target_simd_t, simd::simd_concept source_simd_t> |
| constexpr target_simd_t | upcast_unsigned_avx512 (source_simd_t const &src) |
| | Upcasts the given vector into the target vector using unsigned extension of packed values.
|
| |
| template<simd::simd_concept target_simd_t, simd::simd_concept source_simd_t> |
| constexpr target_simd_t | upcast_unsigned_sse4 (source_simd_t const &src) |
| | Upcasts the given vector into the target vector using unsigned extension of packed values.
|
| |
| void | update_alignment_lengths (int32_t &ref_length, int32_t &seq_length, char const cigar_operation, uint32_t const cigar_count) |
| | Updates the sequence lengths by cigar_count depending on the cigar operation op.
|
| |
| template<typename formats_t > |
| std::vector< std::string > | valid_file_extensions () |
| | Returns a list of valid file extensions.
|
| |
template<typename urng_t >
requires std::ranges::sized_range<urng_t> && std::ranges::random_access_range<urng_t> && nucleotide_alphabet<std::ranges::range_reference_t<urng_t>> |
| | view_translate (urng_t &&, translation_frames const) -> view_translate< std::views::all_t< urng_t > > |
| | Class template argument deduction for view_translate.
|
| |
|
template<typename urng_t > |
| | view_translate_join (urng_t &&, translation_frames const =translation_frames{}) -> view_translate_join< std::views::all_t< urng_t > > |
| | Class template argument deduction for view_translate_join.
|
| |
|
template<typename urng_t > |
| | view_translate_single (urng_t &&) -> view_translate_single< std::views::all_t< urng_t > > |
| | Class template argument deduction for view_translate_single with default translation_frames.
|
| |
|
template<typename urng_t > |
| | view_translate_single (urng_t &&, translation_frames const) -> view_translate_single< std::views::all_t< urng_t > > |
| | Class template argument deduction for view_translate_single.
|
| |
| template<std::output_iterator< char > it_t> |
| constexpr void | write_eol (it_t &it, bool const add_cr) |
| | Write "\n" or "\r\n" to the stream iterator, depending on arguments.
|
| |
|
|
| alignment_result_value_type () -> alignment_result_value_type< std::nullopt_t *, std::nullopt_t *, std::nullopt_t * > |
| | Type deduction for an empty object. It will always fail the compilation, if any field is accessed.
|
| |
|
template<typename sequence1_id_t , typename sequence2_id_t , typename score_t > |
| | alignment_result_value_type (sequence1_id_t, sequence2_id_t, score_t) -> alignment_result_value_type< sequence1_id_t, sequence2_id_t, score_t > |
| | Type deduction for id and score only.
|
| |
|
template<typename sequence1_id_t , typename sequence2_id_t , typename score_t , typename end_positions_t > |
| | alignment_result_value_type (sequence1_id_t, sequence2_id_t, score_t, end_positions_t) -> alignment_result_value_type< sequence1_id_t, sequence2_id_t, score_t, end_positions_t > |
| | Type deduction for id, score and end positions.
|
| |
|
template<typename sequence1_id_t , typename sequence2_id_t , typename score_t , typename end_positions_t , typename begin_positions_t > |
| | alignment_result_value_type (sequence1_id_t, sequence2_id_t, score_t, end_positions_t, begin_positions_t) -> alignment_result_value_type< sequence1_id_t, sequence2_id_t, score_t, end_positions_t, begin_positions_t > |
| | Type deduction for id, score, end positions and begin positions.
|
| |
|
template<typename sequence1_id_t , typename sequence2_id_t , typename score_t , typename end_positions_t , typename begin_positions_t , typename alignment_t > |
| | alignment_result_value_type (sequence1_id_t, sequence2_id_t, score_t, end_positions_t, begin_positions_t, alignment_t) -> alignment_result_value_type< sequence1_id_t, sequence2_id_t, score_t, end_positions_t, begin_positions_t, alignment_t > |
| | Type deduction for id, score, end positions, begin positions and alignment.
|
| |
|
template<std::ranges::viewable_range other_range_t> |
| | pairwise_combine_view (other_range_t &&range) -> pairwise_combine_view< std::views::all_t< other_range_t > > |
| | Deduces the correct template type from a non-view lvalue range by wrapping the range in std::views::all.
|
| |
|
| template<typename... elems> |
| constexpr bool | all_model_aligned_seq = (aligned_sequence<elems> && ...) |
| | True, if each type models seqan3::aligned_sequence; false otherwise.
|
| |
| template<typename... elems> |
| constexpr bool | all_model_aligned_seq< type_list< elems... > > = all_model_aligned_seq<elems...> |
| | True, if each type in the seqan3::type_list models seqan3::aligned_sequence; false otherwise.
|
| |
| template<typename type_t > |
| constexpr auto | bits_of = min_viable_uint_v<CHAR_BIT * sizeof(type_t)> |
| | How many bits has a type?
|
| |
| template<typename algorithm_id_type > |
| constexpr std::array< std::array< void *, 0 >, 0 > | compatibility_table {} |
| | Declaration of algorithm specific compatibility table.
|
| |
| template<> |
| constexpr std::array< std::array< bool, static_cast< uint8_t >(align_config_id::SIZE)>, static_cast< uint8_t >(align_config_id::SIZE)> | compatibility_table< align_config_id > |
| | Declaration of algorithm specific compatibility table.
|
| |
| template<> |
| constexpr std::array< std::array< bool, static_cast< uint8_t >(search_config_id::SIZE)>, static_cast< uint8_t >(search_config_id::SIZE)> | compatibility_table< search_config_id > |
| | Compatibility matrix to check how search configuration elements can be combined.
|
| |
| template<alphabet in_t, alphabet out_t> |
| constexpr std::array< out_t, alphabet_size< in_t > > | convert_through_char_representation |
| | A precomputed conversion table for two alphabets based on their char representations.
|
| |
| template<typename t > |
| constexpr bool | decays_to_ignore_v = std::is_same_v<std::remove_cvref_t<t>, ignore_t> |
| | Return whether the input type with const, volatile and references removed is std::ignore's type. (type trait).
|
| |
| template<typename scalar_t , template< typename, size_t > typename simd_backend_t> |
| constexpr auto | default_simd_length |
| | seqan3::detail::default_simd_length returns the default length depending on the given scalar_t type, which is used in seqan3::simd::simd_type.
|
| |
| template<template< typename, size_t > typename simd_backend_t> |
| constexpr auto | default_simd_max_length = 0u |
| | seqan3 auto-detects the maximum number of packable [u]int8_t types.
|
| |
| template<> |
| constexpr auto | default_simd_max_length< builtin_simd > |
| | This function specializes seqan3::detail::default_simd_max_length for seqan3::detail::builtin_simd.
|
| |
| template<typename list_t > |
| constexpr bool | has_member_file_extensions = false |
| | Helper function to determine if all types in a format type list have a static member file_extensions.
|
| |
| template<typename query_t > |
| constexpr bool | has_type_valid_formats = false |
| | Helper function to determine if a type has a static member valid_formats.
|
| |
| template<typename builtin_simd_t > |
| constexpr bool | is_builtin_simd_v = is_builtin_simd<builtin_simd_t>::value |
| | Helper variable to test whether a type is a simd builtin type.
|
| |
|
template<typename type > |
| constexpr bool | is_char_adaptation_v |
| | Whether a type is char, char16_t, char32_t or wchar_t (type trait).
|
| |
|
template<typename t > |
| constexpr bool | is_gapped_alphabet = false |
| | Helper variable to determine if an alphabet is gapped [default: false].
|
| |
|
template<typename t > |
| constexpr bool | is_gapped_alphabet< gapped< t > > = true |
| | Helper variable to determine if an alphabet is gapped, true for specialisations of seqan3::gapped.
|
| |
| template<typename builtin_simd_t > |
| constexpr bool | is_native_builtin_simd_v = is_native_builtin_simd<builtin_simd_t>::value |
| | Helper variable to test whether a type is a native simd builtin type.
|
| |
| template<typename t > |
| constexpr bool | is_type_list_of_sam_file_input_formats_v = false |
| | Auxiliary value metafuncton that checks whether a type is a seqan3::type_list and all types meet seqan3::sam_file_input_format [default is false].
|
| |
| template<typename... ts> |
| constexpr bool | is_type_list_of_sam_file_input_formats_v< type_list< ts... > > = (sam_file_input_format<ts> && ...) |
| | Auxiliary value metafuncton that checks whether a type is a seqan3::type_list and all types meet seqan3::sam_file_input_format [overload].
|
| |
| template<typename t > |
| constexpr bool | is_type_list_of_sam_file_output_formats_v = false |
| | Auxiliary value metafuncton that checks whether a type is a seqan3::type_list and all types meet seqan3::sam_file_output_format [default is false].
|
| |
| template<typename... ts> |
| constexpr bool | is_type_list_of_sam_file_output_formats_v< type_list< ts... > > = (sam_file_output_format<ts> && ...) |
| | Auxiliary value metafuncton that checks whether a type is a seqan3::type_list and all types meet seqan3::sam_file_output_format [overload].
|
| |
| template<typename t > |
| constexpr bool | is_type_list_of_sequence_file_input_formats_v = false |
| | Auxiliary value metafuncton that checks whether a type is a seqan3::type_list and all types meet seqan3::sequence_file_input_format [default is false].
|
| |
| template<typename... ts> |
| constexpr bool | is_type_list_of_sequence_file_input_formats_v< type_list< ts... > > |
| | Auxiliary value metafuncton that checks whether a type is a seqan3::type_list and all types meet seqan3::sequence_file_input_format [overload].
|
| |
| template<typename t > |
| constexpr bool | is_type_list_of_sequence_file_output_formats_v = false |
| | Auxiliary value metafuncton that checks whether a type is a seqan3::type_list and all types meet seqan3::sequence_file_output_format [default is false].
|
| |
| template<typename... ts> |
| constexpr bool | is_type_list_of_sequence_file_output_formats_v< type_list< ts... > > |
| | Auxiliary value metafuncton that checks whether a type is a seqan3::type_list and all types meet seqan3::sequence_file_output_format [overload].
|
| |
| template<typename t > |
| constexpr bool | is_type_list_of_structure_file_input_formats_v = false |
| | Auxiliary value metafuncton that checks whether a type is a seqan3::type_list and all types meet seqan3::structure_file_input_format [default is false].
|
| |
| template<typename... ts> |
| constexpr bool | is_type_list_of_structure_file_input_formats_v< type_list< ts... > > |
| | Auxiliary value metafuncton that checks whether a type is a seqan3::type_list and all types meet seqan3::structure_file_input_format [overload].
|
| |
| template<typename t > |
| constexpr bool | is_type_list_of_structure_file_output_formats_v = false |
| | Auxiliary value metafuncton that checks whether a type is a seqan3::type_list and all types meet seqan3::structure_file_output_format [default is false].
|
| |
| template<typename... ts> |
| constexpr bool | is_type_list_of_structure_file_output_formats_v< type_list< ts... > > |
| | Auxiliary value metafuncton that checks whether a type is a seqan3::type_list and all types meet seqan3::structure_file_output_format [overload].
|
| |
|
template<typename type > |
| constexpr bool | is_uint_adaptation_v |
| | Whether a type is uint8_t, uint16_t or uint32_t.
|
| |
| constexpr auto | istreambuf |
| | A view factory that returns a view over the stream buffer of an input stream.
|
| |
|
template<typename score_type > |
| constexpr score_type | matrix_inf = std::numeric_limits<score_type>::max() |
| | A special score which represents infinity.
|
| |
| template<uint64_t value> |
| constexpr auto | min_viable_uint_v = static_cast<min_viable_uint_t<value>>(value) |
| | Given a value, cast the value as the smallest unsigned integer that can hold it.
|
| |
| template<uint8_t min_error, uint8_t max_error> |
| constexpr int | optimum_search_scheme {0} |
| | Search scheme that is optimal in the running time for the specified lower and upper error bound.
|
| |
| template<std::ranges::range rng_t, typename char_t > |
| constexpr bool | reference_type_is_streamable_v = false |
| | Helper template variable that checks if the reference type of a range can be streamed into an instance of seqan3::debug_stream_type .
|
| |
|
constexpr char | sam_tag_type_char [12] = {'A', 'i', 'f', 'Z', 'H', 'B', 'B', 'B', 'B', 'B', 'B', 'B'} |
| | Each SAM tag type char identifier. Index corresponds to the seqan3::detail::sam_tag_variant types.
|
| |
|
constexpr char | sam_tag_type_char_extra [12] = {'\0', '\0', '\0', '\0', '\0', 'c', 'C', 's', 'S', 'i', 'I', 'f'} |
| | Each types SAM tag type extra char id. Index corresponds to the seqan3::detail::sam_tag_variant types.
|
| |
| template<typename int_t > |
| constexpr size_t | size_in_values_v |
| | Return the number of values an integral type can have, i.e. the difference between min and max.
|
| |
| constexpr auto | take_exactly |
| | A view adaptor that returns the first size elements from the underlying range (or less if the underlying range is shorter); also provides size information.
|
| |
| constexpr auto | take_exactly_or_throw |
| | A view adaptor that returns the first size elements from the underlying range and also exposes size information; throws if the underlying range is smaller than size.
|
| |
| constexpr auto | take_line = detail::take_until_and_consume(is_char<'\r'> || is_char<'\n'>) |
| | A view adaptor that returns a single line from the underlying range or the full range if there is no newline.
|
| |
| constexpr auto | take_line_or_throw = detail::take_until_or_throw_and_consume(is_char<'\r'> || is_char<'\n'>) |
| | A view adaptor that returns a single line from the underlying range (throws if there is no end-of-line).
|
| |
| constexpr auto | take_until |
| | A view adaptor that returns elements from the underlying range until the functor evaluates to true (or the end of the underlying range is reached).
|
| |
| constexpr auto | take_until_and_consume |
| | A view adaptor that returns elements from the underlying range until the functor evaluates to true (or the end of the underlying range is reached and consumes the end in single-pass ranges).
|
| |
| constexpr auto | take_until_or_throw |
| | A view adaptor that returns elements from the underlying range until the functor evaluates to true (throws if the end of the underlying range is reached).
|
| |
| constexpr auto | take_until_or_throw_and_consume |
| | A view adaptor that returns elements from the underlying range until the functor evaluates to true (throws if the end of the underlying range is reached and consumes the end in single-pass ranges).
|
| |
| template<typename char_type > |
| constexpr std::array< char_type, detail::size_in_values_v< char_type > > | to_lower_table |
| | Auxiliary table for seqan3::to_lower.
|
| |
| template<typename char_type > |
| constexpr std::array< char_type, detail::size_in_values_v< char_type > > | to_upper_table |
| | Auxiliary table for seqan3::to_upper.
|
| |
| template<typename lhs_t , typename tuple_derived_t , typename rhs_t , typename... component_types> |
| constexpr bool | tuple_eq_guard |
| | Prevents wrong instantiations of seqan3::alphabet_tuple_base's equality comparison operators.
|
| |
| template<typename tuple_derived_t , typename rhs_t , typename... component_types> |
| constexpr bool | tuple_general_guard |
| | Prevents wrong instantiations of seqan3::alphabet_tuple_base's equality comparison operators.
|
| |
| template<typename lhs_t , typename tuple_derived_t , typename rhs_t , typename... component_types> |
| constexpr bool | tuple_order_guard |
| | Prevents wrong instantiations of seqan3::alphabet_tuple_base's ordered comparison operators.
|
| |
| template<typename type > |
| std::string const | type_name_as_string |
| | Defines the human-readable name of the given type using the typeid operator.
|
| |
| template<typename lhs_t , typename rhs_t , bool lhs_rhs_switched, typename... alternative_types> |
| constexpr bool | variant_comparison_guard |
| | Prevents wrong instantiations of std::alphabet_variant's comparison operators.
|
| |
| template<typename other_t , typename... alternative_types> |
| constexpr bool | variant_general_guard |
| | Prevents wrong instantiations of std::alphabet_variant's constructors.
|
| |
1.9.8