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

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

+ Collaboration diagram for concepts:

Classes

interface  std::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  std::Boolean
 Specifies that a type can be used in Boolean contexts. More...
 
interface  std::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  std::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  std::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  std::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  std::Copyable
 Subsumes std::Movable, std::CopyConstructible, and requires that the type be std::Assignable bool from a const & of itself. More...
 
interface  std::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  std::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  std::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  std::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  std::EqualityComparable
 The same as std::WeaklyEqualityComparableWith<t,t>. More...
 
interface  std::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  std::Integral
 The concept Integral is satisfied if and only if T is an integral type. More...
 
interface  std::Invocable
 Specifies whether the given callable is invocable with the given arguments. More...
 
interface  std::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  std::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  std::Predicate
 Specifies whether the given callable is std::RegularInvocable and returns bool. More...
 
interface  std::Regular
 Subsumes std::Semiregular and std::EqualityComparable. More...
 
interface  std::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  std::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  std::Same
 The concept std::Same<T, U> is satisfied if and only if T and U denote the same type. More...
 
interface  std::Semiregular
 Subsumes std::Copyable and std::DefaultConstructible. More...
 
interface  std::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  std::StrictTotallyOrdered
 Requires std::EqualityComparable and all remaing comparison operators (<, <=, >, >=). More...
 
interface  std::StrictTotallyOrderedWith
 Requires std::EqualityComparable and all remaing comparison operators (<, <=, >, >=). More...
 
interface  std::StrictWeakOrder
 The concept StrictWeakOrder<R, T, U> specifies that the Relation R imposes a strict weak ordering on its arguments. More...
 
interface  std::Swappable
 The concept std::Swappable specifies that lvalues of type T are swappable. More...
 
interface  std::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...
 
interface  std::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...
 

Functions

t & std::Assignable::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::EqualityComparable

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::StrictTotallyOrdered

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

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.