The main SeqAn3 namespace. More...

Namespaces
	align_cfg
	A special sub namespace for the alignment configurations.

	custom
	A namespace for third party and standard library specialisations of SeqAn customisation points.

	search_cfg
	A special sub namespace for the search configurations.

	view
	The SeqAn3 namespace for views.

Classes
class	aa10li
	The reduced Li amino acid alphabet. More...

class	aa10murphy
	The reduced Murphy amino acid alphabet. More...

class	aa20
	The canonical amino acid alphabet. More...

class	aa27
	The twenty-seven letter amino acid alphabet. More...

class	aligned_allocator
	Allocates uninitialized storage whose memory-alignment is specified by alignment. More...

interface	AlignedSequence
	The generic concept for an aligned sequence.This concept describes the requirements a sequence must fulfil in order to be used inside of the alignment algorithm to store the final alignment. More...

class	alignment_coordinate
	Represents the begin/end of the pairwise alignment in the respective sequences. More...

class	alignment_file_header
	Stores the header information of alignment files. More...

class	alignment_file_input
	A class for reading alignment files, e.g. SAM, BAM, BLAST ... More...

struct	alignment_file_input_default_traits
	The default traits for seqan3::alignment_file_input. More...

struct	alignment_file_input_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...

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	alignment_result
	Stores the alignment results and gives access to score, alignment and the front and back coordinates. More...

interface	AlignmentFileInputFormat
	The generic concept for alignment file input formats. More...

interface	AlignmentFileInputTraits
	The requirements a traits_type for seqan3::alignment_file_input must meet. More...

interface	AlignmentFileOutputFormat
	The generic concept for alignment file out formats. More...

interface	Alphabet
	The generic alphabet concept that covers most data types used in ranges. More...

class	alphabet_base
	A CRTP-base that makes defining a custom alphabet easier. More...

class	alphabet_base< derived_type, 1ul, char_t >
	Specialisation of seqan3::alphabet_base for alphabets of size 1. More...

class	alphabet_proxy
	A CRTP-base that eases the definition of proxy types returned in place of regular alphabets. More...

class	alphabet_tuple_base
	The CRTP base for a combined alphabet that contains multiple values of different alphabets at the same time. More...

class	alphabet_variant
	A combined alphabet that can hold values of either of its alternatives. More...

class	aminoacid_base
	A CRTP-base that refines seqan3::alphabet_base and is used by the amino acids. More...

class	aminoacid_scoring_scheme
	A data structure for managing and computing the score of two amino acids. More...

interface	AminoacidAlphabet
	A concept that indicates whether an alphabet represents amino acids.Since an amino acid alphabet has no specific characteristics (like the complement function for nucleotide alphabets), we distinguish an amino acid alphabet by the seqan3::is_aminoacid type trait. 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
	A type that satisfies std::is_arithmetic_v<t>. More...

class	arithmetic_range_validator
	A validator that checks whether a number is inside a given range. More...

struct	back_end_first
	The penalty configuration for aligning the back of the first sequence with a gap. More...

struct	back_end_second
	The penalty configuration for aligning the back of the second sequence with a gap. More...

class	bi_fm_index
	The SeqAn Bidirectional FM Index. More...

class	bi_fm_index_cursor
	The SeqAn Bidirectional FM Index Cursor. More...

interface	BiFmIndex
	Concept for bidirectional FM indices. More...

interface	BiFmIndexCursor
	Concept for bidirectional FM index cursors. More...

class	bitcompressed_vector
	A space-optimised version of std::vector that compresses multiple letters into a single byte. More...

interface	CerealArchive
	All archives of the Cereal library satisfy this. More...

interface	CerealInputArchive
	All input archives of the Cereal library satisfy this. More...

interface	Cerealisable
	Specifies the requirements for types that are serialisable via Cereal. More...

interface	CerealOutputArchive
	All output archives of the Cereal library satisfy this. More...

interface	CerealTextArchive
	All text archives of the Cereal library satisfy this. More...

interface	Char
	This concept encompasses exactly the types `char`, `signed char`, `unsigned char`, `wchar_t`, `char16_t` and `char32_t`. More...

class	cigar
	The cigar alphabet pairs a counter with a seqan3::cigar_op letter. More...

class	cigar_op
	The (extended) cigar operation alphabet of M,D,I,H,N,P,S,X,=. More...

interface	Compatible
	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...

class	configuration
	Collection of elements to configure an algorithm. More...

struct	const_reference
	Exposes the `const_reference` of another type. More...

struct	const_reference< rng_t >
	Exposes the `const_reference` of another type. More...

interface	ConstIterableRange
	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...

interface	Container
	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
	Exposes the `difference_type` of another type. More...

struct	difference_type< it_t >
	Exposes the `difference_type` of another type. More...

struct	difference_type< rng_t >
	Exposes the `difference_type` of another type. 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...

class	end_gaps
	Wraps the sequence end-gap specifiers and provides ordered access to the respective values. More...

interface	ExplicitlyConvertibleTo
	Resolves to `std::ranges::ExplicitlyConvertibleTo<type1, type2>()`. More...

struct	fields
	A class template that holds a choice of seqan3::field. More...

struct	file_open_error
	Thrown if there is an unspecified filesystem or stream error while opening, e.g. permission problem. More...

class	file_validator_base
	An abstract base class for the file and directory validators. More...

interface	FloatingPoint
	An arithmetic type that also satisfies std::is_floating_point_v<t>. More...

class	fm_index
	The SeqAn FM Index. More...

class	fm_index_cursor
	The SeqAn FM Index Cursor. More...

interface	FmIndex
	Concept for unidirectional FM indices. More...

interface	FmIndexCursor
	Concept for unidirectional FM index cursors. More...

struct	format_bam
	The BAM format. More...

struct	format_embl
	The EMBL format (tag). More...

struct	format_error
	Thrown if information given to output format didn't match expectations. More...

struct	format_fasta
	The FastA format (tag). More...

struct	format_fastq
	The FastQ format. (tag) More...

struct	format_genbank
	The GenBank format (tag). More...

struct	format_sam
	The SAM format (tag). More...

struct	format_vienna
	The Vienna format (dot bracket notation) for RNA sequences with secondary structure. More...

interface	ForwardingRange
	Specifies a range whose iterators may outlive the range and remain valid. More...

struct	front_end_first
	The penalty configuration for aligning the front of the first sequence with a gap. More...

struct	front_end_second
	The penalty configuration for aligning the front of the second sequence with a gap. More...

class	gap
	The alphabet of a gap character '-'. More...

class	gap_decorator
	A gap decorator allows the annotation of sequences with gap symbols while leaving the underlying sequence unmodified. 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	ImplicitlyConvertibleTo
	Resolves to `std::ranges::ImplicitlyConvertibleTo<type1, type2>()`. More...

struct	innermost_value_type
	Recursively determines the `value_type` on containers and/or iterators. More...

class	input_directory_validator
	A validator that checks if a given path is a valid input directory. More...

class	input_file_validator
	A validator that checks if a given path is a valid input file. More...

class	invalid_alignment_configuration
	Thrown if the configuration of the alignment algorithm is invalid. More...

struct	invalid_char_assignment
	An exception typically thrown by seqan3::Alphabet::assign_char_strict. More...

struct	io_error
	Thrown if there is an io error in low level io operations such as in std::basic_streambuf operations. More...

struct	is_aminoacid
	Identifies amino acid alphabets. More...

struct	is_aminoacid< aa10li >
	Identifies aa10li as an amino acid alphabet (UnaryTypeTrait specialisation). More...

struct	is_aminoacid< aa10murphy >
	Identifies aa10murphy as an amino acid alphabet (UnaryTypeTrait specialisation). More...

struct	is_aminoacid< aa20 >
	Identifies aa20 as an amino acid alphabet (UnaryTypeTrait specialisation). More...

struct	is_aminoacid< aa27 >
	Identifies aa27 as an amino acid alphabet (UnaryTypeTrait specialisation). More...

struct	is_constexpr_default_constructible
	Whether a type std::is_default_constructible in `constexpr`-context. More...

struct	is_constexpr_default_constructible< t >
	Whether a type std::is_default_constructible in `constexpr`-context (UnaryTypeTrait specialisation). More...

struct	is_execution_policy
	Test whether a class represents an execution policy. More...

interface	IStream
	Concept for input streams. More...

struct	iterator_tag
	Exposes the iterator_category from the modelled concept. More...

struct	lower_bound
	Type for a lower boundary. More...

class	mask
	Implementation of a masked alphabet to be used for tuple composites. More...

class	masked
	Implementation of a masked composite, 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	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...

class	nucleotide_scoring_scheme
	A data structure for managing and computing the score of two nucleotides. More...

interface	NucleotideAlphabet
	A concept that indicates whether an alphabet represents nucleotides. More...

class	option_declared_multiple_times
	Argument parser exception thrown when a non-list option is declared multiple times. More...

interface	OStream
	Concept for output streams. More...

class	output_directory_validator
	A validator that checks if a given path is a valid output directory. More...

class	output_file_validator
	A validator that checks if a given path is a valid output file. More...

class	overflow_error_on_conversion
	Argument parser exception thrown when an argument could not be casted to the according type. More...

class	parallel_policy
	Parallel execution policy. More...

class	parallel_unsequenced_policy
	Parallel and unsequenced execution policy. 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_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	pipeable_config_element
	Adds pipe interface to configuration elements. More...

struct	pod_tuple
	cond More...

struct	pod_tuple< type0 >
	Recursion anchor for pod_tuple. More...

struct	pod_tuple< type0, types... >
	Behaves like std::tuple but is an aggregate PODType. 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	QualityAlphabet
	A concept that indicates whether an alphabet represents quality scores. More...

interface	RandomAccessContainer
	A more refined container concept than seqan3::SequenceContainer. More...

struct	record
	The class template that file records are based on; behaves like an std::tuple. More...

struct	ref_info_not_given
	Type tag which indicates that no reference information has been passed to the alignment file on construction. More...

struct	reference
	Exposes the `reference` of another type. More...

struct	reference< it_t >
	Exposes the `reference` type of another type. More...

struct	reference< rng_t >
	Exposes the `reference` of another type. More...

class	regex_validator
	A validator that checks if a matches a regular expression pattern. More...

struct	remove_rvalue_reference
	Return the input type with `&&` removed, but lvalue references preserved. More...

class	required_option_missing
	Argument parser exception thrown when a required option is missing. More...

interface	ReservableContainer
	A more refined container concept than seqan3::RandomAccessContainer. 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	RnaStructureAlphabet
	A concept that indicates whether an alphabet represents RNA structure. More...

struct	rvalue_reference
	Exposes the `rvalue_reference` of another type. More...

struct	rvalue_reference< it_t >
	Exposes the `rvalue_reference` type of another type. More...

struct	rvalue_reference< rng_t >
	Exposes the `rvalue_reference` of another type. More...

class	sam_dna16
	A 16 letter DNA alphabet, containing all IUPAC symbols minus the gap and plus an equality sign ('='). 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	ScoringScheme
	A concept that requires that type be able to score two letters. More...

interface	Semialphabet
	The basis for seqan3::Alphabet, but requires only rank interface (not char). More...

class	semialphabet_any
	A semi-alphabet that type erases all other semi-alphabets of the same size. More...

struct	sequence_end_gap_specifier_base
	A mixin class which can maintain a static or a dynamic bool state. 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...

struct	sequence_file_input_options
	The options type defines various option members that influence the behaviour of all or some formats. More...

class	sequence_file_output
	A class for writing sequence files, e.g. FASTA, FASTQ ... More...

struct	sequence_file_output_options
	The options type defines various option members that influence the behaviour of all or some formats. More...

interface	SequenceContainer
	A more refined container concept than seqan3::Container. More...

class	sequenced_policy
	Sequenced execution policy. More...

interface	SequenceFileInputFormat
	The generic concept for sequence file in formats. More...

interface	SequenceFileInputTraits
	The requirements a traits_type for seqan3::sequence_file_input must meet. More...

interface	SequenceFileOutputFormat
	The generic concept for sequence file out formats. More...

struct	size_type
	Exposes the `size_type` of another type. More...

struct	size_type< it_t >
	Exposes the `size_type` of another type. More...

struct	size_type< rng_t >
	Exposes the `size_type` of another type. More...

class	small_string
	Implements a small string that can be used for compile time computations. More...

class	small_vector
	A constexpr vector implementation with dynamic size at compile time. More...

interface	StandardLayout
	Resolves to std::is_standard_layout_v<t>. More...

class	static_band
	Data structure for a static band. More...

interface	Stream
	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_input
	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_input. More...

struct	structure_file_input_options
	The options type defines various option members that influence the behaviour of all or some formats. More...

class	structure_file_output
	A class for writing structured sequence files, e.g. Stockholm, Connect, Vienna, ViennaRNA bpp matrix ... 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::alphabet_tuple_base that joins an aminoacid alphabet with a protein structure alphabet. More...

class	structured_rna
	A seqan3::alphabet_tuple_base that joins a nucleotide alphabet with an RNA structure alphabet. More...

interface	StructureFileInputFormat
	The generic concept for structure file in formats. More...

interface	StructureFileInputTraits
	The requirements a traits_type for seqan3::structure_file_input must meet. More...

interface	StructureFileOutputFormat
	The generic concept for structure file out formats. 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	TransformationTrait
	Concept for a transformation trait. More...

interface	Trivial
	A type that satisfies seqan3::TriviallyCopyable and seqan3::TriviallyDestructible. More...

interface	TriviallyCopyable
	A type that satisfies std::is_trivially_copyable_v<t>. More...

interface	TriviallyDestructible
	A type that satisfies std::is_trivially_destructible_v<t>. More...

interface	TupleLike
	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	UnaryTypeTrait
	Concept for a unary traits type. 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	unknown_option
	Argument parser exception thrown when encountering unknown option. More...

class	unsequenced_policy
	Unsequenced execution policy. 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
	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...

struct	value_type
	Exposes the `value_type` of another type. More...

struct	value_type< it_t >
	Exposes the `value_type` of another type. More...

struct	value_type< rng_t >
	Exposes the `value_type` of another type. More...

interface	WeaklyAssignable
	Resolves to std::is_assignable_v<t>. More...

interface	WeaklyOrderedWith
	Requires the two operands to be comparable with `==` and `!=` in both directions. More...

interface	WritableAlphabet
	Refines seqan3::Alphabet and adds assignability. More...

interface	WritableSemialphabet
	A refinement of seqan3::Semialphabet that adds assignability. More...

class	wuss
	The WUSS structure alphabet of the characters `.<>:,-_~;()[]{}AaBbCcDd`... More...

Typedefs
template<typename t >
using	all_view = decltype(view::all(std::declval< t >()))
	Deduces the return value of seqan3::view::all.

template<typename alphabet_type >
using	alphabet_char_t = decltype(seqan3::to_char(std::declval< alphabet_type const >()))
	The `char_type` of the alphabet; defined as the return type of seqan3::to_char.

template<typename alphabet_type >
using	alphabet_phred_t = decltype(seqan3::to_phred(std::declval< alphabet_type >()))
	The `phred_type` of the alphabet; defined as the return type of seqan3::to_phred.

template<typename semi_alphabet_type >
using	alphabet_rank_t = decltype(seqan3::to_rank(std::declval< semi_alphabet_type >()))
	The `rank_type` of the semi-alphabet; defined as the return type of seqan3::to_rank.

template<typename t >
using	const_reference_t = typename const_reference< t >::type
	Shortcut for seqan3::const_reference (TransformationTrait shortcut). More...

using	default_sdsl_index_type = sdsl_wt_index_type
	The default FM Index Configuration. More...

template<typename t >
using	difference_type_t = typename difference_type< t >::type
	Shortcut for seqan3::difference_type (TransformationTrait shortcut). 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 = alphabet_variant< 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 (TransformationTrait shortcut). More...

template<typename it_t >
using	iterator_tag_t = typename iterator_tag< it_t >::type
	Return the `iterator_category` type of the input type (TransformationTrait shortcut). More...

using	ostream_iterator = ::ranges::ostream_iterator
	Alias for ranges::ostream_iterator. Writes successive elements onto the output stream from which it was constructed.

using	ostreambuf_iterator = ::ranges::ostreambuf_iterator
	Alias for ranges::ostreambuf_iterator. Writes successive characters onto the output stream from which it was constructed.

template<typename t >
using	reference_t = typename reference< t >::type
	Shortcut for seqan3::reference (TransformationTrait shortcut). 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 trait). More...

template<typename t >
using	remove_rvalue_reference_t = typename remove_rvalue_reference< t >::type
	Return the input type with `&&` removed, but lvalue references preserved (TransformationTrait shortcut). 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
	Shortcut for seqan3::rvalue_reference (TransformationTrait shortcut). 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.

using	sdsl_wt_index_type = sdsl::csa_wt< sdsl::wt_blcd< sdsl::bit_vector, sdsl::rank_support_v<>, sdsl::select_support_scan<>, sdsl::select_support_scan< 0 > >, 16, 10000000, sdsl::sa_order_sa_sampling<>, sdsl::isa_sampling<>, sdsl::plain_byte_alphabet >
	The FM Index Configuration using a Wavelet Tree. More...

template<typename t >
using	size_type_t = typename size_type< t >::type
	Shortcut for seqan3::size_type (TransformationTrait shortcut). 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
	Shortcut for seqan3::value_type (TransformationTrait shortcut). More...

Enumerations
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, 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	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 exec_policy_t , typename sequence_t , typename alignment_config_t >
constexpr auto	align_pairwise (exec_policy_t const &exec, sequence_t &&seq, alignment_config_t const &config)
	Computes the pairwise alignment for a pair of sequences or a range over sequence pairs. More...

template<typename sequence_t , typename alignment_config_t >
constexpr auto	align_pairwise (sequence_t &&seq, alignment_config_t const &config)

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

debug_stream_type &	operator<< (debug_stream_type &s, cigar const c)
	Overload for the seqan3::debug_stream's operator.

template<TupleLike tuple_t>
debug_stream_type &	operator<< (debug_stream_type &stream, tuple_t const &alignment)
	Streaming operator for alignments, which are represented as tuples of aligned sequences. More...

template<Validator validator1_type, Validator validator2_type>
auto	operator\| (validator1_type &&vali1, validator2_type &&vali2)
	Enables the chaining of validators. More...

template<FmIndex index_t, typename queries_t , typename configuration_t >
auto	search (queries_t &&queries, index_t const &index, configuration_t const &cfg)
	Search a query or a range of queries in an index. More...

template<FmIndex index_t, typename configuration_t >
auto	search (char const *const queries, index_t const &index, configuration_t const &cfg)

template<FmIndex index_t, typename configuration_t >
auto	search (std::initializer_list< char const *const > const &queries, index_t const &index, configuration_t const &cfg)

template<FmIndex index_t, typename queries_t >
auto	search (queries_t &&queries, index_t const &index)
	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<FmIndex index_t>
auto	search (index_t const &index, char const *const queries)

template<FmIndex index_t>
auto	search (std::initializer_list< char const *const > const &queries, index_t const &index)

template<genetic_code gc = genetic_code::CANONICAL, NucleotideAlphabet 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...

Aligned sequence interface for containers over the seqan3::gapped alphabet
Enables containers to model seqan3::AlignedSequence if they model seqan3::SequenceContainer and have a value type of the seqan3::gapped alphabet.
Aligned sequence interface for ranges that have the corresponding member functions.
Enables ranges to model seqan3::AlignedSequence if they have the member functions insert_gap() and erase_gap().
template<typename range_type >
range_type::iterator	insert_gap (range_type &rng, typename range_type::iterator const it, typename range_type::size_type const size=1)
	An implementation of seqan3::AlignedSequence::insert_gap for ranges with the corresponding member function insert_gap(it, size). More...

template<typename range_type >
range_type::iterator	erase_gap (range_type &rng, typename range_type::iterator const it)
	An implementation of seqan3::AlignedSequence::erase_gap for ranges with the corresponding member function erase_gap(it). More...

template<typename range_type >
range_type::iterator	erase_gap (range_type &rng, typename range_type::iterator const first, typename range_type::iterator const last)
	An implementation of seqan3::AlignedSequence::erase_gap for ranges with the corresponding member function erase_gap(first, last). More...

Literals
std::vector< dot_bracket3 >	operator""_db3 (const char *str, std::size_t len)

std::vector< dssp9 >	operator""_dssp9 (const char *str, std::size_t len)

Tuple interface
template<template< typename ... > class query_t, typename ... configs_t>
constexpr auto const &	get (configuration< configs_t... > const &config) noexcept

template<template< typename ... > class query_t, typename ... configs_t>
constexpr auto &&	get (configuration< configs_t... > &&config) noexcept

template<template< typename ... > class query_t, typename ... configs_t>
constexpr auto const &&	get (configuration< configs_t... > const &&config) noexcept

Operations on characters
template<Char 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 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...

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 , TupleLike 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<TupleLike tuple_t>
constexpr auto	tuple_pop_front (tuple_t &&t)
	Removes the first element of a tuple. More...

Type deduction guides
template<size_t capacity2, typename value_type >
	small_vector (const value_type(&array)[capacity2]) -> small_vector< value_type, capacity2 >
	Deducts the size and value type from an built-in array on construction.

template<std::ranges::ViewableRange urng_t>
	gap_decorator (urng_t &&range) -> gap_decorator< std::remove_reference_t< urng_t > const &>
	Ranges (not views!) always deduce to `const & range_type` since they are access-only anyway.

template<std::ranges::View urng_t>
	gap_decorator (urng_t range) -> gap_decorator< urng_t >
	Views always deduce to their respective type because they are copied.

Template argument type deduction guides
template<std::ranges::Range text_t>
	bi_fm_index (text_t &&) -> bi_fm_index< dimension_v< text_t > !=1 >
	Deduces the dimensions of the text.

template<std::ranges::Range text_t>
	fm_index (text_t &&) -> fm_index< dimension_v< text_t > !=1 >
	Deduces the dimensions of the text.

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.

template<typename alph_t >

constexpr auto alphabet_size = detail::adl::only::alphabet_size_obj<alph_t>()

A type trait that holds the size of a (semi-)alphabet. More...

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 (type trait). More...

constexpr detail::global_alignment_type global_alignment

Helper variable to select the global alignment. More...

constexpr detail::local_alignment_type local_alignment

Helper variable to select the local alignment. More...

constexpr parallel_policy par {}

Global execution policy object for parallel execution policy. More...

constexpr parallel_unsequenced_policy par_unseq {}

Global execution policy object for parallel and unsequenced execution policy. More...

constexpr sequenced_policy seq {}

Global execution policy object for sequenced execution policy. 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.

constexpr unsequenced_policy unseq {}

Global execution policy object for unsequenced execution policy. More...

Function objects

constexpr auto to_rank = detail::adl::only::to_rank_fn{}

Return the rank representation of a (semi-)alphabet object. More...

constexpr auto assign_rank_to = detail::adl::only::assign_rank_to_fn{}

Assign a rank to an alphabet object. More...

constexpr auto to_char = detail::adl::only::to_char_fn{}

Return the char representation of an alphabet object. More...

constexpr auto assign_char_to = detail::adl::only::assign_char_to_fn{}

Assign a character to an alphabet object. More...

template<typename alph_t >

constexpr auto char_is_valid_for = detail::adl::only::char_is_valid_for_fn<alph_t>{}

Returns whether a character is in the valid set of a seqan3::Alphabet (usually implies a bijective mapping to an alphabet value). More...

constexpr auto assign_char_strictly_to = detail::adl::only::assign_char_strictly_to_fn{}

Assign a character to an alphabet object, throw if the character is not valid. More...

Function objects (Nucleotide)

constexpr auto complement = detail::adl::only::complement_fn{}

Return the complement of a nucleotide object. More...

Function objects (Quality)

constexpr auto to_phred = detail::adl::only::to_phred_fn{}

The public getter function for the phred representation of a quality score. More...

constexpr auto assign_phred_to = detail::adl::only::assign_phred_to_fn{}

Assign a phred score to a quality alphabet object. More...

Function objects (Structure)

constexpr auto is_pair_open = detail::adl::only::is_pair_open_fn{}

Check whether the given character represents a rightward interaction in an RNA structure. More...

constexpr auto is_pair_close = detail::adl::only::is_pair_close_fn{}

Check whether the given character represents a leftward interaction in an RNA structure. More...

constexpr auto is_unpaired = detail::adl::only::is_unpaired_fn{}

Check whether the given character represents an unpaired nucleotide in an RNA structure. More...

template<typename alph_t >

constexpr auto max_pseudoknot_depth = detail::adl::only::max_pseudoknot_depth_obj<alph_t>()

A type trait that holds the ability of the structure alphabet to represent pseudoknots, i.e. crossing interactions, up to a certain depth. More...

constexpr auto pseudoknot_id = detail::adl::only::pseudoknot_id_fn{}

Retrieve an id for the level of a pseudoknotted interaction (also known as 'page number'). More...

Character predicates

Character predicates are function like objects that can be used to check if a character c fulfills certain constraints. SeqAn3 implements all predicates 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:

char chr{'1'};
auto constexpr my_cond = is_char<'%'> || is_digit;
bool is_percent = my_cond(chr); // is_percent == true

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 predicates

seqan3::is_in_alphabet: Checks if the given character is part of the specified alphabet.
seqan3::is_in_interval: Checks if the given character is within specified range of ASCII characters.
seqan3::is_char: Checks if the character is equal to the specified ASCII character.
seqan3::is_eof: Checks if a character is the end-of-file marker.

Standard library predicates

SeqAn offers the 12 predicates 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 character predicates 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	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`
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>

constexpr auto is_in_interval

Checks whether a given letter is in the specified interval. More...

template<Alphabet alphabet_t>

constexpr auto is_in_alphabet

Checks whether a given letter is valid for the specified seqan3::Alphabet. More...

template<int char_v>

constexpr auto 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...

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

◆ get() [1/3]

template<template< typename ... > class query_t, typename ... configs_t>

constexpr auto const& seqan3::get ( configuration< configs_t... > const & config )

noexcept

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<template< typename ... > class query_t, typename ... configs_t>

constexpr auto&& seqan3::get ( configuration< configs_t... > && config )

noexcept

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<template< typename ... > class query_t, typename ... configs_t>

constexpr auto const&& seqan3::get ( configuration< configs_t... > const && config )

noexcept

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_t The 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.

#include <seqan3/io/alignment_file/sam_tag_dictionary.hpp>
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

◆ to_lower()

template<Char 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_type Type of the parameter; must model seqan3::Char.

Parameters

c	The 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_upper()

template<Char 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_type Type of the parameter; must model seqan3::Char.

Parameters

c	The 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, NucleotideAlphabet 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_type The type of input nucleotides.

Parameters

[in]	n1	First nucleotide in triplet.
[in]	n2	Second nucleotide in triplet.
[in]	n3	Third 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_type Type of input_tuple. Usually std::tuple, but similar types like std::array and seqan3::pod_tuple are also supported.

Parameters

[in] input_tuple Triplet 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_type Type of input_range; must satisfy std::ranges::InputRange.

Parameters

[in] input_range Range 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_type Type of input_range; must satisfy std::ranges::RandomAccessRange.

Parameters

[in] input_range Range 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)

The full version as std::string.

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Disjunction and Negation

Custom predicates

Standard library predicates

Detailed Description

Enumeration Type Documentation

◆ genetic_code

◆ translation_frames

Function Documentation

◆ get() [1/3]

◆ get() [2/3]

◆ get() [3/3]

◆ operator""_tag()

◆ to_lower()

◆ to_upper()

◆ translate_triplet() [1/3]

Complexity

Exceptions

◆ translate_triplet() [2/3]

Complexity

Exceptions

◆ translate_triplet() [3/3]

Complexity

Exceptions

Complexity

Exceptions

Variable Documentation

◆ seqan3_version