Edit: /usr/include/boost/asio/require.hpp (14926B)
//
// require.hpp
// ~~~~~~~~~~~
//
// Copyright (c) 2003-2020 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 BOOST_ASIO_REQUIRE_HPP
#define 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 asio_require_fn {
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
{
BOOST_ASIO_STATIC_CONSTEXPR(overload_type, overload = ill_formed);
BOOST_ASIO_STATIC_CONSTEXPR(bool, is_noexcept = false);
typedef void result_type;
};
template
struct call_traits::type,
typename decay::type
>::value
&&
decay::type::is_requirable
&&
static_require::is_valid
)
>::type>
{
BOOST_ASIO_STATIC_CONSTEXPR(overload_type, overload = identity);
BOOST_ASIO_STATIC_CONSTEXPR(bool, is_noexcept = true);
#if defined(BOOST_ASIO_HAS_MOVE)
typedef BOOST_ASIO_MOVE_ARG(T) result_type;
#else // defined(BOOST_ASIO_HAS_MOVE)
typedef BOOST_ASIO_MOVE_ARG(typename decay::type) result_type;
#endif // defined(BOOST_ASIO_HAS_MOVE)
};
template
struct call_traits::type,
typename decay::type
>::value
&&
decay::type::is_requirable
&&
!static_require::is_valid
&&
require_member::is_valid
)
>::type> :
require_member
{
BOOST_ASIO_STATIC_CONSTEXPR(overload_type, overload = call_member);
};
template
struct call_traits::type,
typename decay::type
>::value
&&
decay::type::is_requirable
&&
!static_require::is_valid
&&
!require_member::is_valid
&&
require_free::is_valid
)
>::type> :
require_free
{
BOOST_ASIO_STATIC_CONSTEXPR(overload_type, overload = call_free);
};
template
struct call_traits::overload != ill_formed
&&
call_traits<
typename call_traits::result_type,
void(P1)
>::overload != ill_formed
>::type>
{
BOOST_ASIO_STATIC_CONSTEXPR(overload_type, overload = two_props);
BOOST_ASIO_STATIC_CONSTEXPR(bool, is_noexcept =
(
call_traits::is_noexcept
&&
call_traits<
typename call_traits::result_type,
void(P1)
>::is_noexcept
));
typedef typename decay<
typename call_traits<
typename call_traits::result_type,
void(P1)
>::result_type
>::type result_type;
};
template
struct call_traits::overload != ill_formed
&&
call_traits<
typename call_traits::result_type,
void(P1, PN BOOST_ASIO_ELLIPSIS)
>::overload != ill_formed
>::type>
{
BOOST_ASIO_STATIC_CONSTEXPR(overload_type, overload = n_props);
BOOST_ASIO_STATIC_CONSTEXPR(bool, is_noexcept =
(
call_traits::is_noexcept
&&
call_traits<
typename call_traits::result_type,
void(P1, PN BOOST_ASIO_ELLIPSIS)
>::is_noexcept
));
typedef typename decay<
typename call_traits<
typename call_traits::result_type,
void(P1, PN BOOST_ASIO_ELLIPSIS)
>::result_type
>::type result_type;
};
struct impl
{
template
BOOST_ASIO_NODISCARD BOOST_ASIO_CONSTEXPR typename enable_if<
call_traits::overload == identity,
typename call_traits::result_type
>::type
operator()(
BOOST_ASIO_MOVE_ARG(T) t,
BOOST_ASIO_MOVE_ARG(Property)) const
BOOST_ASIO_NOEXCEPT_IF((
call_traits::is_noexcept))
{
return BOOST_ASIO_MOVE_CAST(T)(t);
}
template
BOOST_ASIO_NODISCARD BOOST_ASIO_CONSTEXPR typename enable_if<
call_traits::overload == call_member,
typename call_traits::result_type
>::type
operator()(
BOOST_ASIO_MOVE_ARG(T) t,
BOOST_ASIO_MOVE_ARG(Property) p) const
BOOST_ASIO_NOEXCEPT_IF((
call_traits::is_noexcept))
{
return BOOST_ASIO_MOVE_CAST(T)(t).require(
BOOST_ASIO_MOVE_CAST(Property)(p));
}
template
BOOST_ASIO_NODISCARD BOOST_ASIO_CONSTEXPR typename enable_if<
call_traits::overload == call_free,
typename call_traits::result_type
>::type
operator()(
BOOST_ASIO_MOVE_ARG(T) t,
BOOST_ASIO_MOVE_ARG(Property) p) const
BOOST_ASIO_NOEXCEPT_IF((
call_traits::is_noexcept))
{
return require(
BOOST_ASIO_MOVE_CAST(T)(t),
BOOST_ASIO_MOVE_CAST(Property)(p));
}
template
BOOST_ASIO_NODISCARD BOOST_ASIO_CONSTEXPR typename enable_if<
call_traits::overload == two_props,
typename call_traits::result_type
>::type
operator()(
BOOST_ASIO_MOVE_ARG(T) t,
BOOST_ASIO_MOVE_ARG(P0) p0,
BOOST_ASIO_MOVE_ARG(P1) p1) const
BOOST_ASIO_NOEXCEPT_IF((
call_traits::is_noexcept))
{
return (*this)(
(*this)(
BOOST_ASIO_MOVE_CAST(T)(t),
BOOST_ASIO_MOVE_CAST(P0)(p0)),
BOOST_ASIO_MOVE_CAST(P1)(p1));
}
template
BOOST_ASIO_NODISCARD BOOST_ASIO_CONSTEXPR typename enable_if<
call_traits::overload == n_props,
typename call_traits::result_type
>::type
operator()(
BOOST_ASIO_MOVE_ARG(T) t,
BOOST_ASIO_MOVE_ARG(P0) p0,
BOOST_ASIO_MOVE_ARG(P1) p1,
BOOST_ASIO_MOVE_ARG(PN) BOOST_ASIO_ELLIPSIS pn) const
BOOST_ASIO_NOEXCEPT_IF((
call_traits::is_noexcept))
{
return (*this)(
(*this)(
BOOST_ASIO_MOVE_CAST(T)(t),
BOOST_ASIO_MOVE_CAST(P0)(p0)),
BOOST_ASIO_MOVE_CAST(P1)(p1),
BOOST_ASIO_MOVE_CAST(PN)(pn) BOOST_ASIO_ELLIPSIS);
}
};
template
struct static_instance
{
static const T instance;
};
template
const T static_instance::instance = {};
} // namespace asio_require_fn
namespace boost {
namespace asio {
namespace {
static BOOST_ASIO_CONSTEXPR const asio_require_fn::impl&
require = asio_require_fn::static_instance<>::instance;
} // namespace
#if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
template
struct can_require :
integral_constant::overload
!= asio_require_fn::ill_formed>
{
};
#else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
template
struct can_require :
integral_constant::overload
!= asio_require_fn::ill_formed>
{
};
template
struct can_require :
integral_constant::overload
!= asio_require_fn::ill_formed>
{
};
template
struct can_require :
integral_constant::overload
!= asio_require_fn::ill_formed>
{
};
template
struct can_require :
false_type
{
};
#endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
#if defined(BOOST_ASIO_HAS_VARIABLE_TEMPLATES)
template
constexpr bool can_require_v
= can_require::value;
#endif // defined(BOOST_ASIO_HAS_VARIABLE_TEMPLATES)
#if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
template
struct is_nothrow_require :
integral_constant::is_noexcept>
{
};
#else // defined(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(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
#if defined(BOOST_ASIO_HAS_VARIABLE_TEMPLATES)
template
constexpr bool is_nothrow_require_v
= is_nothrow_require::value;
#endif // defined(BOOST_ASIO_HAS_VARIABLE_TEMPLATES)
#if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
template
struct require_result
{
typedef typename asio_require_fn::call_traits<
T, void(Properties...)>::result_type type;
};
#else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
template
struct require_result
{
typedef typename asio_require_fn::call_traits<
T, void(P0, P1, P2)>::result_type type;
};
template
struct require_result
{
typedef typename asio_require_fn::call_traits<
T, void(P0, P1)>::result_type type;
};
template
struct require_result
{
typedef typename asio_require_fn::call_traits<
T, void(P0)>::result_type type;
};
template
struct require_result
{
};
#endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
} // namespace asio
} // namespace boost
#endif // defined(GENERATING_DOCUMENTATION)
#include
#endif // BOOST_ASIO_REQUIRE_HPP