luabind/detail/policy.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 #ifndef LUABIND_POLICY_HPP_INCLUDED
  25 #define LUABIND_POLICY_HPP_INCLUDED
  26
  27 #include <luabind/config.hpp>
  28
  29 #include <typeinfo>
  30 #include <string>
  31 #include <memory>
  32
  33 #include <boost/type_traits/is_enum.hpp>
  34 #include <boost/type_traits/is_array.hpp>
  35 #include <boost/mpl/bool.hpp>
  36 #include <boost/mpl/integral_c.hpp>
  37 #include <boost/mpl/equal_to.hpp>
  38 #include <boost/mpl/eval_if.hpp>
  39 #include <boost/mpl/or.hpp>
  40 #include <boost/type_traits/add_reference.hpp>
  41 #include <boost/type_traits/remove_reference.hpp>
  42 #include <boost/type_traits/is_pointer.hpp>
  43 #include <boost/type_traits/is_base_and_derived.hpp>
  44 #include <boost/bind/arg.hpp>
  45 #include <boost/limits.hpp>
  46 #include <boost/tuple/tuple.hpp>
  47 #include <boost/version.hpp>
  48
  49 #include <luabind/detail/class_registry.hpp>
  50 #include <luabind/detail/primitives.hpp>
  51 #include <luabind/detail/object_rep.hpp>
  52 #include <luabind/detail/typetraits.hpp>
  53 #include <luabind/detail/class_cache.hpp>
  54 #include <luabind/detail/debug.hpp>
  55 #include <luabind/detail/class_rep.hpp>
  56 #include <luabind/detail/has_get_pointer.hpp>
  57 #include <luabind/detail/make_instance.hpp>
  58
  59 #include <boost/type_traits/add_reference.hpp>
  60
  61 #include <luabind/detail/decorate_type.hpp>
  62 #include <luabind/weak_ref.hpp>
  63 #include <luabind/back_reference_fwd.hpp>
  64
  65 #include <luabind/value_wrapper.hpp>
  66 #include <luabind/from_stack.hpp>
  67 #include <luabind/typeid.hpp>
  68
  69 namespace luabind
  70 {
  71         namespace detail
  72         {
  73                 struct conversion_policy_base {};
  74         }
  75
  76         template<int N, bool HasArg = true>
  77         struct conversion_policy : detail::conversion_policy_base
  78         {
  79                 BOOST_STATIC_CONSTANT(int, index = N);
  80                 BOOST_STATIC_CONSTANT(bool, has_arg = HasArg);
  81         };
  82
  83         class index_map
  84         {
  85         public:
  86                 index_map(const int* m): m_map(m) {}
  87
  88                 int operator[](int index) const
  89                 {
  90                         return m_map[index];
  91                 }
  92
  93         private:
  94                 const int* m_map;
  95         };
  96
  97 //       template<class T> class functor;
  98          class weak_ref;
  99 }
 100
 101 namespace luabind { namespace detail
 102 {
 103         template<class H, class T>
 104         struct policy_cons
 105         {
 106                 typedef H head;
 107                 typedef T tail;
 108
 109                 template<class U>
 110                 policy_cons<U, policy_cons<H,T> > operator,(policy_cons<U,detail::null_type>)
 111                 {
 112                         return policy_cons<U, policy_cons<H,T> >();
 113                 }
 114
 115                 template<class U>
 116                 policy_cons<U, policy_cons<H,T> > operator+(policy_cons<U,detail::null_type>)
 117                 {
 118                         return policy_cons<U, policy_cons<H,T> >();
 119                 }
 120
 121                 template<class U>
 122                 policy_cons<U, policy_cons<H,T> > operator|(policy_cons<U,detail::null_type>)
 123                 {
 124                         return policy_cons<U, policy_cons<H,T> >();
 125                 }
 126         };
 127
 128         struct indirection_layer
 129         {
 130                 template<class T>
 131                 indirection_layer(const T&);
 132         };
 133
 134         yes_t is_policy_cons_test(const null_type&);
 135         template<class H, class T>
 136         yes_t is_policy_cons_test(const policy_cons<H,T>&);
 137         no_t is_policy_cons_test(...);
 138
 139         template<class T>
 140         struct is_policy_cons
 141         {
 142                 static const T& t;
 143
 144                 BOOST_STATIC_CONSTANT(bool, value =
 145                         sizeof(is_policy_cons_test(t)) == sizeof(yes_t));
 146
 147                 typedef boost::mpl::bool_<value> type;
 148         };
 149
 150         template<bool>
 151         struct is_string_literal
 152         {
 153                 static no_t helper(indirection_layer);
 154                 static yes_t helper(const char*);
 155         };
 156
 157         template<>
 158         struct is_string_literal<false>
 159         {
 160                 static no_t helper(indirection_layer);
 161         };
 162
 163
 164     namespace mpl = boost::mpl;
 165
 166     template <class T, class Clone>
 167     void make_pointee_instance(lua_State* L, T& x, mpl::true_, Clone)
 168     {
 169         if (get_pointer(x))
 170         {
 171             make_instance(L, x);
 172         }
 173         else
 174         {
 175             lua_pushnil(L);
 176         }
 177     }
 178
 179     template <class T>
 180     void make_pointee_instance(lua_State* L, T& x, mpl::false_, mpl::true_)
 181     {
 182         std::auto_ptr<T> ptr(new T(x));
 183         make_instance(L, ptr);
 184     }
 185
 186     template <class T>
 187     void make_pointee_instance(lua_State* L, T& x, mpl::false_, mpl::false_)
 188     {
 189         make_instance(L, &x);
 190     }
 191
 192     template <class T, class Clone>
 193     void make_pointee_instance(lua_State* L, T& x, Clone)
 194     {
 195         make_pointee_instance(L, x, has_get_pointer<T>(), Clone());
 196     }
 197
 198 // ********** pointer converter ***********
 199
 200         struct pointer_converter
 201         {
 202                 typedef pointer_converter type;
 203         typedef mpl::false_ is_native;
 204
 205         pointer_converter()
 206           : result(0)
 207         {}
 208
 209         void* result;
 210
 211         int const consumed_args(...)
 212         {
 213             return 1;
 214         }
 215
 216                 template<class T>
 217                 void apply(lua_State* L, T* ptr)
 218                 {
 219                         if (ptr == 0)
 220                         {
 221                                 lua_pushnil(L);
 222                                 return;
 223                         }
 224
 225                         if (luabind::get_back_reference(L, ptr))
 226                                 return;
 227
 228             make_instance(L, ptr);
 229                 }
 230
 231                 template<class T>
 232                 T* apply(lua_State*, by_pointer<T>, int)
 233                 {
 234             return static_cast<T*>(result);
 235                 }
 236
 237                 template<class T>
 238                 int match(lua_State* L, by_pointer<T>, int index)
 239                 {
 240                         if (lua_isnil(L, index)) return 0;
 241                         object_rep* obj = get_instance(L, index);
 242                         if (obj == 0) return -1;
 243
 244             if (obj->is_const())
 245                 return -1;
 246
 247             std::pair<void*, int> s = obj->get_instance(registered_class<T>::id);
 248             result = s.first;
 249             return s.second;
 250                 }
 251
 252                 template<class T>
 253                 void converter_postcall(lua_State*, by_pointer<T>, int)
 254                 {}
 255         };
 256
 257 // ******* value converter *******
 258
 259         struct value_converter
 260         {
 261                 typedef value_converter type;
 262         typedef mpl::false_ is_native;
 263
 264         int const consumed_args(...)
 265         {
 266             return 1;
 267         }
 268
 269         value_converter()
 270           : result(0)
 271         {}
 272
 273         void* result;
 274
 275                 template<class T>
 276                 void apply(lua_State* L, T x)
 277                 {
 278                         if (luabind::get_back_reference(L, x))
 279                                 return;
 280
 281             make_pointee_instance(L, x, mpl::true_());
 282                 }
 283
 284                 template<class T>
 285                 T apply(lua_State*, by_value<T>, int)
 286                 {
 287             return *static_cast<T*>(result);
 288                 }
 289
 290                 template<class T>
 291                 int match(lua_State* L, by_value<T>, int index)
 292                 {
 293                         // special case if we get nil in, try to match the holder type
 294                         if (lua_isnil(L, index))
 295                                 return -1;
 296
 297                         object_rep* obj = get_instance(L, index);
 298                         if (obj == 0) return -1;
 299
 300             std::pair<void*, int> s = obj->get_instance(registered_class<T>::id);
 301             result = s.first;
 302             return s.second;
 303                 }
 304
 305                 template<class T>
 306                 void converter_postcall(lua_State*, T, int) {}
 307         };
 308
 309 // ******* const pointer converter *******
 310
 311     struct const_pointer_converter
 312         {
 313                 typedef const_pointer_converter type;
 314         typedef mpl::false_ is_native;
 315
 316         int const consumed_args(...)
 317         {
 318             return 1;
 319         }
 320
 321         const_pointer_converter()
 322           : result(0)
 323         {}
 324
 325         void* result;
 326
 327                 template<class T>
 328                 void apply(lua_State* L, const T* ptr)
 329                 {
 330                         if (ptr == 0)
 331                         {
 332                                 lua_pushnil(L);
 333                                 return;
 334                         }
 335
 336                         if (luabind::get_back_reference(L, ptr))
 337                                 return;
 338
 339             make_instance(L, ptr);
 340                 }
 341
 342                 template<class T>
 343                 T const* apply(lua_State*, by_const_pointer<T>, int)
 344                 {
 345                         return static_cast<T const*>(result);
 346                 }
 347
 348                 template<class T>
 349                 int match(lua_State* L, by_const_pointer<T>, int index)
 350                 {
 351                         if (lua_isnil(L, index)) return 0;
 352                         object_rep* obj = get_instance(L, index);
 353                         if (obj == 0) return -1; // if the type is not one of our own registered types, classify it as a non-match
 354             std::pair<void*, int> s = obj->get_instance(registered_class<T>::id);
 355             if (s.second >= 0 && !obj->is_const())
 356                 s.second += 10;
 357             result = s.first;
 358             return s.second;
 359                 }
 360
 361         template<class T>
 362         void converter_postcall(lua_State*, T, int) {}
 363         };
 364
 365 // ******* reference converter *******
 366
 367     struct ref_converter : pointer_converter
 368         {
 369                 typedef ref_converter type;
 370         typedef mpl::false_ is_native;
 371
 372         int const consumed_args(...)
 373         {
 374             return 1;
 375         }
 376
 377                 template<class T>
 378                 void apply(lua_State* L, T& ref)
 379                 {
 380                         if (luabind::get_back_reference(L, ref))
 381                                 return;
 382
 383             make_pointee_instance(L, ref, mpl::false_());
 384                 }
 385
 386                 template<class T>
 387                 T& apply(lua_State* L, by_reference<T>, int index)
 388                 {
 389                         assert(!lua_isnil(L, index));
 390             return *pointer_converter::apply(L, by_pointer<T>(), index);
 391                 }
 392
 393                 template<class T>
 394                 int match(lua_State* L, by_reference<T>, int index)
 395                 {
 396                         if (lua_isnil(L, index)) return -1;
 397                         return pointer_converter::match(L, by_pointer<T>(), index);
 398                 }
 399
 400                 template<class T>
 401                 void converter_postcall(lua_State*, T, int) {}
 402         };
 403
 404 // ******** const reference converter *********
 405
 406         struct const_ref_converter
 407         {
 408                 typedef const_ref_converter type;
 409         typedef mpl::false_ is_native;
 410
 411         int const consumed_args(...)
 412         {
 413             return 1;
 414         }
 415
 416         const_ref_converter()
 417           : result(0)
 418         {}
 419
 420         void* result;
 421
 422                 template<class T>
 423                 void apply(lua_State* L, T const& ref)
 424                 {
 425                         if (luabind::get_back_reference(L, ref))
 426                                 return;
 427
 428             make_pointee_instance(L, ref, mpl::false_());
 429                 }
 430
 431                 template<class T>
 432                 T const& apply(lua_State*, by_const_reference<T>, int)
 433                 {
 434                         return *static_cast<T*>(result);
 435                 }
 436
 437                 template<class T>
 438                 int match(lua_State* L, by_const_reference<T>, int index)
 439                 {
 440                         object_rep* obj = get_instance(L, index);
 441                         if (obj == 0) return -1; // if the type is not one of our own registered types, classify it as a non-match
 442
 443             std::pair<void*, int> s = obj->get_instance(registered_class<T>::id);
 444             if (s.second >= 0 && !obj->is_const())
 445                 s.second += 10;
 446             result = s.first;
 447             return s.second;
 448                 }
 449
 450                 template<class T>
 451                 void converter_postcall(lua_State*, by_const_reference<T>, int)
 452                 {
 453                 }
 454         };
 455
 456         // ****** enum converter ********
 457
 458         struct enum_converter
 459         {
 460                 typedef enum_converter type;
 461         typedef mpl::true_ is_native;
 462
 463         int const consumed_args(...)
 464         {
 465             return 1;
 466         }
 467
 468                 void apply(lua_State* L, int val)
 469                 {
 470                         lua_pushnumber(L, val);
 471                 }
 472
 473                 template<class T>
 474                 T apply(lua_State* L, by_value<T>, int index)
 475                 {
 476                         return static_cast<T>(static_cast<int>(lua_tonumber(L, index)));
 477                 }
 478
 479                 template<class T>
 480                 static int match(lua_State* L, by_value<T>, int index)
 481                 {
 482                         if (lua_isnumber(L, index)) return 0; else return -1;
 483                 }
 484
 485                 template<class T>
 486                 T apply(lua_State* L, by_const_reference<T>, int index)
 487                 {
 488                         return static_cast<T>(static_cast<int>(lua_tonumber(L, index)));
 489                 }
 490
 491                 template<class T>
 492                 static int match(lua_State* L, by_const_reference<T>, int index)
 493                 {
 494                         if (lua_isnumber(L, index)) return 0; else return -1;
 495                 }
 496
 497                 template<class T>
 498                 void converter_postcall(lua_State*, T, int) {}
 499         };
 500
 501         template <class U>
 502         struct value_wrapper_converter
 503         {
 504                 typedef value_wrapper_converter<U> type;
 505                 typedef mpl::true_ is_native;
 506
 507         int const consumed_args(...)
 508         {
 509             return 1;
 510         }
 511
 512                 template<class T>
 513                 T apply(lua_State* L, by_const_reference<T>, int index)
 514                 {
 515                         return T(from_stack(L, index));
 516                 }
 517
 518                 template<class T>
 519                 T apply(lua_State* L, by_value<T>, int index)
 520                 {
 521                         return apply(L, by_const_reference<T>(), index);
 522                 }
 523
 524                 template<class T>
 525                 static int match(lua_State* L, by_const_reference<T>, int index)
 526                 {
 527                         return value_wrapper_traits<T>::check(L, index)
 528                 ? (std::numeric_limits<int>::max)() / LUABIND_MAX_ARITY
 529                 : -1;
 530                 }
 531
 532                 template<class T>
 533                 static int match(lua_State* L, by_value<T>, int index)
 534                 {
 535                         return match(L, by_const_reference<T>(), index);
 536                 }
 537
 538                 void converter_postcall(...) {}
 539
 540                 template<class T>
 541                 void apply(lua_State* interpreter, T const& value_wrapper)
 542                 {
 543                         value_wrapper_traits<T>::unwrap(interpreter, value_wrapper);
 544                 }
 545     };
 546
 547     template <class T>
 548     struct default_converter_generator
 549       : mpl::eval_if<
 550             is_value_wrapper_arg<T>
 551           , value_wrapper_converter<T>
 552           , mpl::eval_if<
 553                 boost::is_enum<typename boost::remove_reference<T>::type>
 554               , enum_converter
 555               , mpl::eval_if<
 556                     is_nonconst_pointer<T>
 557                   , pointer_converter
 558                   , mpl::eval_if<
 559                         is_const_pointer<T>
 560                       , const_pointer_converter
 561                       , mpl::eval_if<
 562                             is_nonconst_reference<T>
 563                           , ref_converter
 564                           , mpl::eval_if<
 565                                 is_const_reference<T>
 566                               , const_ref_converter
 567                               , value_converter
 568                             >
 569                         >
 570                     >
 571                 >
 572             >
 573         >
 574     {};
 575
 576 } // namespace detail
 577
 578 // *********** default_policy *****************
 579
 580 template <class T>
 581 struct default_converter
 582   : detail::default_converter_generator<T>::type
 583 {};
 584
 585 template <class T, class Derived = default_converter<T> >
 586 struct native_converter_base
 587 {
 588     typedef boost::mpl::true_ is_native;
 589
 590     int const consumed_args(...)
 591     {
 592         return 1;
 593     }
 594
 595     template <class U>
 596     void converter_postcall(lua_State*, U const&, int)
 597     {}
 598
 599     int match(lua_State* L, detail::by_value<T>, int index)
 600     {
 601         return derived().compute_score(L, index);
 602     }
 603
 604     int match(lua_State* L, detail::by_value<T const>, int index)
 605     {
 606         return derived().compute_score(L, index);
 607     }
 608
 609     int match(lua_State* L, detail::by_const_reference<T>, int index)
 610     {
 611         return derived().compute_score(L, index);
 612     }
 613
 614     T apply(lua_State* L, detail::by_value<T>, int index)
 615     {
 616         return derived().from(L, index);
 617     }
 618
 619     T apply(lua_State* L, detail::by_value<T const>, int index)
 620     {
 621         return derived().from(L, index);
 622     }
 623
 624     T apply(lua_State* L, detail::by_const_reference<T>, int index)
 625     {
 626         return derived().from(L, index);
 627     }
 628
 629     void apply(lua_State* L, T const& value)
 630     {
 631         derived().to(L, value);
 632     }
 633
 634     Derived& derived()
 635     {
 636         return static_cast<Derived&>(*this);
 637     }
 638 };
 639
 640 template <class T>
 641 lua_Integer as_lua_integer(T v)
 642 {
 643     return static_cast<lua_Integer>(v);
 644 }
 645
 646 template <class T>
 647 lua_Number as_lua_number(T v)
 648 {
 649     return static_cast<lua_Number>(v);
 650 }
 651
 652 # define LUABIND_NUMBER_CONVERTER(type, kind) \
 653     template <> \
 654 struct default_converter<type> \
 655   : native_converter_base<type> \
 656 { \
 657     int compute_score(lua_State* L, int index) \
 658     { \
 659         return lua_type(L, index) == LUA_TNUMBER ? 0 : -1; \
 660     }; \
 661     \
 662     type from(lua_State* L, int index) \
 663     { \
 664         return static_cast<type>(BOOST_PP_CAT(lua_to, kind)(L, index)); \
 665     } \
 666     \
 667     void to(lua_State* L, type const& value) \
 668     { \
 669         BOOST_PP_CAT(lua_push, kind)(L, BOOST_PP_CAT(as_lua_, kind)(value)); \
 670     } \
 671 }; \
 672 \
 673 template <> \
 674 struct default_converter<type const> \
 675   : default_converter<type> \
 676 {}; \
 677 \
 678 template <> \
 679 struct default_converter<type const&> \
 680   : default_converter<type> \
 681 {};
 682
 683 LUABIND_NUMBER_CONVERTER(char, integer)
 684 LUABIND_NUMBER_CONVERTER(signed char, integer)
 685 LUABIND_NUMBER_CONVERTER(unsigned char, integer)
 686 LUABIND_NUMBER_CONVERTER(signed short, integer)
 687 LUABIND_NUMBER_CONVERTER(unsigned short, integer)
 688 LUABIND_NUMBER_CONVERTER(signed int, integer)
 689
 690 LUABIND_NUMBER_CONVERTER(unsigned int, number)
 691 LUABIND_NUMBER_CONVERTER(unsigned long, number)
 692
 693 LUABIND_NUMBER_CONVERTER(signed long, integer)
 694 LUABIND_NUMBER_CONVERTER(float, number)
 695 LUABIND_NUMBER_CONVERTER(double, number)
 696 LUABIND_NUMBER_CONVERTER(long double, number)
 697
 698 # undef LUABIND_NUMBER_CONVERTER
 699
 700 template <>
 701 struct default_converter<bool>
 702   : native_converter_base<bool>
 703 {
 704     static int compute_score(lua_State* L, int index)
 705     {
 706         return lua_type(L, index) == LUA_TBOOLEAN ? 0 : -1;
 707     }
 708
 709     bool from(lua_State* L, int index)
 710     {
 711         return lua_toboolean(L, index) == 1;
 712     }
 713
 714     void to(lua_State* L, bool value)
 715     {
 716         lua_pushboolean(L, value);
 717     }
 718 };
 719
 720 template <>
 721 struct default_converter<bool const>
 722   : default_converter<bool>
 723 {};
 724
 725 template <>
 726 struct default_converter<bool const&>
 727   : default_converter<bool>
 728 {};
 729
 730 template <>
 731 struct default_converter<std::string>
 732   : native_converter_base<std::string>
 733 {
 734     static int compute_score(lua_State* L, int index)
 735     {
 736         return lua_type(L, index) == LUA_TSTRING ? 0 : -1;
 737     }
 738
 739     std::string from(lua_State* L, int index)
 740     {
 741         return std::string(lua_tostring(L, index), lua_strlen(L, index));
 742     }
 743
 744     void to(lua_State* L, std::string const& value)
 745     {
 746         lua_pushlstring(L, value.data(), value.size());
 747     }
 748 };
 749
 750 template <>
 751 struct default_converter<std::string const>
 752   : default_converter<std::string>
 753 {};
 754
 755 template <>
 756 struct default_converter<std::string const&>
 757   : default_converter<std::string>
 758 {};
 759
 760 template <>
 761 struct default_converter<char const*>
 762 {
 763     typedef boost::mpl::true_ is_native;
 764
 765     int const consumed_args(...)
 766     {
 767         return 1;
 768     }
 769
 770     template <class U>
 771     static int match(lua_State* L, U, int index)
 772     {
 773         int type = lua_type(L, index);
 774         return (type == LUA_TSTRING || type == LUA_TNIL) ? 0 : -1;
 775     }
 776
 777     template <class U>
 778     char const* apply(lua_State* L, U, int index)
 779     {
 780         return lua_tostring(L, index);
 781     }
 782
 783     void apply(lua_State* L, char const* str)
 784     {
 785         lua_pushstring(L, str);
 786     }
 787
 788     template <class U>
 789     void converter_postcall(lua_State*, U, int)
 790     {}
 791 };
 792
 793 template <>
 794 struct default_converter<const char* const>
 795   : default_converter<char const*>
 796 {};
 797
 798 template <>
 799 struct default_converter<char*>
 800   : default_converter<char const*>
 801 {};
 802
 803 template <std::size_t N>
 804 struct default_converter<char const[N]>
 805   : default_converter<char const*>
 806 {};
 807
 808 template <std::size_t N>
 809 struct default_converter<char[N]>
 810   : default_converter<char const*>
 811 {};
 812
 813 template <>
 814 struct default_converter<lua_State*>
 815 {
 816     int const consumed_args(...)
 817     {
 818         return 0;
 819     }
 820
 821     template <class U>
 822     lua_State* apply(lua_State* L, U, int)
 823     {
 824         return L;
 825     }
 826
 827     template <class U>
 828     static int match(lua_State*, U, int)
 829     {
 830         return 0;
 831     }
 832
 833     template <class U>
 834     void converter_postcall(lua_State*, U, int) {}
 835 };
 836
 837 namespace detail
 838 {
 839
 840         struct default_policy : converter_policy_tag
 841         {
 842                 BOOST_STATIC_CONSTANT(bool, has_arg = true);
 843
 844                 template<class T>
 845                 static void precall(lua_State*, T, int) {}
 846
 847                 template<class T, class Direction>
 848                 struct apply
 849                 {
 850             typedef default_converter<T> type;
 851         };
 852         };
 853
 854     template<class T>
 855     struct is_primitive
 856       : default_converter<T>::is_native
 857     {};
 858
 859 // ============== new policy system =================
 860
 861         template<int, class> struct find_conversion_policy;
 862
 863         template<bool IsConverter = false>
 864         struct find_conversion_impl
 865         {
 866                 template<int N, class Policies>
 867                 struct apply
 868                 {
 869                         typedef typename find_conversion_policy<N, typename Policies::tail>::type type;
 870                 };
 871         };
 872
 873         template<>
 874         struct find_conversion_impl<true>
 875         {
 876                 template<int N, class Policies>
 877                 struct apply
 878                 {
 879                         typedef typename Policies::head head;
 880                         typedef typename Policies::tail tail;
 881
 882                         BOOST_STATIC_CONSTANT(bool, found = (N == head::index));
 883
 884                         typedef typename
 885                                 boost::mpl::if_c<found
 886                                         , head
 887                                         , typename find_conversion_policy<N, tail>::type
 888                                 >::type type;
 889                 };
 890         };
 891
 892         template<class Policies>
 893         struct find_conversion_impl2
 894         {
 895                 template<int N>
 896                 struct apply
 897                         : find_conversion_impl<
 898                                 boost::is_base_and_derived<conversion_policy_base, typename Policies::head>::value
 899                         >::template apply<N, Policies>
 900                 {
 901                 };
 902         };
 903
 904         template<>
 905         struct find_conversion_impl2<detail::null_type>
 906         {
 907                 template<int N>
 908                 struct apply
 909                 {
 910                         typedef default_policy type;
 911                 };
 912         };
 913
 914         template<int N, class Policies>
 915         struct find_conversion_policy : find_conversion_impl2<Policies>::template apply<N>
 916         {
 917         };
 918
 919         template<class List>
 920         struct policy_list_postcall
 921         {
 922                 typedef typename List::head head;
 923                 typedef typename List::tail tail;
 924
 925                 static void apply(lua_State* L, const index_map& i)
 926                 {
 927                         head::postcall(L, i);
 928                         policy_list_postcall<tail>::apply(L, i);
 929                 }
 930         };
 931
 932         template<>
 933         struct policy_list_postcall<detail::null_type>
 934         {
 935                 static void apply(lua_State*, const index_map&) {}
 936         };
 937
 938 // ==================================================
 939
 940 // ************** precall and postcall on policy_cons *********************
 941
 942
 943         template<class List>
 944         struct policy_precall
 945         {
 946                 typedef typename List::head head;
 947                 typedef typename List::tail tail;
 948
 949                 static void apply(lua_State* L, int index)
 950                 {
 951                         head::precall(L, index);
 952                         policy_precall<tail>::apply(L, index);
 953                 }
 954         };
 955
 956         template<>
 957         struct policy_precall<detail::null_type>
 958         {
 959                 static void apply(lua_State*, int) {}
 960         };
 961
 962         template<class List>
 963         struct policy_postcall
 964         {
 965                 typedef typename List::head head;
 966                 typedef typename List::tail tail;
 967
 968                 static void apply(lua_State* L, int index)
 969                 {
 970                         head::postcall(L, index);
 971                         policy_postcall<tail>::apply(L, index);
 972                 }
 973         };
 974
 975         template<>
 976         struct policy_postcall<detail::null_type>
 977         {
 978                 static void apply(lua_State*, int) {}
 979         };
 980
 981 }} // namespace luabind::detail
 982
 983
 984 namespace luabind { namespace
 985 {
 986 #if defined(__GNUC__) && ( \
 987     (BOOST_VERSION < 103500) \
 988  || (BOOST_VERSION < 103900 && (__GNUC__ * 100 + __GNUC_MINOR__ <= 400)) \
 989  || (__GNUC__ * 100 + __GNUC_MINOR__ < 400))
 990   static inline boost::arg<0> return_value()
 991   {
 992           return boost::arg<0>();
 993   }
 994
 995   static inline boost::arg<0> result()
 996   {
 997           return boost::arg<0>();
 998   }
 999 # define LUABIND_PLACEHOLDER_ARG(N) boost::arg<N>(*)()
1000 #elif defined(BOOST_MSVC) || defined(__MWERKS__) \
1001   || (BOOST_VERSION >= 103900 && defined(__GNUC__) \
1002         && (__GNUC__ * 100 + __GNUC_MINOR__ == 400))
1003   static boost::arg<0> return_value;
1004   static boost::arg<0> result;
1005 # define LUABIND_PLACEHOLDER_ARG(N) boost::arg<N>
1006 #else
1007   boost::arg<0> return_value;
1008   boost::arg<0> result;
1009 # define LUABIND_PLACEHOLDER_ARG(N) boost::arg<N>
1010 #endif
1011 }}
1012
1013 #endif // LUABIND_POLICY_HPP_INCLUDED
1014