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