luabind/object.hpp

   1 // Copyright (c) 2005 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 #ifndef LUABIND_OBJECT_050419_HPP
  24 #define LUABIND_OBJECT_050419_HPP
  25
  26 #include <boost/implicit_cast.hpp> // detail::push()
  27 #include <boost/ref.hpp> // detail::push()
  28 #include <boost/mpl/bool.hpp> // value_wrapper_traits specializations
  29 #include <boost/mpl/apply_wrap.hpp>
  30 #include <boost/tuple/tuple.hpp>
  31 #include <boost/optional.hpp>
  32
  33 #include <luabind/nil.hpp>
  34 #include <luabind/value_wrapper.hpp>
  35 #include <luabind/detail/pcall.hpp>
  36 #include <luabind/handle.hpp>
  37 #include <luabind/from_stack.hpp>
  38 #include <luabind/detail/policy.hpp>
  39 #include <luabind/detail/stack_utils.hpp>
  40 #include <luabind/detail/convert_to_lua.hpp> // REFACTOR
  41 #include <luabind/typeid.hpp>
  42
  43 #include <boost/iterator/iterator_facade.hpp> // iterator
  44
  45 #include <boost/preprocessor/iteration/iterate.hpp>
  46 #include <boost/utility/enable_if.hpp>
  47
  48 namespace luabind {
  49
  50 namespace detail
  51 {
  52   namespace mpl = boost::mpl;
  53
  54   template<class T, class ConverterGenerator>
  55   void push_aux(lua_State* interpreter, T& value, ConverterGenerator*)
  56   {
  57       typedef typename boost::mpl::if_<
  58           boost::is_reference_wrapper<T>
  59         , BOOST_DEDUCED_TYPENAME boost::unwrap_reference<T>::type&
  60         , T
  61       >::type unwrapped_type;
  62
  63       typename mpl::apply_wrap2<
  64           ConverterGenerator,unwrapped_type,cpp_to_lua
  65       >::type cv;
  66
  67       cv.apply(
  68           interpreter
  69         , boost::implicit_cast<
  70               BOOST_DEDUCED_TYPENAME boost::unwrap_reference<T>::type&
  71           >(value)
  72       );
  73   }
  74
  75   template<class T, class Policies>
  76   void push(lua_State* interpreter, T& value, Policies const&)
  77   {
  78       typedef typename find_conversion_policy<
  79           0
  80         , Policies
  81       >::type converter_policy;
  82
  83       push_aux(interpreter, value, (converter_policy*)0);
  84   }
  85
  86   template<class T>
  87   void push(lua_State* interpreter, T& value)
  88   {
  89       push(interpreter, value, null_type());
  90   }
  91
  92 } // namespace detail
  93
  94 namespace adl
  95 {
  96   namespace mpl = boost::mpl;
  97
  98   template <class T>
  99   class object_interface;
 100
 101   namespace is_object_interface_aux
 102   {
 103     typedef char (&yes)[1];
 104     typedef char (&no)[2];
 105
 106     template <class T>
 107     yes check(object_interface<T>*);
 108     no check(void*);
 109
 110     template <class T>
 111     struct impl
 112     {
 113         BOOST_STATIC_CONSTANT(bool, value =
 114             sizeof(is_object_interface_aux::check((T*)0)) == sizeof(yes)
 115         );
 116
 117         typedef mpl::bool_<value> type;
 118     };
 119
 120   } // namespace detail
 121
 122   template <class T>
 123   struct is_object_interface
 124     : is_object_interface_aux::impl<T>::type
 125   {};
 126
 127   template <class R, class T, class U>
 128   struct enable_binary
 129 # ifndef BOOST_NO_SFINAE
 130     : boost::enable_if<
 131           mpl::or_<
 132               is_object_interface<T>
 133             , is_object_interface<U>
 134           >
 135         , R
 136       >
 137   {};
 138 # else
 139   {
 140       typedef R type;
 141   };
 142 # endif
 143
 144   template<class T, class U>
 145   int binary_interpreter(lua_State*& L, T const& lhs, U const& rhs
 146     , boost::mpl::true_, boost::mpl::true_)
 147   {
 148        L = value_wrapper_traits<T>::interpreter(lhs);
 149                  lua_State* L2 = value_wrapper_traits<U>::interpreter(rhs);
 150
 151        // you are comparing objects with different interpreters
 152        // that's not allowed.
 153                  assert(L == L2 || L == 0 || L2 == 0);
 154
 155        // if the two objects we compare have different interpreters
 156        // then they
 157
 158        if (L != L2) return -1;
 159        if (L == 0) return 1;
 160        return 0;
 161   }
 162
 163   template<class T, class U>
 164   int binary_interpreter(lua_State*& L, T const& x, U const&
 165     , boost::mpl::true_, boost::mpl::false_)
 166   {
 167        L = value_wrapper_traits<T>::interpreter(x);
 168        return 0;
 169   }
 170
 171   template<class T, class U>
 172   int binary_interpreter(lua_State*& L, T const&, U const& x, boost::mpl::false_, boost::mpl::true_)
 173   {
 174       L = value_wrapper_traits<U>::interpreter(x);
 175       return 0;
 176   }
 177
 178   template<class T, class U>
 179   int binary_interpreter(lua_State*& L, T const& x, U const& y)
 180   {
 181       return binary_interpreter(
 182           L
 183         , x
 184         , y
 185         , is_value_wrapper<T>()
 186         , is_value_wrapper<U>()
 187       );
 188   }
 189
 190 #define LUABIND_BINARY_OP_DEF(op, fn) \
 191   template<class LHS, class RHS> \
 192   typename enable_binary<bool,LHS,RHS>::type \
 193   operator op(LHS const& lhs, RHS const& rhs) \
 194   { \
 195       lua_State* L = 0; \
 196       switch (binary_interpreter(L, lhs, rhs)) \
 197       { \
 198           case 1: \
 199               return true; \
 200           case -1: \
 201               return false; \
 202       } \
 203 \
 204       assert(L); \
 205 \
 206       detail::stack_pop pop1(L, 1); \
 207       detail::push(L, lhs); \
 208       detail::stack_pop pop2(L, 1); \
 209       detail::push(L, rhs); \
 210 \
 211       return fn(L, -1, -2) != 0; \
 212   }
 213
 214 LUABIND_BINARY_OP_DEF(==, lua_equal)
 215 LUABIND_BINARY_OP_DEF(<, lua_lessthan)
 216
 217   template<class ValueWrapper>
 218   std::ostream& operator<<(std::ostream& os
 219     , object_interface<ValueWrapper> const& v)
 220   {
 221       using namespace luabind;
 222       lua_State* interpreter = value_wrapper_traits<ValueWrapper>::interpreter(
 223           static_cast<ValueWrapper const&>(v));
 224       detail::stack_pop pop(interpreter, 1);
 225       value_wrapper_traits<ValueWrapper>::unwrap(interpreter
 226         , static_cast<ValueWrapper const&>(v));
 227                 char const* p = lua_tostring(interpreter, -1);
 228         std::size_t len = lua_strlen(interpreter, -1);
 229                 std::copy(p, p + len, std::ostream_iterator<char>(os));
 230                 return os;
 231         }
 232
 233 #undef LUABIND_BINARY_OP_DEF
 234
 235   template<class LHS, class RHS>
 236   typename enable_binary<bool,LHS,RHS>::type
 237   operator>(LHS const& lhs, RHS const& rhs)
 238   {
 239       return !(lhs < rhs || lhs == rhs);
 240   }
 241
 242   template<class LHS, class RHS>
 243   typename enable_binary<bool,LHS,RHS>::type
 244   operator<=(LHS const& lhs, RHS const& rhs)
 245   {
 246       return lhs < rhs || lhs == rhs;
 247   }
 248
 249   template<class LHS, class RHS>
 250   typename enable_binary<bool,LHS,RHS>::type
 251   operator>=(LHS const& lhs, RHS const& rhs)
 252   {
 253       return !(lhs < rhs);
 254   }
 255
 256   template<class LHS, class RHS>
 257   typename enable_binary<bool,LHS,RHS>::type
 258   operator!=(LHS const& lhs, RHS const& rhs)
 259   {
 260       return !(lhs == rhs);
 261   }
 262
 263   template<class ValueWrapper, class Arguments>
 264   struct call_proxy;
 265
 266   template<class Next>
 267   class index_proxy;
 268
 269   class object;
 270
 271   template<class Derived>
 272   class object_interface
 273   {
 274       struct safe_bool_type {};
 275   public:
 276       ~object_interface() {}
 277
 278       call_proxy<Derived, boost::tuples::tuple<> > operator()();
 279
 280       template<class A0>
 281       call_proxy<
 282           Derived
 283         , boost::tuples::tuple<A0 const*>
 284       > operator()(A0 const& a0)
 285       {
 286           typedef boost::tuples::tuple<A0 const*> arguments;
 287
 288           return call_proxy<Derived, arguments>(
 289               derived()
 290             , arguments(&a0)
 291           );
 292       }
 293
 294       template<class A0, class A1>
 295       call_proxy<
 296           Derived
 297         , boost::tuples::tuple<A0 const*, A1 const*>
 298       > operator()(A0 const& a0, A1 const& a1)
 299       {
 300           typedef boost::tuples::tuple<A0 const*, A1 const*> arguments;
 301
 302           return call_proxy<Derived, arguments>(
 303               derived()
 304             , arguments(&a0, &a1)
 305           );
 306       }
 307
 308       // The rest of the overloads are PP-generated.
 309       #define BOOST_PP_ITERATION_PARAMS_1 (3, \
 310           (3, LUABIND_MAX_ARITY, <luabind/detail/object_call.hpp>))
 311       #include BOOST_PP_ITERATE()
 312
 313       operator safe_bool_type*() const
 314       {
 315           lua_State* L = value_wrapper_traits<Derived>::interpreter(derived());
 316
 317           if (!L)
 318               return 0;
 319
 320           value_wrapper_traits<Derived>::unwrap(L, derived());
 321           detail::stack_pop pop(L, 1);
 322
 323           return lua_toboolean(L, -1) == 1 ? (safe_bool_type*)1 : 0;
 324       }
 325
 326   private:
 327       Derived& derived()
 328       {
 329           return *static_cast<Derived*>(this);
 330       }
 331
 332       Derived const& derived() const
 333       {
 334           return *static_cast<Derived const*>(this);
 335       }
 336   };
 337
 338 #ifdef LUABIND_USE_VALUE_WRAPPER_TAG
 339   struct iterator_proxy_tag;
 340 #endif
 341
 342   template<class AccessPolicy>
 343   class iterator_proxy
 344     : public object_interface<iterator_proxy<AccessPolicy> >
 345   {
 346   public:
 347 #ifdef LUABIND_USE_VALUE_WRAPPER_TAG
 348       typedef iterator_proxy_tag value_wrapper_tag;
 349 #endif
 350
 351       iterator_proxy(lua_State* interpreter, handle const& table, handle const& key)
 352         : m_interpreter(interpreter)
 353         , m_table_index(lua_gettop(interpreter) + 1)
 354         , m_key_index(m_table_index + 1)
 355       {
 356           table.push(m_interpreter);
 357           key.push(m_interpreter);
 358       }
 359
 360       iterator_proxy(iterator_proxy const& other)
 361         : m_interpreter(other.m_interpreter)
 362         , m_table_index(other.m_table_index)
 363         , m_key_index(other.m_key_index)
 364       {
 365           other.m_interpreter = 0;
 366       }
 367
 368       ~iterator_proxy()
 369       {
 370           if (m_interpreter)
 371               lua_pop(m_interpreter, 2);
 372       }
 373
 374                 // this will set the value to nil
 375                 iterator_proxy & operator=(luabind::detail::nil_type)
 376                 {
 377           lua_pushvalue(m_interpreter, m_key_index);
 378                          lua_pushnil(m_interpreter);
 379           AccessPolicy::set(m_interpreter, m_table_index);
 380           return *this;
 381                 }
 382
 383       template<class T>
 384       iterator_proxy& operator=(T const& value)
 385       {
 386           lua_pushvalue(m_interpreter, m_key_index);
 387           detail::push(m_interpreter, value);
 388           AccessPolicy::set(m_interpreter, m_table_index);
 389           return *this;
 390       }
 391
 392       template<class Key>
 393       index_proxy<iterator_proxy<AccessPolicy> > operator[](Key const& key)
 394       {
 395           return index_proxy<iterator_proxy<AccessPolicy> >(
 396               *this, m_interpreter, key
 397           );
 398       }
 399
 400       // This is non-const to prevent conversion on lvalues.
 401       operator object();
 402
 403       lua_State* interpreter() const
 404       {
 405           return m_interpreter;
 406       }
 407
 408       // TODO: Why is it non-const?
 409       void push(lua_State* interpreter)
 410       {
 411           assert(interpreter == m_interpreter);
 412           lua_pushvalue(m_interpreter, m_key_index);
 413           AccessPolicy::get(m_interpreter, m_table_index);
 414       }
 415
 416   private:
 417       mutable lua_State* m_interpreter;
 418       int m_table_index;
 419       int m_key_index;
 420   };
 421
 422 } // namespace adl
 423
 424 namespace detail
 425 {
 426   struct basic_access
 427   {
 428       static void set(lua_State* interpreter, int table)
 429       {
 430           lua_settable(interpreter, table);
 431       }
 432
 433       static void get(lua_State* interpreter, int table)
 434       {
 435           lua_gettable(interpreter, table);
 436       }
 437   };
 438
 439   struct raw_access
 440   {
 441       static void set(lua_State* interpreter, int table)
 442       {
 443           lua_rawset(interpreter, table);
 444       }
 445
 446       static void get(lua_State* interpreter, int table)
 447       {
 448           lua_rawget(interpreter, table);
 449       }
 450   };
 451
 452   template<class AccessPolicy>
 453   class basic_iterator
 454     : public boost::iterator_facade<
 455         basic_iterator<AccessPolicy>
 456       , adl::iterator_proxy<AccessPolicy>
 457       , boost::single_pass_traversal_tag
 458       , adl::iterator_proxy<AccessPolicy>
 459     >
 460   {
 461   public:
 462       basic_iterator()
 463         : m_interpreter(0)
 464       {}
 465
 466       template<class ValueWrapper>
 467       explicit basic_iterator(ValueWrapper const& value_wrapper)
 468         : m_interpreter(
 469               value_wrapper_traits<ValueWrapper>::interpreter(value_wrapper)
 470           )
 471       {
 472           detail::stack_pop pop(m_interpreter, 1);
 473           value_wrapper_traits<ValueWrapper>::unwrap(m_interpreter, value_wrapper);
 474
 475           lua_pushnil(m_interpreter);
 476           if (lua_next(m_interpreter, -2) != 0)
 477           {
 478               detail::stack_pop pop(m_interpreter, 2);
 479               handle(m_interpreter, -2).swap(m_key);
 480           }
 481           else
 482           {
 483               m_interpreter = 0;
 484               return;
 485           }
 486
 487           handle(m_interpreter, -1).swap(m_table);
 488       }
 489
 490       adl::object key() const;
 491
 492   private:
 493       friend class boost::iterator_core_access;
 494
 495       void increment()
 496       {
 497           m_table.push(m_interpreter);
 498           m_key.push(m_interpreter);
 499
 500           detail::stack_pop pop(m_interpreter, 1);
 501
 502           if (lua_next(m_interpreter, -2) != 0)
 503           {
 504               m_key.replace(m_interpreter, -2);
 505               lua_pop(m_interpreter, 2);
 506           }
 507           else
 508           {
 509               m_interpreter = 0;
 510               handle().swap(m_table);
 511               handle().swap(m_key);
 512           }
 513       }
 514
 515       bool equal(basic_iterator const& other) const
 516       {
 517           if (m_interpreter == 0 && other.m_interpreter == 0)
 518               return true;
 519
 520           if (m_interpreter != other.m_interpreter)
 521               return false;
 522
 523           detail::stack_pop pop(m_interpreter, 2);
 524           m_key.push(m_interpreter);
 525           other.m_key.push(m_interpreter);
 526           return lua_equal(m_interpreter, -2, -1) != 0;
 527       }
 528
 529       adl::iterator_proxy<AccessPolicy> dereference() const
 530       {
 531           return adl::iterator_proxy<AccessPolicy>(m_interpreter, m_table, m_key);
 532       }
 533
 534       lua_State* m_interpreter;
 535       handle m_table;
 536       handle m_key;
 537   };
 538
 539 // Needed because of some strange ADL issues.
 540
 541 #define LUABIND_OPERATOR_ADL_WKND(op) \
 542   inline bool operator op( \
 543       basic_iterator<basic_access> const& x \
 544     , basic_iterator<basic_access> const& y) \
 545   { \
 546       return boost::operator op(x, y); \
 547   } \
 548  \
 549   inline bool operator op( \
 550       basic_iterator<raw_access> const& x \
 551     , basic_iterator<raw_access> const& y) \
 552   { \
 553       return boost::operator op(x, y); \
 554   }
 555
 556   LUABIND_OPERATOR_ADL_WKND(==)
 557   LUABIND_OPERATOR_ADL_WKND(!=)
 558
 559 #undef LUABIND_OPERATOR_ADL_WKND
 560
 561 } // namespace detail
 562
 563 namespace adl
 564 {
 565
 566 #ifdef LUABIND_USE_VALUE_WRAPPER_TAG
 567   struct index_proxy_tag;
 568 #endif
 569
 570   template<class Next>
 571   class index_proxy
 572     : public object_interface<index_proxy<Next> >
 573   {
 574   public:
 575 #ifdef LUABIND_USE_VALUE_WRAPPER_TAG
 576       typedef index_proxy_tag value_wrapper_tag;
 577 #endif
 578
 579       typedef index_proxy<Next> this_type;
 580
 581       template<class Key>
 582       index_proxy(Next const& next, lua_State* interpreter, Key const& key)
 583         : m_interpreter(interpreter)
 584         , m_key_index(lua_gettop(interpreter) + 1)
 585         , m_next(next)
 586       {
 587           detail::push(m_interpreter, key);
 588       }
 589
 590       index_proxy(index_proxy const& other)
 591         : m_interpreter(other.m_interpreter)
 592         , m_key_index(other.m_key_index)
 593         , m_next(other.m_next)
 594       {
 595           other.m_interpreter = 0;
 596       }
 597
 598       ~index_proxy()
 599       {
 600           if (m_interpreter)
 601               lua_pop(m_interpreter, 1);
 602       }
 603
 604       // This is non-const to prevent conversion on lvalues.
 605       operator object();
 606
 607                 // this will set the value to nil
 608                 this_type& operator=(luabind::detail::nil_type)
 609                 {
 610                value_wrapper_traits<Next>::unwrap(m_interpreter, m_next);
 611           detail::stack_pop pop(m_interpreter, 1);
 612
 613           lua_pushvalue(m_interpreter, m_key_index);
 614                          lua_pushnil(m_interpreter);
 615           lua_settable(m_interpreter, -3);
 616           return *this;
 617                 }
 618
 619       template<class T>
 620       this_type& operator=(T const& value)
 621       {
 622           value_wrapper_traits<Next>::unwrap(m_interpreter, m_next);
 623           detail::stack_pop pop(m_interpreter, 1);
 624
 625           lua_pushvalue(m_interpreter, m_key_index);
 626           detail::push(m_interpreter, value);
 627           lua_settable(m_interpreter, -3);
 628           return *this;
 629       }
 630
 631       this_type& operator=(this_type const& value)
 632       {
 633           value_wrapper_traits<Next>::unwrap(m_interpreter, m_next);
 634           detail::stack_pop pop(m_interpreter, 1);
 635
 636           lua_pushvalue(m_interpreter, m_key_index);
 637           detail::push(m_interpreter, value);
 638           lua_settable(m_interpreter, -3);
 639           return *this;
 640       }
 641
 642       template<class T>
 643       index_proxy<this_type> operator[](T const& key)
 644       {
 645           return index_proxy<this_type>(*this, m_interpreter, key);
 646       }
 647
 648       void push(lua_State* interpreter);
 649
 650       lua_State* interpreter() const
 651       {
 652           return m_interpreter;
 653       }
 654
 655   private:
 656                 struct hidden_type {};
 657
 658 //      this_type& operator=(index_proxy<Next> const&);
 659
 660       mutable lua_State* m_interpreter;
 661       int m_key_index;
 662
 663       Next const& m_next;
 664   };
 665
 666 } // namespace adl
 667
 668 typedef detail::basic_iterator<detail::basic_access> iterator;
 669 typedef detail::basic_iterator<detail::raw_access> raw_iterator;
 670
 671 #ifndef LUABIND_USE_VALUE_WRAPPER_TAG
 672 template<class T>
 673 struct value_wrapper_traits<adl::index_proxy<T> >
 674 #else
 675 template<>
 676 struct value_wrapper_traits<adl::index_proxy_tag>
 677 #endif
 678 {
 679     typedef boost::mpl::true_ is_specialized;
 680
 681     template<class Next>
 682     static lua_State* interpreter(adl::index_proxy<Next> const& proxy)
 683     {
 684         return proxy.interpreter();
 685     }
 686
 687     template<class Next>
 688     static void unwrap(lua_State* interpreter, adl::index_proxy<Next> const& proxy)
 689     {
 690         const_cast<adl::index_proxy<Next>&>(proxy).push(interpreter);
 691     }
 692 };
 693
 694 #ifndef LUABIND_USE_VALUE_WRAPPER_TAG
 695 template<class AccessPolicy>
 696 struct value_wrapper_traits<adl::iterator_proxy<AccessPolicy> >
 697 #else
 698 template<>
 699 struct value_wrapper_traits<adl::iterator_proxy_tag>
 700 #endif
 701 {
 702     typedef boost::mpl::true_ is_specialized;
 703
 704     template<class Proxy>
 705     static lua_State* interpreter(Proxy const& p)
 706     {
 707         return p.interpreter();
 708     }
 709
 710     template<class Proxy>
 711     static void unwrap(lua_State* interpreter, Proxy const& p)
 712     {
 713         // TODO: Why const_cast?
 714         const_cast<Proxy&>(p).push(interpreter);
 715     }
 716 };
 717
 718 namespace adl
 719 {
 720
 721   // An object holds a reference to a Lua value residing
 722   // in the registry.
 723   class object : public object_interface<object>
 724   {
 725   public:
 726       object()
 727       {}
 728
 729       explicit object(handle const& other)
 730         : m_handle(other)
 731       {}
 732
 733       explicit object(from_stack const& stack_reference)
 734         : m_handle(stack_reference.interpreter, stack_reference.index)
 735       {
 736       }
 737
 738       template<class T>
 739       object(lua_State* interpreter, T const& value)
 740       {
 741           detail::push(interpreter, value);
 742           detail::stack_pop pop(interpreter, 1);
 743           handle(interpreter, -1).swap(m_handle);
 744       }
 745
 746       template<class T, class Policies>
 747       object(lua_State* interpreter, T const& value, Policies const&)
 748       {
 749           detail::push(interpreter, value, Policies());
 750           detail::stack_pop pop(interpreter, 1);
 751           handle(interpreter, -1).swap(m_handle);
 752       }
 753
 754       void push(lua_State* interpreter) const;
 755       lua_State* interpreter() const;
 756       bool is_valid() const;
 757
 758       template<class T>
 759       index_proxy<object> operator[](T const& key) const
 760       {
 761           return index_proxy<object>(
 762               *this, m_handle.interpreter(), key
 763           );
 764       }
 765
 766       void swap(object& other)
 767       {
 768           m_handle.swap(other.m_handle);
 769       }
 770
 771   private:
 772       handle m_handle;
 773   };
 774
 775   inline void object::push(lua_State* interpreter) const
 776   {
 777       m_handle.push(interpreter);
 778   }
 779
 780   inline lua_State* object::interpreter() const
 781   {
 782       return m_handle.interpreter();
 783   }
 784
 785   inline bool object::is_valid() const
 786   {
 787       return m_handle.interpreter() != 0;
 788   }
 789
 790   class argument : public object_interface<argument>
 791   {
 792   public:
 793           argument(from_stack const& stack_reference)
 794                 : m_interpreter(stack_reference.interpreter)
 795                 , m_index(stack_reference.index)
 796           {
 797                   if (m_index < 0)
 798                           m_index = lua_gettop(m_interpreter) - m_index + 1;
 799           }
 800
 801       template<class T>
 802       index_proxy<argument> operator[](T const& key) const
 803       {
 804           return index_proxy<argument>(*this, m_interpreter, key);
 805       }
 806
 807           void push(lua_State* L) const
 808           {
 809                   lua_pushvalue(L, m_index);
 810           }
 811
 812           lua_State* interpreter() const
 813           {
 814                   return m_interpreter;
 815           }
 816
 817   private:
 818           lua_State* m_interpreter;
 819           int m_index;
 820   };
 821
 822 } // namespace adl
 823
 824 using adl::object;
 825 using adl::argument;
 826
 827 #ifndef LUABIND_USE_VALUE_WRAPPER_TAG
 828 template <class ValueWrapper, class Arguments>
 829 struct value_wrapper_traits<adl::call_proxy<ValueWrapper, Arguments> >
 830 #else
 831 template<>
 832 struct value_wrapper_traits<adl::call_proxy_tag>
 833 #endif
 834 {
 835     typedef boost::mpl::true_ is_specialized;
 836
 837     template<class W, class A>
 838     static lua_State* interpreter(adl::call_proxy<W,A> const& proxy)
 839     {
 840         return value_wrapper_traits<W>::interpreter(*proxy.value_wrapper);
 841     }
 842
 843     template<class W, class A>
 844     static void unwrap(lua_State*, adl::call_proxy<W,A> const& proxy)
 845     {
 846         object result = const_cast<adl::call_proxy<W,A>&>(proxy);
 847         result.push(result.interpreter());
 848     }
 849 };
 850
 851 template<>
 852 struct value_wrapper_traits<object>
 853 {
 854     typedef boost::mpl::true_ is_specialized;
 855
 856     static lua_State* interpreter(object const& value)
 857     {
 858         return value.interpreter();
 859     }
 860
 861     static void unwrap(lua_State* interpreter, object const& value)
 862     {
 863         value.push(interpreter);
 864     }
 865
 866     static bool check(...)
 867     {
 868         return true;
 869     }
 870 };
 871
 872 template<>
 873 struct value_wrapper_traits<argument>
 874 {
 875     typedef boost::mpl::true_ is_specialized;
 876
 877     static lua_State* interpreter(argument const& value)
 878     {
 879         return value.interpreter();
 880     }
 881
 882     static void unwrap(lua_State* interpreter, argument const& value)
 883     {
 884         value.push(interpreter);
 885     }
 886
 887     static bool check(...)
 888     {
 889         return true;
 890     }
 891 };
 892
 893 template<class Next>
 894 inline void adl::index_proxy<Next>::push(lua_State* interpreter)
 895 {
 896     assert(interpreter == m_interpreter);
 897
 898     value_wrapper_traits<Next>::unwrap(m_interpreter, m_next);
 899
 900     lua_pushvalue(m_interpreter, m_key_index);
 901     lua_gettable(m_interpreter, -2);
 902     lua_remove(m_interpreter, -2);
 903 }
 904
 905 template<class Next>
 906 inline adl::index_proxy<Next>::operator object()
 907 {
 908     detail::stack_pop pop(m_interpreter, 1);
 909     push(m_interpreter);
 910     return object(from_stack(m_interpreter, -1));
 911 }
 912
 913 template<class AccessPolicy>
 914 adl::iterator_proxy<AccessPolicy>::operator object()
 915 {
 916     lua_pushvalue(m_interpreter, m_key_index);
 917     AccessPolicy::get(m_interpreter, m_table_index);
 918     detail::stack_pop pop(m_interpreter, 1);
 919     return object(from_stack(m_interpreter, -1));
 920 }
 921
 922 template<class AccessPolicy>
 923 object detail::basic_iterator<AccessPolicy>::key() const
 924 {
 925     return object(m_key);
 926 }
 927
 928 namespace detail
 929 {
 930
 931   template<
 932       class T
 933     , class ValueWrapper
 934     , class Policies
 935     , class ErrorPolicy
 936     , class ReturnType
 937   >
 938   ReturnType object_cast_aux(
 939       ValueWrapper const& value_wrapper
 940     , T*
 941     , Policies*
 942     , ErrorPolicy*
 943     , ReturnType*
 944   )
 945   {
 946       lua_State* interpreter = value_wrapper_traits<ValueWrapper>::interpreter(
 947           value_wrapper
 948       );
 949
 950 #ifndef LUABIND_NO_ERROR_CHECKING
 951       if (!interpreter)
 952           return ErrorPolicy::handle_error(interpreter, typeid(void));
 953 #endif
 954
 955       value_wrapper_traits<ValueWrapper>::unwrap(interpreter, value_wrapper);
 956
 957       detail::stack_pop pop(interpreter, 1);
 958
 959       typedef typename detail::find_conversion_policy<
 960           0
 961         , Policies
 962       >::type converter_generator;
 963
 964       typename mpl::apply_wrap2<converter_generator, T, lua_to_cpp>::type cv;
 965
 966 #ifndef LUABIND_NO_ERROR_CHECKING
 967       if (cv.match(interpreter, LUABIND_DECORATE_TYPE(T), -1) < 0)
 968       {
 969           return ErrorPolicy::handle_error(interpreter, typeid(T));
 970       }
 971 #endif
 972
 973       return cv.apply(interpreter, LUABIND_DECORATE_TYPE(T), -1);
 974   }
 975
 976 # ifdef BOOST_MSVC
 977 #  pragma warning(push)
 978 #  pragma warning(disable:4702) // unreachable code
 979 # endif
 980
 981   template<class T>
 982   struct throw_error_policy
 983   {
 984       static T handle_error(lua_State* interpreter, type_id const& type_info)
 985       {
 986 #ifndef LUABIND_NO_EXCEPTIONS
 987           throw cast_failed(interpreter, type_info);
 988 #else
 989           cast_failed_callback_fun e = get_cast_failed_callback();
 990           if (e) e(interpreter, type_info);
 991
 992           assert(0 && "object_cast failed. If you want to handle this error use "
 993               "luabind::set_error_callback()");
 994           std::terminate();
 995 #endif
 996           return *(typename boost::remove_reference<T>::type*)0;
 997       }
 998   };
 999
1000 # ifdef BOOST_MSVC
1001 #  pragma warning(pop)
1002 # endif
1003
1004   template<class T>
1005   struct nothrow_error_policy
1006   {
1007       static boost::optional<T> handle_error(lua_State*, type_id const&)
1008       {
1009           return boost::optional<T>();
1010       }
1011   };
1012
1013 } // namespace detail
1014
1015 template<class T, class ValueWrapper>
1016 T object_cast(ValueWrapper const& value_wrapper)
1017 {
1018     return detail::object_cast_aux(
1019         value_wrapper
1020       , (T*)0
1021       , (detail::null_type*)0
1022       , (detail::throw_error_policy<T>*)0
1023       , (T*)0
1024     );
1025 }
1026
1027 template<class T, class ValueWrapper, class Policies>
1028 T object_cast(ValueWrapper const& value_wrapper, Policies const&)
1029 {
1030     return detail::object_cast_aux(
1031         value_wrapper
1032       , (T*)0
1033       , (Policies*)0
1034       , (detail::throw_error_policy<T>*)0
1035       , (T*)0
1036     );
1037 }
1038
1039 template<class T, class ValueWrapper>
1040 boost::optional<T> object_cast_nothrow(ValueWrapper const& value_wrapper)
1041 {
1042     return detail::object_cast_aux(
1043         value_wrapper
1044       , (T*)0
1045       , (detail::null_type*)0
1046       , (detail::nothrow_error_policy<T>*)0
1047       , (boost::optional<T>*)0
1048     );
1049 }
1050
1051 template<class T, class ValueWrapper, class Policies>
1052 boost::optional<T> object_cast_nothrow(ValueWrapper const& value_wrapper, Policies const&)
1053 {
1054     return detail::object_cast_aux(
1055         value_wrapper
1056       , (T*)0
1057       , (Policies*)0
1058       , (detail::nothrow_error_policy<T>*)0
1059       , (boost::optional<T>*)0
1060     );
1061 }
1062
1063 namespace detail
1064 {
1065
1066   template<int Index>
1067   struct push_args_from_tuple
1068   {
1069       template<class H, class T, class Policies>
1070       inline static void apply(lua_State* L, const boost::tuples::cons<H, T>& x, const Policies& p)
1071       {
1072           convert_to_lua_p<Index>(L, *x.get_head(), p);
1073           push_args_from_tuple<Index+1>::apply(L, x.get_tail(), p);
1074       }
1075
1076       template<class H, class T>
1077       inline static void apply(lua_State* L, const boost::tuples::cons<H, T>& x)
1078       {
1079           convert_to_lua(L, *x.get_head());
1080           push_args_from_tuple<Index+1>::apply(L, x.get_tail());
1081       }
1082
1083       template<class Policies>
1084       inline static void apply(lua_State*, const boost::tuples::null_type&, const Policies&) {}
1085
1086       inline static void apply(lua_State*, const boost::tuples::null_type&) {}
1087   };
1088
1089 } // namespace detail
1090
1091 namespace adl
1092 {
1093
1094   template<class ValueWrapper, class Arguments>
1095   struct call_proxy
1096   {
1097       call_proxy(ValueWrapper& value_wrapper, Arguments arguments)
1098         : value_wrapper(&value_wrapper)
1099         , arguments(arguments)
1100       {}
1101
1102       call_proxy(call_proxy const& other)
1103         : value_wrapper(other.value_wrapper)
1104         , arguments(other.arguments)
1105       {
1106           other.value_wrapper = 0;
1107       }
1108
1109       ~call_proxy()
1110       {
1111           if (value_wrapper)
1112               call((detail::null_type*)0);
1113       }
1114
1115       operator object()
1116       {
1117           return call((detail::null_type*)0);
1118       }
1119
1120       template<class Policies>
1121       object operator[](Policies const&)
1122       {
1123           return call((Policies*)0);
1124       }
1125
1126       template<class Policies>
1127       object call(Policies*)
1128       {
1129           lua_State* interpreter = value_wrapper_traits<ValueWrapper>::interpreter(
1130               *value_wrapper
1131           );
1132
1133           value_wrapper_traits<ValueWrapper>::unwrap(
1134               interpreter
1135             , *value_wrapper
1136           );
1137
1138           value_wrapper = 0;
1139
1140           detail::push_args_from_tuple<1>::apply(interpreter, arguments, Policies());
1141
1142           if (detail::pcall(interpreter, boost::tuples::length<Arguments>::value, 1))
1143           {
1144 #ifndef LUABIND_NO_EXCEPTIONS
1145               throw luabind::error(interpreter);
1146 #else
1147               error_callback_fun e = get_error_callback();
1148               if (e) e(interpreter);
1149
1150               assert(0 && "the lua function threw an error and exceptions are disabled."
1151                   "if you want to handle this error use luabind::set_error_callback()");
1152               std::terminate();
1153 #endif
1154           }
1155
1156           detail::stack_pop pop(interpreter, 1);
1157           return object(from_stack(interpreter, -1));
1158       }
1159
1160       mutable ValueWrapper* value_wrapper;
1161       Arguments arguments;
1162   };
1163
1164   template<class Derived>
1165   call_proxy<Derived, boost::tuples::tuple<> >
1166   object_interface<Derived>::operator()()
1167   {
1168       return call_proxy<Derived, boost::tuples::tuple<> >(
1169           derived()
1170         , boost::tuples::tuple<>()
1171       );
1172   }
1173
1174   // Simple value_wrapper adaptor with the sole purpose of helping with
1175   // overload resolution. Use this as a function parameter type instead
1176   // of "object" or "argument" to restrict the parameter to Lua tables.
1177   template <class Base = object>
1178   struct table : Base
1179   {
1180       table(from_stack const& stack_reference)
1181         : Base(stack_reference)
1182       {}
1183   };
1184
1185 } // namespace adl
1186
1187 using adl::table;
1188
1189 template <class Base>
1190 struct value_wrapper_traits<adl::table<Base> >
1191   : value_wrapper_traits<Base>
1192 {
1193     static bool check(lua_State* L, int idx)
1194     {
1195         return value_wrapper_traits<Base>::check(L, idx) &&
1196             lua_istable(L, idx);
1197     }
1198 };
1199
1200 inline object newtable(lua_State* interpreter)
1201 {
1202     lua_newtable(interpreter);
1203     detail::stack_pop pop(interpreter, 1);
1204     return object(from_stack(interpreter, -1));
1205 }
1206
1207 // this could be optimized by returning a proxy
1208 inline object globals(lua_State* interpreter)
1209 {
1210     lua_pushvalue(interpreter, LUA_GLOBALSINDEX);
1211     detail::stack_pop pop(interpreter, 1);
1212     return object(from_stack(interpreter, -1));
1213 }
1214
1215 // this could be optimized by returning a proxy
1216 inline object registry(lua_State* interpreter)
1217 {
1218     lua_pushvalue(interpreter, LUA_REGISTRYINDEX);
1219     detail::stack_pop pop(interpreter, 1);
1220     return object(from_stack(interpreter, -1));
1221 }
1222
1223 template<class ValueWrapper, class K>
1224 inline object gettable(ValueWrapper const& table, K const& key)
1225 {
1226     lua_State* interpreter = value_wrapper_traits<ValueWrapper>::interpreter(
1227         table
1228     );
1229
1230     value_wrapper_traits<ValueWrapper>::unwrap(interpreter, table);
1231     detail::stack_pop pop(interpreter, 2);
1232     detail::push(interpreter, key);
1233     lua_gettable(interpreter, -2);
1234     return object(from_stack(interpreter, -1));
1235 }
1236
1237 template<class ValueWrapper, class K, class T>
1238 inline void settable(ValueWrapper const& table, K const& key, T const& value)
1239 {
1240     lua_State* interpreter = value_wrapper_traits<ValueWrapper>::interpreter(
1241         table
1242     );
1243
1244     // TODO: Exception safe?
1245
1246     value_wrapper_traits<ValueWrapper>::unwrap(interpreter, table);
1247     detail::stack_pop pop(interpreter, 1);
1248     detail::push(interpreter, key);
1249     detail::push(interpreter, value);
1250     lua_settable(interpreter, -3);
1251 }
1252
1253 template<class ValueWrapper, class K>
1254 inline object rawget(ValueWrapper const& table, K const& key)
1255 {
1256     lua_State* interpreter = value_wrapper_traits<ValueWrapper>::interpreter(
1257         table
1258     );
1259
1260     value_wrapper_traits<ValueWrapper>::unwrap(interpreter, table);
1261     detail::stack_pop pop(interpreter, 2);
1262     detail::push(interpreter, key);
1263     lua_rawget(interpreter, -2);
1264     return object(from_stack(interpreter, -1));
1265 }
1266
1267 template<class ValueWrapper, class K, class T>
1268 inline void rawset(ValueWrapper const& table, K const& key, T const& value)
1269 {
1270     lua_State* interpreter = value_wrapper_traits<ValueWrapper>::interpreter(
1271         table
1272     );
1273
1274     // TODO: Exception safe?
1275
1276     value_wrapper_traits<ValueWrapper>::unwrap(interpreter, table);
1277     detail::stack_pop pop(interpreter, 1);
1278     detail::push(interpreter, key);
1279     detail::push(interpreter, value);
1280     lua_rawset(interpreter, -3);
1281 }
1282
1283 template<class ValueWrapper>
1284 inline int type(ValueWrapper const& value)
1285 {
1286     lua_State* interpreter = value_wrapper_traits<ValueWrapper>::interpreter(
1287         value
1288     );
1289
1290     value_wrapper_traits<ValueWrapper>::unwrap(interpreter, value);
1291     detail::stack_pop pop(interpreter, 1);
1292     return lua_type(interpreter, -1);
1293 }
1294
1295 template <class ValueWrapper>
1296 inline object getmetatable(ValueWrapper const& obj)
1297 {
1298     lua_State* interpreter = value_wrapper_traits<ValueWrapper>::interpreter(
1299         obj
1300     );
1301
1302     value_wrapper_traits<ValueWrapper>::unwrap(interpreter, obj);
1303     detail::stack_pop pop(interpreter, 2);
1304     lua_getmetatable(interpreter, -1);
1305     return object(from_stack(interpreter, -1));
1306 }
1307
1308 template <class ValueWrapper1, class ValueWrapper2>
1309 inline void setmetatable(
1310     ValueWrapper1 const& obj, ValueWrapper2 const& metatable)
1311 {
1312     lua_State* interpreter = value_wrapper_traits<ValueWrapper1>::interpreter(
1313         obj
1314     );
1315
1316     value_wrapper_traits<ValueWrapper1>::unwrap(interpreter, obj);
1317     detail::stack_pop pop(interpreter, 1);
1318     value_wrapper_traits<ValueWrapper2>::unwrap(interpreter, metatable);
1319     lua_setmetatable(interpreter, -2);
1320 }
1321
1322 template <class ValueWrapper>
1323 inline lua_CFunction tocfunction(ValueWrapper const& value)
1324 {
1325     lua_State* interpreter = value_wrapper_traits<ValueWrapper>::interpreter(
1326         value
1327     );
1328
1329     value_wrapper_traits<ValueWrapper>::unwrap(interpreter, value);
1330     detail::stack_pop pop(interpreter, 1);
1331     return lua_tocfunction(interpreter, -1);
1332 }
1333
1334 template <class T, class ValueWrapper>
1335 inline T* touserdata(ValueWrapper const& value)
1336 {
1337     lua_State* interpreter = value_wrapper_traits<ValueWrapper>::interpreter(
1338         value
1339     );
1340
1341     value_wrapper_traits<ValueWrapper>::unwrap(interpreter, value);
1342     detail::stack_pop pop(interpreter, 1);
1343     return static_cast<T*>(lua_touserdata(interpreter, -1));
1344 }
1345
1346 template <class ValueWrapper>
1347 inline object getupvalue(ValueWrapper const& value, int index)
1348 {
1349     lua_State* interpreter = value_wrapper_traits<ValueWrapper>::interpreter(
1350         value
1351     );
1352
1353     value_wrapper_traits<ValueWrapper>::unwrap(interpreter, value);
1354     detail::stack_pop pop(interpreter, 2);
1355     lua_getupvalue(interpreter, -1, index);
1356     return object(from_stack(interpreter, -1));
1357 }
1358
1359 template <class ValueWrapper1, class ValueWrapper2>
1360 inline void setupvalue(
1361     ValueWrapper1 const& function, int index, ValueWrapper2 const& value)
1362 {
1363     lua_State* interpreter = value_wrapper_traits<ValueWrapper1>::interpreter(
1364         function
1365     );
1366
1367     value_wrapper_traits<ValueWrapper1>::unwrap(interpreter, function);
1368     detail::stack_pop pop(interpreter, 1);
1369     value_wrapper_traits<ValueWrapper2>::unwrap(interpreter, value);
1370     lua_setupvalue(interpreter, -2, index);
1371 }
1372
1373 template <class GetValueWrapper>
1374 object property(GetValueWrapper const& get)
1375 {
1376     lua_State* interpreter = value_wrapper_traits<GetValueWrapper>::interpreter(
1377         get
1378     );
1379
1380     value_wrapper_traits<GetValueWrapper>::unwrap(interpreter, get);
1381     lua_pushnil(interpreter);
1382
1383     lua_pushcclosure(interpreter, &detail::property_tag, 2);
1384     detail::stack_pop pop(interpreter, 1);
1385
1386     return object(from_stack(interpreter, -1));
1387 }
1388
1389 template <class GetValueWrapper, class SetValueWrapper>
1390 object property(GetValueWrapper const& get, SetValueWrapper const& set)
1391 {
1392     lua_State* interpreter = value_wrapper_traits<GetValueWrapper>::interpreter(
1393         get
1394     );
1395
1396     value_wrapper_traits<GetValueWrapper>::unwrap(interpreter, get);
1397     value_wrapper_traits<SetValueWrapper>::unwrap(interpreter, set);
1398
1399     lua_pushcclosure(interpreter, &detail::property_tag, 2);
1400     detail::stack_pop pop(interpreter, 1);
1401
1402     return object(from_stack(interpreter, -1));
1403
1404 }
1405
1406
1407 } // namespace luabind
1408
1409 #endif // LUABIND_OBJECT_050419_HPP
1410