StarMirror/sol2
1
0
Fork 0
mirror of https://github.com/ThePhD/sol2.git synced 2024-03-22 13:10:44 +08:00
Code Issues Projects Releases Wiki Activity

update everything

Browse Source
This commit is contained in:
ThePhD 2018-12-22 15:36:42 -05:00
parent 88cafb281f
commit a6abc0a0d9
No known key found for this signature in database
GPG Key ID: 1509DB1C0F702BFA
30 changed files with 630 additions and 501 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

45
cmake/Modules/FindLuaBuild/LuaJIT.cmake
View File

@ -230,11 +230,11 @@ file(TO_CMAKE_PATH "${LUA_JIT_SOURCE_DIR}/${LUA_JIT_PREBUILT_EXE}" LUA_JIT_SOURC
file(TO_CMAKE_PATH "${LUA_JIT_SOURCE_DIR}/${LUA_JIT_PREBUILT_DLL}" LUA_JIT_SOURCE_LUA_DLL)
file(TO_CMAKE_PATH "${LUA_JIT_SOURCE_DIR}/${LUA_JIT_PREBUILT_EXP}" LUA_JIT_SOURCE_LUA_LIB_EXP)
file(TO_CMAKE_PATH "${LUA_JIT_LIB_FILE}" LUA_JIT_DESTINATION_LUA_LIB)
file(TO_CMAKE_PATH "${LUA_JIT_IMP_LIB_FILE}" LUA_JIT_DESTINATION_LUA_IMP_LIB)
file(TO_CMAKE_PATH "${LUA_JIT_EXE_FILE}" LUA_JIT_DESTINATION_LUA_INTERPRETER)
file(TO_CMAKE_PATH "${LUA_JIT_DLL_FILE}" LUA_JIT_DESTINATION_LUA_DLL)
file(TO_CMAKE_PATH "${CMAKE_ARCHIVE_OUTPUT_DIRECTORY}/${LUA_JIT_LIB_EXP_FILENAME}" LUA_JIT_DESTINATION_LUA_LIB_EXP)
file(TO_CMAKE_PATH "${LUA_JIT_IMP_LIB_FILE}" LUA_JIT_DESTINATION_LUA_IMP_LIB)
file(TO_CMAKE_PATH "${LUA_JIT_LIB_FILE}" LUA_JIT_DESTINATION_LUA_LIB)
file(TO_CMAKE_PATH "${LUA_JIT_EXE_FILE}" LUA_JIT_DESTINATION_LUA_INTERPRETER)
if (WIN32 AND NOT MSVC)
string(COMPARE EQUAL ${LUA_JIT_VERSION} ${LUA_JIT_2.0_LATEST_VERSION} lua_jit_same_version_20)
@ -247,21 +247,14 @@ elseif(LUA_JIT_NORMALIZED_LUA_VERSION MATCHES "latest")
set(LUA_JIT_PULL_LATEST TRUE)
endif()
set(LUA_JIT_BYPRODUCTS "${LUA_JIT_SOURCE_LUA_LIB}"
set(LUA_JIT_BYPRODUCTS "${LUA_JIT_SOURCE_LUA_LIB}" "${LUA_JIT_SOURCE_LUA_LIB_EXP}"
"${LUA_JIT_SOURCE_LUA_DLL}" "${LUA_JIT_SOURCE_LUA_INTERPRETER}")
set(LUA_JIT_INSTALL_BYPRODUCTS "${LUA_JIT_DESTINATION_LUA_LIB}"
set(LUA_JIT_INSTALL_BYPRODUCTS "${LUA_JIT_DESTINATION_LUA_LIB}" "${LUA_JIT_DESTINATION_LUA_LIB_EXP}"
"${LUA_JIT_DESTINATION_LUA_DLL}" "${LUA_JIT_DESTINATION_LUA_INTERPRETER}")
if (MSVC)
set(LUA_JIT_BYPRODUCTS "${LUA_JIT_BYPRODUCTS}" "${LUA_JIT_SOURCE_LUA_LIB_EXP}")
set(LUA_JIT_INSTALL_BYPRODUCTS "${LUA_JIT_INSTALL_BYPRODUCTS}" "${LUA_JIT_DESTINATION_LUA_LIB_EXP}")
endif()
if (CMAKE_IMPORT_LIBRARY_SUFFIX)
if (NOT MSVC)
set(LUA_JIT_BYPRODUCTS "${LUA_JIT_BYPRODUCTS}" "${LUA_JIT_SOURCE_LUA_IMP_LIB}")
endif()
set(LUA_JIT_BYPRODUCTS "${LUA_JIT_BYPRODUCTS}" "${LUA_JIT_SOURCE_LUA_IMP_LIB}")
set(LUA_JIT_INSTALL_BYPRODUCTS "${LUA_JIT_INSTALL_BYPRODUCTS}" "${LUA_JIT_DESTINATION_LUA_IMP_LIB}")
endif()
@ -271,16 +264,16 @@ set(LUA_JIT_POSTBUILD_COMMENTS "Executable - Moving \"${LUA_JIT_SOURCE_LUA_INTER
set(LUA_JIT_POSTBUILD_COMMANDS COMMAND "${CMAKE_COMMAND}" -E copy "${LUA_JIT_SOURCE_LUA_INTERPRETER}" "${LUA_JIT_DESTINATION_LUA_INTERPRETER}")
if (BUILD_LUA_AS_DLL)
if (MSVC)
set(LUA_JIT_POSTBUILD_COMMENTS "${LUA_JIT_POSTBUILD_COMMENTS}\nImport Library - Moving \"${LUA_JIT_SOURCE_LUA_IMP_LIB}\" to \"${LUA_JIT_DESTINATION_LUA_IMP_LIB}\"...")
set(LUA_JIT_POSTBUILD_COMMENTS "${LUA_JIT_POSTBUILD_COMMENTS} | Import Library - Moving \"${LUA_JIT_SOURCE_LUA_IMP_LIB}\" to \"${LUA_JIT_DESTINATION_LUA_IMP_LIB}\"...")
set(LUA_JIT_POSTBUILD_COMMANDS ${LUA_JIT_POSTBUILD_COMMANDS} COMMAND "${CMAKE_COMMAND}" -E copy "${LUA_JIT_SOURCE_LUA_IMP_LIB}" "${LUA_JIT_DESTINATION_LUA_IMP_LIB}")
set(LUA_JIT_POSTBUILD_COMMENTS "${LUA_JIT_POSTBUILD_COMMENTS}\nLibrary - Moving \"${LUA_JIT_SOURCE_LUA_LIB_EXP}\" to \"${LUA_JIT_DESTINATION_LUA_LIB_EXP}\"...")
set(LUA_JIT_POSTBUILD_COMMENTS "${LUA_JIT_POSTBUILD_COMMENTS} | Library - Moving \"${LUA_JIT_SOURCE_LUA_LIB_EXP}\" to \"${LUA_JIT_DESTINATION_LUA_LIB_EXP}\"...")
set(LUA_JIT_POSTBUILD_COMMANDS ${LUA_JIT_POSTBUILD_COMMANDS} && "${CMAKE_COMMAND}" -E copy "${LUA_JIT_SOURCE_LUA_LIB_EXP}" "${LUA_JIT_DESTINATION_LUA_LIB_EXP}")
endif()
set(LUA_JIT_POSTBUILD_COMMENTS "${LUA_JIT_POSTBUILD_COMMENTS}\nDynamic Library - Moving \"${LUA_JIT_SOURCE_LUA_DLL}\" to \"${LUA_JIT_DESTINATION_LUA_DLL}\"...")
set(LUA_JIT_POSTBUILD_COMMENTS "${LUA_JIT_POSTBUILD_COMMENTS} | Dynamic Library - Moving \"${LUA_JIT_SOURCE_LUA_DLL}\" to \"${LUA_JIT_DESTINATION_LUA_DLL}\"...")
set(LUA_JIT_POSTBUILD_COMMANDS ${LUA_JIT_POSTBUILD_COMMANDS} COMMAND "${CMAKE_COMMAND}" -E copy "${LUA_JIT_SOURCE_LUA_DLL}" "${LUA_JIT_DESTINATION_LUA_DLL}")
else()
set(LUA_JIT_POSTBUILD_COMMENTS "${LUA_JIT_POSTBUILD_COMMENTS}\nLibrary - Moving \"${LUA_JIT_SOURCE_LUA_LIB}\" to \"${LUA_JIT_DESTINATION_LUA_LIB}\"...")
set(LUA_JIT_POSTBUILD_COMMENTS "${LUA_JIT_POSTBUILD_COMMENTS} | Library - Moving \"${LUA_JIT_SOURCE_LUA_LIB}\" to \"${LUA_JIT_DESTINATION_LUA_LIB}\"...")
set(LUA_JIT_POSTBUILD_COMMANDS ${LUA_JIT_POSTBUILD_COMMANDS} COMMAND "${CMAKE_COMMAND}" -E copy "${LUA_JIT_SOURCE_LUA_LIB}" "${LUA_JIT_DESTINATION_LUA_LIB}")
endif()
@ -307,7 +300,7 @@ if (LUA_JIT_GIT_COMMIT OR LUA_JIT_PULL_LATEST)
${LUA_JIT_BUILD_COMMAND}
INSTALL_COMMAND ""
TEST_COMMAND ""
BUILD_BYPRODUCTS "${LUA_JIT_BYPRODUCTS}")
BUILD_BYPRODUCTS "${LUA_JIT_BYPRODUCTS}" "${LUA_JIT_BYPRODUCTS}")
else()
ExternalProject_Add(LUA_JIT
BUILD_IN_SOURCE TRUE
@ -326,25 +319,25 @@ else()
CONFIGURE_COMMAND ""
${LUA_JIT_BUILD_COMMAND}
INSTALL_COMMAND ""
TEST_COMMAND ""
BUILD_BYPRODUCTS "${LUA_JIT_BYPRODUCTS}")
TEST_COMMAND "")
endif()
# # MAYBE?:
# Add additional post-build step to move all necessary headers/lua files
# for now, we just point directly to the `src` directory...
add_custom_target(luajit_postbuild
ExternalProject_Add_Step(LUA_JIT move
${LUA_JIT_POSTBUILD_COMMANDS}
WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}"
COMMENT ${LUA_JIT_POSTBUILD_COMMENTS}
DEPENDS "${LUA_JIT_BYPRODUCTS}"
)
DEPENDS build
ALWAYS TRUE)
ExternalProject_Add_StepTargets(LUA_JIT move)
# # Lua Library
add_library(${lualib} ${LUA_BUILD_LIBRARY_TYPE} IMPORTED)
# make sure the library we export really does depend on Lua JIT's external project
add_dependencies(${lualib} luajit_postbuild)
add_dependencies(${lualib} LUA_JIT-move)
# Configure properties
if (BUILD_LUA_AS_DLL)
if (MSVC)
@ -380,7 +373,7 @@ add_executable(${luainterpreter} IMPORTED)
set_target_properties(${luainterpreter}
PROPERTIES
IMPORTED_LOCATION "${LUA_JIT_DESTINATION_LUA_INTERPRETER}")
add_dependencies(${luainterpreter} luajit_postbuild)
add_dependencies(${luainterpreter} LUA_JIT-move)
# # set externally-visible target indicator
set(LUA_LIBRARIES ${lualib})

2
docs/source/api/stack.rst
View File

@ -241,7 +241,7 @@ This is an SFINAE-friendly struct that is meant to expose static function ``get`
:name: pusher
template <typename X, typename = void>
struct pusher {
struct unqualified_pusher {
template <typename T>
static int push ( lua_State* L, T&&, ... ) {
// can optionally take more than just 1 argument

2
docs/source/tutorial/customization.rst
View File

@ -1,7 +1,7 @@
adding your own types
=====================
Sometimes, overriding Sol to make it handle certain ``struct``'s and ``class``'es as something other than just userdata is desirable. The way to do this is to take advantage of the 4 customization points for Sol. These are ``sol::lua_size<T>``, ``sol::stack::pusher<T, C>``, ``sol::stack::getter<T, C>``, ``sol::stack::checker<T, sol::type t, C>``.
Sometimes, overriding Sol to make it handle certain ``struct``'s and ``class``'es as something other than just userdata is desirable. The way to do this is to take advantage of the 4 customization points for Sol. These are ``sol::lua_size<T>``, ``sol::stack::unqualified_pusher<T, C>``, ``sol::stack::getter<T, C>``, ``sol::stack::checker<T, sol::type t, C>``.
These are template class/structs, so you'll override them using a technique C++ calls *class/struct specialization*. Below is an example of a struct that gets broken apart into 2 pieces when going in the C++ --> Lua direction, and then pulled back into a struct when going in the Lua --> C++:

98
examples/source/customization.cpp
View File

@ -1,98 +0,0 @@
#define SOL_CHECK_ARGUMENTS 1
#include <sol/sol.hpp>
#include <iostream>
#include "assert.hpp"
struct two_things {
int a;
bool b;
};
namespace sol {
// First, the expected size
// Specialization of a struct
template <>
struct lua_size<two_things> : std::integral_constant<int, 2> {};
// Then, specialize the type
// this makes sure Sol can return it properly
template <>
struct lua_type_of<two_things> : std::integral_constant<sol::type, sol::type::poly> {};
// Now, specialize various stack structures
namespace stack {
template <>
struct unqualified_checker<two_things> {
template <typename Handler>
static bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
// indices can be negative to count backwards from the top of the stack,
// rather than the bottom up
// to deal with this, we adjust the index to
// its absolute position using the lua_absindex function
int absolute_index = lua_absindex(L, index);
// Check first and second second index for being the proper types
bool success = stack::check<int>(L, absolute_index, handler)
&& stack::check<bool>(L, absolute_index + 1, handler);
tracking.use(2);
return success;
}
};
template <>
struct unqualified_getter<two_things> {
static two_things get(lua_State* L, int index, record& tracking) {
int absolute_index = lua_absindex(L, index);
// Get the first element
int a = stack::get<int>(L, absolute_index);
// Get the second element,
// in the +1 position from the first
bool b = stack::get<bool>(L, absolute_index + 1);
// we use 2 slots, each of the previous takes 1
tracking.use(2);
return two_things{ a, b };
}
};
template <>
struct pusher<two_things> {
static int push(lua_State* L, const two_things& things) {
int amount = stack::push(L, things.a);
// amount will be 1: int pushes 1 item
amount += stack::push(L, things.b);
// amount 2 now, since bool pushes a single item
// Return 2 things
return amount;
}
};
}
}
int main() {
std::cout << "=== customization ===" << std::endl;
std::cout << std::boolalpha;
sol::state lua;
lua.open_libraries(sol::lib::base);
// Create a pass-through style of function
lua.script("function f ( a, b ) print(a, b) return a, b end");
// get the function out of Lua
sol::function f = lua["f"];
two_things things = f(two_things{ 24, false });
c_assert(things.a == 24);
c_assert(things.b == false);
// things.a == 24
// things.b == true
std::cout << "things.a: " << things.a << std::endl;
std::cout << "things.b: " << things.b << std::endl;
std::cout << std::endl;
return 0;
}

2
examples/source/custom_global_transparent_argument.cpp → examples/source/customization_global_transparent_argument.cpp
View File

@ -37,7 +37,7 @@ GlobalResource* sol_lua_get(sol::types<GlobalResource*>, lua_State* L, int /*ind
return ls;
}
int sol_lua_push(lua_State* L, GlobalResource* ls) {
int sol_lua_push(sol::types<GlobalResource*>, lua_State* L, GlobalResource* ls) {
// push light userdata
return sol::stack::push(L, static_cast<void*>(ls));
}

70
examples/source/customization_multiple.cpp Normal file
View File

@ -0,0 +1,70 @@
#define SOL_CHECK_ARGUMENTS 1
#include <sol/sol.hpp>
#include <iostream>
#include "assert.hpp"
struct two_things {
int a;
bool b;
};
template <typename Handler>
bool check(sol::types<two_things>, lua_State* L, int index, Handler&& handler, sol::stack::record& tracking) {
// indices can be negative to count backwards from the top of the stack,
// rather than the bottom up
// to deal with this, we adjust the index to
// its absolute position using the lua_absindex function
int absolute_index = lua_absindex(L, index);
// Check first and second second index for being the proper types
bool success = sol::stack::check<int>(L, absolute_index, handler) && sol::stack::check<bool>(L, absolute_index + 1, handler);
tracking.use(2);
return success;
}
two_things get(sol::types<two_things>, lua_State* L, int index, sol::stack::record& tracking) {
int absolute_index = lua_absindex(L, index);
// Get the first element
int a = sol::stack::get<int>(L, absolute_index);
// Get the second element,
// in the +1 position from the first
bool b = sol::stack::get<bool>(L, absolute_index + 1);
// we use 2 slots, each of the previous takes 1
tracking.use(2);
return two_things{ a, b };
}
int push(sol::types<two_things>, lua_State* L, const two_things& things) {
int amount = sol::stack::push(L, things.a);
// amount will be 1: int pushes 1 item
amount += sol::stack::push(L, things.b);
// amount 2 now, since bool pushes a single item
// Return 2 things
return amount;
}
int main() {
std::cout << "=== customization ===" << std::endl;
std::cout << std::boolalpha;
sol::state lua;
lua.open_libraries(sol::lib::base);
// Create a pass-through style of function
lua.script("function f ( a, b ) print(a, b) return a, b end");
// get the function out of Lua
sol::function f = lua["f"];
two_things things = f(two_things{ 24, false });
c_assert(things.a == 24);
c_assert(things.b == false);
// things.a == 24
// things.b == true
std::cout << "things.a: " << things.a << std::endl;
std::cout << "things.b: " << things.b << std::endl;
std::cout << std::endl;
return 0;
}

2
include/sol/as_args.hpp
View File

@ -39,7 +39,7 @@ namespace sol {
namespace stack {
template <typename T>
struct pusher<as_args_t<T>> {
struct unqualified_pusher<as_args_t<T>> {
int push(lua_State* L, const as_args_t<T>& e) {
int p = 0;
for (const auto& i : e.src) {

2
include/sol/as_returns.hpp
View File

@ -40,7 +40,7 @@ namespace sol {
namespace stack {
template <typename T>
struct pusher<as_returns_t<T>> {
struct unqualified_pusher<as_returns_t<T>> {
int push(lua_State* L, const as_returns_t<T>& e) {
auto& src = detail::unwrap(e.src);
int p = 0;

6
include/sol/compatibility/version.hpp
View File

@ -49,6 +49,12 @@
#endif // sol luajit
#endif // luajit
#if SOL_LUAJIT && SOL_LUAJIT_VERSION >= 20100
#if !defined(SOL_EXCEPTIONS_SAFE_PROPAGATION) && (!defined(SOL_EXCEPTIONS_ALWAYS_UNSAFE) && !(SOL_EXCEPTIONS_ALWAYS_UNSAFE))
#define SOL_EXCEPTIONS_SAFE_PROPAGATION 1
#endif // Do not catch (...) clauses
#endif // LuaJIT beta 02.01.00 have better exception handling on all platforms since beta3
#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 502
#define SOL_LUA_VERSION LUA_VERSION_NUM
#elif defined(LUA_VERSION_NUM) && LUA_VERSION_NUM == 501

4
include/sol/forward.hpp
View File

@ -198,6 +198,10 @@ namespace sol {
template <typename T>
bool weak_derive<T>::value = false;
namespace stack {
struct record;
}
} // namespace sol
#define SOL_BASE_CLASSES(T, ...) \

68
include/sol/function_types.hpp
View File

@ -42,7 +42,7 @@ namespace sol {
namespace stack {
template <typename... Sigs>
struct pusher<function_sig<Sigs...>> {
struct unqualified_pusher<function_sig<Sigs...>> {
template <bool is_yielding, typename... Sig, typename Fx, typename... Args>
static void select_convertible(std::false_type, types<Sig...>, lua_State* L, Fx&& fx, Args&&... args) {
typedef std::remove_pointer_t<std::decay_t<Fx>> clean_fx;
@ -244,24 +244,24 @@ namespace sol {
};
template <typename T>
struct pusher<yielding_t<T>> {
struct unqualified_pusher<yielding_t<T>> {
template <typename... Args>
static int push(lua_State* L, const yielding_t<T>& f, Args&&... args) {
pusher<function_sig<>> p{};
unqualified_pusher<function_sig<>> p{};
(void)p;
return p.push(L, detail::yield_tag, f.func, std::forward<Args>(args)...);
}
template <typename... Args>
static int push(lua_State* L, yielding_t<T>&& f, Args&&... args) {
pusher<function_sig<>> p{};
unqualified_pusher<function_sig<>> p{};
(void)p;
return p.push(L, detail::yield_tag, f.func, std::forward<Args>(args)...);
}
};
template <typename T, typename... Args>
struct pusher<function_arguments<T, Args...>> {
struct unqualified_pusher<function_arguments<T, Args...>> {
template <std::size_t... I, typename FP>
static int push_func(std::index_sequence<I...>, lua_State* L, FP&& fp) {
return stack::push<T>(L, std::get<I>(std::forward<FP>(fp).arguments)...);
@ -277,28 +277,28 @@ namespace sol {
};
template <typename Signature>
struct pusher<std::function<Signature>> {
struct unqualified_pusher<std::function<Signature>> {
static int push(lua_State* L, const std::function<Signature>& fx) {
return pusher<function_sig<Signature>>{}.push(L, fx);
return unqualified_pusher<function_sig<Signature>>{}.push(L, fx);
}
static int push(lua_State* L, std::function<Signature>&& fx) {
return pusher<function_sig<Signature>>{}.push(L, std::move(fx));
return unqualified_pusher<function_sig<Signature>>{}.push(L, std::move(fx));
}
};
template <typename Signature>
struct pusher<Signature, std::enable_if_t<std::is_member_pointer<Signature>::value>> {
struct unqualified_pusher<Signature, std::enable_if_t<std::is_member_pointer<Signature>::value>> {
template <typename F, typename... Args>
static int push(lua_State* L, F&& f, Args&&... args) {
pusher<function_sig<>> p{};
unqualified_pusher<function_sig<>> p{};
(void)p;
return p.push(L, std::forward<F>(f), std::forward<Args>(args)...);
}
};
template <typename Signature>
struct pusher<Signature, std::enable_if_t<meta::all<std::is_function<std::remove_pointer_t<Signature>>, meta::neg<std::is_same<Signature, lua_CFunction>>, meta::neg<std::is_same<Signature, std::remove_pointer_t<lua_CFunction>>>
struct unqualified_pusher<Signature, std::enable_if_t<meta::all<std::is_function<std::remove_pointer_t<Signature>>, meta::neg<std::is_same<Signature, lua_CFunction>>, meta::neg<std::is_same<Signature, std::remove_pointer_t<lua_CFunction>>>
#if defined(SOL_NOEXCEPT_FUNCTION_TYPE) && SOL_NOEXCEPT_FUNCTION_TYPE
,
meta::neg<std::is_same<Signature, detail::lua_CFunction_noexcept>>, meta::neg<std::is_same<Signature, std::remove_pointer_t<detail::lua_CFunction_noexcept>>>
@ -306,29 +306,29 @@ namespace sol {
>::value>> {
template <typename F>
static int push(lua_State* L, F&& f) {
return pusher<function_sig<>>{}.push(L, std::forward<F>(f));
return unqualified_pusher<function_sig<>>{}.push(L, std::forward<F>(f));
}
};
template <typename... Functions>
struct pusher<overload_set<Functions...>> {
struct unqualified_pusher<overload_set<Functions...>> {
static int push(lua_State* L, overload_set<Functions...>&& set) {
// TODO: yielding
typedef function_detail::overloaded_function<0, Functions...> F;
pusher<function_sig<>>{}.set_fx<false, F>(L, std::move(set.functions));
unqualified_pusher<function_sig<>>{}.set_fx<false, F>(L, std::move(set.functions));
return 1;
}
static int push(lua_State* L, const overload_set<Functions...>& set) {
// TODO: yielding
typedef function_detail::overloaded_function<0, Functions...> F;
pusher<function_sig<>>{}.set_fx<false, F>(L, set.functions);
unqualified_pusher<function_sig<>>{}.set_fx<false, F>(L, set.functions);
return 1;
}
};
template <typename T>
struct pusher<protect_t<T>> {
struct unqualified_pusher<protect_t<T>> {
static int push(lua_State* L, protect_t<T>&& pw) {
lua_CFunction cf = call_detail::call_user<void, false, false, protect_t<T>, 2>;
int upvalues = 0;
@ -347,7 +347,7 @@ namespace sol {
};
template <typename F, typename G>
struct pusher<property_wrapper<F, G>, std::enable_if_t<!std::is_void<F>::value && !std::is_void<G>::value>> {
struct unqualified_pusher<property_wrapper<F, G>, std::enable_if_t<!std::is_void<F>::value && !std::is_void<G>::value>> {
static int push(lua_State* L, property_wrapper<F, G>&& pw) {
return stack::push(L, overload(std::move(pw.read), std::move(pw.write)));
}
@ -357,7 +357,7 @@ namespace sol {
};
template <typename F>
struct pusher<property_wrapper<F, void>> {
struct unqualified_pusher<property_wrapper<F, void>> {
static int push(lua_State* L, property_wrapper<F, void>&& pw) {
return stack::push(L, std::move(pw.read));
}
@ -367,7 +367,7 @@ namespace sol {
};
template <typename F>
struct pusher<property_wrapper<void, F>> {
struct unqualified_pusher<property_wrapper<void, F>> {
static int push(lua_State* L, property_wrapper<void, F>&& pw) {
return stack::push(L, std::move(pw.write));
}
@ -377,7 +377,7 @@ namespace sol {
};
template <typename T>
struct pusher<var_wrapper<T>> {
struct unqualified_pusher<var_wrapper<T>> {
static int push(lua_State* L, var_wrapper<T>&& vw) {
return stack::push(L, std::move(vw.value));
}
@ -387,34 +387,34 @@ namespace sol {
};
template <typename... Functions>
struct pusher<factory_wrapper<Functions...>> {
struct unqualified_pusher<factory_wrapper<Functions...>> {
static int push(lua_State* L, const factory_wrapper<Functions...>& fw) {
typedef function_detail::overloaded_function<0, Functions...> F;
pusher<function_sig<>>{}.set_fx<false, F>(L, fw.functions);
unqualified_pusher<function_sig<>>{}.set_fx<false, F>(L, fw.functions);
return 1;
}
static int push(lua_State* L, factory_wrapper<Functions...>&& fw) {
typedef function_detail::overloaded_function<0, Functions...> F;
pusher<function_sig<>>{}.set_fx<false, F>(L, std::move(fw.functions));
unqualified_pusher<function_sig<>>{}.set_fx<false, F>(L, std::move(fw.functions));
return 1;
}
static int push(lua_State* L, const factory_wrapper<Functions...>& set, function_detail::call_indicator) {
typedef function_detail::overloaded_function<1, Functions...> F;
pusher<function_sig<>>{}.set_fx<false, F>(L, set.functions);
unqualified_pusher<function_sig<>>{}.set_fx<false, F>(L, set.functions);
return 1;
}
static int push(lua_State* L, factory_wrapper<Functions...>&& set, function_detail::call_indicator) {
typedef function_detail::overloaded_function<1, Functions...> F;
pusher<function_sig<>>{}.set_fx<false, F>(L, std::move(set.functions));
unqualified_pusher<function_sig<>>{}.set_fx<false, F>(L, std::move(set.functions));
return 1;
}
};
template <>
struct pusher<no_construction> {
struct unqualified_pusher<no_construction> {
static int push(lua_State* L, no_construction) {
lua_CFunction cf = &function_detail::no_construction_error;
return stack::push(L, cf);
@ -426,7 +426,7 @@ namespace sol {
};
template <typename T, typename... Lists>
struct pusher<detail::tagged<T, constructor_list<Lists...>>> {
struct unqualified_pusher<detail::tagged<T, constructor_list<Lists...>>> {
static int push(lua_State* L, detail::tagged<T, constructor_list<Lists...>>) {
lua_CFunction cf = call_detail::construct<T, detail::default_safe_function_calls, true, Lists...>;
return stack::push(L, cf);
@ -439,7 +439,7 @@ namespace sol {
};
template <typename L0, typename... Lists>
struct pusher<constructor_list<L0, Lists...>> {
struct unqualified_pusher<constructor_list<L0, Lists...>> {
typedef constructor_list<L0, Lists...> cl_t;
static int push(lua_State* L, cl_t cl) {
typedef typename meta::bind_traits<L0>::return_type T;
@ -448,7 +448,7 @@ namespace sol {
};
template <typename T, typename... Fxs>
struct pusher<detail::tagged<T, constructor_wrapper<Fxs...>>> {
struct unqualified_pusher<detail::tagged<T, constructor_wrapper<Fxs...>>> {
template <typename C>
static int push(lua_State* L, C&& c) {
lua_CFunction cf = call_detail::call_user<T, false, false, constructor_wrapper<Fxs...>, 2>;
@ -460,7 +460,7 @@ namespace sol {
};
template <typename F, typename... Fxs>
struct pusher<constructor_wrapper<F, Fxs...>> {
struct unqualified_pusher<constructor_wrapper<F, Fxs...>> {
template <typename C>
static int push(lua_State* L, C&& c) {
typedef typename meta::bind_traits<F>::template arg_at<0> arg0;
@ -470,7 +470,7 @@ namespace sol {
};
template <typename T>
struct pusher<detail::tagged<T, destructor_wrapper<void>>> {
struct unqualified_pusher<detail::tagged<T, destructor_wrapper<void>>> {
static int push(lua_State* L, destructor_wrapper<void>) {
lua_CFunction cf = detail::usertype_alloc_destruct<T>;
return stack::push(L, cf);
@ -478,7 +478,7 @@ namespace sol {
};
template <typename T, typename Fx>
struct pusher<detail::tagged<T, destructor_wrapper<Fx>>> {
struct unqualified_pusher<detail::tagged<T, destructor_wrapper<Fx>>> {
static int push(lua_State* L, destructor_wrapper<Fx>&& c) {
lua_CFunction cf = call_detail::call_user<T, false, false, destructor_wrapper<Fx>, 2>;
int upvalues = 0;
@ -497,7 +497,7 @@ namespace sol {
};
template <typename Fx>
struct pusher<destructor_wrapper<Fx>> {
struct unqualified_pusher<destructor_wrapper<Fx>> {
static int push(lua_State* L, destructor_wrapper<Fx>&& c) {
lua_CFunction cf = call_detail::call_user<void, false, false, destructor_wrapper<Fx>, 2>;
int upvalues = 0;
@ -516,7 +516,7 @@ namespace sol {
};
template <typename F, typename... Filters>
struct pusher<filter_wrapper<F, Filters...>> {
struct unqualified_pusher<filter_wrapper<F, Filters...>> {
typedef filter_wrapper<F, Filters...> P;
static int push(lua_State* L, const P& p) {

2
include/sol/protected_function_result.hpp
View File

@ -211,7 +211,7 @@ namespace sol {
namespace stack {
template <>
struct pusher<protected_function_result> {
struct unqualified_pusher<protected_function_result> {
static int push(lua_State* L, const protected_function_result& pfr) {
#if defined(SOL_SAFE_STACK_CHECK) && SOL_SAFE_STACK_CHECK
luaL_checkstack(L, static_cast<int>(pfr.pop_count()), detail::not_enough_stack_space_generic);

2
include/sol/proxy.hpp
View File

@ -253,7 +253,7 @@ namespace sol {
namespace stack {
template <typename Table, typename Key>
struct pusher<proxy<Table, Key>> {
struct unqualified_pusher<proxy<Table, Key>> {
static int push(lua_State* L, const proxy<Table, Key>& p) {
reference r = p;
return r.push(L);

2
include/sol/stack.hpp
View File

@ -244,7 +244,7 @@ namespace sol {
}
inline void luajit_exception_handler(lua_State* L, int (*handler)(lua_State*, lua_CFunction) = detail::c_trampoline) {
#if defined(SOL_LUAJIT) && !defined(SOL_EXCEPTIONS_SAFE_PROPAGATION)
#if defined(SOL_LUAJIT) && (!defined(SOL_EXCEPTIONS_SAFE_PROPAGATION) || !(SOL_EXCEPTIONS_SAFE_PROPAGATION))
if (L == nullptr) {
return;
}

55
include/sol/stack_check_get_qualified.hpp
View File

@ -26,17 +26,60 @@
#include "stack_core.hpp"
#include "stack_check_get_unqualified.hpp"
#include "optional.hpp"
namespace sol {
namespace stack {
namespace sol { namespace stack {
template <typename T, typename C>
struct qualified_check_getter {
typedef decltype(stack_detail::unchecked_get<T>(nullptr, -1, std::declval<record&>())) R;
template <typename Handler>
static decltype(auto) get(lua_State* L, int index, Handler&& handler, record& tracking) {
return stack::unqualified_check_get<T>(L, index, std::forward<Handler>(handler), tracking);
static optional<R> get(lua_State* L, int index, Handler&& handler, record& tracking) {
if (!check<T>(L, index, std::forward<Handler>(handler))) {
tracking.use(static_cast<int>(!lua_isnone(L, index)));
return nullopt;
}
return stack_detail::unchecked_get<T>(L, index, tracking);
}
};
}
} // namespace sol::stack
template <typename T>
struct qualified_check_getter<T, std::enable_if_t<is_lua_reference<T>::value>> {
template <typename Handler>
static optional<T> get(lua_State* L, int index, Handler&& handler, record& tracking) {
// actually check if it's none here, otherwise
// we'll have a none object inside an optional!
bool success = lua_isnoneornil(L, index) == 0 && stack::check<T>(L, index, no_panic);
if (!success) {
// expected type, actual type
tracking.use(static_cast<int>(success));
handler(L, index, type::poly, type_of(L, index), "");
return nullopt;
}
return stack_detail::unchecked_get<T>(L, index, tracking);
}
};
template <typename T>
struct qualified_getter<optional<T>> {
static decltype(auto) get(lua_State* L, int index, record& tracking) {
return check_get<T>(L, index, no_panic, tracking);
}
};
#if defined(SOL_CXX17_FEATURES) && SOL_CXX17_FEATURES
template <typename T>
struct qualified_getter<std::optional<T>> {
static std::optional<T> get(lua_State* L, int index, record& tracking) {
if (!check<T>(L, index, no_panic)) {
tracking.use(static_cast<int>(!lua_isnone(L, index)));
return std::nullopt;
}
return stack_detail::unchecked_get<T>(L, index, tracking);
}
};
#endif // C++17 features
}} // namespace sol::stack
#endif // SOL_STACK_CHECK_QUALIFIED_GET_HPP

12
include/sol/stack_check_get_unqualified.hpp
View File

@ -40,7 +40,7 @@
namespace sol {
namespace stack {
template <typename T, typename>
struct check_getter {
struct unqualified_check_getter {
typedef decltype(stack_detail::unchecked_unqualified_get<T>(nullptr, -1, std::declval<record&>())) R;
template <typename Handler>
@ -54,7 +54,7 @@ namespace stack {
};
template <typename T>
struct check_getter<T, std::enable_if_t<is_lua_reference<T>::value>> {
struct unqualified_check_getter<T, std::enable_if_t<is_lua_reference<T>::value>> {
template <typename Handler>
static optional<T> get(lua_State* L, int index, Handler&& handler, record& tracking) {
// actually check if it's none here, otherwise
@ -71,7 +71,7 @@ namespace stack {
};
template <typename T>
struct check_getter<T, std::enable_if_t<std::is_integral<T>::value && lua_type_of<T>::value == type::number>> {
struct unqualified_check_getter<T, std::enable_if_t<std::is_integral<T>::value && lua_type_of<T>::value == type::number>> {
template <typename Handler>
static optional<T> get(lua_State* L, int index, Handler&& handler, record& tracking) {
#if SOL_LUA_VERSION >= 503
@ -102,7 +102,7 @@ namespace stack {
};
template <typename T>
struct check_getter<T, std::enable_if_t<std::is_enum<T>::value && !meta::any_same<T, meta_function, type>::value>> {
struct unqualified_check_getter<T, std::enable_if_t<std::is_enum<T>::value && !meta::any_same<T, meta_function, type>::value>> {
template <typename Handler>
static optional<T> get(lua_State* L, int index, Handler&& handler, record& tracking) {
int isnum = 0;
@ -119,7 +119,7 @@ namespace stack {
};
template <typename T>
struct check_getter<T, std::enable_if_t<std::is_floating_point<T>::value>> {
struct unqualified_check_getter<T, std::enable_if_t<std::is_floating_point<T>::value>> {
template <typename Handler>
static optional<T> get(lua_State* L, int index, Handler&& handler, record& tracking) {
int isnum = 0;
@ -156,7 +156,7 @@ namespace stack {
#if defined(SOL_STD_VARIANT) && SOL_STD_VARIANT
template <typename... Tn>
struct check_getter<std::variant<Tn...>> {
struct unqualified_check_getter<std::variant<Tn...>> {
typedef std::variant<Tn...> V;
typedef std::variant_size<V> V_size;
typedef std::integral_constant<bool, V_size::value == 0> V_is_empty;

16
include/sol/stack_check_unqualified.hpp
View File

@ -38,8 +38,7 @@
#endif // SOL_STD_VARIANT
#endif // SOL_CXX17_FEATURES
namespace sol {
namespace stack {
namespace sol { namespace stack {
namespace stack_detail {
template <typename T, bool poptable = true>
inline bool check_metatable(lua_State* L, int index = -2) {
@ -95,7 +94,12 @@ namespace stack {
};
template <typename T, type expected, typename C>
struct qualified_checker : unqualified_checker<meta::unqualified_t<T>, lua_type_of<meta::unqualified_t<T>>::value, C> {};
struct qualified_checker {
template <typename Handler>
static bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
return stack::unqualified_check<T>(L, index, std::forward<Handler>(handler), tracking);
}
};
template <typename T>
struct unqualified_checker<T, type::number, std::enable_if_t<std::is_integral<T>::value>> {
@ -459,7 +463,8 @@ namespace stack {
handler(L, index, type::userdata, indextype, "value is not a valid userdata");
return false;
}
if (meta::any<std::is_same<T, lightuserdata_value>, std::is_same<T, userdata_value>, std::is_same<T, userdata>, std::is_same<T, lightuserdata>>::value)
if (meta::any<std::is_same<T, lightuserdata_value>, std::is_same<T, userdata_value>, std::is_same<T, userdata>, std::is_same<T, lightuserdata>>::
value)
return true;
if (lua_getmetatable(L, index) == 0) {
return true;
@ -668,7 +673,6 @@ namespace stack {
#endif // SOL_STD_VARIANT
#endif // SOL_CXX17_FEATURES
}
} // namespace sol::stack
}} // namespace sol::stack
#endif // SOL_STACK_CHECK_UNQUALIFIED_HPP

27
include/sol/stack_core.hpp
View File

@ -48,6 +48,7 @@
namespace sol {
namespace detail {
struct with_function_tag {};
struct as_reference_tag {};
template <typename T>
struct as_pointer_tag {};
@ -570,7 +571,7 @@ namespace sol {
template <typename T, typename = void>
struct popper;
template <typename T, typename = void>
struct pusher;
struct unqualified_pusher;
template <typename T, type = lua_type_of<T>::value, typename = void>
struct unqualified_checker;
template <typename T, type = lua_type_of<T>::value, typename = void>
@ -578,7 +579,7 @@ namespace sol {
template <typename T, typename = void>
struct userdata_checker;
template <typename T, typename = void>
struct check_getter;
struct unqualified_check_getter;
template <typename T, typename = void>
struct qualified_check_getter;
@ -613,7 +614,8 @@ namespace sol {
struct is_adl_sol_lua_get {
private:
template <typename C>
static meta::sfinae_yes_t test(decltype(sol_lua_get(types<C>(), static_cast<lua_State*>(nullptr), -1, std::declval<stack::record>()))*);
static meta::sfinae_yes_t test(
std::remove_reference_t<decltype(sol_lua_get(types<C>(), static_cast<lua_State*>(nullptr), -1, std::declval<stack::record&>()))>*);
template <typename C>
static meta::sfinae_no_t test(...);
@ -625,8 +627,8 @@ namespace sol {
struct is_adl_sol_lua_check {
private:
template <typename C>
static meta::sfinae_yes_t test(
decltype(sol_lua_check(types<C>(), static_cast<lua_State*>(nullptr), -1, no_panic, std::declval<stack::record>()))*);
static meta::sfinae_yes_t test(std::remove_reference_t<decltype(
sol_lua_check(types<C>(), static_cast<lua_State*>(nullptr), -1, no_panic, std::declval<stack::record&>()))>*);
template <typename C>
static meta::sfinae_no_t test(...);
@ -638,8 +640,8 @@ namespace sol {
struct is_adl_sol_lua_check_get {
private:
template <typename C>
static meta::sfinae_yes_t test(
decltype(sol_lua_check_get(types<C>(), static_cast<lua_State*>(nullptr), -1, no_panic, std::declval<stack::record>()))*);
static meta::sfinae_yes_t test(std::remove_reference_t<decltype(
sol_lua_check_get(types<C>(), static_cast<lua_State*>(nullptr), -1, no_panic, std::declval<stack::record&>()))>*);
template <typename C>
static meta::sfinae_no_t test(...);
@ -651,7 +653,7 @@ namespace sol {
struct is_adl_sol_lua_push {
private:
template <typename... C>
static meta::sfinae_yes_t test(decltype(sol_lua_push(static_cast<lua_State*>(nullptr), std::declval<C>()...))*);
static meta::sfinae_yes_t test(std::remove_reference_t<decltype(sol_lua_push(static_cast<lua_State*>(nullptr), std::declval<C>()...))>*);
template <typename... C>
static meta::sfinae_no_t test(...);
@ -663,7 +665,8 @@ namespace sol {
struct is_adl_sol_lua_push_exact {
private:
template <typename... C>
static meta::sfinae_yes_t test(decltype(sol_lua_push(types<T>(), static_cast<lua_State*>(nullptr), std::declval<C>()...))*);
static meta::sfinae_yes_t test(
std::remove_reference_t<decltype(sol_lua_push(types<T>(), static_cast<lua_State*>(nullptr), std::declval<C>()...))>*);
template <typename... C>
static meta::sfinae_no_t test(...);
@ -812,7 +815,7 @@ namespace sol {
return sol_lua_push(L, std::forward<T>(t), std::forward<Args>(args)...);
}
else {
pusher<Tu> p{};
unqualified_pusher<Tu> p{};
(void)p;
return p.push(L, std::forward<T>(t), std::forward<Args>(args)...);
}
@ -832,7 +835,7 @@ namespace sol {
return sol_lua_push(L, std::forward<Arg>(arg), std::forward<Args>(args)...);
}
else {
pusher<Tu> p{};
unqualified_pusher<Tu> p{};
(void)p;
return p.push(L, std::forward<Arg>(arg), std::forward<Args>(args)...);
}
@ -974,7 +977,7 @@ namespace sol {
return sol_lua_check_get(types<Tu>(), L, index, std::forward<Handler>(handler), tracking);
}
else {
check_getter<Tu> cg{};
unqualified_check_getter<Tu> cg{};
(void)cg;
return cg.get(L, index, std::forward<Handler>(handler), tracking);
}

2
include/sol/stack_proxy.hpp
View File

@ -54,7 +54,7 @@ namespace sol {
};
template <>
struct pusher<stack_proxy> {
struct unqualified_pusher<stack_proxy> {
static int push(lua_State*, const stack_proxy& ref) {
return ref.push();
}

2
include/sol/stack_proxy_base.hpp
View File

@ -86,7 +86,7 @@ namespace sol {
};
template <>
struct pusher<stack_proxy_base> {
struct unqualified_pusher<stack_proxy_base> {
static int push(lua_State*, const stack_proxy_base& ref) {
return ref.push();
}

191
include/sol/stack_push.hpp
View File

@ -71,7 +71,7 @@ namespace sol {
}
template <typename T>
struct pusher<detail::as_value_tag<T>> {
struct unqualified_pusher<detail::as_value_tag<T>> {
template <typename F, typename... Args>
static int push_fx(lua_State* L, F&& f, Args&&... args) {
#if defined(SOL_SAFE_STACK_CHECK) && SOL_SAFE_STACK_CHECK
@ -95,14 +95,23 @@ namespace sol {
return push_fx(L, fx, std::forward<Args>(args)...);
}
template <typename Arg, typename... Args, typename = std::enable_if_t<!std::is_same_v<meta::unqualified_t<Arg>, detail::with_function_tag>>>
static int push(lua_State* L, Arg&& arg, Args&&... args) {
return push_keyed(L, usertype_traits<T>::metatable(), std::forward<Arg>(arg), std::forward<Args>(args)...);
}
static int push(lua_State* L) {
return push_keyed(L, usertype_traits<T>::metatable());
}
template <typename... Args>
static int push(lua_State* L, Args&&... args) {
return push_keyed(L, usertype_traits<T>::metatable(), std::forward<Args>(args)...);
static int push(lua_State* L, detail::with_function_tag, Args&&... args) {
return push_fx(L, std::forward<Args>(args)...);
}
};
template <typename T>
struct pusher<detail::as_pointer_tag<T>> {
struct unqualified_pusher<detail::as_pointer_tag<T>> {
typedef meta::unqualified_t<T> U;
template <typename F>
@ -124,13 +133,19 @@ namespace sol {
return push_fx(L, fx, obj);
}
static int push(lua_State* L, T* obj) {
return push_keyed(L, usertype_traits<U*>::metatable(), obj);
template <typename Arg, typename... Args, typename = std::enable_if_t<!std::is_same_v<meta::unqualified_t<Arg>, detail::with_function_tag>>>
static int push(lua_State* L, Arg&& arg, Args&&... args) {
return push_keyed(L, usertype_traits<U*>::metatable(), std::forward<Arg>(arg), std::forward<Args>(args)...);
}
template <typename... Args>
static int push(lua_State* L, detail::with_function_tag, Args&&... args) {
return push_fx(L, std::forward<Args>(args)...);
}
};
template <>
struct pusher<detail::as_reference_tag> {
struct unqualified_pusher<detail::as_reference_tag> {
template <typename T>
static int push(lua_State* L, T&& obj) {
return stack::push(L, detail::ptr(obj));
@ -138,25 +153,25 @@ namespace sol {
};
template <typename T, typename>
struct pusher {
struct unqualified_pusher {
template <typename... Args>
static int push(lua_State* L, Args&&... args) {
return pusher<detail::as_value_tag<T>>{}.push(L, std::forward<Args>(args)...);
return stack::push<detail::as_value_tag<T>>(L, std::forward<Args>(args)...);
}
};
template <typename T>
struct pusher<T*,
struct unqualified_pusher<T*,
meta::disable_if_t<meta::any<is_container<meta::unqualified_t<T>>, std::is_function<meta::unqualified_t<T>>,
is_lua_reference<meta::unqualified_t<T>>>::value>> {
template <typename... Args>
static int push(lua_State* L, Args&&... args) {
return pusher<detail::as_pointer_tag<T>>{}.push(L, std::forward<Args>(args)...);
return stack::push<detail::as_pointer_tag<T>>(L, std::forward<Args>(args)...);
}
};
template <typename T>
struct pusher<T, std::enable_if_t<is_unique_usertype<T>::value>> {
struct unqualified_pusher<T, std::enable_if_t<is_unique_usertype<T>::value>> {
typedef unique_usertype_traits<T> u_traits;
typedef typename u_traits::type P;
typedef typename u_traits::actual_type Real;
@ -202,14 +217,14 @@ namespace sol {
};
template <typename T>
struct pusher<std::reference_wrapper<T>> {
struct unqualified_pusher<std::reference_wrapper<T>> {
static int push(lua_State* L, const std::reference_wrapper<T>& t) {
return stack::push(L, std::addressof(detail::deref(t.get())));
}
};
template <typename T>
struct pusher<T, std::enable_if_t<std::is_floating_point<T>::value>> {
struct unqualified_pusher<T, std::enable_if_t<std::is_floating_point<T>::value>> {
static int push(lua_State* L, const T& value) {
#if defined(SOL_SAFE_STACK_CHECK) && SOL_SAFE_STACK_CHECK
luaL_checkstack(L, 1, detail::not_enough_stack_space_floating);
@ -220,7 +235,7 @@ namespace sol {
};
template <typename T>
struct pusher<T, std::enable_if_t<std::is_integral<T>::value>> {
struct unqualified_pusher<T, std::enable_if_t<std::is_integral<T>::value>> {
static int push(lua_State* L, const T& value) {
#if defined(SOL_SAFE_STACK_CHECK) && SOL_SAFE_STACK_CHECK
luaL_checkstack(L, 1, detail::not_enough_stack_space_integral);
@ -259,7 +274,7 @@ namespace sol {
};
template <typename T>
struct pusher<T, std::enable_if_t<std::is_enum<T>::value>> {
struct unqualified_pusher<T, std::enable_if_t<std::is_enum<T>::value>> {
static int push(lua_State* L, const T& value) {
if (std::is_same<char, std::underlying_type_t<T>>::value) {
return stack::push(L, static_cast<int>(value));
@ -269,7 +284,7 @@ namespace sol {
};
template <typename T>
struct pusher<detail::as_table_tag<T>> {
struct unqualified_pusher<detail::as_table_tag<T>> {
static int push(lua_State* L, const T& tablecont) {
typedef meta::has_key_value_pair<meta::unqualified_t<std::remove_pointer_t<T>>> has_kvp;
return push(has_kvp(), std::false_type(), L, tablecont);
@ -346,23 +361,23 @@ namespace sol {
};
template <typename T>
struct pusher<as_table_t<T>, std::enable_if_t<is_container<std::remove_pointer_t<meta::unwrap_unqualified_t<T>>>::value>> {
struct unqualified_pusher<as_table_t<T>, std::enable_if_t<is_container<std::remove_pointer_t<meta::unwrap_unqualified_t<T>>>::value>> {
static int push(lua_State* L, const T& tablecont) {
return stack::push<detail::as_table_tag<T>>(L, tablecont);
}
};
template <typename T>
struct pusher<as_table_t<T>, std::enable_if_t<!is_container<std::remove_pointer_t<meta::unwrap_unqualified_t<T>>>::value>> {
struct unqualified_pusher<as_table_t<T>, std::enable_if_t<!is_container<std::remove_pointer_t<meta::unwrap_unqualified_t<T>>>::value>> {
static int push(lua_State* L, const T& v) {
return stack::push(L, v);
}
};
template <typename T>
struct pusher<nested<T>, std::enable_if_t<is_container<std::remove_pointer_t<meta::unwrap_unqualified_t<T>>>::value>> {
struct unqualified_pusher<nested<T>, std::enable_if_t<is_container<std::remove_pointer_t<meta::unwrap_unqualified_t<T>>>::value>> {
static int push(lua_State* L, const T& tablecont) {
pusher<detail::as_table_tag<T>> p{};
unqualified_pusher<detail::as_table_tag<T>> p{};
// silence annoying VC++ warning
(void)p;
return p.push(std::true_type(), L, tablecont);
@ -370,9 +385,9 @@ namespace sol {
};
template <typename T>
struct pusher<nested<T>, std::enable_if_t<!is_container<std::remove_pointer_t<meta::unwrap_unqualified_t<T>>>::value>> {
struct unqualified_pusher<nested<T>, std::enable_if_t<!is_container<std::remove_pointer_t<meta::unwrap_unqualified_t<T>>>::value>> {
static int push(lua_State* L, const T& tablecont) {
pusher<meta::unqualified_t<T>> p{};
unqualified_pusher<meta::unqualified_t<T>> p{};
// silence annoying VC++ warning
(void)p;
return p.push(L, tablecont);
@ -380,9 +395,9 @@ namespace sol {
};
template <typename T>
struct pusher<std::initializer_list<T>> {
struct unqualified_pusher<std::initializer_list<T>> {
static int push(lua_State* L, const std::initializer_list<T>& il) {
pusher<detail::as_table_tag<std::initializer_list<T>>> p{};
unqualified_pusher<detail::as_table_tag<std::initializer_list<T>>> p{};
// silence annoying VC++ warning
(void)p;
return p.push(L, il);
@ -390,7 +405,7 @@ namespace sol {
};
template <typename T>
struct pusher<T, std::enable_if_t<is_lua_reference<T>::value>> {
struct unqualified_pusher<T, std::enable_if_t<is_lua_reference<T>::value>> {
static int push(lua_State* L, const T& ref) {
return ref.push(L);
}
@ -401,7 +416,7 @@ namespace sol {
};
template <>
struct pusher<bool> {
struct unqualified_pusher<bool> {
static int push(lua_State* L, bool b) {
#if defined(SOL_SAFE_STACK_CHECK) && SOL_SAFE_STACK_CHECK
luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
@ -412,7 +427,7 @@ namespace sol {
};
template <>
struct pusher<lua_nil_t> {
struct unqualified_pusher<lua_nil_t> {
static int push(lua_State* L, lua_nil_t) {
#if defined(SOL_SAFE_STACK_CHECK) && SOL_SAFE_STACK_CHECK
luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
@ -423,14 +438,14 @@ namespace sol {
};
template <>
struct pusher<stack_count> {
struct unqualified_pusher<stack_count> {
static int push(lua_State*, stack_count st) {
return st.count;
}
};
template <>
struct pusher<metatable_t> {
struct unqualified_pusher<metatable_t> {
static int push(lua_State* L, metatable_t) {
#if defined(SOL_SAFE_STACK_CHECK) && SOL_SAFE_STACK_CHECK
luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
@ -441,7 +456,7 @@ namespace sol {
};
template <>
struct pusher<std::remove_pointer_t<lua_CFunction>> {
struct unqualified_pusher<std::remove_pointer_t<lua_CFunction>> {
static int push(lua_State* L, lua_CFunction func, int n = 0) {
#if defined(SOL_SAFE_STACK_CHECK) && SOL_SAFE_STACK_CHECK
luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
@ -452,7 +467,7 @@ namespace sol {
};
template <>
struct pusher<lua_CFunction> {
struct unqualified_pusher<lua_CFunction> {
static int push(lua_State* L, lua_CFunction func, int n = 0) {
#if defined(SOL_SAFE_STACK_CHECK) && SOL_SAFE_STACK_CHECK
luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
@ -464,7 +479,7 @@ namespace sol {
#if defined(SOL_NOEXCEPT_FUNCTION_TYPE) && SOL_NOEXCEPT_FUNCTION_TYPE
template <>
struct pusher<std::remove_pointer_t<detail::lua_CFunction_noexcept>> {
struct unqualified_pusher<std::remove_pointer_t<detail::lua_CFunction_noexcept>> {
static int push(lua_State* L, detail::lua_CFunction_noexcept func, int n = 0) {
#if defined(SOL_SAFE_STACK_CHECK) && SOL_SAFE_STACK_CHECK
luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
@ -475,7 +490,7 @@ namespace sol {
};
template <>
struct pusher<detail::lua_CFunction_noexcept> {
struct unqualified_pusher<detail::lua_CFunction_noexcept> {
static int push(lua_State* L, detail::lua_CFunction_noexcept func, int n = 0) {
#if defined(SOL_SAFE_STACK_CHECK) && SOL_SAFE_STACK_CHECK
luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
@ -487,7 +502,7 @@ namespace sol {
#endif // noexcept function type
template <>
struct pusher<c_closure> {
struct unqualified_pusher<c_closure> {
static int push(lua_State* L, c_closure cc) {
#if defined(SOL_SAFE_STACK_CHECK) && SOL_SAFE_STACK_CHECK
luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
@ -498,7 +513,7 @@ namespace sol {
};
template <typename Arg, typename... Args>
struct pusher<closure<Arg, Args...>> {
struct unqualified_pusher<closure<Arg, Args...>> {
template <std::size_t... I, typename T>
static int push(std::index_sequence<I...>, lua_State* L, T&& c) {
using f_tuple = decltype(std::forward<T>(c).upvalues);
@ -513,7 +528,7 @@ namespace sol {
};
template <>
struct pusher<void*> {
struct unqualified_pusher<void*> {
static int push(lua_State* L, void* userdata) {
#if defined(SOL_SAFE_STACK_CHECK) && SOL_SAFE_STACK_CHECK
luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
@ -524,7 +539,7 @@ namespace sol {
};
template <>
struct pusher<const void*> {
struct unqualified_pusher<const void*> {
static int push(lua_State* L, const void* userdata) {
#if defined(SOL_SAFE_STACK_CHECK) && SOL_SAFE_STACK_CHECK
luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
@ -535,7 +550,7 @@ namespace sol {
};
template <>
struct pusher<lightuserdata_value> {
struct unqualified_pusher<lightuserdata_value> {
static int push(lua_State* L, lightuserdata_value userdata) {
#if defined(SOL_SAFE_STACK_CHECK) && SOL_SAFE_STACK_CHECK
luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
@ -546,7 +561,7 @@ namespace sol {
};
template <typename T>
struct pusher<light<T>> {
struct unqualified_pusher<light<T>> {
static int push(lua_State* L, light<T> l) {
#if defined(SOL_SAFE_STACK_CHECK) && SOL_SAFE_STACK_CHECK
luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
@ -557,7 +572,7 @@ namespace sol {
};
template <typename T>
struct pusher<user<T>> {
struct unqualified_pusher<user<T>> {
template <bool with_meta = true, typename Key, typename... Args>
static int push_with(lua_State* L, Key&& name, Args&&... args) {
#if defined(SOL_SAFE_STACK_CHECK) && SOL_SAFE_STACK_CHECK
@ -622,7 +637,7 @@ namespace sol {
};
template <>
struct pusher<userdata_value> {
struct unqualified_pusher<userdata_value> {
static int push(lua_State* L, userdata_value data) {
#if defined(SOL_SAFE_STACK_CHECK) && SOL_SAFE_STACK_CHECK
luaL_checkstack(L, 1, detail::not_enough_stack_space_userdata);
@ -634,7 +649,7 @@ namespace sol {
};
template <>
struct pusher<const char*> {
struct unqualified_pusher<const char*> {
static int push_sized(lua_State* L, const char* str, std::size_t len) {
#if defined(SOL_SAFE_STACK_CHECK) && SOL_SAFE_STACK_CHECK
luaL_checkstack(L, 1, detail::not_enough_stack_space_string);
@ -659,34 +674,34 @@ namespace sol {
};
template <>
struct pusher<char*> {
struct unqualified_pusher<char*> {
static int push_sized(lua_State* L, const char* str, std::size_t len) {
pusher<const char*> p{};
unqualified_pusher<const char*> p{};
(void)p;
return p.push_sized(L, str, len);
}
static int push(lua_State* L, const char* str) {
pusher<const char*> p{};
unqualified_pusher<const char*> p{};
(void)p;
return p.push(L, str);
}
static int push(lua_State* L, const char* strb, const char* stre) {
pusher<const char*> p{};
unqualified_pusher<const char*> p{};
(void)p;
return p.push(L, strb, stre);
}
static int push(lua_State* L, const char* str, std::size_t len) {
pusher<const char*> p{};
unqualified_pusher<const char*> p{};
(void)p;
return p.push(L, str, len);
}
};
template <size_t N>
struct pusher<char[N]> {
struct unqualified_pusher<char[N]> {
static int push(lua_State* L, const char (&str)[N]) {
#if defined(SOL_SAFE_STACK_CHECK) && SOL_SAFE_STACK_CHECK
luaL_checkstack(L, 1, detail::not_enough_stack_space_string);
@ -705,7 +720,7 @@ namespace sol {
};
template <>
struct pusher<char> {
struct unqualified_pusher<char> {
static int push(lua_State* L, char c) {
const char str[2] = { c, '\0' };
return stack::push(L, str, 1);
@ -713,7 +728,7 @@ namespace sol {
};
template <typename Traits, typename Al>
struct pusher<std::basic_string<char, Traits, Al>> {
struct unqualified_pusher<std::basic_string<char, Traits, Al>> {
static int push(lua_State* L, const std::basic_string<char, Traits, Al>& str) {
#if defined(SOL_SAFE_STACK_CHECK) && SOL_SAFE_STACK_CHECK
luaL_checkstack(L, 1, detail::not_enough_stack_space_string);
@ -732,7 +747,7 @@ namespace sol {
};
template <typename Ch, typename Traits>
struct pusher<basic_string_view<Ch, Traits>> {
struct unqualified_pusher<basic_string_view<Ch, Traits>> {
static int push(lua_State* L, const basic_string_view<Ch, Traits>& sv) {
return stack::push(L, sv.data(), sv.length());
}
@ -743,7 +758,7 @@ namespace sol {
};
template <>
struct pusher<meta_function> {
struct unqualified_pusher<meta_function> {
static int push(lua_State* L, meta_function m) {
#if defined(SOL_SAFE_STACK_CHECK) && SOL_SAFE_STACK_CHECK
luaL_checkstack(L, 1, detail::not_enough_stack_space_meta_function_name);
@ -755,7 +770,7 @@ namespace sol {
};
template <>
struct pusher<absolute_index> {
struct unqualified_pusher<absolute_index> {
static int push(lua_State* L, absolute_index ai) {
#if defined(SOL_SAFE_STACK_CHECK) && SOL_SAFE_STACK_CHECK
luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
@ -766,7 +781,7 @@ namespace sol {
};
template <>
struct pusher<raw_index> {
struct unqualified_pusher<raw_index> {
static int push(lua_State* L, raw_index ri) {
#if defined(SOL_SAFE_STACK_CHECK) && SOL_SAFE_STACK_CHECK
luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
@ -777,7 +792,7 @@ namespace sol {
};
template <>
struct pusher<ref_index> {
struct unqualified_pusher<ref_index> {
static int push(lua_State* L, ref_index ri) {
#if defined(SOL_SAFE_STACK_CHECK) && SOL_SAFE_STACK_CHECK
luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
@ -788,7 +803,7 @@ namespace sol {
};
template <>
struct pusher<const wchar_t*> {
struct unqualified_pusher<const wchar_t*> {
static int push(lua_State* L, const wchar_t* wstr) {
return push(L, wstr, std::char_traits<wchar_t>::length(wstr));
}
@ -810,28 +825,28 @@ namespace sol {
};
template <>
struct pusher<wchar_t*> {
struct unqualified_pusher<wchar_t*> {
static int push(lua_State* L, const wchar_t* str) {
pusher<const wchar_t*> p{};
unqualified_pusher<const wchar_t*> p{};
(void)p;
return p.push(L, str);
}
static int push(lua_State* L, const wchar_t* strb, const wchar_t* stre) {
pusher<const wchar_t*> p{};
unqualified_pusher<const wchar_t*> p{};
(void)p;
return p.push(L, strb, stre);
}
static int push(lua_State* L, const wchar_t* str, std::size_t len) {
pusher<const wchar_t*> p{};
unqualified_pusher<const wchar_t*> p{};
(void)p;
return p.push(L, str, len);
}
};
template <>
struct pusher<const char16_t*> {
struct unqualified_pusher<const char16_t*> {
static int convert_into(lua_State* L, char* start, std::size_t, const char16_t* strb, const char16_t* stre) {
char* target = start;
char32_t cp = 0;
@ -888,28 +903,28 @@ namespace sol {
};
template <>
struct pusher<char16_t*> {
struct unqualified_pusher<char16_t*> {
static int push(lua_State* L, const char16_t* str) {
pusher<const char16_t*> p{};
unqualified_pusher<const char16_t*> p{};
(void)p;
return p.push(L, str);
}
static int push(lua_State* L, const char16_t* strb, const char16_t* stre) {
pusher<const char16_t*> p{};
unqualified_pusher<const char16_t*> p{};
(void)p;
return p.push(L, strb, stre);
}
static int push(lua_State* L, const char16_t* str, std::size_t len) {
pusher<const char16_t*> p{};
unqualified_pusher<const char16_t*> p{};
(void)p;
return p.push(L, str, len);
}
};
template <>
struct pusher<const char32_t*> {
struct unqualified_pusher<const char32_t*> {
static int convert_into(lua_State* L, char* start, std::size_t, const char32_t* strb, const char32_t* stre) {
char* target = start;
char32_t cp = 0;
@ -965,28 +980,28 @@ namespace sol {
};
template <>
struct pusher<char32_t*> {
struct unqualified_pusher<char32_t*> {
static int push(lua_State* L, const char32_t* str) {
pusher<const char32_t*> p{};
unqualified_pusher<const char32_t*> p{};
(void)p;
return p.push(L, str);
}
static int push(lua_State* L, const char32_t* strb, const char32_t* stre) {
pusher<const char32_t*> p{};
unqualified_pusher<const char32_t*> p{};
(void)p;
return p.push(L, strb, stre);
}
static int push(lua_State* L, const char32_t* str, std::size_t len) {
pusher<const char32_t*> p{};
unqualified_pusher<const char32_t*> p{};
(void)p;
return p.push(L, str, len);
}
};
template <size_t N>
struct pusher<wchar_t[N]> {
struct unqualified_pusher<wchar_t[N]> {
static int push(lua_State* L, const wchar_t (&str)[N]) {
return push(L, str, std::char_traits<wchar_t>::length(str));
}
@ -997,7 +1012,7 @@ namespace sol {
};
template <size_t N>
struct pusher<char16_t[N]> {
struct unqualified_pusher<char16_t[N]> {
static int push(lua_State* L, const char16_t (&str)[N]) {
return push(L, str, std::char_traits<char16_t>::length(str));
}
@ -1008,7 +1023,7 @@ namespace sol {
};
template <size_t N>
struct pusher<char32_t[N]> {
struct unqualified_pusher<char32_t[N]> {
static int push(lua_State* L, const char32_t (&str)[N]) {
return push(L, str, std::char_traits<char32_t>::length(str));
}
@ -1019,7 +1034,7 @@ namespace sol {
};
template <>
struct pusher<wchar_t> {
struct unqualified_pusher<wchar_t> {
static int push(lua_State* L, wchar_t c) {
const wchar_t str[2] = { c, '\0' };
return stack::push(L, &str[0], 1);
@ -1027,7 +1042,7 @@ namespace sol {
};
template <>
struct pusher<char16_t> {
struct unqualified_pusher<char16_t> {
static int push(lua_State* L, char16_t c) {
const char16_t str[2] = { c, '\0' };
return stack::push(L, &str[0], 1);
@ -1035,7 +1050,7 @@ namespace sol {
};
template <>
struct pusher<char32_t> {
struct unqualified_pusher<char32_t> {
static int push(lua_State* L, char32_t c) {
const char32_t str[2] = { c, '\0' };
return stack::push(L, &str[0], 1);
@ -1043,7 +1058,7 @@ namespace sol {
};
template <typename Ch, typename Traits, typename Al>
struct pusher<std::basic_string<Ch, Traits, Al>, std::enable_if_t<!std::is_same<Ch, char>::value>> {
struct unqualified_pusher<std::basic_string<Ch, Traits, Al>, std::enable_if_t<!std::is_same<Ch, char>::value>> {
static int push(lua_State* L, const std::basic_string<Ch, Traits, Al>& wstr) {
return push(L, wstr, wstr.size());
}
@ -1054,7 +1069,7 @@ namespace sol {
};
template <typename... Args>
struct pusher<std::tuple<Args...>> {
struct unqualified_pusher<std::tuple<Args...>> {
template <std::size_t... I, typename T>
static int push(std::index_sequence<I...>, lua_State* L, T&& t) {
#if defined(SOL_SAFE_STACK_CHECK) && SOL_SAFE_STACK_CHECK
@ -1072,7 +1087,7 @@ namespace sol {
};
template <typename A, typename B>
struct pusher<std::pair<A, B>> {
struct unqualified_pusher<std::pair<A, B>> {
template <typename T>
static int push(lua_State* L, T&& t) {
int pushcount = stack::push(L, std::get<0>(std::forward<T>(t)));
@ -1082,7 +1097,7 @@ namespace sol {
};
template <typename O>
struct pusher<optional<O>> {
struct unqualified_pusher<optional<O>> {
template <typename T>
static int push(lua_State* L, T&& t) {
if (t == nullopt) {
@ -1093,35 +1108,35 @@ namespace sol {
};
template <>
struct pusher<nullopt_t> {
struct unqualified_pusher<nullopt_t> {
static int push(lua_State* L, nullopt_t) {
return stack::push(L, lua_nil);
}
};
template <>
struct pusher<std::nullptr_t> {
struct unqualified_pusher<std::nullptr_t> {
static int push(lua_State* L, std::nullptr_t) {
return stack::push(L, lua_nil);
}
};
template <>
struct pusher<this_state> {
struct unqualified_pusher<this_state> {
static int push(lua_State*, const this_state&) {
return 0;
}
};
template <>
struct pusher<this_main_state> {
struct unqualified_pusher<this_main_state> {
static int push(lua_State*, const this_main_state&) {
return 0;
}
};
template <>
struct pusher<new_table> {
struct unqualified_pusher<new_table> {
static int push(lua_State* L, const new_table& nt) {
lua_createtable(L, nt.sequence_hint, nt.map_hint);
return 1;
@ -1130,7 +1145,7 @@ namespace sol {
#if defined(SOL_CXX17_FEATURES) && SOL_CXX17_FEATURES
template <typename O>
struct pusher<std::optional<O>> {
struct unqualified_pusher<std::optional<O>> {
template <typename T>
static int push(lua_State* L, T&& t) {
if (t == std::nullopt) {
@ -1158,7 +1173,7 @@ namespace sol {
} // namespace stack_detail
template <typename... Tn>
struct pusher<std::variant<Tn...>> {
struct unqualified_pusher<std::variant<Tn...>> {
static int push(lua_State* L, const std::variant<Tn...>& v) {
return std::visit(stack_detail::push_function(L), v);
}

4
include/sol/thread.hpp
View File

@ -49,7 +49,7 @@ namespace sol {
namespace stack {
template <>
struct pusher<lua_thread_state> {
struct unqualified_pusher<lua_thread_state> {
int push(lua_State*, lua_thread_state lts) {
lua_pushthread(lts.L);
return 1;
@ -66,7 +66,7 @@ namespace sol {
};
template <>
struct check_getter<lua_thread_state> {
struct unqualified_check_getter<lua_thread_state> {
template <typename Handler>
optional<lua_thread_state> get(lua_State* L, int index, Handler&& handler, record& tracking) {
lua_thread_state lts( lua_tothread(L, index) );

2
include/sol/unsafe_function_result.hpp
View File

@ -159,7 +159,7 @@ namespace sol {
namespace stack {
template <>
struct pusher<unsafe_function_result> {
struct unqualified_pusher<unsafe_function_result> {
static int push(lua_State* L, const unsafe_function_result& fr) {
int p = 0;
for (int i = 0; i < fr.return_count(); ++i) {

22
include/sol/usertype_container.hpp
View File

@ -372,22 +372,22 @@ namespace sol {
} // namespace stack_detail
template <typename T>
struct pusher<as_container_t<T>> {
struct unqualified_pusher<as_container_t<T>> {
typedef meta::unqualified_t<T> C;
static int push_lvalue(std::true_type, lua_State* L, const C& cont) {
stack_detail::metatable_setup<C*, true> fx(L);
return pusher<detail::as_pointer_tag<const C>>{}.push_fx(L, fx, detail::ptr(cont));
return stack::push<detail::as_pointer_tag<const C>>(L, detail::with_function_tag(), fx, detail::ptr(cont));
}
static int push_lvalue(std::false_type, lua_State* L, const C& cont) {
stack_detail::metatable_setup<C, true> fx(L);
return pusher<detail::as_value_tag<C>>{}.push_fx(L, fx, cont);
return stack::push<detail::as_value_tag<C>>(L, detail::with_function_tag(), fx, cont);
}
static int push_rvalue(std::true_type, lua_State* L, C&& cont) {
stack_detail::metatable_setup<C, true> fx(L);
return pusher<detail::as_value_tag<C>>{}.push_fx(L, fx, std::move(cont));
return stack::push<detail::as_value_tag<C>>(L, detail::with_function_tag(), fx, std::move(cont));
}
static int push_rvalue(std::false_type, lua_State* L, const C& cont) {
@ -404,37 +404,37 @@ namespace sol {
};
template <typename T>
struct pusher<as_container_t<T*>> {
struct unqualified_pusher<as_container_t<T*>> {
typedef std::add_pointer_t<meta::unqualified_t<std::remove_pointer_t<T>>> C;
static int push(lua_State* L, T* cont) {
stack_detail::metatable_setup<C> fx(L);
return pusher<detail::as_pointer_tag<T>>{}.push_fx(L, fx, cont);
return stack::push<detail::as_pointer_tag<T>>(L, detail::with_function_tag(), fx, cont);
}
};
template <typename T>
struct pusher<T, std::enable_if_t<meta::all<is_container<meta::unqualified_t<T>>, meta::neg<is_lua_reference<meta::unqualified_t<T>>>>::value>> {
struct unqualified_pusher<T, std::enable_if_t<meta::all<is_container<meta::unqualified_t<T>>, meta::neg<is_lua_reference<meta::unqualified_t<T>>>>::value>> {
typedef meta::unqualified_t<T> C;
static int push(lua_State* L, const T& cont) {
stack_detail::metatable_setup<C> fx(L);
return pusher<detail::as_value_tag<T>>{}.push_fx(L, fx, cont);
return stack::push<detail::as_value_tag<T>>(L, detail::with_function_tag(), fx, cont);
}
static int push(lua_State* L, T&& cont) {
stack_detail::metatable_setup<C> fx(L);
return pusher<detail::as_value_tag<T>>{}.push_fx(L, fx, std::move(cont));
return stack::push<detail::as_value_tag<T>>(L, detail::with_function_tag(), fx, std::move(cont));
}
};
template <typename T>
struct pusher<T*, std::enable_if_t<meta::all<is_container<meta::unqualified_t<T>>, meta::neg<is_lua_reference<meta::unqualified_t<T>>>>::value>> {
struct unqualified_pusher<T*, std::enable_if_t<meta::all<is_container<meta::unqualified_t<T>>, meta::neg<is_lua_reference<meta::unqualified_t<T>>>>::value>> {
typedef std::add_pointer_t<meta::unqualified_t<std::remove_pointer_t<T>>> C;
static int push(lua_State* L, T* cont) {
stack_detail::metatable_setup<C> fx(L);
return pusher<detail::as_pointer_tag<T>>{}.push_fx(L, fx, cont);
return stack::push<detail::as_pointer_tag<T>>(L, detail::with_function_tag(), fx, cont);
}
};

2
include/sol/variadic_args.hpp
View File

@ -173,7 +173,7 @@ namespace sol {
};
template <>
struct pusher<variadic_args> {
struct unqualified_pusher<variadic_args> {
static int push(lua_State* L, const variadic_args& ref) {
return ref.push(L);
}

2
include/sol/variadic_results.hpp
View File

@ -37,7 +37,7 @@ namespace sol {
namespace stack {
template <>
struct pusher<variadic_results> {
struct unqualified_pusher<variadic_results> {
int push(lua_State* L, const variadic_results& e) {
int p = 0;
for (const auto& i : e) {

8
single/include/sol/forward.hpp
View File

@ -20,8 +20,8 @@
// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
// This file was generated with a script.
// Generated 2018-12-21 06:03:11.681784 UTC
// This header was generated with sol v2.20.6 (revision c35c66b)
// Generated 2018-12-22 20:32:42.897539 UTC
// This header was generated with sol v2.20.6 (revision 88cafb2)
// https://github.com/ThePhD/sol2
#ifndef SOL_SINGLE_INCLUDE_FORWARD_HPP
@ -414,6 +414,10 @@ namespace sol {
template <typename T>
bool weak_derive<T>::value = false;
namespace stack {
struct record;
}
} // namespace sol
#define SOL_BASE_CLASSES(T, ...) \

428
single/include/sol/sol.hpp
View File

File diff suppressed because it is too large Load Diff

34
tests/runtime_tests/source/customizations.cpp
View File

@ -66,19 +66,11 @@ sol::optional<custom> sol_lua_check_get(sol::types<custom> type_tag, lua_State*
int sol_lua_push(lua_State* L, const custom& c) {
++custom::push_calls;
// ensure there's enough space for 1 more thing on the stack
lua_checkstack(L, 1);
// tell Lua we've left something on
// the stack: return what comes from pushing an integer
return sol::stack::push(L, c.bweh);
}
int sol_lua_push(sol::types<custom>, lua_State* L, const custom& c) {
++custom::exact_push_calls;
// ensure there's enough space for 1 more thing on the stack
lua_checkstack(L, 1);
// tell Lua we've left something on
// the stack: return what comes from pushing an integer
return sol::stack::push(L, c.bweh);
}
@ -118,13 +110,9 @@ bool sol_lua_check(sol::types<multi_custom>, lua_State* L, int index, Handler&&
int sol_lua_push(lua_State* L, const multi_custom& c) {
++multi_custom::push_calls;
// ensure there's enough space for 1 more thing on the stack
lua_checkstack(L, 3);
int p = sol::stack::push(L, c.bweh);
p += sol::stack::push(L, c.bwuh);
p += sol::stack::push(L, c.blah);
// tell Lua we've left something on
// the stack: return what comes from pushing an integer
return p;
}
@ -136,12 +124,14 @@ struct super_custom {
static int check_get_calls;
static int push_calls;
static int exact_push_calls;
static int pointer_push_calls;
};
int super_custom::get_calls = 0;
int super_custom::check_calls = 0;
int super_custom::check_get_calls = 0;
int super_custom::push_calls = 0;
int super_custom::pointer_push_calls = 0;
int super_custom::exact_push_calls = 0;
super_custom* sol_lua_get(sol::types<super_custom*>, lua_State* L, int index, sol::stack::record& tracking) {
@ -169,6 +159,11 @@ bool sol_lua_check(sol::types<super_custom>, lua_State* L, int index, Handler&&
return true;
}
template <typename Handler>
bool sol_lua_check(sol::types<super_custom*>, lua_State* L, int index, Handler&& handler, sol::stack::record& tracking) {
return sol_lua_check(sol::types<super_custom>(), L, index, std::forward<Handler>(handler), tracking);
}
int sol_lua_push(lua_State* L, const super_custom& c) {
++super_custom::push_calls;
// ensure there's enough space for 1 more thing on the stack
@ -185,7 +180,7 @@ int sol_lua_push(lua_State* L, const super_custom& c) {
}
int sol_lua_push(lua_State* L, super_custom* c) {
++super_custom::push_calls;
++super_custom::pointer_push_calls;
// ensure there's enough space for 1 more thing on the stack
lua_checkstack(L, 1);
// tell Lua we've left something on
@ -197,7 +192,8 @@ int sol_lua_push(lua_State* L, super_custom* c) {
return 1;
}
int sol_lua_push(lua_State* L, std::reference_wrapper<super_custom> c) {
int sol_lua_push(sol::types<std::reference_wrapper<super_custom>>, lua_State* L, std::reference_wrapper<super_custom> c) {
++super_custom::exact_push_calls;
return sol::stack::push(L, std::addressof(c.get()));
}
@ -248,20 +244,26 @@ TEST_CASE("customization/adl", "using the ADL customization points in various si
super_custom::check_calls = 0;
super_custom::check_get_calls = 0;
super_custom::push_calls = 0;
super_custom::pointer_push_calls = 0;
super_custom::exact_push_calls = 0;
super_custom meow_original{ 50 };
lua["meow"] = std::ref(meow_original);
super_custom& meow = lua["meow"];
super_custom* p_meow = lua["meow"];
std::reference_wrapper<super_custom> ref_meow = lua["meow"];
super_custom meow_copy = lua["meow"];
REQUIRE(meow.bweh == 50);
REQUIRE(&meow == &meow_original);
REQUIRE(p_meow == &meow_original);
REQUIRE(&ref_meow.get() == &meow_original);
REQUIRE(meow_copy.bweh == 50);
REQUIRE(super_custom::get_calls > 0);
REQUIRE(super_custom::check_calls > 0);
REQUIRE(super_custom::push_calls > 0);
REQUIRE(super_custom::check_get_calls == 0);
REQUIRE(super_custom::exact_push_calls == 0);
REQUIRE(super_custom::push_calls == 0);
REQUIRE(super_custom::pointer_push_calls > 0);
REQUIRE(super_custom::exact_push_calls > 0);
}
}

15
tests/runtime_tests/source/customizations_private.cpp
View File

@ -37,6 +37,15 @@ struct number_shim {
double num = 0;
};
// HEY:
// Don't do this.
// The code below is for sol3 to specialize things,
// not for YOU to specialize things.
// If you customize things in this fashion,
// I will break your code sometime in the future when fixing things.
// Do. Not. Use the designated ADL customization points, or file
// a bug.
namespace sol {
template <>
@ -71,7 +80,7 @@ namespace sol {
};
template <>
struct pusher<two_things> {
struct unqualified_pusher<two_things> {
static int push(lua_State* L, const two_things& things) {
int amount = stack::push(L, things.a);
amount += stack::push(L, things.b);
@ -108,7 +117,7 @@ namespace sol {
} // namespace stack
} // namespace sol
TEST_CASE("customization/split struct", "using the newly documented customization points to handle different kinds of classes") {
TEST_CASE("customization/split struct", "using the old customization points to handle different kinds of classes") {
sol::state lua;
// Create a pass-through style of function
@ -132,7 +141,7 @@ TEST_CASE("customization/split struct", "using the newly documented customizatio
REQUIRE(d == 36.5);
}
TEST_CASE("customization/usertype", "using the newly documented customization points to handle different kinds of classes") {
TEST_CASE("customization/usertype", "using the old customization points to handle different kinds of classes") {
sol::state lua;
// Create a pass-through style of function