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
  42 #include <boost/iterator/iterator_facade.hpp> // iterator
  43 #include <boost/python/detail/is_xxx.hpp>
  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                 int 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* interpreter, 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, LUABIND_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, LUABIND_TYPEID(T));
 970       }
 971 #endif
 972
 973       return cv.apply(interpreter, LUABIND_DECORATE_TYPE(T), -1);
 974   }
 975
 976   template<class T>
 977   struct throw_error_policy
 978   {
 979       static T handle_error(lua_State* interpreter, LUABIND_TYPE_INFO type_info)
 980       {
 981 #ifndef LUABIND_NO_EXCEPTIONS
 982           throw cast_failed(interpreter, type_info);
 983 #else
 984           cast_failed_callback_fun e = get_cast_failed_callback();
 985           if (e) e(interpreter, type_info);
 986
 987           assert(0 && "object_cast failed. If you want to handle this error use "
 988               "luabind::set_error_callback()");
 989           std::terminate();
 990 #endif
 991           return *(typename boost::remove_reference<T>::type*)0;
 992       }
 993   };
 994
 995   template<class T>
 996   struct nothrow_error_policy
 997   {
 998       static boost::optional<T> handle_error(lua_State*, LUABIND_TYPE_INFO)
 999       {
1000           return boost::optional<T>();
1001       }
1002   };
1003
1004 } // namespace detail
1005
1006 template<class T, class ValueWrapper>
1007 T object_cast(ValueWrapper const& value_wrapper)
1008 {
1009     return detail::object_cast_aux(
1010         value_wrapper
1011       , (T*)0
1012       , (detail::null_type*)0
1013       , (detail::throw_error_policy<T>*)0
1014       , (T*)0
1015     );
1016 }
1017
1018 template<class T, class ValueWrapper, class Policies>
1019 T object_cast(ValueWrapper const& value_wrapper, Policies const&)
1020 {
1021     return detail::object_cast_aux(
1022         value_wrapper
1023       , (T*)0
1024       , (Policies*)0
1025       , (detail::throw_error_policy<T>*)0
1026       , (T*)0
1027     );
1028 }
1029
1030 template<class T, class ValueWrapper>
1031 boost::optional<T> object_cast_nothrow(ValueWrapper const& value_wrapper)
1032 {
1033     return detail::object_cast_aux(
1034         value_wrapper
1035       , (T*)0
1036       , (detail::null_type*)0
1037       , (detail::nothrow_error_policy<T>*)0
1038       , (boost::optional<T>*)0
1039     );
1040 }
1041
1042 template<class T, class ValueWrapper, class Policies>
1043 boost::optional<T> object_cast_nothrow(ValueWrapper const& value_wrapper, Policies const&)
1044 {
1045     return detail::object_cast_aux(
1046         value_wrapper
1047       , (T*)0
1048       , (Policies*)0
1049       , (detail::nothrow_error_policy<T>*)0
1050       , (boost::optional<T>*)0
1051     );
1052 }
1053
1054 namespace detail
1055 {
1056
1057   template<int Index>
1058   struct push_args_from_tuple
1059   {
1060       template<class H, class T, class Policies>
1061       inline static void apply(lua_State* L, const boost::tuples::cons<H, T>& x, const Policies& p)
1062       {
1063           convert_to_lua_p<Index>(L, *x.get_head(), p);
1064           push_args_from_tuple<Index+1>::apply(L, x.get_tail(), p);
1065       }
1066
1067       template<class H, class T>
1068       inline static void apply(lua_State* L, const boost::tuples::cons<H, T>& x)
1069       {
1070           convert_to_lua(L, *x.get_head());
1071           push_args_from_tuple<Index+1>::apply(L, x.get_tail());
1072       }
1073
1074       template<class Policies>
1075       inline static void apply(lua_State*, const boost::tuples::null_type&, const Policies&) {}
1076
1077       inline static void apply(lua_State*, const boost::tuples::null_type&) {}
1078   };
1079
1080 } // namespace detail
1081
1082 namespace adl
1083 {
1084
1085   template<class ValueWrapper, class Arguments>
1086   struct call_proxy
1087   {
1088       call_proxy(ValueWrapper& value_wrapper, Arguments arguments)
1089         : value_wrapper(&value_wrapper)
1090         , arguments(arguments)
1091       {}
1092
1093       call_proxy(call_proxy const& other)
1094         : value_wrapper(other.value_wrapper)
1095         , arguments(other.arguments)
1096       {
1097           other.value_wrapper = 0;
1098       }
1099
1100       ~call_proxy()
1101       {
1102           if (value_wrapper)
1103               call((detail::null_type*)0);
1104       }
1105
1106       operator object()
1107       {
1108           return call((detail::null_type*)0);
1109       }
1110
1111       template<class Policies>
1112       object operator[](Policies const&)
1113       {
1114           return call((Policies*)0);
1115       }
1116
1117       template<class Policies>
1118       object call(Policies*)
1119       {
1120           lua_State* interpreter = value_wrapper_traits<ValueWrapper>::interpreter(
1121               *value_wrapper
1122           );
1123
1124           value_wrapper_traits<ValueWrapper>::unwrap(
1125               interpreter
1126             , *value_wrapper
1127           );
1128
1129           value_wrapper = 0;
1130
1131           detail::push_args_from_tuple<1>::apply(interpreter, arguments, Policies());
1132
1133           if (detail::pcall(interpreter, boost::tuples::length<Arguments>::value, 1))
1134           {
1135 #ifndef LUABIND_NO_EXCEPTIONS
1136               throw luabind::error(interpreter);
1137 #else
1138               error_callback_fun e = get_error_callback();
1139               if (e) e(interpreter);
1140
1141               assert(0 && "the lua function threw an error and exceptions are disabled."
1142                   "if you want to handle this error use luabind::set_error_callback()");
1143               std::terminate();
1144 #endif
1145           }
1146
1147           detail::stack_pop pop(interpreter, 1);
1148           return object(from_stack(interpreter, -1));
1149       }
1150
1151       mutable ValueWrapper* value_wrapper;
1152       Arguments arguments;
1153   };
1154
1155   template<class Derived>
1156   call_proxy<Derived, boost::tuples::tuple<> >
1157   object_interface<Derived>::operator()()
1158   {
1159       return call_proxy<Derived, boost::tuples::tuple<> >(
1160           derived()
1161         , boost::tuples::tuple<>()
1162       );
1163   }
1164
1165 } // namespace adl
1166
1167 inline object newtable(lua_State* interpreter)
1168 {
1169     lua_newtable(interpreter);
1170     detail::stack_pop pop(interpreter, 1);
1171     return object(from_stack(interpreter, -1));
1172 }
1173
1174 // this could be optimized by returning a proxy
1175 inline object globals(lua_State* interpreter)
1176 {
1177     lua_pushvalue(interpreter, LUA_GLOBALSINDEX);
1178     detail::stack_pop pop(interpreter, 1);
1179     return object(from_stack(interpreter, -1));
1180 }
1181
1182 // this could be optimized by returning a proxy
1183 inline object registry(lua_State* interpreter)
1184 {
1185     lua_pushvalue(interpreter, LUA_REGISTRYINDEX);
1186     detail::stack_pop pop(interpreter, 1);
1187     return object(from_stack(interpreter, -1));
1188 }
1189
1190 template<class ValueWrapper, class K>
1191 inline object gettable(ValueWrapper const& table, K const& key)
1192 {
1193     lua_State* interpreter = value_wrapper_traits<ValueWrapper>::interpreter(
1194         table
1195     );
1196
1197     value_wrapper_traits<ValueWrapper>::unwrap(interpreter, table);
1198     detail::stack_pop pop(interpreter, 2);
1199     detail::push(interpreter, key);
1200     lua_gettable(interpreter, -2);
1201     return object(from_stack(interpreter, -1));
1202 }
1203
1204 template<class ValueWrapper, class K, class T>
1205 inline void settable(ValueWrapper const& table, K const& key, T const& value)
1206 {
1207     lua_State* interpreter = value_wrapper_traits<ValueWrapper>::interpreter(
1208         table
1209     );
1210
1211     // TODO: Exception safe?
1212
1213     value_wrapper_traits<ValueWrapper>::unwrap(interpreter, table);
1214     detail::stack_pop pop(interpreter, 1);
1215     detail::push(interpreter, key);
1216     detail::push(interpreter, value);
1217     lua_settable(interpreter, -3);
1218 }
1219
1220 template<class ValueWrapper, class K>
1221 inline object rawget(ValueWrapper const& table, K const& key)
1222 {
1223     lua_State* interpreter = value_wrapper_traits<ValueWrapper>::interpreter(
1224         table
1225     );
1226
1227     value_wrapper_traits<ValueWrapper>::unwrap(interpreter, table);
1228     detail::stack_pop pop(interpreter, 2);
1229     detail::push(interpreter, key);
1230     lua_rawget(interpreter, -2);
1231     return object(from_stack(interpreter, -1));
1232 }
1233
1234 template<class ValueWrapper, class K, class T>
1235 inline void rawset(ValueWrapper const& table, K const& key, T const& value)
1236 {
1237     lua_State* interpreter = value_wrapper_traits<ValueWrapper>::interpreter(
1238         table
1239     );
1240
1241     // TODO: Exception safe?
1242
1243     value_wrapper_traits<ValueWrapper>::unwrap(interpreter, table);
1244     detail::stack_pop pop(interpreter, 1);
1245     detail::push(interpreter, key);
1246     detail::push(interpreter, value);
1247     lua_rawset(interpreter, -3);
1248 }
1249
1250 template<class ValueWrapper>
1251 inline int type(ValueWrapper const& value)
1252 {
1253     lua_State* interpreter = value_wrapper_traits<ValueWrapper>::interpreter(
1254         value
1255     );
1256
1257     value_wrapper_traits<ValueWrapper>::unwrap(interpreter, value);
1258     detail::stack_pop pop(interpreter, 1);
1259     return lua_type(interpreter, -1);
1260 }
1261
1262 template <class ValueWrapper>
1263 inline object getmetatable(ValueWrapper const& obj)
1264 {
1265     lua_State* interpreter = value_wrapper_traits<ValueWrapper>::interpreter(
1266         obj
1267     );
1268
1269     value_wrapper_traits<ValueWrapper>::unwrap(interpreter, obj);
1270     detail::stack_pop pop(interpreter, 2);
1271     lua_getmetatable(interpreter, -1);
1272     return object(from_stack(interpreter, -1));
1273 }
1274
1275 template <class ValueWrapper1, class ValueWrapper2>
1276 inline void setmetatable(
1277     ValueWrapper1 const& obj, ValueWrapper2 const& metatable)
1278 {
1279     lua_State* interpreter = value_wrapper_traits<ValueWrapper1>::interpreter(
1280         obj
1281     );
1282
1283     value_wrapper_traits<ValueWrapper1>::unwrap(interpreter, obj);
1284     detail::stack_pop pop(interpreter, 1);
1285     value_wrapper_traits<ValueWrapper2>::unwrap(interpreter, metatable);
1286     lua_setmetatable(interpreter, -2);
1287 }
1288
1289 template <class ValueWrapper>
1290 inline lua_CFunction tocfunction(ValueWrapper const& value)
1291 {
1292     lua_State* interpreter = value_wrapper_traits<ValueWrapper>::interpreter(
1293         value
1294     );
1295
1296     value_wrapper_traits<ValueWrapper>::unwrap(interpreter, value);
1297     detail::stack_pop pop(interpreter, 1);
1298     return lua_tocfunction(interpreter, -1);
1299 }
1300
1301 template <class T, class ValueWrapper>
1302 inline T* touserdata(ValueWrapper const& value)
1303 {
1304     lua_State* interpreter = value_wrapper_traits<ValueWrapper>::interpreter(
1305         value
1306     );
1307
1308     value_wrapper_traits<ValueWrapper>::unwrap(interpreter, value);
1309     detail::stack_pop pop(interpreter, 1);
1310     return static_cast<T*>(lua_touserdata(interpreter, -1));
1311 }
1312
1313 template <class ValueWrapper>
1314 inline object getupvalue(ValueWrapper const& value, int index)
1315 {
1316     lua_State* interpreter = value_wrapper_traits<ValueWrapper>::interpreter(
1317         value
1318     );
1319
1320     value_wrapper_traits<ValueWrapper>::unwrap(interpreter, value);
1321     detail::stack_pop pop(interpreter, 2);
1322     lua_getupvalue(interpreter, -1, index);
1323     return object(from_stack(interpreter, -1));
1324 }
1325
1326 template <class ValueWrapper1, class ValueWrapper2>
1327 inline void setupvalue(
1328     ValueWrapper1 const& function, int index, ValueWrapper2 const& value)
1329 {
1330     lua_State* interpreter = value_wrapper_traits<ValueWrapper1>::interpreter(
1331         function
1332     );
1333
1334     value_wrapper_traits<ValueWrapper1>::unwrap(interpreter, function);
1335     detail::stack_pop pop(interpreter, 1);
1336     value_wrapper_traits<ValueWrapper2>::unwrap(interpreter, value);
1337     lua_setupvalue(interpreter, -2, index);
1338 }
1339
1340 template <class GetValueWrapper>
1341 object property(GetValueWrapper const& get)
1342 {
1343     lua_State* interpreter = value_wrapper_traits<GetValueWrapper>::interpreter(
1344         get
1345     );
1346
1347     value_wrapper_traits<GetValueWrapper>::unwrap(interpreter, get);
1348     lua_pushnil(interpreter);
1349
1350     lua_pushcclosure(interpreter, &detail::property_tag, 2);
1351     detail::stack_pop pop(interpreter, 1);
1352
1353     return object(from_stack(interpreter, -1));
1354 }
1355
1356 template <class GetValueWrapper, class SetValueWrapper>
1357 object property(GetValueWrapper const& get, SetValueWrapper const& set)
1358 {
1359     lua_State* interpreter = value_wrapper_traits<GetValueWrapper>::interpreter(
1360         get
1361     );
1362
1363     value_wrapper_traits<GetValueWrapper>::unwrap(interpreter, get);
1364     value_wrapper_traits<SetValueWrapper>::unwrap(interpreter, set);
1365
1366     lua_pushcclosure(interpreter, &detail::property_tag, 2);
1367     detail::stack_pop pop(interpreter, 1);
1368
1369     return object(from_stack(interpreter, -1));
1370
1371 }
1372
1373
1374 } // namespace luabind
1375
1376 #endif // LUABIND_OBJECT_050419_HPP
1377