static T* call(lua_State* L, const constructor<BOOST_PP_ENUM_PARAMS(LUABIND_MAX_ARITY,A)>*, const Policies*) { // L is used, but the metrowerks compiler warns about this before expanding the macros L = L; BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_DECL, _) return new T(BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_PARAM, _)); }
overload_rep(R(*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), A)), Policies*) : m_const(false/*is_indirect_const<T>::value*/) { m_params_.reserve(BOOST_PP_ITERATION()); BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_PARAM, _) BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_POLICY_DECL, 1) m_arity = 0 BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_ARITY, 0); }
overload_rep(R(T::*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), A)) const, Policies*) : m_const(true) { m_params_.reserve(BOOST_PP_ITERATION()); BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_PARAM, _) BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_POLICY_DECL, 2) m_arity = 1 BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_ARITY, 0); }
overload_rep(R(T::*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), A)), Policies*) : m_pointer_offset(0) , m_num_args(BOOST_PP_ITERATION()) , m_const(false) { BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_PARAM, _) BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_POLICY_DECL, _) m_arity = 0 BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_ARITY, 0); }
JAVABIND_DETAIL_WRAPPER_NATIVE_return_type JAVABIND_DETAIL_WRAPPER_NATIVE_function_name (JNIEnv* env, jobject self_internal, jlong peer BOOST_PP_ENUM_TRAILING_BINARY_PARAMS(BOOST_PP_ITERATION(), A, a)) { assert(peer != 0); peer_info<T>* info = reinterpret_cast<peer_info<T>*>(peer); F const* f = static_cast<F const*>(info->bootstrap_info->vtable[index]); return JAVABIND_DETAIL_WRAPPER_NATIVE_unwrap(JAVABIND_DETAIL_WRAPPER_NATIVE_call() ( JAVABIND_DETAIL_WRAPPER_NATIVE_complementary_args(BOOST_PP_ITERATION()) BOOST_PP_REPEAT(BOOST_PP_ITERATION() , JAVABIND_DETAIL_WRAPPER_NATIVE_wrap_argument, 0) )) ; }
static void action_port (Port port, Context context, Descriptor descriptor , Document document BOOST_PP_ENUM_TRAILING_BINARY_PARAMS (BOOST_PP_ITERATION (), A, a)) { AbortContextTraits::abort_port(port, context, descriptor, document BOOST_PP_ENUM_TRAILING_PARAMS (BOOST_PP_ITERATION (), a)); }
result_type operator()(jvb::environment e BOOST_PP_ENUM_TRAILING_BINARY_PARAMS(BOOST_PP_ITERATION(), A, a)) const { e.raw()->CallStaticVoidMethod(cls, id BOOST_PP_REPEAT(BOOST_PP_ITERATION() , JVB_TRAILING_UNWRAP, a)); error::throw_exception(e); }
void pause (Media m, Descriptor d, Document document BOOST_PP_ENUM_TRAILING_BINARY_PARAMS (BOOST_PP_ITERATION (), A, a) ) { media::pause<pause_action_traits>(m, d, document BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(), a)); }
void operator()(jvb::environment e, jvb::Object obj BOOST_PP_ENUM_TRAILING_BINARY_PARAMS(BOOST_PP_ITERATION(), A, a)) const { assert(obj.raw() != 0); BOOST_MPL_ASSERT((boost::mpl::bool_<(sizeof(void*) <= sizeof(::jlong))>)); // typename Allocator::template rebind<T>::other allocator; std::cout << "constructor wrapper" << std::endl; // void* p = allocator.allocate(1, 0); // T* object = new (p) T; binding::virtual_table<N>const* vtable; ::jclass c = obj.class_(e).raw(); { const char* d = "J"; assert(c != 0); jfieldID fid = e.raw()->GetStaticFieldID (c, javabind_vtable_field_name, d); assert(fid != 0); jlong rl = e.raw()->GetStaticLongField(c, fid); void* p = 0; std::memcpy(&p, &rl, sizeof(void*)); vtable = static_cast<binding::virtual_table<N>*>(p); } void* fp = vtable->methods[I].function_object.get(); assert(fp != 0); boost::function<Result(jvb::environment BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(), A))>* f = static_cast<boost::function<Result(jvb::environment BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(), A))>*>(fp); std::auto_ptr<binding::peer_info<T, N> > peer_info(new binding::peer_info<T, N> (*vtable, (*f)(e BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(), a)) )); { ::jlong rl = 0; void* p = peer_info.release(); std::memcpy(&rl, &p, sizeof(void*)); const char* d = "J"; assert(c != 0); jfieldID fid = e.raw()->GetFieldID (c, binding::javabind_peer_info_field_name, d); assert(fid != 0); e.raw()->SetLongField(obj.raw(), fid, rl); } }
result_type operator()(environment e BOOST_PP_ENUM_TRAILING_BINARY_PARAMS(BOOST_PP_ITERATION(), A, a)) const { jobject r = e.raw()->CallObjectMethod(obj, id BOOST_PP_REPEAT(BOOST_PP_ITERATION() , JVB_TRAILING_UNWRAP, a)); if(r == 0) error::throw_exception(e); return result_type(static_cast<jstring>(static_cast<void*>(r))); }
result_type operator()(environment e BOOST_PP_ENUM_TRAILING_BINARY_PARAMS(BOOST_PP_ITERATION(), A, a)) const { jlong r = e.raw()->CallLongMethod(obj, id BOOST_PP_REPEAT(BOOST_PP_ITERATION() , JVB_TRAILING_UNWRAP, a)); error::throw_exception(e); return r; }
inline void get_member_signature_impl(T(*f)(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), A)), lua_State* L, string_class& s) { s += "("; #if BOOST_PP_ITERATION() > 0 s += name_of_type(LUABIND_DECORATE_TYPE(A0), L, 0L); BOOST_PP_REPEAT(BOOST_PP_DEC(BOOST_PP_ITERATION()), LUABIND_ADD_LUA_TYPE_NAME, _) #endif s += ")"; }
void stop (Media m, Descriptor descriptor, Document document BOOST_PP_ENUM_TRAILING_BINARY_PARAMS (BOOST_PP_ITERATION (), A, a) ) { media::stop<stop_action_traits> (m, descriptor, document BOOST_PP_ENUM_TRAILING_PARAMS (BOOST_PP_ITERATION (), a)); }
inline void get_free_function_signature_impl(T(*f)(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), A)), lua_State* L, std::string& s) { (void)f; s += "("; #if BOOST_PP_ITERATION() > 0 s += name_of_type(LUABIND_DECORATE_TYPE(A0), L, 0L); BOOST_PP_REPEAT(BOOST_PP_DEC(BOOST_PP_ITERATION()), LUABIND_ADD_LUA_TYPE_NAME, _) #endif s += ")"; }
void resume (Context context, Descriptor descriptor, Document document BOOST_PP_ENUM_TRAILING_BINARY_PARAMS (BOOST_PP_ITERATION (), A, a)) { typedef typename boost::unwrap_reference<Context>::type context_type; typedef typename boost::unwrap_reference<Document>::type document_type; GNTL_CONCEPT_ASSERT ((concept::structure::Context<context_type>)); GNTL_CONCEPT_ASSERT ((concept::structure::Document<document_type>)); algorithm::structure::context::resume<resume_action_traits> (context, descriptor, document BOOST_PP_ENUM_TRAILING_PARAMS (BOOST_PP_ITERATION (), a)); }
void pause (Port port, Context context, Document document BOOST_PP_ENUM_TRAILING_BINARY_PARAMS (BOOST_PP_ITERATION (), A, a)) { typedef typename boost::unwrap_reference<Port>::type port_type; typedef typename boost::unwrap_reference<Context>::type context_type; typedef typename boost::unwrap_reference<Document>::type document_type; GNTL_CONCEPT_ASSERT ((concept::parser::Port<port_type>)); GNTL_CONCEPT_ASSERT ((concept::structure::Context<context_type>)); GNTL_CONCEPT_ASSERT ((concept::structure::Document<document_type>)); algorithm::structure::port::pause<pause_action_traits> (port, context, document BOOST_PP_ENUM_TRAILING_PARAMS (BOOST_PP_ITERATION (), a)); }
struct BOOST_PP_CAT(funop, BOOST_PP_ITERATION()) { typedef proto::expr< tag::function , BOOST_PP_CAT(list, BOOST_PP_INC(BOOST_PP_ITERATION()))< Expr & BOOST_PP_ENUM_TRAILING(BOOST_PP_ITERATION(), M0, ~) > , BOOST_PP_INC(BOOST_PP_ITERATION()) > type; static type const call( Expr &e BOOST_PP_ENUM_TRAILING_BINARY_PARAMS(BOOST_PP_ITERATION(), A, &a) ) { type that = { e BOOST_PP_ENUM_TRAILING(BOOST_PP_ITERATION(), M1, ~) }; return that; } };
static void define( char const* name , StubsT const& , keyword_range const& kw , CallPolicies const& policies , NameSpaceT& name_space , char const* doc) { detail::name_space_def( name_space , name , &StubsT::BOOST_PP_CAT(func_, BOOST_PP_ITERATION()) , kw , policies , doc , &name_space); }
typename boost::mpl::if_<boost::is_void<Ret> , luabind::detail::proxy_functor_void_caller<boost::tuples::tuple<BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_TUPLE_PARAMS, _)> > , luabind::detail::proxy_functor_caller<Ret, boost::tuples::tuple<BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_TUPLE_PARAMS, _)> > >::type operator()(BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_OPERATOR_PARAMS, _)) const { typedef boost::tuples::tuple<BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_TUPLE_PARAMS, _)> tuple_t; #if BOOST_PP_ITERATION() == 0 tuple_t args; #else tuple_t args(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), &a)); #endif typedef typename boost::mpl::if_<boost::is_void<Ret> , luabind::detail::proxy_functor_void_caller<boost::tuples::tuple<BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_TUPLE_PARAMS, _)> > , luabind::detail::proxy_functor_caller<Ret, boost::tuples::tuple<BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_TUPLE_PARAMS, _)> > >::type proxy_type; return proxy_type(const_cast<luabind::functor<Ret>*>(this), args); }
result_type operator()(environment e BOOST_PP_ENUM_TRAILING_BINARY_PARAMS(BOOST_PP_ITERATION(), A, a)) const { typedef mpl::vector<BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), A)> param_types; typedef typename mpl::transform <param_types , mpl::if_ <boost::is_same<mpl::_1, const char*> , jvb::string , mpl::_1> >::type correct_param_types; typedef typename boost::function_types::function_type <typename mpl::push_front<correct_param_types, result_type>::type>::type sig_type; Class cls(e, R::name()); assert(cls.raw() != 0); constructors<sig_type> m(e, cls); assert(m.raw() != 0); detail::new_object_functor<result_type> c; return c(e, cls, m.raw() BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(), a)); }
struct BOOST_PP_CAT(funop, BOOST_PP_ITERATION()) { typedef typename proto::base_expr< Domain , tag::function , BOOST_PP_CAT(list, BOOST_PP_INC(BOOST_PP_ITERATION()))< Expr & BOOST_PP_ENUM_TRAILING(BOOST_PP_ITERATION(), BOOST_PROTO_AS_CHILD_TYPE, ~) > >::type type; BOOST_FORCEINLINE static type const call( Expr &e BOOST_PP_ENUM_TRAILING_BINARY_PARAMS(BOOST_PP_ITERATION(), A, &a) ) { type that = { e BOOST_PP_ENUM_TRAILING(BOOST_PP_ITERATION(), BOOST_PROTO_AS_CHILD, ~) }; return that; } };
BOOST_FORCEINLINE format_named_scope_actor< fallback_to_none, typename boost::log::aux::deduce_char_type< typename parameter::binding< typename boost::log::aux::make_arg_list< BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), ArgT) >::type, keywords::tag::format, void >::type >::type > format_named_scope(attribute_name const& name, BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_ITERATION(), ArgT, const& arg)) { typedef typename boost::log::aux::deduce_char_type< typename parameter::binding< typename boost::log::aux::make_arg_list< BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), ArgT) >::type, keywords::tag::format, void >::type >::type char_type; return aux::format_named_scope< char_type, phoenix::actor >(name, fallback_to_none(), (BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), arg))); }
BOOST_FORCEINLINE format_named_scope_actor< FallbackPolicyT, typename boost::log::aux::deduce_char_type< typename parameter::binding< typename boost::log::aux::make_arg_list< BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), ArgT) >::type, keywords::tag::format, void >::type >::type, ActorT > format_named_scope(attribute_actor< T, FallbackPolicyT, TagT, ActorT > const& placeholder, BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_ITERATION(), ArgT, const& arg)) { BOOST_STATIC_ASSERT_MSG((is_same< T, attributes::named_scope::value_type >::value),\ "Boost.Log: Named scope formatter only accepts attribute values of type attributes::named_scope::value_type."); typedef typename boost::log::aux::deduce_char_type< typename parameter::binding< typename boost::log::aux::make_arg_list< BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), ArgT) >::type, keywords::tag::format, void >::type >::type char_type; return aux::format_named_scope< char_type, ActorT >(placeholder.get_name(), placeholder.get_fallback_policy(), (BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), arg))); }
BOOST_FORCEINLINE format_named_scope_actor< fallback_to_none, typename boost::log::aux::deduce_char_type< typename parameter::binding< typename boost::log::aux::make_arg_list< BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), ArgT) >::type, keywords::tag::format, void >::type >::type, ActorT > format_named_scope(attribute_keyword< DescriptorT, ActorT > const& keyword, BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_ITERATION(), ArgT, const& arg)) { BOOST_STATIC_ASSERT_MSG((is_same< typename DescriptorT::value_type, attributes::named_scope::value_type >::value),\ "Boost.Log: Named scope formatter only accepts attribute values of type attributes::named_scope::value_type."); typedef typename boost::log::aux::deduce_char_type< typename parameter::binding< typename boost::log::aux::make_arg_list< BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), ArgT) >::type, keywords::tag::format, void >::type >::type char_type; return aux::format_named_scope< char_type, ActorT >(keyword.get_name(), fallback_to_none(), (BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), arg))); }
/// \c expr\<\> type represents a terminal expression; /// the parameter to the \c proto::term\<\> template /// represents the terminal's value type. /// /// \c Arity is an integral constant representing the number of child /// nodes this node contains. If \c Arity is 0, then this /// node is a terminal. /// /// \c proto::basic_expr\<\> is a valid Fusion random-access sequence, where /// the elements of the sequence are the child expressions. #ifdef BOOST_PROTO_DEFINE_TERMINAL template<typename Tag, typename Arg0> struct basic_expr<Tag, term<Arg0>, 0> #else template<typename Tag BOOST_PP_ENUM_TRAILING_PARAMS(ARG_COUNT, typename Arg)> struct basic_expr<Tag, BOOST_PP_CAT(list, BOOST_PP_ITERATION())<BOOST_PP_ENUM_PARAMS(ARG_COUNT, Arg)>, BOOST_PP_ITERATION() > #endif { typedef Tag proto_tag; static const long proto_arity_c = BOOST_PP_ITERATION(); typedef mpl::long_<BOOST_PP_ITERATION() > proto_arity; typedef basic_expr proto_base_expr; #ifdef BOOST_PROTO_DEFINE_TERMINAL typedef term<Arg0> proto_args; #else typedef BOOST_PP_CAT(list, BOOST_PP_ITERATION())<BOOST_PP_ENUM_PARAMS(ARG_COUNT, Arg)> proto_args; #endif typedef basic_expr proto_grammar; typedef basic_default_domain proto_domain; typedef default_generator proto_generator; typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag;
#elif BOOST_PP_ITERATION_FLAGS() == 1 #define LUABIND_TUPLE_PARAMS(z, n, data) const A##n * #define LUABIND_OPERATOR_PARAMS(z, n, data) const A##n & a##n template<class R BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), class A)> typename boost::mpl::if_<boost::is_void<R> , luabind::detail::proxy_member_void_caller<boost::tuples::tuple<BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_TUPLE_PARAMS, _)> > , luabind::detail::proxy_member_caller<R, boost::tuples::tuple<BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_TUPLE_PARAMS, _)> > >::type call(char const* name BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_OPERATOR_PARAMS, _), detail::type<R>* = 0) const { typedef boost::tuples::tuple<BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_TUPLE_PARAMS, _)> tuple_t; #if BOOST_PP_ITERATION() == 0 tuple_t args; #else tuple_t args(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), &a)); #endif typedef typename boost::mpl::if_<boost::is_void<R> , luabind::detail::proxy_member_void_caller<boost::tuples::tuple<BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_TUPLE_PARAMS, _)> > , luabind::detail::proxy_member_caller<R, boost::tuples::tuple<BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_TUPLE_PARAMS, _)> > >::type proxy_type; // this will be cleaned up by the proxy object // once the call has been made // TODO: what happens if this virtual function is // dispatched from a lua thread where the state // pointer is different? // get the function lua_State* L = m_self.state();
#include BOOST_PP_ITERATE() } #endif #elif BOOST_PP_ITERATION_FLAGS() == 1 #define MONOBIND_TYPE( z, n, _ ) typename convert_param< A ## n >::base #define MONOBIND_PARAMS( z, n, _ ) typename convert_param< A ## n >::base a ## n #define MONOBIND_CONVERTER( z, n, _ ) convert_param< A ## n >::convert( a ## n ) #if BOOST_PP_ITERATION() > 0 template < BOOST_PP_ENUM_PARAMS( BOOST_PP_ITERATION(), class A ) > #endif static typename convert_result< R >::converted call_function( R(*f)( BOOST_PP_ENUM_PARAMS( BOOST_PP_ITERATION(), A ) ) BOOST_PP_COMMA_IF( BOOST_PP_ITERATION() ) BOOST_PP_ENUM( BOOST_PP_ITERATION(), MONOBIND_PARAMS, nil ) ) { return convert_result< R >::convert( f( BOOST_PP_ENUM( BOOST_PP_ITERATION(), MONOBIND_CONVERTER, nil ) ) ); } #undef MONOBIND_PARAMS #undef MONOBIND_CONVERTER #undef MONOBIND_TYPE #elif BOOST_PP_ITERATION_FLAGS() == 2 #define MONOBIND_TYPE( z, n, _ ) typename convert_param< A ## n >::base #define MONOBIND_PARAMS( z, n, _ ) typename convert_param< A ## n >::base a ## n #define MONOBIND_CONVERTER( z, n, _ ) convert_param< A ## n >::convert( a ## n ) #if BOOST_PP_ITERATION() > 0
// #define JVB_DETAIL_NATIVE_FUNCTIONS_return_type void // #else // #define JVB_DETAIL_NATIVE_FUNCTIONS_return_template_param typename R, // #define JVB_DETAIL_NATIVE_FUNCTIONS_return_type R // #endif #define JVB_DETAIL_NATIVE_FUNCTIONS_ARGS_LIST(Z, N, DATA) \ BOOST_PP_COMMA() typename ::jvb::type_mapping<typename mpl::at_c<ParamSeq, N>::type>::java_type BOOST_PP_CAT(a, N) #define JVB_DETAIL_NATIVE_FUNCTIONS_wrap_argument(Z, N, DATA) \ BOOST_PP_COMMA() wrap_argument<typename mpl::at_c<ParamSeq, N>::type>(BOOST_PP_CAT(a, N), env) template <typename F, typename ParamSeq, typename R> struct native_function<F, ParamSeq, R, true, BOOST_PP_ITERATION()> { static void call(JNIEnv* env, jobject self_internal BOOST_PP_REPEAT(BOOST_PP_ITERATION(), JVB_DETAIL_NATIVE_FUNCTIONS_ARGS_LIST, ~)) { F()(environment(env), jvb::Object(self_internal) BOOST_PP_REPEAT(BOOST_PP_ITERATION() , JVB_DETAIL_NATIVE_FUNCTIONS_wrap_argument, BOOST_PP_ITERATION())); } }; #undef JVB_DETAIL_NATIVE_FUNCTIONS_wrap_argument #undef JVB_DETAIL_NATIVE_FUNCTIONS_seq_elem #undef JVB_DETAIL_NATIVE_FUNCTIONS_return_template_param #undef JVB_DETAIL_NATIVE_FUNCTIONS_return_type } } #endif
BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_PARAM, _) BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_POLICY_DECL, _) m_arity = 0 BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_ARITY, 0); } // non-member functions template<class R, class T BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), class A), class Policies> overload_rep(R(*)(T* BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), A)), Policies*) : m_pointer_offset(0) , m_num_args(BOOST_PP_ITERATION()) , m_const(false) { BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_PARAM, _) BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_POLICY_DECL, _) m_arity = 0 BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_ARITY, 0); } template<class R, class T BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), class A), class Policies> overload_rep(R(*)(const T* BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), A)), Policies*) : m_pointer_offset(0) , m_num_args(BOOST_PP_ITERATION()) , m_const(true) { BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_PARAM, _) BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_POLICY_DECL, _) m_arity = 0 BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_ARITY, 0); } template<class R, class T BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), class A), class Policies> overload_rep(R(*)(T& BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), A)), Policies*)
BOOST_PP_REPEAT(BOOST_PP_ITERATION() , JAVABIND_DETAIL_WRAPPER_NATIVE_wrap_argument, 0) )) ; } #undef JAVABIND_DETAIL_WRAPPER_NATIVE_wrap_argument #define JAVABIND_DETAIL_WRAPPER_NATIVE_seq_elem(z, n, data) \ , typename type_mapping<typename boost::mpl::at_c<S, n+1>::type>::java_type template <JAVABIND_DETAIL_WRAPPER_NATIVE_return_template_param typename S> struct wrapper_native_cast<JAVABIND_DETAIL_WRAPPER_NATIVE_return_type , S, JAVABIND_DETAIL_WRAPPER_NATIVE_is_member_function , JAVABIND_DETAIL_WRAPPER_NATIVE_env_first_param , JAVABIND_DETAIL_WRAPPER_NATIVE_is_static, typename boost::enable_if_c <boost::mpl::size<S>::type::value-1 == BOOST_PP_ITERATION(), void>::type > { typedef detail::wrapper_result_type<JAVABIND_DETAIL_WRAPPER_NATIVE_return_type, S , JAVABIND_DETAIL_WRAPPER_NATIVE_is_static> wrapper_result_type; typedef typename wrapper_result_type::type result_type; typedef typename wrapper_result_type::call_result_type call_result_type; template <std::size_t index, typename T, typename F> static result_type call() { return static_cast<result_type>(& JAVABIND_DETAIL_WRAPPER_NATIVE_function_name <index, T #ifndef JAVABIND_DETAIL_WRAPPER_NATIVE_void_return , call_result_type