tibia-client/src/framework/luaengine/luavaluecasts.h

401 lines
12 KiB
C
Raw Normal View History

2011-08-28 15:17:58 +02:00
/*
2012-01-02 17:58:37 +01:00
* Copyright (c) 2010-2012 OTClient <https://github.com/edubart/otclient>
2011-08-28 15:17:58 +02:00
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
2011-08-14 04:09:11 +02:00
#ifndef LUAVALUECASTS_H
#define LUAVALUECASTS_H
// this file is and must be included only from luainterface.h
#include "declarations.h"
#include <framework/otml/declarations.h>
2011-08-14 04:09:11 +02:00
template<typename T>
int push_internal_luavalue(T v);
// bool
int push_luavalue(bool b);
bool luavalue_cast(int index, bool& b);
2011-08-14 04:09:11 +02:00
// int
int push_luavalue(int i);
bool luavalue_cast(int index, int& i);
2011-08-14 04:09:11 +02:00
// double
int push_luavalue(double d);
bool luavalue_cast(int index, double& d);
2011-08-14 04:09:11 +02:00
// float
inline int push_luavalue(float f) { push_luavalue((double)f); return 1; }
inline bool luavalue_cast(int index, float& f) { double d; bool r = luavalue_cast(index, d); f = d; return r; }
2012-01-06 21:42:28 +01:00
// int8
inline int push_luavalue(int8 v) { push_luavalue((int)v); return 1; }
2012-01-06 21:42:28 +01:00
inline bool luavalue_cast(int index, int8& v) { int i; bool r = luavalue_cast(index, i); v = i; return r; }
// uint8
inline int push_luavalue(uint8 v) { push_luavalue((int)v); return 1; }
2012-01-06 21:42:28 +01:00
inline bool luavalue_cast(int index, uint8& v){ int i; bool r = luavalue_cast(index, i); v = i; return r; }
// int16
inline int push_luavalue(int16 v) { push_luavalue((int)v); return 1; }
2012-01-06 21:42:28 +01:00
inline bool luavalue_cast(int index, int16& v){ int i; bool r = luavalue_cast(index, i); v = i; return r; }
// uint16
inline int push_luavalue(uint16 v) { push_luavalue((int)v); return 1; }
2012-01-06 21:42:28 +01:00
inline bool luavalue_cast(int index, uint16& v){ int i; bool r = luavalue_cast(index, i); v = i; return r; }
// uint32
inline int push_luavalue(uint32 v) { push_luavalue((double)v); return 1; }
2012-01-06 21:42:28 +01:00
inline bool luavalue_cast(int index, uint32& v) { double d; bool r = luavalue_cast(index, d); v = d; return r; }
// int64
inline int push_luavalue(int64 v) { push_luavalue((double)v); return 1; }
2012-01-06 21:42:28 +01:00
inline bool luavalue_cast(int index, int64& v) { double d; bool r = luavalue_cast(index, d); v = d; return r; }
// uint64
inline int push_luavalue(uint64 v) { push_luavalue((double)v); return 1; }
2012-01-06 21:42:28 +01:00
inline bool luavalue_cast(int index, uint64& v) { double d; bool r = luavalue_cast(index, d); v = d; return r; }
2011-08-20 22:30:41 +02:00
// string
int push_luavalue(const char* cstr);
int push_luavalue(const std::string& str);
bool luavalue_cast(int index, std::string& str);
2011-08-14 04:09:11 +02:00
// lua cpp function
int push_luavalue(const LuaCppFunction& func);
// color
int push_luavalue(const Color& color);
bool luavalue_cast(int index, Color& color);
2011-08-14 04:09:11 +02:00
// rect
int push_luavalue(const Rect& rect);
bool luavalue_cast(int index, Rect& rect);
// point
int push_luavalue(const Point& point);
bool luavalue_cast(int index, Point& point);
// size
int push_luavalue(const Size& size);
bool luavalue_cast(int index, Size& size);
// otml nodes
int push_luavalue(const OTMLNodePtr& node);
bool luavalue_cast(int index, OTMLNodePtr& node);
// enum
template<class T>
typename std::enable_if<std::is_enum<T>::value, bool>::type
luavalue_cast(int index, T& myenum);
// LuaObject pointers
2011-08-14 04:09:11 +02:00
template<class T>
typename std::enable_if<std::is_base_of<LuaObject, typename T::element_type>::value, int>::type
push_luavalue(const T& obj);
2011-08-14 04:09:11 +02:00
bool luavalue_cast(int index, LuaObjectPtr& obj);
template<class T>
typename std::enable_if<std::is_base_of<LuaObject, T>::value, bool>::type
luavalue_cast(int index, std::shared_ptr<T>& ptr);
// std::function
2011-08-14 04:09:11 +02:00
template<typename Ret, typename... Args>
int push_luavalue(const std::function<Ret(Args...)>& func);
2011-08-14 04:09:11 +02:00
template<typename... Args>
bool luavalue_cast(int index, std::function<void(Args...)>& func);
2011-08-14 04:09:11 +02:00
template<typename Ret, typename... Args>
typename std::enable_if<!std::is_void<Ret>::value, bool>::type
luavalue_cast(int index, std::function<Ret(Args...)>& func);
2011-08-14 04:09:11 +02:00
2011-08-26 20:00:22 +02:00
// vector
template<typename T>
int push_luavalue(const std::vector<T>& vec);
2011-08-26 20:00:22 +02:00
template<typename T>
bool luavalue_cast(int index, std::vector<T>& vec);
2011-09-02 06:21:18 +02:00
// deque
template<class T>
int push_luavalue(const std::deque<T>& vec);
2011-09-02 06:21:18 +02:00
2012-02-06 20:19:47 +01:00
template<typename T>
bool luavalue_cast(int index, std::deque<T>& vec);
// map
template<class K, class V>
int push_luavalue(const std::map<K, V>& map);
template<class K, class V>
bool luavalue_cast(int index, std::map<K, V>& map);
2011-08-26 20:00:22 +02:00
// tuple
template<typename... Args>
int push_luavalue(const std::tuple<Args...>& tuple);
template<typename... Args>
int push_internal_luavalue(const std::tuple<Args...>& tuple);
2011-08-14 04:09:11 +02:00
// start definitions
2011-08-14 04:09:11 +02:00
#include "luaexception.h"
#include "luainterface.h"
2011-08-14 04:09:11 +02:00
template<typename T>
int push_internal_luavalue(T v) {
return push_luavalue(v);
}
2011-08-14 04:09:11 +02:00
template<class T>
typename std::enable_if<std::is_enum<T>::value, bool>::type
luavalue_cast(int index, T& myenum) {
return luavalue_cast(index, (int&)myenum);
2011-08-14 04:09:11 +02:00
}
template<class T>
typename std::enable_if<std::is_base_of<LuaObject, typename T::element_type>::value, int>::type
push_luavalue(const T& obj) {
if(obj)
g_lua.pushObject(obj);
else
g_lua.pushNil();
return 1;
2011-08-14 04:09:11 +02:00
}
template<class T>
typename std::enable_if<std::is_base_of<LuaObject, T>::value, bool>::type
luavalue_cast(int index, std::shared_ptr<T>& ptr) {
2011-08-14 04:09:11 +02:00
LuaObjectPtr obj;
if(!luavalue_cast(index, obj))
return false;
ptr = std::dynamic_pointer_cast<T>(obj);
return true;
}
template<typename Ret, typename... Args>
int push_luavalue(const std::function<Ret(Args...)>& func) {
if(func) {
LuaCppFunction f = luabinder::bind_fun(func);
g_lua.pushCppFunction(f);
} else
g_lua.pushNil();
return 1;
2011-08-14 04:09:11 +02:00
}
template<typename... Args>
bool luavalue_cast(int index, std::function<void(Args...)>& func) {
2011-08-14 04:09:11 +02:00
if(g_lua.isFunction(index)) {
g_lua.pushValue(index);
// weak references are used here, this means that the script must hold another reference
// to this function, otherwise it will expire
int funcWeakRef = g_lua.weakRef();
2011-10-29 01:56:45 +02:00
func = [=](Args... args) {
2011-08-14 04:09:11 +02:00
// note that we must catch exceptions, because this lambda can be called from anywhere
// and most of them won't catch exceptions (e.g. dispatcher)
g_lua.getWeakRef(funcWeakRef);
try {
if(g_lua.isFunction()) {
int numArgs = g_lua.polymorphicPush(args...);
int rets = g_lua.safeCall(numArgs);
g_lua.pop(rets);
2011-08-14 04:09:11 +02:00
} else {
throw LuaException("attempt to call an expired lua function from C++,"
"did you forget to hold a reference for that function?", 0);
}
} catch(LuaException& e) {
2012-06-01 22:39:23 +02:00
g_logger.error(stdext::format("lua function callback failed: %s", e.what()));
2011-08-14 04:09:11 +02:00
}
};
return true;
} else if(g_lua.isNil(index)) {
func = std::function<void(Args...)>();
2011-08-14 04:09:11 +02:00
return true;
}
return false;
}
template<typename Ret, typename... Args>
typename std::enable_if<!std::is_void<Ret>::value, bool>::type
luavalue_cast(int index, std::function<Ret(Args...)>& func) {
2011-08-14 04:09:11 +02:00
if(g_lua.isFunction(index)) {
g_lua.pushValue(index);
// weak references are used here, this means that the script must hold another reference
// to this function, otherwise it will expire
int funcWeakRef = g_lua.weakRef();
2011-10-29 01:56:45 +02:00
func = [=](Args... args) -> Ret {
2011-08-14 04:09:11 +02:00
// note that we must catch exceptions, because this lambda can be called from anywhere
// and most of them won't catch exceptions (e.g. dispatcher)
try {
g_lua.getWeakRef(funcWeakRef);
if(g_lua.isFunction()) {
int numArgs = g_lua.polymorphicPush(args...);
if(g_lua.safeCall(numArgs) != 1)
2011-08-14 04:09:11 +02:00
throw LuaException("a function from lua didn't retrieve the expected number of results", 0);
return g_lua.polymorphicPop<Ret>();
} else {
throw LuaException("attempt to call an expired lua function from C++,"
"did you forget to hold a reference for that function?", 0);
}
} catch(LuaException& e) {
2012-06-01 22:39:23 +02:00
g_logger.error(stdext::format("lua function callback failed: %s", e.what()));
2011-08-14 04:09:11 +02:00
}
return Ret();
};
return true;
} else if(g_lua.isNil(index)) {
func = std::function<Ret(Args...)>();
2011-08-14 04:09:11 +02:00
return true;
}
return false;
}
2011-08-26 20:00:22 +02:00
template<typename T>
int push_luavalue(const std::vector<T>& vec) {
2011-08-26 20:00:22 +02:00
g_lua.newTable();
int i = 1;
for(const T& v : vec) {
push_internal_luavalue(v);
2011-08-26 20:00:22 +02:00
g_lua.rawSeti(i);
i++;
}
return 1;
2011-08-26 20:00:22 +02:00
}
template<typename T>
bool luavalue_cast(int index, std::vector<T>& vec)
{
if(g_lua.isTable(index)) {
g_lua.pushNil();
while(g_lua.next(index < 0 ? index-1 : index)) {
T value;
if(luavalue_cast(-1, value))
vec.push_back(value);
g_lua.pop();
}
return true;
}
return false;
}
2011-09-02 06:21:18 +02:00
template<typename T>
int push_luavalue(const std::deque<T>& vec) {
2011-09-02 06:21:18 +02:00
g_lua.newTable();
int i = 1;
for(const T& v : vec) {
push_internal_luavalue(v);
2011-09-02 06:21:18 +02:00
g_lua.rawSeti(i);
i++;
}
return 1;
2011-09-02 06:21:18 +02:00
}
2012-02-06 20:19:47 +01:00
template<typename T>
bool luavalue_cast(int index, std::deque<T>& vec)
{
if(g_lua.isTable(index)) {
g_lua.pushNil();
while(g_lua.next(index < 0 ? index-1 : index)) {
T value;
if(luavalue_cast(-1, value))
vec.push_back(value);
g_lua.pop();
}
return true;
}
return false;
}
template<class K, class V>
int push_luavalue(const std::map<K, V>& map)
{
g_lua.newTable();
for(auto& it : map) {
push_internal_luavalue(it.first);
push_internal_luavalue(it.second);
g_lua.rawSet();
}
return 1;
}
template<class K, class V>
bool luavalue_cast(int index, std::map<K, V>& map)
{
if(g_lua.isTable(index)) {
g_lua.pushNil();
while(g_lua.next(index < 0 ? index-1 : index)) {
K key;
V value;
if(luavalue_cast(-1, value) && luavalue_cast(-2, key))
map[key] = value;
g_lua.pop();
}
return true;
}
return false;
}
2011-08-26 20:00:22 +02:00
template<int N>
struct push_tuple_internal_luavalue {
2011-08-26 20:00:22 +02:00
template<typename Tuple>
static void call(const Tuple& tuple) {
push_internal_luavalue(std::get<N-1>(tuple));
2011-08-26 20:00:22 +02:00
g_lua.rawSeti(N);
push_tuple_internal_luavalue<N-1>::call(tuple);
}
};
template<>
struct push_tuple_internal_luavalue<0> {
template<typename Tuple>
static void call(const Tuple& tuple) { }
};
template<typename... Args>
int push_internal_luavalue(const std::tuple<Args...>& tuple) {
g_lua.newTable();
push_tuple_internal_luavalue<sizeof...(Args)>::call(tuple);
return 1;
}
template<int N>
struct push_tuple_luavalue {
template<typename Tuple>
static void call(const Tuple& tuple) {
push_internal_luavalue(std::get<std::tuple_size<Tuple>::value - N>(tuple));
2011-08-26 20:00:22 +02:00
push_tuple_luavalue<N-1>::call(tuple);
}
};
template<>
struct push_tuple_luavalue<0> {
template<typename Tuple>
static void call(const Tuple& tuple) { }
};
template<typename... Args>
int push_luavalue(const std::tuple<Args...>& tuple) {
2011-08-26 20:00:22 +02:00
push_tuple_luavalue<sizeof...(Args)>::call(tuple);
return sizeof...(Args);
2011-08-26 20:00:22 +02:00
}
2011-08-14 04:09:11 +02:00
#endif