SeqAn3  3.0.2
The Modern C++ library for sequence analysis.
concepts

The <concepts> header from C++20's standard library. More...

+ Collaboration diagram for concepts:

Classes

interface  assignable_from
 The concept std::assignable_from<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  boolean
 Specifies that a type can be used in boolean contexts. More...
 
interface  common_reference_with
 The concept std::common_reference_with<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  common_with
 The concept std::common_with<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  constructible_from
 The std::constructible_from concept specifies that a variable of type T can be initialized with the given set of argument types Args.... More...
 
interface  convertible_to
 The concept std::convertible_to<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  copy_constructible
 The concept std::copy_constructible is satisfied if T is an lvalue reference type, or if it is a move_constructible 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  copyable
 Subsumes std::movable, std::copy_constructible, and requires that the type be std::assignable_from bool from a const & of itself. More...
 
interface  default_constructible
 The std::default_constructible concept provides a shorthand for the common case when the question is whether a type can be constructed with no arguments. More...
 
interface  derived_from
 The concept std::derived_from<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  equality_comparable
 The same as std::weakly_equality_comparable_with<t,t>. More...
 
interface  equality_comparable_with
 Requires seqan3::detail::weakly_equality_comparable_witht<t1,t2>, but also that t1 and t2, as well as their common_reference_t satisfy std::equality_comparable. 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  movable
 Subsumes std::Object, std::move_constructible, std::swappable bool and requires that the type be std::assignable_from bool from a value of itself. More...
 
interface  move_constructible
 The concept std::move_constructible 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  predicate
 Specifies whether the given callable is std::regular_invocable and returns bool. More...
 
interface  regular
 Subsumes std::semiregular and std::equality_comparable. More...
 
interface  regular_invocable
 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_as
 The concept std::same_as<T, U> is satisfied if and only if T and U denote the same type. More...
 
interface  semiregular
 Subsumes std::copyable and std::default_constructible. More...
 
interface  signed_integral
 The concept std::signed_integral is satisfied if and only if T is an integral type and std::is_signed_v<T> is true. More...
 
interface  strict_weak_order
 The concept strict_weak_order<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  swappable_with
 The concept std::swappable_with<T, U> specifies that expressions of the type and value category encoded by T and U are swappable with each other. More...
 
interface  totally_ordered
 Requires std::equality_comparable and all remaing comparison operators (<, <=, >, >=). More...
 
interface  totally_ordered_with
 Requires std::equality_comparable and all remaing comparison operators (<, <=, >, >=). More...
 
interface  unsigned_integral
 The concept std::unsigned_integral is satisfied if and only if T is an integral type and std::is_signed_v<T> is false. More...
 

Functions

t & assignable_from::operator= (t1 const &rhs)
 Assignment operator. More...
 

Requirements for std::swappable

You can expect these functions on all types that implement std::swappable.

void swap (t &lhs, t &rhs)
 Swaps the contents of two objects. More...
 

Requirements for std::equality_comparable

You can expect these functions on all types that implement std::Equality_comparable.

bool operator== (type const &lhs, type const &rhs)
 (In-)Equality comparison. More...
 
bool operator!= (type const &lhs, type const &rhs)
 (In-)Equality comparison. More...
 

Requirements for std::totally_ordered

You can expect these functions on all types that implement std::totally_ordered.

bool operator< (type const &lhs, type const &rhs)
 Less-than, greater-than and -or-equal comparisons. More...
 
bool operator<= (type const &lhs, type const &rhs)
 Less-than, greater-than and -or-equal comparisons. More...
 
bool operator> (type const &lhs, type const &rhs)
 Less-than, greater-than and -or-equal comparisons. More...
 
bool operator>= (type const &lhs, type const &rhs)
 Less-than, greater-than and -or-equal comparisons. More...
 

Detailed Description

The <concepts> header from C++20's standard library.

Function Documentation

◆ operator!=()

bool operator!= ( type const &  lhs,
type const &  rhs 
)
related

(In-)Equality comparison.

Parameters
[in]lhsLeft hand side parameter to compare.
[in]rhsRight hand side parameter to compare.
Returns
true or false, depending of the outcome of the comparison.
Attention
This is a concept requirement, not an actual function (however types satisfying this concept will provide an implementation).

◆ operator<()

bool operator< ( type const &  lhs,
type const &  rhs 
)
related

Less-than, greater-than and -or-equal comparisons.

Parameters
[in]lhsLeft hand side parameter to compare.
[in]rhsRight hand side parameter to compare.
Returns
true or false, depending of the outcome of the comparison.
Attention
This is a concept requirement, not an actual function (however types satisfying this concept will provide an implementation).

◆ operator<=()

bool operator<= ( type const &  lhs,
type const &  rhs 
)
related

Less-than, greater-than and -or-equal comparisons.

Parameters
[in]lhsLeft hand side parameter to compare.
[in]rhsRight hand side parameter to compare.
Returns
true or false, depending of the outcome of the comparison.
Attention
This is a concept requirement, not an actual function (however types satisfying this concept will provide an implementation).

◆ operator=()

t & operator= ( t1 const &  rhs)

Assignment operator.

Parameters
rhsRight hand side parameter to assign.
Returns
Reference to self.
Attention
This is a concept requirement, not an actual function (however types satisfying this concept will provide an implementation).

◆ operator==()

bool operator== ( type const &  lhs,
type const &  rhs 
)
related

(In-)Equality comparison.

Parameters
[in]lhsLeft hand side parameter to compare.
[in]rhsRight hand side parameter to compare.
Returns
true or false, depending of the outcome of the comparison.
Attention
This is a concept requirement, not an actual function (however types satisfying this concept will provide an implementation).

◆ operator>()

bool operator> ( type const &  lhs,
type const &  rhs 
)
related

Less-than, greater-than and -or-equal comparisons.

Parameters
[in]lhsLeft hand side parameter to compare.
[in]rhsRight hand side parameter to compare.
Returns
true or false, depending of the outcome of the comparison.
Attention
This is a concept requirement, not an actual function (however types satisfying this concept will provide an implementation).

◆ operator>=()

bool operator>= ( type const &  lhs,
type const &  rhs 
)
related

Less-than, greater-than and -or-equal comparisons.

Parameters
[in]lhsLeft hand side parameter to compare.
[in]rhsRight hand side parameter to compare.
Returns
true or false, depending of the outcome of the comparison.
Attention
This is a concept requirement, not an actual function (however types satisfying this concept will provide an implementation).

◆ swap()

void swap ( t &  lhs,
t &  rhs 
)
related

Swaps the contents of two objects.

Parameters
lhsLeft hand side parameter to swap.
rhsRight hand side parameter to swap.