Range-v3 Range algorithms, views, and actions for the Standard Library |

Classes | Typedefs | Functions | Variables
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)
template<bool B>
std::enable_if_t< B > | requires_ ()

## Variables
template<bool... Bs>
constexpr bool | and_v = (Bs &&...)
template<typename T , typename U >
concept | assignable_from__requires_
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<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__requires_
template<typename T , typename U >
concept | swappable_with__requires_
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__requires_

template<typename T , typename U >

concept concepts::defs::assignable_from__requires_

Initial value:
= CPP_REQUIRES_requires `(T t, U && u)
template<typename T, typename U>
concept assignable_from =
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(A, B) && __is_same(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__requires_

template<typename T >

concept concepts::defs::swappable__requires_

Initial value:
= CPP_REQUIRES_requires `(T & t, T & u)
template<typename T>
concept swappable =
defs::swappable__requires_<T>

## ◆ swappable_with__requires_

template<typename T , typename U >

concept concepts::defs::swappable_with__requires_

Initial value:
= CPP_REQUIRES_requires `(T && t, U && u)
template<typename T, typename U>
concept swappable_with =
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>