// // require.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 ACTIV_BOOST_ASIO_REQUIRE_HPP #define ACTIV_BOOST_ASIO_REQUIRE_HPP #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include #include #include #include #include #include #include #if defined(GENERATING_DOCUMENTATION) namespace Boost { namespace asio { /// A customisation point that applies a concept-preserving property to an /// object. /** * The name require denotes a customisation point object. The * expression Boost::asio::require(E, P0, Pn...) for some * subexpressions E and P0, and where Pn... * represents N subexpressions (where N is 0 or more, and with * types T = decay_t and Prop0 = * decay_t) is expression-equivalent to: * * @li If is_applicable_property_v && Prop0::is_requirable is * not a well-formed constant expression with value true, * Boost::asio::require(E, P0, Pn...) is ill-formed. * * @li Otherwise, E if N == 0 and the expression * Prop0::template static_query_v == Prop0::value() is a * well-formed constant expression with value true. * * @li Otherwise, (E).require(P0) if N == 0 and the expression * (E).require(P0) is a valid expression. * * @li Otherwise, require(E, P0) if N == 0 and the expression * require(E, P0) is a valid expression with overload resolution * performed in a context that does not include the declaration of the * require customization point object. * * @li Otherwise, * Boost::asio::require(Boost::asio::require(E, P0), Pn...) * if N > 0 and the expression * Boost::asio::require(Boost::asio::require(E, P0), Pn...) * is a valid expression. * * @li Otherwise, Boost::asio::require(E, P0, Pn...) is ill-formed. */ inline constexpr unspecified require = unspecified; /// A type trait that determines whether a @c require expression is well-formed. /** * Class template @c can_require is a trait that is derived from * @c true_type if the expression Boost::asio::require(std::declval(), * std::declval()...) is well formed; otherwise @c false_type. */ template struct can_require : integral_constant { }; /// A type trait that determines whether a @c require expression will not throw. /** * Class template @c is_nothrow_require is a trait that is derived from * @c true_type if the expression Boost::asio::require(std::declval(), * std::declval()...) is @c noexcept; otherwise @c false_type. */ template struct is_nothrow_require : integral_constant { }; /// A type trait that determines the result type of a @c require expression. /** * Class template @c require_result is a trait that determines the result * type of the expression Boost::asio::require(std::declval(), * std::declval()...). */ template struct require_result { /// The result of the @c require expression. typedef automatically_determined type; }; } // namespace asio } // namespace Boost #else // defined(GENERATING_DOCUMENTATION) namespace Boost_asio_require_fn { using Boost::asio::conditional; using Boost::asio::decay; using Boost::asio::declval; using Boost::asio::enable_if; using Boost::asio::is_applicable_property; using Boost::asio::traits::require_free; using Boost::asio::traits::require_member; using Boost::asio::traits::static_require; void require(); enum overload_type { identity, call_member, call_free, two_props, n_props, ill_formed }; template struct call_traits { ACTIV_BOOST_ASIO_STATIC_CONSTEXPR(overload_type, overload = ill_formed); ACTIV_BOOST_ASIO_STATIC_CONSTEXPR(bool, is_noexcept = false); typedef void result_type; }; template struct call_traits::type, typename decay::type >::value >::type, typename enable_if< decay::type::is_requirable >::type, typename enable_if< static_require::is_valid >::type> { ACTIV_BOOST_ASIO_STATIC_CONSTEXPR(overload_type, overload = identity); ACTIV_BOOST_ASIO_STATIC_CONSTEXPR(bool, is_noexcept = true); #if defined(ACTIV_BOOST_ASIO_HAS_MOVE) typedef ACTIV_BOOST_ASIO_MOVE_ARG(T) result_type; #else // defined(ACTIV_BOOST_ASIO_HAS_MOVE) typedef ACTIV_BOOST_ASIO_MOVE_ARG(typename decay::type) result_type; #endif // defined(ACTIV_BOOST_ASIO_HAS_MOVE) }; template struct call_traits::type, typename decay::type >::value >::type, typename enable_if< decay::type::is_requirable >::type, typename enable_if< !static_require::is_valid >::type, typename enable_if< require_member::type, Property>::is_valid >::type> : require_member::type, Property> { ACTIV_BOOST_ASIO_STATIC_CONSTEXPR(overload_type, overload = call_member); }; template struct call_traits::type, typename decay::type >::value >::type, typename enable_if< decay::type::is_requirable >::type, typename enable_if< !static_require::is_valid >::type, typename enable_if< !require_member::type, Property>::is_valid >::type, typename enable_if< require_free::is_valid >::type> : require_free { ACTIV_BOOST_ASIO_STATIC_CONSTEXPR(overload_type, overload = call_free); }; template struct call_traits::overload != ill_formed >::type, typename enable_if< call_traits< Impl, typename call_traits::result_type, void(P1) >::overload != ill_formed >::type> { ACTIV_BOOST_ASIO_STATIC_CONSTEXPR(overload_type, overload = two_props); ACTIV_BOOST_ASIO_STATIC_CONSTEXPR(bool, is_noexcept = ( call_traits::is_noexcept && call_traits< Impl, typename call_traits::result_type, void(P1) >::is_noexcept )); typedef typename decay< typename call_traits< Impl, typename call_traits::result_type, void(P1) >::result_type >::type result_type; }; template struct call_traits::overload != ill_formed >::type, typename enable_if< call_traits< Impl, typename call_traits::result_type, void(P1, PN ACTIV_BOOST_ASIO_ELLIPSIS) >::overload != ill_formed >::type> { ACTIV_BOOST_ASIO_STATIC_CONSTEXPR(overload_type, overload = n_props); ACTIV_BOOST_ASIO_STATIC_CONSTEXPR(bool, is_noexcept = ( call_traits::is_noexcept && call_traits< Impl, typename call_traits::result_type, void(P1, PN ACTIV_BOOST_ASIO_ELLIPSIS) >::is_noexcept )); typedef typename decay< typename call_traits< Impl, typename call_traits::result_type, void(P1, PN ACTIV_BOOST_ASIO_ELLIPSIS) >::result_type >::type result_type; }; struct impl { template struct proxy { #if defined(ACTIV_BOOST_ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT) struct type { template auto require(ACTIV_BOOST_ASIO_MOVE_ARG(P) p) noexcept( noexcept( declval::type>().require( ACTIV_BOOST_ASIO_MOVE_CAST(P)(p)) ) ) -> decltype( declval::type>().require( ACTIV_BOOST_ASIO_MOVE_CAST(P)(p)) ); }; #else // defined(ACTIV_BOOST_ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT) typedef T type; #endif // defined(ACTIV_BOOST_ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT) }; template ACTIV_BOOST_ASIO_NODISCARD ACTIV_BOOST_ASIO_CONSTEXPR typename enable_if< call_traits::overload == identity, typename call_traits::result_type >::type operator()( ACTIV_BOOST_ASIO_MOVE_ARG(T) t, ACTIV_BOOST_ASIO_MOVE_ARG(Property)) const ACTIV_BOOST_ASIO_NOEXCEPT_IF(( call_traits::is_noexcept)) { return ACTIV_BOOST_ASIO_MOVE_CAST(T)(t); } template ACTIV_BOOST_ASIO_NODISCARD ACTIV_BOOST_ASIO_CONSTEXPR typename enable_if< call_traits::overload == call_member, typename call_traits::result_type >::type operator()( ACTIV_BOOST_ASIO_MOVE_ARG(T) t, ACTIV_BOOST_ASIO_MOVE_ARG(Property) p) const ACTIV_BOOST_ASIO_NOEXCEPT_IF(( call_traits::is_noexcept)) { return ACTIV_BOOST_ASIO_MOVE_CAST(T)(t).require( ACTIV_BOOST_ASIO_MOVE_CAST(Property)(p)); } template ACTIV_BOOST_ASIO_NODISCARD ACTIV_BOOST_ASIO_CONSTEXPR typename enable_if< call_traits::overload == call_free, typename call_traits::result_type >::type operator()( ACTIV_BOOST_ASIO_MOVE_ARG(T) t, ACTIV_BOOST_ASIO_MOVE_ARG(Property) p) const ACTIV_BOOST_ASIO_NOEXCEPT_IF(( call_traits::is_noexcept)) { return require( ACTIV_BOOST_ASIO_MOVE_CAST(T)(t), ACTIV_BOOST_ASIO_MOVE_CAST(Property)(p)); } template ACTIV_BOOST_ASIO_NODISCARD ACTIV_BOOST_ASIO_CONSTEXPR typename enable_if< call_traits::overload == two_props, typename call_traits::result_type >::type operator()( ACTIV_BOOST_ASIO_MOVE_ARG(T) t, ACTIV_BOOST_ASIO_MOVE_ARG(P0) p0, ACTIV_BOOST_ASIO_MOVE_ARG(P1) p1) const ACTIV_BOOST_ASIO_NOEXCEPT_IF(( call_traits::is_noexcept)) { return (*this)( (*this)( ACTIV_BOOST_ASIO_MOVE_CAST(T)(t), ACTIV_BOOST_ASIO_MOVE_CAST(P0)(p0)), ACTIV_BOOST_ASIO_MOVE_CAST(P1)(p1)); } template ACTIV_BOOST_ASIO_NODISCARD ACTIV_BOOST_ASIO_CONSTEXPR typename enable_if< call_traits::overload == n_props, typename call_traits::result_type >::type operator()( ACTIV_BOOST_ASIO_MOVE_ARG(T) t, ACTIV_BOOST_ASIO_MOVE_ARG(P0) p0, ACTIV_BOOST_ASIO_MOVE_ARG(P1) p1, ACTIV_BOOST_ASIO_MOVE_ARG(PN) ACTIV_BOOST_ASIO_ELLIPSIS pn) const ACTIV_BOOST_ASIO_NOEXCEPT_IF(( call_traits::is_noexcept)) { return (*this)( (*this)( ACTIV_BOOST_ASIO_MOVE_CAST(T)(t), ACTIV_BOOST_ASIO_MOVE_CAST(P0)(p0)), ACTIV_BOOST_ASIO_MOVE_CAST(P1)(p1), ACTIV_BOOST_ASIO_MOVE_CAST(PN)(pn) ACTIV_BOOST_ASIO_ELLIPSIS); } }; template struct static_instance { static const T instance; }; template const T static_instance::instance = {}; } // namespace Boost_asio_require_fn namespace Boost { namespace asio { namespace { static ACTIV_BOOST_ASIO_CONSTEXPR const Boost_asio_require_fn::impl& require = Boost_asio_require_fn::static_instance<>::instance; } // namespace typedef Boost_asio_require_fn::impl require_t; #if defined(ACTIV_BOOST_ASIO_HAS_VARIADIC_TEMPLATES) template struct can_require : integral_constant::overload != Boost_asio_require_fn::ill_formed> { }; #else // defined(ACTIV_BOOST_ASIO_HAS_VARIADIC_TEMPLATES) template struct can_require : integral_constant::overload != Boost_asio_require_fn::ill_formed> { }; template struct can_require : integral_constant::overload != Boost_asio_require_fn::ill_formed> { }; template struct can_require : integral_constant::overload != Boost_asio_require_fn::ill_formed> { }; template struct can_require : false_type { }; #endif // defined(ACTIV_BOOST_ASIO_HAS_VARIADIC_TEMPLATES) #if defined(ACTIV_BOOST_ASIO_HAS_VARIABLE_TEMPLATES) template constexpr bool can_require_v = can_require::value; #endif // defined(ACTIV_BOOST_ASIO_HAS_VARIABLE_TEMPLATES) #if defined(ACTIV_BOOST_ASIO_HAS_VARIADIC_TEMPLATES) template struct is_nothrow_require : integral_constant::is_noexcept> { }; #else // defined(ACTIV_BOOST_ASIO_HAS_VARIADIC_TEMPLATES) template struct is_nothrow_require : integral_constant::is_noexcept> { }; template struct is_nothrow_require : integral_constant::is_noexcept> { }; template struct is_nothrow_require : integral_constant::is_noexcept> { }; template struct is_nothrow_require : false_type { }; #endif // defined(ACTIV_BOOST_ASIO_HAS_VARIADIC_TEMPLATES) #if defined(ACTIV_BOOST_ASIO_HAS_VARIABLE_TEMPLATES) template constexpr bool is_nothrow_require_v = is_nothrow_require::value; #endif // defined(ACTIV_BOOST_ASIO_HAS_VARIABLE_TEMPLATES) #if defined(ACTIV_BOOST_ASIO_HAS_VARIADIC_TEMPLATES) template struct require_result { typedef typename Boost_asio_require_fn::call_traits< require_t, T, void(Properties...)>::result_type type; }; #else // defined(ACTIV_BOOST_ASIO_HAS_VARIADIC_TEMPLATES) template struct require_result { typedef typename Boost_asio_require_fn::call_traits< require_t, T, void(P0, P1, P2)>::result_type type; }; template struct require_result { typedef typename Boost_asio_require_fn::call_traits< require_t, T, void(P0, P1)>::result_type type; }; template struct require_result { typedef typename Boost_asio_require_fn::call_traits< require_t, T, void(P0)>::result_type type; }; template struct require_result { }; #endif // defined(ACTIV_BOOST_ASIO_HAS_VARIADIC_TEMPLATES) } // namespace asio } // namespace Boost #endif // defined(GENERATING_DOCUMENTATION) #include #endif // ACTIV_BOOST_ASIO_REQUIRE_HPP