SeqAn3
std Namespace Reference

SeqAn specific customisations in the standard namespace. More...

Classes

interface  Assignable
 The concept std::Assignable<LHS, RHS> specifies that an expression of the type and value category specified by RHS can be assigned to an lvalue expression whose type is specified by LHS. More...
 
interface  BidirectionalIterator
 The concept BidirectionalIterator refines std::ForwardIterator by adding the ability to move an iterator backward. More...
 
interface  Boolean
 Specifies that a type can be used in Boolean contexts. More...
 
interface  Common
 The concept std::Common<T, U> specifies that two types T and U share a common type (as computed by std::common_type_t) to which both can be converted. More...
 
interface  CommonReference
 The concept std::CommonReference<T, U> specifies that two types T and U share a common reference type (as computed by std::common_reference_t) to which both can be converted. More...
 
interface  Constructible
 The std::Constructible concept specifies that a variable of type T can be initialized with the given set of argument types Args.... More...
 
interface  ConvertibleTo
 The concept std::ConvertibleTo<From, To> specifies that an expression of the type and value category specified by From can be implicitly and explicitly converted to the type To, and the two forms of conversion are equivalent. More...
 
interface  Copyable
 Subsumes std::Movable, std::CopyConstructible, and requires that the type be std::Assignable bool from a const & of itself. More...
 
interface  CopyConstructible
 The concept std::CopyConstructible is satisfied if T is an lvalue reference type, or if it is a MoveConstructible object type where an object of that type can constructed from a (possibly const) lvalue or const rvalue of that type in both direct- and copy-initialization contexts with the usual semantics (a copy is constructed with the source unchanged). More...
 
interface  DefaultConstructible
 The std::DefaultConstructible concept provides a shorthand for the common case when the question is whether a type can be constructed with no arguments. More...
 
interface  DerivedFrom
 The concept std::DerivedFrom<Derived, Base> is satisfied if and only if Base is a class type that is either Derived or a public and unambiguous base of Derived, ignoring cv-qualifiers. More...
 
interface  Destructible
 The concept std::Destructible specifies the concept of all types whose instances can safely be destroyed at the end of their lifetime (including reference types). More...
 
interface  EqualityComparable
 The same as std::WeaklyEqualityComparableWith<t,t>. More...
 
interface  EqualityComparableWith
 Requires std::detail::WeaklyEqualityComparableWitht<t1,t2>, but also that t1 and t2, as well as their common_reference_t satisfy std::EqualityComparable. More...
 
interface  ForwardIterator
 The InputIterator concept is a refinement of std::Iterator, adding the requirement that the referenced values can be read (via std::Readable) and the requirement that the iterator category tag be present. More...
 
struct  from_chars_result
 Result type of std::from_chars. More...
 
struct  hash< alphabet_t >
 Struct for hashing a character. More...
 
struct  hash< urng_t >
 Struct for hashing a range of characters. More...
 
interface  Incrementable
 The concept Incrementable specifies the requirements on a type that can be incremented (with the pre- and post-increment operators). The increment operations (including those required by std::WeaklyIncrementable) are required to be equality-preserving, and the type is required to be std::EqualityComparable. More...
 
interface  InputIterator
 The InputIterator concept is a refinement of std::Iterator, adding the requirement that the referenced values can be read (via std::Readable) and the requirement that the iterator category tag be present. More...
 
interface  Integral
 The concept Integral is satisfied if and only if T is an integral type. More...
 
interface  Invocable
 Specifies whether the given callable is invocable with the given arguments. More...
 
interface  Iterator
 The Iterator concept forms the basis of the iterator concept taxonomy; every iterator satisfies the Iterator requirements. More...
 
interface  Movable
 Subsumes std::Object, std::MoveConstructible, std::Swappable bool and requires that the type be std::Assignable bool from a value of itself. More...
 
interface  MoveConstructible
 The concept std::MoveConstructible is satisfied if T is a reference type, or if it is an object type where an object of that type can constructed from an rvalue of that type in both direct- and copy-initialization contexts, with the usual semantics. More...
 
interface  OutputIterator
 The OutputIterator concept is a refinement of std::Iterator, adding the requirement that it can be used to write values of values of type and value category encoded by T (via std::Writable). std::EqualityComparable is not required. More...
 
interface  Predicate
 Specifies whether the given callable is std::RegularInvocable and returns bool. More...
 
interface  RandomAccessIterator
 The concept RandomAccessIterator refines std::BidirectionalIterator by adding support for constant time advancement with the +=, +, -=, and - operators, constant time computation of distance with -, and array notation with subscripting. More...
 
interface  Readable
 The concept Readable is satisfied by types that are readable by applying operator*, such as pointers, smart pointers, and iterators. More...
 
interface  Regular
 Subsumes std::Semiregular and std::EqualityComparable. More...
 
interface  RegularInvocable
 Specifies whether the given callable is invocable with the given arguments and equality preserving (invocations change neither the callable, nor the arguments). More...
 
interface  Relation
 Specifies that R defines a binary relation over the set of expressions whose type and value category are those encoded by either t or u. More...
 
interface  Same
 The concept std::Same<T, U> is satisfied if and only if T and U denote the same type. More...
 
interface  Semiregular
 Subsumes std::Copyable and std::DefaultConstructible. More...
 
interface  Sentinel
 The Sentinel concept specifies the relationship between an std::Iterator type and a std::Semiregular type whose values denote a range. More...
 
interface  SignedIntegral
 The concept std::SignedIntegral is satisfied if and only if T is an integral type and std::is_signed_v<T> is true. More...
 
interface  SizedSentinel
 The SizedSentinel concept specifies that an object of the iterator type I and an object of the sentinel type S can be subtracted to compute the distance between them in constant time. More...
 
interface  StrictTotallyOrdered
 Requires std::EqualityComparable and all remaing comparison operators (<, <=, >, >=). More...
 
interface  StrictTotallyOrderedWith
 Requires std::EqualityComparable and all remaing comparison operators (<, <=, >, >=). More...
 
interface  StrictWeakOrder
 The concept StrictWeakOrder<R, T, U> specifies that the Relation R imposes a strict weak ordering on its arguments. More...
 
interface  Swappable
 The concept std::Swappable specifies that lvalues of type T are swappable. More...
 
interface  SwappableWith
 The concept std::SwappableWith<T, U> specifies that expressions of the type and value category encoded by T and U are swappable with each other. More...
 
struct  to_chars_result
 Result type of std::to_chars. More...
 
struct  tuple_element< elem_no, seqan3::record< field_types, field_ids > >
 Value metafunction specialisation for seqan3::record; returns the type of an element in the record. More...
 
struct  tuple_element< elem_no, seqan3::sequence_file_input< traits_type, selected_field_ids, valid_formats, stream_type > >
 std::tuple_element overload for column-like access. [metafunction specialisation for seqan3::sequence_file_input] More...
 
struct  tuple_element< elem_no, seqan3::structure_file_in< traits_type, selected_field_ids, valid_formats, stream_type > >
 std::tuple_element overload for column-like access. [metafunction specialisation for seqan3::structure_file_in] More...
 
struct  tuple_element< i, tuple_t >
 Obtains the type of the specified element. More...
 
struct  tuple_element< idx, seqan3::align_result< output_type_list_t > >
 Overloads the tuple element type trait function for seqan3::align_result. More...
 
struct  tuple_size< seqan3::align_result< output_type_list_t > >
 Overloads the tuple size type trait function for seqan3::align_result. More...
 
struct  tuple_size< seqan3::record< field_types, field_ids > >
 Value metafunction specialisation for seqan3::record; returns number of elements in record. More...
 
struct  tuple_size< seqan3::sequence_file_input< traits_type, selected_field_ids, valid_formats, stream_type > >
 std::tuple_size overload for column-like access. [metafunction specialisation for seqan3::sequence_file_input] More...
 
struct  tuple_size< seqan3::structure_file_in< traits_type, selected_field_ids, valid_formats, stream_type > >
 std::tuple_size overload for column-like access. [metafunction specialisation for seqan3::structure_file_in] More...
 
struct  tuple_size< tuple_t >
 Provides access to the number of elements in a tuple as a compile-time constant expression. More...
 
struct  type_identity
 The identity transformation (a TransformationTrait that returns the input). More...
 
interface  UnsignedIntegral
 The concept std::UnsignedIntegral is satisfied if and only if T is an integral type and std::is_signed_v<T> is false. More...
 
interface  WeaklyIncrementable
 The concept WeaklyIncrementable specifies the requirements on a type that can be incremented (with the pre- and post-increment operators). The increment operations need not be equality-preserving, and the type need not be std::EqualityComparable. More...
 
interface  Writable
 The concept Writable<Out, T> specifies the requirements for writing a value whose type and value category are encoded by T into an iterator Out's referenced object. More...
 

Typedefs

template<typename t >
using type_identity_t = typename type_identity< t >::type
 A shortcut for std::type_identity.
 

Enumerations

enum  chars_format { chars_format::scientific = 0x1, chars_format::fixed = 0x2, chars_format::hex = 0x4, chars_format::general = fixed | scientific }
 A BitmaskType used to specify floating-point formatting for std::to_chars and std::from_chars. More...
 

Functions

template<typename container_t >
constexpr auto back_inserter (container_t &container)
 Create a std::back_insert_iterator for the argument. More...
 
template<std::Integral value_type>
std::from_chars_result from_chars (char const *first, char const *last, value_type &value, int base)
 Parse a char sequence into an integral. More...
 
template<std::Integral value_type>
std::from_chars_result from_chars (char const *first, char const *last, value_type &value)
 std::from_chars overload for integrals with default base = 10.
 
template<seqan3::floating_point_concept floating_point_type>
std::from_chars_result from_chars (char const *first, char const *last, floating_point_type &value, std::chars_format fmt=std::chars_format::general)
 Parse a char sequence into an floating point value. More...
 
template<std::Integral value_type>
std::to_chars_result to_chars (char *first, char *last, value_type value, int base)
 Convert an integral into a char sequence. More...
 
template<std::Integral value_type>
std::to_chars_result to_chars (char *first, char *last, value_type value)
 std::to_chars overload with default base = 10.
 

Detailed Description

SeqAn specific customisations in the standard namespace.