luabind/detail/policy.hpp

   1 // Copyright (c) 2003 Daniel Wallin and Arvid Norberg
   2
   3 // Permission is hereby granted, free of charge, to any person obtaining a
   4 // copy of this software and associated documentation files (the "Software"),
   5 // to deal in the Software without restriction, including without limitation
   6 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
   7 // and/or sell copies of the Software, and to permit persons to whom the
   8 // Software is furnished to do so, subject to the following conditions:
   9
  10 // The above copyright notice and this permission notice shall be included
  11 // in all copies or substantial portions of the Software.
  12
  13 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
  14 // ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
  15 // TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
  16 // PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
  17 // SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
  18 // ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  19 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  20 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
  21 // OR OTHER DEALINGS IN THE SOFTWARE.
  22
  23
  24 #ifndef LUABIND_POLICY_HPP_INCLUDED
  25 #define LUABIND_POLICY_HPP_INCLUDED
  26
  27 #include <luabind/config.hpp>
  28
  29 #include <typeinfo>
  30
  31 #include <boost/type_traits/is_enum.hpp>
  32 #include <boost/mpl/bool.hpp>
  33 #include <boost/mpl/integral_c.hpp>
  34 #include <boost/mpl/equal_to.hpp>
  35 #include <boost/type_traits/add_reference.hpp>
  36 #include <boost/limits.hpp>
  37
  38 #include <luabind/detail/class_registry.hpp>
  39 #include <luabind/detail/primitives.hpp>
  40 #include <luabind/detail/object_rep.hpp>
  41 #include <luabind/detail/typetraits.hpp>
  42
  43 #include <boost/type_traits/add_reference.hpp>
  44
  45 #include <luabind/detail/decorate_type.hpp>
  46 #include <luabind/object.hpp>
  47
  48 namespace luabind
  49 {
  50         namespace detail
  51         {
  52                 struct conversion_policy_base {};
  53         }
  54
  55         template<int N, bool HasArg = true>
  56         struct conversion_policy : detail::conversion_policy_base
  57         {
  58                 BOOST_STATIC_CONSTANT(int, index = N);
  59                 BOOST_STATIC_CONSTANT(bool, has_arg = HasArg);
  60         };
  61
  62         class index_map
  63         {
  64         public:
  65
  66                 index_map(const int* m): m_map(m) {}
  67
  68                 int operator[](int index) const
  69                 {
  70                         return m_map[index + 1];
  71                 }
  72
  73         private:
  74
  75                 const int* m_map;
  76         };
  77
  78         namespace converters
  79         {
  80                 using luabind::detail::yes_t;
  81                 using luabind::detail::no_t;
  82                 using luabind::detail::by_value;
  83                 using luabind::detail::by_reference;
  84                 using luabind::detail::by_const_reference;
  85                 using luabind::detail::by_pointer;
  86                 using luabind::detail::by_const_pointer;
  87
  88                 no_t is_user_defined(...);
  89         }
  90
  91         namespace detail
  92         {
  93                 template<class T>
  94                 struct is_user_defined
  95                 {
  96                         BOOST_STATIC_CONSTANT(bool, value =
  97                                 sizeof(luabind::converters::is_user_defined(LUABIND_DECORATE_TYPE(T))) == sizeof(yes_t));
  98                 };
  99
 100                 int implicit_cast(const class_rep* crep, LUABIND_TYPE_INFO const&, int& pointer_offset);
 101         }
 102
 103          template<class T> class functor;
 104          class object;
 105 }
 106
 107 namespace luabind { namespace detail
 108 {
 109         template<class>
 110         struct is_primitive;
 111
 112         template<class T>
 113         yes_t is_lua_functor_test(const functor<T>&);
 114
 115 #if defined(BOOST_MSVC) && (BOOST_MSVC <= 1300)
 116         no_t is_lua_functor_test(...);
 117 #else
 118         template<class T>
 119         no_t is_lua_functor_test(const T&);
 120 #endif
 121
 122         template<class T>
 123         struct is_lua_functor
 124         {
 125                 static T t;
 126
 127                 BOOST_STATIC_CONSTANT(bool, value = sizeof(is_lua_functor_test(t)) == sizeof(yes_t));
 128         };
 129
 130         namespace
 131         {
 132                 static char msvc_fix[64];
 133         }
 134
 135         template<class T>
 136         struct indirect_type
 137         {
 138                 typedef typename
 139                         boost::mpl::if_<is_primitive<T>
 140                                 , const type<T>&
 141                                 , typename boost::mpl::apply_if<boost::mpl::or_<boost::is_reference<T>, boost::is_pointer<T> >
 142                                         , identity<T>
 143                                         , boost::add_reference<T>
 144                                 >::type
 145                         >::type result_type;
 146
 147                 static inline result_type get()
 148                 {
 149                         return reinterpret_cast<result_type>(msvc_fix);
 150                 }
 151         };
 152
 153         template<class H, class T>
 154         struct policy_cons
 155         {
 156                 typedef H head;
 157                 typedef T tail;
 158
 159                 template<class U>
 160                 policy_cons<U, policy_cons<H,T> > operator,(policy_cons<U,detail::null_type>)
 161                 {
 162                         return policy_cons<U, policy_cons<H,T> >();
 163                 }
 164
 165                 template<class U>
 166                 policy_cons<U, policy_cons<H,T> > operator+(policy_cons<U,detail::null_type>)
 167                 {
 168                         return policy_cons<U, policy_cons<H,T> >();
 169                 }
 170
 171                 template<class U>
 172                 policy_cons<U, policy_cons<H,T> > operator|(policy_cons<U,detail::null_type>)
 173                 {
 174                         return policy_cons<U, policy_cons<H,T> >();
 175                 }
 176         };
 177
 178         struct indirection_layer
 179         {
 180                 template<class T>
 181                 indirection_layer(const T&);
 182         };
 183
 184         template<class H, class T>
 185         yes_t is_policy_cons_test(const policy_cons<H,T>&);
 186         no_t is_policy_cons_test(...);
 187
 188         template<class T>
 189         struct is_policy_cons
 190         {
 191                 static const T& t;
 192
 193                 BOOST_STATIC_CONSTANT(bool, value =
 194                         sizeof(is_policy_cons_test(t)) == sizeof(yes_t));
 195         };
 196
 197         no_t is_string_literal(indirection_layer);
 198         yes_t is_string_literal(const char*);
 199
 200         template<class T>
 201         struct is_primitive/*: boost::mpl::bool_c<false>*/
 202         {
 203                 static T t;
 204
 205                 BOOST_STATIC_CONSTANT(bool, value = sizeof(is_string_literal(t)) == sizeof(yes_t));
 206         };
 207
 208         template<> struct is_primitive<luabind::object>: boost::mpl::bool_<true> {};
 209         template<> struct is_primitive<const luabind::object>: boost::mpl::bool_<true> {};
 210         template<> struct is_primitive<const luabind::object&>: boost::mpl::bool_<true> {};
 211
 212         template<> struct is_primitive<int>: boost::mpl::bool_<true> {};
 213         template<> struct is_primitive<char>: boost::mpl::bool_<true> {};
 214         template<> struct is_primitive<short>: boost::mpl::bool_<true> {};
 215         template<> struct is_primitive<long>: boost::mpl::bool_<true> {};
 216         template<> struct is_primitive<unsigned char>: boost::mpl::bool_<true> {};
 217         template<> struct is_primitive<unsigned short>: boost::mpl::bool_<true> {};
 218         template<> struct is_primitive<unsigned long>: boost::mpl::bool_<true> {};
 219         template<> struct is_primitive<unsigned int>: boost::mpl::bool_<true> {};
 220         template<> struct is_primitive<float>: boost::mpl::bool_<true> {};
 221         template<> struct is_primitive<double>: boost::mpl::bool_<true> {};
 222         template<> struct is_primitive<long double>: boost::mpl::bool_<true> {};
 223         template<> struct is_primitive<char*>: boost::mpl::bool_<true> {};
 224         template<> struct is_primitive<bool>: boost::mpl::bool_<true> {};
 225
 226         template<> struct is_primitive<const int>: boost::mpl::bool_<true> {};
 227         template<> struct is_primitive<const char>: boost::mpl::bool_<true> {};
 228         template<> struct is_primitive<const short>: boost::mpl::bool_<true> {};
 229         template<> struct is_primitive<const long>: boost::mpl::bool_<true> {};
 230         template<> struct is_primitive<const unsigned int>: boost::mpl::bool_<true> {};
 231         template<> struct is_primitive<const unsigned char>: boost::mpl::bool_<true> {};
 232         template<> struct is_primitive<const unsigned short>: boost::mpl::bool_<true> {};
 233         template<> struct is_primitive<const unsigned long>: boost::mpl::bool_<true> {};
 234         template<> struct is_primitive<const float>: boost::mpl::bool_<true> {};
 235         template<> struct is_primitive<const double>: boost::mpl::bool_<true> {};
 236         template<> struct is_primitive<const long double>: boost::mpl::bool_<true> {};
 237         template<> struct is_primitive<const char*>: boost::mpl::bool_<true> {};
 238         template<> struct is_primitive<const char* const>: boost::mpl::bool_<true> {};
 239         template<> struct is_primitive<const bool>: boost::mpl::bool_<true> {};
 240
 241         // TODO: add more
 242         template<> struct is_primitive<const int&>: boost::mpl::bool_<true> {};
 243         template<> struct is_primitive<const char&>: boost::mpl::bool_<true> {};
 244         template<> struct is_primitive<const short&>: boost::mpl::bool_<true> {};
 245         template<> struct is_primitive<const long&>: boost::mpl::bool_<true> {};
 246         template<> struct is_primitive<const unsigned int&>: boost::mpl::bool_<true> {};
 247         template<> struct is_primitive<const unsigned char&>: boost::mpl::bool_<true> {};
 248         template<> struct is_primitive<const unsigned short&>: boost::mpl::bool_<true> {};
 249         template<> struct is_primitive<const unsigned long&>: boost::mpl::bool_<true> {};
 250         template<> struct is_primitive<const float&>: boost::mpl::bool_<true> {};
 251         template<> struct is_primitive<const double&>: boost::mpl::bool_<true> {};
 252         template<> struct is_primitive<const long double&>: boost::mpl::bool_<true> {};
 253         template<> struct is_primitive<const bool&>: boost::mpl::bool_<true> {};
 254
 255         template<> struct is_primitive<const std::string&>: boost::mpl::bool_<true> {};
 256         template<> struct is_primitive<std::string>: boost::mpl::bool_<true> {};
 257         template<> struct is_primitive<const std::string>: boost::mpl::bool_<true> {};
 258
 259
 260         template<class Direction> struct primitive_converter;
 261
 262         template<>
 263         struct primitive_converter<cpp_to_lua>
 264         {
 265                 void apply(lua_State* L, const luabind::object& v)
 266                 {
 267                         // if you hit this assert you are trying to return a value from one state into another lua state
 268                         assert((v.lua_state() == L) && "you cannot return a value from one lua state into another");
 269                         v.pushvalue();
 270                 }
 271                 void apply(lua_State* L, int v) { lua_pushnumber(L, v); }
 272                 void apply(lua_State* L, short v) { lua_pushnumber(L, v); }
 273                 void apply(lua_State* L, char v) { lua_pushnumber(L, v); }
 274                 void apply(lua_State* L, long v) { lua_pushnumber(L, v); }
 275                 void apply(lua_State* L, unsigned int v) { lua_pushnumber(L, v); }
 276                 void apply(lua_State* L, unsigned short v) { lua_pushnumber(L, v); }
 277                 void apply(lua_State* L, unsigned char v) { lua_pushnumber(L, v); }
 278                 void apply(lua_State* L, unsigned long v) { lua_pushnumber(L, v); }
 279                 void apply(lua_State* L, float v) { lua_pushnumber(L, v); }
 280                 void apply(lua_State* L, double v) { lua_pushnumber(L, v); }
 281                 void apply(lua_State* L, long double v) { lua_pushnumber(L, v); }
 282                 void apply(lua_State* L, const char* v) { lua_pushstring(L, v); }
 283                 void apply(lua_State* L, const std::string& v) { lua_pushstring(L, v.c_str()); }
 284                 void apply(lua_State* L, bool b) { lua_pushboolean(L, b); }
 285         };
 286
 287         template<>
 288         struct primitive_converter<lua_to_cpp>
 289         {
 290                 // TODO: add more
 291                 bool apply(lua_State* L, detail::by_value<bool>, int index) { return lua_toboolean(L, index) == 1; }
 292                 float apply(lua_State* L, detail::by_value<float>, int index) { return static_cast<float>(lua_tonumber(L, index)); }
 293                 double apply(lua_State* L, detail::by_value<double>, int index) { return static_cast<double>(lua_tonumber(L, index)); }
 294                 long double apply(lua_State* L, detail::by_value<long double>, int index) { return static_cast<long double>(lua_tonumber(L, index)); }
 295                 int apply(lua_State* L, detail::by_value<int>, int index) { return static_cast<int>(lua_tonumber(L, index)); }
 296                 short apply(lua_State* L, detail::by_value<short>, int index) { return static_cast<short>(lua_tonumber(L, index)); }
 297                 char apply(lua_State* L, detail::by_value<char>, int index) { return static_cast<char>(lua_tonumber(L, index)); }
 298                 long apply(lua_State* L, detail::by_value<long>, int index) { return static_cast<long>(lua_tonumber(L, index)); }
 299                 unsigned int apply(lua_State* L, detail::by_value<unsigned int>, int index) { return static_cast<unsigned int>(lua_tonumber(L, index)); }
 300                 unsigned short apply(lua_State* L, detail::by_value<unsigned short>, int index) { return static_cast<short>(lua_tonumber(L, index)); }
 301                 unsigned char apply(lua_State* L, detail::by_value<unsigned char>, int index) { return static_cast<char>(lua_tonumber(L, index)); }
 302                 unsigned long apply(lua_State* L, detail::by_value<unsigned long>, int index) { return static_cast<long>(lua_tonumber(L, index)); }
 303
 304                 float apply(lua_State* L, detail::by_value<const float>, int index) { return static_cast<float>(lua_tonumber(L, index)); }
 305                 double apply(lua_State* L, detail::by_value<const double>, int index) { return static_cast<double>(lua_tonumber(L, index)); }
 306                 long double apply(lua_State* L, detail::by_value<const long double>, int index) {return  static_cast<long double>(lua_tonumber(L, index)); }
 307                 int apply(lua_State* L, detail::by_value<const int>, int index) { return static_cast<int>(lua_tonumber(L, index)); }
 308                 short apply(lua_State* L, detail::by_value<const short>, int index) { return static_cast<short>(lua_tonumber(L, index)); }
 309                 char apply(lua_State* L, detail::by_value<const char>, int index) { return static_cast<char>(lua_tonumber(L, index)); }
 310                 long apply(lua_State* L, detail::by_value<const long>, int index) { return static_cast<long>(lua_tonumber(L, index)); }
 311
 312                 unsigned int apply(lua_State* L, detail::by_value<const unsigned int>, int index) { return static_cast<int>(lua_tonumber(L, index)); }
 313                 unsigned short apply(lua_State* L, detail::by_value<const unsigned short>, int index) { return static_cast<short>(lua_tonumber(L, index)); }
 314                 unsigned char apply(lua_State* L, detail::by_value<const unsigned char>, int index) { return static_cast<char>(lua_tonumber(L, index)); }
 315                 unsigned long apply(lua_State* L, detail::by_value<const unsigned long>, int index) { return static_cast<long>(lua_tonumber(L, index)); }
 316
 317                 std::string apply(lua_State* L, detail::by_value<std::string>, int index) { return static_cast<const char*>(lua_tostring(L, index)); }
 318                 const std::string apply(lua_State* L, detail::by_value<const std::string>, int index) { return static_cast<const char*>(lua_tostring(L, index)); }
 319
 320                 luabind::object apply(lua_State* L, detail::by_value<luabind::object>, int index)
 321                 {
 322                         lua_pushvalue(L, index);
 323                         return luabind::object(L, detail::ref(L), true/*luabind::object::reference()*/);
 324                 }
 325
 326                 const luabind::object apply(lua_State* L, detail::by_value<const luabind::object>, int index)
 327                 {
 328                         lua_pushvalue(L, index);
 329                         return luabind::object(L, detail::ref(L), true/*luabind::object::reference()*/);
 330                 }
 331
 332                 // TODO: add more
 333
 334                 template<class T>
 335                 T apply(lua_State* L, detail::by_const_reference<T>, int index) { return apply(L, detail::by_value<T>(), index); }
 336
 337                 const char* apply(lua_State* L, detail::by_const_pointer<char>, int index) { return static_cast<const char*>(lua_tostring(L, index)); }
 338
 339                 // matchers
 340                 static int match(lua_State* L, detail::by_value<bool>, int index) { if (lua_type(L, index) == LUA_TBOOLEAN) return 0; else return -1;}
 341                 static int match(lua_State* L, detail::by_value<float>, int index) { if (lua_type(L, index) == LUA_TNUMBER) return 0; else return -1;}
 342                 static int match(lua_State* L, detail::by_value<double>, int index) { if (lua_type(L, index) == LUA_TNUMBER) return 0; else return -1;}
 343                 static int match(lua_State* L, detail::by_value<long double>, int index) { if (lua_type(L, index) == LUA_TNUMBER) return 0; else return -1;}
 344                 static int match(lua_State* L, detail::by_value<int>, int index) { if (lua_type(L, index) == LUA_TNUMBER) return 0; else return -1;}
 345                 static int match(lua_State* L, detail::by_value<short>, int index) { if (lua_type(L, index) == LUA_TNUMBER) return 0; else return -1;}
 346                 static int match(lua_State* L, detail::by_value<char>, int index) { if (lua_type(L, index) == LUA_TNUMBER) return 0; else return -1;}
 347                 static int match(lua_State* L, detail::by_value<long>, int index) { if (lua_type(L, index) == LUA_TNUMBER) return 0; else return -1;}
 348                 static int match(lua_State* L, detail::by_value<unsigned int>, int index) { if (lua_type(L, index) == LUA_TNUMBER) return 0; else return -1;}
 349                 static int match(lua_State* L, detail::by_value<unsigned short>, int index) { if (lua_type(L, index) == LUA_TNUMBER) return 0; else return -1;}
 350                 static int match(lua_State* L, detail::by_value<unsigned char>, int index) { if (lua_type(L, index) == LUA_TNUMBER) return 0; else return -1;}
 351                 static int match(lua_State* L, detail::by_value<unsigned long>, int index) { if (lua_type(L, index) == LUA_TNUMBER) return 0; else return -1;}
 352                 static int match(lua_State* L, detail::by_value<std::string>, int index) { if (lua_type(L, index) == LUA_TSTRING) return 0; else return -1;}
 353                 static int match(lua_State* L, detail::by_value<const std::string>, int index) { if (lua_type(L, index) == LUA_TSTRING) return 0; else return -1;}
 354                 static int match(lua_State*, detail::by_value<luabind::object>, int) { return std::numeric_limits<int>::max() - 1; }
 355                 static int match(lua_State*, detail::by_value<const luabind::object>, int) { return std::numeric_limits<int>::max() - 1; }
 356
 357                 static int match(lua_State* L, by_const_pointer<char>, int index) { if (lua_type(L, index) == LUA_TSTRING) return 0; else return -1;}
 358                 static int match(lua_State* L, by_const_pointer<const char>, int index) { if (lua_type(L, index) == LUA_TSTRING) return 0; else return -1;}
 359
 360                 template<class T>
 361                 static int match(lua_State* L, detail::by_const_reference<T>, int index) { return match(L, detail::by_value<T>(), index); }
 362
 363                 template<class T>
 364                 void converter_postcall(lua_State*, T, int) {}
 365         };
 366
 367
 368
 369 // *********** default converters ***************
 370
 371
 372 // ********** user defined converter ***********
 373
 374         template<class Direction> struct user_defined_converter;
 375
 376         template<>
 377         struct user_defined_converter<lua_to_cpp>
 378         {
 379                 template<class T>
 380                 T apply(lua_State* L, detail::by_value<T>, int index)
 381                 {
 382 //                      std::cerr << "user_defined_converter\n";
 383                         return converters::convert_lua_to_cpp(L, detail::by_value<T>(), index);
 384                 }
 385
 386                 template<class T>
 387                 T apply(lua_State* L, detail::by_reference<T>, int index)
 388                 {
 389 //                      std::cerr << "user_defined_converter\n";
 390                         return converters::convert_lua_to_cpp(L, detail::by_reference<T>(), index);
 391                 }
 392
 393                 template<class T>
 394                 T apply(lua_State* L, detail::by_const_reference<T>, int index)
 395                 {
 396 //                      std::cerr << "user_defined_converter\n";
 397                         return converters::convert_lua_to_cpp(L, detail::by_const_reference<T>(), index);
 398                 }
 399
 400                 template<class T>
 401                 T* apply(lua_State* L, detail::by_pointer<T>, int index)
 402                 {
 403 //                      std::cerr << "user_defined_converter\n";
 404                         return converters::convert_lua_to_cpp(L, detail::by_pointer<T>(), index);
 405                 }
 406
 407                 template<class T>
 408                 const T* apply(lua_State* L, detail::by_const_pointer<T>, int index)
 409                 {
 410 //                      std::cerr << "user_defined_converter\n";
 411                         return converters::convert_lua_to_cpp(L, detail::by_pointer<T>(), index);
 412                 }
 413
 414                 template<class T>
 415                 static int match(lua_State* L, T, int index)
 416                 {
 417                         return converters::match_lua_to_cpp(L, T(), index);
 418                 }
 419
 420                 template<class T>
 421                 void converter_postcall(lua_State*, T, int) {}
 422         };
 423
 424         template<>
 425         struct user_defined_converter<cpp_to_lua>
 426         {
 427                         template<class T>
 428                         void apply(lua_State* L, const T& v)
 429                         {
 430                                 converters::convert_cpp_to_lua(L, v);
 431                         }
 432         };
 433
 434 // ********** pointer converter ***********
 435
 436
 437         template<class Direction> struct pointer_converter;
 438
 439         template<>
 440         struct pointer_converter<cpp_to_lua>
 441         {
 442                 template<class T>
 443                 void apply(lua_State* L, T* ptr)
 444                 {
 445                         if (ptr == 0)
 446                         {
 447                                 lua_pushnil(L);
 448                                 return;
 449                         }
 450
 451                         class_registry* registry = class_registry::get_registry(L);
 452                         class_rep* crep = registry->find_class(LUABIND_TYPEID(T));
 453
 454                         // if you get caught in this assert you are
 455                         // trying to use an unregistered type
 456                         assert(crep && "you are trying to use an unregistered type");
 457
 458                         // create the struct to hold the object
 459                         void* obj = lua_newuserdata(L, sizeof(object_rep));
 460                         //new(obj) object_rep(ptr, crep, object_rep::owner, destructor_s<T>::apply);
 461                         new(obj) object_rep(ptr, crep, 0, 0);
 462
 463                         // set the meta table
 464                         detail::getref(L, crep->metatable_ref());
 465                         lua_setmetatable(L, -2);
 466                 }
 467         };
 468
 469         template<class T> struct make_pointer { typedef T* type; };
 470         template<>
 471         struct pointer_converter<lua_to_cpp>
 472         {
 473                 template<class T>
 474                 typename make_pointer<T>::type apply(lua_State* L, by_pointer<T>, int index)
 475                 {
 476                         // preconditions:
 477                         //      lua_isuserdata(L, index);
 478                         // getmetatable().__lua_class is true
 479                         // object_rep->flags() & object_rep::constant == 0
 480
 481                         if (lua_isnil(L, index)) return 0;
 482
 483                         int offset = 0;
 484                         object_rep* obj = static_cast<object_rep*>(lua_touserdata(L, index));
 485                         assert((obj != 0) && "internal error, please report"); // internal error
 486                         const class_rep* crep = obj->crep();
 487
 488                         int steps = implicit_cast(crep, LUABIND_TYPEID(T), offset);
 489
 490                         // should never be called with a type that can't be cast
 491                         assert((steps >= 0) && "internal error, please report");
 492
 493                         T* ptr = reinterpret_cast<T*>(obj->ptr(offset));
 494 //                      std::cerr << "pointer_converter<lua_to_cpp>: " << ptr << " " << offset << "\n";
 495
 496                         return ptr;
 497                 }
 498
 499                 template<class T>
 500                 static int match(lua_State* L, by_pointer<T>, int index)
 501                 {
 502                         if (lua_isnil(L, index)) return 0;
 503                         object_rep* obj = is_class_object(L, index);
 504                         if (obj == 0) return -1;
 505                         // cannot cast a constant object to nonconst
 506                         if (obj->flags() & object_rep::constant) return -1;
 507                         int d;
 508                         return implicit_cast(obj->crep(), LUABIND_TYPEID(T), d);
 509                 }
 510
 511                 template<class T>
 512                 void converter_postcall(lua_State*, T, int) {}
 513         };
 514
 515 // ******* value converter *******
 516
 517         template<class Direction> struct value_converter;
 518
 519         template<>
 520         struct value_converter<cpp_to_lua>
 521         {
 522                 template<class T>
 523                 void apply(lua_State* L, const T& ref)
 524                 {
 525                         class_registry* registry = class_registry::get_registry(L);
 526                         class_rep* crep = registry->find_class(LUABIND_TYPEID(T));
 527
 528                         // if you get caught in this assert you are
 529                         // trying to use an unregistered type
 530                         assert(crep && "you are trying to use an unregistered type");
 531
 532                         T* copied_obj = new T(ref);
 533
 534 //                      std::cerr << "value_converter<cpp_to_lua>: " << copied_obj << "\n";
 535
 536                         // create the struct to hold the object
 537                         void* obj = lua_newuserdata(L, sizeof(object_rep));
 538                         // we send 0 as destructor since we know it will never be called
 539                         new(obj) object_rep(copied_obj, crep, object_rep::owner, destructor<T>);
 540
 541                         // set the meta table
 542                         detail::getref(L, crep->metatable_ref());
 543                         lua_setmetatable(L, -2);
 544                 }
 545         };
 546
 547
 548         template<class T> struct make_const_reference { typedef const T& type; };
 549
 550         template<>
 551         struct value_converter<lua_to_cpp>
 552         {
 553                 template<class T>
 554                 typename make_const_reference<T>::type apply(lua_State* L, by_value<T>, int index)
 555                 {
 556                         // preconditions:
 557                         //      lua_isuserdata(L, index);
 558                         // getmetatable().__lua_class is true
 559                         // object_rep->flags() & object_rep::constant == 0
 560
 561                         assert((lua_isnil(L, index) == false) && "internal error, please report");
 562
 563                         int offset = 0;
 564                         object_rep* obj = static_cast<object_rep*>(lua_touserdata(L, index));
 565                         assert((obj != 0) && "internal error, please report"); // internal error
 566                         const class_rep* crep = obj->crep();
 567
 568                         int steps = implicit_cast(crep, LUABIND_TYPEID(T), offset);
 569
 570                         // should never be called with a type that can't be cast
 571                         assert((steps >= 0) && "internal error, please report");
 572
 573                         T* ptr = reinterpret_cast<T*>(obj->ptr(offset));
 574
 575                         return *ptr;
 576                 }
 577
 578                 template<class T>
 579                 static int match(lua_State* L, by_value<T>, int index)
 580                 {
 581                         if (lua_isnil(L, index)) return 0;
 582                         object_rep* obj = is_class_object(L, index);
 583                         if (obj == 0) return -1;
 584                         int d;
 585                         return implicit_cast(obj->crep(), LUABIND_TYPEID(T), d);
 586                 }
 587
 588                 template<class T>
 589                 void converter_postcall(lua_State*, T, int) {}
 590         };
 591
 592 // ******* const pointer converter *******
 593
 594         template<class Direction> struct const_pointer_converter;
 595
 596         template<>
 597         struct const_pointer_converter<cpp_to_lua>
 598         {
 599                 template<class T>
 600                 void apply(lua_State* L, const T* ptr)
 601                 {
 602                         if (ptr == 0)
 603                         {
 604                                 lua_pushnil(L);
 605                                 return;
 606                         }
 607
 608                         class_registry* registry = class_registry::get_registry(L);
 609                         class_rep* crep = registry->find_class(LUABIND_TYPEID(T));
 610
 611                         // if you get caught in this assert you are
 612                         // trying to use an unregistered type
 613                         assert(crep && "you are trying to use an unregistered type");
 614
 615                         // create the struct to hold the object
 616                         void* obj = lua_newuserdata(L, sizeof(object_rep));
 617                         assert(obj && "internal error, please report");
 618                         // we send 0 as destructor since we know it will never be called
 619                         new(obj) object_rep(const_cast<T*>(ptr), crep, object_rep::constant, 0);
 620
 621                         // set the meta table
 622                         detail::getref(L, crep->metatable_ref());
 623                         lua_setmetatable(L, -2);
 624                 }
 625         };
 626
 627
 628         template<class T> struct make_const_pointer { typedef const T* type; };
 629         template<>
 630         struct const_pointer_converter<lua_to_cpp>
 631         {
 632                 template<class T>
 633                 typename make_const_pointer<T>::type apply(lua_State* L, by_const_pointer<T>, int index)
 634                 {
 635 //                      std::cerr << "const_pointer_converter\n";
 636                         return pointer_converter<lua_to_cpp>().apply(L, by_pointer<T>(), index);
 637                 }
 638
 639                 template<class T>
 640                 static int match(lua_State* L, by_const_pointer<T>, int index)
 641                 {
 642                         if (lua_isnil(L, index)) return 0;
 643                         object_rep* obj = is_class_object(L, index);
 644                         if (obj == 0) return -1; // if the type is not one of our own registered types, classify it as a non-match
 645                         int d;
 646                         return implicit_cast(obj->crep(), LUABIND_TYPEID(T), d);
 647                 }
 648
 649                 template<class T>
 650                 void converter_postcall(lua_State*, T, int) {}
 651         };
 652
 653 // ******* reference converter *******
 654
 655         template<class Direction> struct ref_converter;
 656
 657         template<>
 658         struct ref_converter<cpp_to_lua>
 659         {
 660                 template<class T>
 661                 void apply(lua_State* L, T& ref)
 662                 {
 663                         class_registry* registry = class_registry::get_registry(L);
 664                         class_rep* crep = registry->find_class(LUABIND_TYPEID(T));
 665
 666                         // if you get caught in this assert you are
 667                         // trying to use an unregistered type
 668                         assert(crep && "you are trying to use an unregistered type");
 669
 670                         T* ptr = &ref;
 671
 672                         // create the struct to hold the object
 673                         void* obj = lua_newuserdata(L, sizeof(object_rep));
 674                         assert(obj && "internal error, please report");
 675                         new(obj) object_rep(ptr, crep, 0, 0);
 676
 677                         // set the meta table
 678                         detail::getref(L, crep->metatable_ref());
 679                         lua_setmetatable(L, -2);
 680                 }
 681         };
 682
 683         template<class T> struct make_reference { typedef T& type; };
 684         template<>
 685         struct ref_converter<lua_to_cpp>
 686         {
 687                 template<class T>
 688                 typename make_reference<T>::type apply(lua_State* L, by_reference<T>, int index)
 689                 {
 690 //                      std::cerr << "ref_converter<lua_to_cpp>\n";
 691                         return *pointer_converter<lua_to_cpp>().apply(L, by_pointer<T>(), index);
 692                 }
 693
 694                 template<class T>
 695                 static int match(lua_State* L, by_reference<T>, int index)
 696                 {
 697                         return pointer_converter<lua_to_cpp>::match(L, by_pointer<T>(), index);
 698                 }
 699
 700                 template<class T>
 701                 void converter_postcall(lua_State*, T, int) {}
 702         };
 703
 704 // ******** const reference converter *********
 705
 706         template<class Direction> struct const_ref_converter;
 707
 708         template<>
 709         struct const_ref_converter<cpp_to_lua>
 710         {
 711                 template<class T>
 712                 void apply(lua_State* L, const T& ref)
 713                 {
 714                         class_registry* registry = class_registry::get_registry(L);
 715                         class_rep* crep = registry->find_class(LUABIND_TYPEID(T));
 716
 717                         // if you get caught in this assert you are
 718                         // trying to use an unregistered type
 719                         assert(crep && "you are trying to use an unregistered type");
 720
 721                         T* ptr = const_cast<T*>(&ref);
 722
 723 //                      std::cerr << "const_ref_converter<cpp_to_lua>: " << ptr << "\n";
 724
 725                         // create the table to hold the object
 726                         object_rep* obj = static_cast<object_rep*>(lua_newuserdata(L, sizeof(object_rep)));
 727                         assert(obj && "internal error, please report");
 728                         new(obj) object_rep(ptr, crep, object_rep::constant, 0);
 729
 730                         // set the meta table
 731                         detail::getref(L, crep->metatable_ref());
 732                         lua_setmetatable(L, -2);
 733                 }
 734         };
 735
 736         template<>
 737         struct const_ref_converter<lua_to_cpp>
 738         {
 739                 template<class T>
 740                 typename make_const_reference<T>::type apply(lua_State* L, by_const_reference<T>, int index)
 741                 {
 742 //                      std::cerr << "const_ref_converter<lua_to_cpp>\n";
 743                         return *const_pointer_converter<lua_to_cpp>().apply(L, by_const_pointer<T>(), index);
 744                 }
 745
 746                 template<class T>
 747                 static int match(lua_State* L, by_const_reference<T>, int index)
 748                 {
 749                         return const_pointer_converter<lua_to_cpp>::match(L, by_const_pointer<T>(), index);
 750                 }
 751
 752                 template<class T>
 753                 void converter_postcall(lua_State*, T, int) {}
 754         };
 755
 756         // ****** enum converter ********
 757
 758         template<class Direction = cpp_to_lua>
 759         struct enum_converter;
 760
 761         template<>
 762         struct enum_converter<lua_to_cpp>
 763         {
 764                 template<class T>
 765                 T apply(lua_State* L, by_value<T>, int index)
 766                 {
 767 //                      std::cerr << "enum_converter\n";
 768                         return static_cast<T>(static_cast<int>(lua_tonumber(L, index)));
 769                 }
 770
 771                 template<class T>
 772                 static int match(lua_State* L, by_value<T>, int index)
 773                 {
 774                         if (lua_isnumber(L, index)) return 0; else return -1;
 775                 }
 776
 777                 template<class T>
 778                 void converter_postcall(lua_State*, T, int) {}
 779         };
 780
 781         // ****** functor converter ********
 782
 783         template<class Direction> struct functor_converter;
 784
 785         template<>
 786         struct functor_converter<lua_to_cpp>
 787         {
 788                 template<class T>
 789                 functor<T> apply(lua_State* L, by_const_reference<functor<T> >, int index)
 790                 {
 791                         lua_pushvalue(L, index);
 792                         int ref = detail::ref(L);
 793                         return functor<T>(L, ref);
 794                 }
 795
 796                 template<class T>
 797                 functor<T> apply(lua_State* L, by_value<functor<T> >, int index)
 798                 {
 799                         lua_pushvalue(L, index);
 800                         int ref = detail::ref(L);
 801                         return functor<T>(L, ref);
 802                 }
 803
 804                 template<class T>
 805                 static int match(lua_State* L, by_const_reference<functor<T> >, int index)
 806                 {
 807                         if (lua_isfunction(L, index)) return 0; else return -1;
 808                 }
 809
 810                 template<class T>
 811                 static int match(lua_State* L, by_value<functor<T> >, int index)
 812                 {
 813                         if (lua_isfunction(L, index)) return 0; else return -1;
 814                 }
 815
 816                 template<class T>
 817                 void converter_postcall(lua_State*, T, int) {}
 818         };
 819
 820
 821
 822
 823
 824 // *********** default_policy *****************
 825
 826
 827
 828         struct default_policy : converter_policy_tag
 829         {
 830                 BOOST_STATIC_CONSTANT(bool, has_arg = true);
 831
 832                 template<class T>
 833                 static void precall(lua_State*, T, int) {}
 834
 835 //              template<class T>
 836 //              static void postcall(lua_State*, T, int) {}
 837
 838                 template<class T, class Direction>
 839                 struct generate_converter
 840                 {
 841                         typedef typename boost::mpl::if_<is_user_defined<T>
 842                                                 , user_defined_converter<Direction>
 843                                                 , typename boost::mpl::if_<is_primitive<T>
 844                                                         , primitive_converter<Direction>
 845                                                         , typename boost::mpl::if_<is_lua_functor<T>
 846                                                                 , functor_converter<Direction>
 847                                                                 , typename boost::mpl::if_<boost::is_enum<T>
 848                                                                         , enum_converter<Direction>
 849                                                                         , typename boost::mpl::if_<is_nonconst_pointer<T>
 850                                                                                 , pointer_converter<Direction>
 851                                                                                 , typename boost::mpl::if_<is_const_pointer<T>
 852                                                                                         , const_pointer_converter<Direction>
 853                                                                                         , typename boost::mpl::if_<is_nonconst_reference<T>
 854                                                                                                 , ref_converter<Direction>
 855                                                                                                 , typename boost::mpl::if_<is_const_reference<T>
 856                                                                                                         , const_ref_converter<Direction>
 857                                                                                                         , value_converter<Direction>
 858                         >::type>::type>::type>::type>::type>::type>::type>::type type;
 859                 };
 860         };
 861
 862 // ********** get policy **********
 863
 864 #if defined(BOOST_MSVC) && (BOOST_MSVC <= 1300)
 865         template<int N, class T>
 866         struct get_policy_list_impl
 867         {
 868                 template<class U>
 869                 struct inner
 870                 {
 871                         typedef typename U::head head;
 872                         typedef typename U::tail tail;
 873
 874                         typedef typename boost::mpl::if_<boost::mpl::equal_to<boost::mpl::integral_c<int, head::index>, boost::mpl::integral_c<int, N> >
 875                                 ,       policy_cons<head, typename get_policy_list_impl<N, tail>::type>
 876                                 ,       typename get_policy_list_impl<N, tail>::type
 877                         >::type type;
 878                 };
 879
 880                 template<>
 881                 struct inner<null_type>
 882                 {
 883                         typedef null_type type;
 884                 };
 885
 886                 typedef typename inner<T>::type type;
 887         };
 888 #else
 889         template<class List>
 890         struct get_policy_list_impl
 891         {
 892                 template<int N>
 893                 struct apply
 894                 {
 895                         typedef typename List::head head;
 896                         typedef typename List::tail tail;
 897
 898                         typedef typename boost::mpl::if_<boost::mpl::equal_to<boost::mpl::integral_c<int, head::index>, boost::mpl::integral_c<int, N> >
 899                                 ,       policy_cons<head, typename get_policy_list_impl<tail>::template apply<N>::type>
 900                                 ,       typename get_policy_list_impl<tail>::template apply<N>::type
 901                         >::type type;
 902                 };
 903         };
 904
 905         template<>
 906         struct get_policy_list_impl<detail::null_type>
 907         {
 908                 template<int N>
 909                 struct apply
 910                 {
 911                         typedef null_type type;
 912                 };
 913         };
 914 #endif
 915
 916         template<int N, class T>
 917         struct get_policy_list
 918         {
 919 #if defined(BOOST_MSVC) && (BOOST_MSVC <= 1300)
 920                 typedef typename get_policy_list_impl<N, T>::type type;
 921 #else
 922                 typedef typename get_policy_list_impl<T>::template apply<N>::type type;
 923 #endif
 924         };
 925
 926 // ============== new policy system =================
 927
 928         template<int, class> struct find_conversion_policy;
 929
 930         template<bool IsConverter = false>
 931         struct find_conversion_impl
 932         {
 933                 template<int N, class Policies>
 934                 struct apply
 935                 {
 936                         typedef typename find_conversion_policy<N, typename Policies::tail>::type type;
 937                 };
 938         };
 939
 940         template<>
 941         struct find_conversion_impl<true>
 942         {
 943                 template<int N, class Policies>
 944                 struct apply
 945                 {
 946                         typedef typename Policies::head head;
 947                         typedef typename Policies::tail tail;
 948
 949                         BOOST_STATIC_CONSTANT(bool, found = (N == head::index));
 950
 951                         typedef typename
 952                                 boost::mpl::if_c<found
 953                                         , head
 954                                         , typename find_conversion_policy<N, tail>::type
 955                                 >::type type;
 956                 };
 957         };
 958
 959         template<class Policies>
 960         struct find_conversion_impl2
 961         {
 962                 template<int N>
 963                 struct apply
 964                         : find_conversion_impl<
 965                                 boost::is_base_and_derived<conversion_policy_base, typename Policies::head>::value
 966                         >::template apply<N, Policies>
 967                 {
 968                 };
 969         };
 970
 971         template<>
 972         struct find_conversion_impl2<detail::null_type>
 973         {
 974                 template<int N>
 975                 struct apply
 976                 {
 977                         typedef default_policy type;
 978                 };
 979         };
 980
 981         template<int N, class Policies>
 982         struct find_conversion_policy : find_conversion_impl2<Policies>::template apply<N>
 983         {
 984         };
 985
 986         template<class List>
 987         struct policy_list_postcall
 988         {
 989                 typedef typename List::head head;
 990                 typedef typename List::tail tail;
 991
 992                 static void apply(lua_State* L, const index_map& i)
 993                 {
 994                         head::postcall(L, i);
 995                         policy_list_postcall<tail>::apply(L, i);
 996                 }
 997         };
 998
 999         template<>
1000         struct policy_list_postcall<detail::null_type>
1001         {
1002                 static void apply(lua_State*, const index_map&) {}
1003         };
1004
1005 /*      template<int N>
1006         struct find_conversion_policy<N, detail::null_type>
1007         {
1008                 typedef default_policy type;
1009         };*/
1010
1011 // ==================================================
1012
1013 // ************** precall and postcall on policy_cons *********************
1014
1015
1016         template<class List>
1017         struct policy_precall
1018         {
1019                 typedef typename List::head head;
1020                 typedef typename List::tail tail;
1021
1022                 static void apply(lua_State* L, int index)
1023                 {
1024                         head::precall(L, index);
1025                         policy_precall<tail>::apply(L, index);
1026                 }
1027         };
1028
1029         template<>
1030         struct policy_precall<detail::null_type>
1031         {
1032                 static void apply(lua_State*, int) {}
1033         };
1034
1035         template<class List>
1036         struct policy_postcall
1037         {
1038                 typedef typename List::head head;
1039                 typedef typename List::tail tail;
1040
1041                 static void apply(lua_State* L, int index)
1042                 {
1043                         head::postcall(L, index);
1044                         policy_postcall<tail>::apply(L, index);
1045                 }
1046         };
1047
1048         template<>
1049         struct policy_postcall<detail::null_type>
1050         {
1051                 static void apply(lua_State*, int) {}
1052         };
1053
1054 /*
1055         struct pointer_only_converter
1056         {
1057                 template<class T>
1058                 static const T* apply(lua_State* L, type<const T*>, int index)
1059                 {
1060                         int a = index;
1061                 }
1062         };
1063 */
1064         struct only_one_converter_policy_can_be_used_per_index {};
1065
1066         template<class List, class T> struct assert_converter_policy_impl;
1067
1068         template<class List>
1069         struct assert_converter_policy
1070         {
1071                 template<class T>
1072                 struct apply
1073                 {
1074                         typedef typename boost::mpl::if_<boost::is_base_and_derived<converter_policy_tag, typename List::head>
1075                                 , only_one_converter_policy_can_be_used_per_index
1076                                 , typename assert_converter_policy_impl<typename List::tail, T>::type
1077                         >::type type;
1078                 };
1079         };
1080
1081         template<>
1082         struct assert_converter_policy<detail::null_type>
1083         {
1084                 template<class T>
1085                 struct apply
1086                 {
1087                         typedef T type;
1088                 };
1089         };
1090
1091         template<class List, class T>
1092         struct assert_converter_policy_impl
1093         {
1094                 typedef typename assert_converter_policy<List>::template apply<T>::type type;
1095         };
1096
1097         template<class List>
1098         struct find_converter_policy_impl
1099         {
1100                 typedef typename List::head head;
1101                 typedef typename List::tail tail;
1102
1103                 typedef typename boost::mpl::if_<boost::is_base_and_derived<converter_policy_tag, head>
1104                         , typename assert_converter_policy_impl<tail, head>::type
1105                         , typename find_converter_policy_impl<tail>::type
1106                 >::type type;
1107         };
1108
1109         template<>
1110         struct find_converter_policy_impl<detail::null_type>
1111         {
1112                 typedef default_policy type;
1113         };
1114
1115 /*      template<class List>
1116         struct find_converter_policy
1117                 : find_converter_policy_impl<List>
1118         {
1119         };
1120 */
1121
1122 }}
1123
1124
1125 namespace luabind {      namespace
1126 {
1127         LUABIND_ANONYMOUS_FIX boost::arg<0> return_value;
1128         LUABIND_ANONYMOUS_FIX boost::arg<0> result;
1129 }}
1130
1131 #include <luabind/detail/object_funs.hpp>
1132
1133 #endif // LUABIND_POLICY_HPP_INCLUDED
1134