Range-v3
Range algorithms, views, and actions for the Standard Library
concepts Namespace Reference

INTERNAL ONLY. More...

Classes

struct  basic_common_reference
 Users can specialize this to hook the common_reference_with concept. More...
 
struct  common_reference
 Users can specialize this to hook the common_reference_with concept. More...
 
struct  common_reference< T >
 
struct  common_reference< T, U >
 
struct  common_reference< T, U, Vs... >
 
struct  common_type
 Users should specialize this to hook the common_with concept until std gets a SFINAE-friendly std::common_type and there's some sane way to deal with cv and ref qualifiers. More...
 
struct  common_type< T >
 
struct  common_type< T, U >
 
struct  common_type< T, U, Vs... >
 
struct  is_nothrow_swappable
 
struct  is_nothrow_swappable_with
 
struct  is_swappable
 
struct  is_swappable_with
 
struct  return_t_
 

Typedefs

template<bool B>
using bool_ = std::integral_constant< bool, B >
 
template<typename... Ts>
using common_reference_t = typename common_reference< Ts... >::type
 
template<typename... Ts>
using common_type_t = typename common_type< Ts... >::type
 
template<typename T >
using remove_cvref_t = typename std::remove_cv< typename std::remove_reference< T >::type >::type
 
template<typename T , typename EnableIf >
using return_t = meta::invoke< return_t_< EnableIf >, T >
 

Functions

template<typename T , typename U = T>
constexpr meta::if_c< std::is_move_constructible< T >::value &&std::is_assignable< T &, U >::value, T > exchange (T &t, U &&u) noexcept(std::is_nothrow_move_constructible< T >::value &&std::is_nothrow_assignable< T &, U >::value)
 

Variables

template<bool... Bs>
constexpr bool and_v = (Bs &&...)
 
template<typename T , typename U >
concept assignable_from
 
template<typename T , typename U >
concept assignable_from__requires_ = CPP_REQUIRES_requires `(T t, U && u) ( t = (U &&) u, requires_<same_as<T, decltype(t = (U &&) u)>> )
 
template<typename T , typename U >
concept common_reference_with
 
template<typename T , typename U >
concept common_reference_with__concept_ = same_as<common_reference_t<T, U>, common_reference_t<U, T>> && convertible_to<T, common_reference_t<T, U>> && convertible_to<U, common_reference_t<T, U>>
 
template<typename T , typename U >
concept common_with
 
template<typename T , typename U >
concept common_with__concept_ = same_as<common_type_t<T, U>, common_type_t<U, T>> && convertible_to<T, common_type_t<T, U>> && convertible_to<U, common_type_t<T, U>> && common_reference_with< std::add_lvalue_reference_t<T const>, std::add_lvalue_reference_t<U const>> && common_reference_with< std::add_lvalue_reference_t<common_type_t<T, U>>, common_reference_t< std::add_lvalue_reference_t<T const>, std::add_lvalue_reference_t<U const>>>
 
template<typename T , typename... Args>
concept constructible_from
 
template<typename From , typename To >
concept convertible_to
 
template<typename T >
concept copy_assignable__concept_ = assignable_from<T &, T const &>
 
template<typename T >
concept copy_constructible
 
template<typename T >
concept copy_constructible__concept_ = constructible_from<T, T &> && constructible_from<T, T const &> && constructible_from<T, T const> && convertible_to<T &, T> && convertible_to<T const &, T> && convertible_to<T const, T>
 
template<typename T >
concept copyable
 
template<typename T >
concept default_constructible
 
template<typename T , typename U >
concept derived_from
 
template<typename T , typename U >
concept derived_from__concept_ = convertible_to<T const volatile *, U const volatile *>
 
template<typename T >
concept destructible
 
template<typename T >
concept equality_comparable
 
template<typename T , typename U >
concept equality_comparable_with
 
template<typename T , typename U >
concept equality_comparable_with__concept_ = equality_comparable< common_reference_t<detail::as_cref_t<T>, detail::as_cref_t<U>>>
 
template<typename T >
concept integral
 
template<bool B>
concept is_true = B
 
template<typename T >
concept movable
 
template<typename T >
concept move_assignable__concept_ = assignable_from<T &, T>
 
template<typename T >
concept move_constructible
 
template<bool... Bs>
constexpr bool or_v = (Bs ||...)
 
template<typename T >
concept regular
 
template<bool B>
constexpr std::enable_if_t< B, intrequires_ = 0
 
template<typename A , typename B >
concept same_as
 
template<class T , template< typename... > class Trait, typename... Args>
concept satisfies
 
template<typename T >
concept semiregular
 
template<typename T >
concept signed_integral
 
constexpr adl_swap_detail::swap_fn swap {}
 
template<typename T >
concept swappable
 
template<typename T >
concept swappable__requires_ = CPP_REQUIRES_requires `(T & t, T & u) ( concepts::swap(t, u) )
 
template<typename T , typename U >
concept swappable_with
 
template<typename T , typename U >
concept swappable_with__requires_ = CPP_REQUIRES_requires `(T && t, U && u) ( concepts::swap((T &&) t, (T &&) t), concepts::swap((U &&) u, (U &&) u), concepts::swap((U &&) u, (T &&) t), concepts::swap((T &&) t, (U &&) u) )
 
template<typename T , typename Cat = std::partial_ordering>
concept three_way_comparable
 
template<typename T , typename U , typename Cat = std::partial_ordering>
concept three_way_comparable_with
 
template<typename T >
concept totally_ordered
 
template<typename T , typename U >
concept totally_ordered_with
 
template<typename T , typename U >
concept totally_ordered_with__concept_ = totally_ordered< common_reference_t< detail::as_cref_t<T>, detail::as_cref_t<U>>> && detail::partially_ordered_with_<T, U>
 
template<typename... Args>
concept type = true
 
template<typename T >
concept unsigned_integral
 

Detailed Description

INTERNAL ONLY.

INTERNAL ONLY INTERNAL ONLY INTERNAL ONLY INTERNAL ONLY INTERNAL ONLY INTERNAL ONLY INTERNAL ONLY INTERNAL ONLY INTERNAL ONLY INTERNAL ONLY INTERNAL ONLY INTERNAL ONLY INTERNAL ONLY INTERNAL ONLY INTERNAL ONLY INTERNAL ONLY INTERNAL ONLY INTERNAL ONLY INTERNAL ONLY INTERNAL ONLY INTERNAL ONLY INTERNAL ONLY INTERNAL ONLY INTERNAL ONLY INTERNAL ONLY INTERNAL ONLY INTERNAL ONLY INTERNAL ONLY INTERNAL ONLY INTERNAL ONLY INTERNAL ONLY INTERNAL ONLY INTERNAL ONLY INTERNAL ONLY INTERNAL ONLY INTERNAL ONLY INTERNAL ONLY INTERNAL ONLY

Variable Documentation

◆ assignable_from

template<typename T , typename U >
concept concepts::defs::assignable_from
Initial value:
=
std::is_lvalue_reference<T>::value &&
common_reference_with<detail::as_cref_t<T>, detail::as_cref_t<U>> &&
defs::assignable_from__requires_<T, U>

◆ common_reference_with

template<typename T , typename U >
concept concepts::defs::common_reference_with
Initial value:
=
concepts::common_reference_with__concept_<T, U>

◆ common_with

template<typename T , typename U >
concept concepts::defs::common_with
Initial value:
=
concepts::common_with__concept_<T, U>

◆ constructible_from

template<typename T , typename... Args>
concept concepts::defs::constructible_from
Initial value:
=
destructible<T> &&
__is_constructible(T, Args...)

◆ convertible_to

template<typename From , typename To >
concept concepts::defs::convertible_to
Initial value:
=
implicitly_convertible_to<From, To> &&
explicitly_convertible_to<From, To>

◆ copy_constructible

template<typename T >
concept concepts::defs::copy_constructible
Initial value:
=
move_constructible<T> &&
concepts::copy_constructible__concept_<T>

◆ copyable

template<typename T >
concept concepts::defs::copyable
Initial value:
=
copy_constructible<T> &&
movable<T> &&
concepts::copy_assignable__concept_<T>

◆ default_constructible

template<typename T >
concept concepts::defs::default_constructible
Initial value:
=
constructible_from<T>

◆ derived_from

template<typename T , typename U >
concept concepts::defs::derived_from
Initial value:
=
__is_base_of(U, T) &&
concepts::derived_from__concept_<T, U>

◆ destructible

template<typename T >
concept concepts::defs::destructible
Initial value:
=
std::is_nothrow_destructible<T>::value

◆ equality_comparable

template<typename T >
concept concepts::defs::equality_comparable
Initial value:
=
detail::weakly_equality_comparable_with_<T, T>

◆ equality_comparable_with

template<typename T , typename U >
concept concepts::defs::equality_comparable_with
Initial value:
=
equality_comparable<T> &&
equality_comparable<U> &&
detail::weakly_equality_comparable_with_<T, U> &&
common_reference_with<detail::as_cref_t<T>, detail::as_cref_t<U>> &&
concepts::equality_comparable_with__concept_<T, U>

◆ integral

template<typename T >
concept concepts::defs::integral
Initial value:
=
std::is_integral<T>::value

◆ movable

template<typename T >
concept concepts::defs::movable
Initial value:
=
std::is_object<T>::value &&
move_constructible<T> &&
concepts::move_assignable__concept_<T> &&
swappable<T>

◆ move_constructible

template<typename T >
concept concepts::defs::move_constructible
Initial value:
=
constructible_from<T, T> &&
convertible_to<T, T>

◆ regular

template<typename T >
concept concepts::defs::regular
Initial value:
=
semiregular<T> &&
equality_comparable<T>

◆ same_as

template<typename A , typename B >
concept concepts::defs::same_as
Initial value:
=
__is_same_as(A, B) && __is_same_as(B, A)

◆ satisfies

template<class T , template< typename... > class Trait, typename... Args>
concept concepts::defs::satisfies
Initial value:
=
static_cast<bool>(Trait<T, Args...>::type::value)

◆ semiregular

template<typename T >
concept concepts::defs::semiregular
Initial value:
=
copyable<T> &&
default_constructible<T>

◆ signed_integral

template<typename T >
concept concepts::defs::signed_integral
Initial value:
=
integral<T> &&
std::is_signed<T>::value

◆ swappable

template<typename T >
concept concepts::defs::swappable
Initial value:
=
defs::swappable__requires_<T>

◆ swappable_with

template<typename T , typename U >
concept concepts::defs::swappable_with
Initial value:
=
common_reference_with<detail::as_cref_t<T>, detail::as_cref_t<U>> &&
defs::swappable_with__requires_<T, U>

◆ three_way_comparable

template<typename T , typename Cat = std::partial_ordering>
concept concepts::defs::three_way_comparable
Initial value:
=
detail::weakly_equality_comparable_with_<T, T> &&
detail::partially_ordered_with_<T ,T> &&
requires `(detail::as_cref_t<T>& a, detail::as_cref_t<T>& b) {
{ a <=> b } -> detail::compares_as<Cat>;
}

◆ three_way_comparable_with

template<typename T , typename U , typename Cat = std::partial_ordering>
concept concepts::defs::three_way_comparable_with
Initial value:
=
three_way_comparable<T, Cat> &&
three_way_comparable<U, Cat> &&
common_reference_with<detail::as_cref_t<T>&, detail::as_cref_t<U>&> &&
three_way_comparable<common_reference_t<detail::as_cref_t<T>&, detail::as_cref_t<U>&>> &&
detail::partially_ordered_with_<T, U> &&
requires `(detail::as_cref_t<T>& t, detail::as_cref_t<U>& u) {
{ t <=> u } -> detail::compares_as<Cat>;
{ u <=> t } -> detail::compares_as<Cat>;
}

◆ totally_ordered

template<typename T >
concept concepts::defs::totally_ordered
Initial value:
=
equality_comparable<T> &&
detail::partially_ordered_with_<T, T>

◆ totally_ordered_with

template<typename T , typename U >
concept concepts::defs::totally_ordered_with
Initial value:
=
totally_ordered<T> &&
totally_ordered<U> &&
equality_comparable_with<T, U> &&
concepts::totally_ordered_with__concept_<T, U>

◆ unsigned_integral

template<typename T >
concept concepts::defs::unsigned_integral
Initial value:
=
integral<T> &&
!signed_integral<T>