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