| blob | 5095b6574e61d616ad1e0e143d91e27e94db5caf |
3 <html>
4 <head>
8 </head>
10 <body>
12 <p>This library is currently in public beta phase. This documentation should be considered beta as well.
13 Please report any grammatical corrections/spelling corrections.</p>
17 <ol>
19 <ul>
22 </ul>
27 <ul>
31 </ul>
33 <ul>
39 </ul>
41 <ul>
45 </ul>
47 <ul>
51 </ul>
54 <ul>
66 </ul>
74 </ol>
78 <p>Luabind is a library that helps you create bindings
80 has the ability to expose functions and classes, written in C++, to lua. It will
81 also supply the functionality to define classes in lua and let them derive from
82 other lua classes or C++ classes. Lua classes can override virtual functions
83 from their C++ base classes. It is written towards lua 5.0, and does not work
86 <p>It is implemented utilizing template meta programming.
87 That means that you don't need an extra preprocess pass to compile your project
88 (it is done by the compiler). It also means you don't (usually) have to know the
89 exact signature of each function you register, since the library will generate
90 code depending on the compile-time type of the function (which includes the
91 signature). The main drawback of this approach is that the compilation time will
92 increase for the file that does the registration, it is therefore recommended
93 that you register everything in the same cpp-file.</p>
95 <p>luabind is released under the terms of the
98 <p>We are very interested in hearing about projects that use luabind, please let
99 us know about your project.</p>
104 <ul>
105 <li>overloaded free functions
106 <li>C++ classes in lua
107 <ul>
108 <li>overloaded member functions
109 <li>operators
110 <li>properties
111 <li>enums
112 </ul>
113 <li>lua functions in C++
114 <li>lua classes in C++
115 <li>lua classes (single inheritance)
116 <ul>
117 <li>derives from lua or C++ classes
118 <li>override virtual functions from C++ classes
119 </ul>
120 <li>implicit casts between registered types
121 <li>best match signature matching
122 <li>return value policies and parameter policies
123 </ul>
127 <p>Luabind has been tested to work on the following
128 compilers:</p>
130 <ul>
139 </ul>
143 <ul>
145 </ul>
148 functions are treated as non-const member functions.</p>
150 <p>If you have tried luabind with a compiler not listed here, let us know
151 your result with it.</p>
155 <p>To keep down the compilation-time luabind is built as a library. This means you
156 have to either build it and lika against it, or include its source files in your project.
159 (only boost headers). It also requires that lua is installed.</p>
161 <p>There is a makefile in the root-directory that will build the library and the test program.
162 If you are using a UNIX-system (or cygwin) they will make it easy to build luabind as a static
163 library. If you are using Visual Studio it may be easier to include the files in the <tt>src</tt>
164 directory in your project.</p>
166 <p>When building luabind you have several options that may streamline the library to better suit
167 your needs. It is extremely important that your application has the same settings as the library
168 was built with. The available options are found in the <a href="#config">Configuration</a> section.</p>
170 <p>If you want to change the settings to differ from the default, it's recommended that you define
171 the settings on the commandline of all your files (in the project settings in visual studio).</p>
177 <pre>
178 extern "C"
179 {
180 #include "lua.h"
181 }
184 </pre>
186 <p>This includes support for both registering classes and functions. If you just want to
190 <pre>
193 </pre>
196 register the functions to create classes from lua, and initialize some state-global
197 structures used by luabind. If you don't call this function you will hit asserts later in
198 the library. There is no corresponding close function because once a class has been registered
199 in lua, there really isn't any good way to remove it. Partly because any remaining instances
200 of that class relies on the class being there. Everything will be cleaned up when the state
201 is closed though.</p>
203 <p>Note that no luabind header will include <tt>"lua.h"</tt>, this is up to you. You have to include
204 it before any luabind header is included.</p>
209 <p>Everything that gets registered in lua is registered in a namespace (lua tables) or in the global
210 scope (called module). All registrations must be surrounded by its scope. To define a module, the
213 <pre>
214 module(L)
215 [
216 // declarations
217 ];
218 </pre>
220 <p>This will register all declared functions or classes in the global namespace in lua. If you want
221 to have a namespace for your module (like the standard libraries) you can give a name to the constructor,
222 like this:</p>
224 <pre>
225 module(L, "my_library")
226 [
227 // declarations
228 ];
229 </pre>
233 <p>If you want nested namespaces you can use the <tt>luabind::namespace_</tt> class. It works exactly
234 as <tt>luabind::module</tt> except that it doesn't take a <tt>lua_State*</tt> in it's constructor.
235 An example of its usage could look like this:</p>
237 <pre>
238 module(L, "my_library")
239 [
241 // declarations
243 namespace_("detail")
244 [
245 // library-private declarations
246 ]
248 ];
249 </pre>
253 <pre>
254 module(L)
255 [
256 namespace_("my_library")
257 [
258 // declarations
259 ]
261 ];
262 </pre>
264 <pre>
265 module(L, "my_library")
266 [
267 // declarations
268 ];
269 </pre>
271 <p>In the rest of the documentation the <tt>module</tt> around declarations is ommited to make the
272 examples focus on the actual declaration.</p>
274 <p>A word of caution, if you are in <b>really</b> bad need for performance, putting your functions
275 in tables will increase the lookup time.</p>
279 <p>To bind functions to lua you use the function <tt>luabind::function()</tt>. It has the following
280 synopsis:</p>
282 <pre>
284 void function(lua_State* L, const char* name, F f, const Policies&);
285 </pre>
287 <ul>
288 <li>L is the lua state you want this function registered
289 in.
290 <li>name is the name the function will have within lua.
291 <li>F is the function pointer you want to register.
292 <li>The Policies parameter is used to describe how
293 parameters and return values are treated by the function, this is an optional
295 </ul>
297 <p>An example usage could be if you want to register the
300 <pre>
302 </pre>
306 <p>If you have more than one function with the same name,
307 and want to register them in lua, you have to explicitly give the signature.
308 This is to let C++ know which function you refer to. For example, if you have
311 <pre>
314 </pre>
318 <p>luabind will generate code that checks the lua stack to
319 see if the values there can match your functions' signatures. It will handle
320 implicit typecasts between derived classes, and it will prefer matches with the
321 least number of implicit casts. In a function call, if the function is
322 overloaded and there's no overload that match the parameters better than the
323 other, you have an ambiguity. This will spawn a run-time error, stating that the
324 function call is ambiguous. A simple example of this is to register one function
325 that takes an <tt>int</tt> and one that takes a <tt>float</tt>. Since lua don't distinguish between floats and
326 integers, both will always match.</p>
328 <p>Since all overloads are tested, it will always find the
329 best match (not the first match). This also means that it can handle situations
330 where the only difference in the signature is that one member function is const
331 and the other isn't. For example, if the following function and class is
332 registered:</p>
334 <pre>
335 struct A
336 {
337 void f();
338 void f() const;
339 };
341 const A* create_a();
343 struct B: A {};
344 struct C: B {};
346 void g(A*);
347 void g(B*);
348 </pre>
350 <p>(note that <tt>create_a()</tt> would need an <a href="#policies_adopt" >adopt return value policy</a>. How to register classes is
355 <pre>
356 a1 = create_a()
357 a1:f() -- the const version is called
359 a2 = A()
360 a2:f() -- the non-const version is called
362 a = A()
363 b = B()
364 c = C()
366 g(a) -- calls g(A*)
367 g(b) -- calls g(B*)
368 g(c) -- calls g(B*)
369 </pre>
373 <p>To call a lua function, you can either use <tt>call_function()</tt>, <tt>call_member()</tt>, an
377 Ret call_function(lua_State* L, const char* name, ...)</tt></h3>
378 <p>This calls the global function called <tt>name</tt>. This function can only call global lua functions. The
379 ... represents a variable number of parameters that are sent to the lua function. This function call may
382 <p>The return value isn't actually <tt>Ret</tt> (the template parameter), but a proxy object that will do
383 the function call. This enables you to give policies to the call. You do this with the operator[]. You
384 give the policies within the brackets, like this:</p>
386 <pre>
388 </pre>
392 <p>This treats the given <tt>object</tt> as an instance of a class. The given name is the name of a member
393 function to call. The ... represents a variable number of parameters given to the function. This function may
396 <p>You can give policies to a member function call the same way as you do with <tt>call_function</tt>.</p>
400 <p>To register classes you use a class called <tt>class_</tt>. Its name is supposed to resemble the C++
401 keyword, to make it look more intuitive. It has an overloaded member function
403 operators, constructors, enums and properties on the class. It will return its
404 this-pointer, to let you register more members directly.</p>
406 <p>Let's start with a simple example. Consider the
407 following C++ class:</p>
409 <pre>
410 class testclass
411 {
412 public:
413 testclass(const std::string& s): m_string(s) {}
415 private:
416 std::string m_string;
417 };
418 </pre>
420 <p>To register it with a lua environment, write as follows
423 <pre>
427 .commit(L);
428 </pre>
430 <p>This will register the class with the name <tt>testclass</tt> and constructor that takes a string as
431 argument and one member function with the name <tt>print_string</tt>. The <tt>commit</tt> member function
432 will do the actual registration of the class, therefore, <tt>commit</tt> has to be the last member function called (You cannot add any more attributes or member functions to your class after <tt>commit</tt>).
433 You can use this class in lua like this:</p>
435 <pre>
436 -- instantiate the class
437 a = testclass('a string')
439 -- call the member function print_string on it
440 -- this will print 'a string' on stdout
441 a:print_string()
442 </pre>
444 <p>It is also possible to register free functions as member
445 functions. The requirement on the function is that it takes a pointer, const
446 pointer, reference or const reference to the class type as the first parameter.
447 The rest of the parameters are the ones that are visible in lua, while the
448 object pointer is given as the first parameter. If we have the following C++
449 code:</p>
451 <pre>
452 struct A
453 {
454 int a;
455 };
457 int plus(A* o, int v) { return o->a + v; }
458 </pre>
460 <p>You can register the plus, function as if it was a
463 <pre>
466 .commit(L)
467 ;
468 </pre>
472 the object pointer parameter is const, the function will act as if it was a
473 const member function (it can be called on const objects).</p>
477 <p>To register a global data member with a class is easily
478 done. Consider the following class:</p>
480 <pre>
481 struct A
482 {
483 int a;
484 };
485 </pre>
489 <pre>
492 .commit(L)
493 ;
494 </pre>
496 <p>Then it's both readable and writable. You can
497 also register attributes as read-only.</p>
501 .commit(L)
502 ;
503 </pre>
505 <p>You can also register getter and setter functions and
506 make them look as if they were a public data member. Consider the following
507 class:</p>
509 <pre>
510 class A
511 {
512 void set_a(int x) { a_ = x; }
513 int get_a() const { return a_; }
514 private:
515 int a_;
516 };
517 </pre>
519 <p>It can be registered as if it had a public data member
522 <pre>
525 .commit(L)
526 ;
527 </pre>
531 writing to the data member. If you want to make it read only you can just omit
532 the last parameter.</p>
536 <p>If your class contains enumerated constants (enums), you
537 can register them as well to make them available in lua. Note that they will not
538 be type safe, all enums are integers in lua, and all functions that takes an
539 enum, will accept any integer. You register them like this:</p>
541 <pre>
543 .enum_("constants")
544 [
548 ]
549 .commit(L)
550 ;
551 </pre>
553 <p>In lua they are reached like any data member, except
554 that they are read-only and reached on the class itself rather than on an
555 instance of the class.</p>
557 <pre>
558 print(A.my_enum)
559 print(A.another_enum)
560 </pre>
566 <p>The mechanism for registering operators on your class is
568 to refer to the class itself and then you just write the operator expression
571 <pre>
572 struct vec
573 {
574 vec operator+(int s);
575 };
576 </pre>
580 <pre>
582 .def(self + int())
583 .commit(L)
584 ;
585 </pre>
587 <p>This will work regardless if your plus operator is
588 defined inside your class or as a free function.</p>
594 <pre>
596 .def(const_self + int())
597 .commit(L)
598 ;
599 </pre>
603 <ul>
604 <li>+
605 <li>-
606 <li>*
607 <li>/
608 <li>^
611 <li>==
612 <li>unary -
613 <li>operator()
614 </ul>
616 <p>This means, no in-place operators. The equality operator (==) has a little
617 hatch, it will not be called if the references are equal. This means that
618 the == operator has to do pretty much what's it's expected to do.</p>
620 <p>In the above example the other operand type is
622 is a complex type that cannot easily be instantiated you can wrap the type in a
625 <p>To register this class, we don't want to instantiate a
626 string just to register the operator.</p>
628 <pre>
629 struct vec
630 {
631 vec operator+(std::string);
632 };
633 </pre>
636 wrapper like this:</p>
638 <pre>
641 .commit(L)
642 ;
643 </pre>
647 <pre>
649 .def( self(int()) )
650 .commit(L)
651 ;
652 </pre>
655 it's not really an operator. It is used for converting objects to strings
656 in a standard way in lua. If you register this functionality, you will
658 you object to a string.</p>
660 <p>To implement this operator in C++ you should supply an
663 <pre>
664 class number {};
667 </pre>
669 <pre>
671 .def(tostring(self))
672 .commit(L)
673 ;
674 </pre>
679 <p>If you want to register classes that derives from other
683 <pre>
684 struct A {};
685 struct B: A{};
686 </pre>
690 <pre>
692 .commit(L)
693 ;
695 .commit(L)
696 ;
697 </pre>
699 <p>If you have multiple inheritance you can specify more
703 <pre>
705 .commit(L)
706 ;
707 </pre>
711 <p>If you don't specify that classes derive from each
712 other, luabind will not be able to implicitly cast pointers between the types.
715 signature:</p>
717 <pre>
718 void f(A*);
719 </pre>
723 <pre>
724 b = B()
725 f(b) -- error, no function 'f' matches the arguments (B)
726 </pre>
732 <p>When you register a class you can tell luabind that all instances of that class should be held
734 the holder type as an extra template-parameter to the <tt>class_</tt> your constructing, like this:</p>
736 <pre>
738 </pre>
740 <p>You also have to supply two functions for your smart pointer. One that returns the type of const
741 version of the smart pointer type (<tt>boost::shared_ptr<const A></tt> in this case). And one
742 function that extracts the raw pointer from the smart pointer. The first function is needed because
743 luabind has to allow the non-const -> conversion when passing values from lua to C++. The second
744 function is needed when lua calls member functions on held types, the this pointer must be a raw
745 pointer, it is also needed to allow the smart_pointer -> raw_pointer conversion from
746 lua to C++. They look like this:</p>
748 <pre>
749 namespace luabind
750 {
756 {
758 }
759 }
760 </pre>
762 <p>The current implementation requires that the const-version and non-const version of the holder type
763 has the exact same memory layout and can be <tt>reinterpret_cast</tt>:ed between each other.</p>
767 <table>
768 <tr>
770 </tr>
771 <tr>
774 </tr>
775 <tr>
778 </tr>
779 <tr>
782 </tr>
783 <tr>
786 </tr>
787 <tr>
790 </tr>
791 <tr>
794 </tr>
795 <tr>
798 </tr>
799 <tr>
802 </tr>
803 <tr>
806 </tr>
807 <tr>
809 </tr>
810 <tr>
813 </tr>
814 <tr>
817 </tr>
818 <tr>
821 </tr>
822 <tr>
825 </tr>
827 </table>
829 <p>When using a holder type, it can be useful to know if the pointer is valid. For example when using
830 std::auto_ptr, the holder will be invalidated when passed as a parameter to a function.
833 <pre>
835 struct test {};
838 module(L)
839 [
841 .def(constructor<>()),
844 ];
846 a = test()
847 f(a)
848 print a.__ok -- prints false
850 </pre>
854 <p>Since functions have to be able to take lua values (of variable type) we need a wrapper
859 <pre>
860 class object
861 {
862 public:
863 class iterator;
864 class raw_iterator;
865 class array_iterator;
868 object(lua_State*, const T& value);
869 object(const object&);
870 object(lua_State*);
871 object();
873 ~object();
875 iterator begin() const;
876 iterator end() const;
877 raw_iterator raw_begin() const;
878 raw_iterator raw_end() const;
879 array_iterator abegin() const;
880 array_iterator aend() const;
882 void set();
883 lua_State* lua_state() const;
884 void pushvalue() const;
885 bool is_valid() const;
886 operator bool() const;
892 object at(const Key&) const;
895 object raw_at(const Key&) const;
902 bool operator==(const T&) const;
903 bool operator==(const object&) const;
908 bool operator!=(const object&) const;
910 void swap(object&);
911 int type() const;
921 /* ... */
923 };
924 </pre>
926 <p>When you have a lua object, you can assign it a new value with the assignment operator (=). When
927 you do this, the <tt>default_policy</tt> will be used to make the conversion from C++ value to lua.
928 If your <tt>luabind::object</tt> is a table you can access its members through the operator[] or
929 the iterators. The value returned from the operator[] is a proxy object that can be used both
930 for reading and writing values into the table (using operator=). Note that it is impossible
931 to know if a lua value is indexable or not (lua_gettable doesn't fail, it succeeds or crashes).
932 This means that if you're trying to index something that cannot be indexed, you're on your own. Lua
935 at the given table position (like operator[] but only for reading).<p>
938 the table, the standard way that will invoke metamethods if any. The <tt>object::raw_iterator</tt>
939 uses <tt>lua_rawget</tt> and <tt>object::array_iterator</tt> uses <tt>lua_rawgeti</tt>. The latter
940 will only iterate over numberical keys starting at 1 and continue until the first nil value.</p>
942 <p>The <tt>lua_state()</tt> function returns the lua state where this object is stored. If you want
943 to manipulate the object with lua functions directly you can push it onto the lua stack by calling
944 <tt>pushvalue()</tt>. And set the object's value by calling <tt>set()</tt>, which will pop the top
945 value from the lua stack and assign it to the object.</p>
948 on the operands and return its result.</p>
950 <p>The <tt>int type()</tt> member function will return the lua type of the object. It will return
953 <p>The <tt>is_valid</tt> function tells you whether the object has been initialized or not. When created
954 with its default constructor, objects are invalid. To make an object valid, you can assign it a value. If
955 you want to invalidate an object you can simply assign it an invalid object.</p>
958 isn't really an implicit cast to bool, but an implicit cast to a member pointer, since member pointers
959 don't have any arithmetic operators on them (which can cause hard to find errors). The functionality of
962 <pre>
963 object o;
964 // ...
965 if (o.is_valid())
966 {
967 // ...
968 }
969 </pre>
973 <pre>
974 object o;
975 // ...
976 if (o)
977 {
978 // ...
979 }
980 </pre>
982 <p>The application operator will call the value as if it was a function. You can give it any number
983 of parameters (currently the <tt>default_policy</tt> will be used for the conversion). The returned
984 object refers to the return value (currently only one return value is supported). This operator may
986 <a href="#policies">policies</a> to your function call, you can use index-operator (operator[]) on
987 the function call, and give the policies within the [ and ]. Like this:</p>
989 <pre>
991 </pre>
993 <p>This tells luabind to make lua adopt the ownership and responsibility for the pointer passed in
994 to the lua-function.</p>
996 <p>It's important that all instances of <tt>object</tt> have been destructed by the time the lua state
997 is closed. The object will keep a pointer to the lua state and release its lua object in its
998 destructor.</p>
1002 <pre>
1003 void my_function(const object& table)
1004 {
1005 if (table.type() == LUA_TTABLE)
1006 {
1007 table["time"] = std::clock();
1011 }
1012 }
1013 </pre>
1015 <p>If you take a <tt>luabind::object</tt> as a parameter to a function, any lua value will match that parameter.
1016 That's why we have to make sure it's a table before we index into it.</p>
1020 <p>The iterators, that are returned by the <tt>begin()</tt> and <tt>end()</tt> (and their variants) are (almost)
1022 ForwardIterator</a> concept. The exceptions are that operator-> and post increment doesn't exist on
1023 them.</p>
1027 <pre>
1028 class object::iterator
1029 {
1030 iterator();
1031 iterator(const iterator&);
1033 iterator& operator++();
1034 bool operator!=(const iterator&) const;
1037 object key() const;
1040 };
1041 </pre>
1043 <p>The implementation defined return value from the dereference operator is a proxy object that can be used as if it was
1044 an <tt>object</tt>, it can also be used to assign the specific table entry with a new value. If you want to assign a
1045 value to an entry pointed to by an iterator, just use the assignment operator on the dereferenced iterator:</p>
1047 <pre>
1048 *iter = 5;
1049 </pre>
1051 <p>The <tt>key()</tt> member returns the key used by the iterator when indexing the associated lua table.</p>
1055 <p>
1056 There are a couple of functions related to objects and tables.
1057 </p>
1060 <tt>T object_cast<<i>Type</i>>(const object&, const Policies&);</tt><br>
1061 <tt>boost::optional<T> object_cast_nothrow<<i>Type</i>>(const object&);</tt><br>
1062 <tt>boost::optional<T> object_cast_nothrow<<i>Type</i>>(const object&, const Policies&);</tt></h3>
1064 can supply a policy to handle the conversion from lua to C++. If the cast cannot be made a
1065 <tt>cast_failed</tt> exception will be thrown. If you have defined <tt>LUABIND_NO_ERROR_CHECKING</tt>
1066 (see <a href="#config">configuration</a>) no checking will occur, and if the cast is invalid the
1067 application may very well crash. The nothrow versions will return an uninitialized <tt>boost::optional<T></tt>
1068 object, to indicate that the cast could not be performed.</p>
1072 <p>These functions return the global environment table and the registry table respectively.</p>
1080 only be used to store functions. If you take it as a parameter, it will only match functions.</p>
1084 <pre>
1086 </pre>
1088 <p>It takes one template parameter, the return value of the lua function it represents.
1089 Currently the functor can have at most one return value (unlike lua functions). It has the
1090 following synopsis:</p>
1092 <pre>
1094 class functor
1095 {
1096 public:
1098 functor(lua_State*, const char* name);
1099 functor(const functor&);
1101 ~functor();
1103 bool is_valid() const;
1104 operator bool() const;
1106 lua_State* lua_state() const;
1107 void pushvalue() const;
1120 /* ... */
1121 };
1122 </pre>
1124 <p>The application operator takes any parameters. The parameters are converted into lua and the
1125 function is called. The return value will act as if it was the type <tt>Ret</tt>, with the exception that you can use the
1126 return value to give policies to the call. You do this the same way as you do with <a href="#object">objects</a>,
1127 using the operator[], and giving the policies inside the brackets.</p>
1129 <p>The <tt>is_valid()</tt> function works just like the one on <a href="#object"><tt>object</tt></a>, it tells you if
1130 the functor has been assigned with a valid lua function. The <tt>operator bool()</tt> is an alias for this member function
1135 <pre>
1136 function f(a, b)
1137 return a + b
1138 end
1139 </pre>
1143 <pre>
1147 </pre>
1150 application operator of <a href="#functor"><tt>luabind::functor</tt></a>, this is because lua doesn't have
1151 signatures for its functions. All lua functions take any number of parameters
1152 of any type.</p>
1154 <p>If we have a C++ function that takes a <a href="#functor"><tt>luabind::functor</tt></a> and registers it, it will accept lua
1155 functions passed to it. This enables us to expose APIs that requires you to
1156 register callbacks. For example, if your C++ API looks like this:</p>
1158 <pre>
1159 void set_callback(void(*)(int, int));
1160 </pre>
1162 <pre>
1163 object o;
1164 // ...
1165 if (o.is_valid())
1166 {
1167 // ...
1168 }
1169 </pre>
1172 <p>And you want to expose it to lua, you have to wrap the
1173 call to the lua function inside a real C++ function, like this:</p>
1175 <pre>
1178 void callback_wrapper(int a, int b)
1179 {
1180 lua_callback(a, b);
1181 }
1184 {
1185 lua_callback = f;
1186 set_callback(&callback_wrapper);
1187 }
1188 </pre>
1190 <p>And then register <tt>set_callback_wrapper</tt> instead of registering <tt>set_callback</tt>.
1191 This will have the effect that when one tries to register the callback from lua, your
1192 <tt>set_callback_wrapper</tt> will be called instead and first set the lua functor to the given function.
1194 <tt>callback_wrapper</tt> will be called whenever the callback should be called, and it will simply
1195 call the lua function that we registered.</p>
1197 <p>You can also use <a href="#object_functions"><tt>object_cast</tt></a> to cast an object to a <a href="#functor"><tt>functor</tt></a>.</p>
1201 <p>In addition to binding C++ functions and classes with
1202 lua, luabind also provide an oo-system in lua.</p>
1204 <pre>
1205 class 'lua_testclass'
1207 function lua_testclass:__init(name)
1208 self.name = name
1209 end
1211 function lua_testclass:print()
1212 print(self.name)
1213 end
1215 a = lua_testclass('example')
1216 a:print()
1217 </pre>
1221 <pre>
1222 class 'derived' (lua_testclass)
1224 function derived:__init() super('derived name')
1225 end
1227 function derived:print()
1228 print('Derived:print() -> ')
1229 lua_testclass.print(self)
1230 end
1231 </pre>
1234 used in the constructor to initialize the base class. The user is required to
1237 <p>As you can see in this example, you can call the
1238 base class' member functions. You can find all member functions in the base class,
1243 <p>It is also possible to derive lua classes from C++
1244 classes, and override virtual functions with lua functions. To do this we have
1245 to create a wrapper class for our C++ base class. This is the class that will
1246 hold the lua object when we instantiate a lua class.</p>
1248 <p>The wrapper class has to provide the same constructors
1250 This is the reference to the lua object that should be held by the wrapper, and should
1251 be stored in a member variable as done in the sample below.</p>
1253 <pre>
1254 class base class
1255 {
1256 public:
1259 };
1261 struct baseclass_wrapper: baseclass
1262 {
1263 luabind::object m_l;
1264 baseclass_wrapper(luabind::object l, const char* s): baseclass(s), m_l(l) {}
1267 static void f_static(baseclass* ptr, int a)
1268 {
1269 return ptr->baseclass::f(a);
1270 }
1271 };
1272 </pre>
1273 <pre>
1277 .commit(L)
1278 ;
1279 </pre>
1281 <p>Note that if you have both base classes and a base class
1284 in which you specify them is not important.</p>
1286 <p>If we didn't have a class wrapper, it would not be possible to pass a lua class
1287 back to C++. Since the entry points of the virtual functions would still point to
1288 the C++ base class, and not to the functions defined in lua. That's why we need
1289 one function that calls the base class' real function (used if the lua class
1290 doesn't redefine it) and one virtual function that dispatches the call into luabind,
1291 to allow it to select if a lua function should be called, or if the original
1292 function should be called. If you don't intend to derive from a C++ class, or if
1293 it doesn't have any virtual member functions, you can register it without a
1294 class wrapper.</p>
1296 <p>You don't need to have a class wrapper in order to derive from a class,
1297 but if it has virtual functions you may have silent errors. The rule of thumb is:
1298 If your class has virtual functions, create a wrapper type, if it doesn't don't create
1299 a wrapper type.</p>
1303 <p>You can overload most operators in lua for your classes. You do this by simply declaring
1304 a member function with the same name as an operator (the name of the metamethods in lua). The operators
1305 you can overload are:</p>
1307 <ul>
1319 </ul>
1321 <p><tt>__tostring</tt> isn't really an operator, but it's the metamethod that is called by the standard
1322 library's <tt>tostring()</tt> function. There's one strange behavior regarding binary operators. You are not
1323 guaranteed that the self pointer you get actually refers to an instance of your class. This is because
1324 lua doesn't distinguish the two cases where you get the other operand as left hand value or right hand value.
1325 Consider the following examples:</p>
1327 <pre>
1328 class 'my_class'
1330 function my_class:__init(v)
1331 self.val = v
1332 end
1334 function my_class:__sub(v)
1335 return my_class(self.val - v.val)
1336 end
1338 function my_class:__tostring()
1339 return self.val
1340 end
1341 </pre>
1343 <p>This will work well as long as you only subtracts instances of <tt>my_class</tt> with each other. But
1344 If you want to be able to subtract ordinary numbers from your class too, you have to manually check the type
1347 <pre>
1348 function my_class:__sub(v)
1349 if (type(self) == 'number') then
1350 return my_class(self - v.val)
1352 elseif (type(v) == 'number') then
1353 return my_class(self.val - v)
1355 else
1356 -- assume both operands are instances of my_class
1357 return my_class(self.val - v.val)
1359 end
1360 end
1361 </pre>
1363 <p>The reason why <tt>__sub</tt> is used as an example is because subtraction is not commutative (the
1364 order of the operands matter). That's why luabind cannot change order of the operands to make the
1365 self reference always refer to the actual class instance.</p>
1367 <p>If you have two different lua classes with an overloaded operator, the operator of the right hand
1368 side type will be called. If the other operand is a C++ class with the same operator overloaded, it
1369 will be prioritized over the lua class' operator. If none of the C++ overloads matches, the lua
1370 class' operator will be called.</p>
1374 <p>If an object needs to perform actions when it's collected we provide
1376 The __finalize functions will be called on all classes in the inheritance
1377 chain, starting with the most derived type.</p>
1379 <pre>
1380 ...
1382 function lua_testclass:__finalize()
1383 -- called when the an object is collected
1384 end
1385 </pre>
1388 <p>If any of the functions you register throws an exception when called, that exception will be caught
1389 by luabind and converted to an error string and <tt>lua_error</tt> will be invoked. If the exception
1390 is a <tt>std::exception</tt> or a <tt>const char*</tt> the string that is pushed on the lua stack,
1391 as error message, will be the <tt>what()</tt> or the string itself respectively. If the exception
1392 is unknown, a generic string saying that the function threw an exception will be pushed.</p>
1394 <p>Exceptions thrown from user defined functions have to be caught by luabind. If they weren't they
1395 would be thrown through lua itself, which is usually compiled as C code and doesn't support the
1396 stack-unwinding that exceptions imply.</p>
1398 <p>Any function that invokes lua code may throw <tt>luabind::error</tt>. This exception means that a lua
1399 run-time error occurred. The error message is found on top of the lua stack. The reason why the
1400 exception doesn't contain the error string itself is because it would then require heap allocation
1401 which may fail. If an exception class throws an exception while it is being thrown itself, the
1402 application will be terminated.</p>
1406 <pre>
1407 class error: std::exception
1408 {
1409 public:
1410 error(lua_State*);
1411 lua_State* state() const throw();
1412 virtual const char* what() const throw();
1413 };
1414 </pre>
1416 <p>The state function returns a pointer to the lua state in which the error was thrown. This pointer
1417 may be invalid if you catch this exception after the lua state is destructed. If the lua state is
1418 valid you can use it to retrieve the error message from the top of the lua stack.</p>
1422 <pre>
1423 struct lua_state
1424 {
1425 lua_state(lua_State* L): m_L(L) {}
1426 ~lua_state() { lua_close(m_L); }
1427 operator lua_State*() { return m_L; }
1428 lua_State* m_L;
1429 };
1431 int main()
1432 {
1433 try
1434 {
1435 lua_state L = lua_open();
1436 /* ... */
1437 }
1438 catch(luabind::error& e)
1439 {
1440 lua_State* L = e.state();
1441 // L will now point to the destructed
1442 // lua state and be invalid
1443 /* ... */
1444 }
1445 }
1446 </pre>
1448 <p>There's another exception that luabind may throw. <tt>luabind::cast_failed</tt>, this exception
1449 is thrown from <a href="#lua_fun"><tt>call_function</tt></a>, <a href="#lua_fun"><tt>call_member</tt></a> or when <a href="#functor"><tt>functor</tt></a> is invoked.
1450 It means that the return value from the lua function couldn't be converted to a C++ value. It is
1451 also thrown from <a href="#object_functions"><tt>object_cast</tt></a> if the cast cannot be made.</p>
1455 <pre>
1456 class cast_failed: std::exception
1457 {
1458 public:
1459 cast_failed(lua_State*);
1460 lua_State* state() const throw();
1461 LUABIND_TYPE_INFO info() const throw();
1462 virtual const char* what() const throw();
1463 };
1464 </pre>
1466 <p>Again, the <tt>state</tt> member function returns a pointer to the lua state where the error occurred.
1467 See the example above to see where this pointer may be invalid.</p>
1469 <p>The <tt>info</tt> member function returns the user defined <a href="#luabind_type_info"><tt>LUABIND_TYPE_INFO</tt></a>, which
1470 defaults to a <tt>const std::type_info*</tt>. This type info describes the type that we tried
1471 to cast a lua value to.</p>
1473 <p>If you have defined <a href="#luabind_no_exceptions"><tt>LUABIND_NO_EXCEPTIONS</tt></a> none of these exceptions will be thrown,
1474 instead you can set two callback functions that are called instead. These two functions are only defined if <a href="#luabind_no_exceptions"><tt>LUABIND_NO_EXCEPTIONS</tt></a> are defined.</p>
1476 <h3><a name="set_error_callback"></a><tt>luabind::set_error_callback(void(*)(lua_State*))</tt></h3>
1477 <p>The function you set will be called when a runtime-error occur in lua code. You can find an
1478 error message on top of the lua stack. This function is not expected to return, if it does
1481 <h3><a name="set_cast_failed_callback"></a><tt>luabind::set_cast_failed_callback(void(*)(lua_State*, LUABIND_TYPE_INFO))</tt></h3>
1483 <p>The function you set is called instead of throwing <tt>cast_failed</tt>. This function is not expected to return, if it does luabind will call <tt>std::terminate()</tt>.</p>
1488 <p>Sometimes it is necessary to control how luabind passes
1489 arguments and return value, to do this we have policies. These are the
1490 policies that can be used:</p>
1494 <p>This will make a copy of the parameter. This is the
1495 default behavior when passing parameters by-value. Note that this can only be
1496 used when passing from C++ to lua. This policy requires that the parameter
1497 type has a copy constructor.</p>
1504 <p>Consider making a factory function in C++ and exposing
1505 it to lua:</p><pre>base* create_base()
1506 {
1507 return new base();
1508 }
1509 </pre>
1511 <pre>
1512 function(L, "create_base", create_base);
1513 </pre>
1515 <p>Here we need to make sure lua understands that it should
1516 adopt the pointer returned by the factory-function. This can be done using the
1517 adopt-policy.</p>
1519 <pre>
1520 function(L, "create_base", adopt(return_value));
1521 </pre>
1525 <pre>
1526 base* set_and_get_new(base* ptr)
1527 {
1528 base_ptrs.push_back(ptr);
1529 return new base();
1530 }
1531 </pre>
1533 <pre>
1535 </pre>
1537 <p>When lua adopts a pointer, it will call <tt>delete</tt> on it. This means that it cannot adopt pointers allocated with
1544 <p>The dependency policy is used to create life-time dependencies between values. Consider the following example:</p>
1546 <pre>
1547 struct A
1548 {
1549 B m_member;
1551 const B& get_member()
1552 {
1553 return m_member;
1554 }
1555 };
1556 </pre>
1560 <pre>
1562 .def(constructor<>())
1564 .commit(L)
1565 ;
1566 </pre>
1568 <p>However, since the return value of get_member is a reference to a member of A, this will create
1569 some life-time issues. For example:</p>
1571 <pre>
1572 a = A()
1573 b = a:get_member() -- b points to a member of a
1574 a = nil
1575 collectgarbage(0) -- since there are no references left to a, it is removed
1576 -- at this point, b is pointing into a removed object
1577 </pre>
1579 <p>When using the dependency-policy, it is possible to tell luabind to tie the lifetime of one
1580 object to another, like this:</p>
1582 <pre>
1584 .def(constructor<>())
1586 .commit(L)
1587 ;
1588 </pre>
1590 <p>This will create a dependency between the return-value of the function, and the self-object. This means
1591 that the self-object will be kept alive as long as the result is still alive.</p>
1593 <pre>
1594 a = A()
1595 b = a:get_member() -- b points to a member of a
1596 a = nil
1597 collectgarbage(0) -- a is dependent on b, so it isn't removed
1598 b = nil
1599 collectgarbage(0) -- all dependencies to a gone, a is removed
1600 </pre>
1606 <p>It is very common to return references to arguments or the this-pointer to allow for chaining in C++.</p>
1607 <pre>
1608 struct A
1609 {
1610 float m_val;
1612 A& set(float v)
1613 {
1614 m_val = v;
1615 return *this;
1616 }
1617 };
1618 </pre>
1620 <p>When luabind generates code for this, it will create a new object for the return-value, pointing to the self-object. This
1621 isn't a problem, but could be a bit inefficient. When using the return_reference_to-policy we have the ability to tell
1622 luabind that the return-value is already on the lua stack.</p>
1624 <pre>
1626 .def(constructor<>())
1628 .commit(L)
1629 ;
1630 </pre>
1632 <p>Instead of creating a new object, luabind will just copy the object that is already on the stack.</p>
1633 <p>NOTE! This policy ignores all type information and should be used only it situations where the parameter type
1634 is a perfect match to the return-type (such as in the example).</p>
1636 <p>To use this policy you need to include <tt><luabind/return_reference_to_policy.hpp></tt>.</p>
1640 <p>This policy makes it possible to wrap functions that take non const references as its parameters with the intention to write return values to them.</p>
1642 <pre>
1644 </pre>
1645 or
1646 <pre>
1647 void f(float* val) { *val = *val + 10.f; }
1648 </pre>
1652 <pre>
1654 </pre>
1656 <p>When invoking this function from lua it will return the value assigned to its parameter.</p>
1658 <pre>
1660 </pre>
1662 <p>When this policy is used in conjunction with user define types we often need to do ownership transfers.</p>
1664 <pre>
1665 struct A
1666 {
1667 };
1669 void f(A*& obj) { obj = new A(); }
1670 or
1671 void f(A** obj) { *obj = new A(); }
1672 </pre>
1674 <p>Here we need to make sure luabind takes control over object returned, for this we use the <tt>adopt</tt> policy</p>
1676 <pre>
1678 .commit(L)
1679 ;
1682 </pre>
1684 <p>Here we are using <tt>adopt</tt> as an internal policy to <tt>out_value</tt>. The index specified, <tt>_2</tt>, means adopt will be used to convert the value back to lua. Using <tt>_1</tt> means the policy will be used when converting from lua to C++.</p>
1690 <p>This policy works in exactly the same way as <tt>out_value</tt>, except that it replaces the parameters with default-constructed
1691 objects.</p>
1693 <pre>
1695 {
1696 x = 3.f;
1697 y = 4.f;
1698 }
1701 </pre>
1702 <pre>
1703 x,y = get()
1704 print(x,y) -- prints '3 4'
1705 </pre>
1707 <p>Like out_value, it is possible to specify an internal policy used then converting the values back to lua.</p>
1709 <pre>
1710 void get(test_class*& obj)
1711 {
1712 obj = new test_class();
1713 }
1716 </pre>
1720 <p>This is a very simple policy which makes it possible to throw away the value returned by a C++ function, instead of converting it to lua. This example makes sure the <tt>this</tt> reference never gets converted to lua</p>
1722 <pre>
1723 struct simple
1724 {
1726 {
1727 name = n;
1728 return *this;
1729 }
1731 std::string name;
1732 };
1736 .commit(L)
1737 ;
1738 </pre>
1744 <p>This policy converts an STL container to a generator function that can be used in lua to
1745 iterate over the container. It works on any container that defines <tt>begin()</tt> and <tt>end()</tt>
1746 member functions (they have to return iterators). It can be used like this:</p>
1748 <pre>
1749 struct A
1750 {
1752 };
1756 .commit(L)
1757 ;
1758 </pre>
1762 <pre>
1763 a = A()
1765 for name in a.names do
1766 print(name)
1767 end
1768 </pre>
1786 <p>There are a number of configuration options available when building luabind. It is very important
1787 that your project has the exact same conmfiguration options as the ones given when the library was build!
1788 The exceptions are the <tt>LUABIND_MAX_ARITY</tt> and <tt>LUABIND_MAX_BASES</tt> which are template-based
1789 options and only matters when you use the library (which means they can differ from the settings of the
1790 library).</p>
1792 <p>The default settings can be found in <tt>luabind/config.hpp</tt> they will be used if no other settings
1793 are given.</p>
1795 <p>If you want to change the settings of the library, you can modify the config-file. It is included and used
1796 by all make-files. You can change paths to lua and boost in there as well.</p>
1799 <p>Controls the maximum arity of functions that are registered
1800 with luabind. You can't register functions that takes more
1801 parameters than the number this macro is set to. It defaults
1802 to 5, so, if your functions have greater arity you have to
1803 redefine it. A high limit will increase compilation time.</p>
1805 <p>Controls the maximum number of classes one class can derive from
1806 in luabind (the number of classes specified within
1808 A high limit will increase compilation time.</p>
1810 <p>If this macro is defined, all the lua code is expected only to make
1811 legal calls. If illegal function calls are made (e.g. giving parameters
1812 that doesn't match the function signature) they will not be detected
1813 by luabind and the application will probably crash. Error checking
1814 could be disabled when shipping a release build (given that no end-user
1815 has access to write custom lua code). Note that function parameter
1816 matching will be done if a function is overloaded, since otherwise it's
1817 impossible to know which one was called. Functions will still be able
1818 to throw exceptions when error checking is disabled.</p>
1820 <p>Functions will still be able to throw exceptions, they will be
1825 <p>If this macro is defined, luabind will expect that all strings given
1826 to the def() methods are static constant strings (given as string
1827 constants for example). luabind will not copy the strings if you
1828 enable this setting, but just keep the char pointers. This may be
1829 especially useful for embedded systems or consoles where heap
1830 allocations should be minimized.</p>
1834 <p>This define will disable all usage of try, catch and throw in
1835 luabind. This will in many cases disable run-time errors, when
1836 performing invalid casts or calling lua-functions that fails or
1837 returns values that cannot be converted by the given policy.
1838 luabind requires that no function called directly or indirectly
1839 by luabind throws an exception (throwing exceptions through
1840 lua has undefined behavior).</p>
1842 <p>Where exceptions are the only way to get an error report from
1843 luabind, they will be replaced with calls to the callback
1852 <p>If you don't want to use the RTTI supplied by C++
1853 you can supply your own type-info structure with the
1854 LUABIND_TYPE_INFO define. Your type-info structure must
1855 be copyable and must be able to compare itself against
1856 other type-info structures. You supply the compare
1857 function through the LUABIND_TYPE_INFO_EQUAL()
1858 define. It should compare the two type-info structures
1859 it is given and return true if they represent the same type
1860 and false otherwise. You also have to supply a function
1861 to generate your type-info structure. You do this through
1862 the LUABIND_TYPEID() define. It should return your type-info
1863 structure and it takes a type as its parameter. That is,
1864 a compile time parameter. LUABIND_INVALID_TYPE_INFO macro
1865 should be defined to an invalid type. No other type should
1866 be able to produce this type info. To use it you probably
1867 have to make a traits class with specializations for all
1868 classes that you have type-info for. Like this:</p>
1870 <pre>
1871 class A;
1872 class B;
1873 class C;
1880 </pre>
1882 <p>If you have set up your own RTTI system like this (by using integers to identify types)
1883 you can have luabind use it with the following defines</p>
1885 <pre>
1886 #define LUABIND_TYPE_INFO int
1887 #define LUABIND_TYPE_INFO_EQUAL(i1, i2) i1 == i2
1889 #define LUABIND_INVALID_TYPE_INFO -1
1890 </pre>
1892 <p>The default behavior, if you don't define any of these three, is to use the built-in
1893 RTTI support in C++.</p>
1895 <pre>
1896 #define LUABIND_TYPE_INFO const std::type_info*
1897 #define LUABIND_TYPEID(t) &typeid(t)
1898 #define LUABIND_TYPE_INFO_EQUAL(i1, i2) *i1 == *i2
1899 #define LUABIND_INVALID_TYPE_INFO &typeid(detail::null_type)
1900 </pre>
1909 <p>The classes and objects are implemented as user data in lua. To make sure that
1910 the user data really is the internal structure it is supposed to be, we tag their
1911 metatables. A user data who's metatable contains a boolean member named
1914 is expected to be an instantiation of a luabind class.</p>
1916 <p>This means that if you make your own user data and tags its metatable with the
1917 exact same names, you can very easily fool luabind and crash the application.</p>
1923 in a lua-class is called. This is to make it easy for that constructor to call its base
1925 well be overwritten. This is probably not the best solution, and this restriction may very
1926 well be removed in the future.</p>
1929 This namespace contains non-public classes and are not supposed to be used directly.</p>
1933 <ul>
1935 <p>There is no data member named <i><attribute-name></i> in the class <i><class-name></i>, or
1936 there's no setter-method registered on that property name. See the <a href="#class_property">properties</a> section.</p>
1940 <p>The class' constructor or member function threw an unknown exception. Known exceptions are <tt>const char*</tt>,
1943 <li>no overload of '<i><class-name></I>:<i><function-name></i>' matched the arguments (<<i>parameter-types>)</i>
1944 <li>no match for function call '<i><function-name></i>' with the parameters (<i><parameter-types></i>)
1945 <li>no constructor of <i><class-name></i> matched the arguments (<i><parameter-types></i>)
1946 <li>no operator <i><operator-name></i> matched the arguments (<i><parameter-types></i>)
1947 <p>No function/operator with the given name takes the parameters you gave it. You have either misspelled the function name,
1948 or given it incorrect parameters. This error is followed by a list of possible candidate functions to help you figure out what
1949 parameter has the wrong type. If the candidate list is empty there's no function at all with that name. See the
1952 <li>call of overloaded '<i><class-name></i>:<i><function-name></i>(<<i>parameter-types></i>)' is ambiguous
1953 <li>ambiguous match for function call '<i><function-name></i>' with the parameters (<i><parameter-types></i>)
1954 <li>call of overloaded constructor '<i><class-name></i>(<i><parameter-types></i>)' is ambiguous
1955 <li>call of overloaded operator <i><operator-name></i> (<i><parameter-types></i>) is ambiguous
1956 <p>This means that the function/operator you are trying to call has at least one other overload that matches the arguments
1957 just as good as the first overload.</p>
1960 <p>You are trying to derive a lua class from a C++ class that doesn't have a wrapped type. You have to give
1961 your C++ class a wrapped type when you register it with lua. See the <a href="#class_lua_derive">deriving in lua</a> section.</p>
1963 <li>derived class must call super on base
1964 <li>cannot set property '<i><class-name></i>.<i><attribute_name></i>' because it's read only
1965 <p>The attribute you are trying to set is registered as read only. If you want it to be writeable you have to change your
1966 class registration and use <tt>def_readwrite()</tt> instead of <tt>def_readonly()</tt>. Alternatively (if your attribute
1967 is a property with getter and setter functions), you have to give a setter function when declaring your attribute. See
1971 <p>You will get this error message if you are trying to access an enum that doesn't exist. Read about how to
1974 <li>expected base class
1975 <p>You have written a malformed <a href="#class_lua">class definition in lua</a>. The format is:
1976 <tt>class '<i><class-name></i>' [<i><base-class></i>]</tt>. If you don't want to derive from
1977 a base class, you have to break the line directly after the class declaration.</p>
1979 <li>invalid construct, expected class name
1980 <p>You have written a malformed <a href="#class_lua">class definition in lua</a>. The <tt>class</tt> function expects
1981 a string as argument. That string is the name of the lua class to define.</p>
1982 </ul>
1985 <ul>
1988 <p>If you're having problem with functions that cannot be converted from
1989 <tt>'void (__stdcall *)(int,int)'</tt> to <tt>'void (__cdecl *)(int,int)'</tt>.
1990 You can change the project settings to make the compiler generate functions with
1994 <p>You cannot register a function with ellipses in its signature. Since ellipses don't preserve
1995 type safety, those should be avoided anyway.</p>
1999 structure overflow</tt>. You should try to split that compilation unit up
2000 in smaller ones.</p>
2003 <p>Visual Studio doesn't like anonymous namespaces in its precompiled headers. If you encounter this
2004 problem you can disable precompiled headers for the compilation unit (cpp-file) that uses luabind.</p>
2007 <p>In visual studio you will probably hit this error. To fix it you have to increase the internal heap
2008 with a command-line option. We managed to compile the test suit with /Zm300, but you may need a larger
2009 heap then that.</p>
2012 <p>It seems that this error occurs when too many <tt>assert()</tt> are used in a program, or more
2013 specifically, the <tt>__LINE__</tt> macro. It seems to be fixed by changing /ZI (Program database
2014 for edit and continue) to /Zi (Program database).</p>
2017 <p>If you're compiling in debug mode, you will probably have a lot of debug-info and symbols (luabind
2018 consists of a lot of functions). Also, if built in debug mode, no optimizations were applied, luabind
2019 relies on that the compiler is able to inline functions. If you built in release mode, try running
2021 <p>Our tests suggests that cygwin's gcc produces much bigger executables compared to gcc on other
2022 platforms and other compilers.</p>
2025 <p>Yes you can, but you can only register explicit instantiations of the class. Because there's no
2026 lua counterpart to C++ templates. For example, you can register an explicit instantiation of
2028 <pre>
2032 .commit(L)
2033 ;
2034 </pre>
2038 <p>No, the destructor of a class is always called by luabind when an object is collected. Note that
2039 lua has to own the object to collect it. If you pass it to C++ and gives up ownership (with
2040 <a href="#policy_adopt">adopt</a> policy) it will no longer be owned by lua, and not collected.</p>
2041 <p>If you have a class hierarchy, you should make the destructor <tt>virtual</tt> if you want to
2042 be sure that the correct destructor is called (this apply to C++ in general).</p>
2045 <p>VC6.5 chokes on warnings, if you are getting alot of warnings from your code try suppressing them
2046 with a pragma directive, this should solve the problem.</p>
2048 </ul>
2051 <ul>
2052 <li>A mechanism for wrapping iterators with generators.
2053 </ul>
2056 <ul>
2057 <li>If one class registers two functions with the same name and the same signature,
2058 there's currently no error. The last registered function will be the one that's used.
2060 <li>Visual studio have problems selecting the correct overload of <tt>std::swap()</tt> for <tt>luabind::object</tt>.
2061 </ul>
2066 and <a href="mailto:c99ang@cs.umu.se">Arvid Norberg</a>. © Copyright 2003. All rights reserved.</p>
2068 <p>This library was inspired by Dave Abrahams'
2069 <a href="http://www.boost.org/libs/python/doc/index.html">Boost.Python</a> library which can be found in the
2071 <p>
2082 </p>
2084 </body></html>