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         scopes
  56                 classes with the same name in different scopes will have the same (fully qualified) name.
  57                 functions that are renamed will still have the same name in error-messages
  58
  59         finish smart pointer support
  60                 * make sure there are no bugs in the conversion from holder to const_holder
  61                 * the adopt policy should not be able to adopt pointers to held_types. This
  62                 must be prohibited.
  63                 * name_of_type must recognize holder_types and not return "custom"
  64
  65         support calling functions on lua threads (i.e. use lua_resume() instead of lua_pcall()).
  66
  67         document the new yield-policy more
  68
  69         cache finalizers in the class_rep. For lua classes
  70         we currently do a lookup each time we need to know if a lua class
  71         has a finalizer.
  72
  73         static functions, this could be implemented by letting classes contain
  74         other declarations (classes or functions)
  75
  76         document custom policies, custom converters
  77
  78         store the instance object for policies.
  79
  80         support the __concat metamethod. This is a bit tricky, since it cannot be
  81         treated as a normal operator. It is a binary operator but we want to use the
  82         __tostring implementation for both arguments.
  83
  84 */
  85
  86 #include <luabind/config.hpp>
  87
  88 #include <string>
  89 #include <map>
  90 #include <vector>
  91 #include <cassert>
  92
  93 #include <boost/static_assert.hpp>
  94 #include <boost/type_traits.hpp>
  95 #include <boost/bind.hpp>
  96 #include <boost/function.hpp>
  97 #include <boost/preprocessor/repetition/enum_params.hpp>
  98 #include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
  99 #include <boost/preprocessor/repetition/repeat.hpp>
 100 #include <boost/type_traits/is_same.hpp>
 101 #include <boost/mpl/list.hpp>
 102 #include <boost/mpl/apply.hpp>
 103 #include <boost/mpl/lambda.hpp>
 104 #include <boost/mpl/logical.hpp>
 105 #include <boost/mpl/find_if.hpp>
 106 #include <boost/mpl/apply_if.hpp>
 107 #include <boost/mpl/logical.hpp>
 108
 109 #include <luabind/config.hpp>
 110 #include <luabind/scope.hpp>
 111 #include <luabind/detail/constructor.hpp>
 112 #include <luabind/detail/call.hpp>
 113 #include <luabind/detail/signature_match.hpp>
 114 #include <luabind/detail/primitives.hpp>
 115 #include <luabind/detail/property.hpp>
 116 #include <luabind/detail/typetraits.hpp>
 117 #include <luabind/detail/class_rep.hpp>
 118 #include <luabind/detail/method_rep.hpp>
 119 #include <luabind/detail/construct_rep.hpp>
 120 #include <luabind/detail/object_rep.hpp>
 121 #include <luabind/detail/operators.hpp>
 122 #include <luabind/detail/calc_arity.hpp>
 123 #include <luabind/detail/call_member.hpp>
 124 #include <luabind/detail/enum_maker.hpp>
 125 #include <luabind/detail/get_signature.hpp>
 126 #include <luabind/detail/implicit_cast.hpp>
 127 #include <luabind/detail/operator_id.hpp>
 128 #include <luabind/detail/pointee_typeid.hpp>
 129
 130 //#include <boost/langbinding/inheritance.hpp>
 131
 132 namespace luabind
 133 {
 134         namespace detail
 135         {
 136                 struct unspecified {};
 137         }
 138
 139         using detail::type;
 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::null_type* get_const_holder(...)
 147         {
 148                 return 0;
 149         }
 150
 151         namespace detail
 152         {
 153                 template<BOOST_PP_ENUM_PARAMS(LUABIND_MAX_BASES, class A)>
 154                 double is_bases_helper(const bases<BOOST_PP_ENUM_PARAMS(LUABIND_MAX_BASES, A)>&);
 155
 156 #ifndef BOOST_MSVC
 157                 template<class T>
 158                 char is_bases_helper(const T&);
 159 #else
 160                 char is_bases_helper(...);
 161 #endif
 162
 163                 template<class T>
 164                 struct is_bases
 165                 {
 166                         static const T& t;
 167
 168                         BOOST_STATIC_CONSTANT(bool, value = sizeof(is_bases_helper(t)) == sizeof(double));
 169                         typedef boost::mpl::bool_<value> type;
 170                         BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_bases,(T))
 171                 };
 172
 173                 double is_not_unspecified_helper(const unspecified*);
 174                 char is_not_unspecified_helper(...);
 175
 176                 template<class T>
 177                 struct is_not_unspecified
 178                 {
 179                         BOOST_STATIC_CONSTANT(bool, value = sizeof(is_not_unspecified_helper(static_cast<T*>(0))) == sizeof(char));
 180                         typedef boost::mpl::bool_<value> type;
 181                         BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_not_unspecified,(T))
 182                 };
 183
 184                 template<class Predicate>
 185                 struct get_predicate
 186                 {
 187                         typedef typename boost::mpl::and_<
 188                                                 Predicate
 189                                         ,       is_not_unspecified<boost::mpl::_1>
 190                                         > type;
 191                 };
 192
 193                 template<class Parameters, class Predicate, class DefaultValue>
 194                 struct extract_parameter
 195                 {
 196                         typedef typename get_predicate<Predicate>::type pred;
 197                         typedef typename boost::mpl::find_if<Parameters, pred>::type iterator;
 198                         typedef typename boost::mpl::apply_if<boost::is_same<iterator, typename boost::mpl::end<Parameters>::type>
 199                                 , boost::mpl::identity<DefaultValue>
 200                                 , iterator
 201                         >::type type;
 202                 };
 203
 204                 // TODO: is this detail::class_rep::function_dispatcher or detail::free_functions::function_dispatcher?
 205 //              LUABIND_API int function_dispatcher(lua_State* L);
 206
 207                 // this should know about the smart pointer type.
 208                 // and should really do:
 209                 // get_pointer(*static_cast<SmartPointer*>(obj_ptr))
 210                 // to extract the held pointer.
 211                 template<class HeldType, class T, class F, class Policies>
 212                 struct function_callback_non_null : Policies
 213                 {
 214                         function_callback_non_null(F f_): f(f_) {}
 215                         inline int operator()(lua_State* L, void* obj_ptr)
 216                         {
 217 //                              HeldType& held_obj = *static_cast<HeldType*>(obj_ptr);
 218 //                              T* ptr = static_cast<T*>(luabind::get_pointer(held_obj));
 219                                 // is this correct?
 220                                 T* ptr = static_cast<T*>(obj_ptr);
 221
 222                                 return call(f, ptr, L, static_cast<Policies*>(this));
 223                         }
 224                         F f;
 225                 };
 226
 227                 template<class T, class F, class Policies>
 228                 struct function_callback_null_type : Policies
 229                 {
 230                         function_callback_null_type(F f_): f(f_) {}
 231                         inline int operator()(lua_State* L, void* obj_ptr)
 232                         {
 233 //                              std::cout << "HeldType: null_type\n";
 234                                 T* ptr = static_cast<T*>(obj_ptr);
 235                                 return call(f, ptr, L, static_cast<Policies*>(this));
 236                         }
 237                         F f;
 238                 };
 239
 240                 template<class HeldType, class T, class F, class Policies>
 241                 struct function_callback_s
 242                 {
 243                         typedef typename
 244                                 boost::mpl::if_<boost::is_same<HeldType,detail::null_type>
 245                                         , function_callback_null_type<T,F,Policies>
 246                                         , function_callback_non_null<HeldType,T,F,Policies>
 247                         >::type type;
 248                 };
 249
 250                 template<class T, class F, class Policies>
 251                 struct match_function_callback_s
 252                 {
 253                         static inline int apply(lua_State* L)
 254                         {
 255                                 object_rep* obj = static_cast<object_rep*>(lua_touserdata(L, 1));
 256                                 F fptr = 0;
 257                                 return match(fptr, L, obj->flags() & object_rep::constant, static_cast<Policies*>(0));
 258                         }
 259                 };
 260
 261                 // prints the types of the values on the stack, in the
 262                 // range [start_index, lua_gettop()]
 263
 264                 LUABIND_API std::string stack_content_by_name(lua_State* L, int start_index);
 265
 266                 struct LUABIND_API create_class
 267                 {
 268                         static int stage1(lua_State* L);
 269                         static int stage2(lua_State* L);
 270                 };
 271
 272                 template<class Type>
 273                 struct register_wrapped_type
 274                 {
 275                         template<class Signature, class Policies>
 276                         static void apply(detail::construct_rep::overload_t& o, const Signature*, const Policies*)
 277                         {
 278                                 o.set_wrapped_constructor(
 279                                         &detail::construct_wrapped_class<Type, Policies, Signature>::apply
 280                                 );
 281                         }
 282                 };
 283
 284                 template<>
 285                 struct register_wrapped_type<detail::null_type>
 286                 {
 287                         template<class Signature, class Policies>
 288                         static void apply(detail::construct_rep::overload_t&, const Signature*, const Policies*) {}
 289                 };
 290
 291
 292                 // if the class is held by a smart pointer, we need to be able to
 293                 // implicitly dereference the pointer when needed.
 294
 295                 template<class UnderlyingT, class HeldT>
 296                 struct extract_underlying_type
 297                 {
 298                         static void* extract(void* ptr)
 299                         {
 300                                 HeldT& held_obj = *reinterpret_cast<HeldT*>(ptr);
 301                                 UnderlyingT* underlying_ptr = static_cast<UnderlyingT*>(get_pointer(held_obj));
 302                                 return underlying_ptr;
 303                         }
 304                 };
 305
 306                 template<class UnderlyingT, class HeldT>
 307                 struct extract_underlying_const_type
 308                 {
 309                         static const void* extract(void* ptr)
 310                         {
 311                                 HeldT& held_obj = *reinterpret_cast<HeldT*>(ptr);
 312                                 const UnderlyingT* underlying_ptr = static_cast<const UnderlyingT*>(get_pointer(held_obj));
 313                                 return underlying_ptr;
 314                         }
 315                 };
 316
 317                 template<class HeldType>
 318                 struct internal_holder_extractor
 319                 {
 320                         typedef void*(*extractor_fun)(void*);
 321
 322                         template<class T>
 323                         static extractor_fun apply(detail::type<T>)
 324                         {
 325                                 return &detail::extract_underlying_type<T, HeldType>::extract;
 326                         }
 327                 };
 328
 329                 template<>
 330                 struct internal_holder_extractor<detail::null_type>
 331                 {
 332                         typedef void*(*extractor_fun)(void*);
 333
 334                         template<class T>
 335                         static extractor_fun apply(detail::type<T>)
 336                         {
 337                                 return 0;
 338                         }
 339                 };
 340
 341
 342                 template<class HeldType, class ConstHolderType>
 343                 struct convert_holder
 344                 {
 345                         static void apply(void* holder, void* target)
 346                         {
 347                                 new(target) ConstHolderType(*reinterpret_cast<HeldType*>(holder));
 348                         };
 349                 };
 350
 351
 352                 template<class HeldType>
 353                 struct const_converter
 354                 {
 355                         typedef void(*converter_fun)(void*, void*);
 356
 357                         template<class ConstHolderType>
 358                         static converter_fun apply(ConstHolderType*)
 359                         {
 360                                 return &detail::convert_holder<HeldType, ConstHolderType>::apply;
 361                         }
 362                 };
 363
 364                 template<>
 365                 struct const_converter<detail::null_type>
 366                 {
 367                         typedef void(*converter_fun)(void*, void*);
 368
 369                         template<class T>
 370                         static converter_fun apply(T*)
 371                         {
 372                                 return 0;
 373                         }
 374                 };
 375
 376
 377
 378
 379                 template<class HeldType>
 380                 struct internal_const_holder_extractor
 381                 {
 382                         typedef const void*(*extractor_fun)(void*);
 383
 384                         template<class T>
 385                         static extractor_fun apply(detail::type<T>)
 386                         {
 387                                 return get_extractor(detail::type<T>(), luabind::get_const_holder(static_cast<HeldType*>(0)));
 388                         }
 389                 private:
 390                         template<class T, class ConstHolderType>
 391                         static extractor_fun get_extractor(detail::type<T>, ConstHolderType*)
 392                         {
 393                                 return &detail::extract_underlying_const_type<T, ConstHolderType>::extract;
 394                         }
 395                 };
 396
 397                 template<>
 398                 struct internal_const_holder_extractor<detail::null_type>
 399                 {
 400                         typedef const void*(*extractor_fun)(void*);
 401
 402                         template<class T>
 403                         static extractor_fun apply(detail::type<T>)
 404                         {
 405                                 return 0;
 406                         }
 407                 };
 408
 409
 410
 411                 // this is simply a selector that returns the type_info
 412                 // of the held type, or invalid_type_info if we don't have
 413                 // a held_type
 414                 template<class HeldType>
 415                 struct internal_holder_type
 416                 {
 417                         static LUABIND_TYPE_INFO apply()
 418                         {
 419                                 return LUABIND_TYPEID(HeldType);
 420                         }
 421                 };
 422
 423                 template<>
 424                 struct internal_holder_type<detail::null_type>
 425                 {
 426                         static LUABIND_TYPE_INFO apply()
 427                         {
 428                                 return LUABIND_INVALID_TYPE_INFO;
 429                         }
 430                 };
 431
 432
 433                 // this is the actual held_type constructor
 434                 template<class HeldType, class T>
 435                 struct internal_construct_holder
 436                 {
 437                         static void apply(void* target, void* raw_pointer)
 438                         {
 439                                 new(target) HeldType(static_cast<T*>(raw_pointer));
 440                         }
 441                 };
 442
 443                 // the following two functions are the ones that returns
 444                 // a pointer to a held_type_constructor, or 0 if there
 445                 // is no held_type
 446                 template<class HeldType>
 447                 struct holder_constructor
 448                 {
 449                         typedef void(*constructor)(void*,void*);
 450                         template<class T>
 451                         static constructor apply(detail::type<T>)
 452                         {
 453                                 return &internal_construct_holder<HeldType, T>::apply;
 454                         }
 455                 };
 456
 457                 template<>
 458                 struct holder_constructor<detail::null_type>
 459                 {
 460                         typedef void(*constructor)(void*,void*);
 461                         template<class T>
 462                         static constructor apply(detail::type<T>)
 463                         {
 464                                 return 0;
 465                         }
 466                 };
 467
 468                 // the following two functions are the ones that returns
 469                 // a pointer to a const_held_type_constructor, or 0 if there
 470                 // is no held_type
 471                 template<class HolderType>
 472                 struct const_holder_constructor
 473                 {
 474                         typedef void(*constructor)(void*,void*);
 475                         template<class T>
 476                         static constructor apply(detail::type<T>)
 477                         {
 478                                 return get_const_holder_constructor(detail::type<T>(), luabind::get_const_holder(static_cast<HolderType*>(0)));
 479                         }
 480
 481                 private:
 482
 483                         template<class T, class ConstHolderType>
 484                                 static constructor get_const_holder_constructor(detail::type<T>, ConstHolderType*)
 485                         {
 486                                 return &internal_construct_holder<ConstHolderType, T>::apply;
 487                         }
 488                 };
 489
 490                 template<>
 491                 struct const_holder_constructor<detail::null_type>
 492                 {
 493                         typedef void(*constructor)(void*,void*);
 494                         template<class T>
 495                         static constructor apply(detail::type<T>)
 496                         {
 497                                 return 0;
 498                         }
 499                 };
 500
 501
 502
 503                 // this is a selector that returns the size of the held_type
 504                 // or 0 if we don't have a held_type
 505                 template <class HolderType>
 506                 struct internal_holder_size
 507                 {
 508                         static int apply() { return get_internal_holder_size(luabind::get_const_holder(static_cast<HolderType*>(0))); }
 509                 private:
 510                         template<class ConstHolderType>
 511                         static int get_internal_holder_size(ConstHolderType*)
 512                         {
 513                                 return max_c<sizeof(HolderType), sizeof(ConstHolderType)>::value;
 514                         }
 515                 };
 516
 517                 template <>
 518                 struct internal_holder_size<detail::null_type>
 519                 {
 520                         static int apply() {    return 0; }
 521                 };
 522
 523
 524                 // if we have a held type, return the destructor to it
 525                 // note the difference. The held_type should only be destructed (not deleted)
 526                 // since it's constructed in the lua userdata
 527                 template<class HeldType>
 528                 struct internal_holder_destructor
 529                 {
 530                         typedef void(*destructor_t)(void*);
 531                         template<class T>
 532                         static destructor_t apply(detail::type<T>)
 533                         {
 534                                 return &detail::destruct_only_s<HeldType>::apply;
 535                         }
 536                 };
 537
 538                 // if we don't have a held type, return the destructor of the raw type
 539                 template<>
 540                 struct internal_holder_destructor<detail::null_type>
 541                 {
 542                         typedef void(*destructor_t)(void*);
 543                         template<class T>
 544                         static destructor_t apply(detail::type<T>)
 545                         {
 546                                 return &detail::delete_s<T>::apply;
 547                         }
 548                 };
 549
 550
 551                 // if we have a held type, return the destructor to it's const version
 552                 template<class HolderType>
 553                 struct internal_const_holder_destructor
 554                 {
 555                         typedef void(*destructor_t)(void*);
 556                         template<class T>
 557                         static destructor_t apply(detail::type<T>)
 558                         {
 559                                 return const_holder_type_destructor(luabind::get_const_holder(static_cast<HolderType*>(0)));
 560                         }
 561
 562                 private:
 563
 564                         template<class ConstHolderType>
 565                         static destructor_t const_holder_type_destructor(ConstHolderType*)
 566                         {
 567                                 return &detail::destruct_only_s<ConstHolderType>::apply;
 568                         }
 569
 570                 };
 571
 572                 // if we don't have a held type, return the destructor of the raw type
 573                 template<>
 574                 struct internal_const_holder_destructor<detail::null_type>
 575                 {
 576                         typedef void(*destructor_t)(void*);
 577                         template<class T>
 578                         static destructor_t apply(detail::type<T>)
 579                         {
 580                                 return 0;
 581                         }
 582                 };
 583
 584
 585
 586
 587                 template<class HolderType>
 588                 struct get_holder_alignment
 589                 {
 590                         static int apply()
 591                         {
 592                                 return internal_alignment(luabind::get_const_holder(static_cast<HolderType*>(0)));
 593                         }
 594
 595                 private:
 596
 597                         template<class ConstHolderType>
 598                         static int internal_alignment(ConstHolderType*)
 599                         {
 600                                 return detail::max_c<boost::alignment_of<HolderType>::value
 601                                         , boost::alignment_of<ConstHolderType>::value>::value;
 602                         }
 603                 };
 604
 605                 template<>
 606                 struct get_holder_alignment<detail::null_type>
 607                 {
 608                         static int apply()
 609                         {
 610                                 return 1;
 611                         }
 612                 };
 613
 614
 615         } // detail
 616
 617
 618
 619
 620
 621
 622
 623
 624
 625
 626
 627
 628
 629 /*
 630         struct class_base: detail::scoped_object
 631         {
 632         protected:
 633
 634                 struct base_desc
 635                 {
 636                         LUABIND_TYPE_INFO type;
 637                         int ptr_offset;
 638                 };
 639
 640         private:
 641
 642 #ifndef NDEBUG
 643                 bool m_cloned;
 644 #endif
 645
 646                 const char* m_name;
 647
 648                 std::map<const char*, detail::method_rep, detail::ltstr> m_methods;
 649
 650                 // datamembers, some members may be readonly, and
 651                 // only have a getter function
 652                 std::map<const char*, detail::class_rep::callback, detail::ltstr> m_getters;
 653                 std::map<const char*, detail::class_rep::callback, detail::ltstr> m_setters;
 654
 655                 // the operators in lua
 656                 std::vector<detail::class_rep::operator_callback> m_operators[detail::number_of_operators];
 657                 std::map<const char*, int, detail::ltstr> m_static_constants;
 658
 659                 std::vector<base_desc> m_bases;
 660                 detail::construct_rep m_constructor;
 661
 662                 void(*m_destructor)(void*);
 663                 void(*m_const_holder_destructor)(void*);
 664
 665                 void*(*m_extractor)(void*);
 666                 const void*(*m_const_extractor)(void*);
 667
 668                 void(*m_const_converter)(void*,void*);
 669
 670                 void(*m_construct_holder)(void*, void*);
 671                 void(*m_construct_const_holder)(void*, void*);
 672
 673                 int m_holder_size;
 674                 int m_holder_alignment;
 675
 676                 LUABIND_TYPE_INFO m_type;
 677                 LUABIND_TYPE_INFO m_holder_type;
 678                 LUABIND_TYPE_INFO m_const_holder_type;
 679
 680 #ifndef LUABIND_DONT_COPY_STRINGS
 681                 // the maps that contains char pointers points into
 682                 // this vector of strings.
 683                 std::vector<char*> m_strings;
 684 #endif
 685
 686
 687         public:
 688
 689                 // public 'cause of enum_maker, FIX
 690                 void add_static_constant(const char* name, int val)
 691                 {
 692                         m_static_constants[name] = val;
 693                 }
 694
 695         protected:
 696
 697                 mutable std::vector<detail::scoped_object*> m_children;
 698
 699                 void init(LUABIND_TYPE_INFO type
 700                         , LUABIND_TYPE_INFO holder_type
 701                         , void*(*extractor)(void*)
 702                         , const void*(*const_extractor)(void*)
 703                         , void(*const_converter)(void*,void*)
 704                         , void(*holder_constructor)(void*,void*)
 705                         , void(*const_holder_constructor)(void*,void*)
 706                         , void(*destructor)(void*)
 707                         , void(*const_holder_destructor)(void*)
 708                         , int holder_size
 709                         , int holder_alignment)
 710                 {
 711                         m_type = type;
 712                         m_holder_type = holder_type;
 713                         m_extractor = extractor;
 714                         m_const_extractor = const_extractor;
 715                         m_const_converter = const_converter;
 716                         m_construct_holder = holder_constructor;
 717                         m_construct_const_holder = const_holder_constructor;
 718                         m_destructor = destructor;
 719                         m_const_holder_destructor = const_holder_destructor;
 720                         m_holder_size = holder_size;
 721                         m_holder_alignment = holder_alignment;
 722                 }
 723
 724                 template<class T>
 725                 void set_const_holder_type(T*)
 726                 {
 727                         m_const_holder_type = LUABIND_TYPEID(T);
 728                 }
 729
 730                 inline void add_getter(const char* name, const boost::function2<int, lua_State*, int>& g)
 731                 {
 732                         detail::class_rep::callback c;
 733                         c.func = g;
 734                         c.pointer_offset = 0;
 735 #ifndef LUABIND_DONT_COPY_STRINGS
 736                         m_strings.push_back(detail::dup_string(name));
 737                         m_getters[m_strings.back()] = c;
 738 #else
 739                         m_getters[name] = c;
 740 #endif
 741                 }
 742
 743                 inline void add_setter(const char* name, const boost::function2<int, lua_State*, int>& s)
 744                 {
 745                         detail::class_rep::callback c;
 746                         c.func = s;
 747                         c.pointer_offset = 0;
 748 #ifndef LUABIND_DONT_COPY_STRINGS
 749                         m_strings.push_back(detail::dup_string(name));
 750                         m_setters[m_strings.back()] = c;
 751 #else
 752                         m_setters[name] = c;
 753 #endif
 754                 }
 755
 756                 void add_base(const base_desc& b)
 757                 {
 758                         m_bases.push_back(b);
 759                 }
 760
 761         public:
 762
 763                 void add_constructor(const detail::construct_rep::overload_t& o)
 764                 {
 765                         m_constructor.overloads.push_back(o);
 766                 }
 767
 768                 void add_method(const char* name, const detail::overload_rep& o)
 769                 {
 770 #ifdef LUABIND_DONT_COPY_STRINGS
 771                         detail::method_rep& method = m_methods[name];
 772                         method.name = name;
 773 #else
 774                         m_strings.push_back(detail::dup_string(name));
 775                         detail::method_rep& method = m_methods[m_strings.back()];
 776                         method.name = m_strings.back();
 777 #endif
 778                         method.add_overload(o);
 779                         method.crep = 0;
 780                 }
 781
 782 #ifndef LUABIND_NO_ERROR_CHECKING
 783                 inline void add_operator(int op_id,  int(*func)(lua_State*), int(*matcher)(lua_State*), void(*sig)(lua_State*, std::string&), int arity)
 784 #else
 785                 inline void add_operator(int op_id,  int(*func)(lua_State*), int(*matcher)(lua_State*), int arity)
 786 #endif
 787                 {
 788                         detail::class_rep::operator_callback o;
 789                         o.set_fun(func);
 790                         o.set_match_fun(matcher);
 791                         o.set_arity(arity);
 792
 793 #ifndef LUABIND_NO_ERROR_CHECKING
 794
 795                         o.set_sig_fun(sig);
 796
 797 #endif
 798                         m_operators[op_id].push_back(o);
 799                 }
 800
 801
 802
 803
 804
 805
 806
 807                 const char* name() const { return m_name; }
 808
 809                 class_base(const char* name)
 810                 {
 811 #ifndef LUABIND_DONT_COPY_STRINGS
 812                         m_strings.push_back(detail::dup_string(name));
 813                         m_name = m_strings.back();
 814 #else
 815                         m_name = name;
 816 #endif
 817
 818 #ifndef NDEBUG
 819                         m_cloned = false;
 820 #endif
 821                 }
 822
 823                 virtual ~class_base()
 824                 {
 825                         for (std::vector<detail::scoped_object*>::iterator
 826                                         i = m_children.begin(); i != m_children.end(); ++i)
 827                                 delete *i;
 828
 829 // if we are copying strings, we have to destroy them too
 830 #ifndef LUABIND_DONT_COPY_STRINGS
 831                         for (std::vector<char*>::iterator i = m_strings.begin(); i != m_strings.end(); ++i)
 832                                 delete[] *i;
 833 #endif
 834                 }
 835
 836                 // pushes the class_rep on the lua stack
 837                 virtual void commit(lua_State* L)
 838                 {
 839                         assert(!m_cloned && "class already commited");
 840
 841                         detail::getref(L, scope_stack::top(L));
 842                         lua_pushstring(L, m_name);
 843
 844                         detail::class_rep* crep;
 845
 846                         detail::class_registry* r = detail::class_registry::get_registry(L);
 847                         // create a class_rep structure for this class.
 848                         // allocate it within lua to let lua collect it on
 849                         // lua_close(). This is better than allocating it
 850                         // as a static, since it will then be destructed
 851                         // when the program exits instead.
 852                         // warning: we assume that lua will not
 853                         // move the userdata memory.
 854                         lua_newuserdata(L, sizeof(detail::class_rep));
 855                         crep = reinterpret_cast<detail::class_rep*>(lua_touserdata(L, -1));
 856
 857                         new(crep) detail::class_rep(    m_type
 858                                 , m_name
 859                                 , L
 860                                 , m_destructor
 861                                 , m_const_holder_destructor
 862                                 , m_holder_type
 863                                 , m_const_holder_type
 864                                 , m_extractor
 865                                 , m_const_extractor
 866                                 , m_const_converter
 867                                 , m_construct_holder
 868                                 , m_construct_const_holder
 869                                 , m_holder_size
 870                                 , m_holder_alignment);
 871
 872                         // register this new type in the class registry
 873                         r->add_class(m_type, crep);
 874                         if (!(LUABIND_TYPE_INFO_EQUAL(m_holder_type, LUABIND_INVALID_TYPE_INFO)))
 875                         {
 876                                 // if we have a held type
 877                                 // we have to register it in the class-table
 878                                 // but only for the base class, if it already
 879                                 // exists, we don't have to register it
 880                                 detail::class_rep* c = r->find_class(m_holder_type);
 881                                 if (c == 0)
 882                                 {
 883                                         r->add_class(m_holder_type, crep);
 884                                         r->add_class(m_const_holder_type, crep);
 885                                 }
 886                         }
 887
 888                         // constructors
 889                         m_constructor.swap(crep->m_constructor);
 890
 891                         #ifndef LUABIND_DONT_COPY_STRINGS
 892                                 assert(crep->m_strings.empty() && "Internal error");
 893                                 std::swap(crep->m_strings, m_strings);
 894                         #endif
 895
 896                         std::swap(crep->m_getters, m_getters);
 897                         std::swap(crep->m_setters, m_setters);
 898
 899                         for(int i = 0; i < detail::number_of_operators; ++i)
 900                                 std::swap(crep->m_operators[i], m_operators[i]);
 901
 902                         std::swap(crep->m_static_constants, m_static_constants);
 903
 904                         // here!
 905 //                      crep->m_methods = m_methods;
 906
 907                         for (std::vector<base_desc>::iterator i = m_bases.begin();
 908                                                         i != m_bases.end();
 909                                                         ++i)
 910                         {
 911                                 detail::class_registry* r = detail::class_registry::get_registry(L);
 912
 913                                 // the baseclass' class_rep structure
 914                                 detail::class_rep* bcrep = r->find_class(i->type);
 915
 916                                 detail::class_rep::base_info base;
 917                                 base.pointer_offset = i->ptr_offset;
 918                                 base.base = bcrep;
 919
 920                                 crep->add_base_class(base);
 921
 922                                 typedef std::map<const char*, detail::method_rep, detail::ltstr> methods_t;
 923
 924                                 for (methods_t::const_iterator i
 925                                                 = bcrep->m_methods.begin()
 926                                                 ; i != bcrep->m_methods.end()
 927                                                 ; ++i)
 928                                 {
 929                                         detail::method_rep& m = m_methods[i->first];
 930
 931                                         typedef std::vector<detail::overload_rep> overloads_t;
 932
 933                                         for (overloads_t::const_iterator j
 934                                                         = i->second.overloads().begin()
 935                                                         ; j != i->second.overloads().end()
 936                                                         ; ++j)
 937                                         {
 938                                                 detail::overload_rep o = *j;
 939                                                 o.add_offset(base.pointer_offset);
 940                                                 m.add_overload(o);
 941                                         }
 942                                 }
 943
 944                                 // copy base class table
 945                                 detail::getref(L, crep->table_ref());
 946                                 detail::getref(L, bcrep->table_ref());
 947                                 lua_pushnil(L);
 948
 949                                 while (lua_next(L, -2))
 950                                 {
 951                                         lua_pushvalue(L, -2); // copy key
 952                                         lua_insert(L, -2);
 953                                         lua_settable(L, -5);
 954                                 }
 955
 956                                 lua_pop(L, 2);
 957                         }
 958
 959                         crep->m_methods = m_methods;
 960
 961                         for (std::map<const char*, detail::method_rep, detail::ltstr>::iterator i
 962                                 = crep->m_methods.begin(); i != crep->m_methods.end(); ++i)
 963                         {
 964                                 i->second.crep = crep;
 965                         }
 966
 967                         // add methods
 968                         for (std::map<const char*, detail::method_rep, detail::ltstr>::iterator i
 969                                 = m_methods.begin(); i != m_methods.end(); ++i)
 970                         {
 971                                 detail::getref(L, crep->table_ref());
 972                                 lua_pushstring(L, i->first);
 973                                 lua_pushnil(L);
 974                                 lua_settable(L, -3);
 975                                 lua_pop(L, 1);
 976
 977                                 crep->add_method(L, i->first, crep->m_methods[i->first]);
 978                                 i->second.crep = crep;
 979                         }
 980
 981                         m_methods.clear();
 982
 983                         lua_settable(L, -3);
 984                         lua_pop(L, 1);
 985                 }
 986
 987
 988                 // destructive copy
 989                 virtual luabind::detail::scoped_object* clone()
 990                 {
 991                         assert(m_cloned == false);
 992
 993 #ifndef NDEBUG
 994                         m_cloned = true;
 995 #endif
 996
 997                         class_base* ret = new class_base(m_name);
 998
 999                         std::swap(ret->m_getters, m_getters);
1000                         std::swap(ret->m_setters, m_setters);
1001
1002                         for(int i = 0; i < detail::number_of_operators; ++i)
1003                                 std::swap(ret->m_operators[i], m_operators[i]);
1004
1005                         std::swap(ret->m_static_constants, m_static_constants);
1006
1007                         ret->init(m_type
1008                                 , m_holder_type
1009                                 , m_extractor
1010                                 , m_const_extractor
1011                                 , m_const_converter
1012                                 , m_construct_holder
1013                                 , m_construct_const_holder
1014                                 , m_destructor
1015                                 , m_const_holder_destructor
1016                                 , m_holder_size
1017                                 , m_holder_alignment);
1018
1019                         ret->m_const_holder_type = m_const_holder_type;
1020
1021                         ret->m_bases.swap(m_bases);
1022                         ret->m_methods.swap(m_methods);
1023                         m_constructor.swap(ret->m_constructor);
1024
1025                         ret->m_name = m_name;
1026
1027 #ifndef LUABIND_DONT_COPY_STRINGS
1028                         std::swap(ret->m_strings, m_strings);
1029 #endif
1030
1031                         m_children.swap(ret->m_children);
1032
1033                         return ret;
1034                 }
1035         };
1036 */
1037         namespace detail {
1038
1039                 struct class_registration;
1040
1041                 struct class_base : detail::scope
1042                 {
1043                 public:
1044                         class_base(char const* name);
1045
1046                         struct base_desc
1047                         {
1048                                 LUABIND_TYPE_INFO type;
1049                                 int ptr_offset;
1050                         };
1051
1052                         void init(
1053                                 LUABIND_TYPE_INFO type
1054                                 , LUABIND_TYPE_INFO holder_type
1055                                 , LUABIND_TYPE_INFO const_holder_type
1056                                 , void*(*extractor)(void*)
1057                                 , const void*(*const_extractor)(void*)
1058                                 , void(*const_converter)(void*,void*)
1059                                 , void(*holder_constructor)(void*,void*)
1060                                 , void(*const_holder_constructor)(void*,void*)
1061                                 , void(*destructor)(void*)
1062                                 , void(*const_holder_destructor)(void*)
1063                                 , int holder_size
1064                                 , int holder_alignment);
1065
1066                         void add_getter(
1067                                 const char* name
1068                                 , const boost::function2<int, lua_State*, int>& g);
1069
1070                         void add_setter(
1071                                 const char* name
1072                                 , const boost::function2<int, lua_State*, int>& s);
1073
1074                         void add_base(const base_desc& b);
1075                         void add_constructor(const detail::construct_rep::overload_t& o);
1076                         void add_method(const char* name, const detail::overload_rep& o);
1077
1078 #ifndef LUABIND_NO_ERROR_CHECKING
1079                         void add_operator(
1080                                 int op_id
1081                                 ,  int(*func)(lua_State*)
1082                                 , int(*matcher)(lua_State*)
1083                                 , void(*sig)(lua_State*
1084                                 , std::string&)
1085                                 , int arity);
1086 #else
1087                         void add_operator(
1088                                 int op_id
1089                                 ,  int(*func)(lua_State*)
1090                                 , int(*matcher)(lua_State*)
1091                                 , int arity);
1092 #endif
1093
1094                         const char* name() const;
1095
1096                         void add_static_constant(const char* name, int val);
1097
1098                 private:
1099                         class_registration* m_registration;
1100                 };
1101
1102         } // namespace detail
1103
1104         // registers a class in the lua environment
1105         template<class T, class X1, class X2, class X3>
1106         struct class_: detail::class_base
1107         {
1108                 typedef class_<T, X1, X2, X3> self_t;
1109
1110                 lua_State* m_L;
1111
1112         private:
1113
1114                 template<class A, class B, class C, class D>
1115                 class_(const class_<A,B,C,D>&);
1116
1117         public:
1118
1119                 // WrappedType MUST inherit from T
1120                 typedef typename detail::extract_parameter<
1121                                 boost::mpl::vector3<X1,X2,X3>
1122                         ,  boost::is_base_and_derived<T, boost::mpl::_>
1123         /*              ,       boost::mpl::not_<
1124                                                 boost::mpl::or_<
1125                                                                 detail::is_bases<boost::mpl::_>
1126                                                         ,       boost::is_base_and_derived<boost::mpl::_, T>
1127                                                 >
1128                                 >*/
1129                                 ,       detail::null_type
1130                 >::type WrappedType;
1131
1132                 typedef typename detail::extract_parameter<
1133                           boost::mpl::list3<X1,X2,X3>
1134                         , boost::mpl::not_<
1135                                 boost::mpl::or_<
1136                                         boost::mpl::or_<
1137                                                   detail::is_bases<boost::mpl::_>
1138                                                 , boost::is_base_and_derived<boost::mpl::_, T>
1139                                                 >
1140                                         , boost::is_base_and_derived<T, boost::mpl::_>
1141                                 >
1142                         >
1143                   , detail::null_type
1144                 >::type HeldType;
1145 /*
1146                 template<class To>
1147                 void register_downcast(boost::mpl::true_, detail::type<To>* = 0)
1148                 { boost::langbinding::register_conversion<To, T>(true); }
1149
1150                 template<class To>
1151                 void register_downcast(boost::mpl::false_, detail::type<To>* = 0)
1152                 {}
1153 */
1154                 // this function generates conversion information
1155                 // in the given class_rep structure. It will be able
1156                 // to implicitly cast to the given template type
1157                 template<class To>
1158                 void gen_base_info(detail::type<To>)
1159                 {
1160 //                      boost::langbinding::register_dynamic_id<To>();
1161 //                      boost::langbinding::register_conversion<T, To>(false);
1162
1163 //                      register_downcast<To>(boost::mpl::bool_<boost::is_polymorphic<To>::value>());
1164
1165                         // fist, make sure the given base class is registered.
1166                         // if it's not registered we can't push it's lua table onto
1167                         // the stack because it doesn't have a table
1168
1169                         // try to cast this type to the base type and remember
1170                         // the pointer offset. For multiple inheritance the pointer
1171                         // may change when casting. Since we need to be able to
1172                         // cast we need this pointer offset.
1173                         // store the information in this class' base class-vector
1174                         base_desc base;
1175                         base.type = LUABIND_TYPEID(To);
1176                         base.ptr_offset = detail::ptr_offset(detail::type<T>(), detail::type<To>());
1177                         add_base(base);
1178                 }
1179
1180                 void gen_base_info(detail::type<detail::null_type>)
1181                 {}
1182
1183 #define LUABIND_GEN_BASE_INFO(z, n, text) gen_base_info(detail::type<B##n>());
1184
1185                 template<BOOST_PP_ENUM_PARAMS(LUABIND_MAX_BASES, class B)>
1186                 void generate_baseclass_list(detail::type<bases<BOOST_PP_ENUM_PARAMS(LUABIND_MAX_BASES, B)> >)
1187                 {
1188                         BOOST_PP_REPEAT(LUABIND_MAX_BASES, LUABIND_GEN_BASE_INFO, _)
1189                 }
1190
1191 #undef LUABIND_GEN_BASE_INFO
1192
1193                 // this is the internal version of def() it is run from both overloads
1194                 // of def. It has two versions, one where a contstructor is registered
1195                 // and one where a function is registered
1196                 template<class Policies>
1197                 struct internal_def_s
1198                 {
1199                         template<class F>
1200                         static void apply(const char* name, F f, detail::class_base* c)
1201                         {
1202 //                              std::cout << "HeldType2: " << typeid(HeldType).name() << "\n";
1203
1204                                 detail::overload_rep o(f, static_cast<Policies*>(0));
1205
1206                                 typedef LUABIND_MSVC_TYPENAME detail::function_callback_s<HeldType,T,F,Policies>::type call_t;
1207
1208                                 o.set_match_fun(&detail::match_function_callback_s<T,F,Policies>::apply);
1209                                 o.call_fun = boost::bind<int>(call_t(f), _1, _2);
1210
1211 #ifndef LUABIND_NO_ERROR_CHECKING
1212
1213                                 o.set_sig_fun(&detail::get_member_signature<F>::apply);
1214
1215 #endif
1216
1217                                 c->add_method(name, o);
1218                         }
1219
1220                         template<BOOST_PP_ENUM_PARAMS(LUABIND_MAX_ARITY, class A)>
1221                         static void apply(constructor<BOOST_PP_ENUM_PARAMS(LUABIND_MAX_ARITY, A)>, detail::class_base* c)
1222                         {
1223 //                              std::cout << "HeldType2: " << typeid(HeldType).name() << "\n";
1224
1225                                 detail::construct_rep::overload_t o;
1226
1227                                 o.set_constructor(
1228                                         &detail::construct_class<
1229                                                  T
1230                                                 ,Policies
1231                                                 ,constructor<BOOST_PP_ENUM_PARAMS(LUABIND_MAX_ARITY, A)>
1232                                         >::apply
1233                                 );
1234
1235                                 // if we have a WrappedType, we have to register it's constructor
1236                                 // but if it's null_type (no WrappedType) we should not register it
1237                                 detail::register_wrapped_type<WrappedType>::apply(o,
1238                                                 static_cast<const constructor<BOOST_PP_ENUM_PARAMS(LUABIND_MAX_ARITY, A)>*>(0),
1239                                                 static_cast<const Policies*>(0));
1240
1241
1242                                 o.set_match_fun(
1243                                         &detail::constructor_match<
1244                                                  constructor<BOOST_PP_ENUM_PARAMS(LUABIND_MAX_ARITY, A)>
1245                                                 ,2
1246                                                 ,Policies
1247                                         >::apply);
1248
1249 #ifndef LUABIND_NO_ERROR_CHECKING
1250
1251                                 o.set_sig_fun(&detail::get_signature<constructor<BOOST_PP_ENUM_PARAMS(LUABIND_MAX_ARITY, A)> >::apply);
1252
1253 #endif
1254
1255                                 typedef constructor<BOOST_PP_ENUM_PARAMS(LUABIND_MAX_ARITY, A)> con_t;
1256
1257                                 o.set_arity(detail::calc_arity<con_t::arity>::apply(con_t(), static_cast<Policies*>(0)));
1258
1259                                 c->add_constructor(o);
1260                         }
1261                 };
1262
1263                 class_(lua_State* L, const char* name): class_base(name), m_L(L) { init(); }
1264                 class_(const char* name): class_base(name), m_L(0) { init(); }
1265
1266                 ~class_()
1267                 {
1268         /*              if (m_L != 0)
1269                         {
1270                                 scope::init(m_L);
1271                                 lua_pushvalue(m_L, LUA_GLOBALSINDEX);
1272                                 scope_stack::push(m_L);
1273                                 commit(m_L);
1274                                 scope_stack::pop(m_L);
1275                         }*/
1276                 }
1277
1278                 template<class F>
1279                 class_& def(const char* name, F f)
1280                 {
1281                         internal_def_s<detail::null_type>::apply(name, f, this);
1282                         return *this;
1283                 }
1284
1285                 template<class F, class Policies>
1286                 class_& def(const char* name, F f, const Policies&)
1287                 {
1288                         internal_def_s<Policies>::apply(name, f, this);
1289                         return *this;
1290                 }
1291
1292                 template<BOOST_PP_ENUM_PARAMS(LUABIND_MAX_ARITY, class A)>
1293                 class_& def(constructor<BOOST_PP_ENUM_PARAMS(LUABIND_MAX_ARITY, A)> sig)
1294                 {
1295                         internal_def_s<detail::null_type>::apply(sig, this);
1296                         return *this;
1297                 }
1298
1299                 template<BOOST_PP_ENUM_PARAMS(LUABIND_MAX_ARITY, class A), class Policies>
1300                 class_& def(constructor<BOOST_PP_ENUM_PARAMS(LUABIND_MAX_ARITY, A)> sig, const Policies& policies)
1301                 {
1302                         internal_def_s<Policies>::apply(sig, this);
1303                         return *this;
1304                 }
1305
1306                 template<class Getter>
1307                 class_& property(const char* name, Getter g)
1308                 {
1309                         add_getter(name, boost::bind<int>(detail::get_caller<T, Getter, detail::null_type>(), _1, _2, g));
1310                         return *this;
1311                 }
1312
1313                 template<class Getter, class MaybeSetter>
1314                 class_& property(const char* name, Getter g, MaybeSetter s)
1315                 {
1316                         return property_impl(name, g, s, boost::mpl::bool_<detail::is_policy_cons<MaybeSetter>::value>());
1317                 }
1318
1319                 template<class Getter, class Setter, class GetPolicies>
1320                 class_& property(const char* name, Getter g, Setter s, const GetPolicies& get_policies)
1321                 {
1322                         add_getter(name, boost::bind<int>(detail::get_caller<T, Getter, GetPolicies>(get_policies), _1, _2, g));
1323                         add_setter(name, boost::bind<int>(detail::set_caller<T, Setter, detail::null_type>(), _1, _2, s));
1324                         return *this;
1325                 }
1326
1327                 template<class Getter, class Setter, class GetPolicies, class SetPolicies>
1328                 class_& property(const char* name
1329                                                                         , Getter g, Setter s
1330                                                                         , const GetPolicies& get_policies
1331                                                                         , const SetPolicies& set_policies)
1332                 {
1333                         add_getter(name, boost::bind<int>(detail::get_caller<T, Getter, GetPolicies>(get_policies), _1, _2, g));
1334                         add_setter(name, boost::bind<int>(detail::set_caller<T, Setter, GetPolicies>(set_policies), _1, _2, s));
1335                         return *this;
1336                 }
1337
1338                 template<class D>
1339                 class_& def_readonly(const char* name, D T::*member_ptr)
1340                 {
1341                         add_getter(name, boost::bind<int>(detail::auto_get<T,D,detail::null_type>(), _1, _2, member_ptr));
1342                         return *this;
1343                 }
1344
1345                 template<class D, class Policies>
1346                 class_& def_readonly(const char* name, D T::*member_ptr, const Policies& policies)
1347                 {
1348                         add_getter(name, boost::bind<int>(detail::auto_get<T,D,Policies>(policies), _1, _2, member_ptr));
1349                         return *this;
1350                 }
1351
1352                 template<class D>
1353                 class_& def_readwrite(const char* name, D T::*member_ptr)
1354                 {
1355                         add_getter(name, boost::bind<int>(detail::auto_get<T,D,detail::null_type>(), _1, _2, member_ptr));
1356                         add_setter(name, boost::bind<int>(detail::auto_set<T,D,detail::null_type>(), _1, _2, member_ptr));
1357                         return *this;
1358                 }
1359
1360                 template<class D, class GetPolicies>
1361                 class_& def_readwrite(const char* name, D T::*member_ptr, const GetPolicies& get_policies)
1362                 {
1363                         add_getter(name, boost::bind<int>(detail::auto_get<T,D,GetPolicies>(get_policies), _1, _2, member_ptr));
1364                         add_setter(name, boost::bind<int>(detail::auto_set<T,D,detail::null_type>(), _1, _2, member_ptr));
1365                         return *this;
1366                 }
1367
1368                 template<class D, class GetPolicies, class SetPolicies>
1369                 class_& def_readwrite(const char* name, D T::*member_ptr, const GetPolicies& get_policies, const SetPolicies& set_policies)
1370                 {
1371                         add_getter(name, boost::bind<int>(detail::auto_get<T,D,GetPolicies>(get_policies), _1, _2, member_ptr));
1372                         add_setter(name, boost::bind<int>(detail::auto_set<T,D,SetPolicies>(set_policies), _1, _2, member_ptr));
1373                         return *this;
1374                 }
1375
1376                 template<class op_id, class Left, class Right, class Policies>
1377                 class_& def(detail::operator_<op_id, Left, Right>, const Policies& policies)
1378                 {
1379                         typedef typename detail::operator_unwrapper<Policies, op_id, T, Left, Right> op_type;
1380 #ifndef LUABIND_NO_ERROR_CHECKING
1381                         add_operator(op_type::get_id()
1382                                                                         , &op_type::execute
1383                                                                         , &op_type::match
1384                                                                         , &detail::get_signature<constructor<typename op_type::left_t, typename op_type::right_t> >::apply
1385                                                                         , detail::is_unary(op_type::get_id()) ? 1 : 2);
1386 #else
1387                         add_operator(op_type::get_id()
1388                                                                         , &op_type::execute
1389                                                                         , &op_type::match
1390                                                                         , detail::is_unary(op_type::get_id()) ? 1 : 2);
1391 #endif
1392                         return *this;
1393                 }
1394
1395                 template<class op_id, class Left, class Right>
1396                 class_& def(detail::operator_<op_id, Left, Right>)
1397                 {
1398                         typedef typename detail::operator_unwrapper<detail::null_type, op_id, T, Left, Right> op_type;
1399
1400 #ifndef LUABIND_NO_ERROR_CHECKING
1401                         add_operator(op_type::get_id()
1402                                                                         , &op_type::execute
1403                                                                         , &op_type::match
1404                                                                         , &detail::get_signature<constructor<LUABIND_MSVC_TYPENAME op_type::left_t, LUABIND_MSVC_TYPENAME op_type::right_t> >::apply
1405                                                                         , detail::is_unary(op_type::get_id()) ? 1 : 2);
1406 #else
1407                         add_operator(op_type::get_id()
1408                                                                         , &op_type::execute
1409                                                                         , &op_type::match
1410                                                                         , detail::is_unary(op_type::get_id()) ? 1 : 2);
1411 #endif
1412                         return *this;
1413                 }
1414
1415                 template<class Signature, bool Constant>
1416                 class_& def(detail::application_operator<Signature, Constant>*)
1417                 {
1418                         typedef detail::application_operator<Signature, Constant, detail::null_type> op_t;
1419
1420                         int arity = detail::calc_arity<Signature::arity>::apply(Signature(), static_cast<detail::null_type*>(0));
1421
1422 #ifndef LUABIND_NO_ERROR_CHECKING
1423                         add_operator(detail::op_call, &op_t::template apply<T>::execute, &op_t::match, &detail::get_signature<Signature>::apply, arity + 1);
1424 #else
1425                         add_operator(detail::op_call, &op_t::template apply<T>::execute, &op_t::match, arity + 1);
1426 #endif
1427
1428                         return *this;
1429                 }
1430
1431                 template<class Signature, bool Constant, class Policies>
1432                 class_& def(detail::application_operator<Signature, Constant>*, const Policies& policies)
1433                 {
1434                         typedef detail::application_operator<Signature, Constant, Policies> op_t;
1435
1436                         int arity = detail::calc_arity<Signature::arity>::apply(Signature(), static_cast<Policies*>(0));
1437
1438 #ifndef LUABIND_NO_ERROR_CHECKING
1439                         add_operator(detail::op_call, &op_t::template apply<T>::execute, &op_t::match, &detail::get_signature<Signature>::apply, arity + 1);
1440 #else
1441                         add_operator(detail::op_call, &op_t::template apply<T>::execute, &op_t::match, arity + 1);
1442 #endif
1443
1444                         return *this;
1445                 }
1446
1447                 detail::enum_maker<self_t> enum_(const char*)
1448                 {
1449                         return detail::enum_maker<self_t>(*this);
1450                 }
1451
1452         private:
1453
1454                 void init()
1455                 {
1456                         typedef typename detail::extract_parameter<
1457                                         boost::mpl::list3<X1,X2,X3>
1458                                 ,       boost::mpl::or_<
1459                                                         detail::is_bases<boost::mpl::_>
1460                                                 ,       boost::is_base_and_derived<boost::mpl::_, T>
1461                                         >
1462                                 ,       no_bases
1463                         >::type bases_t;
1464
1465                         typedef typename
1466                                 boost::mpl::if_<detail::is_bases<bases_t>
1467                                         ,       bases_t
1468                                         ,       bases<bases_t>
1469                                 >::type Base;
1470
1471                         class_base::init(LUABIND_TYPEID(T)
1472                                 , detail::internal_holder_type<HeldType>::apply()
1473                                 , detail::pointee_typeid(
1474                                         get_const_holder(static_cast<HeldType*>(0)))
1475                                 , detail::internal_holder_extractor<HeldType>::apply(detail::type<T>())
1476                                 , detail::internal_const_holder_extractor<HeldType>::apply(detail::type<T>())
1477                                 , detail::const_converter<HeldType>::apply(
1478                                         luabind::get_const_holder((HeldType*)0))
1479                                 , detail::holder_constructor<HeldType>::apply(detail::type<T>())
1480                                 , detail::const_holder_constructor<HeldType>::apply(detail::type<T>())
1481                                 , detail::internal_holder_destructor<HeldType>::apply(detail::type<T>())
1482                                 , detail::internal_const_holder_destructor<HeldType>::apply(detail::type<T>())
1483                                 , detail::internal_holder_size<HeldType>::apply()
1484                                 , detail::get_holder_alignment<HeldType>::apply());
1485
1486                         generate_baseclass_list(detail::type<Base>());
1487                 }
1488
1489                 template<class Getter, class GetPolicies>
1490                 class_& property_impl(const char* name,
1491                                                                          Getter g,
1492                                                                          GetPolicies policies,
1493                                                                          boost::mpl::bool_<true>)
1494                 {
1495                         add_getter(name, boost::bind<int>(detail::get_caller<T,Getter,GetPolicies>(policies), _1, _2, g));
1496                         return *this;
1497                 }
1498
1499                 template<class Getter, class Setter>
1500                 class_& property_impl(const char* name,
1501                                                                          Getter g,
1502                                                                          Setter s,
1503                                                                          boost::mpl::bool_<false>)
1504                 {
1505                         add_getter(name, boost::bind<int>(detail::get_caller<T,Getter,detail::null_type>(), _1, _2, g));
1506                         add_setter(name, boost::bind<int>(detail::set_caller<T,Setter,detail::null_type>(), _1, _2, s));
1507                         return *this;
1508                 }
1509
1510         };
1511 }
1512
1513 #endif // LUABIND_CLASS_HPP_INCLUDED
1514