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