mirror of
https://github.com/ThePhD/sol2.git
synced 2024-03-22 13:10:44 +08:00
Style fixes and fixes for templates not usually used by MSVC (broken two-phase lookup killing me here. :c)
Member functions now work as well for set_function. If performance of `new`ing a type ever becomes too large, we can create a custom allocator for the std::shared_ptr's of the types. We can also up-front allocate for the unordered_map as well.
This commit is contained in:
ThePhD
parent
be98a4fdd4
commit
29f171e124
|
|
@ -30,70 +30,70 @@ namespace detail {
|
|||
template<typename TFuncSignature>
|
||||
struct function_traits;
|
||||
|
||||
template<typename T, typename R, typename... Tn>
|
||||
struct function_traits<R(T::*)(Tn...)> {
|
||||
static const std::size_t arity = sizeof...(Tn);
|
||||
template<typename T, typename R, typename... Args>
|
||||
struct function_traits<R(T::*)(Args...)> {
|
||||
static const std::size_t arity = sizeof...(Args);
|
||||
static const bool is_member_function = true;
|
||||
typedef std::tuple<Tn...> arg_tuple_t;
|
||||
typedef types<Tn...> args_t;
|
||||
typedef R(T::* func_t)(Tn...);
|
||||
typedef R(T::* func_pointer_t)(Tn...);
|
||||
typedef R return_t;
|
||||
typedef std::tuple<Args...> arg_tuple_type;
|
||||
typedef types<Args...> args_type;
|
||||
typedef R(T::* func_pointer_type)(Args...);
|
||||
typedef typename std::remove_pointer<func_pointer_type>::type func_type;
|
||||
typedef R return_type;
|
||||
template<std::size_t i>
|
||||
using arg_n = std::tuple_element<i, arg_tuple_t>;
|
||||
using arg_n = std::tuple_element<i, arg_tuple_type>;
|
||||
};
|
||||
|
||||
template<typename T, typename R, typename... Tn>
|
||||
struct function_traits<R(T::*)(Tn...) const> {
|
||||
static const std::size_t arity = sizeof...(Tn);
|
||||
template<typename T, typename R, typename... Args>
|
||||
struct function_traits<R(T::*)(Args...) const> {
|
||||
static const std::size_t arity = sizeof...(Args);
|
||||
static const bool is_member_function = true;
|
||||
typedef std::tuple<Tn...> arg_tuple_t;
|
||||
typedef types<Tn...> args_t;
|
||||
typedef R(T::* func_t)(Tn...);
|
||||
typedef R(T::* func_pointer_t)(Tn...);
|
||||
typedef R return_t;
|
||||
typedef std::tuple<Args...> arg_tuple_type;
|
||||
typedef types<Args...> args_type;
|
||||
typedef R(T::* func_type)(Args...);
|
||||
typedef R(T::* func_pointer_type)(Args...);
|
||||
typedef R return_type;
|
||||
template<std::size_t i>
|
||||
using arg_n = std::tuple_element<i, arg_tuple_t>;
|
||||
using arg_n = std::tuple_element<i, arg_tuple_type>;
|
||||
};
|
||||
|
||||
template<typename R, typename... Tn>
|
||||
struct function_traits<R(Tn...)> {
|
||||
static const std::size_t arity = sizeof...(Tn);
|
||||
template<typename R, typename... Args>
|
||||
struct function_traits<R(Args...)> {
|
||||
static const std::size_t arity = sizeof...(Args);
|
||||
static const bool is_member_function = false;
|
||||
typedef std::tuple<Tn...> arg_tuple_t;
|
||||
typedef types<Tn...> args_t;
|
||||
typedef R(func_t)(Tn...);
|
||||
typedef R(*func_pointer_t)(Tn...);
|
||||
typedef R return_t;
|
||||
typedef std::tuple<Args...> arg_tuple_type;
|
||||
typedef types<Args...> args_type;
|
||||
typedef R(func_type)(Args...);
|
||||
typedef R(*func_pointer_type)(Args...);
|
||||
typedef R return_type;
|
||||
template<std::size_t i>
|
||||
using arg_n = std::tuple_element<i, arg_tuple_t>;
|
||||
using arg_n = std::tuple_element<i, arg_tuple_type>;
|
||||
};
|
||||
|
||||
template<typename R, typename... Tn>
|
||||
struct function_traits<R(*)(Tn...)> {
|
||||
static const std::size_t arity = sizeof...(Tn);
|
||||
template<typename R, typename... Args>
|
||||
struct function_traits<R(*)(Args...)> {
|
||||
static const std::size_t arity = sizeof...(Args);
|
||||
static const bool is_member_function = false;
|
||||
typedef std::tuple<Tn...> arg_tuple_t;
|
||||
typedef types<Tn...> args_t;
|
||||
typedef R(func_t)(Tn...);
|
||||
typedef R(*func_pointer_t)(Tn...);
|
||||
typedef R return_t;
|
||||
typedef std::tuple<Args...> arg_tuple_type;
|
||||
typedef types<Args...> args_type;
|
||||
typedef R(func_type)(Args...);
|
||||
typedef R(*func_pointer_type)(Args...);
|
||||
typedef R return_type;
|
||||
template<std::size_t i>
|
||||
using arg_n = std::tuple_element<i, arg_tuple_t>;
|
||||
using arg_n = std::tuple_element<i, arg_tuple_type>;
|
||||
};
|
||||
|
||||
using std::get;
|
||||
|
||||
template<typename Function, typename Tuple, size_t... Indices>
|
||||
inline auto call(Function f, const Tuple& t, indices<Indices...>) -> decltype(f(get<Indices>(t)...)) {
|
||||
inline auto call(Function&& f, const Tuple& t, indices<Indices...>) -> decltype(f(get<Indices>(t)...)) {
|
||||
return f(get<Indices>(t)...);
|
||||
}
|
||||
|
||||
} // detail
|
||||
|
||||
template<typename Function, typename... Args>
|
||||
inline auto call(Function f, const std::tuple<Args...>& t) -> decltype(detail::call(f, t, detail::build_indices<sizeof...(Args)>{})) {
|
||||
return call(f, t, detail::build_indices<sizeof...(Args)>{});
|
||||
inline auto call(Function&& f, const std::tuple<Args...>& t) -> decltype(detail::call(std::forward<Function>(f), t, build_indices<sizeof...(Args)>{})) {
|
||||
return call(std::forward<Function>(f), t, build_indices<sizeof...(Args)>{});
|
||||
}
|
||||
|
||||
} // sol
|
||||
|
|
|
|||
|
|
@ -42,23 +42,23 @@ struct lambda_lua_func : public lua_func {
|
|||
typedef function_traits<fx_t> fx_traits;
|
||||
TFx fx;
|
||||
|
||||
template<typename... TFxn>
|
||||
lambda_lua_func(TFxn&&... fxn) : fx(std::forward<TFxn>(fxn)...) {
|
||||
template<typename... FxArgs>
|
||||
lambda_lua_func(FxArgs&&... fxargs) : fx(std::forward<FxArgs>(fxargs)...) {
|
||||
|
||||
}
|
||||
|
||||
virtual int operator () (lua_State* L) override {
|
||||
return (*this)(tuple_types<fx_traits::return_t>(), fx_traits::args_t(), L);
|
||||
return (*this)(tuple_types<fx_traits::return_type>(), fx_traits::args_type(), L);
|
||||
}
|
||||
|
||||
template<typename... Tn>
|
||||
int operator()(types<void>, types<Tn...> t, lua_State* L) {
|
||||
template<typename... Args>
|
||||
int operator()(types<void>, types<Args...> t, lua_State* L) {
|
||||
stack::pop_call(L, fx, t);
|
||||
return 0;
|
||||
}
|
||||
|
||||
template<typename... TRn, typename... Tn>
|
||||
int operator()(types<TRn...>, types<Tn...> t, lua_State* L) {
|
||||
template<typename... TRn, typename... Args>
|
||||
int operator()(types<TRn...>, types<Args...> t, lua_State* L) {
|
||||
auto r = stack::pop_call(L, fx, t);
|
||||
stack::push(L, r);
|
||||
return sizeof...(TRn);
|
||||
|
|
@ -71,23 +71,23 @@ struct explicit_lua_func : public lua_func {
|
|||
typedef function_traits<fx_t> fx_traits;
|
||||
TFx fx;
|
||||
|
||||
template<typename... TFxn>
|
||||
explicit_lua_func(TFxn&&... fxn) : fx(std::forward<TFxn>(fxn)...) {
|
||||
template<typename... FxArgs>
|
||||
explicit_lua_func(FxArgs&&... fxargs) : fx(std::forward<FxArgs>(fxargs)...) {
|
||||
|
||||
}
|
||||
|
||||
virtual int operator () (lua_State* L) override {
|
||||
return (*this)(tuple_types<fx_traits::return_t>(), fx_traits::args_t(), L);
|
||||
return (*this)(tuple_types<fx_traits::return_type>(), fx_traits::args_type(), L);
|
||||
}
|
||||
|
||||
template<typename... Tn>
|
||||
int operator () (types<void>, types<Tn...> t, lua_State* L) {
|
||||
template<typename... Args>
|
||||
int operator () (types<void>, types<Args...> t, lua_State* L) {
|
||||
stack::pop_call(L, fx, t);
|
||||
return 0;
|
||||
}
|
||||
|
||||
template<typename... TRn, typename... Tn>
|
||||
int operator () (types<TRn...>, types<Tn...> t, lua_State* L) {
|
||||
template<typename... TRn, typename... Args>
|
||||
int operator () (types<TRn...>, types<Args...> t, lua_State* L) {
|
||||
auto r = stack::pop_call(L, fx, t);
|
||||
stack::push(L, r);
|
||||
return sizeof...(TRn);
|
||||
|
|
@ -98,26 +98,43 @@ template<typename TFx, typename T>
|
|||
struct explicit_lua_func<TFx, T, true> : public lua_func {
|
||||
typedef typename std::remove_pointer<typename std::decay<TFx>::type>::type fx_t;
|
||||
typedef function_traits<fx_t> fx_traits;
|
||||
T* member;
|
||||
TFx fx;
|
||||
|
||||
template<typename... TFxn>
|
||||
explicit_lua_func(T* m, TFxn&&... fxn) : member(m), fx(std::forward<TFxn>(fxn)...) {
|
||||
struct lambda {
|
||||
T* member;
|
||||
TFx invocation;
|
||||
|
||||
template<typename... FxArgs>
|
||||
lambda(T* m, FxArgs&&... fxargs) : member(m), invocation(std::forward<FxArgs>(fxargs)...) {
|
||||
|
||||
}
|
||||
|
||||
template<typename... Args>
|
||||
typename fx_traits::return_type operator () (Args&&... args) {
|
||||
return ((*member).*invocation)(std::forward<Args>(args)...);
|
||||
}
|
||||
} fx;
|
||||
|
||||
template<typename... FxArgs>
|
||||
explicit_lua_func(T* m, FxArgs&&... fxargs) : fx(m, std::forward<FxArgs>(fxargs)...) {
|
||||
|
||||
}
|
||||
|
||||
template<typename... FxArgs>
|
||||
explicit_lua_func(T& m, FxArgs&&... fxargs) : fx(std::addressof(m), std::forward<FxArgs>(fxargs)...) {
|
||||
|
||||
}
|
||||
|
||||
virtual int operator () (lua_State* L) override {
|
||||
return (*this)(tuple_types<fx_traits::return_t>(), fx_traits::args_t(), L);
|
||||
return (*this)(tuple_types<fx_traits::return_type>(), fx_traits::args_type(), L);
|
||||
}
|
||||
|
||||
template<typename... Tn>
|
||||
int operator () (types<void>, types<Tn...>, lua_State* L) {
|
||||
template<typename... Args>
|
||||
int operator () (types<void>, types<Args...>, lua_State* L) {
|
||||
stack::pop_call(L, fx, t);
|
||||
return 0;
|
||||
}
|
||||
|
||||
template<typename... TRn, typename... Tn>
|
||||
int operator () (types<TRn...>, types<Tn...> t, lua_State* L) {
|
||||
template<typename... TRn, typename... Args>
|
||||
int operator () (types<TRn...>, types<Args...> t, lua_State* L) {
|
||||
auto r = stack::pop_call(L, fx, t);
|
||||
stack::push(L, r);
|
||||
return sizeof...(TRn);
|
||||
|
|
|
|||
|
|
@ -45,8 +45,8 @@ auto ltr_pop(T&& extra, F f, types<>, Vs&&... vs)
|
|||
// take head, produce value from it, pass after other values
|
||||
template<class F, class Head, class... Tail, class... Vs>
|
||||
auto ltr_pop(lua_State* L, F f, types<Head, Tail...>, Vs&&... vs)
|
||||
-> decltype(ltr_pop(L, f, types<Tail...>{}, std::forward<Vs>(vs)..., stack::pop<Head>(L))) {
|
||||
return ltr_pop(L, f, types<Tail...>{}, std::forward<Vs>(vs)..., stack::pop<Head>(L));
|
||||
-> decltype(ltr_pop(L, f, types<Tail...>{}, std::forward<Vs>(vs)..., pop<Head>(L))) {
|
||||
return ltr_pop(L, f, types<Tail...>{}, std::forward<Vs>(vs)..., pop<Head>(L));
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
|
|
|
|||
|
|
@ -149,8 +149,14 @@ public:
|
|||
|
||||
template<typename T, typename TFx>
|
||||
state& set_function(T&& key, TFx&& fx) {
|
||||
global.set_function(std::forward<T>(key), std::forward<TFx>(fx));
|
||||
return *this;
|
||||
global.set_function(std::forward<T>(key), std::forward<TFx>(fx));
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename T, typename TFx, typename TM>
|
||||
state& set_function(T&& key, TFx&& fx, TM& mem) {
|
||||
global.set_function(std::forward<T>(key), std::forward<TFx>(fx), mem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
|
|
|
|||
|
|
@ -60,53 +60,59 @@ public:
|
|||
|
||||
template<typename T, typename TFx>
|
||||
table& set_function(T&& key, TFx&& fx) {
|
||||
typedef typename std::remove_pointer<typename std::decay<TFx>::type>::type clean_fx;
|
||||
const static bool isfunction = std::is_function<clean_fx>::value;
|
||||
return set_function(std::integral_constant<bool, !isfunction>(),
|
||||
std::forward<T>(key), std::forward<TFx>(fx));
|
||||
typedef typename std::remove_pointer<typename std::decay<TFx>::type>::type clean_fx;
|
||||
const static bool isfunction = std::is_function<clean_fx>::value;
|
||||
return set_fx(std::integral_constant<bool, !isfunction>(),
|
||||
std::forward<T>(key), std::forward<TFx>(fx));
|
||||
}
|
||||
|
||||
template<typename T, typename TFx>
|
||||
table& set_function(std::true_type, T&& key, TFx&& fx) {
|
||||
typedef typename std::decay<TFx>::type clean_fx;
|
||||
std::string fkey(key);
|
||||
lua_CFunction freefunc = &detail::lua_cfun;
|
||||
auto hint = funcs.find(fkey);
|
||||
detail::lua_func* target = nullptr;
|
||||
if (hint == funcs.end()) {
|
||||
std::shared_ptr<detail::lua_func> sptr(new detail::lambda_lua_func<clean_fx>(std::forward<TFx>(fx)));
|
||||
hint = funcs.emplace_hint(hint, fkey, std::move(sptr));
|
||||
}
|
||||
target = hint->second.get();
|
||||
lua_pushlightuserdata(state(), static_cast<void*>(target));
|
||||
lua_pushcclosure(state(), freefunc, 1);
|
||||
lua_setglobal(state(), fkey.c_str());
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename T, typename TFx>
|
||||
table& set_function(std::false_type, T&& key, TFx&& fx) {
|
||||
typedef typename std::decay<TFx>::type clean_fx;
|
||||
std::string fkey(key);
|
||||
lua_CFunction freefunc = &detail::lua_cfun;
|
||||
auto hint = funcs.find(fkey);
|
||||
detail::lua_func* target = nullptr;
|
||||
if (hint == funcs.end()) {
|
||||
std::shared_ptr<detail::lua_func> sptr(new detail::explicit_lua_func<TFx>(std::forward<TFx>(fx)));
|
||||
hint = funcs.emplace_hint(hint, fkey, std::move(sptr));
|
||||
}
|
||||
target = hint->second.get();
|
||||
lua_pushlightuserdata(state(), static_cast<void*>(target));
|
||||
lua_pushcclosure(state(), freefunc, 1);
|
||||
lua_setglobal(state(), fkey.c_str());
|
||||
return *this;
|
||||
template<typename T, typename TFx, typename TM>
|
||||
table& set_function(T&& key, TFx&& fx, TM& mem) {
|
||||
typedef typename std::remove_pointer<typename std::decay<TFx>::type>::type clean_fx;
|
||||
std::unique_ptr<detail::lua_func> sptr(new detail::explicit_lua_func<clean_fx, TM>(mem, std::forward<TFx>(fx)));
|
||||
return set_fx(std::forward<T>(key), std::move(sptr));
|
||||
}
|
||||
|
||||
size_t size() const {
|
||||
push();
|
||||
return lua_rawlen(state(), -1);
|
||||
}
|
||||
|
||||
|
||||
private:
|
||||
|
||||
template<typename T, typename TFx>
|
||||
table& set_fx(std::true_type, T&& key, TFx&& fx) {
|
||||
typedef typename std::remove_pointer<typename std::decay<TFx>::type>::type clean_fx;
|
||||
std::unique_ptr<detail::lua_func> sptr(new detail::lambda_lua_func<clean_fx>(std::forward<TFx>(fx)));
|
||||
return set_fx(std::forward<T>(key), std::move(sptr));
|
||||
}
|
||||
|
||||
template<typename T, typename TFx>
|
||||
table& set_fx(std::false_type, T&& key, TFx&& fx) {
|
||||
typedef typename std::remove_pointer<typename std::decay<TFx>::type>::type clean_fx;
|
||||
typedef typename std::decay<TFx>::type ptr_fx;
|
||||
std::unique_ptr<detail::lua_func> sptr(new detail::explicit_lua_func<ptr_fx>(std::forward<TFx>(fx)));
|
||||
return set_fx(std::forward<T>(key), std::move(sptr));
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
table& set_fx(T&& key, std::unique_ptr<detail::lua_func> funcptr) {
|
||||
std::string fkey(key);
|
||||
auto hint = funcs.find(fkey);
|
||||
if (hint == funcs.end()) {
|
||||
std::shared_ptr<detail::lua_func> sptr(funcptr.release());
|
||||
hint = funcs.emplace_hint(hint, fkey, std::move(sptr));
|
||||
}
|
||||
else {
|
||||
hint->second.reset(funcptr.release());
|
||||
}
|
||||
detail::lua_func* target = target = hint->second.get();
|
||||
lua_CFunction freefunc = &detail::lua_cfun;
|
||||
lua_pushlightuserdata(state(), static_cast<void*>(target));
|
||||
lua_pushcclosure(state(), freefunc, 1);
|
||||
lua_setglobal(state(), fkey.c_str());
|
||||
return *this;
|
||||
}
|
||||
};
|
||||
} // sol
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user