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