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
