// Copyright 2008 Eric Niebler. 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)
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
#pragma wave option(preserve: 1)
#endif
#define BOOST_PP_ITERATION_PARAMS_1 \
(3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/transform/detail/construct_funop.hpp>))
#include BOOST_PP_ITERATE()
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
#pragma wave option(output: null)
#endif
#else
#define N BOOST_PP_ITERATION()
template<BOOST_PP_ENUM_PARAMS(N, typename A)>
BOOST_FORCEINLINE
Type operator ()(BOOST_PP_ENUM_BINARY_PARAMS(N, A, &a)) const
{
return Type(BOOST_PP_ENUM_PARAMS(N, a));
}
#undef N
#endif
// 0ary
template<class Little>
static Result call(Little& little)
{
return little.template call<Result>();
}
// 1ary-
#define BOOST_PP_ITERATION_PARAMS_1 (3, (1, PSTADE_EGG_MAX_LINEAR_ARITY, <pstade/egg/detail/call_little.hpp>))
#include BOOST_PP_ITERATE()
};
} } } // namespace pstade::egg::detail
#endif
#else
#define n BOOST_PP_ITERATION()
template<class Little, BOOST_PP_ENUM_PARAMS(n, class A)>
static Result call(Little& little, BOOST_PP_ENUM_BINARY_PARAMS(n, A, & a))
{
return little.template call<Result>(BOOST_PP_ENUM_PARAMS(n, a));
}
#undef n
#endif
# undef BOOST_TMP_MACRO
};
template< typename Pointer, class Allocator, factory_alloc_propagation AP >
class factory<Pointer&, Allocator, AP>;
// forbidden, would create a dangling reference
}
# define BOOST_FUNCTIONAL_FACTORY_HPP_INCLUDED
# else // defined(BOOST_PP_IS_ITERATING)
# define N BOOST_PP_ITERATION()
# if !defined(BOOST_TMP_MACRO)
# if N > 0
template< BOOST_PP_ENUM_PARAMS(N, typename T) >
# endif
inline result_type operator()(BOOST_PP_ENUM_BINARY_PARAMS(N,T,& a)) const
{
return result_type( new value_type(BOOST_PP_ENUM_PARAMS(N,a)) );
}
# else // defined(BOOST_TMP_MACRO)
# if N > 0
template< BOOST_PP_ENUM_PARAMS(N, typename T) >
# endif
inline result_type operator()(BOOST_PP_ENUM_BINARY_PARAMS(N,T,& a)) const
{
value_type* memory = this->get_allocator().allocate(1);
try
{
return make_pointer(
new(memory) value_type(BOOST_PP_ENUM_PARAMS(N,a)),
boost::non_type<factory_alloc_propagation,AP>() );
: mpl::true_
{};
template<typename R BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)>
struct is_applyable<R(*)(BOOST_PP_ENUM_PARAMS(N, A))>
: mpl::true_
{};
template<typename T, typename A>
struct construct_<proto::expr<T, A, N>, true>
{
typedef proto::expr<T, A, N> result_type;
template<BOOST_PP_ENUM_PARAMS(BOOST_PP_MAX(N, 1), typename A)>
BOOST_FORCEINLINE
result_type operator ()(BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_MAX(N, 1), A, &a)) const
{
return result_type::make(BOOST_PP_ENUM_PARAMS(BOOST_PP_MAX(N, 1), a));
}
};
template<typename T, typename A>
struct construct_<proto::basic_expr<T, A, N>, true>
{
typedef proto::basic_expr<T, A, N> result_type;
template<BOOST_PP_ENUM_PARAMS(BOOST_PP_MAX(N, 1), typename A)>
BOOST_FORCEINLINE
result_type operator ()(BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_MAX(N, 1), A, &a)) const
{
return result_type::make(BOOST_PP_ENUM_PARAMS(BOOST_PP_MAX(N, 1), a));
template <typename F, BOOST_PP_ENUM_PARAMS(N, typename A)>
struct result<F(BOOST_PP_ENUM_PARAMS(N, A))>
: eval_result<
eval_type
, basic_environment<
BOOST_PP_ENUM_BINARY_PARAMS(
N
, typename remove_reference<A
, >::type BOOST_PP_INTERCEPT
)
>
>
{};
template <BOOST_PP_ENUM_PARAMS(N, typename T)>
typename result<
actor(BOOST_PP_ENUM_BINARY_PARAMS(N, T, & BOOST_PP_INTERCEPT))
>::type
operator()(BOOST_PP_ENUM_BINARY_PARAMS(N, T, & _)) const
{
return eval_type::eval(
basic_environment<BOOST_PP_ENUM_PARAMS(N, T)>(
BOOST_PP_ENUM_PARAMS(N, _))
);
}
#undef N
#endif // defined(BOOST_PP_IS_ITERATING)
}}
#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
#pragma wave option(output: null)
#endif
#endif // BOOST_FUSION_DONT_USE_PREPROCESSED_FILES
#endif
#else // defined(BOOST_PP_IS_ITERATING)
///////////////////////////////////////////////////////////////////////////////
//
// Preprocessor vertical repetition code
//
///////////////////////////////////////////////////////////////////////////////
#define N BOOST_PP_ITERATION()
template <BOOST_PP_ENUM_PARAMS(N, typename T)>
inline tuple<BOOST_PP_ENUM(N, BOOST_FUSION_REF, _)>
tie(BOOST_PP_ENUM_BINARY_PARAMS(N, T, & _))
{
return tuple<BOOST_PP_ENUM(N, BOOST_FUSION_REF, _)>(
BOOST_PP_ENUM_PARAMS(N, _));
}
#undef N
#endif // defined(BOOST_PP_IS_ITERATING)
#else // BOOST_PP_IS_ITERATING
#define N BOOST_PP_ITERATION()
#define HPX_ENUM_MUTEX_ARG(z, n, data) \
BOOST_PP_COMMA_IF(BOOST_PP_DEC(n)) BOOST_PP_CAT(m, n) \
/**/
#define HPX_ENUM_FROM_1_TO_N() \
BOOST_PP_REPEAT_FROM_TO(1, N, HPX_ENUM_MUTEX_ARG, _) \
/**/
namespace boost { namespace detail
{
template <BOOST_PP_ENUM_PARAMS(N, typename MutexType)>
inline unsigned lock_helper(BOOST_PP_ENUM_BINARY_PARAMS(N, MutexType, & m))
{
boost::unique_lock<MutexType0> l0(m0);
if (unsigned const failed_lock = try_lock_internal(HPX_ENUM_FROM_1_TO_N()))
{
return failed_lock;
}
l0.release();
return 0;
}
template <BOOST_PP_ENUM_PARAMS(N, typename MutexType)>
inline unsigned try_lock_internal(BOOST_PP_ENUM_BINARY_PARAMS(N, MutexType, & m))
{
boost::unique_lock<MutexType0> l0(m0, boost::try_to_lock);
if (!l0)
#define PHOENIX_CORE_DETAIL_BASIC_ENVIRONMENT_HPP
#include <boost/preprocessor/iterate.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
#define BOOST_PP_ITERATION_PARAMS_1 \
(3, (3, PHOENIX_ARG_LIMIT, \
"boost/spirit/home/phoenix/core/detail/basic_environment.hpp"))
#include BOOST_PP_ITERATE()
#endif
///////////////////////////////////////////////////////////////////////////////
//
// Preprocessor vertical repetition code
//
///////////////////////////////////////////////////////////////////////////////
#else // defined(BOOST_PP_IS_ITERATING)
#define N BOOST_PP_ITERATION()
template <BOOST_PP_ENUM_PARAMS(N, typename U)>
basic_environment(BOOST_PP_ENUM_BINARY_PARAMS(N, U, & _))
: args_(BOOST_PP_ENUM_PARAMS(N, _)) {}
#undef N
#endif // defined(BOOST_PP_IS_ITERATING)
#ifndef BOOST_PP_IS_ITERATING
#ifndef PHOENIX_CORE_DETAIL_COMPOSITE_HPP
#define PHOENIX_CORE_DETAIL_COMPOSITE_HPP
#include <boost/preprocessor/iterate.hpp>
#define BOOST_PP_ITERATION_PARAMS_1 \
(3, (3, PHOENIX_COMPOSITE_LIMIT, \
"boost/spirit/home/phoenix/core/detail/composite.hpp"))
#include BOOST_PP_ITERATE()
#endif
///////////////////////////////////////////////////////////////////////////////
//
// Preprocessor vertical repetition code
//
///////////////////////////////////////////////////////////////////////////////
#else // defined(BOOST_PP_IS_ITERATING)
#define N BOOST_PP_ITERATION()
template <BOOST_PP_ENUM_PARAMS(N, typename U)>
composite(BOOST_PP_ENUM_BINARY_PARAMS(N, U, & _))
: base_type(BOOST_PP_ENUM_PARAMS(N, _)) {}
#undef N
#endif // defined(BOOST_PP_IS_ITERATING)
};
BOOST_EGG_CONST((T_call_little), call_little) = {};
} } // namespace boost::egg
#endif
#else
#define n BOOST_PP_ITERATION()
template<class Little, BOOST_PP_ENUM_PARAMS(n, class A)>
typename apply_little<Little, BOOST_PP_ENUM_PARAMS(n, A)>::type
operator()(Little &little, BOOST_PP_ENUM_BINARY_PARAMS(n, A, &a)) const
{
#if defined(BOOST_EGG_NEEDS_OVERLOADED)
return details::overloaded_call_little<Little,
typename apply_little<Little, BOOST_PP_ENUM_PARAMS(n, A)>::type
>::call(little, BOOST_PP_ENUM_PARAMS(n, a));
#else
return little.template call<
typename apply_little<Little, BOOST_PP_ENUM_PARAMS(n, A)>::type
>(BOOST_PP_ENUM_PARAMS(n, a));
#endif
}
#undef n
#endif
#else
template<class Me, BOOST_EGG_APPLY_DECL_PARAMS(BOOST_PP_INC(n), A)>
struct BOOST_EGG_APPLY_DECL;
// as pipe
typedef X_pipable<Bytag, Bytag> S_pipable;
template<class Me, BOOST_PP_ENUM_PARAMS(n, class A)>
struct apply<Me, BOOST_PP_ENUM_PARAMS(n, A)> :
result_of_<
typename result_of_<S_pipable(Base const &)>::type(BOOST_EGG_PP_ENUM_PARAMS_WITH(n, A, &))
>
{ };
template<class Re, BOOST_PP_ENUM_PARAMS(n, class A)>
Re call(BOOST_PP_ENUM_BINARY_PARAMS(n, A, &a)) const
{
return S_pipable()(m_base)(BOOST_PP_ENUM_PARAMS(n, a));
}
// as function call
template<class Me, class O, BOOST_PP_ENUM_PARAMS(n, class A)>
struct apply<Me, O, BOOST_PP_ENUM_PARAMS(n, A)> :
result_of_<Base const(typename result_of_forward<Bytag, O>::type, BOOST_EGG_FORWARDING_META_ARGS(n, A, Bytag const))>
{ };
template<class Re, class O, BOOST_PP_ENUM_PARAMS(n, class A)>
Re call(O &o, BOOST_PP_ENUM_BINARY_PARAMS(n, A, &a)) const
{
return m_base(egg::forward<Bytag>(o), BOOST_EGG_FORWARDING_ARGS(n, a, Bytag const));
}
