?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
*** empty log message ***
[luabind.git] / luabind / detail / policy.hpp
blobc52af7b16388fdcfee387545f1007adfc4455ae2
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 // if you get caught in this assert you are
653 // trying to use an unregistered type
654 assert(crep && "you are trying to use an unregistered type");
655
656 // create the struct to hold the object
657 void* obj = lua_newuserdata(L, sizeof(object_rep));
658 //new(obj) object_rep(ptr, crep, object_rep::owner, destructor_s<T>::apply);
659 new(obj) object_rep(ptr, crep, 0, 0);
660
661 // set the meta table
662 detail::getref(L, crep->metatable_ref());
663 lua_setmetatable(L, -2);
664
665 // make_instance(L, ptr, (pointer_holder<T, T*>*)0);
666 }
667 };
668
669 template<class T> struct make_pointer { typedef T* type; };
670 template<>
671 struct pointer_converter<lua_to_cpp>
672 {
673 // TODO: does the pointer converter need this?!
674 char target[32];
675 void (*destructor)(void *);
676
677 pointer_converter(): destructor(0) {}
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 if ((void*)ptr == (char*)target) destructor = detail::destruct_only_s<T>::apply;
696 assert(!destructor || sizeof(T) <= 32);
697
698 return ptr;
699 }
700
701 template<class T>
702 static int match(lua_State* L, by_pointer<T>, int index)
703 {
704 if (lua_isnil(L, index)) return 0;
705 object_rep* obj = is_class_object(L, index);
706 if (obj == 0) return -1;
707 // cannot cast a constant object to nonconst
708 if (obj->flags() & object_rep::constant) return -1;
709
710 if ((LUABIND_TYPE_INFO_EQUAL(obj->crep()->holder_type(), LUABIND_TYPEID(T))))
711 return (obj->flags() & object_rep::constant)?-1:0;
712 if ((LUABIND_TYPE_INFO_EQUAL(obj->crep()->const_holder_type(), LUABIND_TYPEID(T))))
713 return (obj->flags() & object_rep::constant)?0:-1;
714
715
716 int d;
717 return implicit_cast(obj->crep(), LUABIND_TYPEID(T), d);
718 }
719
720 ~pointer_converter()
721 {
722 if (destructor) destructor(target);
723 }
724
725 template<class T>
726 void converter_postcall(lua_State*, by_pointer<T>, int)
727 {}
728 };
729
730 // ******* value converter *******
731
732 template<class Direction> struct value_converter;
733
734 template<>
735 struct value_converter<cpp_to_lua>
736 {
737 template<class T>
738 void apply(lua_State* L, const T& ref)
739 {
740 class_rep* crep = get_class_rep<T>(L);
741
742 // if you get caught in this assert you are
743 // trying to use an unregistered type
744 assert(crep && "you are trying to use an unregistered type");
745
746 void* obj_rep;
747 void* held;
748
749 boost::tie(obj_rep,held) = crep->allocate(L);
750
751 void* object_ptr;
752 void(*destructor)(void*);
753 destructor = crep->destructor();
754 int flags = object_rep::owner;
755 if (crep->has_holder())
756 {
757 new(held) T(ref);
758 object_ptr = held;
759 if (LUABIND_TYPE_INFO_EQUAL(LUABIND_TYPEID(T), crep->const_holder_type()))
760 {
761 flags |= object_rep::constant;
762 destructor = crep->const_holder_destructor();
763 }
764 }
765 else
766 {
767 object_ptr = new T(ref);
768 }
769 new(obj_rep) object_rep(object_ptr, crep, flags, destructor);
770
771 // set the meta table
772 detail::getref(L, crep->metatable_ref());
773 lua_setmetatable(L, -2);
774 }
775 };
776
777
778 template<class T> struct make_const_reference { typedef const T& type; };
779
780 template<class T>
781 struct destruct_guard
782 {
783 T* ptr;
784 bool dismiss;
785 destruct_guard(T* p): ptr(p), dismiss(false) {}
786
787 ~destruct_guard()
788 {
789 if (!dismiss)
790 ptr->~T();
791 }
792 };
793
794 template<>
795 struct value_converter<lua_to_cpp>
796 {
797 template<class T>
798 /*typename make_const_reference<T>::type*/T apply(lua_State* L, by_value<T>, int index)
799 {
800 // preconditions:
801 // lua_isuserdata(L, index);
802 // getmetatable().__lua_class is true
803 // object_rep->flags() & object_rep::constant == 0
804
805 object_rep* obj = 0;
806 const class_rep* crep = 0;
807
808 // special case if we get nil in, try to convert the holder type
809 if (lua_isnil(L, index))
810 {
811 crep = get_class_rep<T>(L);;
812 assert(crep);
813 }
814 else
815 {
816 obj = static_cast<object_rep*>(lua_touserdata(L, index));
817 assert((obj != 0) && "internal error, please report"); // internal error
818 crep = obj->crep();
819 }
820 assert(crep);
821
822 // TODO: align!
823 char target[sizeof(T)];
824 T* ptr = reinterpret_cast<T*>(crep->convert_to(LUABIND_TYPEID(T), obj, target));
825
826 destruct_guard<T> guard(ptr);
827 if ((void*)ptr != (void*)target) guard.dismiss = true;
828
829 return *ptr;
830 }
831
832 template<class T>
833 static int match(lua_State* L, by_value<T>, int index)
834 {
835 // special case if we get nil in, try to match the holder type
836 if (lua_isnil(L, index))
837 {
838 class_rep* crep = get_class_rep<T>(L);
839 if (crep == 0) return -1;
840 if ((LUABIND_TYPE_INFO_EQUAL(crep->holder_type(), LUABIND_TYPEID(T))))
841 return 0;
842 if ((LUABIND_TYPE_INFO_EQUAL(crep->const_holder_type(), LUABIND_TYPEID(T))))
843 return 0;
844 return -1;
845 }
846
847 object_rep* obj = is_class_object(L, index);
848 if (obj == 0) return -1;
849 int d;
850
851 if ((LUABIND_TYPE_INFO_EQUAL(obj->crep()->holder_type(), LUABIND_TYPEID(T))))
852 return (obj->flags() & object_rep::constant)?-1:0;
853 if ((LUABIND_TYPE_INFO_EQUAL(obj->crep()->const_holder_type(), LUABIND_TYPEID(T))))
854 return (obj->flags() & object_rep::constant)?0:1;
855
856 return implicit_cast(obj->crep(), LUABIND_TYPEID(T), d);
857 }
858
859 template<class T>
860 void converter_postcall(lua_State*, T, int) {}
861 };
862
863 // ******* const pointer converter *******
864
865 template<class Direction> struct const_pointer_converter;
866
867 template<>
868 struct const_pointer_converter<cpp_to_lua>
869 {
870 template<class T>
871 void apply(lua_State* L, const T* ptr)
872 {
873 if (ptr == 0)
874 {
875 lua_pushnil(L);
876 return;
877 }
878
879 class_rep* crep = get_class_rep<T>(L);
880
881 // if you get caught in this assert you are
882 // trying to use an unregistered type
883 assert(crep && "you are trying to use an unregistered type");
884
885 // create the struct to hold the object
886 void* obj = lua_newuserdata(L, sizeof(object_rep));
887 assert(obj && "internal error, please report");
888 // we send 0 as destructor since we know it will never be called
889 new(obj) object_rep(const_cast<T*>(ptr), crep, object_rep::constant, 0);
890
891 // set the meta table
892 detail::getref(L, crep->metatable_ref());
893 lua_setmetatable(L, -2);
894 }
895 };
896
897
898 template<class T> struct make_const_pointer { typedef const T* type; };
899 template<>
900 struct const_pointer_converter<lua_to_cpp>
901 : private pointer_converter<lua_to_cpp>
902 {
903 template<class T>
904 typename make_const_pointer<T>::type apply(lua_State* L, by_const_pointer<T>, int index)
905 {
906 // std::cerr << "const_pointer_converter\n";
907 return pointer_converter<lua_to_cpp>::apply(L, by_pointer<T>(), index);
908 }
909
910 template<class T>
911 static int match(lua_State* L, by_const_pointer<T>, int index)
912 {
913 if (lua_isnil(L, index)) return 0;
914 object_rep* obj = is_class_object(L, index);
915 if (obj == 0) return -1; // if the type is not one of our own registered types, classify it as a non-match
916
917 if ((LUABIND_TYPE_INFO_EQUAL(obj->crep()->holder_type(), LUABIND_TYPEID(T))))
918 return (obj->flags() & object_rep::constant)?-1:0;
919 if ((LUABIND_TYPE_INFO_EQUAL(obj->crep()->const_holder_type(), LUABIND_TYPEID(T))))
920 return (obj->flags() & object_rep::constant)?0:1;
921
922 int d;
923 return implicit_cast(obj->crep(), LUABIND_TYPEID(T), d);
924 }
925
926 template<class T>
927 void converter_postcall(lua_State* L, by_const_pointer<T>, int index)
928 {
929 pointer_converter<lua_to_cpp>::converter_postcall(L, by_pointer<T>(), index);
930 }
931 };
932
933 // ******* reference converter *******
934
935 template<class Direction> struct ref_converter;
936
937 template<>
938 struct ref_converter<cpp_to_lua>
939 {
940 template<class T>
941 void apply(lua_State* L, T& ref)
942 {
943 class_rep* crep = get_class_rep<T>(L);
944
945 // if you get caught in this assert you are
946 // trying to use an unregistered type
947 assert(crep && "you are trying to use an unregistered type");
948
949 T* ptr = &ref;
950
951 // create the struct to hold the object
952 void* obj = lua_newuserdata(L, sizeof(object_rep));
953 assert(obj && "internal error, please report");
954 new(obj) object_rep(ptr, crep, 0, 0);
955
956 // set the meta table
957 detail::getref(L, crep->metatable_ref());
958 lua_setmetatable(L, -2);
959 }
960 };
961
962 template<class T> struct make_reference { typedef T& type; };
963 template<>
964 struct ref_converter<lua_to_cpp>
965 {
966 template<class T>
967 typename make_reference<T>::type apply(lua_State* L, by_reference<T>, int index)
968 {
969 // std::cerr << "ref_converter<lua_to_cpp>\n";
970 return *pointer_converter<lua_to_cpp>().apply(L, by_pointer<T>(), index);
971 }
972
973 template<class T>
974 static int match(lua_State* L, by_reference<T>, int index)
975 {
976 return pointer_converter<lua_to_cpp>::match(L, by_pointer<T>(), index);
977 }
978
979 template<class T>
980 void converter_postcall(lua_State*, T, int) {}
981 };
982
983 // ******** const reference converter *********
984
985 template<class Direction> struct const_ref_converter;
986
987 template<>
988 struct const_ref_converter<cpp_to_lua>
989 {
990 template<class T>
991 void apply(lua_State* L, const T& ref)
992 {
993 class_rep* crep = get_class_rep<T>(L);
994
995 // if you get caught in this assert you are
996 // trying to use an unregistered type
997 assert(crep && "you are trying to use an unregistered type");
998
999
1000 void* obj_rep;
1001 void* held;
1002
1003 boost::tie(obj_rep,held) = crep->allocate(L);
1004
1005 void* object_ptr;
1006 void(*destructor)(void*);
1007 destructor = crep->destructor();
1008 int flags = 0;
1009 if (crep->has_holder())
1010 {
1011 flags = object_rep::owner;
1012 new(held) T(ref);
1013 object_ptr = held;
1014 if (LUABIND_TYPE_INFO_EQUAL(LUABIND_TYPEID(T), crep->const_holder_type()))
1015 {
1016 flags |= object_rep::constant;
1017 destructor = crep->const_holder_destructor();
1018 }
1019 }
1020 else
1021 {
1022 object_ptr = new T(ref);
1023 }
1024 new(obj_rep) object_rep(object_ptr, crep, flags, destructor);
1025
1026 // set the meta table
1027 detail::getref(L, crep->metatable_ref());
1028 lua_setmetatable(L, -2);
1029 }
1030 };
1031
1032 template<>
1033 struct const_ref_converter<lua_to_cpp>
1034 {
1035 // TODO: align!
1036 char target[32];
1037 void (*destructor)(void*);
1038
1039 const_ref_converter(): destructor(0) {}
1040
1041 template<class T>
1042 typename make_const_reference<T>::type apply(lua_State* L, by_const_reference<T>, int index)
1043 {
1044 object_rep* obj = 0;
1045 class_rep const * crep = 0;
1046
1047 // special case if we get nil in, try to convert the holder type
1048 if (lua_isnil(L, index))
1049 {
1050 crep = get_class_rep<T>(L);
1051 assert(crep);
1052 }
1053 else
1054 {
1055 obj = static_cast<object_rep*>(lua_touserdata(L, index));
1056 assert((obj != 0) && "internal error, please report"); // internal error
1057 crep = obj->crep();
1058 }
1059 assert(crep);
1060
1061 T* ptr = reinterpret_cast<T*>(crep->convert_to(LUABIND_TYPEID(T), obj, target));
1062 // if the pointer returned points into the converter storage,
1063 // we need to destruct it once the converter destructs
1064 if ((void*)ptr == (void*)target) destructor = detail::destruct_only_s<T>::apply;
1065 assert(!destructor || sizeof(T) <= 32);
1066
1067 return *ptr;
1068 }
1069
1070 template<class T>
1071 static int match(lua_State* L, by_const_reference<T>, int index)
1072 {
1073 // special case if we get nil in, try to match the holder type
1074 if (lua_isnil(L, index))
1075 {
1076 class_rep* crep = get_class_rep<T>(L);;
1077 if (crep == 0) return -1;
1078 if ((LUABIND_TYPE_INFO_EQUAL(crep->holder_type(), LUABIND_TYPEID(T))))
1079 return 0;
1080 if ((LUABIND_TYPE_INFO_EQUAL(crep->const_holder_type(), LUABIND_TYPEID(T))))
1081 return 0;
1082 return -1;
1083 }
1084
1085 object_rep* obj = is_class_object(L, index);
1086 if (obj == 0) return -1; // if the type is not one of our own registered types, classify it as a non-match
1087
1088 if ((LUABIND_TYPE_INFO_EQUAL(obj->crep()->holder_type(), LUABIND_TYPEID(T))))
1089 return (obj->flags() & object_rep::constant)?-1:0;
1090 if ((LUABIND_TYPE_INFO_EQUAL(obj->crep()->const_holder_type(), LUABIND_TYPEID(T))))
1091 return (obj->flags() & object_rep::constant)?0:1;
1092
1093 int d;
1094 return implicit_cast(obj->crep(), LUABIND_TYPEID(T), d);
1095 }
1096
1097 ~const_ref_converter()
1098 {
1099 if (destructor) destructor(target);
1100 }
1101
1102 template<class T>
1103 void converter_postcall(lua_State* L, by_const_reference<T>, int index)
1104 {
1105 }
1106 };
1107
1108 // ****** enum converter ********
1109
1110 template<class Direction = cpp_to_lua>
1111 struct enum_converter
1112 {
1113 void apply(lua_State* L, int val)
1114 {
1115 lua_pushnumber(L, val);
1116 }
1117 };
1118
1119 template<>
1120 struct enum_converter<lua_to_cpp>
1121 {
1122 template<class T>
1123 T apply(lua_State* L, by_value<T>, int index)
1124 {
1125 // std::cerr << "enum_converter\n";
1126 return static_cast<T>(static_cast<int>(lua_tonumber(L, index)));
1127 }
1128
1129 template<class T>
1130 static int match(lua_State* L, by_value<T>, int index)
1131 {
1132 if (lua_isnumber(L, index)) return 0; else return -1;
1133 }
1134
1135 template<class T>
1136 void converter_postcall(lua_State*, T, int) {}
1137 };
1138
1139 // ****** functor converter ********
1140
1141 template<class Direction> struct functor_converter;
1142
1143 template<>
1144 struct functor_converter<lua_to_cpp>
1145 {
1146 template<class T>
1147 functor<T> apply(lua_State* L, by_const_reference<functor<T> >, int index)
1148 {
1149 if (lua_isnil(L, index))
1150 return functor<T>();
1151
1152 lua_pushvalue(L, index);
1153 detail::lua_reference ref;
1154 ref.set(L);
1155 return functor<T>(L, ref);
1156 }
1157
1158 template<class T>
1159 functor<T> apply(lua_State* L, by_value<functor<T> >, int index)
1160 {
1161 if (lua_isnil(L, index))
1162 return functor<T>();
1163
1164 lua_pushvalue(L, index);
1165 detail::lua_reference ref;
1166 ref.set(L);
1167 return functor<T>(L, ref);
1168 }
1169
1170 template<class T>
1171 static int match(lua_State* L, by_const_reference<functor<T> >, int index)
1172 {
1173 if (lua_isfunction(L, index) || lua_isnil(L, index)) return 0; else return -1;
1174 }
1175
1176 template<class T>
1177 static int match(lua_State* L, by_value<functor<T> >, int index)
1178 {
1179 if (lua_isfunction(L, index) || lua_isnil(L, index)) return 0; else return -1;
1180 }
1181
1182 template<class T>
1183 void converter_postcall(lua_State*, T, int) {}
1184 };
1185
1186
1187
1188
1189
1190 // *********** default_policy *****************
1191
1192
1193
1194 struct default_policy : converter_policy_tag
1195 {
1196 BOOST_STATIC_CONSTANT(bool, has_arg = true);
1197
1198 template<class T>
1199 static void precall(lua_State*, T, int) {}
1200
1201 // template<class T>
1202 // static void postcall(lua_State*, T, int) {}
1203
1204 template<class T, class Direction>
1205 struct generate_converter
1206 {
1207 typedef typename boost::mpl::if_<is_user_defined<T>
1208 , user_defined_converter<Direction>
1209 // , typename boost::mpl::if_<is_implicit_conversion<T>
1210 // , implicit_converter<Direction>
1211 , typename boost::mpl::if_<is_primitive<T>
1212 , primitive_converter<Direction>
1213 , typename boost::mpl::if_<is_lua_functor<T>
1214 , functor_converter<Direction>
1215 , typename boost::mpl::if_<boost::is_enum<T>
1216 , enum_converter<Direction>
1217 , typename boost::mpl::if_<is_nonconst_pointer<T>
1218 , pointer_converter<Direction>
1219 , typename boost::mpl::if_<is_const_pointer<T>
1220 , const_pointer_converter<Direction>
1221 , typename boost::mpl::if_<is_nonconst_reference<T>
1222 , ref_converter<Direction>
1223 , typename boost::mpl::if_<is_const_reference<T>
1224 , const_ref_converter<Direction>
1225 , value_converter<Direction>
1226 >::type>::type>::type>::type>::type>::type>::type>::type type;
1227 };
1228 };
1229
1230 // ********** get policy **********
1231
1232 #if defined(BOOST_MSVC) && (BOOST_MSVC <= 1300)
1233 template<int N, class T>
1234 struct get_policy_list_impl
1235 {
1236 template<class U>
1237 struct inner
1238 {
1239 typedef typename U::head head;
1240 typedef typename U::tail tail;
1241
1242 typedef typename boost::mpl::if_<boost::mpl::equal_to<boost::mpl::integral_c<int, head::index>, boost::mpl::integral_c<int, N> >
1243 , policy_cons<head, typename get_policy_list_impl<N, tail>::type>
1244 , typename get_policy_list_impl<N, tail>::type
1245 >::type type;
1246 };
1247
1248 template<>
1249 struct inner<null_type>
1250 {
1251 typedef null_type type;
1252 };
1253
1254 typedef typename inner<T>::type type;
1255 };
1256 #else
1257 template<class List>
1258 struct get_policy_list_impl
1259 {
1260 template<int N>
1261 struct apply
1262 {
1263 typedef typename List::head head;
1264 typedef typename List::tail tail;
1265
1266 typedef typename boost::mpl::if_<boost::mpl::equal_to<boost::mpl::integral_c<int, head::index>, boost::mpl::integral_c<int, N> >
1267 , policy_cons<head, typename get_policy_list_impl<tail>::template apply<N>::type>
1268 , typename get_policy_list_impl<tail>::template apply<N>::type
1269 >::type type;
1270 };
1271 };
1272
1273 template<>
1274 struct get_policy_list_impl<detail::null_type>
1275 {
1276 template<int N>
1277 struct apply
1278 {
1279 typedef null_type type;
1280 };
1281 };
1282 #endif
1283
1284 template<int N, class T>
1285 struct get_policy_list
1286 {
1287 #if defined(BOOST_MSVC) && (BOOST_MSVC <= 1300)
1288 typedef typename get_policy_list_impl<N, T>::type type;
1289 #else
1290 typedef typename get_policy_list_impl<T>::template apply<N>::type type;
1291 #endif
1292 };
1293
1294 // ============== new policy system =================
1295
1296 template<int, class> struct find_conversion_policy;
1297
1298 template<bool IsConverter = false>
1299 struct find_conversion_impl
1300 {
1301 template<int N, class Policies>
1302 struct apply
1303 {
1304 typedef typename find_conversion_policy<N, typename Policies::tail>::type type;
1305 };
1306 };
1307
1308 template<>
1309 struct find_conversion_impl<true>
1310 {
1311 template<int N, class Policies>
1312 struct apply
1313 {
1314 typedef typename Policies::head head;
1315 typedef typename Policies::tail tail;
1316
1317 BOOST_STATIC_CONSTANT(bool, found = (N == head::index));
1318
1319 typedef typename
1320 boost::mpl::if_c<found
1321 , head
1322 , typename find_conversion_policy<N, tail>::type
1323 >::type type;
1324 };
1325 };
1326
1327 template<class Policies>
1328 struct find_conversion_impl2
1329 {
1330 template<int N>
1331 struct apply
1332 : find_conversion_impl<
1333 boost::is_base_and_derived<conversion_policy_base, typename Policies::head>::value
1334 >::template apply<N, Policies>
1335 {
1336 };
1337 };
1338
1339 template<>
1340 struct find_conversion_impl2<detail::null_type>
1341 {
1342 template<int N>
1343 struct apply
1344 {
1345 typedef default_policy type;
1346 };
1347 };
1348
1349 template<int N, class Policies>
1350 struct find_conversion_policy : find_conversion_impl2<Policies>::template apply<N>
1351 {
1352 };
1353
1354 template<class List>
1355 struct policy_list_postcall
1356 {
1357 typedef typename List::head head;
1358 typedef typename List::tail tail;
1359
1360 static void apply(lua_State* L, const index_map& i)
1361 {
1362 head::postcall(L, i);
1363 policy_list_postcall<tail>::apply(L, i);
1364 }
1365 };
1366
1367 template<>
1368 struct policy_list_postcall<detail::null_type>
1369 {
1370 static void apply(lua_State*, const index_map&) {}
1371 };
1372
1373 /* template<int N>
1374 struct find_conversion_policy<N, detail::null_type>
1375 {
1376 typedef default_policy type;
1377 };*/
1378
1379 // ==================================================
1380
1381 // ************** precall and postcall on policy_cons *********************
1382
1383
1384 template<class List>
1385 struct policy_precall
1386 {
1387 typedef typename List::head head;
1388 typedef typename List::tail tail;
1389
1390 static void apply(lua_State* L, int index)
1391 {
1392 head::precall(L, index);
1393 policy_precall<tail>::apply(L, index);
1394 }
1395 };
1396
1397 template<>
1398 struct policy_precall<detail::null_type>
1399 {
1400 static void apply(lua_State*, int) {}
1401 };
1402
1403 template<class List>
1404 struct policy_postcall
1405 {
1406 typedef typename List::head head;
1407 typedef typename List::tail tail;
1408
1409 static void apply(lua_State* L, int index)
1410 {
1411 head::postcall(L, index);
1412 policy_postcall<tail>::apply(L, index);
1413 }
1414 };
1415
1416 template<>
1417 struct policy_postcall<detail::null_type>
1418 {
1419 static void apply(lua_State*, int) {}
1420 };
1421
1422 /*
1423 struct pointer_only_converter
1424 {
1425 template<class T>
1426 static const T* apply(lua_State* L, type<const T*>, int index)
1427 {
1428 int a = index;
1429 }
1430 };
1431 */
1432 struct only_one_converter_policy_can_be_used_per_index {};
1433
1434 template<class List, class T> struct assert_converter_policy_impl;
1435
1436 template<class List>
1437 struct assert_converter_policy
1438 {
1439 template<class T>
1440 struct apply
1441 {
1442 typedef typename boost::mpl::if_<boost::is_base_and_derived<converter_policy_tag, typename List::head>
1443 , only_one_converter_policy_can_be_used_per_index
1444 , typename assert_converter_policy_impl<typename List::tail, T>::type
1445 >::type type;
1446 };
1447 };
1448
1449 template<>
1450 struct assert_converter_policy<detail::null_type>
1451 {
1452 template<class T>
1453 struct apply
1454 {
1455 typedef T type;
1456 };
1457 };
1458
1459 template<class List, class T>
1460 struct assert_converter_policy_impl
1461 {
1462 typedef typename assert_converter_policy<List>::template apply<T>::type type;
1463 };
1464
1465 template<class List>
1466 struct find_converter_policy_impl
1467 {
1468 typedef typename List::head head;
1469 typedef typename List::tail tail;
1470
1471 typedef typename boost::mpl::if_<boost::is_base_and_derived<converter_policy_tag, head>
1472 , typename assert_converter_policy_impl<tail, head>::type
1473 , typename find_converter_policy_impl<tail>::type
1474 >::type type;
1475 };
1476
1477 template<>
1478 struct find_converter_policy_impl<detail::null_type>
1479 {
1480 typedef default_policy type;
1481 };
1482
1483 }
1484 /*
1485 namespace converters
1486 {
1487 template<class T>
1488 struct FROM
1489 {
1490 BOOST_STATIC_CONSTANT(bool, is_specialized = true);
1491
1492 template<class U, int N>
1493 static U convert(lua_State* L, boost::mpl::int_<N>, detail::type<U>, int index)
1494 {
1495 typename luabind::detail::default_policy
1496 ::generate_converter<T, detail::lua_to_cpp>::type c;
1497 return static_cast<U>(c.apply(L,
1498 LUABIND_DECORATE_TYPE(T), index));
1499 }
1500
1501 template<class U>
1502 static std::pair<int,int> match(lua_State* L, boost::mpl::int_<N>, detail::type<U>, int index)
1503 {
1504 typedef typename luabind::detail::default_policy
1505 ::generate_converter<T, detail::lua_to_cpp>::type c;
1506
1507 int my_match = c::match(L, LUABIND_DECORATE_TYPE(T), index);
1508
1509 std::pair<int,int> result = TO<N + 1, U>
1510 ::match(L, boost::mpl::int_<N + 1>(), detail::type<U>(), index);
1511
1512 if (my_match < result.first() && my_match != -1)
1513 return std::make_pair(my_match, N);
1514 else
1515 return result;
1516 }
1517 };
1518 }
1519 */
1520 }
1521
1522
1523 namespace luabind { namespace
1524 {
1525 LUABIND_ANONYMOUS_FIX boost::arg<0> return_value;
1526 LUABIND_ANONYMOUS_FIX boost::arg<0> result;
1527 }}
1528
1529 #include <luabind/detail/object_funs.hpp>
1530
1531 #endif // LUABIND_POLICY_HPP_INCLUDED
1532
luabind