HeeroYui-deprecated/luaWrapper
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

[DEV] example 2 basicly work

Browse Source
This commit is contained in:
Edouard DUPIN 2018-08-12 23:03:27 +02:00
parent d1180282ac
commit 831faeef69
10 changed files with 260 additions and 244 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

194
luaWrapper/luaWrapperUtil.hpp
View File

@ -44,18 +44,6 @@ template<typename U> U luaU_check(lua_State* _L, int _index);
template<typename U> U luaU_to(lua_State* _L, int _index);
template<typename U> void luaU_push(lua_State* _L, const U& _value);
/*
template<typename U> U luaU_check(lua_State* _L, int _index) {
return implem_luaU_check<U>(_L, _index);
}
template<typename U> U luaU_to(lua_State* _L, int _index) {
return implem_luaU_to<U>(_L, _index);
}
template<typename U> void luaU_push(lua_State* _L, const U& _value) {
implem_luaU_push<U>(_L, _value);
}
*/
/**
* This is slightly different than the previous three functions in that you
* shouldn't need to write your own version of it, since it uses luaU_check
@ -68,30 +56,6 @@ template<typename U> U luaU_opt(lua_State* _L, int _index, const U& _fallback =
return luaU_check<U>(_L, _index);
}
}
/*
template<typename T> T implem_luaU_check<T, typename LUAW_STD::enable_if<LUAW_STD::is_enum<T>::value>::type>(lua_State* _L, int _index) {
return static_cast<T>(luaL_checkinteger(_L, _index));
}
template<typename T> T implem_luaU_to<T, typename LUAW_STD::enable_if<LUAW_STD::is_enum<T>::value>::type>(lua_State* _L, int _index) {
return static_cast<T>(lua_tointeger(_L, _index));
}
template<typename T> void implem_luaU_push<T, typename LUAW_STD::enable_if<LUAW_STD::is_enum<T>::value>::type>(lua_State* _L, const T& _value) {
lua_pushnumber(_L, static_cast<int>(_value));
}
template<typename T> T* implem_luaU_check<T*, typename LUAW_STD::enable_if<LUAW_STD::is_class<T>::value>::type>(lua_State* _L, int _index) {
return luaW_check<T>(_L, _index);
}
template<typename T> T* implem_luaU_to<T*, typename LUAW_STD::enable_if<LUAW_STD::is_class<T>::value>::type>(lua_State* _L, int _index) {
return luaW_to<T>(_L, _index);
}
template<typename T> void implem_luaU_push<T*, typename LUAW_STD::enable_if<LUAW_STD::is_class<T>::value>::type>(lua_State* _L, T*& _value) {
luaW_push <T>(_L, _value);
}
template<typename T> void implem_luaU_push<T*, typename LUAW_STD::enable_if<LUAW_STD::is_class<T>::value>::type>(lua_State* _L, T* _value) {
luaW_push <T>(_L, _value);
}
*/
/**
* These are just some functions I've always felt should exist
@ -176,66 +140,66 @@ template <typename U> inline void luaU_setfield(lua_State* _L, int _index, const
*/
template <typename T, typename U, U T::*Member> int luaU_get(lua_State* _L) {
T* obj = luaW_check<T>(_L, 1);
luaU_push<U>(_L, obj->*Member);
ememory::SharedPtr<T> obj = luaW_check<T>(_L, 1);
luaU_push<U>(_L, obj.get()->*Member);
return 1;
}
template <typename T, typename U, U* T::*Member> int luaU_get(lua_State* _L) {
T* obj = luaW_check<T>(_L, 1);
luaW_push<U>(_L, obj->*Member);
ememory::SharedPtr<T> obj = luaW_check<T>(_L, 1);
luaW_push<U>(_L, obj.get()->*Member);
return 1;
}
template <typename T, typename U, U (T::*Getter)() const> int luaU_get(lua_State* _L) {
T* obj = luaW_check<T>(_L, 1);
luaU_push<U>(_L, (obj->*Getter)());
ememory::SharedPtr<T> obj = luaW_check<T>(_L, 1);
luaU_push<U>(_L, (obj.get()->*Getter)());
return 1;
}
template <typename T, typename U, const U& (T::*Getter)() const> int luaU_get(lua_State* _L) {
T* obj = luaW_check<T>(_L, 1);
luaU_push<U>(_L, (obj->*Getter)());
ememory::SharedPtr<T> obj = luaW_check<T>(_L, 1);
luaU_push<U>(_L, (obj.get()->*Getter)());
return 1;
}
template <typename T, typename U, U* (T::*Getter)() const> int luaU_get(lua_State* _L) {
T* obj = luaW_check<T>(_L, 1);
luaW_push<U>(_L, (obj->*Getter)());
ememory::SharedPtr<T> obj = luaW_check<T>(_L, 1);
luaW_push<U>(_L, (obj.get()->*Getter)());
return 1;
}
template <typename T, typename U, U T::*Member> int luaU_set(lua_State* _L) {
T* obj = luaW_check<T>(_L, 1);
if (obj) {
obj->*Member = luaU_check<U>(_L, 2);
ememory::SharedPtr<T> obj = luaW_check<T>(_L, 1);
if (obj != null) {
obj.get()->*Member = luaU_check<U>(_L, 2);
}
return 0;
}
template <typename T, typename U, U* T::*Member> int luaU_set(lua_State* _L) {
T* obj = luaW_check<T>(_L, 1);
if (obj) {
U* member = luaW_opt<U>(_L, 2);
obj->*Member = member;
ememory::SharedPtr<T> obj = luaW_check<T>(_L, 1);
if (obj != null) {
ememory::SharedPtr<U> member = luaW_opt<U>(_L, 2);
obj.get()->*Member = member.get();
}
return 0;
}
template <typename T, typename U, const U* T::*Member> int luaU_set(lua_State* _L) {
T* obj = luaW_check<T>(_L, 1);
if (obj) {
U* member = luaW_opt<U>(_L, 2);
obj->*Member = member;
ememory::SharedPtr<T> obj = luaW_check<T>(_L, 1);
if (obj != null) {
ememory::SharedPtr<U> member = luaW_opt<U>(_L, 2);
obj.get()->*Member = member.get();
}
return 0;
}
template <typename T, typename U, const U* T::*Member> int luaU_setandrelease(lua_State* _L) {
T* obj = luaW_check<T>(_L, 1);
if (obj) {
U* member = luaW_opt<U>(_L, 2);
obj->*Member = member;
ememory::SharedPtr<T> obj = luaW_check<T>(_L, 1);
if (obj != null) {
ememory::SharedPtr<U> member = luaW_opt<U>(_L, 2);
obj.get()->*Member = member.get();
if (member) {
luaW_release<U>(_L, member);
}
@ -244,35 +208,35 @@ template <typename T, typename U, const U* T::*Member> int luaU_setandrelease(lu
}
template <typename T, typename U, void (T::*Setter)(U)> int luaU_set(lua_State* _L) {
T* obj = luaW_check<T>(_L, 1);
if (obj) {
(obj->*Setter)(luaU_check<U>(_L, 2));
ememory::SharedPtr<T> obj = luaW_check<T>(_L, 1);
if (obj != null) {
(obj.get()->*Setter)(luaU_check<U>(_L, 2));
}
return 0;
}
template <typename T, typename U, void (T::*Setter)(const U&)> int luaU_set(lua_State* _L) {
T* obj = luaW_check<T>(_L, 1);
if (obj) {
(obj->*Setter)(luaU_check<U>(_L, 2));
ememory::SharedPtr<T> obj = luaW_check<T>(_L, 1);
if (obj != null) {
(obj.get()->*Setter)(luaU_check<U>(_L, 2));
}
return 0;
}
template <typename T, typename U, void (T::*Setter)(U*)> int luaU_set(lua_State* _L) {
T* obj = luaW_check<T>(_L, 1);
if (obj) {
U* member = luaW_opt<U>(_L, 2);
(obj->*Setter)(member);
ememory::SharedPtr<T> obj = luaW_check<T>(_L, 1);
if (obj != null) {
ememory::SharedPtr<U> member = luaW_opt<U>(_L, 2);
(obj.get()->*Setter)(member.get());
}
return 0;
}
template <typename T, typename U, void (T::*Setter)(U*)> int luaU_setandrelease(lua_State* _L) {
T* obj = luaW_check<T>(_L, 1);
if (obj) {
U* member = luaW_opt<U>(_L, 2);
(obj->*Setter)(member);
ememory::SharedPtr<T> obj = luaW_check<T>(_L, 1);
if (obj != null) {
ememory::SharedPtr<U> member = luaW_opt<U>(_L, 2);
(obj.get()->*Setter)(member);
if (member) {
luaW_release<U>(_L, member);
}
@ -281,97 +245,105 @@ template <typename T, typename U, void (T::*Setter)(U*)> int luaU_setandrelease(
}
template <typename T, typename U, U T::*Member> int luaU_getset(lua_State* _L) {
T* obj = luaW_check<T>(_L, 1);
if (obj && lua_gettop(_L) >= 2) {
obj->*Member = luaU_check<U>(_L, 2);
ememory::SharedPtr<T> obj = luaW_check<T>(_L, 1);
if ( obj != null
&& lua_gettop(_L) >= 2) {
obj.get()->*Member = luaU_check<U>(_L, 2);
return 0;
} else {
luaU_push<U>(_L, obj->*Member);
luaU_push<U>(_L, obj.get()->*Member);
return 1;
}
}
template <typename T, typename U, U* T::*Member> int luaU_getset(lua_State* _L) {
T* obj = luaW_check<T>(_L, 1);
if (obj && lua_gettop(_L) >= 2) {
U* member = luaW_opt<U>(_L, 2);
obj->*Member = member;
ememory::SharedPtr<T> obj = luaW_check<T>(_L, 1);
if ( obj != null
&& lua_gettop(_L) >= 2) {
ememory::SharedPtr<U> member = luaW_opt<U>(_L, 2);
obj.get()->*Member = member.get();
return 0;
} else {
luaW_push<U>(_L, obj->*Member);
luaW_push<U>(_L, obj.get()->*Member);
return 1;
}
}
template <typename T, typename U, U* T::*Member> int luaU_getsetandrelease(lua_State* _L) {
T* obj = luaW_check<T>(_L, 1);
if (obj && lua_gettop(_L) >= 2) {
U* member = luaW_opt<U>(_L, 2);
obj->*Member = member;
ememory::SharedPtr<T> obj = luaW_check<T>(_L, 1);
if ( obj != null
&& lua_gettop(_L) >= 2) {
ememory::SharedPtr<U> member = luaW_opt<U>(_L, 2);
obj.get()->*Member = member.get();
if (member)
luaW_release<U>(_L, member);
return 0;
} else {
luaW_push<U>(_L, obj->*Member);
luaW_push<U>(_L, obj.get()->*Member);
return 1;
}
}
template <typename T, typename U, U (T::*Getter)() const, void (T::*Setter)(U)> int luaU_getset(lua_State* _L) {
T* obj = luaW_check<T>(_L, 1);
if (obj && lua_gettop(_L) >= 2) {
(obj->*Setter)(luaU_check<U>(_L, 2));
ememory::SharedPtr<T> obj = luaW_check<T>(_L, 1);
if ( obj != null
&& lua_gettop(_L) >= 2) {
(obj.get()->*Setter)(luaU_check<U>(_L, 2));
return 0;
} else {
luaU_push<U>(_L, (obj->*Getter)());
luaU_push<U>(_L, (obj.get()->*Getter)());
return 1;
}
}
template <typename T, typename U, U (T::*Getter)() const, void (T::*Setter)(const U&)> int luaU_getset(lua_State* _L) {
T* obj = luaW_check<T>(_L, 1);
if (obj && lua_gettop(_L) >= 2) {
(obj->*Setter)(luaU_check<U>(_L, 2));
ememory::SharedPtr<T> obj = luaW_check<T>(_L, 1);
if ( obj != null
&& lua_gettop(_L) >= 2) {
(obj.get()->*Setter)(luaU_check<U>(_L, 2));
return 0;
} else {
luaU_push<U>(_L, (obj->*Getter)());
luaU_push<U>(_L, (obj.get()->*Getter)());
return 1;
}
}
template <typename T, typename U, const U& (T::*Getter)() const, void (T::*Setter)(const U&)> int luaU_getset(lua_State* _L) {
T* obj = luaW_check<T>(_L, 1);
if (obj && lua_gettop(_L) >= 2) {
(obj->*Setter)(luaU_check<U>(_L, 2));
ememory::SharedPtr<T> obj = luaW_check<T>(_L, 1);
if ( obj != null
&& lua_gettop(_L) >= 2) {
(obj.get()->*Setter)(luaU_check<U>(_L, 2));
return 0;
} else {
luaU_push<U>(_L, (obj->*Getter)());
luaU_push<U>(_L, (obj.get()->*Getter)());
return 1;
}
}
template <typename T, typename U, U* (T::*Getter)() const, void (T::*Setter)(U*)> int luaU_getset(lua_State* _L) {
T* obj = luaW_check<T>(_L, 1);
if (obj && lua_gettop(_L) >= 2) {
U* member = luaW_opt<U>(_L, 2);
(obj->*Setter)(member);
ememory::SharedPtr<T> obj = luaW_check<T>(_L, 1);
if ( obj != null
&& lua_gettop(_L) >= 2) {
ememory::SharedPtr<U> member = luaW_opt<U>(_L, 2);
(obj.get()->*Setter)(member.get());
return 0;
} else {
luaW_push<U>(_L, (obj->*Getter)());
luaW_push<U>(_L, (obj.get()->*Getter)());
return 1;
}
}
template <typename T, typename U, U* (T::*Getter)() const, void (T::*Setter)(U*)> int luaU_getsetandrelease(lua_State* _L) {
T* obj = luaW_check<T>(_L, 1);
if (obj && lua_gettop(_L) >= 2) {
U* member = luaW_opt<U>(_L, 2);
(obj->*Setter)(member);
ememory::SharedPtr<T> obj = luaW_check<T>(_L, 1);
if ( obj != null
&& lua_gettop(_L) >= 2) {
ememory::SharedPtr<U> member = luaW_opt<U>(_L, 2);
(obj.get()->*Setter)(member);
if (member)
luaW_release<U>(_L, member);
return 0;
} else {
luaW_push<U>(_L, (obj->*Getter)());
luaW_push<U>(_L, (obj.get()->*Getter)());
return 1;
}
}

38
lutin_luaWrapper-sample1.py Normal file
View File

@ -0,0 +1,38 @@
#!/usr/bin/python
import lutin.debug as debug
import lutin.tools as tools
def get_type():
return "BINARY"
def get_sub_type():
return "SAMPLE"
def get_desc():
return "lua sample 1"
def get_licence():
return "MPL-2"
def get_compagny_type():
return "com"
def get_compagny_name():
return "atria-soft"
def get_maintainer():
return ["Mr DUPIN Edouard <yui.heero@gmail.com>"]
def configure(target, my_module):
my_module.add_src_file([
'sample/sample_1/BankAccount.cpp',
'sample/sample_1/LuaBankAccount.cpp',
'sample/sample_1/main.cpp'
])
my_module.add_depend([
'luaWrapper',
'test-debug'
])
my_module.copy_path('sample/sample_1/example1.lua')
return True

38
lutin_luaWrapper-sample2.py Normal file
View File

@ -0,0 +1,38 @@
#!/usr/bin/python
import lutin.debug as debug
import lutin.tools as tools
def get_type():
return "BINARY"
def get_sub_type():
return "SAMPLE"
def get_desc():
return "lua sample 2"
def get_licence():
return "MPL-2"
def get_compagny_type():
return "com"
def get_compagny_name():
return "atria-soft"
def get_maintainer():
return ["Mr DUPIN Edouard <yui.heero@gmail.com>"]
def configure(target, my_module):
my_module.add_src_file([
'sample/sample_2/Example.cpp',
'sample/sample_2/LuaExample.cpp',
'sample/sample_2/main.cpp'
])
my_module.add_depend([
'luaWrapper',
'test-debug'
])
my_module.copy_path('sample/sample_2/example2.lua')
return True

3
sample/sample_2/Example.cpp
View File

@ -1,7 +1,10 @@
#include "Example.hpp"
#include <etk/String.hpp>
#include <etk/typeInfo.hpp>
#include <iostream>
ETK_DECLARE_TYPE(Example);
// These are just a bunch of generic getters and setters for
// values in the Example class

31
sample/sample_2/Example.hpp
View File

@ -6,28 +6,17 @@
class Example {
public:
Example() :
m_boolean(),
m_integer(),
m_uinteger(),
m_cstring(""),
m_cppstring(""),
m_number(),
m_floatnumber(),
m_ptr(),
m_vec() {
}
Example() { }
bool m_boolean;
int m_integer;
unsigned int m_uinteger;
const char* m_cstring;
etk::String m_cppstring;
double m_number;
float m_floatnumber;
Example* m_ptr;
Vector2D m_vec;
bool m_boolean = false;
int m_integer = -76543;
unsigned int m_uinteger = 765432;
const char* m_cstring = "default C string";
etk::String m_cppstring = "default C++ string";
double m_number = 0.12345;
float m_floatnumber = 0.23456f;
Example* m_ptr = null;
Vector2D m_vec = Vector2D(4,6);
bool GetBoolean() const;
int GetInteger() const;

61
sample/sample_2/LuaCustomTypes.hpp
View File

@ -8,51 +8,26 @@
#include "Vector2D.hpp"
/**
* LuaWrapper knows about primitive types like ints and floats, but it doesn't
* know about things like etk::Strings or other more complicated types.
* Sometimes, rather than register the type with LuaWrapper, it's easier to
* be able to convert it to and from Lua's primitive types, like strings or
* tables.
*
* To do this, you must write luaU_check, luaU_to and luaU_push functions for
* your type. You don't always need all three, it depends on if you're pushing
* objects to Lua, getting objects from Lua, or both.
*
* This example uses etk::String, but if you have other custom string types it
* should be easy to write versions of those functions too
*/
template<> struct luaU_Impl<etk::String> {
static etk::String luaU_check(lua_State* _L, int _index) {
return etk::String(luaL_checkstring(_L, _index));
}
static etk::String luaU_to(lua_State* _L, int _index) {
return etk::String(lua_tostring(_L, _index));
}
static void luaU_push(lua_State* _L, const etk::String& _val) {
lua_pushstring(_L, _val.c_str());
}
};
/**
* These two functions let me convert a simple Vector2D structure into a Lua
* table holding the x and y values
*/
template<> struct luaU_Impl<Vector2D> {
static Vector2D luaU_check(lua_State* _L, int _index) {
return Vector2D(
luaU_getfield<float>(_L, _index, "x"),
luaU_getfield<float>(_L, _index, "y"));
}
static Vector2D luaU_to(lua_State* _L, int _index ) {
return Vector2D(
luaU_getfield<float>(_L, _index, "x"),
luaU_getfield<float>(_L, _index, "y"));
}
static void luaU_push(lua_State* _L, const Vector2D& _val) {
lua_newtable(_L);
luaU_setfield<float>(_L, -1, "x", _val.x);
luaU_setfield<float>(_L, -1, "y", _val.y);
}
};
template<>
Vector2D luaU_check<Vector2D>(lua_State* _L, int _index) {
return Vector2D(luaU_getfield<float>(_L, _index, "x"),
luaU_getfield<float>(_L, _index, "y"));
}
template<>
Vector2D luaU_to<Vector2D>(lua_State* _L, int _index ) {
return Vector2D(luaU_getfield<float>(_L, _index, "x"),
luaU_getfield<float>(_L, _index, "y"));
}
template<>
void luaU_push<Vector2D>(lua_State* _L, const Vector2D& _val) {
lua_newtable(_L);
luaU_setfield<float>(_L, -1, "x", _val.x);
luaU_setfield<float>(_L, -1, "y", _val.y);
}

115
sample/sample_2/LuaExample.cpp
View File

@ -1,4 +1,3 @@
#include <iostream>
#include <etk/String.hpp>
#include <lua/lua.h>
@ -8,24 +7,25 @@
#include "LuaCustomTypes.hpp"
#include "Example.hpp"
#include <test-debug/debug.hpp>
static int Example_PrintMe(lua_State* L) {
Example* ex = luaW_check<Example>(L, 1);
std::cout << "Example="
<< "{m_boolean=" << ex->m_boolean
<< ",m_integer=" << ex->m_integer
<< ",m_uinteger=" << ex->m_uinteger
<< ",m_string='" << ex->m_cstring << "'"
<< ",m_cppstring='" << ex->m_cppstring << "'"
<< ",m_number=" << ex->m_number
<< ",m_floatnumber=" << ex->m_floatnumber
<< ",m_vec={x=" << ex->m_vec.x << ",y=" << ex->m_vec.y <<"}}" << std::endl;
ememory::SharedPtr<Example> ex = luaW_check<Example>(L, 1);
TEST_PRINT( "Example=");
TEST_PRINT( " m_boolean=" << ex->m_boolean);
TEST_PRINT( " m_integer=" << ex->m_integer);
TEST_PRINT( " m_uinteger=" << ex->m_uinteger);
TEST_PRINT( " m_string='" << ex->m_cstring << "'");
TEST_PRINT( " m_cppstring='" << ex->m_cppstring << "'");
TEST_PRINT( " m_number=" << ex->m_number);
TEST_PRINT( " m_floatnumber=" << ex->m_floatnumber);
TEST_PRINT( " m_vec={x=" << ex->m_vec.x << ",y=" << ex->m_vec.y <<"}");
return 0;
}
static luaL_Reg Example_metatable[] = {
// This function is
{ "PrintMe", Example_PrintMe },
{ "printMe", Example_PrintMe },
// In many cases, all you need are simple getter or setter functions This
// was such a common pattern for me that I wrote a huge set of templates
@ -36,40 +36,40 @@ static luaL_Reg Example_metatable[] = {
// them directly with these templates.
//
// Class | data type | class member
{ "GetBoolean", luaU_get<Example, bool, &Example::m_boolean> },
{ "SetBoolean", luaU_set<Example, bool, &Example::m_boolean> },
{ "Boolean", luaU_getset<Example, bool, &Example::m_boolean> },
{ "getBoolean", luaU_get<Example, bool, &Example::m_boolean> },
{ "setBoolean", luaU_set<Example, bool, &Example::m_boolean> },
{ "m_boolean", luaU_getset<Example, bool, &Example::m_boolean> },
{ "GetInteger", luaU_get<Example, int, &Example::m_integer> },
{ "SetInteger", luaU_set<Example, int, &Example::m_integer> },
{ "Integer", luaU_getset<Example, int, &Example::m_integer> },
{ "getInteger", luaU_get<Example, int, &Example::m_integer> },
{ "setInteger", luaU_set<Example, int, &Example::m_integer> },
{ "m_integer", luaU_getset<Example, int, &Example::m_integer> },
{ "GetUInteger", luaU_get<Example, unsigned int, &Example::m_uinteger> },
{ "SetUInteger", luaU_set<Example, unsigned int, &Example::m_uinteger> },
{ "UInteger", luaU_getset<Example, unsigned int, &Example::m_uinteger> },
{ "getUInteger", luaU_get<Example, unsigned int, &Example::m_uinteger> },
{ "setUInteger", luaU_set<Example, unsigned int, &Example::m_uinteger> },
{ "m_uinteger", luaU_getset<Example, unsigned int, &Example::m_uinteger> },
{ "GetCString", luaU_get<Example, const char*, &Example::m_cstring> },
{ "SetCString", luaU_set<Example, const char*, &Example::m_cstring> },
{ "CString", luaU_getset<Example, const char*, &Example::m_cstring> },
{ "getCString", luaU_get<Example, const char*, &Example::m_cstring> },
{ "setCString", luaU_set<Example, const char*, &Example::m_cstring> },
{ "m_string", luaU_getset<Example, const char*, &Example::m_cstring> },
{ "GetCPPString", luaU_get<Example, etk::String, &Example::m_cppstring> },
{ "SetCPPString", luaU_set<Example, etk::String, &Example::m_cppstring> },
{ "CPPString", luaU_getset<Example, etk::String, &Example::m_cppstring> },
{ "getCPPString", luaU_get<Example, etk::String, &Example::m_cppstring> },
{ "setCPPString", luaU_set<Example, etk::String, &Example::m_cppstring> },
{ "m_cppstring", luaU_getset<Example, etk::String, &Example::m_cppstring> },
{ "GetVec", luaU_get<Example, Vector2D, &Example::m_vec> },
{ "SetVec", luaU_set<Example, Vector2D, &Example::m_vec> },
{ "Vec", luaU_getset<Example, Vector2D, &Example::m_vec> },
{ "getVec", luaU_get<Example, Vector2D, &Example::m_vec> },
{ "setVec", luaU_set<Example, Vector2D, &Example::m_vec> },
{ "m_vec", luaU_getset<Example, Vector2D, &Example::m_vec> },
{ "GetNumber", luaU_get<Example, double, &Example::m_number> },
{ "SetNumber", luaU_set<Example, double, &Example::m_number> },
{ "Number", luaU_getset<Example, double, &Example::m_number> },
{ "getNumber", luaU_get<Example, double, &Example::m_number> },
{ "setNumber", luaU_set<Example, double, &Example::m_number> },
{ "m_number", luaU_getset<Example, double, &Example::m_number> },
{ "GetFloatNumber", luaU_get<Example, float, &Example::m_floatnumber> },
{ "SetFloatNumber", luaU_set<Example, float, &Example::m_floatnumber> },
{ "FloatNumber", luaU_getset<Example, float, &Example::m_floatnumber> },
{ "getFloatNumber", luaU_get<Example, float, &Example::m_floatnumber> },
{ "setFloatNumber", luaU_set<Example, float, &Example::m_floatnumber> },
{ "m_floatnumber", luaU_getset<Example, float, &Example::m_floatnumber> },
{ "GetPtr", luaU_get<Example, Example, &Example::m_ptr> },
{ "SetPtr", luaU_set<Example, Example, &Example::m_ptr> },
{ "getPtr", luaU_get<Example, Example, &Example::m_ptr> },
{ "setPtr", luaU_set<Example, Example, &Example::m_ptr> },
{ "Ptr", luaU_getset<Example, Example, &Example::m_ptr> },
// The getters and setters above work on member variables directly, but
@ -85,43 +85,43 @@ static luaL_Reg Example_metatable[] = {
// Class | data type | getter
// Class | data type | setter
// Class | data type | getter | setter
{ "GetBooleanFunc", luaU_get<Example, bool, &Example::GetBoolean> },
{ "SetBooleanFunc", luaU_set<Example, bool, &Example::SetBoolean> },
{ "getBooleanFunc", luaU_get<Example, bool, &Example::GetBoolean> },
{ "setBooleanFunc", luaU_set<Example, bool, &Example::SetBoolean> },
{ "BooleanFunc", luaU_getset<Example, bool, &Example::GetBoolean, &Example::SetBoolean> },
{ "GetIntegerFunc", luaU_get<Example, int, &Example::GetInteger> },
{ "SetIntegerFunc", luaU_set<Example, int, &Example::SetInteger> },
{ "getIntegerFunc", luaU_get<Example, int, &Example::GetInteger> },
{ "setIntegerFunc", luaU_set<Example, int, &Example::SetInteger> },
{ "IntegerFunc", luaU_getset<Example, int, &Example::GetInteger, &Example::SetInteger> },
{ "GetUIntegerFunc", luaU_get<Example, unsigned int, &Example::GetUInteger> },
{ "SetUIntegerFunc", luaU_set<Example, unsigned int, &Example::SetUInteger> },
{ "getUIntegerFunc", luaU_get<Example, unsigned int, &Example::GetUInteger> },
{ "setUIntegerFunc", luaU_set<Example, unsigned int, &Example::SetUInteger> },
{ "UIntegerFunc", luaU_getset<Example, unsigned int, &Example::GetUInteger, &Example::SetUInteger> },
{ "GetCStringFunc", luaU_get<Example, const char*, &Example::GetCString> },
{ "SetCStringFunc", luaU_set<Example, const char*, &Example::SetCString> },
{ "getCStringFunc", luaU_get<Example, const char*, &Example::GetCString> },
{ "setCStringFunc", luaU_set<Example, const char*, &Example::SetCString> },
{ "CStringFunc", luaU_getset<Example, const char*, &Example::GetCString, &Example::SetCString> },
{ "GetNumberFunc", luaU_get<Example, double, &Example::GetNumber> },
{ "SetNumberFunc", luaU_set<Example, double, &Example::SetNumber> },
{ "getNumberFunc", luaU_get<Example, double, &Example::GetNumber> },
{ "setNumberFunc", luaU_set<Example, double, &Example::SetNumber> },
{ "NumberFunc", luaU_getset<Example, double, &Example::GetNumber, &Example::SetNumber> },
{ "GetFloatNumberFunc", luaU_get<Example, float, &Example::GetFloatNumber> },
{ "SetFloatNumberFunc", luaU_set<Example, float, &Example::SetFloatNumber> },
{ "getFloatNumberFunc", luaU_get<Example, float, &Example::GetFloatNumber> },
{ "setFloatNumberFunc", luaU_set<Example, float, &Example::SetFloatNumber> },
{ "FloatNumberFunc", luaU_getset<Example, float, &Example::GetFloatNumber, &Example::SetFloatNumber> },
{ "GetPtrFunc", luaU_get<Example, Example, &Example::GetPtr> },
{ "SetPtrFunc", luaU_set<Example, Example, &Example::SetPtr> },
{ "getPtrFunc", luaU_get<Example, Example, &Example::GetPtr> },
{ "setPtrFunc", luaU_set<Example, Example, &Example::SetPtr> },
{ "PtrFunc", luaU_getset<Example, Example, &Example::GetPtr, &Example::SetPtr> },
// In order to use luaU_get and luaU_set on non-primitive types, you must define luaU_to
// and luaU_check for that type.
// See LuaCustomTypes.hpp for an example involving etk::String and Vector2D
{ "GetCPPStringFunc", luaU_get<Example, etk::String, &Example::GetCPPString> },
{ "SetCPPStringFunc", luaU_set<Example, etk::String, &Example::SetCPPString> },
{ "getCPPStringFunc", luaU_get<Example, etk::String, &Example::GetCPPString> },
{ "setCPPStringFunc", luaU_set<Example, etk::String, &Example::SetCPPString> },
{ "CPPStringFunc", luaU_getset<Example, etk::String, &Example::GetCPPString, &Example::SetCPPString> },
{ "GetVecFunc", luaU_get<Example, Vector2D, &Example::GetVec> },
{ "SetSetFunc", luaU_set<Example, Vector2D, &Example::SetVec> },
{ "getVecFunc", luaU_get<Example, Vector2D, &Example::GetVec> },
{ "setSetFunc", luaU_set<Example, Vector2D, &Example::SetVec> },
{ "VecFunc", luaU_getset<Example, Vector2D, &Example::GetVec, &Example::SetVec> },
{ "DoSomething", luaU_func(&Example::DoSomething) },
@ -132,8 +132,7 @@ static luaL_Reg Example_metatable[] = {
{ NULL, NULL }
};
int luaopen_Example(lua_State* _L)
{
int luaopen_Example(lua_State* _L) {
luaW_register<Example>(_L, "Example", NULL, Example_metatable);
return 1;
}

3
sample/sample_2/Makefile
View File

@ -1,3 +0,0 @@
all:
g++ -std=c++0x -L../lua-5.1/src -I../lua-5.1/src -I../luawrapper Example.cpp LuaExample.cpp main.cpp -llua -ldl -o example2

18
sample/sample_2/example2.lua
View File

@ -1,27 +1,31 @@
local ex = Example.new()
ex:SetBoolean(true)
ex:setBoolean(true)
-- luaU_getset creates a function that acts as both a getter and a setter!
-- For example, I can use a single function, Integer, to set the value to 100
-- then print out that value
ex:Integer(100)
print("Integer = ", ex:Integer());
ex:m_integer(-100)
print("Integer: ", ex:m_integer());
ex:m_uinteger(1000)
print("m_uinteger: ", ex:m_uinteger());
ex:setUInteger(10000)
print("m_uinteger: ", ex:m_uinteger());
ex:SetCPPString("This will be automatically conveted into a std::string")
ex:setCPPString("This will be automatically conveted into a std::string")
-- Because I've defined helper functions for Vector2D, I can pass this table
-- to a function expecting a Vector2d as an argument. I don't need to register
-- a Vector2D type with luaW_register - this table will automatically be converted
vec = { x = 20; y = 30 }
ex:SetVec(vec)
ex:setVec(vec)
vec2 = ex:GetVec()
vec2 = ex:getVec()
print "Printing values from the vector stored on `ex`:"
for k, v in pairs(vec2) do
print(k, v)
end
ex:PrintMe()
ex:printMe()

3
sample/sample_2/main.cpp
View File

@ -16,7 +16,7 @@ static void usage() {
}
int main(int _argc, const char *_argv[]) {
TEST_PRINT("START SAMPLE 1");
TEST_PRINT("START SAMPLE 2");
etk::init(_argc, _argv);
etk::String inputFileName;
for (int32_t iii=0; iii<_argc ; ++iii) {
@ -39,5 +39,6 @@ int main(int _argc, const char *_argv[]) {
TEST_PRINT(lua_tostring(L, -1));
}
lua_close(L);
TEST_PRINT("END SAMPLE 2");
return 0;
}