luabind/detail/call.hpp

   1 // Copyright (c) 2003 Daniel Wallin and Arvid Norberg
   2
   3 // Permission is hereby granted, free of charge, to any person obtaining a
   4 // copy of this software and associated documentation files (the "Software"),
   5 // to deal in the Software without restriction, including without limitation
   6 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
   7 // and/or sell copies of the Software, and to permit persons to whom the
   8 // Software is furnished to do so, subject to the following conditions:
   9
  10 // The above copyright notice and this permission notice shall be included
  11 // in all copies or substantial portions of the Software.
  12
  13 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
  14 // ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
  15 // TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
  16 // PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
  17 // SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
  18 // ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  19 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  20 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
  21 // OR OTHER DEALINGS IN THE SOFTWARE.
  22
  23
  24 #if !BOOST_PP_IS_ITERATING
  25
  26 #ifndef LUABIND_CALL_HPP_INCLUDED
  27 #define LUABIND_CALL_HPP_INCLUDED
  28
  29 #include <boost/config.hpp>
  30 #include <boost/preprocessor/repeat.hpp>
  31 #include <boost/preprocessor/iteration/iterate.hpp>
  32 #include <boost/preprocessor/repetition/enum.hpp>
  33 #include <boost/preprocessor/repetition/enum_params.hpp>
  34 #include <boost/preprocessor/repetition/enum_trailing.hpp>
  35 #include <boost/preprocessor/repetition/repeat.hpp>
  36 #include <boost/preprocessor/punctuation/comma_if.hpp>
  37 #include <boost/preprocessor/cat.hpp>
  38 #include <boost/mpl/bool.hpp>
  39
  40 #include <luabind/config.hpp>
  41 #include <luabind/detail/policy.hpp>
  42 #include <luabind/yield_policy.hpp>
  43
  44 /*
  45 #define LUABIND_DECL(z, n, text) typedef typename detail::get_policy<n+1,Policies>::type BOOST_PP_CAT(a##n,_policy); \
  46                 typedef typename BOOST_PP_CAT(a##n,_policy)::head BOOST_PP_CAT(a##n,_converter_intermediate); \
  47                 typedef typename BOOST_PP_CAT(a##n,_converter_intermediate)::template generate_converter<A##n, lua_to_cpp>::type BOOST_PP_CAT(p##n,_conv);
  48 #define LUABIND_PARAMS(z,n,text) BOOST_PP_CAT(p##n,_conv)::apply(L, LUABIND_DECORATE_TYPE(A##n), n + 2)
  49 */
  50
  51 #define LUABIND_DECL(z, n, text) typedef typename find_conversion_policy<n + 1, Policies>::type BOOST_PP_CAT(converter_policy,n); \
  52                 typename BOOST_PP_CAT(converter_policy,n)::template generate_converter<A##n, lua_to_cpp>::type BOOST_PP_CAT(c,n);
  53 //typedef typename BOOST_PP_CAT(converter_policy,n)::template generate_converter<A##n, lua_to_cpp>::type BOOST_PP_CAT(converter,n);
  54 //#define LUABIND_PARAMS(z,n,text) BOOST_PP_CAT(converter,n)::apply(L, LUABIND_DECORATE_TYPE(A##n), n + 2)
  55 #define LUABIND_ADD_INDEX(z,n,text) + BOOST_PP_CAT(converter_policy,n)::has_arg
  56 #define LUABIND_INDEX_MAP(z,n,text) 2 BOOST_PP_REPEAT(n, LUABIND_ADD_INDEX, _)
  57 #define LUABIND_PARAMS(z,n,text) BOOST_PP_CAT(c,n).apply(L, LUABIND_DECORATE_TYPE(A##n), LUABIND_INDEX_MAP(_,n,_))
  58 #define LUABIND_POSTCALL(z,n,text) BOOST_PP_CAT(c,n).converter_postcall(L, LUABIND_DECORATE_TYPE(A##n), LUABIND_INDEX_MAP(_,n,_));
  59
  60 namespace luabind { namespace detail
  61 {
  62         template<class Policies>
  63         struct maybe_yield
  64         {
  65                 static inline int apply(lua_State* L, int nret)
  66                 {
  67                         return ret(L, nret, boost::mpl::bool_<has_yield<Policies>::value>());
  68                 }
  69
  70                 static inline int ret(lua_State* L, int nret, boost::mpl::bool_<true>)
  71                 {
  72                         return lua_yield(L, nret);
  73                 }
  74
  75                 static inline int ret(lua_State*, int nret, boost::mpl::bool_<false>)
  76                 {
  77                         return nret;
  78                 }
  79         };
  80
  81         template<class T>
  82         struct returns
  83         {
  84                 #define BOOST_PP_ITERATION_PARAMS_1 (4, (0, LUABIND_MAX_ARITY, <luabind/detail/call.hpp>, 1))
  85                 #include BOOST_PP_ITERATE()
  86         };
  87
  88         template<>
  89         struct returns<void>
  90         {
  91                 #define BOOST_PP_ITERATION_PARAMS_1 (4, (0, LUABIND_MAX_ARITY, <luabind/detail/call.hpp>, 2))
  92                 #include BOOST_PP_ITERATE()
  93         };
  94
  95         #define BOOST_PP_ITERATION_PARAMS_1 (4, (0, LUABIND_MAX_ARITY, <luabind/detail/call.hpp>, 3))
  96         #include BOOST_PP_ITERATE()
  97 }}
  98
  99 #undef LUABIND_DECL
 100 #undef LUABIND_PARAMS
 101 #undef LUABIND_POSTCALL
 102 #undef LUABIND_ADD_INDEX
 103 #undef LUABIND_INDEX_MAP
 104
 105 #endif // LUABIND_CALL_HPP_INCLUDED
 106
 107 #elif BOOST_PP_ITERATION_FLAGS() == 1
 108
 109         template<class C, class Policies BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), class A)>
 110         static int call(T(C::*f)(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), A)), C* obj, lua_State* L, const Policies*)
 111         {
 112                 int nargs = lua_gettop(L);
 113
 114                 typedef typename find_conversion_policy<0, Policies>::type converter_policy_ret;
 115                 typename converter_policy_ret::template generate_converter<T, cpp_to_lua>::type converter_ret;
 116
 117                 BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_DECL, _)
 118
 119                 converter_ret.apply(L, (obj->*f)
 120                 (
 121                         BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_PARAMS, _)
 122                 ));
 123
 124                 BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_POSTCALL, _)
 125
 126                 int nret = lua_gettop(L) - nargs;
 127
 128                 const int indices[] =
 129                 {
 130                         1               /* self */,
 131                         nargs + nret /* result */
 132                         BOOST_PP_ENUM_TRAILING(BOOST_PP_ITERATION(), LUABIND_INDEX_MAP, _)
 133                 };
 134
 135                 policy_list_postcall<Policies>::apply(L, indices);
 136
 137                 return maybe_yield<Policies>::apply(L, nret);
 138 //              return nret;
 139         }
 140
 141         template<class C, class Policies BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), class A)>
 142         static int call(T(C::*f)(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), A)) const, C* obj, lua_State* L, const Policies*)
 143         {
 144                 int nargs = lua_gettop(L);
 145                 typedef typename find_conversion_policy<0, Policies>::type converter_policy_ret;
 146                 typename converter_policy_ret::template generate_converter<T, cpp_to_lua>::type converter_ret;
 147                 BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_DECL, _)
 148                 converter_ret.apply(L, (obj->*f)
 149                 (
 150                         BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_PARAMS, _)
 151                 ));
 152
 153                 BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_POSTCALL, _)
 154                 int nret = lua_gettop(L) - nargs;
 155
 156                 const int indices[] =
 157                 {
 158                         1               /* self */,
 159                         nargs + nret /* result */
 160                         BOOST_PP_ENUM_TRAILING(BOOST_PP_ITERATION(), LUABIND_INDEX_MAP, _)
 161                 };
 162
 163                 policy_list_postcall<Policies>::apply(L, indices);
 164
 165         //      return nret;
 166                 return maybe_yield<Policies>::apply(L, nret);
 167         }
 168
 169         template<class C, class Policies BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), class A)>
 170         static int call(T(*f)(C* obj BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), A)), C* obj, lua_State* L, const Policies*)
 171         {
 172                 int nargs = lua_gettop(L);
 173                 typedef typename find_conversion_policy<0, Policies>::type converter_policy_ret;
 174                 typename converter_policy_ret::template generate_converter<T, cpp_to_lua>::type converter_ret;
 175                 BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_DECL, _)
 176                 converter_ret.apply(L, f
 177                 (
 178                         obj BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_PARAMS, _)
 179                 ));
 180                 BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_POSTCALL, _)
 181
 182                 int nret = lua_gettop(L) - nargs;
 183
 184                 const int indices[] =
 185                 {
 186                         1               /* self */,
 187                         nargs + nret /* result */
 188                         BOOST_PP_ENUM_TRAILING(BOOST_PP_ITERATION(), LUABIND_INDEX_MAP, _)
 189                 };
 190
 191                 policy_list_postcall<Policies>::apply(L, indices);
 192
 193         //      return nret;
 194                 return maybe_yield<Policies>::apply(L, nret);
 195         }
 196
 197         template<class C, class Policies BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), class A)>
 198         static int call(T(*f)(const C* obj BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), A)), C* obj, lua_State* L, const Policies*)
 199         {
 200                 int nargs = lua_gettop(L);
 201                 typedef typename find_conversion_policy<0, Policies>::type converter_policy_ret;
 202                 typename converter_policy_ret::template generate_converter<T, cpp_to_lua>::type converter_ret;
 203                 BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_DECL, _)
 204                 converter_ret.apply(L, f
 205                 (
 206                         *obj BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_PARAMS, _)
 207                 ));
 208                 BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_POSTCALL, _)
 209
 210                 int nret = lua_gettop(L) - nargs;
 211
 212                 const int indices[] =
 213                 {
 214                         1               /* self */,
 215                         nargs + nret /* result */
 216                         BOOST_PP_ENUM_TRAILING(BOOST_PP_ITERATION(), LUABIND_INDEX_MAP, _)
 217                 };
 218
 219                 policy_list_postcall<Policies>::apply(L, indices);
 220
 221         //      return nret;
 222                 return maybe_yield<Policies>::apply(L, nret);
 223         }
 224
 225
 226         template<class C, class Policies BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), class A)>
 227         static int call(T(*f)(C& obj BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), A)), C* obj, lua_State* L, const Policies*)
 228         {
 229                 int nargs = lua_gettop(L);
 230                 typedef typename find_conversion_policy<0, Policies>::type converter_policy_ret;
 231                 typename converter_policy_ret::template generate_converter<T, cpp_to_lua>::type converter_ret;
 232                 BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_DECL, _)
 233                 converter_ret.apply(L, f
 234                 (
 235                         *obj BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_PARAMS, _)
 236                 ));
 237                 BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_POSTCALL, _)
 238
 239                 int nret = lua_gettop(L) - nargs;
 240
 241                 const int indices[] =
 242                 {
 243                         1               /* self */,
 244                         nargs + nret /* result */
 245                         BOOST_PP_ENUM_TRAILING(BOOST_PP_ITERATION(), LUABIND_INDEX_MAP, _)
 246                 };
 247
 248                 policy_list_postcall<Policies>::apply(L, indices);
 249
 250         //      return nret;
 251                 return maybe_yield<Policies>::apply(L, nret);
 252         }
 253
 254         template<class C, class Policies BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), class A)>
 255         static int call(T(*f)(const C& obj BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), A)), C* obj, lua_State* L, const Policies*)
 256         {
 257                 int nargs = lua_gettop(L);
 258                 typedef typename find_conversion_policy<0, Policies>::type converter_policy_ret;
 259                 typename converter_policy_ret::template generate_converter<T, cpp_to_lua>::type converter_ret;
 260                 BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_DECL, _)
 261                 converter_ret.apply(L, f
 262                 (
 263                         *obj BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_PARAMS, _)
 264                 ));
 265                 BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_POSTCALL, _)
 266
 267                 int nret = lua_gettop(L) - nargs;
 268
 269                 const int indices[] =
 270                 {
 271                         1               /* self */,
 272                         nargs + nret /* result */
 273                         BOOST_PP_ENUM_TRAILING(BOOST_PP_ITERATION(), LUABIND_INDEX_MAP, _)
 274                 };
 275
 276                 policy_list_postcall<Policies>::apply(L, indices);
 277
 278         //      return nret;
 279                 return maybe_yield<Policies>::apply(L, nret);
 280         }
 281
 282 #elif BOOST_PP_ITERATION_FLAGS() == 2
 283
 284         template<class C, class Policies BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), class A)>
 285         static int call(void(C::*f)(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), A)), C* obj, lua_State* L, const Policies*)
 286         {
 287                 int nargs = lua_gettop(L);
 288                 L = L; // L is used, but metrowerks compiler seem to warn about it before expanding the macros
 289                 BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_DECL, _)
 290                 (obj->*f)
 291                 (
 292                         BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_PARAMS, _)
 293                 );
 294                 BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_POSTCALL, _)
 295
 296                 int nret = lua_gettop(L) - nargs;
 297
 298                 const int indices[] =
 299                 {
 300                         1               /* self */,
 301                         nargs + nret /* result */
 302                         BOOST_PP_ENUM_TRAILING(BOOST_PP_ITERATION(), LUABIND_INDEX_MAP, _)
 303                 };
 304
 305                 policy_list_postcall<Policies>::apply(L, indices);
 306
 307         //      return nret;
 308                 return maybe_yield<Policies>::apply(L, nret);
 309         }
 310
 311         template<class C, class Policies BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), class A)>
 312         static int call(void(C::*f)(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), A)) const, C* obj, lua_State* L, const Policies*)
 313         {
 314                 int nargs = lua_gettop(L);
 315                 L = L; // L is used, but metrowerks compiler seem to warn about it before expanding the macros
 316                 BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_DECL, _)
 317                 (obj->*f)
 318                 (
 319                         BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_PARAMS, _)
 320                 );
 321                 BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_POSTCALL, _)
 322
 323                 int nret = lua_gettop(L) - nargs;
 324
 325                 const int indices[] =
 326                 {
 327                         1               /* self */,
 328                         nargs + nret /* result */
 329                         BOOST_PP_ENUM_TRAILING(BOOST_PP_ITERATION(), LUABIND_INDEX_MAP, _)
 330                 };
 331
 332                 policy_list_postcall<Policies>::apply(L, indices);
 333
 334         //      return nret;
 335                 return maybe_yield<Policies>::apply(L, nret);
 336         }
 337
 338         template<class C, class Policies BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), class A)>
 339         static int call(void(*f)(C* obj BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), A)), C* obj, lua_State* L, const Policies*)
 340         {
 341                 int nargs = lua_gettop(L);
 342                 L = L; // L is used, but metrowerks compiler seem to warn about it before expanding the macros
 343                 BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_DECL, _)
 344                 f(
 345                         obj BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_PARAMS, _)
 346                 );
 347
 348                 int nret = lua_gettop(L) - nargs;
 349
 350                 const int indices[] =
 351                 {
 352                         1               /* self */,
 353                         nargs + nret /* result */
 354                         BOOST_PP_ENUM_TRAILING(BOOST_PP_ITERATION(), LUABIND_INDEX_MAP, _)
 355                 };
 356                 BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_POSTCALL, _)
 357
 358                 policy_list_postcall<Policies>::apply(L, indices);
 359
 360         //      return nret;
 361                 return maybe_yield<Policies>::apply(L, nret);
 362         }
 363
 364         template<class C, class Policies BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), class A)>
 365         static int call(void(*f)(C& obj BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), A)), C* obj, lua_State* L, const Policies*)
 366         {
 367                 int nargs = lua_gettop(L);
 368                 L = L; // L is used, but metrowerks compiler seem to warn about it before expanding the macros
 369                 BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_DECL, _)
 370                 f(
 371                         *obj BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_PARAMS, _)
 372                 );
 373
 374                 int nret = lua_gettop(L) - nargs;
 375
 376                 const int indices[] =
 377                 {
 378                         1               /* self */,
 379                         nargs + nret /* result */
 380                         BOOST_PP_ENUM_TRAILING(BOOST_PP_ITERATION(), LUABIND_INDEX_MAP, _)
 381                 };
 382                 BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_POSTCALL, _)
 383
 384                 policy_list_postcall<Policies>::apply(L, indices);
 385
 386         //      return nret;
 387                 return maybe_yield<Policies>::apply(L, nret);
 388         }
 389
 390         template<class C, class Policies BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), class A)>
 391         static int call(void(*f)(const C& obj BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), A)), C* obj, lua_State* L, const Policies*)
 392         {
 393                 int nargs = lua_gettop(L);
 394                 L = L; // L is used, but metrowerks compiler seem to warn about it before expanding the macros
 395                 BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_DECL, _)
 396                 f(
 397                         *obj BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_PARAMS, _)
 398                 );
 399                 BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_POSTCALL, _)
 400
 401                 int nret = lua_gettop(L) - nargs;
 402
 403                 const int indices[] =
 404                 {
 405                         1               /* self */,
 406                         nargs + nret /* result */
 407                         BOOST_PP_ENUM_TRAILING(BOOST_PP_ITERATION(), LUABIND_INDEX_MAP, _)
 408                 };
 409
 410                 policy_list_postcall<Policies>::apply(L, indices);
 411
 412         //      return nret;
 413                 return maybe_yield<Policies>::apply(L, nret);
 414         }
 415
 416 #elif BOOST_PP_ITERATION_FLAGS() == 3
 417
 418         template<class T, class Policies, class R BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), class A)>
 419         int call(R(*f)(T& BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), A)), T* obj, lua_State* L, const Policies* policies)
 420         {
 421                 return returns<R>::call(f, obj, L, policies);
 422         }
 423
 424         template<class T, class Policies, class R BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), class A)>
 425         int call(R(*f)(const T& BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), A)), T* obj, lua_State* L, const Policies* policies)
 426         {
 427                 return returns<R>::call(f, obj, L, policies);
 428         }
 429
 430         template<class T, class Policies, class R BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), class A)>
 431         int call(R(*f)(T* BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), A)), T* obj, lua_State* L, const Policies* policies)
 432         {
 433                 return returns<R>::call(f, obj, L, policies);
 434         }
 435
 436         template<class T, class Policies, class R BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), class A)>
 437         int call(R(*f)(const T* BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), A)), T* obj, lua_State* L, const Policies* policies)
 438         {
 439                 return returns<R>::call(f, obj, L, policies);
 440         }
 441
 442         template<class T, class Policies, class R BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), class A)>
 443         int call(R(T::*f)(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), A)), T* obj, lua_State* L, const Policies* policies)
 444         {
 445                 return returns<R>::call(f, obj, L, policies);
 446         }
 447
 448         template<class T, class Policies, class R BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), class A)>
 449         int call(R(T::*f)(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), A)) const, T* obj, lua_State* L, const Policies* policies)
 450         {
 451                 return returns<R>::call(f, obj, L, policies);
 452         }
 453
 454 #endif