luabind/class.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_CLASS_HPP_INCLUDED
  25 #define LUABIND_CLASS_HPP_INCLUDED
  26
  27 /*
  28         ISSUES:
  29         ------------------------------------------------------
  30
  31         * solved for member functions, not application operator *
  32         if we have a base class that defines a function a derived class must be able to
  33         override that function (not just overload). Right now we just add the other overload
  34         to the overloads list and will probably get an ambiguity. If we want to support this
  35         each method_rep must include a vector of type_info pointers for each parameter.
  36         Operators do not have this problem, since operators always have to have
  37         it's own type as one of the arguments, no ambiguity can occur. Application
  38         operator, on the other hand, would have this problem.
  39         Properties cannot be overloaded, so they should always be overridden.
  40         If this is to work for application operator, we really need to specify if an application
  41         operator is const or not.
  42
  43         If one class registers two functions with the same name and the same
  44         signature, there's currently no error. The last registered function will
  45         be the one that's used.
  46         How do we know which class registered the function? If the function was
  47         defined by the base class, it is a legal operation, to override it.
  48         we cannot look at the pointer offset, since it always will be zero for one of the bases.
  49
  50
  51
  52         TODO:
  53         ------------------------------------------------------
  54
  55         finish smart pointer support
  56                 * the adopt policy should not be able to adopt pointers to held_types. This
  57                 must be prohibited.
  58                 * name_of_type must recognize holder_types and not return "custom"
  59
  60         document custom policies, custom converters
  61
  62         store the instance object for policies.
  63
  64         support the __concat metamethod. This is a bit tricky, since it cannot be
  65         treated as a normal operator. It is a binary operator but we want to use the
  66         __tostring implementation for both arguments.
  67
  68 */
  69
  70 #include <luabind/prefix.hpp>
  71 #include <luabind/config.hpp>
  72
  73 #include <string>
  74 #include <map>
  75 #include <vector>
  76 #include <cassert>
  77
  78 #include <boost/bind.hpp>
  79 #include <boost/preprocessor/repetition/enum_params.hpp>
  80 #include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
  81 #include <boost/preprocessor/repetition/repeat.hpp>
  82 #include <boost/type_traits/is_same.hpp>
  83 #include <boost/type_traits/is_member_object_pointer.hpp>
  84 #include <boost/mpl/apply.hpp>
  85 #include <boost/mpl/lambda.hpp>
  86 #include <boost/mpl/logical.hpp>
  87 #include <boost/mpl/find_if.hpp>
  88 #include <boost/mpl/eval_if.hpp>
  89 #include <boost/mpl/logical.hpp>
  90
  91 #include <luabind/config.hpp>
  92 #include <luabind/scope.hpp>
  93 #include <luabind/back_reference.hpp>
  94 #include <luabind/function.hpp>
  95 #include <luabind/dependency_policy.hpp>
  96 #include <luabind/detail/constructor.hpp>
  97 #include <luabind/detail/call.hpp>
  98 #include <luabind/detail/deduce_signature.hpp>
  99 #include <luabind/detail/compute_score.hpp>
 100 #include <luabind/detail/primitives.hpp>
 101 #include <luabind/detail/property.hpp>
 102 #include <luabind/detail/typetraits.hpp>
 103 #include <luabind/detail/class_rep.hpp>
 104 #include <luabind/detail/call.hpp>
 105 #include <luabind/detail/object_rep.hpp>
 106 #include <luabind/detail/calc_arity.hpp>
 107 #include <luabind/detail/call_member.hpp>
 108 #include <luabind/detail/enum_maker.hpp>
 109 #include <luabind/detail/get_signature.hpp>
 110 #include <luabind/detail/implicit_cast.hpp>
 111 #include <luabind/detail/operator_id.hpp>
 112 #include <luabind/detail/pointee_typeid.hpp>
 113 #include <luabind/detail/link_compatibility.hpp>
 114 #include <luabind/detail/inheritance.hpp>
 115 #include <luabind/typeid.hpp>
 116
 117 // to remove the 'this' used in initialization list-warning
 118 #ifdef _MSC_VER
 119 #pragma warning(push)
 120 #pragma warning(disable: 4355)
 121 #endif
 122
 123 namespace boost
 124 {
 125
 126   template <class T> class shared_ptr;
 127
 128 } // namespace boost
 129
 130 namespace luabind
 131 {
 132         namespace detail
 133         {
 134                 struct unspecified {};
 135
 136                 template<class Derived> struct operator_;
 137
 138                 struct you_need_to_define_a_get_const_holder_function_for_your_smart_ptr {};
 139         }
 140
 141         template<class T, class X1 = detail::unspecified, class X2 = detail::unspecified, class X3 = detail::unspecified>
 142         struct class_;
 143
 144         // TODO: this function will only be invoked if the user hasn't defined a correct overload
 145         // maybe we should have a static assert in here?
 146         inline detail::you_need_to_define_a_get_const_holder_function_for_your_smart_ptr*
 147         get_const_holder(...)
 148         {
 149                 return 0;
 150         }
 151
 152         template <class T>
 153         boost::shared_ptr<T const>* get_const_holder(boost::shared_ptr<T>*)
 154         {
 155                 return 0;
 156         }
 157
 158     template <
 159         BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(
 160             LUABIND_MAX_BASES, class A, detail::null_type)
 161     >
 162     struct bases
 163     {};
 164
 165     typedef bases<detail::null_type> no_bases;
 166
 167         namespace detail
 168         {
 169         template <class T>
 170         struct is_bases
 171           : mpl::false_
 172         {};
 173
 174         template <BOOST_PP_ENUM_PARAMS(LUABIND_MAX_BASES, class A)>
 175         struct is_bases<bases<BOOST_PP_ENUM_PARAMS(LUABIND_MAX_BASES, A)> >
 176           : mpl::true_
 177         {};
 178
 179         template <class T, class P>
 180         struct is_unspecified
 181           : mpl::apply1<P, T>
 182         {};
 183
 184         template <class P>
 185         struct is_unspecified<unspecified, P>
 186           : mpl::true_
 187         {};
 188
 189         template <class P>
 190         struct is_unspecified_mfn
 191         {
 192             template <class T>
 193             struct apply
 194               : is_unspecified<T, P>
 195             {};
 196         };
 197
 198                 template<class Predicate>
 199                 struct get_predicate
 200                 {
 201             typedef mpl::protect<is_unspecified_mfn<Predicate> > type;
 202                 };
 203
 204         template <class Result, class Default>
 205         struct result_or_default
 206         {
 207             typedef Result type;
 208         };
 209
 210         template <class Default>
 211         struct result_or_default<unspecified, Default>
 212         {
 213             typedef Default type;
 214         };
 215
 216                 template<class Parameters, class Predicate, class DefaultValue>
 217                 struct extract_parameter
 218                 {
 219                         typedef typename get_predicate<Predicate>::type pred;
 220                         typedef typename boost::mpl::find_if<Parameters, pred>::type iterator;
 221             typedef typename result_or_default<
 222                 typename iterator::type, DefaultValue
 223             >::type type;
 224                 };
 225
 226                 // prints the types of the values on the stack, in the
 227                 // range [start_index, lua_gettop()]
 228
 229                 LUABIND_API std::string stack_content_by_name(lua_State* L, int start_index);
 230
 231                 struct LUABIND_API create_class
 232                 {
 233                         static int stage1(lua_State* L);
 234                         static int stage2(lua_State* L);
 235                 };
 236
 237         } // detail
 238
 239         namespace detail {
 240
 241                 template<class T>
 242                 struct static_scope
 243                 {
 244                         static_scope(T& self_) : self(self_)
 245                         {
 246                         }
 247
 248                         T& operator[](scope s) const
 249                         {
 250                                 self.add_inner_scope(s);
 251                                 return self;
 252                         }
 253
 254                 private:
 255                         template<class U> void operator,(U const&) const;
 256                         void operator=(static_scope const&);
 257
 258                         T& self;
 259                 };
 260
 261                 struct class_registration;
 262
 263                 struct LUABIND_API class_base : scope
 264                 {
 265                 public:
 266                         class_base(char const* name);
 267
 268                         struct base_desc
 269                         {
 270                                 type_id type;
 271                                 int ptr_offset;
 272                         };
 273
 274                         void init(
 275                 type_id const& type, class_id id
 276               , class_id wrapper_id, type_id const& wrapped_type
 277               , cast_function wrapper_cast);
 278
 279             void add_base(type_id const& base, cast_function cast);
 280
 281                         void add_member(registration* member);
 282                         void add_default_member(registration* member);
 283
 284                         const char* name() const;
 285
 286                         void add_static_constant(const char* name, int val);
 287                         void add_inner_scope(scope& s);
 288
 289             void add_cast(class_id src, class_id target, cast_function cast);
 290
 291                 private:
 292                         class_registration* m_registration;
 293                 };
 294
 295                 template <class Class, class F, class Policies>
 296                 struct memfun_registration : registration
 297                 {
 298                         memfun_registration(char const* name, F f, Policies const& policies)
 299                           : name(name)
 300                           , f(f)
 301                           , policies(policies)
 302                         {}
 303
 304                         void register_(lua_State* L) const
 305                         {
 306                                 object fn = make_function(
 307                                         L, f, deduce_signature(f, (Class*)0), policies);
 308
 309                                 add_overload(
 310                                         object(from_stack(L, -1))
 311                                   , name
 312                                   , fn
 313                                 );
 314                         }
 315
 316                         char const* name;
 317                         F f;
 318                         Policies policies;
 319                 };
 320
 321         template <class P, class T>
 322         struct default_pointer
 323         {
 324             typedef P type;
 325         };
 326
 327         template <class T>
 328         struct default_pointer<null_type, T>
 329         {
 330             typedef std::auto_ptr<T> type;
 331         };
 332
 333         template <class Class, class Pointer, class Signature, class Policies>
 334         struct constructor_registration : registration
 335         {
 336             constructor_registration(Policies const& policies)
 337               : policies(policies)
 338             {}
 339
 340             void register_(lua_State* L) const
 341             {
 342                 typedef typename default_pointer<Pointer, Class>::type pointer;
 343
 344                 object fn = make_function(
 345                     L
 346                   , construct<Class, pointer, Signature>(), Signature()
 347                   , policies
 348                 );
 349
 350                 add_overload(
 351                     object(from_stack(L, -1))
 352                   , "__init"
 353                   , fn
 354                 );
 355             }
 356
 357             Policies policies;
 358         };
 359
 360         template <class T>
 361         struct reference_result
 362           : mpl::if_<
 363                 mpl::or_<boost::is_pointer<T>, is_primitive<T> >
 364               , T
 365               , typename boost::add_reference<T>::type
 366             >
 367         {};
 368
 369         template <class T, class Policies>
 370         struct inject_dependency_policy
 371           : mpl::if_<
 372                 is_primitive<T>
 373               , Policies
 374               , policy_cons<dependency_policy<0, 1>, Policies>
 375             >
 376         {};
 377
 378         template <
 379             class Class
 380           , class Get, class GetPolicies
 381           , class Set = null_type, class SetPolicies = null_type
 382         >
 383         struct property_registration : registration
 384         {
 385             property_registration(
 386                 char const* name
 387               , Get const& get
 388               , GetPolicies const& get_policies
 389               , Set const& set = Set()
 390               , SetPolicies const& set_policies = SetPolicies()
 391             )
 392               : name(name)
 393               , get(get)
 394               , get_policies(get_policies)
 395               , set(set)
 396               , set_policies(set_policies)
 397             {}
 398
 399             void register_(lua_State* L) const
 400             {
 401                 object context(from_stack(L, -1));
 402                 register_aux(
 403                     L
 404                   , context
 405                   , make_get(L, get, boost::is_member_object_pointer<Get>())
 406                   , set
 407                 );
 408             }
 409
 410             template <class F>
 411             object make_get(lua_State* L, F const& f, mpl::false_) const
 412             {
 413                 return make_function(
 414                     L, f, deduce_signature(f, (Class*)0), get_policies);
 415             }
 416
 417             template <class T, class D>
 418             object make_get(lua_State* L, D T::* mem_ptr, mpl::true_) const
 419             {
 420                 typedef typename reference_result<D>::type result_type;
 421                 typedef typename inject_dependency_policy<
 422                     D, GetPolicies>::type policies;
 423
 424                 return make_function(
 425                     L
 426                   , access_member_ptr<T, D, result_type>(mem_ptr)
 427                   , mpl::vector2<result_type, Class const&>()
 428                   , policies()
 429                 );
 430             }
 431
 432             template <class F>
 433             object make_set(lua_State* L, F const& f, mpl::false_) const
 434             {
 435                 return make_function(
 436                     L, f, deduce_signature(f, (Class*)0), set_policies);
 437             }
 438
 439             template <class T, class D>
 440             object make_set(lua_State* L, D T::* mem_ptr, mpl::true_) const
 441             {
 442                 return make_function(
 443                     L
 444                   , access_member_ptr<T, D>(mem_ptr)
 445                   , mpl::vector3<void, Class&, D const&>()
 446                   , set_policies
 447                 );
 448             }
 449
 450             template <class S>
 451             void register_aux(
 452                 lua_State* L, object const& context
 453               , object const& get_, S const&) const
 454             {
 455                 context[name] = property(
 456                     get_
 457                   , make_set(L, set, boost::is_member_object_pointer<Set>())
 458                 );
 459             }
 460
 461             void register_aux(
 462                 lua_State* L, object const& context
 463               , object const& get_, null_type) const
 464             {
 465                 context[name] = property(get_);
 466             }
 467
 468             char const* name;
 469             Get get;
 470             GetPolicies get_policies;
 471             Set set;
 472             SetPolicies set_policies;
 473         };
 474
 475         } // namespace detail
 476
 477         // registers a class in the lua environment
 478         template<class T, class X1, class X2, class X3>
 479         struct class_: detail::class_base
 480         {
 481                 typedef class_<T, X1, X2, X3> self_t;
 482
 483         private:
 484
 485                 template<class A, class B, class C, class D>
 486                 class_(const class_<A,B,C,D>&);
 487
 488         public:
 489
 490         typedef boost::mpl::vector4<X1, X2, X3, detail::unspecified> parameters_type;
 491
 492                 // WrappedType MUST inherit from T
 493                 typedef typename detail::extract_parameter<
 494                     parameters_type
 495                   , boost::is_base_and_derived<T, boost::mpl::_>
 496                   , detail::null_type
 497                 >::type WrappedType;
 498
 499                 typedef typename detail::extract_parameter<
 500                     parameters_type
 501                   , boost::mpl::not_<
 502                         boost::mpl::or_<
 503                     detail::is_bases<boost::mpl::_>
 504                   , boost::is_base_and_derived<boost::mpl::_, T>
 505                   , boost::is_base_and_derived<T, boost::mpl::_>
 506                                 >
 507                         >
 508                   , detail::null_type
 509                 >::type HeldType;
 510
 511         template <class Src, class Target>
 512         void add_downcast(Src*, Target*, boost::mpl::true_)
 513         {
 514             add_cast(
 515                 detail::registered_class<Src>::id
 516               , detail::registered_class<Target>::id
 517               , detail::dynamic_cast_<Src, Target>::execute
 518             );
 519         }
 520
 521         template <class Src, class Target>
 522         void add_downcast(Src*, Target*, boost::mpl::false_)
 523         {}
 524
 525                 // this function generates conversion information
 526                 // in the given class_rep structure. It will be able
 527                 // to implicitly cast to the given template type
 528                 template<class To>
 529                 void gen_base_info(detail::type_<To>)
 530                 {
 531             add_base(typeid(To), detail::static_cast_<T, To>::execute);
 532             add_cast(
 533                 detail::registered_class<T>::id
 534               , detail::registered_class<To>::id
 535               , detail::static_cast_<T, To>::execute
 536             );
 537
 538             add_downcast((To*)0, (T*)0, boost::is_polymorphic<To>());
 539                 }
 540
 541                 void gen_base_info(detail::type_<detail::null_type>)
 542                 {}
 543
 544 #define LUABIND_GEN_BASE_INFO(z, n, text) gen_base_info(detail::type_<B##n>());
 545
 546                 template<BOOST_PP_ENUM_PARAMS(LUABIND_MAX_BASES, class B)>
 547                 void generate_baseclass_list(detail::type_<bases<BOOST_PP_ENUM_PARAMS(LUABIND_MAX_BASES, B)> >)
 548                 {
 549                         BOOST_PP_REPEAT(LUABIND_MAX_BASES, LUABIND_GEN_BASE_INFO, _)
 550                 }
 551
 552 #undef LUABIND_GEN_BASE_INFO
 553
 554                 class_(const char* name): class_base(name), scope(*this)
 555                 {
 556 #ifndef NDEBUG
 557                         detail::check_link_compatibility();
 558 #endif
 559                         init();
 560                 }
 561
 562                 template<class F>
 563                 class_& def(const char* name, F f)
 564                 {
 565                         return this->virtual_def(
 566                                 name, f, detail::null_type()
 567                           , detail::null_type(), boost::mpl::true_());
 568                 }
 569
 570                 // virtual functions
 571                 template<class F, class DefaultOrPolicies>
 572                 class_& def(char const* name, F fn, DefaultOrPolicies default_or_policies)
 573                 {
 574                         return this->virtual_def(
 575                                 name, fn, default_or_policies, detail::null_type()
 576                           , LUABIND_MSVC_TYPENAME detail::is_policy_cons<DefaultOrPolicies>::type());
 577                 }
 578
 579                 template<class F, class Default, class Policies>
 580                 class_& def(char const* name, F fn
 581                         , Default default_, Policies const& policies)
 582                 {
 583                         return this->virtual_def(
 584                                 name, fn, default_
 585                           , policies, boost::mpl::false_());
 586                 }
 587
 588                 template<BOOST_PP_ENUM_PARAMS(LUABIND_MAX_ARITY, class A)>
 589                 class_& def(constructor<BOOST_PP_ENUM_PARAMS(LUABIND_MAX_ARITY, A)> sig)
 590                 {
 591             return this->def_constructor(&sig, detail::null_type());
 592                 }
 593
 594                 template<BOOST_PP_ENUM_PARAMS(LUABIND_MAX_ARITY, class A), class Policies>
 595                 class_& def(constructor<BOOST_PP_ENUM_PARAMS(LUABIND_MAX_ARITY, A)> sig, const Policies& policies)
 596                 {
 597             return this->def_constructor(&sig, policies);
 598                 }
 599
 600         template <class Getter>
 601         class_& property(const char* name, Getter g)
 602         {
 603             this->add_member(
 604                 new detail::property_registration<T, Getter, detail::null_type>(
 605                     name, g, detail::null_type()));
 606             return *this;
 607         }
 608
 609         template <class Getter, class MaybeSetter>
 610         class_& property(const char* name, Getter g, MaybeSetter s)
 611         {
 612             return property_impl(
 613                 name, g, s
 614               , boost::mpl::bool_<detail::is_policy_cons<MaybeSetter>::value>()
 615             );
 616         }
 617
 618         template<class Getter, class Setter, class GetPolicies>
 619         class_& property(const char* name, Getter g, Setter s, const GetPolicies& get_policies)
 620         {
 621             typedef detail::property_registration<
 622                 T, Getter, GetPolicies, Setter, detail::null_type
 623             > registration_type;
 624
 625             this->add_member(
 626                 new registration_type(name, g, get_policies, s));
 627             return *this;
 628         }
 629
 630         template<class Getter, class Setter, class GetPolicies, class SetPolicies>
 631         class_& property(
 632             const char* name
 633           , Getter g, Setter s
 634           , GetPolicies const& get_policies
 635           , SetPolicies const& set_policies)
 636         {
 637             typedef detail::property_registration<
 638                 T, Getter, GetPolicies, Setter, SetPolicies
 639             > registration_type;
 640
 641             this->add_member(
 642                 new registration_type(name, g, get_policies, s, set_policies));
 643             return *this;
 644         }
 645
 646         template <class C, class D>
 647         class_& def_readonly(const char* name, D C::*mem_ptr)
 648         {
 649             typedef detail::property_registration<T, D C::*, detail::null_type>
 650                 registration_type;
 651
 652             this->add_member(
 653                 new registration_type(name, mem_ptr, detail::null_type()));
 654             return *this;
 655         }
 656
 657         template <class C, class D, class Policies>
 658         class_& def_readonly(const char* name, D C::*mem_ptr, Policies const& policies)
 659         {
 660             typedef detail::property_registration<T, D C::*, Policies>
 661                 registration_type;
 662
 663             this->add_member(
 664                 new registration_type(name, mem_ptr, policies));
 665             return *this;
 666         }
 667
 668         template <class C, class D>
 669         class_& def_readwrite(const char* name, D C::*mem_ptr)
 670         {
 671             typedef detail::property_registration<
 672                 T, D C::*, detail::null_type, D C::*
 673             > registration_type;
 674
 675             this->add_member(
 676                 new registration_type(
 677                     name, mem_ptr, detail::null_type(), mem_ptr));
 678             return *this;
 679         }
 680
 681         template <class C, class D, class GetPolicies>
 682         class_& def_readwrite(
 683             const char* name, D C::*mem_ptr, GetPolicies const& get_policies)
 684         {
 685             typedef detail::property_registration<
 686                 T, D C::*, GetPolicies, D C::*
 687             > registration_type;
 688
 689             this->add_member(
 690                 new registration_type(
 691                     name, mem_ptr, get_policies, mem_ptr));
 692             return *this;
 693         }
 694
 695         template <class C, class D, class GetPolicies, class SetPolicies>
 696         class_& def_readwrite(
 697             const char* name
 698           , D C::*mem_ptr
 699           , GetPolicies const& get_policies
 700           , SetPolicies const& set_policies
 701         )
 702         {
 703             typedef detail::property_registration<
 704                 T, D C::*, GetPolicies, D C::*, SetPolicies
 705             > registration_type;
 706
 707             this->add_member(
 708                 new registration_type(
 709                     name, mem_ptr, get_policies, mem_ptr, set_policies));
 710             return *this;
 711         }
 712
 713                 template<class Derived, class Policies>
 714                 class_& def(detail::operator_<Derived>, Policies const& policies)
 715                 {
 716                         return this->def(
 717                                 Derived::name()
 718                           , &Derived::template apply<T, Policies>::execute
 719                           , policies
 720                         );
 721                 }
 722
 723                 template<class Derived>
 724                 class_& def(detail::operator_<Derived>)
 725                 {
 726                         return this->def(
 727                                 Derived::name()
 728                           , &Derived::template apply<T, detail::null_type>::execute
 729                         );
 730                 }
 731
 732                 detail::enum_maker<self_t> enum_(const char*)
 733                 {
 734                         return detail::enum_maker<self_t>(*this);
 735                 }
 736
 737                 detail::static_scope<self_t> scope;
 738
 739         private:
 740                 void operator=(class_ const&);
 741
 742         detail::cast_function get_wrapper_cast(detail::null_type*)
 743         {
 744             return 0;
 745         }
 746
 747         template <class U>
 748         detail::cast_function get_wrapper_cast(U*)
 749         {
 750             return &detail::static_cast_<U,T>::execute;
 751         }
 752
 753                 void init()
 754                 {
 755                         typedef typename detail::extract_parameter<
 756                                         parameters_type
 757                                 ,       boost::mpl::or_<
 758                                                         detail::is_bases<boost::mpl::_>
 759                                                 ,       boost::is_base_and_derived<boost::mpl::_, T>
 760                                         >
 761                                 ,       no_bases
 762                         >::type bases_t;
 763
 764                         typedef typename
 765                                 boost::mpl::if_<detail::is_bases<bases_t>
 766                                         ,       bases_t
 767                                         ,       bases<bases_t>
 768                                 >::type Base;
 769
 770             class_base::init(
 771                 typeid(T)
 772               , detail::registered_class<T>::id
 773               , detail::registered_class<WrappedType>::id
 774               , typeid(WrappedType)
 775               , get_wrapper_cast((WrappedType*)0)
 776             );
 777
 778                         generate_baseclass_list(detail::type_<Base>());
 779                 }
 780
 781                 template<class Getter, class GetPolicies>
 782                 class_& property_impl(const char* name,
 783                                                                          Getter g,
 784                                                                          GetPolicies policies,
 785                                                                          boost::mpl::bool_<true>)
 786                 {
 787             this->add_member(
 788                 new detail::property_registration<T, Getter, GetPolicies>(
 789                     name, g, policies));
 790                         return *this;
 791                 }
 792
 793                 template<class Getter, class Setter>
 794                 class_& property_impl(const char* name,
 795                                                                          Getter g,
 796                                                                          Setter s,
 797                                                                          boost::mpl::bool_<false>)
 798                 {
 799             typedef detail::property_registration<
 800                 T, Getter, detail::null_type, Setter, detail::null_type
 801             > registration_type;
 802
 803             this->add_member(
 804                 new registration_type(name, g, detail::null_type(), s));
 805                         return *this;
 806                 }
 807
 808                 // these handle default implementation of virtual functions
 809                 template<class F, class Policies>
 810                 class_& virtual_def(char const* name, F const& fn
 811                         , Policies const&, detail::null_type, boost::mpl::true_)
 812                 {
 813                         this->add_member(
 814                                 new detail::memfun_registration<T, F, Policies>(
 815                                         name, fn, Policies()));
 816                         return *this;
 817                 }
 818
 819                 template<class F, class Default, class Policies>
 820                 class_& virtual_def(char const* name, F const& fn
 821                         , Default const& default_, Policies const&, boost::mpl::false_)
 822                 {
 823                         this->add_member(
 824                                 new detail::memfun_registration<T, F, Policies>(
 825                                         name, fn, Policies()));
 826
 827                         this->add_default_member(
 828                                 new detail::memfun_registration<T, Default, Policies>(
 829                                         name, default_, Policies()));
 830
 831                         return *this;
 832                 }
 833
 834         template<class Signature, class Policies>
 835                 class_& def_constructor(Signature*, Policies const&)
 836         {
 837             typedef typename Signature::signature signature;
 838
 839             typedef typename boost::mpl::if_<
 840                 boost::is_same<WrappedType, detail::null_type>
 841               , T
 842               , WrappedType
 843             >::type construct_type;
 844
 845             this->add_member(
 846                 new detail::constructor_registration<
 847                     construct_type, HeldType, signature, Policies>(
 848                         Policies()));
 849
 850             this->add_default_member(
 851                 new detail::constructor_registration<
 852                     construct_type, HeldType, signature, Policies>(
 853                         Policies()));
 854
 855             return *this;
 856         }
 857         };
 858
 859 }
 860
 861 #ifdef _MSC_VER
 862 #pragma warning(pop)
 863 #endif
 864
 865 #endif // LUABIND_CLASS_HPP_INCLUDED
 866