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> U luaU_to(lua_State* _L, int _index);
template<typename U> void luaU_push(lua_State* _L, const U& _value); 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 * 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 * 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); 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 * 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) { template <typename T, typename U, U T::*Member> int luaU_get(lua_State* _L) {
T* obj = luaW_check<T>(_L, 1); ememory::SharedPtr<T> obj = luaW_check<T>(_L, 1);
luaU_push<U>(_L, obj->*Member); luaU_push<U>(_L, obj.get()->*Member);
return 1; return 1;
} }
template <typename T, typename U, U* T::*Member> int luaU_get(lua_State* _L) { template <typename T, typename U, U* T::*Member> int luaU_get(lua_State* _L) {
T* obj = luaW_check<T>(_L, 1); ememory::SharedPtr<T> obj = luaW_check<T>(_L, 1);
luaW_push<U>(_L, obj->*Member); luaW_push<U>(_L, obj.get()->*Member);
return 1; return 1;
} }
template <typename T, typename U, U (T::*Getter)() const> int luaU_get(lua_State* _L) { template <typename T, typename U, U (T::*Getter)() const> int luaU_get(lua_State* _L) {
T* obj = luaW_check<T>(_L, 1); ememory::SharedPtr<T> obj = luaW_check<T>(_L, 1);
luaU_push<U>(_L, (obj->*Getter)()); luaU_push<U>(_L, (obj.get()->*Getter)());
return 1; return 1;
} }
template <typename T, typename U, const U& (T::*Getter)() const> int luaU_get(lua_State* _L) { template <typename T, typename U, const U& (T::*Getter)() const> int luaU_get(lua_State* _L) {
T* obj = luaW_check<T>(_L, 1); ememory::SharedPtr<T> obj = luaW_check<T>(_L, 1);
luaU_push<U>(_L, (obj->*Getter)()); luaU_push<U>(_L, (obj.get()->*Getter)());
return 1; return 1;
} }
template <typename T, typename U, U* (T::*Getter)() const> int luaU_get(lua_State* _L) { template <typename T, typename U, U* (T::*Getter)() const> int luaU_get(lua_State* _L) {
T* obj = luaW_check<T>(_L, 1); ememory::SharedPtr<T> obj = luaW_check<T>(_L, 1);
luaW_push<U>(_L, (obj->*Getter)()); luaW_push<U>(_L, (obj.get()->*Getter)());
return 1; return 1;
} }
template <typename T, typename U, U T::*Member> int luaU_set(lua_State* _L) { template <typename T, typename U, U T::*Member> int luaU_set(lua_State* _L) {
T* obj = luaW_check<T>(_L, 1); ememory::SharedPtr<T> obj = luaW_check<T>(_L, 1);
if (obj) { if (obj != null) {
obj->*Member = luaU_check<U>(_L, 2); obj.get()->*Member = luaU_check<U>(_L, 2);
} }
return 0; return 0;
} }
template <typename T, typename U, U* T::*Member> int luaU_set(lua_State* _L) { template <typename T, typename U, U* T::*Member> int luaU_set(lua_State* _L) {
T* obj = luaW_check<T>(_L, 1); ememory::SharedPtr<T> obj = luaW_check<T>(_L, 1);
if (obj) { if (obj != null) {
U* member = luaW_opt<U>(_L, 2); ememory::SharedPtr<U> member = luaW_opt<U>(_L, 2);
obj->*Member = member; obj.get()->*Member = member.get();
} }
return 0; return 0;
} }
template <typename T, typename U, const U* T::*Member> int luaU_set(lua_State* _L) { template <typename T, typename U, const U* T::*Member> int luaU_set(lua_State* _L) {
T* obj = luaW_check<T>(_L, 1); ememory::SharedPtr<T> obj = luaW_check<T>(_L, 1);
if (obj) { if (obj != null) {
U* member = luaW_opt<U>(_L, 2); ememory::SharedPtr<U> member = luaW_opt<U>(_L, 2);
obj->*Member = member; obj.get()->*Member = member.get();
} }
return 0; return 0;
} }
template <typename T, typename U, const U* T::*Member> int luaU_setandrelease(lua_State* _L) { template <typename T, typename U, const U* T::*Member> int luaU_setandrelease(lua_State* _L) {
T* obj = luaW_check<T>(_L, 1); ememory::SharedPtr<T> obj = luaW_check<T>(_L, 1);
if (obj) { if (obj != null) {
U* member = luaW_opt<U>(_L, 2); ememory::SharedPtr<U> member = luaW_opt<U>(_L, 2);
obj->*Member = member; obj.get()->*Member = member.get();
if (member) { if (member) {
luaW_release<U>(_L, 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) { template <typename T, typename U, void (T::*Setter)(U)> int luaU_set(lua_State* _L) {
T* obj = luaW_check<T>(_L, 1); ememory::SharedPtr<T> obj = luaW_check<T>(_L, 1);
if (obj) { if (obj != null) {
(obj->*Setter)(luaU_check<U>(_L, 2)); (obj.get()->*Setter)(luaU_check<U>(_L, 2));
} }
return 0; return 0;
} }
template <typename T, typename U, void (T::*Setter)(const U&)> int luaU_set(lua_State* _L) { template <typename T, typename U, void (T::*Setter)(const U&)> int luaU_set(lua_State* _L) {
T* obj = luaW_check<T>(_L, 1); ememory::SharedPtr<T> obj = luaW_check<T>(_L, 1);
if (obj) { if (obj != null) {
(obj->*Setter)(luaU_check<U>(_L, 2)); (obj.get()->*Setter)(luaU_check<U>(_L, 2));
} }
return 0; return 0;
} }
template <typename T, typename U, void (T::*Setter)(U*)> int luaU_set(lua_State* _L) { template <typename T, typename U, void (T::*Setter)(U*)> int luaU_set(lua_State* _L) {
T* obj = luaW_check<T>(_L, 1); ememory::SharedPtr<T> obj = luaW_check<T>(_L, 1);
if (obj) { if (obj != null) {
U* member = luaW_opt<U>(_L, 2); ememory::SharedPtr<U> member = luaW_opt<U>(_L, 2);
(obj->*Setter)(member); (obj.get()->*Setter)(member.get());
} }
return 0; return 0;
} }
template <typename T, typename U, void (T::*Setter)(U*)> int luaU_setandrelease(lua_State* _L) { template <typename T, typename U, void (T::*Setter)(U*)> int luaU_setandrelease(lua_State* _L) {
T* obj = luaW_check<T>(_L, 1); ememory::SharedPtr<T> obj = luaW_check<T>(_L, 1);
if (obj) { if (obj != null) {
U* member = luaW_opt<U>(_L, 2); ememory::SharedPtr<U> member = luaW_opt<U>(_L, 2);
(obj->*Setter)(member); (obj.get()->*Setter)(member);
if (member) { if (member) {
luaW_release<U>(_L, 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) { template <typename T, typename U, U T::*Member> int luaU_getset(lua_State* _L) {
T* obj = luaW_check<T>(_L, 1); ememory::SharedPtr<T> obj = luaW_check<T>(_L, 1);
if (obj && lua_gettop(_L) >= 2) { if ( obj != null
obj->*Member = luaU_check<U>(_L, 2); && lua_gettop(_L) >= 2) {
obj.get()->*Member = luaU_check<U>(_L, 2);
return 0; return 0;
} else { } else {
luaU_push<U>(_L, obj->*Member); luaU_push<U>(_L, obj.get()->*Member);
return 1; return 1;
} }
} }
template <typename T, typename U, U* T::*Member> int luaU_getset(lua_State* _L) { template <typename T, typename U, U* T::*Member> int luaU_getset(lua_State* _L) {
T* obj = luaW_check<T>(_L, 1); ememory::SharedPtr<T> obj = luaW_check<T>(_L, 1);
if (obj && lua_gettop(_L) >= 2) { if ( obj != null
U* member = luaW_opt<U>(_L, 2); && lua_gettop(_L) >= 2) {
obj->*Member = member; ememory::SharedPtr<U> member = luaW_opt<U>(_L, 2);
obj.get()->*Member = member.get();
return 0; return 0;
} else { } else {
luaW_push<U>(_L, obj->*Member); luaW_push<U>(_L, obj.get()->*Member);
return 1; return 1;
} }
} }
template <typename T, typename U, U* T::*Member> int luaU_getsetandrelease(lua_State* _L) { template <typename T, typename U, U* T::*Member> int luaU_getsetandrelease(lua_State* _L) {
T* obj = luaW_check<T>(_L, 1); ememory::SharedPtr<T> obj = luaW_check<T>(_L, 1);
if (obj && lua_gettop(_L) >= 2) { if ( obj != null
U* member = luaW_opt<U>(_L, 2); && lua_gettop(_L) >= 2) {
obj->*Member = member; ememory::SharedPtr<U> member = luaW_opt<U>(_L, 2);
obj.get()->*Member = member.get();
if (member) if (member)
luaW_release<U>(_L, member); luaW_release<U>(_L, member);
return 0; return 0;
} else { } else {
luaW_push<U>(_L, obj->*Member); luaW_push<U>(_L, obj.get()->*Member);
return 1; return 1;
} }
} }
template <typename T, typename U, U (T::*Getter)() const, void (T::*Setter)(U)> int luaU_getset(lua_State* _L) { 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); ememory::SharedPtr<T> obj = luaW_check<T>(_L, 1);
if (obj && lua_gettop(_L) >= 2) { if ( obj != null
(obj->*Setter)(luaU_check<U>(_L, 2)); && lua_gettop(_L) >= 2) {
(obj.get()->*Setter)(luaU_check<U>(_L, 2));
return 0; return 0;
} else { } else {
luaU_push<U>(_L, (obj->*Getter)()); luaU_push<U>(_L, (obj.get()->*Getter)());
return 1; return 1;
} }
} }
template <typename T, typename U, U (T::*Getter)() const, void (T::*Setter)(const U&)> int luaU_getset(lua_State* _L) { 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); ememory::SharedPtr<T> obj = luaW_check<T>(_L, 1);
if (obj && lua_gettop(_L) >= 2) { if ( obj != null
(obj->*Setter)(luaU_check<U>(_L, 2)); && lua_gettop(_L) >= 2) {
(obj.get()->*Setter)(luaU_check<U>(_L, 2));
return 0; return 0;
} else { } else {
luaU_push<U>(_L, (obj->*Getter)()); luaU_push<U>(_L, (obj.get()->*Getter)());
return 1; return 1;
} }
} }
template <typename T, typename U, const U& (T::*Getter)() const, void (T::*Setter)(const U&)> int luaU_getset(lua_State* _L) { 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); ememory::SharedPtr<T> obj = luaW_check<T>(_L, 1);
if (obj && lua_gettop(_L) >= 2) { if ( obj != null
(obj->*Setter)(luaU_check<U>(_L, 2)); && lua_gettop(_L) >= 2) {
(obj.get()->*Setter)(luaU_check<U>(_L, 2));
return 0; return 0;
} else { } else {
luaU_push<U>(_L, (obj->*Getter)()); luaU_push<U>(_L, (obj.get()->*Getter)());
return 1; return 1;
} }
} }
template <typename T, typename U, U* (T::*Getter)() const, void (T::*Setter)(U*)> int luaU_getset(lua_State* _L) { 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); ememory::SharedPtr<T> obj = luaW_check<T>(_L, 1);
if (obj && lua_gettop(_L) >= 2) { if ( obj != null
U* member = luaW_opt<U>(_L, 2); && lua_gettop(_L) >= 2) {
(obj->*Setter)(member); ememory::SharedPtr<U> member = luaW_opt<U>(_L, 2);
(obj.get()->*Setter)(member.get());
return 0; return 0;
} else { } else {
luaW_push<U>(_L, (obj->*Getter)()); luaW_push<U>(_L, (obj.get()->*Getter)());
return 1; return 1;
} }
} }
template <typename T, typename U, U* (T::*Getter)() const, void (T::*Setter)(U*)> int luaU_getsetandrelease(lua_State* _L) { 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); ememory::SharedPtr<T> obj = luaW_check<T>(_L, 1);
if (obj && lua_gettop(_L) >= 2) { if ( obj != null
U* member = luaW_opt<U>(_L, 2); && lua_gettop(_L) >= 2) {
(obj->*Setter)(member); ememory::SharedPtr<U> member = luaW_opt<U>(_L, 2);
(obj.get()->*Setter)(member);
if (member) if (member)
luaW_release<U>(_L, member); luaW_release<U>(_L, member);
return 0; return 0;
} else { } else {
luaW_push<U>(_L, (obj->*Getter)()); luaW_push<U>(_L, (obj.get()->*Getter)());
return 1; 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 "Example.hpp"
#include <etk/String.hpp> #include <etk/String.hpp>
#include <etk/typeInfo.hpp>
#include <iostream> #include <iostream>
ETK_DECLARE_TYPE(Example);
// These are just a bunch of generic getters and setters for // These are just a bunch of generic getters and setters for
// values in the Example class // values in the Example class

31
sample/sample_2/Example.hpp
View File

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

51
sample/sample_2/LuaCustomTypes.hpp
View File

@ -8,51 +8,26 @@
#include "Vector2D.hpp" #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 * These two functions let me convert a simple Vector2D structure into a Lua
* table holding the x and y values * table holding the x and y values
*/ */
template<> struct luaU_Impl<Vector2D> { template<>
static Vector2D luaU_check(lua_State* _L, int _index) { Vector2D luaU_check<Vector2D>(lua_State* _L, int _index) {
return Vector2D( return Vector2D(luaU_getfield<float>(_L, _index, "x"),
luaU_getfield<float>(_L, _index, "x"),
luaU_getfield<float>(_L, _index, "y")); luaU_getfield<float>(_L, _index, "y"));
} }
static Vector2D luaU_to(lua_State* _L, int _index ) {
return Vector2D( template<>
luaU_getfield<float>(_L, _index, "x"), Vector2D luaU_to<Vector2D>(lua_State* _L, int _index ) {
return Vector2D(luaU_getfield<float>(_L, _index, "x"),
luaU_getfield<float>(_L, _index, "y")); luaU_getfield<float>(_L, _index, "y"));
} }
static void luaU_push(lua_State* _L, const Vector2D& _val) {
template<>
void luaU_push<Vector2D>(lua_State* _L, const Vector2D& _val) {
lua_newtable(_L); lua_newtable(_L);
luaU_setfield<float>(_L, -1, "x", _val.x); luaU_setfield<float>(_L, -1, "x", _val.x);
luaU_setfield<float>(_L, -1, "y", _val.y); 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 <etk/String.hpp>
#include <lua/lua.h> #include <lua/lua.h>
@ -8,24 +7,25 @@
#include "LuaCustomTypes.hpp" #include "LuaCustomTypes.hpp"
#include "Example.hpp" #include "Example.hpp"
#include <test-debug/debug.hpp>
static int Example_PrintMe(lua_State* L) { static int Example_PrintMe(lua_State* L) {
Example* ex = luaW_check<Example>(L, 1); ememory::SharedPtr<Example> ex = luaW_check<Example>(L, 1);
std::cout << "Example=" TEST_PRINT( "Example=");
<< "{m_boolean=" << ex->m_boolean TEST_PRINT( " m_boolean=" << ex->m_boolean);
<< ",m_integer=" << ex->m_integer TEST_PRINT( " m_integer=" << ex->m_integer);
<< ",m_uinteger=" << ex->m_uinteger TEST_PRINT( " m_uinteger=" << ex->m_uinteger);
<< ",m_string='" << ex->m_cstring << "'" TEST_PRINT( " m_string='" << ex->m_cstring << "'");
<< ",m_cppstring='" << ex->m_cppstring << "'" TEST_PRINT( " m_cppstring='" << ex->m_cppstring << "'");
<< ",m_number=" << ex->m_number TEST_PRINT( " m_number=" << ex->m_number);
<< ",m_floatnumber=" << ex->m_floatnumber TEST_PRINT( " m_floatnumber=" << ex->m_floatnumber);
<< ",m_vec={x=" << ex->m_vec.x << ",y=" << ex->m_vec.y <<"}}" << std::endl; TEST_PRINT( " m_vec={x=" << ex->m_vec.x << ",y=" << ex->m_vec.y <<"}");
return 0; return 0;
} }
static luaL_Reg Example_metatable[] = { static luaL_Reg Example_metatable[] = {
// This function is // This function is
{ "PrintMe", Example_PrintMe }, { "printMe", Example_PrintMe },
// In many cases, all you need are simple getter or setter functions This // 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 // 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. // them directly with these templates.
// //
// Class | data type | class member // Class | data type | class member
{ "GetBoolean", luaU_get<Example, bool, &Example::m_boolean> }, { "getBoolean", luaU_get<Example, bool, &Example::m_boolean> },
{ "SetBoolean", luaU_set<Example, bool, &Example::m_boolean> }, { "setBoolean", luaU_set<Example, bool, &Example::m_boolean> },
{ "Boolean", luaU_getset<Example, bool, &Example::m_boolean> }, { "m_boolean", luaU_getset<Example, bool, &Example::m_boolean> },
{ "GetInteger", luaU_get<Example, int, &Example::m_integer> }, { "getInteger", luaU_get<Example, int, &Example::m_integer> },
{ "SetInteger", luaU_set<Example, int, &Example::m_integer> }, { "setInteger", luaU_set<Example, int, &Example::m_integer> },
{ "Integer", luaU_getset<Example, int, &Example::m_integer> }, { "m_integer", luaU_getset<Example, int, &Example::m_integer> },
{ "GetUInteger", luaU_get<Example, unsigned int, &Example::m_uinteger> }, { "getUInteger", luaU_get<Example, unsigned int, &Example::m_uinteger> },
{ "SetUInteger", luaU_set<Example, unsigned int, &Example::m_uinteger> }, { "setUInteger", luaU_set<Example, unsigned int, &Example::m_uinteger> },
{ "UInteger", luaU_getset<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> }, { "getCString", luaU_get<Example, const char*, &Example::m_cstring> },
{ "SetCString", luaU_set<Example, const char*, &Example::m_cstring> }, { "setCString", luaU_set<Example, const char*, &Example::m_cstring> },
{ "CString", luaU_getset<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> }, { "getCPPString", luaU_get<Example, etk::String, &Example::m_cppstring> },
{ "SetCPPString", luaU_set<Example, etk::String, &Example::m_cppstring> }, { "setCPPString", luaU_set<Example, etk::String, &Example::m_cppstring> },
{ "CPPString", luaU_getset<Example, etk::String, &Example::m_cppstring> }, { "m_cppstring", luaU_getset<Example, etk::String, &Example::m_cppstring> },
{ "GetVec", luaU_get<Example, Vector2D, &Example::m_vec> }, { "getVec", luaU_get<Example, Vector2D, &Example::m_vec> },
{ "SetVec", luaU_set<Example, Vector2D, &Example::m_vec> }, { "setVec", luaU_set<Example, Vector2D, &Example::m_vec> },
{ "Vec", luaU_getset<Example, Vector2D, &Example::m_vec> }, { "m_vec", luaU_getset<Example, Vector2D, &Example::m_vec> },
{ "GetNumber", luaU_get<Example, double, &Example::m_number> }, { "getNumber", luaU_get<Example, double, &Example::m_number> },
{ "SetNumber", luaU_set<Example, double, &Example::m_number> }, { "setNumber", luaU_set<Example, double, &Example::m_number> },
{ "Number", luaU_getset<Example, double, &Example::m_number> }, { "m_number", luaU_getset<Example, double, &Example::m_number> },
{ "GetFloatNumber", luaU_get<Example, float, &Example::m_floatnumber> }, { "getFloatNumber", luaU_get<Example, float, &Example::m_floatnumber> },
{ "SetFloatNumber", luaU_set<Example, float, &Example::m_floatnumber> }, { "setFloatNumber", luaU_set<Example, float, &Example::m_floatnumber> },
{ "FloatNumber", luaU_getset<Example, float, &Example::m_floatnumber> }, { "m_floatnumber", luaU_getset<Example, float, &Example::m_floatnumber> },
{ "GetPtr", luaU_get<Example, Example, &Example::m_ptr> }, { "getPtr", luaU_get<Example, Example, &Example::m_ptr> },
{ "SetPtr", luaU_set<Example, Example, &Example::m_ptr> }, { "setPtr", luaU_set<Example, Example, &Example::m_ptr> },
{ "Ptr", luaU_getset<Example, Example, &Example::m_ptr> }, { "Ptr", luaU_getset<Example, Example, &Example::m_ptr> },
// The getters and setters above work on member variables directly, but // 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 | getter
// Class | data type | setter // Class | data type | setter
// Class | data type | getter | setter // Class | data type | getter | setter
{ "GetBooleanFunc", luaU_get<Example, bool, &Example::GetBoolean> }, { "getBooleanFunc", luaU_get<Example, bool, &Example::GetBoolean> },
{ "SetBooleanFunc", luaU_set<Example, bool, &Example::SetBoolean> }, { "setBooleanFunc", luaU_set<Example, bool, &Example::SetBoolean> },
{ "BooleanFunc", luaU_getset<Example, bool, &Example::GetBoolean, &Example::SetBoolean> }, { "BooleanFunc", luaU_getset<Example, bool, &Example::GetBoolean, &Example::SetBoolean> },
{ "GetIntegerFunc", luaU_get<Example, int, &Example::GetInteger> }, { "getIntegerFunc", luaU_get<Example, int, &Example::GetInteger> },
{ "SetIntegerFunc", luaU_set<Example, int, &Example::SetInteger> }, { "setIntegerFunc", luaU_set<Example, int, &Example::SetInteger> },
{ "IntegerFunc", luaU_getset<Example, int, &Example::GetInteger, &Example::SetInteger> }, { "IntegerFunc", luaU_getset<Example, int, &Example::GetInteger, &Example::SetInteger> },
{ "GetUIntegerFunc", luaU_get<Example, unsigned int, &Example::GetUInteger> }, { "getUIntegerFunc", luaU_get<Example, unsigned int, &Example::GetUInteger> },
{ "SetUIntegerFunc", luaU_set<Example, unsigned int, &Example::SetUInteger> }, { "setUIntegerFunc", luaU_set<Example, unsigned int, &Example::SetUInteger> },
{ "UIntegerFunc", luaU_getset<Example, unsigned int, &Example::GetUInteger, &Example::SetUInteger> }, { "UIntegerFunc", luaU_getset<Example, unsigned int, &Example::GetUInteger, &Example::SetUInteger> },
{ "GetCStringFunc", luaU_get<Example, const char*, &Example::GetCString> }, { "getCStringFunc", luaU_get<Example, const char*, &Example::GetCString> },
{ "SetCStringFunc", luaU_set<Example, const char*, &Example::SetCString> }, { "setCStringFunc", luaU_set<Example, const char*, &Example::SetCString> },
{ "CStringFunc", luaU_getset<Example, const char*, &Example::GetCString, &Example::SetCString> }, { "CStringFunc", luaU_getset<Example, const char*, &Example::GetCString, &Example::SetCString> },
{ "GetNumberFunc", luaU_get<Example, double, &Example::GetNumber> }, { "getNumberFunc", luaU_get<Example, double, &Example::GetNumber> },
{ "SetNumberFunc", luaU_set<Example, double, &Example::SetNumber> }, { "setNumberFunc", luaU_set<Example, double, &Example::SetNumber> },
{ "NumberFunc", luaU_getset<Example, double, &Example::GetNumber, &Example::SetNumber> }, { "NumberFunc", luaU_getset<Example, double, &Example::GetNumber, &Example::SetNumber> },
{ "GetFloatNumberFunc", luaU_get<Example, float, &Example::GetFloatNumber> }, { "getFloatNumberFunc", luaU_get<Example, float, &Example::GetFloatNumber> },
{ "SetFloatNumberFunc", luaU_set<Example, float, &Example::SetFloatNumber> }, { "setFloatNumberFunc", luaU_set<Example, float, &Example::SetFloatNumber> },
{ "FloatNumberFunc", luaU_getset<Example, float, &Example::GetFloatNumber, &Example::SetFloatNumber> }, { "FloatNumberFunc", luaU_getset<Example, float, &Example::GetFloatNumber, &Example::SetFloatNumber> },
{ "GetPtrFunc", luaU_get<Example, Example, &Example::GetPtr> }, { "getPtrFunc", luaU_get<Example, Example, &Example::GetPtr> },
{ "SetPtrFunc", luaU_set<Example, Example, &Example::SetPtr> }, { "setPtrFunc", luaU_set<Example, Example, &Example::SetPtr> },
{ "PtrFunc", luaU_getset<Example, Example, &Example::GetPtr, &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 // In order to use luaU_get and luaU_set on non-primitive types, you must define luaU_to
// and luaU_check for that type. // and luaU_check for that type.
// See LuaCustomTypes.hpp for an example involving etk::String and Vector2D // See LuaCustomTypes.hpp for an example involving etk::String and Vector2D
{ "GetCPPStringFunc", luaU_get<Example, etk::String, &Example::GetCPPString> }, { "getCPPStringFunc", luaU_get<Example, etk::String, &Example::GetCPPString> },
{ "SetCPPStringFunc", luaU_set<Example, etk::String, &Example::SetCPPString> }, { "setCPPStringFunc", luaU_set<Example, etk::String, &Example::SetCPPString> },
{ "CPPStringFunc", luaU_getset<Example, etk::String, &Example::GetCPPString, &Example::SetCPPString> }, { "CPPStringFunc", luaU_getset<Example, etk::String, &Example::GetCPPString, &Example::SetCPPString> },
{ "GetVecFunc", luaU_get<Example, Vector2D, &Example::GetVec> }, { "getVecFunc", luaU_get<Example, Vector2D, &Example::GetVec> },
{ "SetSetFunc", luaU_set<Example, Vector2D, &Example::SetVec> }, { "setSetFunc", luaU_set<Example, Vector2D, &Example::SetVec> },
{ "VecFunc", luaU_getset<Example, Vector2D, &Example::GetVec, &Example::SetVec> }, { "VecFunc", luaU_getset<Example, Vector2D, &Example::GetVec, &Example::SetVec> },
{ "DoSomething", luaU_func(&Example::DoSomething) }, { "DoSomething", luaU_func(&Example::DoSomething) },
@ -132,8 +132,7 @@ static luaL_Reg Example_metatable[] = {
{ NULL, NULL } { NULL, NULL }
}; };
int luaopen_Example(lua_State* _L) int luaopen_Example(lua_State* _L) {
{
luaW_register<Example>(_L, "Example", NULL, Example_metatable); luaW_register<Example>(_L, "Example", NULL, Example_metatable);
return 1; 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() local ex = Example.new()
ex:SetBoolean(true) ex:setBoolean(true)
-- luaU_getset creates a function that acts as both a getter and a setter! -- 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 -- For example, I can use a single function, Integer, to set the value to 100
-- then print out that value -- then print out that value
ex:Integer(100) ex:m_integer(-100)
print("Integer = ", ex:Integer()); 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 -- 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 -- 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 -- a Vector2D type with luaW_register - this table will automatically be converted
vec = { x = 20; y = 30 } 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`:" print "Printing values from the vector stored on `ex`:"
for k, v in pairs(vec2) do for k, v in pairs(vec2) do
print(k, v) print(k, v)
end 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[]) { int main(int _argc, const char *_argv[]) {
TEST_PRINT("START SAMPLE 1"); TEST_PRINT("START SAMPLE 2");
etk::init(_argc, _argv); etk::init(_argc, _argv);
etk::String inputFileName; etk::String inputFileName;
for (int32_t iii=0; iii<_argc ; ++iii) { 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)); TEST_PRINT(lua_tostring(L, -1));
} }
lua_close(L); lua_close(L);
TEST_PRINT("END SAMPLE 2");
return 0; return 0;
} }