luabind/object.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 #if !BOOST_PP_IS_ITERATING
  24
  25 #ifndef LUABIND_OBJECT_HPP_INCLUDED
  26 #define LUABIND_OBJECT_HPP_INCLUDED
  27
  28 #include <iterator>
  29
  30 #include <luabind/prefix.hpp>
  31 #include <luabind/config.hpp>
  32 #include <luabind/error.hpp>
  33 #include <luabind/detail/pcall.hpp>
  34
  35 #include <boost/preprocessor/repeat.hpp>
  36 #include <boost/preprocessor/iteration/iterate.hpp>
  37 #include <boost/preprocessor/repetition/enum.hpp>
  38 #include <boost/preprocessor/repetition/enum_params.hpp>
  39 #include <boost/preprocessor/repetition/enum_binary_params.hpp>
  40 #include <boost/tuple/tuple.hpp>
  41
  42 namespace luabind
  43 {
  44         class object;
  45
  46         namespace detail
  47         {
  48                 class proxy_object;
  49                 class proxy_raw_object;
  50                 class proxy_array_object;
  51
  52                 template<class T>
  53                 void convert_to_lua(lua_State*, const T&);
  54
  55                 template<int Index, class T, class Policies>
  56                 void convert_to_lua_p(lua_State*, const T&, const Policies&);
  57
  58                 template<int Index>
  59                 struct push_args_from_tuple
  60                 {
  61                         template<class H, class T, class Policies>
  62                         inline static void apply(lua_State* L, const boost::tuples::cons<H, T>& x, const Policies& p)
  63                         {
  64                                 convert_to_lua_p<Index>(L, *x.get_head(), p);
  65                                 push_args_from_tuple<Index+1>::apply(L, x.get_tail(), p);
  66                         }
  67
  68                         template<class H, class T>
  69                         inline static void apply(lua_State* L, const boost::tuples::cons<H, T>& x)
  70                         {
  71                                 convert_to_lua(L, *x.get_head());
  72                                 push_args_from_tuple<Index+1>::apply(L, x.get_tail());
  73                         }
  74
  75                         template<class Policies>
  76                         inline static void apply(lua_State*, const boost::tuples::null_type&, const Policies&) {};
  77
  78                         inline static void apply(lua_State*, const boost::tuples::null_type&) {};
  79
  80                 };
  81
  82                 template<class Tuple>
  83                 class proxy_caller
  84                 {
  85                 friend class luabind::object;
  86                 public:
  87
  88                         proxy_caller(luabind::object* o, const Tuple args)
  89                                 : m_obj(o)
  90                                 , m_args(args)
  91                                 , m_called(false)
  92                         {
  93                         }
  94
  95                         proxy_caller(const detail::proxy_caller<Tuple>& rhs)
  96                                 : m_obj(rhs.m_obj)
  97                                 , m_args(rhs.m_args)
  98                                 , m_called(rhs.m_called)
  99                         {
 100                                 rhs.m_called = true;
 101                         }
 102
 103                         ~proxy_caller();
 104                         operator luabind::object();
 105
 106 #if defined(BOOST_MSVC) && (BOOST_MSVC <= 1300)
 107         #define LUABIND_SEMICOLON
 108 #else
 109         #define LUABIND_SEMICOLON ;
 110 #endif
 111
 112                         template<class Policies>
 113                         luabind::object operator[](const Policies& p) LUABIND_SEMICOLON
 114 #if defined(BOOST_MSVC) && (BOOST_MSVC <= 1300)
 115                         {
 116                                 m_called = true;
 117                                 lua_State* L = m_obj->lua_state();
 118                                 m_obj->pushvalue();
 119                                 detail::push_args_from_tuple<1>::apply(L, m_args, p);
 120                                 if (pcall(L, boost::tuples::length<Tuple>::value, 1))
 121                                 {
 122 #ifndef LUABIND_NO_EXCEPTIONS
 123                                         throw error(L);
 124 #else
 125                                         error_callback_fun e = get_error_callback();
 126                                         if (e) e(L);
 127
 128                                         assert(0 && "the lua function threw an error and exceptions are disabled."
 129                                                 "if you want to handle this error use luabind::set_error_callback()");
 130                                         std::terminate();
 131 #endif
 132                                 }
 133                                 detail::lua_reference ref;
 134                                 ref.set(L);
 135                                 return luabind::object(m_obj->lua_state(), ref, true/*luabind::object::reference()*/);
 136                         }
 137 #endif
 138
 139
 140 #undef LUABIND_SEMICOLON
 141                 private:
 142
 143                         luabind::object* m_obj;
 144                         Tuple m_args;
 145                         mutable bool m_called;
 146
 147                 };
 148
 149
 150
 151                 struct stack_pop
 152                 {
 153                         stack_pop(lua_State* L, int n)
 154                                 : m_state(L)
 155                                 , m_n(n)
 156                                 {
 157                                 }
 158
 159                         ~stack_pop()
 160                         {
 161                                 lua_pop(m_state, m_n);
 162                         }
 163
 164                 private:
 165
 166                         lua_State* m_state;
 167                         int m_n;
 168                 };
 169
 170                 struct reset_stack
 171                 {
 172                         reset_stack(lua_State* L_, int offset = 0)
 173                                 : L(L_)
 174                                 , stack_size(lua_gettop(L_) - offset)
 175                         {}
 176
 177                         ~reset_stack()
 178                         {
 179                                 assert(lua_gettop(L) >= stack_size);
 180                                 lua_pop(L, lua_gettop(L) - stack_size);
 181                         }
 182                         lua_State* L;
 183                         int stack_size;
 184                 };
 185
 186
 187                 class LUABIND_API proxy_object
 188                 {
 189                 friend class luabind::object;
 190                 friend class luabind::detail::proxy_array_object;
 191                 friend class luabind::detail::proxy_raw_object;
 192 //              template<class T> friend T object_cast(const proxy_object& obj);
 193                 public:
 194
 195                         template<class T>
 196                         proxy_object& operator=(const T& val)
 197                         {
 198                                 //std::cout << "proxy assigment\n";
 199                                 lua_State* L = m_obj->m_state;
 200                                 m_obj->pushvalue();
 201                                 m_key.get(L);
 202                                 detail::convert_to_lua(L, val);
 203                                 lua_settable(L, -3);
 204                                 // pop table
 205                                 lua_pop(L, 1);
 206                                 return *this;
 207                         }
 208
 209                         template<class T, class Policies>
 210                         void assign(const T& val, const Policies& p)
 211                         {
 212                                 //std::cout << "proxy assigment\n";
 213                                 lua_State* L = m_obj->m_state;
 214                                 m_obj->pushvalue();
 215                                 detail::getref(L, m_key_ref);
 216                                 detail::convert_to_lua_p(L, val, p);
 217                                 lua_settable(L, -3);
 218                                 // pop table
 219                                 lua_pop(L, 1);
 220                                 return *this;
 221                         }
 222
 223                         template<class T>
 224                         detail::proxy_object operator[](const T& key) const;
 225
 226                         proxy_object& operator=(const object& p);
 227                         proxy_object& operator=(const proxy_object& p);
 228                         proxy_object& operator=(const proxy_raw_object& p);
 229                         proxy_object& operator=(const proxy_array_object& p);
 230
 231                         void swap(const proxy_object& rhs);
 232                         proxy_object* operator->()
 233                         { return this; }
 234
 235                         operator luabind::object();
 236
 237                         int type() const
 238                         {
 239                                 pushvalue();
 240                                 detail::stack_pop p(lua_state(), 1);
 241                                 return lua_type(lua_state(), -1);
 242                         }
 243
 244 #define LUABIND_PROXY_RAW_AT_BODY                                                                                       \
 245                         {                                                                                                                                                                                                               \
 246                                 lua_State* L = lua_state();\
 247                                 pushvalue();\
 248                                 detail::convert_to_lua(L, key);\
 249                                 lua_rawget(L, -2);\
 250                                 detail::lua_reference ref;\
 251                                 ref.set(L);\
 252                                 lua_pop(L, 1);\
 253                                 return object(L, ref, true);\
 254                         }
 255
 256 #if defined(BOOST_MSVC) && (BOOST_MSVC <= 1300)
 257                         template<class T>
 258                         inline object raw_at(const T& key)
 259                         LUABIND_PROXY_RAW_AT_BODY
 260 #else
 261                         template<class T>
 262                         inline object raw_at(const T& key);
 263 #endif
 264
 265 #define LUABIND_PROXY_AT_BODY \
 266                         {\
 267                                 lua_State* L = lua_state();\
 268                                 pushvalue();\
 269                                 detail::convert_to_lua(L, key);\
 270                                 lua_gettable(L, -2);\
 271                                 detail::lua_reference ref;\
 272                                 ref.set(L);\
 273                                 lua_pop(L, 1);\
 274                                 return object(L, ref, true);\
 275                         }
 276
 277 #if defined(BOOST_MSVC) && (BOOST_MSVC <= 1300)
 278                         template<class T>
 279                         inline object at(const T& key)
 280                         LUABIND_PROXY_AT_BODY
 281 #else
 282                         template<class T>
 283                         inline object at(const T& key);
 284 #endif
 285
 286                         inline bool is_valid() const { return true; }
 287                         lua_State* lua_state() const;
 288                         void pushvalue() const;
 289                         void set() const;
 290
 291                         // this is a safe substitute for an implicit converter to bool
 292                         typedef void (proxy_object::*member_ptr)() const;
 293                         operator member_ptr() const
 294                         {
 295                                 if (is_valid()) return &proxy_object::dummy;
 296                                 return 0;
 297                         }
 298
 299                 private:
 300
 301                         void dummy() const {}
 302
 303                         proxy_object(luabind::object* o, const lua_reference& key)
 304                                 : m_obj(o)
 305                                 , m_key(key)
 306                         {
 307                         }
 308
 309                         luabind::object* m_obj;
 310                         detail::lua_reference m_key;
 311                 };
 312
 313
 314
 315                 class LUABIND_API proxy_raw_object
 316                 {
 317                 friend class luabind::object;
 318                 friend class luabind::detail::proxy_array_object;
 319                 friend class luabind::detail::proxy_object;
 320 //              template<class T> friend T luabind::object_cast(const proxy_object& obj);
 321                 public:
 322
 323                         template<class T>
 324                         proxy_raw_object& operator=(const T& val)
 325                         {
 326                                 //std::cout << "proxy assigment\n";
 327                                 lua_State* L = m_obj->m_state;
 328                                 m_obj->pushvalue();
 329                                 detail::getref(L, m_key_ref);
 330                                 detail::convert_to_lua(L, val);
 331                                 lua_rawset(L, -3);
 332                                 // pop table
 333                                 lua_pop(L, 1);
 334                                 return *this;
 335                         }
 336
 337                         template<class T, class Policies>
 338                         void assign(const T& val, const Policies& p)
 339                         {
 340                                 //std::cout << "proxy assigment\n";
 341                                 lua_State* L = m_obj->m_state;
 342                                 m_obj->pushvalue();
 343                                 detail::getref(L, m_key_ref);
 344                                 detail::convert_to_lua_p(L, val, p);
 345                                 lua_settable(L, -3);
 346                                 // pop table
 347                                 lua_pop(L, 1);
 348                                 return *this;
 349                         }
 350
 351                         proxy_raw_object& operator=(const object& p);
 352                         proxy_raw_object& operator=(const proxy_object& p);
 353                         proxy_raw_object& operator=(const proxy_raw_object& p);
 354                         proxy_raw_object& operator=(const proxy_array_object& p);
 355                         void swap(const proxy_raw_object& rhs);
 356                         proxy_raw_object* operator->()
 357                         { return this; }
 358
 359                         operator luabind::object();
 360
 361                         int type() const
 362                         {
 363                                 pushvalue();
 364                                 detail::stack_pop p(lua_state(), 1);
 365                                 return lua_type(lua_state(), -1);
 366                         }
 367
 368 #if defined(BOOST_MSVC) && (BOOST_MSVC <= 1300)
 369                         template<class T>
 370                         inline object raw_at(const T& key)
 371                         LUABIND_PROXY_RAW_AT_BODY
 372 #else
 373                         template<class T>
 374                         inline object raw_at(const T& key);
 375 #endif
 376
 377 #if defined(BOOST_MSVC) && (BOOST_MSVC <= 1300)
 378                         template<class T>
 379                         inline object at(const T& key)
 380                         LUABIND_PROXY_AT_BODY
 381 #else
 382                         template<class T>
 383                         inline object at(const T& key);
 384 #endif
 385
 386                         inline bool is_valid() const { return true; }
 387                         lua_State* lua_state() const;
 388                         void pushvalue() const;
 389                         void set() const;
 390
 391                         // this is a safe substitute for an implicit converter to bool
 392                         typedef void (proxy_raw_object::*member_ptr)() const;
 393                         operator member_ptr() const
 394                         {
 395                                 if (is_valid()) return &proxy_raw_object::dummy;
 396                                 return 0;
 397                         }
 398
 399
 400                 private:
 401
 402                         void dummy() const {}
 403
 404                         proxy_raw_object(luabind::object* o, const lua_reference& key)
 405                                 : m_obj(o)
 406                                 , m_key(key)
 407                         {
 408                         }
 409
 410                         luabind::object* m_obj;
 411                         detail::lua_reference m_key;
 412                 };
 413
 414
 415
 416                 class LUABIND_API proxy_array_object
 417                 {
 418                 friend class luabind::object;
 419                 friend class luabind::detail::proxy_object;
 420                 friend class luabind::detail::proxy_raw_object;
 421 //              template<class T> friend T object_cast(const proxy_array_object& obj);
 422                 public:
 423
 424                         template<class T>
 425                         proxy_array_object& operator=(const T& val)
 426                         {
 427                                 //std::cout << "array proxy assigment\n";
 428                                 lua_State* L = m_obj->m_state;
 429                                 m_obj->pushvalue();
 430                                 detail::convert_to_lua(L, val);
 431                                 lua_rawseti(L, -2, m_key);
 432
 433                                 // pops the table
 434                                 lua_pop(L, 1);
 435                                 return *this;
 436                         }
 437
 438                         template<class T, class Policies>
 439                         void assign(const T& val, const Policies& p)
 440                         {
 441                                 //std::cout << "proxy assigment\n";
 442                                 lua_State* L = m_obj->m_state;
 443                                 m_obj->pushvalue();
 444                                 detail::convert_to_lua_p(L, val, p);
 445                                 lua_rawseti(L, -2, m_key);
 446                                 // pop table
 447                                 lua_pop(L, 1);
 448                                 return *this;
 449                         }
 450
 451                         proxy_array_object& operator=(const object& p);
 452                         proxy_array_object& operator=(const proxy_object& p);
 453                         proxy_array_object& operator=(const proxy_raw_object& p);
 454                         proxy_array_object& operator=(const proxy_array_object& p);
 455                         void swap(const proxy_array_object& rhs);
 456
 457                         proxy_array_object* operator->()
 458                         { return this; }
 459                         operator luabind::object();
 460
 461                         int type() const
 462                         {
 463                                 pushvalue();
 464                                 detail::stack_pop p(lua_state(), 1);
 465                                 return lua_type(lua_state(), -1);
 466                         }
 467
 468 #define LUABIND_PROXY_ARRAY_RAW_AT_BODY\
 469                         {\
 470                                 pushvalue();\
 471                                 detail::convert_to_lua(m_state, key);\
 472                                 lua_rawget(m_state, -2);\
 473                                 lua_reference ref;\
 474                                 ref.set(m_state);\
 475                                 lua_pop(m_state, 1);\
 476                                 return object(m_state, ref, true);\
 477                         }
 478
 479 #define LUABIND_PROXY_ARRAY_AT_BODY\
 480                         {\
 481                                 pushvalue();\
 482                                 detail::convert_to_lua(m_state, key);\
 483                                 lua_gettable(m_state, -2);\
 484                                 lua_reference ref;\
 485                                 ref.set(m_state);\
 486                                 lua_pop(m_state, 1);\
 487                                 return object(m_state, ref, true);\
 488                         }
 489
 490 #if defined(BOOST_MSVC) && (BOOST_MSVC <= 1300)
 491                         template<class T>
 492                         inline object at(const T& key)
 493                         LUABIND_PROXY_ARRAY_AT_BODY
 494 #else
 495                         template<class T>
 496                         inline object at(const T& key);
 497 #endif
 498
 499
 500 #if defined(BOOST_MSVC) && (BOOST_MSVC <= 1300)
 501                         template<class T>
 502                         inline object raw_at(const T& key)
 503                         LUABIND_PROXY_ARRAY_RAW_AT_BODY
 504 #else
 505                         template<class T>
 506                         inline object raw_at(const T& key);
 507 #endif
 508
 509                         inline bool is_valid() const { return true; }
 510                         lua_State* lua_state() const;
 511                         void pushvalue() const;
 512                         void set() const;
 513
 514                         // this is a safe substitute for an implicit converter to bool
 515                         typedef void (proxy_array_object::*member_ptr)() const;
 516                         operator member_ptr() const
 517                         {
 518                                 if (is_valid()) return &proxy_array_object::dummy;
 519                                 return 0;
 520                         }
 521
 522                 private:
 523
 524                         void dummy() const {}
 525
 526                         proxy_array_object(luabind::object* o, int key)
 527                                 : m_obj(o)
 528                                 , m_key(key)
 529                         {}
 530                         luabind::object* m_obj;
 531                         int m_key;
 532                 };
 533
 534                 template<class T>
 535                 struct primitive_converter;
 536
 537                 struct tuple_object_ref;
 538
 539         } // detail
 540
 541         class LUABIND_API object
 542         {
 543
 544 #if !(defined (BOOST_MSVC) && (BOOST_MSVC <= 1200))
 545
 546         template<class T>
 547         friend T object_cast(const object& obj);
 548         template<class T>
 549         friend struct detail::primitive_converter;
 550
 551 #endif
 552
 553         friend object get_globals(lua_State*);
 554         friend object get_registry(lua_State*);
 555         friend object newtable(lua_State*);
 556         friend class detail::proxy_object;
 557         friend class detail::proxy_array_object;
 558         friend class detail::proxy_raw_object;
 559
 560         public:
 561
 562                 class array_iterator
 563                 {
 564                 friend class object;
 565                 public:
 566
 567                         typedef std::forward_iterator_tag iterator_category;
 568                         typedef luabind::object value_type;
 569                         typedef value_type& reference;
 570                         typedef value_type* pointer;
 571                         typedef void difference_type;
 572
 573                         array_iterator()
 574                                 : m_obj(0)
 575                                 , m_key(0)
 576                         {
 577                         }
 578
 579                         array_iterator(const array_iterator& iter)
 580                                 : m_obj(iter.m_obj)
 581                                 , m_key(iter.m_key)
 582                         {
 583                         }
 584
 585                         ~array_iterator() {}
 586
 587                         array_iterator& operator=(const array_iterator& rhs)
 588                         {
 589                                 m_obj = rhs.m_obj;
 590                                 m_key = rhs.m_key;
 591                                 return *this;
 592                         }
 593
 594                         detail::proxy_array_object operator*()
 595                         {
 596                                 return m_obj->make_array_proxy(m_key);
 597                         }
 598
 599                         detail::proxy_array_object operator->()
 600                         {
 601                                 return m_obj->make_array_proxy(m_key);
 602                         }
 603
 604                         inline array_iterator& operator++()
 605                         {
 606                                 LUABIND_CHECK_STACK(m_obj->lua_state());
 607
 608                                 m_key++;
 609
 610                                 // invalidate the iterator if we hit a nil element
 611                                 lua_State* L = m_obj->lua_state();
 612                                 m_obj->pushvalue();
 613                                 lua_rawgeti(L, -1, m_key);
 614                                 if (lua_isnil(L, -1)) m_key = -1;
 615                                 lua_pop(L, 2);
 616
 617                                 return *this;
 618                         }
 619
 620                         inline array_iterator operator++(int)
 621                         {
 622                                 LUABIND_CHECK_STACK(m_obj->lua_state());
 623
 624                                 int old_key = m_key;
 625                                 m_key++;
 626
 627                                 // invalidate the iterator if we hit a nil element
 628                                 lua_State* L = m_obj->lua_state();
 629                                 m_obj->pushvalue();
 630                                 lua_rawgeti(L, -1, m_key);
 631                                 if (lua_isnil(L, -1)) m_key = -1;
 632                                 lua_pop(L, 2);
 633
 634                                 return array_iterator(m_obj, old_key);
 635                         }
 636
 637                         bool operator!=(const array_iterator& rhs) const
 638                         {
 639                                 return m_obj != rhs.m_obj || m_key != rhs.m_key;
 640                         }
 641
 642                 private:
 643
 644                         array_iterator(object* obj, int key)
 645                                 : m_obj(obj)
 646                                 , m_key(key)
 647                         {
 648                         }
 649
 650                         object* m_obj;
 651                         int m_key;
 652                 };
 653
 654
 655
 656
 657
 658
 659                 class iterator
 660                 {
 661                 friend class object;
 662                 public:
 663
 664                         typedef std::forward_iterator_tag iterator_category;
 665                         typedef luabind::object value_type;
 666                         typedef value_type& reference;
 667                         typedef value_type* pointer;
 668                         typedef void difference_type;
 669
 670                         iterator()
 671                                 : m_obj(0)
 672                         {
 673                         }
 674
 675                         iterator(const iterator& iter)
 676                                 : m_obj(iter.m_obj)
 677                         {
 678                                 if (m_obj)
 679                                 {
 680                                         m_key = iter.m_key;
 681                                 }
 682                         }
 683
 684                         iterator& operator=(const iterator& rhs)
 685                         {
 686                                 m_obj = rhs.m_obj;
 687                                 if (m_obj)
 688                                 {
 689                                         m_key = rhs.m_key;
 690                                 }
 691                                 else
 692                                 {
 693                                         m_key.reset();
 694                                 }
 695                                 return *this;
 696                         }
 697
 698                         detail::proxy_object operator*()
 699                         {
 700                                 return m_obj->make_proxy(m_key);
 701                         }
 702
 703                         detail::proxy_object operator->()
 704                         {
 705                                 return m_obj->make_proxy(m_key);
 706                         }
 707
 708                         iterator& operator++()
 709                         {
 710                                 lua_State* L = m_obj->lua_state();
 711
 712                                 int n = lua_gettop(L);
 713
 714                                 m_obj->pushvalue();
 715                                 m_key.get(L);
 716
 717                                 if (lua_next(L, -2) != 0)
 718                                 {
 719                                         lua_pop(L, 1);
 720                                         m_key.replace(L);
 721                                         lua_pop(L, 1);
 722                                 }
 723                                 else
 724                                 {
 725                                         lua_pop(L, 1);
 726                                         m_obj = 0;
 727                                         m_key.reset();
 728                                 }
 729
 730                                 assert(n == lua_gettop(L));
 731                                 return *this;
 732                         }
 733
 734                         bool operator!=(const iterator& rhs) const
 735                         {
 736                                 if (m_obj != rhs.m_obj) return true;
 737                                 if (m_obj == 0) return false;
 738                                 if (m_obj->lua_state() != rhs.m_obj->lua_state()) return true;
 739                                 if (m_key.is_valid() != rhs.m_key.is_valid()) return true;
 740
 741                                 // TODO: fix this. add a real equality test of the keys
 742                                 return true;
 743                         }
 744
 745                         object key() const;
 746
 747                 private:
 748
 749                         iterator(luabind::object* obj, detail::lua_reference const& key)
 750                                 : m_obj(obj)
 751                                 , m_key(key)
 752                         {
 753                         }
 754
 755                         object* m_obj;
 756                         detail::lua_reference m_key;
 757                 };
 758
 759
 760
 761
 762                 class raw_iterator
 763                 {
 764                 friend class object;
 765                 public:
 766
 767                         typedef std::forward_iterator_tag iterator_category;
 768                         typedef luabind::object value_type;
 769                         typedef value_type& reference;
 770                         typedef value_type* pointer;
 771                         typedef void difference_type;
 772
 773                         raw_iterator()
 774                                 : m_obj(0)
 775                         {
 776                         }
 777
 778                         raw_iterator(const raw_iterator& iter)
 779                                 : m_obj(iter.m_obj)
 780                                 , m_key()
 781                         {
 782                                 if (m_obj)
 783                                 {
 784                                         m_key = iter.m_key;
 785                                 }
 786                         }
 787
 788                         raw_iterator& operator=(const raw_iterator& rhs)
 789                         {
 790                                 //std::cout << "===\n";
 791                                 m_obj = rhs.m_obj;
 792                                 if (m_obj)
 793                                 {
 794                                         m_key = rhs.m_key;
 795                                 }
 796                                 else
 797                                 {
 798                                         m_key.reset();
 799                                 }
 800                                 return *this;
 801                         }
 802
 803                         detail::proxy_raw_object operator*()
 804                         {
 805                                 return m_obj->make_raw_proxy(m_key);
 806                         }
 807
 808                         detail::proxy_raw_object operator->()
 809                         {
 810                                 return m_obj->make_raw_proxy(m_key);
 811                         }
 812
 813                         raw_iterator& operator++()
 814                         {
 815                                 lua_State* L = m_obj->lua_state();
 816                                 m_obj->pushvalue();
 817                                 m_key.get(L);
 818
 819                                 if (lua_next(L, -2) != 0)
 820                                 {
 821                                         lua_pop(L, 1);
 822                                         m_key.replace(L);
 823                                         lua_pop(L, 1);
 824                                 }
 825                                 else
 826                                 {
 827                                         lua_pop(L, 1);
 828                                         m_key.reset();
 829                                         m_obj = 0;
 830                                 }
 831
 832                                 return *this;
 833                         }
 834
 835                         object key() const;
 836
 837                         bool operator!=(const raw_iterator& rhs) const
 838                         {
 839                                 if (m_obj != rhs.m_obj) return true;
 840                                 if (m_obj == 0) return false;
 841                                 if (m_obj->lua_state() != rhs.m_obj->lua_state()) return true;
 842                                 if (m_key.is_valid() != rhs.m_key.is_valid()) return true;
 843
 844                                 // TODO: fix this. add a real equality test of the keys
 845                                 return true;
 846                         }
 847
 848                 private:
 849
 850                         raw_iterator(object* obj, detail::lua_reference const& key)
 851                                 : m_obj(obj)
 852                                 , m_key(key)
 853                         {}
 854
 855                         object* m_obj;
 856                         detail::lua_reference m_key;
 857                 };
 858
 859
 860
 861
 862
 863
 864                 object()
 865                         : m_state(0)
 866                 {
 867                 }
 868
 869                 explicit object(lua_State* L)
 870                         : m_state(L)
 871                 {
 872                 }
 873
 874                 template<class T>
 875                 object(lua_State* L, const T& val)
 876                         : m_state(L)
 877                 {
 878                         *this = val;
 879                 }
 880
 881                 object(const object& o)
 882                         : m_state(o.m_state)
 883                 {
 884                         o.m_ref.get(m_state);
 885                         m_ref.set(m_state);
 886                 }
 887
 888                 inline ~object()
 889                 {}
 890
 891                 inline bool is_valid() const { return m_ref.is_valid(); }
 892
 893                 // this is a safe substitute for an implicit converter to bool
 894                 typedef void (object::*member_ptr)() const;
 895                 operator member_ptr() const
 896                 {
 897                         if (is_valid()) return &object::dummy;
 898                         return 0;
 899                 }
 900
 901                 int type() const
 902                 {
 903                         pushvalue();
 904                         detail::stack_pop p(lua_state(), 1);
 905                         return lua_type(lua_state(), -1);
 906                 }
 907
 908                 inline iterator begin() const
 909                 {
 910                         m_ref.get(m_state);
 911                         lua_pushnil(m_state);
 912                         lua_next(m_state, -2);
 913                         lua_pop(m_state, 1);
 914                         detail::lua_reference r;
 915                         r.set(m_state);
 916                         iterator i(const_cast<object*>(this), r);
 917                         lua_pop(m_state, 1);
 918                         return i;
 919                 }
 920
 921                 inline iterator end() const
 922                 {
 923                         return iterator(0, detail::lua_reference());
 924                 }
 925
 926                 inline array_iterator abegin() const
 927                 {
 928                         return array_iterator(const_cast<object*>(this), 1);
 929                 }
 930
 931                 inline array_iterator aend() const
 932                 {
 933                         return array_iterator(const_cast<object*>(this), -1);
 934                 }
 935
 936                 raw_iterator raw_begin() const
 937                 {
 938                         m_ref.get(m_state);
 939                         lua_pushnil(m_state);
 940                         lua_next(m_state, -2);
 941                         lua_pop(m_state, 1);
 942                         detail::lua_reference r;
 943                         r.set(m_state);
 944                         raw_iterator i(const_cast<object*>(this), r);
 945                         lua_pop(m_state, 1);
 946                         return i;
 947                 }
 948
 949                 raw_iterator raw_end() const
 950                 {
 951                         return raw_iterator(0, detail::lua_reference());
 952                 }
 953
 954                 inline void set() const
 955                 {
 956                         // you are trying to access an invalid object
 957                         assert((m_state != 0) && "you are trying to access an invalid (uninitialized) object");
 958
 959                         allocate_slot();
 960                         m_ref.replace(m_state);
 961                 }
 962                 inline lua_State* lua_state() const { return m_state; }
 963                 inline void pushvalue() const
 964                 {
 965                         // you are trying to dereference an invalid object
 966                         assert((m_ref.is_valid()) && "you are trying to access an invalid (uninitialized) object");
 967                         assert((m_state != 0) && "internal error, please report");
 968
 969                         m_ref.get(m_state);
 970                 }
 971
 972                 void swap(object& rhs);
 973
 974                 template<class T>
 975                 inline object raw_at(const T& key)
 976                 {
 977                         lua_State* L = lua_state();
 978                         pushvalue();
 979                         detail::convert_to_lua(L, key);
 980                         lua_rawget(L, -2);
 981                         detail::lua_reference ref;
 982                         ref.set(L);
 983                         lua_pop(L, 1);
 984                         return object(L, ref, true);
 985                 }
 986
 987                 template<class T>
 988                 inline object at(const T& key)
 989                 {
 990                         LUABIND_CHECK_STACK(m_state);
 991
 992                         lua_State* L = lua_state();
 993                         pushvalue();
 994                         detail::convert_to_lua(L, key);
 995                         lua_gettable(L, -2);
 996                         detail::lua_reference ref;
 997                         ref.set(L);
 998                         lua_pop(L, 1);
 999                         return object(L, ref, true);
1000                 }
1001
1002                 template<class T>
1003                 inline detail::proxy_object operator[](const T& key) const
1004                 {
1005                         LUABIND_CHECK_STACK(m_state);
1006
1007                         detail::convert_to_lua(m_state, key);
1008                         detail::lua_reference ref;
1009                         ref.set(m_state);
1010                         return detail::proxy_object(const_cast<object*>(this), ref);
1011                 }
1012
1013
1014
1015                 // *****************************
1016                 // OPERATOR =
1017
1018                 template<class T>
1019                 object& operator=(const T& val) const
1020                 {
1021                         assert((m_state != 0) && "you cannot assign a non-lua value to an uninitialized object");
1022                         // you cannot assign a non-lua value to an uninitialized object
1023
1024                         detail::convert_to_lua(m_state, val);
1025                         set();
1026                         return const_cast<luabind::object&>(*this);
1027                 }
1028
1029                 object& operator=(const object& o) const;
1030                 object& operator=(const detail::proxy_object& o) const;
1031                 object& operator=(const detail::proxy_raw_object& o) const;
1032                 object& operator=(const detail::proxy_array_object& o) const;
1033
1034                 template<class T, class Policies>
1035                 void assign(const T& val, const Policies& p) const
1036                 {
1037                         assert((m_state != 0) && "you cannot assign a non-lua value to an uninitialized object");
1038                         // you cannot assign a non-lua value to an uninitialized object
1039
1040                         detail::convert_to_lua_p(m_state, val, p);
1041                         set();
1042                 }
1043
1044                 // const overload should return a tuple_object..?
1045                 inline detail::tuple_object_ref operator,(const object& rhs) const;
1046
1047                 // *****************************
1048                 // OPERATOR()
1049
1050                 #define BOOST_PP_ITERATION_PARAMS_1 (4, (0, LUABIND_MAX_ARITY, <luabind/object.hpp>, 1))
1051                 #include BOOST_PP_ITERATE()
1052
1053
1054
1055                 inline detail::proxy_object make_proxy(detail::lua_reference const& key)
1056                 {
1057                         return detail::proxy_object(this, key);
1058                 }
1059
1060                 inline detail::proxy_raw_object make_raw_proxy(detail::lua_reference const& key)
1061                 {
1062                         return detail::proxy_raw_object(this, key);
1063                 }
1064
1065                 inline detail::proxy_array_object make_array_proxy(int key)
1066                 {
1067                         return detail::proxy_array_object(this, key);
1068                 }
1069
1070                 // TODO: it's not possible to make object friend with wrapped_constructor_helper::apply (since
1071                 // it's an inner class), that's why this interface is public
1072 //      private:
1073
1074                 object(lua_State* L, detail::lua_reference const& ref, bool/*, reference*/)
1075                         : m_state(L)
1076                         , m_ref(ref)
1077                 {
1078                 }
1079
1080 private:
1081
1082                 void dummy() const {}
1083
1084                 void allocate_slot() const
1085                 {
1086                         if (!m_ref.is_valid())
1087                         {
1088                                 lua_pushboolean(m_state, 0);
1089                                 m_ref.set(m_state);
1090                         }
1091                 }
1092
1093                 mutable lua_State* m_state;
1094                 mutable detail::lua_reference m_ref;
1095         };
1096
1097
1098         // *************************************
1099         // OBJECT
1100
1101         inline void object::swap(object& rhs)
1102         {
1103                 // you cannot swap objects from different lua states
1104                 assert((lua_state() == rhs.lua_state()) && "you cannot swap objects from different lua states");
1105                 m_ref.swap(rhs.m_ref);
1106         }
1107
1108         inline object object::iterator::key() const
1109         {
1110                 lua_State* L = m_obj->lua_state();
1111                 return object(L, m_key, true);
1112         }
1113
1114         inline object object::raw_iterator::key() const
1115         {
1116                 lua_State* L = m_obj->lua_state();
1117                 return object(L, m_key, true);
1118         }
1119
1120         namespace detail
1121         {
1122                 // tuple object ----------------------------------------------
1123
1124                 struct tuple_object;
1125
1126                 struct tuple_object_ref
1127                 {
1128                         tuple_object_ref(object* a, object* b)
1129                                 : n(2)
1130                         { refs[0] = a; refs[1] = b; }
1131
1132                         tuple_object_ref& operator,(const object& x)
1133                         { refs[n++] = const_cast<object*>(&x); return *this; }
1134
1135                         struct assign_into
1136                         {
1137                                 assign_into() {}
1138
1139                                 template<class T>
1140                                 assign_into(tuple_object_ref& to, const T& val)
1141                                         : target(&to)
1142                                         , n(0)
1143                                 {
1144                                         if (n >= target->n) return;
1145                                         *target->refs[n++] = val;
1146                                 }
1147
1148                                 template<class T>
1149                                 assign_into& operator,(const T& val)
1150                                 {
1151                                         if (n >= target->n) return *this;
1152                                         *target->refs[n++] = val;
1153                                         return *this;
1154                                 }
1155
1156                                 tuple_object_ref* target;
1157                                 std::size_t n;
1158                         };
1159
1160                         template<class T>
1161                         assign_into operator=(const T& val)
1162                         { return assign_into(*this, val); }
1163
1164                         tuple_object_ref(const tuple_object_ref&);
1165                         assign_into operator=(const tuple_object_ref& x)
1166                         {
1167                                 for (std::size_t i = 0; i < n && i < x.n; ++i)
1168                                         *refs[i] = *x.refs[i];
1169                                 return assign_into();
1170                         }
1171
1172                         inline assign_into operator=(const tuple_object&);
1173
1174                         std::size_t n;
1175                         object* refs[10];
1176                 };
1177
1178                 struct tuple_object
1179                 {
1180                         tuple_object(const object& x)
1181                                 : n(0)
1182                         { objs[n++] = x; }
1183
1184                         tuple_object(const tuple_object_ref& x)
1185                         {
1186                                 for (std::size_t i = 0; i < x.n; ++i)
1187                                         objs[i] = *x.refs[i];
1188                         }
1189
1190                         std::size_t n;
1191                         object objs[10];
1192                 };
1193
1194                 inline tuple_object_ref::assign_into tuple_object_ref::operator=(const tuple_object& x)
1195                 {
1196                         for (std::size_t i = 0; i < n && i < x.n; ++i)
1197                                 *refs[i] = x.objs[i];
1198                         return assign_into();
1199                 }
1200
1201                 // *************************************
1202                 // PROXY CALLER
1203
1204 #if !defined(BOOST_MSVC) || (defined(BOOST_MSVC) && (BOOST_MSVC > 1300))
1205                 template<class Tuple>
1206                 template<class Policies>
1207                 luabind::object proxy_caller<Tuple>::operator[](const Policies& p)
1208                 {
1209                         m_called = true;
1210                         lua_State* L = m_obj->lua_state();
1211                         m_obj->pushvalue();
1212                         detail::push_args_from_tuple<1>::apply(L, m_args, p);
1213                         if (pcall(L, boost::tuples::length<Tuple>::value, 1))
1214                         {
1215 #ifndef LUABIND_NO_EXCEPTIONS
1216                                 throw error(L);
1217 #else
1218                                 error_callback_fun e = get_error_callback();
1219                                 if (e) e(L);
1220
1221                                 assert(0 && "the lua function threw an error and exceptions are disabled."
1222                                         "if you want to handle this error use luabind::set_error_callback()");
1223                                 std::terminate();
1224 #endif
1225                         }
1226                         detail::lua_reference ref;
1227                         ref.set(L);
1228                         return luabind::object(m_obj->lua_state(), ref, true/*luabind::object::reference()*/);
1229                 }
1230 #endif
1231                 // *************************************
1232                 // PROXY OBJECT
1233
1234 #if !defined(BOOST_MSVC) || (defined(BOOST_MSVC) && (BOOST_MSVC > 1300))
1235                 template<class T>
1236                 inline object proxy_object::raw_at(const T& key)
1237                 LUABIND_PROXY_RAW_AT_BODY
1238
1239                 template<class T>
1240                 inline object proxy_object::at(const T& key)
1241                 LUABIND_PROXY_AT_BODY
1242 #endif
1243
1244                 inline lua_State* proxy_object::lua_state() const
1245                 {
1246                         return m_obj->lua_state();
1247                 }
1248
1249                 inline proxy_object::operator luabind::object()
1250                 {
1251                         lua_State* L = m_obj->lua_state();
1252                         pushvalue();
1253                         detail::lua_reference ref;
1254                         ref.set(L);
1255                         return luabind::object(L, ref, true/*luabind::object::reference()*/);
1256                 }
1257
1258
1259                 // *************************************
1260                 // PROXY ARRAY OBJECT
1261
1262 #if !defined(BOOST_MSVC) || (defined(BOOST_MSVC) && (BOOST_MSVC > 1300))
1263                 template<class T>
1264                 inline object proxy_array_object::raw_at(const T& key)
1265                 LUABIND_PROXY_ARRAY_RAW_AT_BODY
1266
1267                 template<class T>
1268                 inline object proxy_array_object::at(const T& key)
1269                 LUABIND_PROXY_ARRAY_AT_BODY
1270 #endif
1271
1272 #undef LUABIND_PROXY_ARRAY_AT_BODY
1273 #undef LUABIND_PROXY_ARRAY_RAW_AT_BODY
1274
1275                 inline lua_State* proxy_array_object::lua_state() const
1276                 {
1277                         return m_obj->lua_state();
1278                 }
1279
1280                 inline proxy_array_object::operator luabind::object()
1281                 {
1282                         lua_State* L = m_obj->lua_state();
1283                         pushvalue();
1284                         detail::lua_reference ref;
1285                         ref.set(L);
1286                         return luabind::object(L, ref, true/*luabind::object::reference()*/);
1287                 }
1288
1289
1290                 // *************************************
1291                 // PROXY RAW OBJECT
1292
1293 #if !defined(BOOST_MSVC) || (defined(BOOST_MSVC) && (BOOST_MSVC > 1300))
1294                 template<class T>
1295                 inline object proxy_raw_object::raw_at(const T& key)
1296                 LUABIND_PROXY_RAW_AT_BODY
1297
1298                 template<class T>
1299                 inline object proxy_raw_object::at(const T& key)
1300                 LUABIND_PROXY_AT_BODY
1301 #endif
1302
1303 #undef LUABIND_PROXY_RAW_AT_BODY
1304 #undef LUABIND_PROXY_AT_BODY
1305
1306                 inline lua_State* proxy_raw_object::lua_state() const
1307                 {
1308                         return m_obj->lua_state();
1309                 }
1310
1311                 inline proxy_raw_object::operator luabind::object()
1312                 {
1313                         lua_State* L = lua_state();
1314                         pushvalue();
1315                         detail::lua_reference ref;
1316                         ref.set(L);
1317                         return luabind::object(L, ref, true/*luabind::object::reference()*/);
1318                 }
1319
1320
1321                 // *************************************
1322                 // PROXY CALLER
1323
1324
1325                 template<class Tuple>
1326                 proxy_caller<Tuple>::~proxy_caller()
1327                 {
1328                         if (m_called) return;
1329
1330                         m_called = true;
1331                         lua_State* L = m_obj->lua_state();
1332                         m_obj->pushvalue();
1333
1334                         push_args_from_tuple<1>::apply(L, m_args);
1335                         if (pcall(L, boost::tuples::length<Tuple>::value, 0))
1336                         {
1337 #ifndef LUABIND_NO_EXCEPTIONS
1338                                 throw luabind::error(L);
1339 #else
1340                                 error_callback_fun e = get_error_callback();
1341                                 if (e) e(L);
1342
1343                                 assert(0 && "the lua function threw an error and exceptions are disabled."
1344                                         "if you want to handle this error use luabind::set_error_callback()");
1345                                 std::terminate();
1346 #endif
1347                         }
1348                 }
1349
1350                 template<class Tuple>
1351                 proxy_caller<Tuple>::operator luabind::object()
1352                 {
1353                         m_called = true;
1354                         lua_State* L = m_obj->lua_state();
1355                         m_obj->pushvalue();
1356
1357                         push_args_from_tuple<1>::apply(L, m_args);
1358                         if (pcall(L, boost::tuples::length<Tuple>::value, 1))
1359                         {
1360 #ifndef LUABIND_NO_EXCEPTIONS
1361                                 throw luabind::error(L);
1362 #else
1363                                 error_callback_fun e = get_error_callback();
1364                                 if (e) e(L);
1365
1366                                 assert(0 && "the lua function threw an error and exceptions are disabled."
1367                                         "if you want to handle this error use luabind::set_error_callback()");
1368                                 std::terminate();
1369 #endif
1370                         }
1371                         detail::lua_reference ref;
1372                         ref.set(L);
1373                         return luabind::object(m_obj->lua_state(), ref, true/*luabind::object::reference()*/);
1374                 }
1375
1376         }
1377
1378         inline detail::tuple_object_ref object::operator,(const object& rhs) const
1379         {
1380                 return detail::tuple_object_ref(
1381                         const_cast<object*>(this), const_cast<object*>(&rhs));
1382         }
1383
1384         typedef detail::tuple_object function_;
1385
1386 #define LUABIND_DECLARE_OPERATOR(MACRO)\
1387         MACRO(object, object) \
1388         MACRO(object, detail::proxy_object) \
1389         MACRO(object, detail::proxy_array_object) \
1390         MACRO(object, detail::proxy_raw_object) \
1391         MACRO(detail::proxy_object, object) \
1392         MACRO(detail::proxy_object, detail::proxy_object) \
1393         MACRO(detail::proxy_object, detail::proxy_array_object) \
1394         MACRO(detail::proxy_object, detail::proxy_raw_object) \
1395         MACRO(detail::proxy_array_object, object) \
1396         MACRO(detail::proxy_array_object, detail::proxy_object) \
1397         MACRO(detail::proxy_array_object, detail::proxy_array_object) \
1398         MACRO(detail::proxy_array_object, detail::proxy_raw_object) \
1399         MACRO(detail::proxy_raw_object, object) \
1400         MACRO(detail::proxy_raw_object, detail::proxy_object) \
1401         MACRO(detail::proxy_raw_object, detail::proxy_array_object) \
1402         MACRO(detail::proxy_raw_object, detail::proxy_raw_object)
1403
1404
1405 #define LUABIND_EQUALITY_OPERATOR(lhs, rhs) LUABIND_API bool operator==(const lhs&, const rhs&);
1406         LUABIND_DECLARE_OPERATOR(LUABIND_EQUALITY_OPERATOR)
1407 #undef LUABIND_EQUALITY_OPERATOR
1408
1409 #define LUABIND_LESSTHAN_OPERATOR(lhs, rhs) LUABIND_API bool operator<(const lhs&, const rhs&);
1410         LUABIND_DECLARE_OPERATOR(LUABIND_LESSTHAN_OPERATOR)
1411 #undef LUABIND_LESSTHAN_OPERATOR
1412
1413 #define LUABIND_LESSOREQUAL_OPERATOR(lhs_t, rhs_t) LUABIND_API bool operator<=(const lhs_t&, const rhs_t&);
1414         LUABIND_DECLARE_OPERATOR(LUABIND_LESSOREQUAL_OPERATOR)
1415 #undef LUABIND_LESSOREQUAL_OPERATOR
1416
1417 #define LUABIND_INEQUALITY_OPERATOR(lhs_t, rhs_t)\
1418         inline bool operator!=(const rhs_t& rhs, const lhs_t& lhs) \
1419         { \
1420                 return !(rhs == lhs); \
1421         }
1422
1423         LUABIND_DECLARE_OPERATOR(LUABIND_INEQUALITY_OPERATOR)
1424
1425 #undef LUABIND_INEQUALITY_OPERATOR
1426
1427 #define LUABIND_GREATEROREQUAL_OPERATOR(lhs_t, rhs_t)\
1428         inline bool operator>=(const rhs_t& rhs, const lhs_t& lhs) \
1429         { \
1430                 return !(rhs < lhs); \
1431         }
1432
1433         LUABIND_DECLARE_OPERATOR(LUABIND_GREATEROREQUAL_OPERATOR)
1434
1435 #undef LUABIND_GREATEROREQUAL_OPERATOR
1436
1437 #define LUABIND_GREATERTHAN_OPERATOR(lhs_t, rhs_t)\
1438         inline bool operator>(const lhs_t& lhs, const rhs_t& rhs) \
1439         { \
1440                 return !(lhs <= rhs); \
1441         }
1442
1443         LUABIND_DECLARE_OPERATOR(LUABIND_GREATERTHAN_OPERATOR)
1444 #undef LUABIND_GREATERTHAN_OPERATOR
1445
1446 #undef LUABIND_DECLARE_OPERATOR
1447
1448 }
1449
1450 namespace std
1451 {
1452
1453 #define LUABIND_DEFINE_SWAP(t1,t2)\
1454         inline void swap(t1 lhs, t2 rhs)\
1455         {\
1456                         assert((lhs.lua_state() == rhs.lua_state()) && "you cannot swap objects from different lua states");\
1457                         rhs.pushvalue();\
1458                         lhs.pushvalue();\
1459                         rhs.set();\
1460                         lhs.set();\
1461         }
1462
1463         inline void swap(luabind::object& lhs, luabind::object& rhs)
1464         {
1465                 lhs.swap(rhs);
1466         }
1467
1468         // object against all other
1469         LUABIND_DEFINE_SWAP(luabind::object&, const luabind::detail::proxy_object&)
1470         LUABIND_DEFINE_SWAP(luabind::object&, const luabind::detail::proxy_raw_object&)
1471         LUABIND_DEFINE_SWAP(luabind::object&, const luabind::detail::proxy_array_object&)
1472         LUABIND_DEFINE_SWAP(const luabind::detail::proxy_object&, luabind::object&)
1473         LUABIND_DEFINE_SWAP(const luabind::detail::proxy_raw_object&, luabind::object&)
1474         LUABIND_DEFINE_SWAP(const luabind::detail::proxy_array_object&, luabind::object&)
1475
1476         // proxy_object against all other
1477         LUABIND_DEFINE_SWAP(const luabind::detail::proxy_object&, const luabind::detail::proxy_object&)
1478         LUABIND_DEFINE_SWAP(const luabind::detail::proxy_object&, const luabind::detail::proxy_raw_object&)
1479         LUABIND_DEFINE_SWAP(const luabind::detail::proxy_object&, const luabind::detail::proxy_array_object&)
1480         LUABIND_DEFINE_SWAP(const luabind::detail::proxy_raw_object&, const luabind::detail::proxy_object&)
1481         LUABIND_DEFINE_SWAP(const luabind::detail::proxy_array_object&, const luabind::detail::proxy_object&)
1482
1483         // proxy_raw_object against all other
1484         LUABIND_DEFINE_SWAP(const luabind::detail::proxy_raw_object&, const luabind::detail::proxy_raw_object&)
1485         LUABIND_DEFINE_SWAP(const luabind::detail::proxy_raw_object&, const luabind::detail::proxy_array_object&)
1486         LUABIND_DEFINE_SWAP(const luabind::detail::proxy_array_object&, const luabind::detail::proxy_raw_object&)
1487
1488         // proxy_array_object against all other
1489         LUABIND_DEFINE_SWAP(const luabind::detail::proxy_array_object&, const luabind::detail::proxy_array_object&)
1490
1491 #undef LUABIND_DEFINE_SWAP
1492
1493 } // std
1494
1495 #endif // LUABIND_OBJECT_HPP_INCLUDED
1496
1497 #elif BOOST_PP_ITERATION_FLAGS() == 1
1498
1499 #define LUABIND_TUPLE_PARAMS(z, n, data) const A##n *
1500 #define LUABIND_OPERATOR_PARAMS(z, n, data) const A##n & a##n
1501
1502 #if BOOST_PP_ITERATION() > 0
1503         template<BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), class A)>
1504 #endif
1505         detail::proxy_caller<boost::tuples::tuple<BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_TUPLE_PARAMS, _)> >
1506         operator()(BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_OPERATOR_PARAMS, _)) const
1507         {
1508                 typedef boost::tuples::tuple<BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_TUPLE_PARAMS, _)> tuple_t;
1509 #if BOOST_PP_ITERATION() == 0
1510                 tuple_t args;
1511 #else
1512                 tuple_t args(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), &a));
1513 #endif
1514                 return detail::proxy_caller<tuple_t>(const_cast<luabind::object*>(this), args);
1515         }
1516
1517 #undef LUABIND_OPERATOR_PARAMS
1518 #undef LUABIND_TUPLE_PARAMS
1519
1520 #endif