?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
*** empty log message ***
[luabind.git] / luabind / detail / policy.hpp
bloba10983cb2e2e3706021c7548f58543b6b41a4d23
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/type_traits/is_array.hpp>
33 #include <boost/mpl/bool.hpp>
34 #include <boost/mpl/integral_c.hpp>
35 #include <boost/mpl/equal_to.hpp>
36 #include <boost/mpl/apply_if.hpp>
37 #include <boost/mpl/or.hpp>
38 #include <boost/type_traits/add_reference.hpp>
39 #include <boost/type_traits/is_pointer.hpp>
40 #include <boost/type_traits/is_base_and_derived.hpp>
41 #include <boost/limits.hpp>
42
43 #include <luabind/detail/class_registry.hpp>
44 #include <luabind/detail/primitives.hpp>
45 #include <luabind/detail/object_rep.hpp>
46 #include <luabind/detail/typetraits.hpp>
47 #include <luabind/detail/class_cache.hpp>
48 #include <luabind/detail/debug.hpp>
49
50 #include <boost/type_traits/add_reference.hpp>
51
52 #include <luabind/detail/decorate_type.hpp>
53 #include <luabind/object.hpp>
54 //#include <luabind/detail/make_instance.hpp>
55 //#include <luabind/pointer_holder.hpp>
56
57 namespace luabind
58 {
59 namespace detail
60 {
61 struct conversion_policy_base {};
62 }
63
64 template<int N, bool HasArg = true>
65 struct conversion_policy : detail::conversion_policy_base
66 {
67 BOOST_STATIC_CONSTANT(int, index = N);
68 BOOST_STATIC_CONSTANT(bool, has_arg = HasArg);
69 };
70
71 class index_map
72 {
73 public:
74
75 index_map(const int* m): m_map(m) {}
76
77 int operator[](int index) const
78 {
79 return m_map[index + 1];
80 }
81
82 private:
83
84 const int* m_map;
85 };
86
87 namespace converters
88 {
89 using luabind::detail::yes_t;
90 using luabind::detail::no_t;
91 using luabind::detail::by_value;
92 using luabind::detail::by_reference;
93 using luabind::detail::by_const_reference;
94 using luabind::detail::by_pointer;
95 using luabind::detail::by_const_pointer;
96
97 no_t is_user_defined(...);
98
99 // template<bool B = true> struct yes_no : yes_t { typedef yes_t type; };
100 // template<> struct yes_no<false> : no_t { typedef no_t type; };
101 /*
102 template<int N, class T>
103 struct TO
104 {
105 BOOST_STATIC_CONSTANT(bool, is_specialized = false);
106
107 std::pair<int,int> match(lua_State*, detail::type<T>, boost::mpl::int_<N>, int)
108 {
109 return std::make_pair(-1,-1);
110 }
111
112 template<int I>
113 void convert(lua_State*, detail::type<T>, boost::mpl::int_<N>, int) {}
114 };
115
116 no_t is_implicit_conversion(...);
117
118 template<class T>
119 yes_no<TO<0,T>::is_specialized> is_implicit_conversion(by_value<T>);
120
121 template<class T>
122 yes_no<TO<0,T>::is_specialized> is_implicit_conversion(by_const_reference<T>);
123
124 template<class T>
125 yes_no<TO<0,T*>::is_specialized> is_implicit_conversion(by_pointer<T>);
126
127 template<class T>
128 yes_no<TO<0,const T*>::is_specialized> is_implicit_conversion(by_const_pointer<T>);
129
130 #define LUABIND_IMPLICIT(index, to, from) template<> struct TO<index,to >:FROM<from > {}*/
131 }
132
133 namespace detail
134 {
135 template<class T>
136 struct is_user_defined
137 {
138 BOOST_STATIC_CONSTANT(bool, value =
139 sizeof(luabind::converters::is_user_defined(LUABIND_DECORATE_TYPE(T))) == sizeof(yes_t));
140 };
141
142 /* template<class T>
143 struct is_implicit_conversion
144 {
145 BOOST_STATIC_CONSTANT(bool, value =
146 sizeof(luabind::converters::is_implicit_conversion(LUABIND_DECORATE_TYPE(T))) == sizeof(yes_t));
147 };
148 */
149 LUABIND_API int implicit_cast(const class_rep* crep, LUABIND_TYPE_INFO const&, int& pointer_offset);
150 }
151
152 template<class T> class functor;
153 class object;
154 }
155
156 namespace luabind { namespace detail
157 {
158 template<class>
159 struct is_primitive;
160
161 template<class T>
162 yes_t is_lua_functor_test(const functor<T>&);
163
164 #if defined(BOOST_MSVC) && (BOOST_MSVC <= 1300)
165 no_t is_lua_functor_test(...);
166 #else
167 template<class T>
168 no_t is_lua_functor_test(const T&);
169 #endif
170
171 template<class T>
172 struct is_lua_functor
173 {
174 static T t;
175
176 BOOST_STATIC_CONSTANT(bool, value = sizeof(is_lua_functor_test(t)) == sizeof(yes_t));
177 };
178
179 namespace
180 {
181 static char msvc_fix[64];
182 }
183
184 template<class T>
185 struct indirect_type
186 {
187 typedef typename
188 boost::mpl::if_<is_primitive<T>
189 , const type<T>&
190 , typename boost::mpl::apply_if<boost::mpl::or_<boost::is_reference<T>, boost::is_pointer<T> >
191 , identity<T>
192 , boost::add_reference<T>
193 >::type
194 >::type result_type;
195
196 static inline result_type get()
197 {
198 return reinterpret_cast<result_type>(msvc_fix);
199 }
200 };
201
202 template<class H, class T>
203 struct policy_cons
204 {
205 typedef H head;
206 typedef T tail;
207
208 template<class U>
209 policy_cons<U, policy_cons<H,T> > operator,(policy_cons<U,detail::null_type>)
210 {
211 return policy_cons<U, policy_cons<H,T> >();
212 }
213
214 template<class U>
215 policy_cons<U, policy_cons<H,T> > operator+(policy_cons<U,detail::null_type>)
216 {
217 return policy_cons<U, policy_cons<H,T> >();
218 }
219
220 template<class U>
221 policy_cons<U, policy_cons<H,T> > operator|(policy_cons<U,detail::null_type>)
222 {
223 return policy_cons<U, policy_cons<H,T> >();
224 }
225 };
226
227 struct indirection_layer
228 {
229 template<class T>
230 indirection_layer(const T&);
231 };
232
233 template<class H, class T>
234 yes_t is_policy_cons_test(const policy_cons<H,T>&);
235 no_t is_policy_cons_test(...);
236
237 template<class T>
238 struct is_policy_cons
239 {
240 static const T& t;
241
242 BOOST_STATIC_CONSTANT(bool, value =
243 sizeof(is_policy_cons_test(t)) == sizeof(yes_t));
244 };
245
246 template<bool>
247 struct is_string_literal
248 {
249 static no_t helper(indirection_layer);
250 static yes_t helper(const char*);
251 };
252
253 template<>
254 struct is_string_literal<false>
255 {
256 static no_t helper(indirection_layer);
257 };
258
259
260 template<class T>
261 struct is_primitive/*: boost::mpl::bool_c<false>*/
262 {
263 static T t;
264
265 BOOST_STATIC_CONSTANT(bool, value =
266 sizeof(is_string_literal<boost::is_array<T>::value>::helper(t)) == sizeof(yes_t));
267 };
268
269 template<> struct is_primitive<luabind::object>: boost::mpl::bool_<true> {};
270 template<> struct is_primitive<const luabind::object>: boost::mpl::bool_<true> {};
271 template<> struct is_primitive<const luabind::object&>: boost::mpl::bool_<true> {};
272
273 template<> struct is_primitive<int>: boost::mpl::bool_<true> {};
274 template<> struct is_primitive<char>: boost::mpl::bool_<true> {};
275 template<> struct is_primitive<short>: boost::mpl::bool_<true> {};
276 template<> struct is_primitive<long>: boost::mpl::bool_<true> {};
277 template<> struct is_primitive<unsigned char>: boost::mpl::bool_<true> {};
278 template<> struct is_primitive<unsigned short>: boost::mpl::bool_<true> {};
279 template<> struct is_primitive<unsigned long>: boost::mpl::bool_<true> {};
280 template<> struct is_primitive<unsigned int>: boost::mpl::bool_<true> {};
281 template<> struct is_primitive<float>: boost::mpl::bool_<true> {};
282 template<> struct is_primitive<double>: boost::mpl::bool_<true> {};
283 template<> struct is_primitive<long double>: boost::mpl::bool_<true> {};
284 template<> struct is_primitive<char*>: boost::mpl::bool_<true> {};
285 template<> struct is_primitive<bool>: boost::mpl::bool_<true> {};
286
287 template<> struct is_primitive<const int>: boost::mpl::bool_<true> {};
288 template<> struct is_primitive<const char>: boost::mpl::bool_<true> {};
289 template<> struct is_primitive<const short>: boost::mpl::bool_<true> {};
290 template<> struct is_primitive<const long>: boost::mpl::bool_<true> {};
291 template<> struct is_primitive<const unsigned int>: boost::mpl::bool_<true> {};
292 template<> struct is_primitive<const unsigned char>: boost::mpl::bool_<true> {};
293 template<> struct is_primitive<const unsigned short>: boost::mpl::bool_<true> {};
294 template<> struct is_primitive<const unsigned long>: boost::mpl::bool_<true> {};
295 template<> struct is_primitive<const float>: boost::mpl::bool_<true> {};
296 template<> struct is_primitive<const double>: boost::mpl::bool_<true> {};
297 template<> struct is_primitive<const long double>: boost::mpl::bool_<true> {};
298 template<> struct is_primitive<const char*>: boost::mpl::bool_<true> {};
299 template<> struct is_primitive<const char* const>: boost::mpl::bool_<true> {};
300 template<> struct is_primitive<const bool>: boost::mpl::bool_<true> {};
301
302 // TODO: add more
303 template<> struct is_primitive<const int&>: boost::mpl::bool_<true> {};
304 template<> struct is_primitive<const char&>: boost::mpl::bool_<true> {};
305 template<> struct is_primitive<const short&>: boost::mpl::bool_<true> {};
306 template<> struct is_primitive<const long&>: boost::mpl::bool_<true> {};
307 template<> struct is_primitive<const unsigned int&>: boost::mpl::bool_<true> {};
308 template<> struct is_primitive<const unsigned char&>: boost::mpl::bool_<true> {};
309 template<> struct is_primitive<const unsigned short&>: boost::mpl::bool_<true> {};
310 template<> struct is_primitive<const unsigned long&>: boost::mpl::bool_<true> {};
311 template<> struct is_primitive<const float&>: boost::mpl::bool_<true> {};
312 template<> struct is_primitive<const double&>: boost::mpl::bool_<true> {};
313 template<> struct is_primitive<const long double&>: boost::mpl::bool_<true> {};
314 template<> struct is_primitive<const bool&>: boost::mpl::bool_<true> {};
315
316 template<> struct is_primitive<const std::string&>: boost::mpl::bool_<true> {};
317 template<> struct is_primitive<std::string>: boost::mpl::bool_<true> {};
318 template<> struct is_primitive<const std::string>: boost::mpl::bool_<true> {};
319
320
321 template<class Direction> struct primitive_converter;
322
323 template<>
324 struct primitive_converter<cpp_to_lua>
325 {
326 void apply(lua_State* L, const luabind::object& v)
327 {
328 // if the luabind::object is uninitialized
329 // treat it as nil.
330 if (v.lua_state() == 0)
331 {
332 lua_pushnil(L);
333 return;
334 }
335 // if you hit this assert you are trying to return a value from one state into another lua state
336 assert((v.lua_state() == L) && "you cannot return an uninitilized value "
337 "or a value from one lua state into another");
338 v.pushvalue();
339 }
340 void apply(lua_State* L, int v) { lua_pushnumber(L, v); }
341 void apply(lua_State* L, short v) { lua_pushnumber(L, v); }
342 void apply(lua_State* L, char v) { lua_pushnumber(L, v); }
343 void apply(lua_State* L, long v) { lua_pushnumber(L, v); }
344 void apply(lua_State* L, unsigned int v) { lua_pushnumber(L, v); }
345 void apply(lua_State* L, unsigned short v) { lua_pushnumber(L, v); }
346 void apply(lua_State* L, unsigned char v) { lua_pushnumber(L, v); }
347 void apply(lua_State* L, unsigned long v) { lua_pushnumber(L, v); }
348 void apply(lua_State* L, float v) { lua_pushnumber(L, v); }
349 void apply(lua_State* L, double v) { lua_pushnumber(L, v); }
350 void apply(lua_State* L, long double v) { lua_pushnumber(L, v); }
351 void apply(lua_State* L, const char* v) { lua_pushstring(L, v); }
352 void apply(lua_State* L, const std::string& v)
353 { lua_pushlstring(L, v.data(), v.size()); }
354 void apply(lua_State* L, bool b) { lua_pushboolean(L, b); }
355 };
356
357 template<>
358 struct primitive_converter<lua_to_cpp>
359 {
360 #define PRIMITIVE_CONVERTER(prim) \
361 prim apply(lua_State* L, luabind::detail::by_const_reference<prim>, int index) { return apply(L, detail::by_value<prim>(), index); } \
362 prim apply(lua_State* L, luabind::detail::by_value<const prim>, int index) { return apply(L, detail::by_value<prim>(), index); } \
363 prim apply(lua_State* L, luabind::detail::by_value<prim>, int index)
364
365 #define PRIMITIVE_MATCHER(prim) \
366 static int match(lua_State* L, luabind::detail::by_const_reference<prim>, int index) { return match(L, detail::by_value<prim>(), index); } \
367 static int match(lua_State* L, luabind::detail::by_value<const prim>, int index) { return match(L, detail::by_value<prim>(), index); } \
368 static int match(lua_State* L, luabind::detail::by_value<prim>, int index)
369
370 PRIMITIVE_CONVERTER(bool) { return lua_toboolean(L, index) == 1; }
371 PRIMITIVE_MATCHER(bool) { if (lua_type(L, index) == LUA_TBOOLEAN) return 0; else return -1; }
372
373 PRIMITIVE_CONVERTER(int) { return static_cast<int>(lua_tonumber(L, index)); }
374 PRIMITIVE_MATCHER(int) { if (lua_type(L, index) == LUA_TNUMBER) return 0; else return -1; }
375
376 PRIMITIVE_CONVERTER(unsigned int) { return static_cast<unsigned int>(lua_tonumber(L, index)); }
377 PRIMITIVE_MATCHER(unsigned int) { if (lua_type(L, index) == LUA_TNUMBER) return 0; else return -1; }
378
379 PRIMITIVE_CONVERTER(char) { return static_cast<char>(lua_tonumber(L, index)); }
380 PRIMITIVE_MATCHER(char) { if (lua_type(L, index) == LUA_TNUMBER) return 0; else return -1; }
381
382 PRIMITIVE_CONVERTER(unsigned char) { return static_cast<unsigned char>(lua_tonumber(L, index)); }
383 PRIMITIVE_MATCHER(unsigned char) { if (lua_type(L, index) == LUA_TNUMBER) return 0; else return -1; }
384
385 PRIMITIVE_CONVERTER(short) { return static_cast<short>(lua_tonumber(L, index)); }
386 PRIMITIVE_MATCHER(short) { if (lua_type(L, index) == LUA_TNUMBER) return 0; else return -1; }
387
388 PRIMITIVE_CONVERTER(unsigned short) { return static_cast<unsigned short>(lua_tonumber(L, index)); }
389 PRIMITIVE_MATCHER(unsigned short) { if (lua_type(L, index) == LUA_TNUMBER) return 0; else return -1; }
390
391 PRIMITIVE_CONVERTER(long) { return static_cast<long>(lua_tonumber(L, index)); }
392 PRIMITIVE_MATCHER(long) { if (lua_type(L, index) == LUA_TNUMBER) return 0; else return -1; }
393
394 PRIMITIVE_CONVERTER(unsigned long) { return static_cast<unsigned long>(lua_tonumber(L, index)); }
395 PRIMITIVE_MATCHER(unsigned long) { if (lua_type(L, index) == LUA_TNUMBER) return 0; else return -1; }
396
397 PRIMITIVE_CONVERTER(float) { return static_cast<float>(lua_tonumber(L, index)); }
398 PRIMITIVE_MATCHER(float) { if (lua_type(L, index) == LUA_TNUMBER) return 0; else return -1; }
399
400 PRIMITIVE_CONVERTER(double) { return static_cast<double>(lua_tonumber(L, index)); }
401 PRIMITIVE_MATCHER(double) { if (lua_type(L, index) == LUA_TNUMBER) return 0; else return -1; }
402
403 PRIMITIVE_CONVERTER(std::string)
404 { return std::string(lua_tostring(L, index), lua_strlen(L, index)); }
405 PRIMITIVE_MATCHER(std::string) { if (lua_type(L, index) == LUA_TSTRING) return 0; else return -1; }
406
407 PRIMITIVE_CONVERTER(luabind::object)
408 {
409 LUABIND_CHECK_STACK(L);
410
411 lua_pushvalue(L, index);
412 detail::lua_reference ref;
413 ref.set(L);
414 return luabind::object(L, ref, true);
415 }
416
417 PRIMITIVE_MATCHER(luabind::object) { return std::numeric_limits<int>::max() - 1; }
418
419 const char* apply(lua_State* L, detail::by_const_pointer<char>, int index) { return static_cast<const char*>(lua_tostring(L, index)); }
420 const char* apply(lua_State* L, detail::by_const_pointer<const char>, int index) { return static_cast<const char*>(lua_tostring(L, index)); }
421 static int match(lua_State* L, by_const_pointer<char>, int index) { if (lua_type(L, index) == LUA_TSTRING) return 0; else return -1;}
422 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;}
423
424 /* template<class T>
425 T apply(lua_State* L, luabind::detail::by_const_reference<T>, int index) { return apply(L, detail::by_value<T>(), index); }
426
427 // TODO: add more
428 bool apply(lua_State* L, detail::by_value<bool>, int index) { return lua_toboolean(L, index) == 1; }
429 float apply(lua_State* L, detail::by_value<float>, int index) { return static_cast<float>(lua_tonumber(L, index)); }
430 double apply(lua_State* L, detail::by_value<double>, int index) { return static_cast<double>(lua_tonumber(L, index)); }
431 long double apply(lua_State* L, detail::by_value<long double>, int index) { return static_cast<long double>(lua_tonumber(L, index)); }
432 int apply(lua_State* L, detail::by_value<int>, int index) { return static_cast<int>(lua_tonumber(L, index)); }
433 short apply(lua_State* L, detail::by_value<short>, int index) { return static_cast<short>(lua_tonumber(L, index)); }
434 char apply(lua_State* L, detail::by_value<char>, int index) { return static_cast<char>(lua_tonumber(L, index)); }
435 long apply(lua_State* L, detail::by_value<long>, int index) { return static_cast<long>(lua_tonumber(L, index)); }
436 unsigned int apply(lua_State* L, detail::by_value<unsigned int>, int index) { return static_cast<unsigned int>(lua_tonumber(L, index)); }
437 unsigned short apply(lua_State* L, detail::by_value<unsigned short>, int index) { return static_cast<short>(lua_tonumber(L, index)); }
438 unsigned char apply(lua_State* L, detail::by_value<unsigned char>, int index) { return static_cast<char>(lua_tonumber(L, index)); }
439 unsigned long apply(lua_State* L, detail::by_value<unsigned long>, int index) { return static_cast<long>(lua_tonumber(L, index)); }
440
441 float apply(lua_State* L, detail::by_value<const float>, int index) { return static_cast<float>(lua_tonumber(L, index)); }
442 double apply(lua_State* L, detail::by_value<const double>, int index) { return static_cast<double>(lua_tonumber(L, index)); }
443 long double apply(lua_State* L, detail::by_value<const long double>, int index) {return static_cast<long double>(lua_tonumber(L, index)); }
444 int apply(lua_State* L, detail::by_value<const int>, int index) { return static_cast<int>(lua_tonumber(L, index)); }
445 short apply(lua_State* L, detail::by_value<const short>, int index) { return static_cast<short>(lua_tonumber(L, index)); }
446 char apply(lua_State* L, detail::by_value<const char>, int index) { return static_cast<char>(lua_tonumber(L, index)); }
447 long apply(lua_State* L, detail::by_value<const long>, int index) { return static_cast<long>(lua_tonumber(L, index)); }
448
449 unsigned int apply(lua_State* L, detail::by_value<const unsigned int>, int index) { return static_cast<int>(lua_tonumber(L, index)); }
450 unsigned short apply(lua_State* L, detail::by_value<const unsigned short>, int index) { return static_cast<short>(lua_tonumber(L, index)); }
451 unsigned char apply(lua_State* L, detail::by_value<const unsigned char>, int index) { return static_cast<char>(lua_tonumber(L, index)); }
452 unsigned long apply(lua_State* L, detail::by_value<const unsigned long>, int index) { return static_cast<long>(lua_tonumber(L, index)); }
453
454 // std::string apply(lua_State* L, detail::by_value<std::string>, int index) { return static_cast<const char*>(lua_tostring(L, index)); }
455 // const std::string apply(lua_State* L, detail::by_value<const std::string>, int index) { return static_cast<const char*>(lua_tostring(L, index)); }
456 // const std::string apply(lua_State* L, detail::by_const_reference<std::string>, int index) { return static_cast<const char*>(lua_tostring(L, index)); }
457 PRIMITIVE_CONVERTER(std::string) { return static_cast<const char*>(lua_tostring(L, index)); }
458
459 luabind::object apply(lua_State* L, detail::by_value<luabind::object>, int index)
460 {
461 lua_pushvalue(L, index);
462 return luabind::object(L, detail::ref(L), true);
463 }
464
465 const luabind::object apply(lua_State* L, detail::by_value<const luabind::object>, int index)
466 {
467 lua_pushvalue(L, index);
468 return luabind::object(L, detail::ref(L), true);
469 }
470
471 // TODO: add more
472
473 const char* apply(lua_State* L, detail::by_const_pointer<char>, int index) { return static_cast<const char*>(lua_tostring(L, index)); }
474
475 // matchers
476 static int match(lua_State* L, detail::by_value<bool>, int index) { if (lua_type(L, index) == LUA_TBOOLEAN) return 0; else return -1;}
477 static int match(lua_State* L, detail::by_value<float>, int index) { if (lua_type(L, index) == LUA_TNUMBER) return 0; else return -1;}
478 static int match(lua_State* L, detail::by_value<double>, int index) { if (lua_type(L, index) == LUA_TNUMBER) return 0; else return -1;}
479 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;}
480 static int match(lua_State* L, detail::by_value<int>, int index) { if (lua_type(L, index) == LUA_TNUMBER) return 0; else return -1;}
481 static int match(lua_State* L, detail::by_value<short>, int index) { if (lua_type(L, index) == LUA_TNUMBER) return 0; else return -1;}
482 static int match(lua_State* L, detail::by_value<char>, int index) { if (lua_type(L, index) == LUA_TNUMBER) return 0; else return -1;}
483 static int match(lua_State* L, detail::by_value<long>, int index) { if (lua_type(L, index) == LUA_TNUMBER) return 0; else return -1;}
484 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;}
485 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;}
486 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;}
487 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;}
488 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;}
489 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;}
490 static int match(lua_State*, detail::by_value<luabind::object>, int) { return std::numeric_limits<int>::max() - 1; }
491 static int match(lua_State*, detail::by_value<const luabind::object>, int) { return std::numeric_limits<int>::max() - 1; }
492
493 static int match(lua_State* L, by_const_pointer<char>, int index) { if (lua_type(L, index) == LUA_TSTRING) return 0; else return -1;}
494 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;}
495
496 template<class T>
497 static int match(lua_State* L, detail::by_const_reference<T>, int index) { return match(L, detail::by_value<T>(), index); }
498 */
499
500 template<class T>
501 void converter_postcall(lua_State*, T, int) {}
502
503 #undef PRIMITIVE_MATCHER
504 #undef PRIMITIVE_CONVERTER
505 };
506
507
508
509 // *********** default converters ***************
510
511 /* template<class> struct implicit_converter;
512
513 template<>
514 struct implicit_converter<lua_to_cpp>
515 {
516 int converter_index;
517
518 template<class T>
519 T apply(lua_State* L, detail::by_value<T>, int index)
520 {
521 return converters::TO<T>::convert(L, detail::type<T>(), index);
522 }
523
524 template<class T>
525 static int match(lua_State* L, detail::by_value<T>, int index)
526 {
527 return converters::TO<T>::match(L, detail::type<T>(), index);
528 }
529
530 template<class T>
531 T apply(lua_State* L, detail::by_const_reference<T>, int index)
532 {
533 return converters::TO<T>::convert(L, detail::type<T>(), index);
534 }
535
536 template<class T>
537 static int match(lua_State* L, detail::by_const_reference<T>, int index)
538 {
539 return converters::TO<T>::match(L, detail::type<T>(), index);
540 }
541
542 template<class T>
543 T* apply(lua_State* L, detail::by_pointer<T>, int index)
544 {
545 return converters::TO<T*>::convert(L, detail::type<T*>(), index);
546 }
547
548 template<class T>
549 static int match(lua_State* L, detail::by_pointer<T>, int index)
550 {
551 return converters::TO<T*>::match(L, detail::type<T*>(), index);
552 }
553
554 template<class T>
555 const T* apply(lua_State* L, detail::by_const_pointer<T>, int index)
556 {
557 return converters::TO<const T*>::convert(L, detail::type<const T*>(), index);
558 }
559
560 template<class T>
561 static int match(lua_State* L, detail::by_const_pointer<T>, int index)
562 {
563 return converters::TO<const T*>::match(L, detail::type<const T*>(), index);
564 }
565
566 template<class T>
567 void converter_postcall(lua_State*, T, int) {}
568 };
569 */
570
571 // ********** user defined converter ***********
572
573 template<class Direction> struct user_defined_converter;
574
575 template<>
576 struct user_defined_converter<lua_to_cpp>
577 {
578 template<class T>
579 T apply(lua_State* L, detail::by_value<T>, int index)
580 {
581 // std::cerr << "user_defined_converter\n";
582 return converters::convert_lua_to_cpp(L, detail::by_value<T>(), index);
583 }
584
585 template<class T>
586 T apply(lua_State* L, detail::by_reference<T>, int index)
587 {
588 // std::cerr << "user_defined_converter\n";
589 return converters::convert_lua_to_cpp(L, detail::by_reference<T>(), index);
590 }
591
592 template<class T>
593 T apply(lua_State* L, detail::by_const_reference<T>, int index)
594 {
595 // std::cerr << "user_defined_converter\n";
596 return converters::convert_lua_to_cpp(L, detail::by_const_reference<T>(), index);
597 }
598
599 template<class T>
600 T* apply(lua_State* L, detail::by_pointer<T>, int index)
601 {
602 // std::cerr << "user_defined_converter\n";
603 return converters::convert_lua_to_cpp(L, detail::by_pointer<T>(), index);
604 }
605
606 template<class T>
607 const T* apply(lua_State* L, detail::by_const_pointer<T>, int index)
608 {
609 // std::cerr << "user_defined_converter\n";
610 return converters::convert_lua_to_cpp(L, detail::by_pointer<T>(), index);
611 }
612
613 template<class T>
614 static int match(lua_State* L, T, int index)
615 {
616 return converters::match_lua_to_cpp(L, T(), index);
617 }
618
619 template<class T>
620 void converter_postcall(lua_State*, T, int) {}
621 };
622
623 template<>
624 struct user_defined_converter<cpp_to_lua>
625 {
626 template<class T>
627 void apply(lua_State* L, const T& v)
628 {
629 converters::convert_cpp_to_lua(L, v);
630 }
631 };
632
633 // ********** pointer converter ***********
634
635
636 template<class Direction> struct pointer_converter;
637
638 template<>
639 struct pointer_converter<cpp_to_lua>
640 {
641 template<class T>
642 void apply(lua_State* L, T* ptr)
643 {
644 if (ptr == 0)
645 {
646 lua_pushnil(L);
647 return;
648 }
649
650 class_rep* crep = get_class_rep<T>(L);
651
652 // class_registry* registry = class_registry::get_registry(L);
653 // class_rep* crep = registry->find_class(LUABIND_TYPEID(T));
654
655 // if you get caught in this assert you are
656 // trying to use an unregistered type
657 assert(crep && "you are trying to use an unregistered type");
658
659 // create the struct to hold the object
660 void* obj = lua_newuserdata(L, sizeof(object_rep));
661 //new(obj) object_rep(ptr, crep, object_rep::owner, destructor_s<T>::apply);
662 new(obj) object_rep(ptr, crep, 0, 0);
663
664 // set the meta table
665 detail::getref(L, crep->metatable_ref());
666 lua_setmetatable(L, -2);
667
668 // make_instance(L, ptr, (pointer_holder<T, T*>*)0);
669 }
670 };
671
672 template<class T> struct make_pointer { typedef T* type; };
673 template<>
674 struct pointer_converter<lua_to_cpp>
675 {
676 bool made_conversion;
677 char target[32];
678
679 template<class T>
680 typename make_pointer<T>::type apply(lua_State* L, by_pointer<T>, int index)
681 {
682 // preconditions:
683 // lua_isuserdata(L, index);
684 // getmetatable().__lua_class is true
685 // object_rep->flags() & object_rep::constant == 0
686
687 if (lua_isnil(L, index)) return 0;
688
689 object_rep* obj = static_cast<object_rep*>(lua_touserdata(L, index));
690 assert((obj != 0) && "internal error, please report"); // internal error
691 const class_rep* crep = obj->crep();
692
693 T* ptr = reinterpret_cast<T*>(crep->convert_to(LUABIND_TYPEID(T), obj, target));
694 /*
695 void* result = boost::langbinding::inheritance_graph::instance().find_dynamic_type(
696 obj->ptr()
697 , LUABIND_TYPEID(T)
698 , crep->type());
699
700 made_conversion = false;
701
702 return (T*)result;
703 */
704 made_conversion = (void*)ptr == (char*)target;
705 assert(!made_conversion || sizeof(T) <= 32);
706
707 // std::cerr << "pointer_converter<lua_to_cpp>: " << ptr << " " << offset << "\n";
708
709 return ptr;
710 }
711
712 template<class T>
713 static int match(lua_State* L, by_pointer<T>, int index)
714 {
715 if (lua_isnil(L, index)) return 0;
716 object_rep* obj = is_class_object(L, index);
717 if (obj == 0) return -1;
718 // cannot cast a constant object to nonconst
719 if (obj->flags() & object_rep::constant) return -1;
720
721 if ((LUABIND_TYPE_INFO_EQUAL(obj->crep()->holder_type(), LUABIND_TYPEID(T))))
722 return (obj->flags() & object_rep::constant)?-1:0;
723 if ((LUABIND_TYPE_INFO_EQUAL(obj->crep()->const_holder_type(), LUABIND_TYPEID(T))))
724 return (obj->flags() & object_rep::constant)?0:-1;
725
726
727 int d;
728 return implicit_cast(obj->crep(), LUABIND_TYPEID(T), d);
729 }
730
731 template<class T>
732 void converter_postcall(lua_State*, by_pointer<T>, int)
733 {
734 if (made_conversion)
735 reinterpret_cast<T*>(target)->~T();
736 }
737 };
738
739 // ******* value converter *******
740
741 template<class Direction> struct value_converter;
742
743 template<>
744 struct value_converter<cpp_to_lua>
745 {
746 template<class T>
747 void apply(lua_State* L, const T& ref)
748 {
749 //class_registry* registry = class_registry::get_registry(L);
750 //class_rep* crep = registry->find_class(LUABIND_TYPEID(T));
751 class_rep* crep = get_class_rep<T>(L);
752
753 // if you get caught in this assert you are
754 // trying to use an unregistered type
755 assert(crep && "you are trying to use an unregistered type");
756
757 void* obj_rep;
758 void* held;
759
760 boost::tie(obj_rep,held) = crep->allocate(L);
761
762 void* object_ptr;
763 void(*destructor)(void*);
764 destructor = crep->destructor();
765 int flags = object_rep::owner;
766 if (crep->has_holder())
767 {
768 new(held) T(ref);
769 object_ptr = held;
770 if (LUABIND_TYPE_INFO_EQUAL(LUABIND_TYPEID(T), crep->const_holder_type()))
771 {
772 flags |= object_rep::constant;
773 destructor = crep->const_holder_destructor();
774 }
775 }
776 else
777 {
778 object_ptr = new T(ref);
779 }
780 new(obj_rep) object_rep(object_ptr, crep, flags, destructor);
781
782 // set the meta table
783 detail::getref(L, crep->metatable_ref());
784 lua_setmetatable(L, -2);
785 }
786 };
787
788
789 template<class T> struct make_const_reference { typedef const T& type; };
790
791 template<class T>
792 struct destruct_guard
793 {
794 T* ptr;
795 bool dismiss;
796 destruct_guard(T* p): ptr(p), dismiss(false) {}
797
798 ~destruct_guard()
799 {
800 if (!dismiss)
801 ptr->~T();
802 }
803 };
804
805 template<>
806 struct value_converter<lua_to_cpp>
807 {
808 template<class T>
809 /*typename make_const_reference<T>::type*/T apply(lua_State* L, by_value<T>, int index)
810 {
811 // preconditions:
812 // lua_isuserdata(L, index);
813 // getmetatable().__lua_class is true
814 // object_rep->flags() & object_rep::constant == 0
815
816 // TODO: if T is a holder type and obj is nil, we should be able to
817 // create a null-holder.
818 assert((lua_isnil(L, index) == false) && "internal error, please report");
819
820 object_rep* obj = static_cast<object_rep*>(lua_touserdata(L, index));
821 assert((obj != 0) && "internal error, please report"); // internal error
822 const class_rep* crep = obj->crep();
823
824 // TODO: align?
825 char target[sizeof(T)];
826 T* ptr = reinterpret_cast<T*>(crep->convert_to(LUABIND_TYPEID(T), obj, target));
827
828 destruct_guard<T> guard(ptr);
829 if ((void*)ptr != (void*)target) guard.dismiss = true;
830
831 return *ptr;
832 }
833
834 template<class T>
835 static int match(lua_State* L, by_value<T>, int index)
836 {
837 if (lua_isnil(L, index)) return 0;
838 object_rep* obj = is_class_object(L, index);
839 if (obj == 0) return -1;
840 int d;
841
842 if ((LUABIND_TYPE_INFO_EQUAL(obj->crep()->holder_type(), LUABIND_TYPEID(T))))
843 return (obj->flags() & object_rep::constant)?-1:0;
844 // if ((LUABIND_TYPE_INFO_EQUAL(obj->crep()->const_holder_type(), LUABIND_TYPEID(T))))
845 // return 0;
846 if ((LUABIND_TYPE_INFO_EQUAL(obj->crep()->const_holder_type(), LUABIND_TYPEID(T))))
847 return (obj->flags() & object_rep::constant)?0:1;
848
849 return implicit_cast(obj->crep(), LUABIND_TYPEID(T), d);
850 }
851
852 template<class T>
853 void converter_postcall(lua_State*, T, int) {}
854 };
855
856 // ******* const pointer converter *******
857
858 template<class Direction> struct const_pointer_converter;
859
860 template<>
861 struct const_pointer_converter<cpp_to_lua>
862 {
863 template<class T>
864 void apply(lua_State* L, const T* ptr)
865 {
866 if (ptr == 0)
867 {
868 lua_pushnil(L);
869 return;
870 }
871
872 //class_registry* registry = class_registry::get_registry(L);
873 //class_rep* crep = registry->find_class(LUABIND_TYPEID(T));
874 class_rep* crep = get_class_rep<T>(L);
875
876 // if you get caught in this assert you are
877 // trying to use an unregistered type
878 assert(crep && "you are trying to use an unregistered type");
879
880 // create the struct to hold the object
881 void* obj = lua_newuserdata(L, sizeof(object_rep));
882 assert(obj && "internal error, please report");
883 // we send 0 as destructor since we know it will never be called
884 new(obj) object_rep(const_cast<T*>(ptr), crep, object_rep::constant, 0);
885
886 // set the meta table
887 detail::getref(L, crep->metatable_ref());
888 lua_setmetatable(L, -2);
889 }
890 };
891
892
893 template<class T> struct make_const_pointer { typedef const T* type; };
894 template<>
895 struct const_pointer_converter<lua_to_cpp>
896 : private pointer_converter<lua_to_cpp>
897 {
898 template<class T>
899 typename make_const_pointer<T>::type apply(lua_State* L, by_const_pointer<T>, int index)
900 {
901 // std::cerr << "const_pointer_converter\n";
902 return pointer_converter<lua_to_cpp>::apply(L, by_pointer<T>(), index);
903 }
904
905 template<class T>
906 static int match(lua_State* L, by_const_pointer<T>, int index)
907 {
908 if (lua_isnil(L, index)) return 0;
909 object_rep* obj = is_class_object(L, index);
910 if (obj == 0) return -1; // if the type is not one of our own registered types, classify it as a non-match
911
912 if ((LUABIND_TYPE_INFO_EQUAL(obj->crep()->holder_type(), LUABIND_TYPEID(T))))
913 return (obj->flags() & object_rep::constant)?-1:0;
914 if ((LUABIND_TYPE_INFO_EQUAL(obj->crep()->const_holder_type(), LUABIND_TYPEID(T))))
915 return (obj->flags() & object_rep::constant)?0:1;
916
917 int d;
918 return implicit_cast(obj->crep(), LUABIND_TYPEID(T), d);
919 }
920
921 template<class T>
922 void converter_postcall(lua_State* L, by_const_pointer<T>, int index)
923 {
924 pointer_converter<lua_to_cpp>::converter_postcall(L, by_pointer<T>(), index);
925 }
926 };
927
928 // ******* reference converter *******
929
930 template<class Direction> struct ref_converter;
931
932 template<>
933 struct ref_converter<cpp_to_lua>
934 {
935 template<class T>
936 void apply(lua_State* L, T& ref)
937 {
938 //class_registry* registry = class_registry::get_registry(L);
939 //class_rep* crep = registry->find_class(LUABIND_TYPEID(T));
940 class_rep* crep = get_class_rep<T>(L);
941
942 // if you get caught in this assert you are
943 // trying to use an unregistered type
944 assert(crep && "you are trying to use an unregistered type");
945
946 T* ptr = &ref;
947
948 // create the struct to hold the object
949 void* obj = lua_newuserdata(L, sizeof(object_rep));
950 assert(obj && "internal error, please report");
951 new(obj) object_rep(ptr, crep, 0, 0);
952
953 // set the meta table
954 detail::getref(L, crep->metatable_ref());
955 lua_setmetatable(L, -2);
956 }
957 };
958
959 template<class T> struct make_reference { typedef T& type; };
960 template<>
961 struct ref_converter<lua_to_cpp>
962 {
963 template<class T>
964 typename make_reference<T>::type apply(lua_State* L, by_reference<T>, int index)
965 {
966 // std::cerr << "ref_converter<lua_to_cpp>\n";
967 return *pointer_converter<lua_to_cpp>().apply(L, by_pointer<T>(), index);
968 }
969
970 template<class T>
971 static int match(lua_State* L, by_reference<T>, int index)
972 {
973 return pointer_converter<lua_to_cpp>::match(L, by_pointer<T>(), index);
974 }
975
976 template<class T>
977 void converter_postcall(lua_State*, T, int) {}
978 };
979
980 // ******** const reference converter *********
981
982 template<class Direction> struct const_ref_converter;
983
984 template<>
985 struct const_ref_converter<cpp_to_lua>
986 {
987 template<class T>
988 void apply(lua_State* L, const T& ref)
989 {
990 //class_registry* registry = class_registry::get_registry(L);
991 //class_rep* crep = registry->find_class(LUABIND_TYPEID(T));
992 class_rep* crep = get_class_rep<T>(L);
993
994 // if you get caught in this assert you are
995 // trying to use an unregistered type
996 assert(crep && "you are trying to use an unregistered type");
997
998
999 void* obj_rep;
1000 void* held;
1001
1002 boost::tie(obj_rep,held) = crep->allocate(L);
1003
1004 void* object_ptr;
1005 void(*destructor)(void*);
1006 destructor = crep->destructor();
1007 int flags = 0;
1008 if (crep->has_holder())
1009 {
1010 flags = object_rep::owner;
1011 new(held) T(ref);
1012 object_ptr = held;
1013 if (LUABIND_TYPE_INFO_EQUAL(LUABIND_TYPEID(T), crep->const_holder_type()))
1014 {
1015 flags |= object_rep::constant;
1016 destructor = crep->const_holder_destructor();
1017 }
1018 }
1019 else
1020 {
1021 object_ptr = new T(ref);
1022 }
1023 new(obj_rep) object_rep(object_ptr, crep, flags, destructor);
1024
1025 // set the meta table
1026 detail::getref(L, crep->metatable_ref());
1027 lua_setmetatable(L, -2);
1028 }
1029 };
1030
1031 template<>
1032 struct const_ref_converter<lua_to_cpp>
1033 : private const_pointer_converter<lua_to_cpp>
1034 {
1035 template<class T>
1036 typename make_const_reference<T>::type apply(lua_State* L, by_const_reference<T>, int index)
1037 {
1038 // std::cerr << "const_ref_converter<lua_to_cpp>\n";
1039 return *const_pointer_converter<lua_to_cpp>::apply(L, by_const_pointer<T>(), index);
1040 }
1041
1042 template<class T>
1043 static int match(lua_State* L, by_const_reference<T>, int index)
1044 {
1045 return const_pointer_converter<lua_to_cpp>::match(L, by_const_pointer<T>(), index);
1046 }
1047
1048 template<class T>
1049 void converter_postcall(lua_State* L, by_const_reference<T>, int index)
1050 {
1051 const_pointer_converter<lua_to_cpp>::converter_postcall(L, by_const_pointer<T>(), index);
1052 }
1053 };
1054
1055 // ****** enum converter ********
1056
1057 template<class Direction = cpp_to_lua>
1058 struct enum_converter
1059 {
1060 void apply(lua_State* L, int val)
1061 {
1062 lua_pushnumber(L, val);
1063 }
1064 };
1065
1066 template<>
1067 struct enum_converter<lua_to_cpp>
1068 {
1069 template<class T>
1070 T apply(lua_State* L, by_value<T>, int index)
1071 {
1072 // std::cerr << "enum_converter\n";
1073 return static_cast<T>(static_cast<int>(lua_tonumber(L, index)));
1074 }
1075
1076 template<class T>
1077 static int match(lua_State* L, by_value<T>, int index)
1078 {
1079 if (lua_isnumber(L, index)) return 0; else return -1;
1080 }
1081
1082 template<class T>
1083 void converter_postcall(lua_State*, T, int) {}
1084 };
1085
1086 // ****** functor converter ********
1087
1088 template<class Direction> struct functor_converter;
1089
1090 template<>
1091 struct functor_converter<lua_to_cpp>
1092 {
1093 template<class T>
1094 functor<T> apply(lua_State* L, by_const_reference<functor<T> >, int index)
1095 {
1096 if (lua_isnil(L, index))
1097 return functor<T>();
1098
1099 lua_pushvalue(L, index);
1100 detail::lua_reference ref;
1101 ref.set(L);
1102 return functor<T>(L, ref);
1103 }
1104
1105 template<class T>
1106 functor<T> apply(lua_State* L, by_value<functor<T> >, int index)
1107 {
1108 if (lua_isnil(L, index))
1109 return functor<T>();
1110
1111 lua_pushvalue(L, index);
1112 detail::lua_reference ref;
1113 ref.set(L);
1114 return functor<T>(L, ref);
1115 }
1116
1117 template<class T>
1118 static int match(lua_State* L, by_const_reference<functor<T> >, int index)
1119 {
1120 if (lua_isfunction(L, index) || lua_isnil(L, index)) return 0; else return -1;
1121 }
1122
1123 template<class T>
1124 static int match(lua_State* L, by_value<functor<T> >, int index)
1125 {
1126 if (lua_isfunction(L, index) || lua_isnil(L, index)) return 0; else return -1;
1127 }
1128
1129 template<class T>
1130 void converter_postcall(lua_State*, T, int) {}
1131 };
1132
1133
1134
1135
1136
1137 // *********** default_policy *****************
1138
1139
1140
1141 struct default_policy : converter_policy_tag
1142 {
1143 BOOST_STATIC_CONSTANT(bool, has_arg = true);
1144
1145 template<class T>
1146 static void precall(lua_State*, T, int) {}
1147
1148 // template<class T>
1149 // static void postcall(lua_State*, T, int) {}
1150
1151 template<class T, class Direction>
1152 struct generate_converter
1153 {
1154 typedef typename boost::mpl::if_<is_user_defined<T>
1155 , user_defined_converter<Direction>
1156 // , typename boost::mpl::if_<is_implicit_conversion<T>
1157 // , implicit_converter<Direction>
1158 , typename boost::mpl::if_<is_primitive<T>
1159 , primitive_converter<Direction>
1160 , typename boost::mpl::if_<is_lua_functor<T>
1161 , functor_converter<Direction>
1162 , typename boost::mpl::if_<boost::is_enum<T>
1163 , enum_converter<Direction>
1164 , typename boost::mpl::if_<is_nonconst_pointer<T>
1165 , pointer_converter<Direction>
1166 , typename boost::mpl::if_<is_const_pointer<T>
1167 , const_pointer_converter<Direction>
1168 , typename boost::mpl::if_<is_nonconst_reference<T>
1169 , ref_converter<Direction>
1170 , typename boost::mpl::if_<is_const_reference<T>
1171 , const_ref_converter<Direction>
1172 , value_converter<Direction>
1173 >::type>::type>::type>::type>::type>::type>::type>::type type;
1174 };
1175 };
1176
1177 // ********** get policy **********
1178
1179 #if defined(BOOST_MSVC) && (BOOST_MSVC <= 1300)
1180 template<int N, class T>
1181 struct get_policy_list_impl
1182 {
1183 template<class U>
1184 struct inner
1185 {
1186 typedef typename U::head head;
1187 typedef typename U::tail tail;
1188
1189 typedef typename boost::mpl::if_<boost::mpl::equal_to<boost::mpl::integral_c<int, head::index>, boost::mpl::integral_c<int, N> >
1190 , policy_cons<head, typename get_policy_list_impl<N, tail>::type>
1191 , typename get_policy_list_impl<N, tail>::type
1192 >::type type;
1193 };
1194
1195 template<>
1196 struct inner<null_type>
1197 {
1198 typedef null_type type;
1199 };
1200
1201 typedef typename inner<T>::type type;
1202 };
1203 #else
1204 template<class List>
1205 struct get_policy_list_impl
1206 {
1207 template<int N>
1208 struct apply
1209 {
1210 typedef typename List::head head;
1211 typedef typename List::tail tail;
1212
1213 typedef typename boost::mpl::if_<boost::mpl::equal_to<boost::mpl::integral_c<int, head::index>, boost::mpl::integral_c<int, N> >
1214 , policy_cons<head, typename get_policy_list_impl<tail>::template apply<N>::type>
1215 , typename get_policy_list_impl<tail>::template apply<N>::type
1216 >::type type;
1217 };
1218 };
1219
1220 template<>
1221 struct get_policy_list_impl<detail::null_type>
1222 {
1223 template<int N>
1224 struct apply
1225 {
1226 typedef null_type type;
1227 };
1228 };
1229 #endif
1230
1231 template<int N, class T>
1232 struct get_policy_list
1233 {
1234 #if defined(BOOST_MSVC) && (BOOST_MSVC <= 1300)
1235 typedef typename get_policy_list_impl<N, T>::type type;
1236 #else
1237 typedef typename get_policy_list_impl<T>::template apply<N>::type type;
1238 #endif
1239 };
1240
1241 // ============== new policy system =================
1242
1243 template<int, class> struct find_conversion_policy;
1244
1245 template<bool IsConverter = false>
1246 struct find_conversion_impl
1247 {
1248 template<int N, class Policies>
1249 struct apply
1250 {
1251 typedef typename find_conversion_policy<N, typename Policies::tail>::type type;
1252 };
1253 };
1254
1255 template<>
1256 struct find_conversion_impl<true>
1257 {
1258 template<int N, class Policies>
1259 struct apply
1260 {
1261 typedef typename Policies::head head;
1262 typedef typename Policies::tail tail;
1263
1264 BOOST_STATIC_CONSTANT(bool, found = (N == head::index));
1265
1266 typedef typename
1267 boost::mpl::if_c<found
1268 , head
1269 , typename find_conversion_policy<N, tail>::type
1270 >::type type;
1271 };
1272 };
1273
1274 template<class Policies>
1275 struct find_conversion_impl2
1276 {
1277 template<int N>
1278 struct apply
1279 : find_conversion_impl<
1280 boost::is_base_and_derived<conversion_policy_base, typename Policies::head>::value
1281 >::template apply<N, Policies>
1282 {
1283 };
1284 };
1285
1286 template<>
1287 struct find_conversion_impl2<detail::null_type>
1288 {
1289 template<int N>
1290 struct apply
1291 {
1292 typedef default_policy type;
1293 };
1294 };
1295
1296 template<int N, class Policies>
1297 struct find_conversion_policy : find_conversion_impl2<Policies>::template apply<N>
1298 {
1299 };
1300
1301 template<class List>
1302 struct policy_list_postcall
1303 {
1304 typedef typename List::head head;
1305 typedef typename List::tail tail;
1306
1307 static void apply(lua_State* L, const index_map& i)
1308 {
1309 head::postcall(L, i);
1310 policy_list_postcall<tail>::apply(L, i);
1311 }
1312 };
1313
1314 template<>
1315 struct policy_list_postcall<detail::null_type>
1316 {
1317 static void apply(lua_State*, const index_map&) {}
1318 };
1319
1320 /* template<int N>
1321 struct find_conversion_policy<N, detail::null_type>
1322 {
1323 typedef default_policy type;
1324 };*/
1325
1326 // ==================================================
1327
1328 // ************** precall and postcall on policy_cons *********************
1329
1330
1331 template<class List>
1332 struct policy_precall
1333 {
1334 typedef typename List::head head;
1335 typedef typename List::tail tail;
1336
1337 static void apply(lua_State* L, int index)
1338 {
1339 head::precall(L, index);
1340 policy_precall<tail>::apply(L, index);
1341 }
1342 };
1343
1344 template<>
1345 struct policy_precall<detail::null_type>
1346 {
1347 static void apply(lua_State*, int) {}
1348 };
1349
1350 template<class List>
1351 struct policy_postcall
1352 {
1353 typedef typename List::head head;
1354 typedef typename List::tail tail;
1355
1356 static void apply(lua_State* L, int index)
1357 {
1358 head::postcall(L, index);
1359 policy_postcall<tail>::apply(L, index);
1360 }
1361 };
1362
1363 template<>
1364 struct policy_postcall<detail::null_type>
1365 {
1366 static void apply(lua_State*, int) {}
1367 };
1368
1369 /*
1370 struct pointer_only_converter
1371 {
1372 template<class T>
1373 static const T* apply(lua_State* L, type<const T*>, int index)
1374 {
1375 int a = index;
1376 }
1377 };
1378 */
1379 struct only_one_converter_policy_can_be_used_per_index {};
1380
1381 template<class List, class T> struct assert_converter_policy_impl;
1382
1383 template<class List>
1384 struct assert_converter_policy
1385 {
1386 template<class T>
1387 struct apply
1388 {
1389 typedef typename boost::mpl::if_<boost::is_base_and_derived<converter_policy_tag, typename List::head>
1390 , only_one_converter_policy_can_be_used_per_index
1391 , typename assert_converter_policy_impl<typename List::tail, T>::type
1392 >::type type;
1393 };
1394 };
1395
1396 template<>
1397 struct assert_converter_policy<detail::null_type>
1398 {
1399 template<class T>
1400 struct apply
1401 {
1402 typedef T type;
1403 };
1404 };
1405
1406 template<class List, class T>
1407 struct assert_converter_policy_impl
1408 {
1409 typedef typename assert_converter_policy<List>::template apply<T>::type type;
1410 };
1411
1412 template<class List>
1413 struct find_converter_policy_impl
1414 {
1415 typedef typename List::head head;
1416 typedef typename List::tail tail;
1417
1418 typedef typename boost::mpl::if_<boost::is_base_and_derived<converter_policy_tag, head>
1419 , typename assert_converter_policy_impl<tail, head>::type
1420 , typename find_converter_policy_impl<tail>::type
1421 >::type type;
1422 };
1423
1424 template<>
1425 struct find_converter_policy_impl<detail::null_type>
1426 {
1427 typedef default_policy type;
1428 };
1429
1430 }
1431 /*
1432 namespace converters
1433 {
1434 template<class T>
1435 struct FROM
1436 {
1437 BOOST_STATIC_CONSTANT(bool, is_specialized = true);
1438
1439 template<class U, int N>
1440 static U convert(lua_State* L, boost::mpl::int_<N>, detail::type<U>, int index)
1441 {
1442 typename luabind::detail::default_policy
1443 ::generate_converter<T, detail::lua_to_cpp>::type c;
1444 return static_cast<U>(c.apply(L,
1445 LUABIND_DECORATE_TYPE(T), index));
1446 }
1447
1448 template<class U>
1449 static std::pair<int,int> match(lua_State* L, boost::mpl::int_<N>, detail::type<U>, int index)
1450 {
1451 typedef typename luabind::detail::default_policy
1452 ::generate_converter<T, detail::lua_to_cpp>::type c;
1453
1454 int my_match = c::match(L, LUABIND_DECORATE_TYPE(T), index);
1455
1456 std::pair<int,int> result = TO<N + 1, U>
1457 ::match(L, boost::mpl::int_<N + 1>(), detail::type<U>(), index);
1458
1459 if (my_match < result.first() && my_match != -1)
1460 return std::make_pair(my_match, N);
1461 else
1462 return result;
1463 }
1464 };
1465 }
1466 */
1467 }
1468
1469
1470 namespace luabind { namespace
1471 {
1472 LUABIND_ANONYMOUS_FIX boost::arg<0> return_value;
1473 LUABIND_ANONYMOUS_FIX boost::arg<0> result;
1474 }}
1475
1476 #include <luabind/detail/object_funs.hpp>
1477
1478 #endif // LUABIND_POLICY_HPP_INCLUDED
1479
luabind