Namespaces
Variants
Views
Actions

Standard library header <experimental/ranges/concepts>

From cppreference.com
< cpp‎ | header
 
 
 

This header is part of the ranges library.

Contents

[edit] Core language concepts

Defined in namespace std::experimental::ranges
specifies that a type is the same as another type
(concept) [edit]
specifies that a type is derived from another type
(concept) [edit]
specifies that a type is implicitly convertible to another type
(concept) [edit]
specifies that two types share a common reference type
(concept) [edit]
specifies that two types share a common type
(concept) [edit]
specifies that a type is an integral type
(concept) [edit]
specifies that a type is a integral type that is signed
(concept) [edit]
specifies that a type is an integral type that is not signed
(concept) [edit]
specifies that a type is assignable from another type
(concept) [edit]
specifies that a type can be swapped or that two types can be swapped with each other
(concept) [edit]

[edit] Comparison concepts

Defined in namespace std::experimental::ranges
specifies that a type can be used in Boolean contexts
(concept) [edit]
specifies that two types can be compared for equality using operators == and !=
(concept) [edit]
specifies that operator == is an equivalence relation
(concept) [edit]
specifies that the comparison operators on the type yield a total order
(concept) [edit]

[edit] Object concepts

Defined in namespace std::experimental::ranges
specifies that an object of the type can be destroyed and have its address taken with unary &
(concept) [edit]
specifies that a variable of the type can be constructed from or bound to a set of argument types
(concept) [edit]
specifies that an object of a type can be default constructed
(concept) [edit]
specifies that an object of a type can be move constructed
(concept) [edit]
specifies that an object of a type can be copy constructed and move constructed
(concept) [edit]
specifies that an object of a type can be moved and swapped
(concept) [edit]
specifies that an object of a type can be copied, moved, and swapped
(concept) [edit]
specifies that an object of a type can be copied, moved, swapped, and default constructed
(concept) [edit]
specifies that a type is regular, that is, it is both Semiregular and EqualityComparable
(concept) [edit]

[edit] Callable concepts

Defined in namespace std::experimental::ranges
specifies that a callable type can be invoked with a given set of argument types
(concept) [edit]
specifies that a callable type is a Boolean predicate
(concept) [edit]
specifies that a callable type is a binary relation
(concept) [edit]
specifies that a Relation imposes a strict weak ordering
(concept) [edit]

[edit] Synopsis

namespace std {
namespace experimental {
namespace ranges {
inline namespace v1 {
 
// 7.3, Core language concepts:
// 7.3.2, Same:
template <class T, class U>
concept bool Same = /* see below */;
 
// 7.3.3, DerivedFrom:
template <class T, class U>
concept bool DerivedFrom = /* see below */;
 
// 7.3.4, ConvertibleTo:
template <class T, class U>
concept bool ConvertibleTo = /* see below */;
 
// 7.3.5, CommonReference:
template <class T, class U>
concept bool CommonReference = /* see below */;
 
// 7.3.6, Common:
template <class T, class U>
concept bool Common = /* see below */;
 
// 7.3.7, Integral:
template <class T>
concept bool Integral = /* see below */;
 
// 7.3.8, SignedIntegral:
template <class T>
concept bool SignedIntegral = /* see below */;
 
// 7.3.9, UnsignedIntegral:
template <class T>
concept bool UnsignedIntegral = /* see below */;
 
// 7.3.10, Assignable:
template <class T, class U>
concept bool Assignable = /* see below */;
 
// 7.3.11, Swappable:
template <class T>
concept bool Swappable = /* see below */;
 
template <class T, class U>
concept bool SwappableWith = /* see below */;
 
// 7.3.12, Destructible:
template <class T>
concept bool Destructible = /* see below */;
 
// 7.3.13, Constructible:
template <class T, class... Args>
concept bool Constructible = /* see below */;
 
// 7.3.14, DefaultConstructible:
template <class T>
concept bool DefaultConstructible = /* see below */;
 
// 7.3.15, MoveConstructible:
template <class T>
concept bool MoveConstructible = /* see below */;
 
// 7.3.16, CopyConstructible:
template <class T>
concept bool CopyConstructible = /* see below */;
 
// 7.4, Comparison concepts:
// 7.4.2, Boolean:
template <class B>
concept bool Boolean = /* see below */;
 
// 7.4.3, EqualityComparable:
template <class T, class U>
concept bool WeaklyEqualityComparableWith = /* see below */;
 
template <class T>
concept bool EqualityComparable = /* see below */;
 
template <class T, class U>
concept bool EqualityComparableWith = /* see below */;
 
// 7.4.4, StrictTotallyOrdered:
template <class T>
concept bool StrictTotallyOrdered = /* see below */;
 
template <class T, class U>
concept bool StrictTotallyOrderedWith = /* see below */;
 
// 7.5, Object concepts:
// 7.5.1, Movable:
template <class T>
concept bool Movable = /* see below */;
 
// 7.5.2, Copyable:
template <class T>
concept bool Copyable = /* see below */;
 
// 7.5.3, Semiregular:
template <class T>
concept bool Semiregular = /* see below */;
 
// 7.5.4, Regular:
template <class T>
concept bool Regular = /* see below */;
 
// 7.6, Callable concepts:
// 7.6.2, Invocable:
template <class F, class... Args>
concept bool Invocable = /* see below */;
 
// 7.6.3, RegularInvocable:
template <class F, class... Args>
concept bool RegularInvocable = /* see below */;
 
// 7.6.4, Predicate:
template <class F, class... Args>
concept bool Predicate = /* see below */;
 
// 7.6.5, Relation:
template <class R, class T, class U>
concept bool Relation = /* see below */;
 
// 7.6.6, StrictWeakOrder:
template <class R, class T, class U>
concept bool StrictWeakOrder = /* see below */;
 
} // namespace v1
} // namespace ranges
} // namespace experimental
} // namespace std