N-archive/suyu
1
0
Fork 0
mirror of https://git.suyu.dev/suyu/suyu.git synced 2024-12-19 12:01:01 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions
suyu/externals/vcpkg/packages/boost-asio_x64-windows/include/boost/asio/prefer.hpp

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

739 lines
21 KiB
C++
Raw Normal View History

Initial commit
2024-03-05 09:42:40 +01:00
//
// prefer.hpp
// ~~~~~~~~~~
//
// Copyright (c) 2003-2022 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_PREFER_HPP
#define BOOST_ASIO_PREFER_HPP
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
# pragma once
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
#include <boost/asio/detail/config.hpp>
#include <boost/asio/detail/type_traits.hpp>
#include <boost/asio/is_applicable_property.hpp>
#include <boost/asio/traits/prefer_free.hpp>
#include <boost/asio/traits/prefer_member.hpp>
#include <boost/asio/traits/require_free.hpp>
#include <boost/asio/traits/require_member.hpp>
#include <boost/asio/traits/static_require.hpp>
#include <boost/asio/detail/push_options.hpp>
#if defined(GENERATING_DOCUMENTATION)
namespace boost {
namespace asio {
/// A customisation point that attempts to apply a property to an object.
/**
* The name <tt>prefer</tt> denotes a customisation point object. The
* expression <tt>boost::asio::prefer(E, P0, Pn...)</tt> for some subexpressions
* <tt>E</tt> and <tt>P0</tt>, and where <tt>Pn...</tt> represents <tt>N</tt>
* subexpressions (where <tt>N</tt> is 0 or more, and with types <tt>T =
* decay_t<decltype(E)></tt> and <tt>Prop0 = decay_t<decltype(P0)></tt>) is
* expression-equivalent to:
*
* @li If <tt>is_applicable_property_v<T, Prop0> && Prop0::is_preferable</tt> is
* not a well-formed constant expression with value <tt>true</tt>,
* <tt>boost::asio::prefer(E, P0, Pn...)</tt> is ill-formed.
*
* @li Otherwise, <tt>E</tt> if <tt>N == 0</tt> and the expression
* <tt>Prop0::template static_query_v<T> == Prop0::value()</tt> is a
* well-formed constant expression with value <tt>true</tt>.
*
* @li Otherwise, <tt>(E).require(P0)</tt> if <tt>N == 0</tt> and the expression
* <tt>(E).require(P0)</tt> is a valid expression.
*
* @li Otherwise, <tt>require(E, P0)</tt> if <tt>N == 0</tt> and the expression
* <tt>require(E, P0)</tt> is a valid expression with overload resolution
* performed in a context that does not include the declaration of the
* <tt>require</tt> customization point object.
*
* @li Otherwise, <tt>(E).prefer(P0)</tt> if <tt>N == 0</tt> and the expression
* <tt>(E).prefer(P0)</tt> is a valid expression.
*
* @li Otherwise, <tt>prefer(E, P0)</tt> if <tt>N == 0</tt> and the expression
* <tt>prefer(E, P0)</tt> is a valid expression with overload resolution
* performed in a context that does not include the declaration of the
* <tt>prefer</tt> customization point object.
*
* @li Otherwise, <tt>E</tt> if <tt>N == 0</tt>.
*
* @li Otherwise,
* <tt>boost::asio::prefer(boost::asio::prefer(E, P0), Pn...)</tt>
* if <tt>N > 0</tt> and the expression
* <tt>boost::asio::prefer(boost::asio::prefer(E, P0), Pn...)</tt>
* is a valid expression.
*
* @li Otherwise, <tt>boost::asio::prefer(E, P0, Pn...)</tt> is ill-formed.
*/
inline constexpr unspecified prefer = unspecified;
/// A type trait that determines whether a @c prefer expression is well-formed.
/**
* Class template @c can_prefer is a trait that is derived from
* @c true_type if the expression <tt>boost::asio::prefer(std::declval<T>(),
* std::declval<Properties>()...)</tt> is well formed; otherwise @c false_type.
*/
template <typename T, typename... Properties>
struct can_prefer :
integral_constant<bool, automatically_determined>
{
};
/// A type trait that determines whether a @c prefer expression will not throw.
/**
* Class template @c is_nothrow_prefer is a trait that is derived from
* @c true_type if the expression <tt>boost::asio::prefer(std::declval<T>(),
* std::declval<Properties>()...)</tt> is @c noexcept; otherwise @c false_type.
*/
template <typename T, typename... Properties>
struct is_nothrow_prefer :
integral_constant<bool, automatically_determined>
{
};
/// A type trait that determines the result type of a @c prefer expression.
/**
* Class template @c prefer_result is a trait that determines the result
* type of the expression <tt>boost::asio::prefer(std::declval<T>(),
* std::declval<Properties>()...)</tt>.
*/
template <typename T, typename... Properties>
struct prefer_result
{
/// The result of the @c prefer expression.
typedef automatically_determined type;
};
} // namespace asio
} // namespace boost
#else // defined(GENERATING_DOCUMENTATION)
namespace boost_asio_prefer_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::prefer_free;
using boost::asio::traits::prefer_member;
using boost::asio::traits::require_free;
using boost::asio::traits::require_member;
using boost::asio::traits::static_require;
void prefer();
void require();
enum overload_type
{
identity,
call_require_member,
call_require_free,
call_prefer_member,
call_prefer_free,
two_props,
n_props,
ill_formed
};
template <typename Impl, typename T, typename Properties,
typename = void, typename = void, typename = void, typename = void,
typename = void, typename = void, typename = void>
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 <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_preferable
>::type,
typename enable_if<
static_require<T, Property>::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<T>::type) result_type;
#endif // defined(BOOST_ASIO_HAS_MOVE)
};
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_preferable
>::type,
typename enable_if<
!static_require<T, Property>::is_valid
>::type,
typename enable_if<
require_member<typename Impl::template proxy<T>::type, Property>::is_valid
>::type> :
require_member<typename Impl::template proxy<T>::type, Property>
{
BOOST_ASIO_STATIC_CONSTEXPR(overload_type, overload = call_require_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_preferable
>::type,
typename enable_if<
!static_require<T, Property>::is_valid
>::type,
typename enable_if<
!require_member<typename Impl::template proxy<T>::type, Property>::is_valid
>::type,
typename enable_if<
require_free<T, Property>::is_valid
>::type> :
require_free<T, Property>
{
BOOST_ASIO_STATIC_CONSTEXPR(overload_type, overload = call_require_free);
};
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_preferable
>::type,
typename enable_if<
!static_require<T, Property>::is_valid
>::type,
typename enable_if<
!require_member<typename Impl::template proxy<T>::type, Property>::is_valid
>::type,
typename enable_if<
!require_free<T, Property>::is_valid
>::type,
typename enable_if<
prefer_member<typename Impl::template proxy<T>::type, Property>::is_valid
>::type> :
prefer_member<typename Impl::template proxy<T>::type, Property>
{
BOOST_ASIO_STATIC_CONSTEXPR(overload_type, overload = call_prefer_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_preferable
>::type,
typename enable_if<
!static_require<T, Property>::is_valid
>::type,
typename enable_if<
!require_member<typename Impl::template proxy<T>::type, Property>::is_valid
>::type,
typename enable_if<
!require_free<T, Property>::is_valid
>::type,
typename enable_if<
!prefer_member<typename Impl::template proxy<T>::type, Property>::is_valid
>::type,
typename enable_if<
prefer_free<T, Property>::is_valid
>::type> :
prefer_free<T, Property>
{
BOOST_ASIO_STATIC_CONSTEXPR(overload_type, overload = call_prefer_free);
};
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_preferable
>::type,
typename enable_if<
!static_require<T, Property>::is_valid
>::type,
typename enable_if<
!require_member<typename Impl::template proxy<T>::type, Property>::is_valid
>::type,
typename enable_if<
!require_free<T, Property>::is_valid
>::type,
typename enable_if<
!prefer_member<typename Impl::template proxy<T>::type, Property>::is_valid
>::type,
typename enable_if<
!prefer_free<T, Property>::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<T>::type) result_type;
#endif // defined(BOOST_ASIO_HAS_MOVE)
};
template <typename Impl, typename T, typename P0, typename P1>
struct call_traits<Impl, T, void(P0, P1),
typename enable_if<
call_traits<Impl, T, void(P0)>::overload != ill_formed
>::type,
typename enable_if<
call_traits<
Impl,
typename call_traits<Impl, T, void(P0)>::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<Impl, T, void(P0)>::is_noexcept
&&
call_traits<
Impl,
typename call_traits<Impl, T, void(P0)>::result_type,
void(P1)
>::is_noexcept
));
typedef typename decay<
typename call_traits<
Impl,
typename call_traits<Impl, T, void(P0)>::result_type,
void(P1)
>::result_type
>::type result_type;
};
template <typename Impl, typename T, typename P0,
typename P1, typename BOOST_ASIO_ELLIPSIS PN>
struct call_traits<Impl, T, void(P0, P1, PN BOOST_ASIO_ELLIPSIS),
typename enable_if<
call_traits<Impl, T, void(P0)>::overload != ill_formed
>::type,
typename enable_if<
call_traits<
Impl,
typename call_traits<Impl, T, void(P0)>::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<Impl, T, void(P0)>::is_noexcept
&&
call_traits<
Impl,
typename call_traits<Impl, T, void(P0)>::result_type,
void(P1, PN BOOST_ASIO_ELLIPSIS)
>::is_noexcept
));
typedef typename decay<
typename call_traits<
Impl,
typename call_traits<Impl, T, void(P0)>::result_type,
void(P1, PN BOOST_ASIO_ELLIPSIS)
>::result_type
>::type result_type;
};
struct impl
{
template <typename T>
struct proxy
{
#if defined(BOOST_ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT) \
&& defined(BOOST_ASIO_HAS_DEDUCED_PREFER_MEMBER_TRAIT)
struct type
{
template <typename P>
auto require(BOOST_ASIO_MOVE_ARG(P) p)
noexcept(
noexcept(
declval<typename conditional<true, T, P>::type>().require(
BOOST_ASIO_MOVE_CAST(P)(p))
)
)
-> decltype(
declval<typename conditional<true, T, P>::type>().require(
BOOST_ASIO_MOVE_CAST(P)(p))
);
template <typename P>
auto prefer(BOOST_ASIO_MOVE_ARG(P) p)
noexcept(
noexcept(
declval<typename conditional<true, T, P>::type>().prefer(
BOOST_ASIO_MOVE_CAST(P)(p))
)
)
-> decltype(
declval<typename conditional<true, T, P>::type>().prefer(
BOOST_ASIO_MOVE_CAST(P)(p))
);
};
#else // defined(BOOST_ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT)
// && defined(BOOST_ASIO_HAS_DEDUCED_PREFER_MEMBER_TRAIT)
typedef T type;
#endif // defined(BOOST_ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT)
// && defined(BOOST_ASIO_HAS_DEDUCED_PREFER_MEMBER_TRAIT)
};
template <typename T, typename Property>
BOOST_ASIO_NODISCARD BOOST_ASIO_CONSTEXPR typename enable_if<
call_traits<impl, T, void(Property)>::overload == identity,
typename call_traits<impl, T, void(Property)>::result_type
>::type
operator()(
BOOST_ASIO_MOVE_ARG(T) t,
BOOST_ASIO_MOVE_ARG(Property)) const
BOOST_ASIO_NOEXCEPT_IF((
call_traits<impl, T, void(Property)>::is_noexcept))
{
return BOOST_ASIO_MOVE_CAST(T)(t);
}
template <typename T, typename Property>
BOOST_ASIO_NODISCARD BOOST_ASIO_CONSTEXPR typename enable_if<
call_traits<impl, T, void(Property)>::overload == call_require_member,
typename call_traits<impl, T, void(Property)>::result_type
>::type
operator()(
BOOST_ASIO_MOVE_ARG(T) t,
BOOST_ASIO_MOVE_ARG(Property) p) const
BOOST_ASIO_NOEXCEPT_IF((
call_traits<impl, T, void(Property)>::is_noexcept))
{
return BOOST_ASIO_MOVE_CAST(T)(t).require(
BOOST_ASIO_MOVE_CAST(Property)(p));
}
template <typename T, typename Property>
BOOST_ASIO_NODISCARD BOOST_ASIO_CONSTEXPR typename enable_if<
call_traits<impl, T, void(Property)>::overload == call_require_free,
typename call_traits<impl, T, void(Property)>::result_type
>::type
operator()(
BOOST_ASIO_MOVE_ARG(T) t,
BOOST_ASIO_MOVE_ARG(Property) p) const
BOOST_ASIO_NOEXCEPT_IF((
call_traits<impl, T, void(Property)>::is_noexcept))
{
return require(
BOOST_ASIO_MOVE_CAST(T)(t),
BOOST_ASIO_MOVE_CAST(Property)(p));
}
template <typename T, typename Property>
BOOST_ASIO_NODISCARD BOOST_ASIO_CONSTEXPR typename enable_if<
call_traits<impl, T, void(Property)>::overload == call_prefer_member,
typename call_traits<impl, T, void(Property)>::result_type
>::type
operator()(
BOOST_ASIO_MOVE_ARG(T) t,
BOOST_ASIO_MOVE_ARG(Property) p) const
BOOST_ASIO_NOEXCEPT_IF((
call_traits<impl, T, void(Property)>::is_noexcept))
{
return BOOST_ASIO_MOVE_CAST(T)(t).prefer(
BOOST_ASIO_MOVE_CAST(Property)(p));
}
template <typename T, typename Property>
BOOST_ASIO_NODISCARD BOOST_ASIO_CONSTEXPR typename enable_if<
call_traits<impl, T, void(Property)>::overload == call_prefer_free,
typename call_traits<impl, T, void(Property)>::result_type
>::type
operator()(
BOOST_ASIO_MOVE_ARG(T) t,
BOOST_ASIO_MOVE_ARG(Property) p) const
BOOST_ASIO_NOEXCEPT_IF((
call_traits<impl, T, void(Property)>::is_noexcept))
{
return prefer(
BOOST_ASIO_MOVE_CAST(T)(t),
BOOST_ASIO_MOVE_CAST(Property)(p));
}
template <typename T, typename P0, typename P1>
BOOST_ASIO_NODISCARD BOOST_ASIO_CONSTEXPR typename enable_if<
call_traits<impl, T, void(P0, P1)>::overload == two_props,
typename call_traits<impl, T, void(P0, P1)>::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<impl, T, void(P0, P1)>::is_noexcept))
{
return (*this)(
(*this)(
BOOST_ASIO_MOVE_CAST(T)(t),
BOOST_ASIO_MOVE_CAST(P0)(p0)),
BOOST_ASIO_MOVE_CAST(P1)(p1));
}
template <typename T, typename P0, typename P1,
typename BOOST_ASIO_ELLIPSIS PN>
BOOST_ASIO_NODISCARD BOOST_ASIO_CONSTEXPR typename enable_if<
call_traits<impl, T,
void(P0, P1, PN BOOST_ASIO_ELLIPSIS)>::overload == n_props,
typename call_traits<impl, T,
void(P0, P1, PN BOOST_ASIO_ELLIPSIS)>::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<impl, T, void(P0, P1, PN BOOST_ASIO_ELLIPSIS)>::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 <typename T = impl>
struct static_instance
{
static const T instance;
};
template <typename T>
const T static_instance<T>::instance = {};
} // namespace boost_asio_prefer_fn
namespace boost {
namespace asio {
namespace {
static BOOST_ASIO_CONSTEXPR const boost_asio_prefer_fn::impl&
prefer = boost_asio_prefer_fn::static_instance<>::instance;
} // namespace
typedef boost_asio_prefer_fn::impl prefer_t;
#if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
template <typename T, typename... Properties>
struct can_prefer :
integral_constant<bool,
boost_asio_prefer_fn::call_traits<
prefer_t, T, void(Properties...)>::overload
!= boost_asio_prefer_fn::ill_formed>
{
};
#else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
template <typename T, typename P0 = void,
typename P1 = void, typename P2 = void>
struct can_prefer :
integral_constant<bool,
boost_asio_prefer_fn::call_traits<
prefer_t, T, void(P0, P1, P2)>::overload
!= boost_asio_prefer_fn::ill_formed>
{
};
template <typename T, typename P0, typename P1>
struct can_prefer<T, P0, P1> :
integral_constant<bool,
boost_asio_prefer_fn::call_traits<
prefer_t, T, void(P0, P1)>::overload
!= boost_asio_prefer_fn::ill_formed>
{
};
template <typename T, typename P0>
struct can_prefer<T, P0> :
integral_constant<bool,
boost_asio_prefer_fn::call_traits<
prefer_t, T, void(P0)>::overload
!= boost_asio_prefer_fn::ill_formed>
{
};
template <typename T>
struct can_prefer<T> :
false_type
{
};
#endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
#if defined(BOOST_ASIO_HAS_VARIABLE_TEMPLATES)
template <typename T, typename BOOST_ASIO_ELLIPSIS Properties>
constexpr bool can_prefer_v
= can_prefer<T, Properties BOOST_ASIO_ELLIPSIS>::value;
#endif // defined(BOOST_ASIO_HAS_VARIABLE_TEMPLATES)
#if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
template <typename T, typename... Properties>
struct is_nothrow_prefer :
integral_constant<bool,
boost_asio_prefer_fn::call_traits<
prefer_t, T, void(Properties...)>::is_noexcept>
{
};
#else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
template <typename T, typename P0 = void,
typename P1 = void, typename P2 = void>
struct is_nothrow_prefer :
integral_constant<bool,
boost_asio_prefer_fn::call_traits<
prefer_t, T, void(P0, P1, P2)>::is_noexcept>
{
};
template <typename T, typename P0, typename P1>
struct is_nothrow_prefer<T, P0, P1> :
integral_constant<bool,
boost_asio_prefer_fn::call_traits<
prefer_t, T, void(P0, P1)>::is_noexcept>
{
};
template <typename T, typename P0>
struct is_nothrow_prefer<T, P0> :
integral_constant<bool,
boost_asio_prefer_fn::call_traits<
prefer_t, T, void(P0)>::is_noexcept>
{
};
template <typename T>
struct is_nothrow_prefer<T> :
false_type
{
};
#endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
#if defined(BOOST_ASIO_HAS_VARIABLE_TEMPLATES)
template <typename T, typename BOOST_ASIO_ELLIPSIS Properties>
constexpr bool is_nothrow_prefer_v
= is_nothrow_prefer<T, Properties BOOST_ASIO_ELLIPSIS>::value;
#endif // defined(BOOST_ASIO_HAS_VARIABLE_TEMPLATES)
#if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
template <typename T, typename... Properties>
struct prefer_result
{
typedef typename boost_asio_prefer_fn::call_traits<
prefer_t, T, void(Properties...)>::result_type type;
};
#else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
template <typename T, typename P0 = void,
typename P1 = void, typename P2 = void>
struct prefer_result
{
typedef typename boost_asio_prefer_fn::call_traits<
prefer_t, T, void(P0, P1, P2)>::result_type type;
};
template <typename T, typename P0, typename P1>
struct prefer_result<T, P0, P1>
{
typedef typename boost_asio_prefer_fn::call_traits<
prefer_t, T, void(P0, P1)>::result_type type;
};
template <typename T, typename P0>
struct prefer_result<T, P0>
{
typedef typename boost_asio_prefer_fn::call_traits<
prefer_t, T, void(P0)>::result_type type;
};
template <typename T>
struct prefer_result<T>
{
};
#endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
} // namespace asio
} // namespace boost
#endif // defined(GENERATING_DOCUMENTATION)
#include <boost/asio/detail/pop_options.hpp>
#endif // BOOST_ASIO_PREFER_HPP
Reference in a new issue Copy permalink