diff options
Diffstat (limited to '3rdparty/asio/include/asio/require_concept.hpp')
-rw-r--r-- | 3rdparty/asio/include/asio/require_concept.hpp | 352 |
1 files changed, 352 insertions, 0 deletions
diff --git a/3rdparty/asio/include/asio/require_concept.hpp b/3rdparty/asio/include/asio/require_concept.hpp new file mode 100644 index 00000000000..1238d6b6158 --- /dev/null +++ b/3rdparty/asio/include/asio/require_concept.hpp @@ -0,0 +1,352 @@ +// +// require_concept.hpp +// ~~~~~~~~~~~~~~~~~~~ +// +// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// +// Distributed under the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef ASIO_REQUIRE_CONCEPT_HPP +#define ASIO_REQUIRE_CONCEPT_HPP + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma once +#endif // defined(_MSC_VER) && (_MSC_VER >= 1200) + +#include "asio/detail/config.hpp" +#include "asio/detail/type_traits.hpp" +#include "asio/is_applicable_property.hpp" +#include "asio/traits/require_concept_member.hpp" +#include "asio/traits/require_concept_free.hpp" +#include "asio/traits/static_require_concept.hpp" + +#include "asio/detail/push_options.hpp" + +#if defined(GENERATING_DOCUMENTATION) + +namespace asio { + +/// A customisation point that applies a concept-enforcing property to an +/// object. +/** + * The name <tt>require_concept</tt> denotes a customization point object. The + * expression <tt>asio::require_concept(E, P)</tt> for some + * subexpressions <tt>E</tt> and <tt>P</tt> (with types <tt>T = + * decay_t<decltype(E)></tt> and <tt>Prop = decay_t<decltype(P)></tt>) is + * expression-equivalent to: + * + * @li If <tt>is_applicable_property_v<T, Prop> && + * Prop::is_requirable_concept</tt> is not a well-formed constant expression + * with value <tt>true</tt>, <tt>asio::require_concept(E, P)</tt> is + * ill-formed. + * + * @li Otherwise, <tt>E</tt> if the expression <tt>Prop::template + * static_query_v<T> == Prop::value()</tt> is a well-formed constant + * expression with value <tt>true</tt>. + * + * @li Otherwise, <tt>(E).require_concept(P)</tt> if the expression + * <tt>(E).require_concept(P)</tt> is well-formed. + * + * @li Otherwise, <tt>require_concept(E, P)</tt> if the expression + * <tt>require_concept(E, P)</tt> is a valid expression with overload + * resolution performed in a context that does not include the declaration + * of the <tt>require_concept</tt> customization point object. + * + * @li Otherwise, <tt>asio::require_concept(E, P)</tt> is ill-formed. + */ +inline constexpr unspecified require_concept = unspecified; + +/// A type trait that determines whether a @c require_concept expression is +/// well-formed. +/** + * Class template @c can_require_concept is a trait that is derived from + * @c true_type if the expression + * <tt>asio::require_concept(std::declval<T>(), + * std::declval<Property>())</tt> is well formed; otherwise @c false_type. + */ +template <typename T, typename Property> +struct can_require_concept : + integral_constant<bool, automatically_determined> +{ +}; + +/// A type trait that determines whether a @c require_concept expression will +/// not throw. +/** + * Class template @c is_nothrow_require_concept is a trait that is derived from + * @c true_type if the expression + * <tt>asio::require_concept(std::declval<T>(), + * std::declval<Property>())</tt> is @c noexcept; otherwise @c false_type. + */ +template <typename T, typename Property> +struct is_nothrow_require_concept : + integral_constant<bool, automatically_determined> +{ +}; + +/// A type trait that determines the result type of a @c require_concept +/// expression. +/** + * Class template @c require_concept_result is a trait that determines the + * result type of the expression + * <tt>asio::require_concept(std::declval<T>(), + * std::declval<Property>())</tt>. + */ +template <typename T, typename Property> +struct require_concept_result +{ + /// The result of the @c require_concept expression. + typedef automatically_determined type; +}; + +} // namespace asio + +#else // defined(GENERATING_DOCUMENTATION) + +namespace asio_require_concept_fn { + +using asio::conditional; +using asio::decay; +using asio::declval; +using asio::enable_if; +using asio::is_applicable_property; +using asio::traits::require_concept_free; +using asio::traits::require_concept_member; +using asio::traits::static_require_concept; + +void require_concept(); + +enum overload_type +{ + identity, + call_member, + call_free, + ill_formed +}; + +template <typename Impl, typename T, typename Properties, typename = void, + typename = void, typename = void, typename = void, typename = void> +struct call_traits +{ + ASIO_STATIC_CONSTEXPR(overload_type, overload = ill_formed); + ASIO_STATIC_CONSTEXPR(bool, is_noexcept = false); + typedef void result_type; +}; + +template <typename Impl, typename T, typename Property> +struct call_traits<Impl, T, void(Property), + typename enable_if< + is_applicable_property< + typename decay<T>::type, + typename decay<Property>::type + >::value + >::type, + typename enable_if< + decay<Property>::type::is_requirable_concept + >::type, + typename enable_if< + static_require_concept<T, Property>::is_valid + >::type> +{ + ASIO_STATIC_CONSTEXPR(overload_type, overload = identity); + ASIO_STATIC_CONSTEXPR(bool, is_noexcept = true); + typedef ASIO_MOVE_ARG(T) result_type; +}; + +template <typename Impl, typename T, typename Property> +struct call_traits<Impl, T, void(Property), + typename enable_if< + is_applicable_property< + typename decay<T>::type, + typename decay<Property>::type + >::value + >::type, + typename enable_if< + decay<Property>::type::is_requirable_concept + >::type, + typename enable_if< + !static_require_concept<T, Property>::is_valid + >::type, + typename enable_if< + require_concept_member< + typename Impl::template proxy<T>::type, + Property + >::is_valid + >::type> : + require_concept_member< + typename Impl::template proxy<T>::type, + Property + > +{ + ASIO_STATIC_CONSTEXPR(overload_type, overload = call_member); +}; + +template <typename Impl, typename T, typename Property> +struct call_traits<Impl, T, void(Property), + typename enable_if< + is_applicable_property< + typename decay<T>::type, + typename decay<Property>::type + >::value + >::type, + typename enable_if< + decay<Property>::type::is_requirable_concept + >::type, + typename enable_if< + !static_require_concept<T, Property>::is_valid + >::type, + typename enable_if< + !require_concept_member< + typename Impl::template proxy<T>::type, + Property + >::is_valid + >::type, + typename enable_if< + require_concept_free<T, Property>::is_valid + >::type> : + require_concept_free<T, Property> +{ + ASIO_STATIC_CONSTEXPR(overload_type, overload = call_free); +}; + +struct impl +{ + template <typename T> + struct proxy + { +#if defined(ASIO_HAS_DEDUCED_REQUIRE_CONCEPT_MEMBER_TRAIT) + struct type + { + template <typename P> + auto require_concept(ASIO_MOVE_ARG(P) p) + noexcept( + noexcept( + declval<typename conditional<true, T, P>::type>().require_concept( + ASIO_MOVE_CAST(P)(p)) + ) + ) + -> decltype( + declval<typename conditional<true, T, P>::type>().require_concept( + ASIO_MOVE_CAST(P)(p)) + ); + }; +#else // defined(ASIO_HAS_DEDUCED_REQUIRE_CONCEPT_MEMBER_TRAIT) + typedef T type; +#endif // defined(ASIO_HAS_DEDUCED_REQUIRE_CONCEPT_MEMBER_TRAIT) + }; + + template <typename T, typename Property> + ASIO_NODISCARD ASIO_CONSTEXPR typename enable_if< + call_traits<impl, T, void(Property)>::overload == identity, + typename call_traits<impl, T, void(Property)>::result_type + >::type + operator()( + ASIO_MOVE_ARG(T) t, + ASIO_MOVE_ARG(Property)) const + ASIO_NOEXCEPT_IF(( + call_traits<impl, T, void(Property)>::is_noexcept)) + { + return ASIO_MOVE_CAST(T)(t); + } + + template <typename T, typename Property> + ASIO_NODISCARD ASIO_CONSTEXPR typename enable_if< + call_traits<impl, T, void(Property)>::overload == call_member, + typename call_traits<impl, T, void(Property)>::result_type + >::type + operator()( + ASIO_MOVE_ARG(T) t, + ASIO_MOVE_ARG(Property) p) const + ASIO_NOEXCEPT_IF(( + call_traits<impl, T, void(Property)>::is_noexcept)) + { + return ASIO_MOVE_CAST(T)(t).require_concept( + ASIO_MOVE_CAST(Property)(p)); + } + + template <typename T, typename Property> + ASIO_NODISCARD ASIO_CONSTEXPR typename enable_if< + call_traits<impl, T, void(Property)>::overload == call_free, + typename call_traits<impl, T, void(Property)>::result_type + >::type + operator()( + ASIO_MOVE_ARG(T) t, + ASIO_MOVE_ARG(Property) p) const + ASIO_NOEXCEPT_IF(( + call_traits<impl, T, void(Property)>::is_noexcept)) + { + return require_concept( + ASIO_MOVE_CAST(T)(t), + ASIO_MOVE_CAST(Property)(p)); + } +}; + +template <typename T = impl> +struct static_instance +{ + static const T instance; +}; + +template <typename T> +const T static_instance<T>::instance = {}; + +} // namespace asio_require_concept_fn +namespace asio { +namespace { + +static ASIO_CONSTEXPR const asio_require_concept_fn::impl& + require_concept = asio_require_concept_fn::static_instance<>::instance; + +} // namespace + +typedef asio_require_concept_fn::impl require_concept_t; + +template <typename T, typename Property> +struct can_require_concept : + integral_constant<bool, + asio_require_concept_fn::call_traits< + require_concept_t, T, void(Property)>::overload != + asio_require_concept_fn::ill_formed> +{ +}; + +#if defined(ASIO_HAS_VARIABLE_TEMPLATES) + +template <typename T, typename Property> +constexpr bool can_require_concept_v + = can_require_concept<T, Property>::value; + +#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES) + +template <typename T, typename Property> +struct is_nothrow_require_concept : + integral_constant<bool, + asio_require_concept_fn::call_traits< + require_concept_t, T, void(Property)>::is_noexcept> +{ +}; + +#if defined(ASIO_HAS_VARIABLE_TEMPLATES) + +template <typename T, typename Property> +constexpr bool is_nothrow_require_concept_v + = is_nothrow_require_concept<T, Property>::value; + +#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES) + +template <typename T, typename Property> +struct require_concept_result +{ + typedef typename asio_require_concept_fn::call_traits< + require_concept_t, T, void(Property)>::result_type type; +}; + +} // namespace asio + +#endif // defined(GENERATING_DOCUMENTATION) + +#include "asio/detail/pop_options.hpp" + +#endif // ASIO_REQUIRE_CONCEPT_HPP |