// The MIT License (MIT) // Copyright (c) 2013 Danny Y., Rapptz // 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. #ifndef SOL_TABLE_HPP #define SOL_TABLE_HPP #include "stack.hpp" #include "lua_function.hpp" #include #include namespace sol { namespace detail { template T* get_ptr(T& val) { return std::addressof(val); } template T* get_ptr(T* val) { return val; } } // detail class table : public reference { friend class state; template T single_get(U&& key) const { push(); stack::push(state(), std::forward(key)); lua_gettable(state(), -2); type_assert(state(), -1, type_of()); auto result = stack::pop(state()); lua_pop(state(), 1); return result; } template typename std::tuple_element>::type element_get(types, Tup&& key) const { typedef typename std::tuple_element>::type T; push(); stack::push(state(), std::get(key)); lua_gettable(state(), -2); type_assert(state(), -1, type_of()); T result = stack::pop(state()); lua_pop(state(), 1); return result; } template typename multi_return::type tuple_get(types t, indices, Tup&& tup) const { return std::make_tuple(element_get(t, std::forward(tup))...); } template Ret tuple_get(types t, indices<0>, Tup&& tup) const { return element_get<0>(t, std::forward(tup)); } template typename multi_return::type get(types t, Keys&&... keys) const { static_assert(sizeof...(Keys) == sizeof...(Ret), "Must have same number of keys as return values"); return tuple_get(t, t, std::make_tuple(std::forward(keys)...)); } public: table() noexcept : reference() {} table(lua_State* L, int index = -1) : reference(L, index) { type_assert(L, index, type::table); } template typename multi_return::type get(Keys&&... keys) const { return get(types(), std::forward(keys)...); } template table& set(T&& key, U&& value) { push(); stack::push(state(), std::forward(key)); stack::push(state(), std::forward(value)); lua_settable(state(), -3); lua_pop(state(), 1); return *this; } template table& set_function(T&& key, TFx&& fx) { typedef typename std::remove_pointer>::type clean_fx; return set_isfunction_fx(std::is_function(), std::forward(key), std::forward(fx)); } template table& set_function(T&& key, TFx&& fx, TObj&& obj) { return set_lvalue_fx(Bool::value || std::is_pointer::value>(), std::forward(key), std::forward(fx), std::forward(obj)); } size_t size() const { push(); return lua_rawlen(state(), -1); } private: template table& set_isfunction_fx(std::true_type, T&& key, TFx&& fx) { return set_fx(std::false_type(), std::forward(key), std::forward(fx)); } template table& set_isfunction_fx(std::false_type, T&& key, TFx&& fx) { typedef Decay clean_lambda; typedef typename function_traits::free_function_pointer_type raw_func_t; typedef std::is_convertible isconvertible; return set_isconvertible_fx(isconvertible(), std::forward(key), std::forward(fx)); } template table& set_isconvertible_fx(std::true_type, T&& key, TFx&& fx) { typedef Decay clean_lambda; typedef typename function_traits::free_function_pointer_type raw_func_t; return set_isfunction_fx(std::true_type(), std::forward(key), raw_func_t(std::forward(fx))); } template table& set_isconvertible_fx(std::false_type, T&& key, TFx&& fx) { typedef typename std::remove_pointer>::type clean_fx; std::unique_ptr sptr(new lambda_lua_func(std::forward(fx))); return set_fx(std::forward(key), std::move(sptr)); } template table& set_lvalue_fx(std::true_type, T&& key, TFx&& fx, TObj&& obj) { return set_fx(std::true_type(), std::forward(key), std::forward(fx), std::forward(obj)); } template table& set_lvalue_fx(std::false_type, T&& key, TFx&& fx, TObj&& obj) { typedef typename std::remove_pointer>::type clean_fx; std::unique_ptr sptr(new explicit_lua_func(std::forward(obj), std::forward(fx))); return set_fx(std::forward(key), std::move(sptr)); } template table& set_fx(std::true_type, T&& key, TFx&& fx, TObj&& obj) { std::string fkey(key); // Layout: // idx 1...n: verbatim data of member function pointer // idx n + 1: is the object's void pointer // We don't need to store the size, because the other side is templated // with the same member function pointer type Decay fxptr(std::forward(fx)); void* userobjdata = static_cast(detail::get_ptr(obj)); lua_CFunction freefunc = &static_object_lua_func, TFx>::call; const char* freefuncname = fkey.c_str(); const luaL_Reg funcreg[ 2 ] = { { freefuncname, freefunc }, { nullptr, nullptr } }; push(); int upvalues = stack::push_user(state(), fxptr); stack::push(state(), userobjdata); luaL_setfuncs(state(), funcreg, upvalues + 1); lua_pop(state(), 1); return *this; } template table& set_fx(std::false_type, T&& key, TFx&& fx) { std::string fkey(key); Decay target(std::forward(fx)); lua_CFunction freefunc = &static_lua_func::call; const char* freefuncname = fkey.c_str(); const luaL_Reg funcreg[ 2 ] = { { freefuncname, freefunc }, { nullptr, nullptr } }; push(); int upvalues = stack::push_user(state(), target); luaL_setfuncs(state(), funcreg, upvalues); lua_pop(state(), 1); return *this; } template table& set_fx(T&& key, std::unique_ptr luafunc) { std::string fkey(key); std::string metakey("sol.stateful."); metakey += fkey; metakey += ".meta"; lua_func* target = luafunc.release(); void* userdata = reinterpret_cast(target); lua_CFunction freefunc = &lua_func::call; const char* freefuncname = fkey.c_str(); const char* metatablename = metakey.c_str(); const luaL_Reg funcreg[ 2 ] = { { freefuncname, freefunc }, { nullptr, nullptr } }; if (luaL_newmetatable(state(), metatablename) == 1) { lua_pushstring(state(), "__gc"); lua_pushcclosure(state(), &lua_func::gc, 0); lua_settable(state(), -3); } push(); stack::push_user(state(), userdata, metatablename); luaL_setfuncs(state(), funcreg, 1); lua_pop(state(), 1); return *this; } }; } // sol #endif // SOL_TABLE_HPP