SeqAn3
seqan3 Namespace Reference

The main SeqAn3 namespace. More...

Namespaces

 align_cfg
 A special sub namespace for the alignment configurations.
 
 search_cfg
 A special sub namespace for the search configurations.
 
 simd
 The SeqAn3 namespace for simd data types, algorithms and meta functions.
 
 view
 The SeqAn3 namespace for views.
 

Classes

class  aa20
 The canonical amino acid alphabet. More...
 
class  aa27
 The twenty-seven letter amino acid alphabet. More...
 
struct  align_result
 Stores the alignment results and offers a tuple-like interface. More...
 
class  aligned_allocator
 Allocates uninitialized storage whose memory-alignment is specified by alignment. More...
 
interface  aligned_sequence_concept
 The generic concept for an aligned sequence.This concept describes the requirements a sequence must fulfil in order to be part of the seqan3::alignment object. More...
 
class  alignment_file_format_sam
 The SAM format. More...
 
struct  alignment_file_header
 Stores the header information of alignment files. More...
 
struct  alignment_file_in_options
 The options type defines various option members that influence the behaviour of all or some formats. More...
 
class  alignment_file_output
 A class for writing alignment files, e.g. SAM, BAL, BLAST, ... More...
 
interface  alignment_file_output_format_concept
 The generic concept for alignment file out formats. More...
 
struct  alignment_file_output_options
 The options type defines various option members that influence the behavior of all or some formats. More...
 
class  alignment_range
 The alignment. More...
 
class  alphabet_base
 A CRTP-base that makes defining a custom alphabet easier. More...
 
interface  alphabet_concept
 The generic alphabet concept that covers most data types used in ranges.This is the core alphabet concept that many other alphabet concepts refine. More...
 
class  alphabet_proxy
 A CRTP-base that eases the definition of proxy types returned in place of regular alphabets. More...
 
struct  alphabet_size
 The size of the alphabet. [value metafunction base template]. More...
 
struct  alphabet_size< alphabet_type_with_members >
 Specialisation of seqan3::alphabet_size that delegates to alphabet_type::value_size. More...
 
struct  alphabet_size< char_type >
 Specialisation of seqan3::alphabet_size that delegates for char types. More...
 
struct  alphabet_size< uint_type >
 Specialisation of seqan3::alphabet_size that delegates for uint types. More...
 
class  aminoacid_base
 A CRTP-base that refines seqan3::alphabet_base and is used by the amino acids. More...
 
interface  aminoacid_concept
 A concept that indicates whether an alphabet represents amino acids.In addition to the requirements for seqan3::alphabet_concept, the amino_acid_concept expects conforming alphabets to provide an enum-like interface with all possible 27 amino acids as values (although some may be mapped to others if the alphabet is smaller than 27). More...
 
class  aminoacid_scoring_scheme
 A data structure for managing and computing the score of two amino acids. More...
 
class  argument_parser
 The SeqAn command line parser. More...
 
struct  argument_parser_meta_data
 Stores all parser related meta information of the seqan3::argument_parser. More...
 
interface  arithmetic_concept
 A type that satisfies std::is_arithmetic_v<t>. More...
 
struct  band_static
 Data structure for a static band. More...
 
class  bi_fm_index
 The SeqAn Bidirectional FM Index. More...
 
interface  bi_fm_index_concept
 Concept for bidirectional FM indices. More...
 
struct  bi_fm_index_default_traits
 The default Bidirectional FM Index Configuration. More...
 
class  bi_fm_index_iterator
 The SeqAn Bidirectional FM Index Iterator. More...
 
interface  bi_fm_index_iterator_concept
 Concept for bidirectional FM index iterators. More...
 
interface  bi_fm_index_traits_concept
 Concept for bidirectional FM Index traits. More...
 
class  bitcompressed_vector
 A space-optimised version of std::vector that compresses multiple letters into a single byte. More...
 
class  cartesian_composition
 The CRTP base for a combined alphabet that contains multiple values of different alphabets at the same time. More...
 
interface  cereal_archive_concept
 All archives of the Cereal library satisfy this. More...
 
interface  cereal_input_archive_concept
 All input archives of the Cereal library satisfy this. More...
 
interface  cereal_output_archive_concept
 All output archives of the Cereal library satisfy this. More...
 
interface  cereal_text_archive_concept
 All text archives of the Cereal library satisfy this. More...
 
interface  cerealisable_concept
 Specifies the requirements for types that are serialisable via Cereal. More...
 
interface  char_adaptation_concept
 A concept that covers char type adaptations for seqan3::alphabet_concept. More...
 
interface  char_concept
 This concept encompasses exactly the types char, signed char, unsigned char, wchar_t, char16_t and char32_t. More...
 
interface  compatible_concept
 Two types are "compatible" if their seqan3::dimension_v and their seqan3::innermost_value_type_t are the same. More...
 
class  concatenated_sequences
 Container that stores sequences concatenated internally. More...
 
interface  const_iterable_concept
 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. More...
 
struct  const_reference
 Type metafunction that returns the const_reference of another type [metafunction declaration]. More...
 
struct  const_reference< rng_t >
 Type metafunction that returns the const_reference of another type [specialisation for input ranges]. More...
 
class  constexpr_string
 Implements a constexpr string that can be used for compile time computations. More...
 
interface  container_concept
 The (most general) container concept as defined by the standard library. More...
 
class  debug_stream_type
 A "pretty printer" for most SeqAn data structures and related types. More...
 
struct  difference_type
 Type metafunction that returns the difference_type of another type [metafunction declaration]. More...
 
struct  difference_type< it_t >
 Type metafunction that returns the difference_type of another type [specialisation for iterators]. More...
 
struct  difference_type< rng_t >
 Type metafunction that returns the difference_type of another type [specialisation for ranges]. More...
 
class  dna15
 The 15 letter DNA alphabet, containing all IUPAC smybols minus the gap. More...
 
class  dna4
 The four letter DNA alphabet of A,C,G,T. More...
 
class  dna5
 The five letter DNA alphabet of A,C,G,T and the unknown character N. More...
 
class  dot_bracket3
 The three letter RNA structure alphabet of the characters ".()". More...
 
class  dssp9
 The protein structure alphabet of the characters "HGIEBTSCX". More...
 
interface  explicitly_convertible_to_concept
 Resolves to std::ranges::ExplicitlyConvertibleTo<type1, type2>(). More...
 
struct  fields
 A class template that holds a choice of seqan3::field. More...
 
class  file_existance_validator
 A validator that checks if a file exists. More...
 
class  file_ext_validator
 A validator that checks if a filenames has one of the valid extensions. More...
 
struct  file_open_error
 Thrown if there is an unspecified filesystem or stream error while opening, e.g. permission problem. More...
 
interface  floating_point_concept
 An arithmetic type that also satisfies std::is_floating_point_v<t>. More...
 
class  fm_index
 The SeqAn FM Index. More...
 
interface  fm_index_concept
 Concept for unidirectional FM indices. More...
 
struct  fm_index_default_traits
 The default FM Index Configuration. More...
 
class  fm_index_iterator
 The SeqAn FM Index Iterator. More...
 
interface  fm_index_iterator_concept
 Concept for unidirectional FM index iterators. More...
 
interface  fm_index_traits_concept
 Concept for unidirectional FM Index traits. More...
 
struct  format_error
 Thrown if information given to output format didn't match expectations. More...
 
struct  gap
 The alphabet of a gap character '-'. More...
 
class  gap_erase_failure
 Thrown in function seqan3::erase_gap, if a position does not contain a gap. More...
 
struct  gap_open_score
 A strong type of underlying type score_type that represents an additional score (usually negative) that is incurred once additionaly per stretch of consecutive gaps. More...
 
class  gap_scheme
 A scheme for representing and computing scores against gap characters. More...
 
struct  gap_score
 A strong type of underlying type score_type that represents the score of any character against a gap character. More...
 
interface  implicitly_convertible_to_concept
 Resolves to std::ranges::ImplicitlyConvertibleTo<type1, type2>(). More...
 
struct  innermost_value_type
 Recursively determines the value_type on containers and/or iterators [Type metafunction]. More...
 
class  integral_range_validator< option_value_type >
 A validator that checks whether a number is inside a given range. More...
 
interface  istream_concept
 Concept for input streams. More...
 
struct  lower_bound
 Type for a lower boundary. More...
 
class  mask
 Implementation of a masked alphabet to be used for cartesian compositions. More...
 
class  masked
 Implementation of a masked composition, which extends a given alphabet with a mask. More...
 
struct  match_score
 A strong type of underlying type score_type that represents the score of two matching characters. More...
 
struct  max_pseudoknot_depth
 Metafunction that indicates to what extent an alphabet can handle pseudoknots. [value metafunction base template]. More...
 
struct  max_pseudoknot_depth< alphabet_type_with_pseudoknot_attribute >
 Specialisation of seqan3::max_pseudoknot_depth that delegates to structure_type::max_pseudoknot_depth. More...
 
struct  mismatch_score
 A strong type of underlying type score_type that represents the score two different characters. More...
 
class  nucleotide_base
 A CRTP-base that refines seqan3::alphabet_base and is used by the nucleotides. More...
 
interface  nucleotide_concept
 A concept that indicates whether an alphabet represents nucleotides.In addition to the requirements for seqan3::alphabet_concept, the nucleotide_concept introduces a requirement for a complement function: seqan3::nucleotide_concept::complement. More...
 
class  nucleotide_scoring_scheme
 A data structure for managing and computing the score of two nucleotides. More...
 
class  option_declared_multiple_times
 Argument parser exception thrown when a non-list option is declared multiple times. More...
 
interface  ostream_concept
 Concept for output streams. More...
 
class  overflow_error_on_conversion
 Argument parser exception thrown when an argument could not be casted to the according type. More...
 
struct  parse_asserter
 A condition checker, that wraps a parse condition and throws a specified exception if the condition was not met. More...
 
struct  parse_error
 Thrown if there is a parse error, such as reading an unexpected character from an input stream. More...
 
class  parser_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). More...
 
class  parser_interruption
 This exception is not an error but expected behavior that shall terminate the program (e.g. when printing the help page). More...
 
class  parser_invalid_argument
 Argument parser exception that is thrown whenever there is an error while parsing the command line arguments. More...
 
class  phred42
 Quality type for traditional Sanger and modern Illumina Phred scores (typical range). More...
 
class  phred63
 Quality type for traditional Sanger and modern Illumina Phred scores (full range). More...
 
class  phred68legacy
 Quality type for Solexa and deprecated Illumina formats. More...
 
struct  pod_tuple
 cond More...
 
struct  pod_tuple< type0 >
 Recursion anchor for pod_tuple. More...
 
struct  pod_tuple< type0, types... >
 endcond More...
 
class  qualified
 Joins an arbitrary alphabet with a quality alphabet. More...
 
class  quality_base
 A CRTP-base that refines seqan3::alphabet_base and is used by the quality alphabets. More...
 
interface  quality_concept
 A concept that indicates whether an alphabet represents quality scores.In addition to the requirements for seqan3::alphabet_concept, the quality_concept introduces a requirement for conversion functions from and to a Phred score. More...
 
interface  random_access_container_concept
 A more refined container concept than seqan3::sequence_container_concept. More...
 
struct  record
 The class template that file records are based on; behaves like an std::tuple. More...
 
struct  reference
 Type metafunction that returns the reference of another type [metafunction declaration]. More...
 
struct  reference< it_t >
 Type metafunction that returns the reference of another type [specialisation for input iterators]. More...
 
struct  reference< rng_t >
 Type metafunction that returns the reference of another type [specialisation for input ranges]. More...
 
class  regex_validator< std::string >
 A validator that checks if a matches a regular expression pattern. More...
 
class  regex_validator< std::vector< std::string > >
 A validator that checks if each value in a container satisfies a regex expression. More...
 
class  required_option_missing
 Argument parser exception thrown when a required option is missing. More...
 
interface  reservable_container_concept
 A more refined container concept than seqan3::random_access_container_concept. More...
 
class  rna15
 The 15 letter RNA alphabet, containing all IUPAC smybols minus the gap. More...
 
class  rna4
 The four letter RNA alphabet of A,C,G,U. More...
 
class  rna5
 The five letter RNA alphabet of A,C,G,U and the unknown character N. More...
 
interface  rna_structure_concept
 A concept that indicates whether an alphabet represents RNA structure. More...
 
struct  rvalue_reference
 Type metafunction that returns the rvalue_reference of another type [metafunction declaration]. More...
 
struct  rvalue_reference< it_t >
 Type metafunction that returns the rvalue_reference of another type [specialisation for input iterators]. More...
 
struct  rvalue_reference< rng_t >
 Type metafunction that returns the rvalue_reference of another type [specialisation for input ranges]. More...
 
class  sam_tag_dictionary
 The SAM tag dictionary class that stores all optional SAM fields. More...
 
struct  sam_tag_type
 The generic base class. More...
 
class  scoring_scheme_base
 A CRTP base class for scoring schemes. More...
 
interface  scoring_scheme_concept
 A concept that requires that type be able to score two letters. More...
 
interface  semi_alphabet_concept
 The basis for seqan3::alphabet_concept, but requires only rank interface (not char). More...
 
interface  sequence_container_concept
 A more refined container concept than seqan3::container_concept. More...
 
class  sequence_file_format_fasta
 The FastA format. More...
 
class  sequence_file_format_fastq
 The FastQ format. More...
 
class  sequence_file_input
 A class for reading sequence files, e.g. FASTA, FASTQ ... More...
 
struct  sequence_file_input_default_traits_aa
 A traits type that specifies input as amino acids. More...
 
struct  sequence_file_input_default_traits_dna
 The default traits for seqan3::sequence_file_input. More...
 
interface  sequence_file_input_format_concept
 The generic concept for sequence file in formats. More...
 
struct  sequence_file_input_options
 The options type defines various option members that influence the behaviour of all or some formats. More...
 
interface  sequence_file_input_traits_concept
 The requirements a traits_type for seqan3::sequence_file_input must meet. More...
 
class  sequence_file_output
 A class for writing sequence files, e.g. FASTA, FASTQ ... More...
 
interface  sequence_file_output_format_concept
 The generic concept for sequence file out formats. More...
 
struct  sequence_file_output_options
 The options type defines various option members that influence the behaviour of all or some formats. More...
 
struct  size_type
 Type metafunction that returns the size_type of another type [metafunction declaration]. More...
 
struct  size_type< it_t >
 Type metafunction that returns the size_type of another type [specialisation for iterators]. More...
 
struct  size_type< rng_t >
 Type metafunction that returns the size_type of another type [specialisation for sized ranges]. More...
 
interface  standard_layout_concept
 Resolves to std::is_standard_layout_v<t>. More...
 
interface  stream_concept
 Concept for i/o streams permitting both directions.An object satisfying the requirements of a stream concept can be used to stream in both (input and output) directions. More...
 
class  structure_file_format_vienna
 The Vienna format (dot bracket notation) for RNA sequences with secondary structure. More...
 
class  structure_file_in
 A class for reading structured sequence files, e.g. Stockholm, Connect, Vienna, ViennaRNA bpp matrix ... More...
 
struct  structure_file_input_default_traits_aa
 A traits type that specifies input as amino acids. More...
 
struct  structure_file_input_default_traits_rna
 The default traits for seqan3::structure_file_in. More...
 
interface  structure_file_input_format_concept
 The generic concept for structure file in formats. More...
 
struct  structure_file_input_options
 The options type defines various option members that influence the behaviour of all or some formats. More...
 
interface  structure_file_input_traits_concept
 The requirements a traits_type for seqan3::structure_file_in must meet. More...
 
class  structure_file_out
 A class for writing structured sequence files, e.g. Stockholm, Connect, Vienna, ViennaRNA bpp matrix ... More...
 
interface  structure_file_output_format_concept
 The generic concept for sequence file out formats. More...
 
struct  structure_file_output_options
 The options type defines various option members that influence the behaviour of all or some formats. More...
 
class  structured_aa
 A seqan3::cartesian_composition that joins an aminoacid alphabet with a protein structure alphabet. More...
 
class  structured_rna
 A seqan3::cartesian_composition that joins a nucleotide alphabet with an RNA structure alphabet. More...
 
class  too_few_arguments
 Argument parser exception thrown when too few arguments are provided. More...
 
class  too_many_arguments
 Argument parser exception thrown when too many arguments are provided. More...
 
interface  trivial_concept
 A type that satisfies seqan3::trivially_copyable_concept and seqan3::trivially_destructible_concept. More...
 
interface  trivially_copyable_concept
 A type that satisfies std::is_trivially_copyable_v<t>. More...
 
interface  trivially_destructible_concept
 A type that satisfies std::is_trivially_destructible_v<t>. More...
 
interface  tuple_like_concept
 Whether a type behaves like a tuple. More...
 
class  type_conversion_failed
 Argument parser exception thrown when an argument could not be casted to the according type. More...
 
interface  uint_adaptation_concept
 A concept that covers uint type adaptations for seqan3::alphabet_concept. More...
 
struct  underlying_char
 The char_type of the alphabet. [type metafunction base template]. More...
 
struct  underlying_char< alphabet_type_with_members >
 Specialisation of seqan3::underlying_char that delegates to typename alphabet_type::char_type. More...
 
struct  underlying_char< char_type >
 Specialisation of seqan3::underlying_char for char types. More...
 
struct  underlying_char< uint_type >
 Specialisation of seqan3::underlying_char for uint types. More...
 
struct  underlying_phred
 
struct  underlying_phred< alphabet_with_member_type >
 The internal phred type. More...
 
struct  underlying_rank
 The rank_type of the semi_alphabet. [type metafunction base template]. More...
 
struct  underlying_rank< alphabet_type_with_members >
 Specialisation of seqan3::underlying_rank that delegates to typename alphabet_type::rank_type. More...
 
struct  underlying_rank< char_type >
 Specialisation of seqan3::underlying_rank for char types. More...
 
struct  underlying_rank< uint_type >
 Specialisation of seqan3::underlying_rank for uint types. More...
 
struct  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. More...
 
struct  unhandled_extension_error
 Thrown if there is no format that accepts a given file extension. More...
 
class  union_composition
 A combined alphabet that can hold values of either of its alternatives. More...
 
class  unknown_option
 Argument parser exception thrown when encountering unknown option. More...
 
struct  upper_bound
 Type for an upper boundary. More...
 
class  validation_failed
 Argument parser exception thrown when an argument could not be casted to the according type. More...
 
interface  validator_concept
 The concept for option validators passed to add_option/positional_option. More...
 
class  value_list_validator
 A validator that checks whether a value is inside a list of valid values. More...
 
class  value_list_validator< option_value_type >
 A validator that checks if each value in a container appears in a list of valid values. More...
 
struct  value_type
 Type metafunction that returns the value_type of another type [metafunction declaration]. More...
 
struct  value_type< it_t >
 Type metafunction that returns the value_type of another type [specialisation for input iterators]. More...
 
struct  value_type< rng_t >
 Type metafunction that returns the value_type of another type [specialisation for input ranges]. More...
 
interface  weakly_assignable_concept
 Resolves to std::is_assignable_v<t>. More...
 
interface  weakly_ordered_with_concept
 Requires the two operands to be comparable with == and != in both directions. More...
 
class  wuss
 The WUSS structure alphabet of the characters .<>:,-_~;()[]{}AaBbCcDd... More...
 

Typedefs

template<typename t >
using const_reference_t = typename const_reference< t >::type
 Type metafunction shortcut for seqan3::const_reference. More...
 
template<typename t >
using difference_type_t = typename difference_type< t >::type
 Type metafunction shortcut for seqan3::difference_type. More...
 
using dna15q = qualified< dna15, phred42 >
 An alphabet that stores a seqan3::dna15 letter and an seqan3::qualified letter at each position.
 
using dna4q = qualified< dna4, phred42 >
 An alphabet that stores a seqan3::dna4 letter and an seqan3::phred42 letter at each position.
 
using dna5q = qualified< dna5, phred42 >
 An alphabet that stores a seqan3::dna5 letter and an seqan3::phred42 letter at each position.
 
template<typename alphabet_t >
using gapped = union_composition< alphabet_t, gap >
 Extends a given alphabet with a gap character. More...
 
template<typename t >
using innermost_value_type_t = typename innermost_value_type< t >::type
 Shortcut for seqan3::innermost_value_type.
 
template<typename t >
using reference_t = typename reference< t >::type
 Type metafunction shortcut for seqan3::reference. More...
 
template<typename t >
using remove_cvref_t = std::remove_cv_t< std::remove_reference_t< t > >
 Return the input type with const, volatile and references removed [Type metafunction]. More...
 
using rna15q = qualified< rna15, phred42 >
 An alphabet that stores a seqan3::rna15 letter and an seqan3::qualified letter at each position.
 
using rna4q = qualified< rna4, phred42 >
 An alphabet that stores a seqan3::rna4 letter and an seqan3::phred42 letter at each position.
 
using rna5q = qualified< rna5, phred42 >
 An alphabet that stores a seqan3::rna5 letter and an seqan3::phred42 letter at each position.
 
template<typename t >
using rvalue_reference_t = typename rvalue_reference< t >::type
 Type metafunction shortcut for seqan3::rvalue_reference. More...
 
template<uint16_t tag_value>
using sam_tag_type_t = typename sam_tag_type< tag_value >::type
 Short cut helper for seqan3::sam_tag_type::type.
 
template<typename t >
using size_type_t = typename size_type< t >::type
 Type metafunction shortcut for seqan3::size_type. More...
 
template<typename ... types>
using type_list = meta::list< types... >
 Type that contains multiple types, an alias for meta::list.
 
template<typename t >
using value_type_t = typename value_type< t >::type
 Type metafunction shortcut for seqan3::value_type. More...
 
typedef wuss< 51 > wuss51
 Alias for the default type wuss51.
 

Enumerations

enum  align_result_key : uint8_t {
  id, score, end, begin,
  trace
}
 Keys for different alignment results.
 
enum  aminoacid_similarity_matrix { aminoacid_similarity_matrix::BLOSUM30, aminoacid_similarity_matrix::BLOSUM45, aminoacid_similarity_matrix::BLOSUM62, aminoacid_similarity_matrix::BLOSUM80 }
 Identifiers for amino acid similarity matrixes. More...
 
enum  field {
  field::SEQ, field::ID, field::QUAL, field::SEQ_QUAL,
  field::OFFSET, field::BPP, field::STRUCTURE, field::STRUCTURED_SEQ,
  field::ENERGY, field::REACT, field::REACT_ERR, field::COMMENT,
  field::ALIGNMENT, field::REF_ID, field::REF_SEQ, field::REF_OFFSET,
  field::HEADER_PTR, field::FLAG, field::MATE, field::MAPQ,
  field::TAGS, field::BIT_SCORE, field::EVALUE, field::USER_DEFINED_0,
  field::USER_DEFINED_1, field::USER_DEFINED_2, field::USER_DEFINED_3, field::USER_DEFINED_4,
  field::USER_DEFINED_5, field::USER_DEFINED_6, field::USER_DEFINED_7, field::USER_DEFINED_8,
  field::USER_DEFINED_9
}
 An enumerator for the fields used in file formats.Some of the fields are shared between formats. More...
 
enum  fmtflags2 {
  none = 0, none = 0b0000, utf8 = 1, small_int_as_number = 1 << 1,
  default_ = small_int_as_number
}
 Flags that change the behaviour of the seqan3::debug_stream. More...
 
enum  free_ends_at : uint8_t {
  none = 0b0000, free_ends_at::seq1_front = 0b0001, free_ends_at::seq1_back = 0b0010, free_ends_at::seq2_front = 0b0100,
  free_ends_at::seq2_back = 0b1000, free_ends_at::seq1 = seq1_front | seq1_back, free_ends_at::seq2 = seq2_front | seq2_back, free_ends_at::all = seq1 | seq2
}
 Enum class for all supported sequence ends specifications. More...
 
enum  genetic_code : uint8_t { CANONICAL =1 }
 Genetic codes used for translation of nucleotides into amino acids. More...
 
enum  option_spec { DEFAULT = 0, REQUIRED = 1, ADVANCED = 2, HIDDEN = 4 }
 Used to further specify argument_parser options/flags. More...
 
enum  translation_frames : uint8_t {
  translation_frames::FWD_FRAME_0 = 1, translation_frames::FWD_FRAME_1 = 1 << 1, translation_frames::FWD_FRAME_2 = 1 << 2, translation_frames::REV_FRAME_0 = 1 << 3,
  translation_frames::REV_FRAME_1 = 1 << 4, translation_frames::REV_FRAME_2 = 1 << 5, translation_frames::FWD_REV_0 = FWD_FRAME_0 | REV_FRAME_0, translation_frames::FWD_REV_1 = FWD_FRAME_1 | REV_FRAME_1,
  translation_frames::FWD_REV_2 = FWD_FRAME_2 | REV_FRAME_2, translation_frames::FWD = FWD_FRAME_0 | FWD_FRAME_1 | FWD_FRAME_2, translation_frames::REV = REV_FRAME_0 | REV_FRAME_1 | REV_FRAME_2, translation_frames::SIX_FRAME = FWD | REV
}
 Specialisation values for single and multiple translation frames. More...
 

Functions

template<typename char_t , char_t ... s>
constexpr uint16_t operator""_tag ()
 The SAM tag literal, such that tags can be used in constant expressions. More...
 
template<typename simd_t >
debug_stream_typeoperator<< (debug_stream_type &s, simd_t &&simd)
 Overload for debug_stream for simd types.
 
template<tuple_like_concept tuple_t>
debug_stream_typeoperator<< (debug_stream_type &stream, tuple_t const &alignment)
 Streaming operator for alignments, which are represented as tuples of aligned sequences. More...
 
template<validator_concept validator1_type, validator_concept validator2_type>
auto operator| (validator1_type &&vali1, validator2_type &&vali2)
 Enables the chaining of validators. ! More...
 
template<fm_index_concept index_t, typename queries_t , typename configuration_t >
auto search (index_t const &index, queries_t &&queries, configuration_t const &cfg)
 Search a query or a range of queries in an index. More...
 
template<fm_index_concept index_t, typename queries_t >
auto search (index_t const &index, queries_t &&queries)
 Search a query or a range of queries in an index. It will not allow for any errors and will output all matches as positions in the text. More...
 
template<genetic_code gc = genetic_code::CANONICAL, nucleotide_concept nucl_type>
constexpr aa27 translate_triplet (nucl_type const &n1, nucl_type const &n2, nucl_type const &n3) noexcept
 Translate one nucleotide triplet into single amino acid (single nucleotide interface). More...
 
template<genetic_code gc = genetic_code::CANONICAL, typename tuple_type >
constexpr aa27 translate_triplet (tuple_type const &input_tuple) noexcept
 Translate one nucleotide triplet into single amino acid (tuple interface). More...
 
template<genetic_code gc = genetic_code::CANONICAL, std::ranges::InputRange range_type>
constexpr aa27 translate_triplet (range_type &&input_range)
 Translate one nucleotide triplet into single amino acid (range interface). More...
 
Enum-based get-interface

Provides a special overload for the get interface using seqan3::search_cfg::id as identifier.

Helpers for seqan3::semi_alphabet_concept

These functions and metafunctions expose member variables and types so that they satisfy seqan3::semi_alphabet_concept.

template<typename alphabet_type >
constexpr underlying_rank_t< alphabet_type > to_rank (alphabet_type const alph) requires requires(alphabet_type alph)
 Implementation of seqan3::semi_alphabet_concept::to_rank() that delegates to a member function. More...
 
template<typename alphabet_type >
constexpr alphabet_type & assign_rank (alphabet_type &alph, underlying_rank_t< alphabet_type > const rank) requires requires(alphabet_type alph)
 Implementation of seqan3::semi_alphabet_concept::assign_rank() that delegates to a member function. More...
 
template<typename alphabet_type >
constexpr alphabet_type && assign_rank (alphabet_type &&alph, underlying_rank_t< alphabet_type > const rank) requires requires(alphabet_type alph)
 Implementation of seqan3::semi_alphabet_concept::assign_rank() that delegates to a member function. More...
 
Helpers for seqan3::alphabet_concept

These functions and metafunctions expose member variables and types so that they satisfy seqan3::alphabet_concept.

template<typename alphabet_type >
constexpr underlying_char_t< alphabet_type > to_char (alphabet_type const alph) requires requires(alphabet_type alph)
 Implementation of seqan3::alphabet_concept::to_char() that delegates to a member function. More...
 
template<typename alphabet_type >
constexpr alphabet_type & assign_char (alphabet_type &alph, underlying_char_t< alphabet_type > const chr) requires requires(alphabet_type alph)
 Implementation of seqan3::alphabet_concept::assign_char() that delegates to a member function. More...
 
template<typename alphabet_type >
constexpr alphabet_type && assign_char (alphabet_type &&alph, underlying_char_t< alphabet_type > const chr) requires requires(alphabet_type alph)
 Implementation of seqan3::alphabet_concept::assign_char() that delegates to a member function. More...
 
Helpers for seqan3::nucleotide_concept

These functions and metafunctions expose member variables and types so that they satisfy seqan3::nucleotide_concept.

Binary operators for scoped enums

Perform binary operations like on ints or weak enums. These overloads are available if seqan3::add_enum_bitwise_operators is defined for your type.

See also
seqan3::add_enum_bitwise_operators
template<typename t >
constexpr t operator & (t lhs, t rhs) noexcept requires std
 
template<typename t >
constexpr t operator| (t lhs, t rhs) noexcept requires std
 
template<typename t >
constexpr t operator^ (t lhs, t rhs) noexcept requires std
 
template<typename t >
constexpr t operator~ (t lhs) noexcept requires std
 
template<typename t >
constexpr t & operator &= (t &lhs, t rhs) noexcept requires std
 
template<typename t >
constexpr t & operator|= (t &lhs, t rhs) noexcept requires std
 
template<typename t >
constexpr t & operator^= (t &lhs, t rhs) noexcept requires std
 
Tuple utility functions

Helper functions for tuple like objects.

template<size_t pivot_c, template< typename ... > typename tuple_t, typename ... ts>
constexpr auto tuple_split (tuple_t< ts... > const &t)
 Splits a tuple like data structure at the given position. More...
 
template<size_t pivot_c, template< typename ... > typename tuple_t, typename ... ts>
constexpr auto tuple_split (tuple_t< ts... > &&t)
 Splits a tuple like data structure at the given position. More...
 
template<typename pivot_t , tuple_like_concept tuple_t>
constexpr auto tuple_split (tuple_t &&t)
 Splits a tuple like data structure at the first position of the given type. More...
 
template<tuple_like_concept tuple_t>
constexpr auto tuple_pop_front (tuple_t &&t)
 Removes the first element of a tuple. More...
 
Operations on characters
template<char_concept char_type>
constexpr char_type to_lower (char_type const c) noexcept
 Converts 'A'-'Z' to 'a'-'z' respectively; other characters are returned as is. More...
 
template<char_concept char_type>
constexpr char_type to_upper (char_type const c) noexcept
 Converts 'a'-'z' to 'A'-'Z' respectively; other characters are returned as is. More...
 

Variables

template<typename t >
constexpr bool add_enum_bitwise_operators = false
 Set to true for a scoped enum to have binary operators overloaded. More...
 
template<>
constexpr bool add_enum_bitwise_operators< fmtflags2 > = true
 Overload bitwise operators for seqan3::fmtflags2.
 
template<>
constexpr bool add_enum_bitwise_operators< translation_frames > = true
 Enable bitwise operators for enum translation_frames.
 
debug_stream_type debug_stream {}
 A global instance of seqan3::debug_stream_type.
 
template<typename t >
constexpr size_t dimension_v = 1
 Returns the number of times you can call seqan3::value_type_t recursively on t [Value metafunction]. More...
 
std::string const seqan3_version
 The full version as std::string. More...
 
constexpr uint8_t seqan3_version_major = SEQAN3_VERSION_MAJOR
 The major version.
 
constexpr uint8_t seqan3_version_minor = SEQAN3_VERSION_MINOR
 The minor version.
 
constexpr uint8_t seqan3_version_patch = SEQAN3_VERSION_PATCH
 The patch version.
 
Parse conditions

Parse conditions are function like objects that can be used to check if a character c fulfills certain constraints. SeqAn3 implements all parse condition also available in the standard library and some more.

Disjunction and Negation

In contrast to the standard library (where the checks are implemented as functions), the functors in SeqAn3 can be joined efficiently, maintaining constant-time evaluation independent of the number of checks. Functors can be combined with the ||-operator or negated via the !-operator:

auto constexpr my_cond = is_char<'%'> || is_digit;
bool is_percent = my_cond(*example_it);

Defining complex combinations and using them in e.g. input/output can increase speed significantly over checking multiple functions: we measured speed-ups of 10x for a single check and speed-ups of over 20x for complex combinations.

Custom conditions

Standard library conditions

SeqAn offers the 12 conditions exactly as defined in the standard library except that we have introduced an underscore in the name to be consistent with our other naming.

The following table lists the predefined parse conditions and which constraints are associated with them.

ASCII values characters

is_cntrl

is_print

is_space

is_blank

is_graph

is_punct

is_alnum

is_alpha

is_upper

is_lower

is_digit

is_xdigit

decimal hexadecimal octal
0–8 \x0\x8 \0\10 control codes (NUL, etc.) ≠0 0 0 0 0 0 0 0 0 0 0 0
9 \x9 \11 tab (\t) ≠0 0 ≠0 ≠0 0 0 0 0 0 0 0 0
10–13 \xA\xD \12\15 whitespaces (\n, \v, \f, \r) ≠0 0 ≠0 0 0 0 0 0 0 0 0 0
14–31 \xE\x1F \16\37 control codes ≠0 0 0 0 0 0 0 0 0 0 0 0
32 \x20 \40 space 0 ≠0 ≠0 ≠0 0 0 0 0 0 0 0 0
33–47 \x21\x2F \41\57 !"#$%&'()*+,-./ 0 ≠0 0 0 ≠0 ≠0 0 0 0 0 0 0
48–57 \x30\x39 \60\71 0123456789 0 ≠0 0 0 ≠0 0 ≠0 0 0 0 ≠0 ≠0
58–64 \x3A\x40 \72\100 :;<=>?@ 0 ≠0 0 0 ≠0 ≠0 0 0 0 0 0 0
65–70 \x41\x46 \101\106 ABCDEF 0 ≠0 0 0 ≠0 0 ≠0 ≠0 ≠0 0 0 ≠0
71–90 \x47\x5A \107\132 GHIJKLMNOP
QRSTUVWXYZ
0 ≠0 0 0 ≠0 0 ≠0 ≠0 ≠0 0 0 0
91–96 \x5B\x60 \133\140 []^_` 0 ≠0 0 0 ≠0 ≠0 0 0 0 0 0 0
97–102 \x61\x66 \141\146 abcdef 0 ≠0 0 0 ≠0 0 ≠0 ≠0 0 ≠0 0 ≠0
103–122 \x67\x7A \147\172 ghijklmnop
qrstuvwxyz
0 ≠0 0 0 ≠0 0 ≠0 ≠0 0 ≠0 0 0
123–126 \x7B\x7E \172\176 {|}~ 0 ≠0 0 0 ≠0 ≠0 0 0 0 0 0 0
127 \x7F \177 backspace character (DEL) ≠0 0 0 0 0 0 0 0 0 0 0 0


template<uint8_t interval_first, uint8_t interval_last>
detail::is_in_interval_type< interval_first, interval_last > constexpr is_in_interval {}
 Checks whether a given letter is in the specified interval. More...
 
template<alphabet_concept alphabet_t>
detail::is_in_alphabet_type< alphabet_t > constexpr is_in_alphabet {}
 Checks whether a given letter is valid for the specified seqan3::alphabet_concept. More...
 
template<int char_v>
detail::is_char_type< char_v > constexpr is_char
 Checks whether a given letter is the same as the template non-type argument. More...
 
auto constexpr is_eof = is_char<EOF>
 Checks whether a given letter is equal to the EOF constant defined in <cstdio>. More...
 
auto constexpr is_cntrl
 Checks whether c is a control character. More...
 
auto constexpr is_print = is_in_interval<' ', '~'>
 Checks whether c is a printable character. More...
 
auto constexpr is_space = is_in_interval<'\t', '\r'> || is_char<' '>
 Checks whether c is a space character. More...
 
auto constexpr is_blank = is_char<'\t'> || is_char<' '>
 Checks whether c is a blank character. More...
 
auto constexpr is_graph = is_in_interval<'!', '~'>
 Checks whether c is a graphic character. More...
 
auto constexpr is_punct
 Checks whether c is a punctuation character. More...
 
auto constexpr is_alnum
 Checks whether c is a alphanumeric character. More...
 
auto constexpr is_alpha = is_in_interval<'A', 'Z'> || is_in_interval<'a', 'z'>
 Checks whether c is a alphabetical character. More...
 
auto constexpr is_upper = is_in_interval<'A', 'Z'>
 Checks whether c is a upper case character. More...
 
auto constexpr is_lower = is_in_interval<'a', 'z'>
 Checks whether c is a lower case character. More...
 
auto constexpr is_digit = is_in_interval<'0', '9'>
 Checks whether c is a digital character. More...
 
auto constexpr is_xdigit
 Checks whether c is a hexadecimal character. More...
 

Helpers for seqan3::quality_concept

These functions and metafunctions expose member variables and types so that the type can model the seqan3::quality_concept.

template<typename alphabet_type >
using underlying_phred_t = typename underlying_phred< alphabet_type >::type
 The internal phred type. More...
 
template<typename alphabet_type >
constexpr alphabet_type & assign_phred (alphabet_type &chr, char const in)
 The public setter function of a phred score. More...
 
template<typename alphabet_type >
constexpr alphabet_type assign_phred (alphabet_type &&chr, char const in)
 
template<typename alphabet_type >
constexpr underlying_phred_t< alphabet_type > to_phred (alphabet_type const &chr)
 The public getter function for the phred representation of a score. More...
 

Detailed Description

The main SeqAn3 namespace.

Enumeration Type Documentation

◆ genetic_code

enum seqan3::genetic_code : uint8_t
strong

Genetic codes used for translation of nucleotides into amino acids.

The numeric values of the enums correspond to the genbank transl_table values (see http://www.ncbi.nlm.nih.gov/Taxonomy/Utils/wprintgc.cgi).

◆ translation_frames

enum seqan3::translation_frames : uint8_t
strong

Specialisation values for single and multiple translation frames.

Enumerator
FWD_FRAME_0 

The first forward frame starting at position 0.

FWD_FRAME_1 

The second forward frame starting at position 1.

FWD_FRAME_2 

The third forward frame starting at position 2.

REV_FRAME_0 

The first reverse frame starting at position 0.

REV_FRAME_1 

The second reverse frame starting at position 1.

REV_FRAME_2 

The third reverse frame starting at position 2.

FWD_REV_0 

The first forward and first reverse frame.

FWD_REV_1 

The second forward and second reverse frame.

FWD_REV_2 

The first third and third reverse frame.

FWD 

All forward frames.

REV 

All reverse frames.

SIX_FRAME 

All frames.

Function Documentation

◆ assign_char() [1/2]

template<typename alphabet_type >
constexpr alphabet_type& seqan3::assign_char ( alphabet_type &  alph,
underlying_char_t< alphabet_type > const  chr 
)

Implementation of seqan3::alphabet_concept::assign_char() that delegates to a member function.

Template Parameters
alphabet_typeMust provide an .assign_char() member function.
Parameters
alphThe alphabet letter that you wish to assign to.
chrThe char value you wish to assign.
Returns
A reference to the alphabet letter you passed in.

◆ assign_char() [2/2]

template<typename alphabet_type >
constexpr alphabet_type&& seqan3::assign_char ( alphabet_type &&  alph,
underlying_char_t< alphabet_type > const  chr 
)

Implementation of seqan3::alphabet_concept::assign_char() that delegates to a member function.

Template Parameters
alphabet_typeMust provide an .assign_char() member function.
Parameters
alphAn alphabet letter temporary.
chrThe char value you wish to assign.
Returns
The assignment result as a temporary.

Use this e.g. to newly create alphabet letters from char:

auto l = assign_char(dna5{}, 'G'); // l is of type dna5

◆ assign_rank() [1/2]

template<typename alphabet_type >
constexpr alphabet_type& seqan3::assign_rank ( alphabet_type &  alph,
underlying_rank_t< alphabet_type > const  rank 
)

Implementation of seqan3::semi_alphabet_concept::assign_rank() that delegates to a member function.

Template Parameters
alphabet_typeMust provide an .assign_rank() member function.
Parameters
alphThe alphabet letter that you wish to assign to.
rankThe rank value you wish to assign.
Returns
A reference to the alphabet letter you passed in.

◆ assign_rank() [2/2]

template<typename alphabet_type >
constexpr alphabet_type&& seqan3::assign_rank ( alphabet_type &&  alph,
underlying_rank_t< alphabet_type > const  rank 
)

Implementation of seqan3::semi_alphabet_concept::assign_rank() that delegates to a member function.

Template Parameters
alphabet_typeMust provide an .assign_rank() member function.
Parameters
alphAn alphabet letter temporary.
rankThe rank value you wish to assign.
Returns
The assignment result as a temporary.

Use this e.g. to newly create alphabet letters from rank:

auto l = assign_rank(dna5{}, 1); // l is of type dna5 and == 'C'_dna5

◆ complement()

template<typename nucleotide_type >
constexpr nucleotide_type seqan3::complement ( nucleotide_type const  alph)
related

Implementation of seqan3::nucleotide_concept::complement() that delegates to a member function.

Template Parameters
nucleotide_typeMust provide a .complement() member function.
Parameters
alphThe alphabet letter for whom you wish to receive the complement.
Returns
The letter's complement, e.g. 'T' for 'A'.

◆ get() [1/3]

template<align_cfg::id e, typename ... cfg_elements_t>
constexpr auto const& seqan3::get ( detail::configuration< cfg_elements_t... > const &  cfg)
related

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

◆ get() [2/3]

template<align_cfg::id e, typename ... cfg_elements_t>
constexpr auto&& seqan3::get ( detail::configuration< cfg_elements_t... > &&  cfg)
related

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

◆ get() [3/3]

template<align_cfg::id e, typename ... cfg_elements_t>
constexpr auto const&& seqan3::get ( detail::configuration< cfg_elements_t... > const &&  cfg)
related

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

◆ operator""_tag()

template<typename char_t , char_t ... s>
constexpr uint16_t seqan3::operator""_tag ( )

The SAM tag literal, such that tags can be used in constant expressions.

Template Parameters
char_tThe char type. Usually char. Parameter pack ...s must be of length 2, since SAM tags consist of two letters (char0 and char1).
Returns
The unique identifier of the SAM tag computed by char0 * 128 + char1.

A SAM tag consists of two letters, initialized via the string literal ""_tag, which delegate to its unique id. e.g.

using namespace seqan3;
// ...
uint16_t tag_id = "NM"_tag; // tag_id = 10061

The purpose of those tags is to fill or query the seqan3::sam_tag_dictionary for a specific key (tag_id) and retrieve the corresponding value.

See also
seqan3::sam_tag_dictionary

◆ operator<<()

template<tuple_like_concept tuple_t>
debug_stream_type& seqan3::operator<< ( debug_stream_type stream,
tuple_t const &  alignment 
)
inline

Streaming operator for alignments, which are represented as tuples of aligned sequences.

Template Parameters
tuple_tThe alignment type, must satisfy tuple_like_concept and its size must be at least 2.
Parameters
streamThe target stream for the formatted output.
alignmentThe alignment that shall be formatted. All sequences must be equally long.
Returns
The given stream to which the alignment representation is appended.

◆ to_char()

template<typename alphabet_type >
constexpr underlying_char_t<alphabet_type> seqan3::to_char ( alphabet_type const  alph)

Implementation of seqan3::alphabet_concept::to_char() that delegates to a member function.

Template Parameters
alphabet_typeMust provide a .to_char() member function.
Parameters
alphThe alphabet letter that you wish to convert to char.
Returns
The letter's value in the alphabet's rank type (usually char).

◆ to_lower()

template<char_concept char_type>
constexpr char_type seqan3::to_lower ( char_type const  c)
noexcept

Converts 'A'-'Z' to 'a'-'z' respectively; other characters are returned as is.

Template Parameters
char_typeType of the parameter; must model seqan3::char_concept.
Parameters
cThe parameter.
Returns
The character converted to lower case.

In contrast to std::tolower this function is independent of locale and can be evaluated in a constexpr context.

◆ to_rank()

template<typename alphabet_type >
constexpr underlying_rank_t<alphabet_type> seqan3::to_rank ( alphabet_type const  alph)

Implementation of seqan3::semi_alphabet_concept::to_rank() that delegates to a member function.

Template Parameters
alphabet_typeMust provide a .to_rank() member function.
Parameters
alphThe alphabet letter that you wish to convert to rank.
Returns
The letter's value in the alphabet's rank type (usually a uint*_t).

◆ to_upper()

template<char_concept char_type>
constexpr char_type seqan3::to_upper ( char_type const  c)
noexcept

Converts 'a'-'z' to 'A'-'Z' respectively; other characters are returned as is.

Template Parameters
char_typeType of the parameter; must model seqan3::char_concept.
Parameters
cThe parameter.
Returns
The character converted to upper case.

In contrast to std::to_upper this function is independent of locale and can be evaluated in a constexpr context.

◆ translate_triplet() [1/3]

template<genetic_code gc = genetic_code::CANONICAL, nucleotide_concept nucl_type>
constexpr aa27 seqan3::translate_triplet ( nucl_type const &  n1,
nucl_type const &  n2,
nucl_type const &  n3 
)
noexcept

Translate one nucleotide triplet into single amino acid (single nucleotide interface).

Template Parameters
nucl_typeThe type of input nucleotides.
Parameters
[in]n1First nucleotide in triplet.
[in]n2Second nucleotide in triplet.
[in]n3Third nucleotide in triplet.

Translates single nucleotides into amino acid according to given genetic code.

Complexity

Constant.

Exceptions

No-throw guarantee.

◆ translate_triplet() [2/3]

template<genetic_code gc = genetic_code::CANONICAL, typename tuple_type >
constexpr aa27 seqan3::translate_triplet ( tuple_type const &  input_tuple)
noexcept

Translate one nucleotide triplet into single amino acid (tuple interface).

Template Parameters
tuple_typeType of input_tuple. Usually std::tuple, but similar types like std::array and seqan3::pod_tuple are also supported.
Parameters
[in]input_tupleTriplet of nucleotides that should be converted to amino acid.

Translates std::tuple or std::array with 3 nucleotides into amino acid according to given genetic code.

Complexity

Constant.

Exceptions

No-throw guarantee.

◆ translate_triplet() [3/3]

template<genetic_code gc = genetic_code::CANONICAL, std::ranges::InputRange range_type>
constexpr aa27 seqan3::translate_triplet ( range_type &&  input_range)

Translate one nucleotide triplet into single amino acid (range interface).

Translate one nucleotide triplet into single amino acid (range interface, input range allows random access).

Template Parameters
range_typeType of input_range; must satisfy std::ranges::InputRange.
Parameters
[in]input_rangeRange of three nucleotides that should be converted to amino acid.

Translates range with 3 nucleotides into amino acid according to given genetic code.

Complexity

Constant.

Exceptions

Strong exception guarantee (never modifies data).

Template Parameters
range_typeType of input_range; must satisfy std::ranges::RandomAccessRange.
Parameters
[in]input_rangeRange of three nucleotides that should be converted to amino acid.

Translates range with 3 nucleotides into amino acid according to given genetic code.

Complexity

Constant.

Exceptions

Strong exception guarantee (never modifies data).

Variable Documentation

◆ seqan3_version

std::string const seqan3::seqan3_version
Initial value:
= std::to_string(seqan3_version_major) + "." +
std::to_string(seqan3_version_minor) + "." +
std::to_string(seqan3_version_patch)
constexpr uint8_t seqan3_version_patch
The patch version.
Definition: version.hpp:66
constexpr uint8_t seqan3_version_major
The major version.
Definition: version.hpp:62
constexpr uint8_t seqan3_version_minor
The minor version.
Definition: version.hpp:64

The full version as std::string.