// The MIT License (MIT) // Copyright (c) 2013-2016 Rapptz, ThePhD and contributors // 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_STACK_PUSH_HPP #define SOL_STACK_PUSH_HPP #include "stack_core.hpp" #include "raii.hpp" #include "optional.hpp" #include namespace sol { namespace stack { template struct pusher { template static int push(lua_State* L, Args&&... args) { // Basically, we store all user-data like this: // If it's a movable/copyable value (no std::ref(x)), then we store the pointer to the new // data in the first sizeof(T*) bytes, and then however many bytes it takes to // do the actual object. Things that are std::ref or plain T* are stored as // just the sizeof(T*), and nothing else. T** pointerpointer = static_cast(lua_newuserdata(L, sizeof(T*) + sizeof(T))); T*& referencereference = *pointerpointer; T* allocationtarget = reinterpret_cast(pointerpointer + 1); referencereference = allocationtarget; std::allocator alloc{}; alloc.construct(allocationtarget, std::forward(args)...); luaL_newmetatable(L, &usertype_traits::metatable[0]); lua_setmetatable(L, -2); return 1; } }; template <> struct pusher { template static int push(lua_State* L, T&& obj) { return stack::push(L, detail::ptr(obj)); } }; template struct pusher { static int push(lua_State* L, T* obj) { if (obj == nullptr) return stack::push(L, nil); T** pref = static_cast(lua_newuserdata(L, sizeof(T*))); *pref = obj; luaL_getmetatable(L, &usertype_traits::metatable[0]); lua_setmetatable(L, -2); return 1; } }; template struct pusher> { template static int push(lua_State* L, Args&&... args) { T** pref = static_cast(lua_newuserdata(L, sizeof(T*) + sizeof(detail::special_destruct_func) + sizeof(Real))); detail::special_destruct_func* fx = static_cast(static_cast(pref + 1)); Real* mem = static_cast(static_cast(fx + 1)); *fx = detail::special_destruct; detail::default_construct::construct(mem, std::forward(args)...); *pref = std::addressof(detail::deref(*mem)); if (luaL_newmetatable(L, &usertype_traits>::metatable[0]) == 1) { set_field(L, "__gc", detail::unique_destruct); } lua_setmetatable(L, -2); return 1; } }; template struct pusher::value>> { template static int push(lua_State* L, Args&&... args) { typedef typename is_unique_usertype::metatable_type meta_type; return stack::push>(L, std::forward(args)...); } }; template struct pusher> { static int push(lua_State* L, std::unique_ptr obj) { if (obj == nullptr) return stack::push(L, nil); return stack::push>>(L, std::move(obj)); } }; template struct pusher> { template static int push(lua_State* L, S&& s) { if (s == nullptr) return stack::push(L, nil); return stack::push>>(L, std::forward(s)); } }; template struct pusher> { static int push(lua_State* L, const std::reference_wrapper& t) { return stack::push(L, std::addressof(detail::deref(t.get()))); } }; template struct pusher::value>> { static int push(lua_State* L, const T& value) { lua_pushnumber(L, value); return 1; } }; template struct pusher, std::is_signed>::value>> { static int push(lua_State* L, const T& value) { lua_pushinteger(L, static_cast(value)); return 1; } }; template struct pusher, std::is_unsigned>::value>> { static int push(lua_State* L, const T& value) { typedef std::make_signed_t signed_int; return stack::push(L, static_cast(value)); } }; template struct pusher, meta::Not>, meta::Not>>::value>> { static int push(lua_State* L, const T& cont) { lua_createtable(L, static_cast(cont.size()), 0); int tableindex = lua_gettop(L); unsigned index = 1; for(auto&& i : cont) { set_field(L, index++, i, tableindex); } return 1; } }; template struct pusher, meta::has_key_value_pair, meta::Not>>::value>> { static int push(lua_State* L, const T& cont) { lua_createtable(L, static_cast(cont.size()), 0); int tableindex = lua_gettop(L); for(auto&& pair : cont) { set_field(L, pair.first, pair.second, tableindex); } return 1; } }; template struct pusher::value || std::is_base_of::value>> { static int push(lua_State*, T& ref) { return ref.push(); } static int push(lua_State*, T&& ref) { return ref.push(); } }; template<> struct pusher { static int push(lua_State* L, bool b) { lua_pushboolean(L, b); return 1; } }; template<> struct pusher { static int push(lua_State* L, nil_t) { lua_pushnil(L); return 1; } }; template<> struct pusher { static int push(lua_State* L, metatable_key_t) { lua_pushlstring(L, "__mt", 4); return 1; } }; template<> struct pusher> { static int push(lua_State* L, lua_CFunction func, int n = 0) { lua_pushcclosure(L, func, n); return 1; } }; template<> struct pusher { static int push(lua_State* L, lua_CFunction func, int n = 0) { lua_pushcclosure(L, func, n); return 1; } }; template<> struct pusher { static int push(lua_State* L, c_closure closure) { lua_pushcclosure(L, closure.c_function, closure.upvalues); return 1; } }; template<> struct pusher { static int push(lua_State* L, void* userdata) { lua_pushlightuserdata(L, userdata); return 1; } }; template<> struct pusher { static int push(lua_State* L, light_userdata_value userdata) { lua_pushlightuserdata(L, userdata); return 1; } }; template<> struct pusher { static int push(lua_State* L, userdata_value data) { void** ud = static_cast(lua_newuserdata(L, sizeof(void*))); *ud = data.value; return 1; } }; template<> struct pusher { static int push(lua_State* L, const char* str) { lua_pushlstring(L, str, std::char_traits::length(str)); return 1; } }; template struct pusher { static int push(lua_State* L, const char (&str)[N]) { lua_pushlstring(L, str, N - 1); return 1; } }; template<> struct pusher { static int push(lua_State* L, const std::string& str) { lua_pushlstring(L, str.c_str(), str.size()); return 1; } }; template struct pusher> { template static int push(std::index_sequence, lua_State* L, T&& t) { int pushcount = 0; (void)detail::swallow{ 0, (pushcount += stack::push(L, detail::forward_get(t) ), 0)... }; return pushcount; } template static int push(lua_State* L, T&& t) { return push(std::index_sequence_for(), L, std::forward(t)); } }; template struct pusher> { template static int push(lua_State* L, T&& t) { int pushcount = stack::push(L, detail::forward_get<0>(t)); pushcount += stack::push(L, detail::forward_get<1>(t)); return pushcount; } }; template struct pusher> { template static int push(lua_State* L, T&& t) { if (t == nullopt) { return stack::push(L, nullopt); } return stack::push(L, t.value()); } }; template<> struct pusher { static int push(lua_State* L, nullopt_t) { return stack::push(L, nil); } }; template<> struct pusher { static int push(lua_State*, const this_state&) { return 0; } }; } // stack } // sol #endif // SOL_STACK_PUSH_HPP