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

Change how proxies are done for the sake of efficiency.

Browse Source
This commit is contained in:
ThePhD 2019-09-15 00:43:44 -04:00
parent b2c22ea8fe
commit bafac3abbd
No known key found for this signature in database
GPG Key ID: 1509DB1C0F702BFA
20 changed files with 456 additions and 284 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
README.md
View File

@ -17,7 +17,7 @@ The library is header-only for easy integration with projects.
## Documentation ## Documentation
Find it [here](http://sol2.rtfd.io/). A run-through kind of tutorial is [here](http://sol2.readthedocs.io/en/latest/tutorial/all-the-things.html)! The API documentation goes over most cases (particularly, the "api/usertype" and "api/proxy" and "api/function" sections) that should still get you off your feet and going, and there's an examples directory [here](https://github.com/ThePhD/sol2/tree/develop/examples) as well. Find it [here](http://sol2.rtfd.io/). A run-through kind of tutorial is [here](http://sol2.readthedocs.io/en/latest/tutorial/all-the-things.html)! The API documentation goes over most cases (particularly, the "api/usertype" and "api/table_proxy" and "api/function" sections) that should still get you off your feet and going, and there's an examples directory [here](https://github.com/ThePhD/sol2/tree/develop/examples) as well.
## Sneak Peek ## Sneak Peek

2
examples/source/table_proxy.cpp
View File

@ -19,7 +19,7 @@ int main () {
lua.open_libraries(sol::lib::base); lua.open_libraries(sol::lib::base);
lua.script(code); lua.script(code);
// produces proxy, implicitly converts to std::string, quietly destroys proxy // produces table_proxy, implicitly converts to std::string, quietly destroys table_proxy
std::string arf_string = lua["bark"]["woof"][2]; std::string arf_string = lua["bark"]["woof"][2];
// lazy-evaluation of tables // lazy-evaluation of tables

2
include/sol/forward.hpp
View File

@ -59,7 +59,7 @@ namespace sol {
template <typename> template <typename>
struct proxy_base; struct proxy_base;
template <typename, typename> template <typename, typename>
struct proxy; struct table_proxy;
template <bool, typename> template <bool, typename>
class basic_table_core; class basic_table_core;

4
include/sol/state_view.hpp
View File

@ -682,12 +682,12 @@ namespace sol {
} }
template <typename T> template <typename T>
proxy<global_table&, detail::proxy_key_t<T>> operator[](T&& key) { table_proxy<global_table&, detail::proxy_key_t<T>> operator[](T&& key) {
return global[std::forward<T>(key)]; return global[std::forward<T>(key)];
} }
template <typename T> template <typename T>
proxy<const global_table&, detail::proxy_key_t<T>> operator[](T&& key) const { table_proxy<const global_table&, detail::proxy_key_t<T>> operator[](T&& key) const {
return global[std::forward<T>(key)]; return global[std::forward<T>(key)];
} }

8
include/sol/table_core.hpp
View File

@ -24,7 +24,7 @@
#ifndef SOL_TABLE_CORE_HPP #ifndef SOL_TABLE_CORE_HPP
#define SOL_TABLE_CORE_HPP #define SOL_TABLE_CORE_HPP
#include "proxy.hpp" #include "table_proxy.hpp"
#include "stack.hpp" #include "stack.hpp"
#include "function_types.hpp" #include "function_types.hpp"
#include "table_iterator.hpp" #include "table_iterator.hpp"
@ -575,17 +575,17 @@ namespace sol {
template <typename T> template <typename T>
auto operator[](T&& key) & { auto operator[](T&& key) & {
return proxy<basic_table_core&, detail::proxy_key_t<T>>(*this, std::forward<T>(key)); return table_proxy<basic_table_core&, detail::proxy_key_t<T>>(*this, std::forward<T>(key));
} }
template <typename T> template <typename T>
auto operator[](T&& key) const& { auto operator[](T&& key) const& {
return proxy<const basic_table_core&, detail::proxy_key_t<T>>(*this, std::forward<T>(key)); return table_proxy<const basic_table_core&, detail::proxy_key_t<T>>(*this, std::forward<T>(key));
} }
template <typename T> template <typename T>
auto operator[](T&& key) && { auto operator[](T&& key) && {
return proxy<basic_table_core, detail::proxy_key_t<T>>(std::move(*this), std::forward<T>(key)); return table_proxy<basic_table_core, detail::proxy_key_t<T>>(std::move(*this), std::forward<T>(key));
} }
template <typename Sig, typename Key, typename... Args> template <typename Sig, typename Key, typename... Args>

86
include/sol/proxy.hpp → include/sol/table_proxy.hpp
View File

@ -21,8 +21,8 @@
// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN // 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. // CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#ifndef SOL_PROXY_HPP #ifndef SOL_TABLE_PROXY_HPP
#define SOL_PROXY_HPP #define SOL_TABLE_PROXY_HPP
#include "traits.hpp" #include "traits.hpp"
#include "function.hpp" #include "function.hpp"
@ -32,7 +32,7 @@
namespace sol { namespace sol {
template <typename Table, typename Key> template <typename Table, typename Key>
struct proxy : public proxy_base<proxy<Table, Key>> { struct table_proxy : public proxy_base<table_proxy<Table, Key>> {
private: private:
using key_type = detail::proxy_key_t<Key>; using key_type = detail::proxy_key_t<Key>;
@ -74,36 +74,35 @@ namespace sol {
key_type key; key_type key;
template <typename T> template <typename T>
proxy(Table table, T&& k) table_proxy(Table table, T&& k) : tbl(table), key(std::forward<T>(k)) {
: tbl(table), key(std::forward<T>(k)) {
} }
template <typename T> template <typename T>
proxy& set(T&& item) & { table_proxy& set(T&& item) & {
tuple_set(std::make_index_sequence<std::tuple_size_v<meta::unqualified_t<key_type>>>(), std::forward<T>(item)); tuple_set(std::make_index_sequence<std::tuple_size_v<meta::unqualified_t<key_type>>>(), std::forward<T>(item));
return *this; return *this;
} }
template <typename T> template <typename T>
proxy&& set(T&& item) && { table_proxy&& set(T&& item) && {
tuple_set(std::make_index_sequence<std::tuple_size_v<meta::unqualified_t<key_type>>>(), std::forward<T>(item)); tuple_set(std::make_index_sequence<std::tuple_size_v<meta::unqualified_t<key_type>>>(), std::forward<T>(item));
return std::move(*this); return std::move(*this);
} }
template <typename... Args> template <typename... Args>
proxy& set_function(Args&&... args) & { table_proxy& set_function(Args&&... args) & {
tbl.set_function(key, std::forward<Args>(args)...); tbl.set_function(key, std::forward<Args>(args)...);
return *this; return *this;
} }
template <typename... Args> template <typename... Args>
proxy&& set_function(Args&&... args) && { table_proxy&& set_function(Args&&... args) && {
tbl.set_function(std::move(key), std::forward<Args>(args)...); tbl.set_function(std::move(key), std::forward<Args>(args)...);
return std::move(*this); return std::move(*this);
} }
template <typename T> template <typename T>
proxy& operator=(T&& other) & { table_proxy& operator=(T&& other) & {
using Tu = meta::unwrap_unqualified_t<T>; using Tu = meta::unwrap_unqualified_t<T>;
if constexpr (!is_lua_reference_or_proxy_v<Tu> && meta::is_callable_v<Tu>) { if constexpr (!is_lua_reference_or_proxy_v<Tu> && meta::is_callable_v<Tu>) {
return set_function(std::forward<T>(other)); return set_function(std::forward<T>(other));
@ -114,7 +113,7 @@ namespace sol {
} }
template <typename T> template <typename T>
proxy&& operator=(T&& other) && { table_proxy&& operator=(T&& other) && {
using Tu = meta::unwrap_unqualified_t<T>; using Tu = meta::unwrap_unqualified_t<T>;
if constexpr (!is_lua_reference_or_proxy_v<Tu> && meta::is_callable_v<Tu>) { if constexpr (!is_lua_reference_or_proxy_v<Tu> && meta::is_callable_v<Tu>) {
return std::move(*this).set_function(std::forward<T>(other)); return std::move(*this).set_function(std::forward<T>(other));
@ -125,12 +124,12 @@ namespace sol {
} }
template <typename T> template <typename T>
proxy& operator=(std::initializer_list<T> other) & { table_proxy& operator=(std::initializer_list<T> other) & {
return set(std::move(other)); return set(std::move(other));
} }
template <typename T> template <typename T>
proxy&& operator=(std::initializer_list<T> other) && { table_proxy&& operator=(std::initializer_list<T> other) && {
return std::move(*this).set(std::move(other)); return std::move(*this).set(std::move(other));
} }
@ -182,29 +181,28 @@ namespace sol {
template <typename K> template <typename K>
decltype(auto) operator[](K&& k) const& { decltype(auto) operator[](K&& k) const& {
auto keys = meta::tuplefy(key, std::forward<K>(k)); auto keys = meta::tuplefy(key, std::forward<K>(k));
return proxy<Table, decltype(keys)>(tbl, std::move(keys)); return table_proxy<Table, decltype(keys)>(tbl, std::move(keys));
} }
template <typename K> template <typename K>
decltype(auto) operator[](K&& k) & { decltype(auto) operator[](K&& k) & {
auto keys = meta::tuplefy(key, std::forward<K>(k)); auto keys = meta::tuplefy(key, std::forward<K>(k));
return proxy<Table, decltype(keys)>(tbl, std::move(keys)); return table_proxy<Table, decltype(keys)>(tbl, std::move(keys));
} }
template <typename K> template <typename K>
decltype(auto) operator[](K&& k) && { decltype(auto) operator[](K&& k) && {
auto keys = meta::tuplefy(std::move(key), std::forward<K>(k)); auto keys = meta::tuplefy(std::move(key), std::forward<K>(k));
return proxy<Table, decltype(keys)>(tbl, std::move(keys)); return table_proxy<Table, decltype(keys)>(tbl, std::move(keys));
} }
template <typename... Ret, typename... Args> template <typename... Ret, typename... Args>
decltype(auto) call(Args&&... args) { decltype(auto) call(Args&&... args) {
#if !defined(__clang__) && defined(_MSC_FULL_VER) && _MSC_FULL_VER >= 191200000 lua_State* L = this->lua_state();
// MSVC is ass sometimes push(L);
return get<function>().call<Ret...>(std::forward<Args>(args)...); int idx = lua_gettop(L);
#else stack_aligned_function func(L, idx);
return get<function>().template call<Ret...>(std::forward<Args>(args)...); return func.call<Ret...>(std::forward<Args>(args)...);
#endif
} }
template <typename... Args> template <typename... Args>
@ -224,7 +222,22 @@ namespace sol {
} }
int push(lua_State* L) const noexcept { int push(lua_State* L) const noexcept {
return get<reference>().push(L); if constexpr (std::is_same_v<meta::unqualified_t<Table>, global_table> || is_stack_table_v<meta::unqualified_t<Table>>) {
auto pp = stack::push_pop<true>(tbl);
int top_index = lua_gettop(L);
stack::get_field<true>(lua_state(), key, -1);
lua_replace(L, top_index + 1);
lua_settop(L, top_index + 1);
}
else {
auto pp = stack::push_pop<false>(tbl);
int tableindex = pp.index_of(tbl);
int aftertableindex = lua_gettop(L);
stack::get_field<false>(lua_state(), key, tableindex);
lua_replace(L, tableindex);
lua_settop(L, aftertableindex + 1);
}
return 1;
} }
type get_type() const { type get_type() const {
@ -242,7 +255,7 @@ namespace sol {
return tbl.lua_state(); return tbl.lua_state();
} }
proxy& force() { table_proxy& force() {
if (!this->valid()) { if (!this->valid()) {
this->set(new_table()); this->set(new_table());
} }
@ -251,46 +264,46 @@ namespace sol {
}; };
template <typename Table, typename Key, typename T> template <typename Table, typename Key, typename T>
inline bool operator==(T&& left, const proxy<Table, Key>& right) { inline bool operator==(T&& left, const table_proxy<Table, Key>& right) {
using G = decltype(stack::get<T>(nullptr, 0)); using G = decltype(stack::get<T>(nullptr, 0));
return right.template get<optional<G>>() == left; return right.template get<optional<G>>() == left;
} }
template <typename Table, typename Key, typename T> template <typename Table, typename Key, typename T>
inline bool operator==(const proxy<Table, Key>& right, T&& left) { inline bool operator==(const table_proxy<Table, Key>& right, T&& left) {
using G = decltype(stack::get<T>(nullptr, 0)); using G = decltype(stack::get<T>(nullptr, 0));
return right.template get<optional<G>>() == left; return right.template get<optional<G>>() == left;
} }
template <typename Table, typename Key, typename T> template <typename Table, typename Key, typename T>
inline bool operator!=(T&& left, const proxy<Table, Key>& right) { inline bool operator!=(T&& left, const table_proxy<Table, Key>& right) {
using G = decltype(stack::get<T>(nullptr, 0)); using G = decltype(stack::get<T>(nullptr, 0));
return right.template get<optional<G>>() != left; return right.template get<optional<G>>() != left;
} }
template <typename Table, typename Key, typename T> template <typename Table, typename Key, typename T>
inline bool operator!=(const proxy<Table, Key>& right, T&& left) { inline bool operator!=(const table_proxy<Table, Key>& right, T&& left) {
using G = decltype(stack::get<T>(nullptr, 0)); using G = decltype(stack::get<T>(nullptr, 0));
return right.template get<optional<G>>() != left; return right.template get<optional<G>>() != left;
} }
template <typename Table, typename Key> template <typename Table, typename Key>
inline bool operator==(lua_nil_t, const proxy<Table, Key>& right) { inline bool operator==(lua_nil_t, const table_proxy<Table, Key>& right) {
return !right.valid(); return !right.valid();
} }
template <typename Table, typename Key> template <typename Table, typename Key>
inline bool operator==(const proxy<Table, Key>& right, lua_nil_t) { inline bool operator==(const table_proxy<Table, Key>& right, lua_nil_t) {
return !right.valid(); return !right.valid();
} }
template <typename Table, typename Key> template <typename Table, typename Key>
inline bool operator!=(lua_nil_t, const proxy<Table, Key>& right) { inline bool operator!=(lua_nil_t, const table_proxy<Table, Key>& right) {
return right.valid(); return right.valid();
} }
template <typename Table, typename Key> template <typename Table, typename Key>
inline bool operator!=(const proxy<Table, Key>& right, lua_nil_t) { inline bool operator!=(const table_proxy<Table, Key>& right, lua_nil_t) {
return right.valid(); return right.valid();
} }
@ -312,13 +325,12 @@ namespace sol {
namespace stack { namespace stack {
template <typename Table, typename Key> template <typename Table, typename Key>
struct unqualified_pusher<proxy<Table, Key>> { struct unqualified_pusher<table_proxy<Table, Key>> {
static int push(lua_State* L, const proxy<Table, Key>& p) { static int push(lua_State* L, const table_proxy<Table, Key>& p) {
reference r = p; return p.push(L);
return r.push(L);
} }
}; };
} // namespace stack } // namespace stack
} // namespace sol } // namespace sol
#endif // SOL_PROXY_HPP #endif // SOL_TABLE_PROXY_HPP

39
include/sol/types.hpp
View File

@ -867,16 +867,14 @@ namespace sol {
} }
template <typename T> template <typename T>
struct is_lua_reference : std::integral_constant<bool, struct is_lua_reference
std::is_base_of_v<reference, T> || std::is_base_of_v<main_reference, T> : std::integral_constant<bool, std::is_base_of_v<reference, T> || std::is_base_of_v<main_reference, T> || std::is_base_of_v<stack_reference, T>> {};
|| std::is_base_of_v<stack_reference, T>> {};
template <typename T> template <typename T>
inline constexpr bool is_lua_reference_v = is_lua_reference<T>::value; inline constexpr bool is_lua_reference_v = is_lua_reference<T>::value;
template <typename T> template <typename T>
struct is_lua_reference_or_proxy struct is_lua_reference_or_proxy : std::integral_constant<bool, is_lua_reference_v<T> || meta::is_specialization_of_v<T, table_proxy>> {};
: std::integral_constant<bool, is_lua_reference_v<T> || meta::is_specialization_of_v<T, proxy>> {};
template <typename T> template <typename T>
inline constexpr bool is_lua_reference_or_proxy_v = is_lua_reference_or_proxy<T>::value; inline constexpr bool is_lua_reference_or_proxy_v = is_lua_reference_or_proxy<T>::value;
@ -901,7 +899,8 @@ namespace sol {
template <typename T> template <typename T>
struct is_container struct is_container
: std::integral_constant<bool, : std::integral_constant<bool,
!std::is_same_v<state_view, T> && !std::is_same_v<state, T> && !meta::is_initializer_list_v<T> && !meta::is_string_like_v<T> && !meta::is_string_literal_array_v<T> && !is_transparent_argument_v<T> && !is_lua_reference_v<T> && (meta::has_begin_end_v<T> || std::is_array_v<T>)> { !std::is_same_v<state_view,
T> && !std::is_same_v<state, T> && !meta::is_initializer_list_v<T> && !meta::is_string_like_v<T> && !meta::is_string_literal_array_v<T> && !is_transparent_argument_v<T> && !is_lua_reference_v<T> && (meta::has_begin_end_v<T> || std::is_array_v<T>)> {
}; };
template <typename T> template <typename T>
@ -1098,7 +1097,8 @@ namespace sol {
struct lua_type_of<T*> : std::integral_constant<type, type::userdata> {}; struct lua_type_of<T*> : std::integral_constant<type, type::userdata> {};
template <typename T> template <typename T>
struct lua_type_of<T, std::enable_if_t<std::is_arithmetic_v<T> || std::is_same_v<T, lua_Number> || std::is_same_v<T, lua_Integer>>> : std::integral_constant<type, type::number> {}; struct lua_type_of<T, std::enable_if_t<std::is_arithmetic_v<T> || std::is_same_v<T, lua_Number> || std::is_same_v<T, lua_Integer>>>
: std::integral_constant<type, type::number> {};
template <typename T> template <typename T>
struct lua_type_of<T, std::enable_if_t<std::is_enum_v<T>>> : std::integral_constant<type, type::number> {}; struct lua_type_of<T, std::enable_if_t<std::is_enum_v<T>>> : std::integral_constant<type, type::number> {};
@ -1114,8 +1114,7 @@ namespace sol {
#endif // SOL_CXX17_FEATURES #endif // SOL_CXX17_FEATURES
template <typename T> template <typename T>
struct lua_type_of<nested<T>> struct lua_type_of<nested<T>> : meta::conditional_t<::sol::is_container_v<T>, std::integral_constant<type, type::table>, lua_type_of<T>> {};
: meta::conditional_t<::sol::is_container_v<T>, std::integral_constant<type, type::table>, lua_type_of<T>> {};
template <typename C, C v, template <typename...> class V, typename... Args> template <typename C, C v, template <typename...> class V, typename... Args>
struct accumulate : std::integral_constant<C, v> {}; struct accumulate : std::integral_constant<C, v> {};
@ -1172,11 +1171,10 @@ namespace sol {
template <typename T> template <typename T>
struct is_lua_primitive struct is_lua_primitive
: std::integral_constant<bool, : std::integral_constant<bool,
type::userdata != lua_type_of_v<T> type::userdata
|| ((type::userdata == lua_type_of_v<T>) && detail::has_internal_marker_v<lua_type_of<T>> != lua_type_of_v<
&& !detail::has_internal_marker_v<lua_size<T>>) T> || ((type::userdata == lua_type_of_v<T>)&&detail::has_internal_marker_v<lua_type_of<T>> && !detail::has_internal_marker_v<lua_size<T>>)
|| is_lua_reference_v<T> || meta::is_specialization_of_v<T, std::tuple> || is_lua_reference_or_proxy_v<T> || meta::is_specialization_of_v<T, std::tuple> || meta::is_specialization_of_v<T, std::pair>> {};
|| meta::is_specialization_of_v<T, std::pair>> {};
template <typename T> template <typename T>
constexpr inline bool is_lua_primitive_v = is_lua_primitive<T>::value; constexpr inline bool is_lua_primitive_v = is_lua_primitive<T>::value;
@ -1265,6 +1263,16 @@ namespace sol {
template <typename T> template <typename T>
inline constexpr bool is_table_v = is_table<T>::value; inline constexpr bool is_table_v = is_table<T>::value;
template <typename T>
struct is_stack_table : std::false_type {};
template <bool x, typename T>
struct is_stack_table<basic_table_core<x, T>> : std::integral_constant<bool, std::is_base_of_v<stack_reference, T>> {};
template <typename T>
struct is_stack_table<basic_lua_table<T>> : std::integral_constant<bool, std::is_base_of_v<stack_reference, T>> {};
template <typename T>
inline constexpr bool is_stack_table_v = is_stack_table<T>::value;
template <typename T> template <typename T>
struct is_function : std::false_type {}; struct is_function : std::false_type {};
template <typename T, bool aligned> template <typename T, bool aligned>
@ -1300,7 +1308,8 @@ namespace sol {
template <typename T> template <typename T>
struct is_automagical struct is_automagical
: std::integral_constant<bool, : std::integral_constant<bool,
std::is_array_v<meta::unqualified_t<T>> || !std::is_same_v<meta::unqualified_t<T>, state> || !std::is_same_v<meta::unqualified_t<T>, state_view>> {}; std::is_array_v<meta::unqualified_t<T>> || !std::is_same_v<meta::unqualified_t<T>, state> || !std::is_same_v<meta::unqualified_t<T>, state_view>> {
};
template <typename T> template <typename T>
inline type type_of() { inline type type_of() {

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

@ -20,8 +20,8 @@
// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. // CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
// This file was generated with a script. // This file was generated with a script.
// Generated 2019-09-08 23:53:48.445628 UTC // Generated 2019-09-15 04:36:38.687873 UTC
// This header was generated with sol v3.0.3 (revision 29c03ea) // This header was generated with sol v3.0.3 (revision b2c22ea)
// https://github.com/ThePhD/sol2 // https://github.com/ThePhD/sol2
#ifndef SOL_SINGLE_INCLUDE_FORWARD_HPP #ifndef SOL_SINGLE_INCLUDE_FORWARD_HPP
@ -281,7 +281,7 @@ namespace sol {
template <typename> template <typename>
struct proxy_base; struct proxy_base;
template <typename, typename> template <typename, typename>
struct proxy; struct table_proxy;
template <bool, typename> template <bool, typename>
class basic_table_core; class basic_table_core;

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

@ -20,8 +20,8 @@
// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. // CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
// This file was generated with a script. // This file was generated with a script.
// Generated 2019-09-08 23:53:47.830273 UTC // Generated 2019-09-15 04:36:35.549872 UTC
// This header was generated with sol v3.0.3 (revision 29c03ea) // This header was generated with sol v3.0.3 (revision b2c22ea)
// https://github.com/ThePhD/sol2 // https://github.com/ThePhD/sol2
#ifndef SOL_SINGLE_INCLUDE_HPP #ifndef SOL_SINGLE_INCLUDE_HPP
@ -307,7 +307,7 @@ namespace sol {
template <typename> template <typename>
struct proxy_base; struct proxy_base;
template <typename, typename> template <typename, typename>
struct proxy; struct table_proxy;
template <bool, typename> template <bool, typename>
class basic_table_core; class basic_table_core;
@ -7094,16 +7094,14 @@ namespace sol {
} }
template <typename T> template <typename T>
struct is_lua_reference : std::integral_constant<bool, struct is_lua_reference
std::is_base_of_v<reference, T> || std::is_base_of_v<main_reference, T> : std::integral_constant<bool, std::is_base_of_v<reference, T> || std::is_base_of_v<main_reference, T> || std::is_base_of_v<stack_reference, T>> {};
|| std::is_base_of_v<stack_reference, T>> {};
template <typename T> template <typename T>
inline constexpr bool is_lua_reference_v = is_lua_reference<T>::value; inline constexpr bool is_lua_reference_v = is_lua_reference<T>::value;
template <typename T> template <typename T>
struct is_lua_reference_or_proxy struct is_lua_reference_or_proxy : std::integral_constant<bool, is_lua_reference_v<T> || meta::is_specialization_of_v<T, table_proxy>> {};
: std::integral_constant<bool, is_lua_reference_v<T> || meta::is_specialization_of_v<T, proxy>> {};
template <typename T> template <typename T>
inline constexpr bool is_lua_reference_or_proxy_v = is_lua_reference_or_proxy<T>::value; inline constexpr bool is_lua_reference_or_proxy_v = is_lua_reference_or_proxy<T>::value;
@ -7128,7 +7126,8 @@ namespace sol {
template <typename T> template <typename T>
struct is_container struct is_container
: std::integral_constant<bool, : std::integral_constant<bool,
!std::is_same_v<state_view, T> && !std::is_same_v<state, T> && !meta::is_initializer_list_v<T> && !meta::is_string_like_v<T> && !meta::is_string_literal_array_v<T> && !is_transparent_argument_v<T> && !is_lua_reference_v<T> && (meta::has_begin_end_v<T> || std::is_array_v<T>)> { !std::is_same_v<state_view,
T> && !std::is_same_v<state, T> && !meta::is_initializer_list_v<T> && !meta::is_string_like_v<T> && !meta::is_string_literal_array_v<T> && !is_transparent_argument_v<T> && !is_lua_reference_v<T> && (meta::has_begin_end_v<T> || std::is_array_v<T>)> {
}; };
template <typename T> template <typename T>
@ -7325,7 +7324,8 @@ namespace sol {
struct lua_type_of<T*> : std::integral_constant<type, type::userdata> {}; struct lua_type_of<T*> : std::integral_constant<type, type::userdata> {};
template <typename T> template <typename T>
struct lua_type_of<T, std::enable_if_t<std::is_arithmetic_v<T> || std::is_same_v<T, lua_Number> || std::is_same_v<T, lua_Integer>>> : std::integral_constant<type, type::number> {}; struct lua_type_of<T, std::enable_if_t<std::is_arithmetic_v<T> || std::is_same_v<T, lua_Number> || std::is_same_v<T, lua_Integer>>>
: std::integral_constant<type, type::number> {};
template <typename T> template <typename T>
struct lua_type_of<T, std::enable_if_t<std::is_enum_v<T>>> : std::integral_constant<type, type::number> {}; struct lua_type_of<T, std::enable_if_t<std::is_enum_v<T>>> : std::integral_constant<type, type::number> {};
@ -7341,8 +7341,7 @@ namespace sol {
#endif // SOL_CXX17_FEATURES #endif // SOL_CXX17_FEATURES
template <typename T> template <typename T>
struct lua_type_of<nested<T>> struct lua_type_of<nested<T>> : meta::conditional_t<::sol::is_container_v<T>, std::integral_constant<type, type::table>, lua_type_of<T>> {};
: meta::conditional_t<::sol::is_container_v<T>, std::integral_constant<type, type::table>, lua_type_of<T>> {};
template <typename C, C v, template <typename...> class V, typename... Args> template <typename C, C v, template <typename...> class V, typename... Args>
struct accumulate : std::integral_constant<C, v> {}; struct accumulate : std::integral_constant<C, v> {};
@ -7399,11 +7398,10 @@ namespace sol {
template <typename T> template <typename T>
struct is_lua_primitive struct is_lua_primitive
: std::integral_constant<bool, : std::integral_constant<bool,
type::userdata != lua_type_of_v<T> type::userdata
|| ((type::userdata == lua_type_of_v<T>) && detail::has_internal_marker_v<lua_type_of<T>> != lua_type_of_v<
&& !detail::has_internal_marker_v<lua_size<T>>) T> || ((type::userdata == lua_type_of_v<T>)&&detail::has_internal_marker_v<lua_type_of<T>> && !detail::has_internal_marker_v<lua_size<T>>)
|| is_lua_reference_v<T> || meta::is_specialization_of_v<T, std::tuple> || is_lua_reference_or_proxy_v<T> || meta::is_specialization_of_v<T, std::tuple> || meta::is_specialization_of_v<T, std::pair>> {};
|| meta::is_specialization_of_v<T, std::pair>> {};
template <typename T> template <typename T>
constexpr inline bool is_lua_primitive_v = is_lua_primitive<T>::value; constexpr inline bool is_lua_primitive_v = is_lua_primitive<T>::value;
@ -7492,6 +7490,16 @@ namespace sol {
template <typename T> template <typename T>
inline constexpr bool is_table_v = is_table<T>::value; inline constexpr bool is_table_v = is_table<T>::value;
template <typename T>
struct is_stack_table : std::false_type {};
template <bool x, typename T>
struct is_stack_table<basic_table_core<x, T>> : std::integral_constant<bool, std::is_base_of_v<stack_reference, T>> {};
template <typename T>
struct is_stack_table<basic_lua_table<T>> : std::integral_constant<bool, std::is_base_of_v<stack_reference, T>> {};
template <typename T>
inline constexpr bool is_stack_table_v = is_stack_table<T>::value;
template <typename T> template <typename T>
struct is_function : std::false_type {}; struct is_function : std::false_type {};
template <typename T, bool aligned> template <typename T, bool aligned>
@ -7526,7 +7534,8 @@ namespace sol {
template <typename T> template <typename T>
struct is_automagical struct is_automagical
: std::integral_constant<bool, : std::integral_constant<bool,
std::is_array_v<meta::unqualified_t<T>> || !std::is_same_v<meta::unqualified_t<T>, state> || !std::is_same_v<meta::unqualified_t<T>, state_view>> {}; std::is_array_v<meta::unqualified_t<T>> || !std::is_same_v<meta::unqualified_t<T>, state> || !std::is_same_v<meta::unqualified_t<T>, state_view>> {
};
template <typename T> template <typename T>
inline type type_of() { inline type type_of() {
@ -22335,12 +22344,12 @@ namespace sol {
// beginning of sol/table_core.hpp // beginning of sol/table_core.hpp
// beginning of sol/proxy.hpp // beginning of sol/table_proxy.hpp
namespace sol { namespace sol {
template <typename Table, typename Key> template <typename Table, typename Key>
struct proxy : public proxy_base<proxy<Table, Key>> { struct table_proxy : public proxy_base<table_proxy<Table, Key>> {
private: private:
using key_type = detail::proxy_key_t<Key>; using key_type = detail::proxy_key_t<Key>;
@ -22382,36 +22391,35 @@ namespace sol {
key_type key; key_type key;
template <typename T> template <typename T>
proxy(Table table, T&& k) table_proxy(Table table, T&& k) : tbl(table), key(std::forward<T>(k)) {
: tbl(table), key(std::forward<T>(k)) {
} }
template <typename T> template <typename T>
proxy& set(T&& item) & { table_proxy& set(T&& item) & {
tuple_set(std::make_index_sequence<std::tuple_size_v<meta::unqualified_t<key_type>>>(), std::forward<T>(item)); tuple_set(std::make_index_sequence<std::tuple_size_v<meta::unqualified_t<key_type>>>(), std::forward<T>(item));
return *this; return *this;
} }
template <typename T> template <typename T>
proxy&& set(T&& item) && { table_proxy&& set(T&& item) && {
tuple_set(std::make_index_sequence<std::tuple_size_v<meta::unqualified_t<key_type>>>(), std::forward<T>(item)); tuple_set(std::make_index_sequence<std::tuple_size_v<meta::unqualified_t<key_type>>>(), std::forward<T>(item));
return std::move(*this); return std::move(*this);
} }
template <typename... Args> template <typename... Args>
proxy& set_function(Args&&... args) & { table_proxy& set_function(Args&&... args) & {
tbl.set_function(key, std::forward<Args>(args)...); tbl.set_function(key, std::forward<Args>(args)...);
return *this; return *this;
} }
template <typename... Args> template <typename... Args>
proxy&& set_function(Args&&... args) && { table_proxy&& set_function(Args&&... args) && {
tbl.set_function(std::move(key), std::forward<Args>(args)...); tbl.set_function(std::move(key), std::forward<Args>(args)...);
return std::move(*this); return std::move(*this);
} }
template <typename T> template <typename T>
proxy& operator=(T&& other) & { table_proxy& operator=(T&& other) & {
using Tu = meta::unwrap_unqualified_t<T>; using Tu = meta::unwrap_unqualified_t<T>;
if constexpr (!is_lua_reference_or_proxy_v<Tu> && meta::is_callable_v<Tu>) { if constexpr (!is_lua_reference_or_proxy_v<Tu> && meta::is_callable_v<Tu>) {
return set_function(std::forward<T>(other)); return set_function(std::forward<T>(other));
@ -22422,7 +22430,7 @@ namespace sol {
} }
template <typename T> template <typename T>
proxy&& operator=(T&& other) && { table_proxy&& operator=(T&& other) && {
using Tu = meta::unwrap_unqualified_t<T>; using Tu = meta::unwrap_unqualified_t<T>;
if constexpr (!is_lua_reference_or_proxy_v<Tu> && meta::is_callable_v<Tu>) { if constexpr (!is_lua_reference_or_proxy_v<Tu> && meta::is_callable_v<Tu>) {
return std::move(*this).set_function(std::forward<T>(other)); return std::move(*this).set_function(std::forward<T>(other));
@ -22433,12 +22441,12 @@ namespace sol {
} }
template <typename T> template <typename T>
proxy& operator=(std::initializer_list<T> other) & { table_proxy& operator=(std::initializer_list<T> other) & {
return set(std::move(other)); return set(std::move(other));
} }
template <typename T> template <typename T>
proxy&& operator=(std::initializer_list<T> other) && { table_proxy&& operator=(std::initializer_list<T> other) && {
return std::move(*this).set(std::move(other)); return std::move(*this).set(std::move(other));
} }
@ -22489,29 +22497,28 @@ namespace sol {
template <typename K> template <typename K>
decltype(auto) operator[](K&& k) const& { decltype(auto) operator[](K&& k) const& {
auto keys = meta::tuplefy(key, std::forward<K>(k)); auto keys = meta::tuplefy(key, std::forward<K>(k));
return proxy<Table, decltype(keys)>(tbl, std::move(keys)); return table_proxy<Table, decltype(keys)>(tbl, std::move(keys));
} }
template <typename K> template <typename K>
decltype(auto) operator[](K&& k) & { decltype(auto) operator[](K&& k) & {
auto keys = meta::tuplefy(key, std::forward<K>(k)); auto keys = meta::tuplefy(key, std::forward<K>(k));
return proxy<Table, decltype(keys)>(tbl, std::move(keys)); return table_proxy<Table, decltype(keys)>(tbl, std::move(keys));
} }
template <typename K> template <typename K>
decltype(auto) operator[](K&& k) && { decltype(auto) operator[](K&& k) && {
auto keys = meta::tuplefy(std::move(key), std::forward<K>(k)); auto keys = meta::tuplefy(std::move(key), std::forward<K>(k));
return proxy<Table, decltype(keys)>(tbl, std::move(keys)); return table_proxy<Table, decltype(keys)>(tbl, std::move(keys));
} }
template <typename... Ret, typename... Args> template <typename... Ret, typename... Args>
decltype(auto) call(Args&&... args) { decltype(auto) call(Args&&... args) {
#if !defined(__clang__) && defined(_MSC_FULL_VER) && _MSC_FULL_VER >= 191200000 lua_State* L = this->lua_state();
// MSVC is ass sometimes push(L);
return get<function>().call<Ret...>(std::forward<Args>(args)...); int idx = lua_gettop(L);
#else stack_aligned_function func(L, idx);
return get<function>().template call<Ret...>(std::forward<Args>(args)...); return func.call<Ret...>(std::forward<Args>(args)...);
#endif
} }
template <typename... Args> template <typename... Args>
@ -22531,7 +22538,22 @@ namespace sol {
} }
int push(lua_State* L) const noexcept { int push(lua_State* L) const noexcept {
return get<reference>().push(L); if constexpr (std::is_same_v<meta::unqualified_t<Table>, global_table> || is_stack_table_v<meta::unqualified_t<Table>>) {
auto pp = stack::push_pop<true>(tbl);
int top_index = lua_gettop(L);
stack::get_field<true>(lua_state(), key, -1);
lua_replace(L, top_index + 1);
lua_settop(L, top_index + 1);
}
else {
auto pp = stack::push_pop<false>(tbl);
int tableindex = pp.index_of(tbl);
int aftertableindex = lua_gettop(L);
stack::get_field<false>(lua_state(), key, tableindex);
lua_replace(L, tableindex);
lua_settop(L, aftertableindex + 1);
}
return 1;
} }
type get_type() const { type get_type() const {
@ -22549,7 +22571,7 @@ namespace sol {
return tbl.lua_state(); return tbl.lua_state();
} }
proxy& force() { table_proxy& force() {
if (!this->valid()) { if (!this->valid()) {
this->set(new_table()); this->set(new_table());
} }
@ -22558,46 +22580,46 @@ namespace sol {
}; };
template <typename Table, typename Key, typename T> template <typename Table, typename Key, typename T>
inline bool operator==(T&& left, const proxy<Table, Key>& right) { inline bool operator==(T&& left, const table_proxy<Table, Key>& right) {
using G = decltype(stack::get<T>(nullptr, 0)); using G = decltype(stack::get<T>(nullptr, 0));
return right.template get<optional<G>>() == left; return right.template get<optional<G>>() == left;
} }
template <typename Table, typename Key, typename T> template <typename Table, typename Key, typename T>
inline bool operator==(const proxy<Table, Key>& right, T&& left) { inline bool operator==(const table_proxy<Table, Key>& right, T&& left) {
using G = decltype(stack::get<T>(nullptr, 0)); using G = decltype(stack::get<T>(nullptr, 0));
return right.template get<optional<G>>() == left; return right.template get<optional<G>>() == left;
} }
template <typename Table, typename Key, typename T> template <typename Table, typename Key, typename T>
inline bool operator!=(T&& left, const proxy<Table, Key>& right) { inline bool operator!=(T&& left, const table_proxy<Table, Key>& right) {
using G = decltype(stack::get<T>(nullptr, 0)); using G = decltype(stack::get<T>(nullptr, 0));
return right.template get<optional<G>>() != left; return right.template get<optional<G>>() != left;
} }
template <typename Table, typename Key, typename T> template <typename Table, typename Key, typename T>
inline bool operator!=(const proxy<Table, Key>& right, T&& left) { inline bool operator!=(const table_proxy<Table, Key>& right, T&& left) {
using G = decltype(stack::get<T>(nullptr, 0)); using G = decltype(stack::get<T>(nullptr, 0));
return right.template get<optional<G>>() != left; return right.template get<optional<G>>() != left;
} }
template <typename Table, typename Key> template <typename Table, typename Key>
inline bool operator==(lua_nil_t, const proxy<Table, Key>& right) { inline bool operator==(lua_nil_t, const table_proxy<Table, Key>& right) {
return !right.valid(); return !right.valid();
} }
template <typename Table, typename Key> template <typename Table, typename Key>
inline bool operator==(const proxy<Table, Key>& right, lua_nil_t) { inline bool operator==(const table_proxy<Table, Key>& right, lua_nil_t) {
return !right.valid(); return !right.valid();
} }
template <typename Table, typename Key> template <typename Table, typename Key>
inline bool operator!=(lua_nil_t, const proxy<Table, Key>& right) { inline bool operator!=(lua_nil_t, const table_proxy<Table, Key>& right) {
return right.valid(); return right.valid();
} }
template <typename Table, typename Key> template <typename Table, typename Key>
inline bool operator!=(const proxy<Table, Key>& right, lua_nil_t) { inline bool operator!=(const table_proxy<Table, Key>& right, lua_nil_t) {
return right.valid(); return right.valid();
} }
@ -22619,16 +22641,15 @@ namespace sol {
namespace stack { namespace stack {
template <typename Table, typename Key> template <typename Table, typename Key>
struct unqualified_pusher<proxy<Table, Key>> { struct unqualified_pusher<table_proxy<Table, Key>> {
static int push(lua_State* L, const proxy<Table, Key>& p) { static int push(lua_State* L, const table_proxy<Table, Key>& p) {
reference r = p; return p.push(L);
return r.push(L);
} }
}; };
} // namespace stack } // namespace stack
} // namespace sol } // namespace sol
// end of sol/proxy.hpp // end of sol/table_proxy.hpp
// beginning of sol/table_iterator.hpp // beginning of sol/table_iterator.hpp
@ -23266,17 +23287,17 @@ namespace sol {
template <typename T> template <typename T>
auto operator[](T&& key) & { auto operator[](T&& key) & {
return proxy<basic_table_core&, detail::proxy_key_t<T>>(*this, std::forward<T>(key)); return table_proxy<basic_table_core&, detail::proxy_key_t<T>>(*this, std::forward<T>(key));
} }
template <typename T> template <typename T>
auto operator[](T&& key) const& { auto operator[](T&& key) const& {
return proxy<const basic_table_core&, detail::proxy_key_t<T>>(*this, std::forward<T>(key)); return table_proxy<const basic_table_core&, detail::proxy_key_t<T>>(*this, std::forward<T>(key));
} }
template <typename T> template <typename T>
auto operator[](T&& key) && { auto operator[](T&& key) && {
return proxy<basic_table_core, detail::proxy_key_t<T>>(std::move(*this), std::forward<T>(key)); return table_proxy<basic_table_core, detail::proxy_key_t<T>>(std::move(*this), std::forward<T>(key));
} }
template <typename Sig, typename Key, typename... Args> template <typename Sig, typename Key, typename... Args>
@ -25005,12 +25026,12 @@ namespace sol {
} }
template <typename T> template <typename T>
proxy<global_table&, detail::proxy_key_t<T>> operator[](T&& key) { table_proxy<global_table&, detail::proxy_key_t<T>> operator[](T&& key) {
return global[std::forward<T>(key)]; return global[std::forward<T>(key)];
} }
template <typename T> template <typename T>
proxy<const global_table&, detail::proxy_key_t<T>> operator[](T&& key) const { table_proxy<const global_table&, detail::proxy_key_t<T>> operator[](T&& key) const {
return global[std::forward<T>(key)]; return global[std::forward<T>(key)];
} }

2
tests/compile_tests/source/proxy.cpp
View File

@ -23,4 +23,4 @@
#include "sol_defines.hpp" #include "sol_defines.hpp"
#include <sol/proxy.hpp> #include <sol/table_proxy.hpp>

2
tests/runtime_tests/source/basic.cpp
View File

@ -217,7 +217,7 @@ TEST_CASE("simple/get_or", "check if table.get_or works correctly") {
REQUIRE(bark == 55.6); REQUIRE(bark == 55.6);
} }
TEST_CASE("simple/proxy get_or", "check if proxy.get_or works correctly") { TEST_CASE("simple/table_proxy get_or", "check if table_proxy.get_or works correctly") {
sol::state lua; sol::state lua;
auto bob_table = lua.create_table("bob"); auto bob_table = lua.create_table("bob");

49
tests/runtime_tests/source/container_table.cpp
View File

@ -37,13 +37,24 @@
#include <set> #include <set>
#include <unordered_set> #include <unordered_set>
inline namespace sol2_test_container_table {
template <typename T>
struct as_table_callable {
T* ptr;
as_table_callable(T& ref_) : ptr(&ref_) {
}
auto operator()() const {
return sol::as_table(*ptr);
}
};
} // namespace sol2_test_container_table
TEST_CASE("containers/vector table roundtrip", "make sure vectors can be round-tripped") { TEST_CASE("containers/vector table roundtrip", "make sure vectors can be round-tripped") {
sol::state lua; sol::state lua;
std::vector<int> v{ 1, 2, 3 }; std::vector<int> v{ 1, 2, 3 };
lua.set_function("f", [&]() { lua.set_function("f", as_table_callable<std::vector<int>>(v));
return sol::as_table(v);
});
auto result1 = lua.safe_script("x = f()", sol::script_pass_on_error); auto result1 = lua.safe_script("x = f()", sol::script_pass_on_error);
REQUIRE(result1.valid()); REQUIRE(result1.valid());
sol::as_table_t<std::vector<int>> x = lua["x"]; sol::as_table_t<std::vector<int>> x = lua["x"];
@ -54,9 +65,7 @@ TEST_CASE("containers/vector table roundtrip", "make sure vectors can be round-t
TEST_CASE("containers/deque table roundtrip", "make sure deques can be round-tripped") { TEST_CASE("containers/deque table roundtrip", "make sure deques can be round-tripped") {
sol::state lua; sol::state lua;
std::deque<int> v{ 1, 2, 3 }; std::deque<int> v{ 1, 2, 3 };
lua.set_function("f", [&]() { lua.set_function("f", as_table_callable<std::deque<int>>(v));
return sol::as_table(v);
});
auto result1 = lua.safe_script("x = f()", sol::script_pass_on_error); auto result1 = lua.safe_script("x = f()", sol::script_pass_on_error);
REQUIRE(result1.valid()); REQUIRE(result1.valid());
sol::as_table_t<std::deque<int>> x = lua["x"]; sol::as_table_t<std::deque<int>> x = lua["x"];
@ -67,9 +76,7 @@ TEST_CASE("containers/deque table roundtrip", "make sure deques can be round-tri
TEST_CASE("containers/array table roundtrip", "make sure arrays can be round-tripped") { TEST_CASE("containers/array table roundtrip", "make sure arrays can be round-tripped") {
sol::state lua; sol::state lua;
std::array<int, 3> v{ { 1, 2, 3 } }; std::array<int, 3> v{ { 1, 2, 3 } };
lua.set_function("f", [&]() { lua.set_function("f", as_table_callable<std::array<int, 3>>(v));
return sol::as_table(v);
});
auto result1 = lua.safe_script("x = f()", sol::script_pass_on_error); auto result1 = lua.safe_script("x = f()", sol::script_pass_on_error);
REQUIRE(result1.valid()); REQUIRE(result1.valid());
sol::as_table_t<std::array<int, 3>> x = lua["x"]; sol::as_table_t<std::array<int, 3>> x = lua["x"];
@ -80,9 +87,7 @@ TEST_CASE("containers/array table roundtrip", "make sure arrays can be round-tri
TEST_CASE("containers/list table roundtrip", "make sure lists can be round-tripped") { TEST_CASE("containers/list table roundtrip", "make sure lists can be round-tripped") {
sol::state lua; sol::state lua;
std::list<int> v{ 1, 2, 3 }; std::list<int> v{ 1, 2, 3 };
lua.set_function("f", [&]() { lua.set_function("f", as_table_callable<std::list<int>>(v));
return sol::as_table(v);
});
auto result1 = lua.safe_script("x = f()", sol::script_pass_on_error); auto result1 = lua.safe_script("x = f()", sol::script_pass_on_error);
REQUIRE(result1.valid()); REQUIRE(result1.valid());
sol::as_table_t<std::list<int>> x = lua["x"]; sol::as_table_t<std::list<int>> x = lua["x"];
@ -93,9 +98,7 @@ TEST_CASE("containers/list table roundtrip", "make sure lists can be round-tripp
TEST_CASE("containers/forward_list table roundtrip", "make sure forward_lists can be round-tripped") { TEST_CASE("containers/forward_list table roundtrip", "make sure forward_lists can be round-tripped") {
sol::state lua; sol::state lua;
std::forward_list<int> v{ 1, 2, 3 }; std::forward_list<int> v{ 1, 2, 3 };
lua.set_function("f", [&]() { lua.set_function("f", as_table_callable<std::forward_list<int>>(v));
return sol::as_table(v);
});
auto result1 = lua.safe_script("x = f()", sol::script_pass_on_error); auto result1 = lua.safe_script("x = f()", sol::script_pass_on_error);
REQUIRE(result1.valid()); REQUIRE(result1.valid());
sol::as_table_t<std::forward_list<int>> x = lua["x"]; sol::as_table_t<std::forward_list<int>> x = lua["x"];
@ -106,9 +109,7 @@ TEST_CASE("containers/forward_list table roundtrip", "make sure forward_lists ca
TEST_CASE("containers/map table roundtrip", "make sure maps can be round-tripped") { TEST_CASE("containers/map table roundtrip", "make sure maps can be round-tripped") {
sol::state lua; sol::state lua;
std::map<std::string, int> v{ { "a", 1 }, { "b", 2 }, { "c", 3 } }; std::map<std::string, int> v{ { "a", 1 }, { "b", 2 }, { "c", 3 } };
lua.set_function("f", [&]() { lua.set_function("f", as_table_callable<std::map<std::string, int>>(v));
return sol::as_table(v);
});
auto result1 = lua.safe_script("x = f()", sol::script_pass_on_error); auto result1 = lua.safe_script("x = f()", sol::script_pass_on_error);
REQUIRE(result1.valid()); REQUIRE(result1.valid());
sol::as_table_t<std::map<std::string, int>> x = lua["x"]; sol::as_table_t<std::map<std::string, int>> x = lua["x"];
@ -119,9 +120,7 @@ TEST_CASE("containers/map table roundtrip", "make sure maps can be round-tripped
TEST_CASE("containers/unordered_map table roundtrip", "make sure unordered_maps can be round-tripped") { TEST_CASE("containers/unordered_map table roundtrip", "make sure unordered_maps can be round-tripped") {
sol::state lua; sol::state lua;
std::unordered_map<std::string, int> v{ { "a", 1 }, { "b", 2 }, { "c", 3 } }; std::unordered_map<std::string, int> v{ { "a", 1 }, { "b", 2 }, { "c", 3 } };
lua.set_function("f", [&]() { lua.set_function("f", as_table_callable<std::unordered_map<std::string, int>>(v));
return sol::as_table(v);
});
auto result1 = lua.safe_script("x = f()", sol::script_pass_on_error); auto result1 = lua.safe_script("x = f()", sol::script_pass_on_error);
REQUIRE(result1.valid()); REQUIRE(result1.valid());
sol::as_table_t<std::unordered_map<std::string, int>> x = lua["x"]; sol::as_table_t<std::unordered_map<std::string, int>> x = lua["x"];
@ -132,9 +131,7 @@ TEST_CASE("containers/unordered_map table roundtrip", "make sure unordered_maps
TEST_CASE("containers/unordered_set table roundtrip", "make sure unordered_sets can be round-tripped") { TEST_CASE("containers/unordered_set table roundtrip", "make sure unordered_sets can be round-tripped") {
sol::state lua; sol::state lua;
std::unordered_set<int> v{ 1, 2, 3 }; std::unordered_set<int> v{ 1, 2, 3 };
lua.set_function("f", [&]() { lua.set_function("f", as_table_callable<std::unordered_set<int>>(v));
return sol::as_table(v);
});
auto result1 = lua.safe_script("x = f()", sol::script_pass_on_error); auto result1 = lua.safe_script("x = f()", sol::script_pass_on_error);
REQUIRE(result1.valid()); REQUIRE(result1.valid());
sol::as_table_t<std::unordered_set<int>> x = lua["x"]; sol::as_table_t<std::unordered_set<int>> x = lua["x"];
@ -145,9 +142,7 @@ TEST_CASE("containers/unordered_set table roundtrip", "make sure unordered_sets
TEST_CASE("containers/set table roundtrip", "make sure sets can be round-tripped") { TEST_CASE("containers/set table roundtrip", "make sure sets can be round-tripped") {
sol::state lua; sol::state lua;
std::set<int> v{ 1, 2, 3 }; std::set<int> v{ 1, 2, 3 };
lua.set_function("f", [&]() { lua.set_function("f", as_table_callable<std::set<int>>(v));
return sol::as_table(v);
});
auto result1 = lua.safe_script("x = f()", sol::script_pass_on_error); auto result1 = lua.safe_script("x = f()", sol::script_pass_on_error);
REQUIRE(result1.valid()); REQUIRE(result1.valid());
sol::as_table_t<std::set<int>> x = lua["x"]; sol::as_table_t<std::set<int>> x = lua["x"];

19
tests/runtime_tests/source/containers.cpp
View File

@ -37,13 +37,24 @@
#include <set> #include <set>
#include <unordered_set> #include <unordered_set>
inline namespace sol2_test_containers {
struct returns_callable {
std::vector<int>* ptr;
returns_callable(std::vector<int>& ref_) : ptr(&ref_) {
}
std::vector<int>& operator()() const {
REQUIRE(ptr->size() == 3);
return *ptr;
}
};
} // namespace sol2_test_containers
TEST_CASE("containers/returns", "make sure that even references to vectors are being serialized as tables") { TEST_CASE("containers/returns", "make sure that even references to vectors are being serialized as tables") {
sol::state lua; sol::state lua;
std::vector<int> v{ 1, 2, 3 }; std::vector<int> v{ 1, 2, 3 };
auto f = [&]() -> std::vector<int>& { returns_callable f(v);
REQUIRE(v.size() == 3);
return v;
};
lua.set_function("f", f); lua.set_function("f", f);
auto result1 = lua.safe_script("x = f()", sol::script_pass_on_error); auto result1 = lua.safe_script("x = f()", sol::script_pass_on_error);
REQUIRE(result1.valid()); REQUIRE(result1.valid());

89
tests/runtime_tests/source/coroutines.cpp
View File

@ -25,6 +25,39 @@
#include <catch.hpp> #include <catch.hpp>
inline namespace sol2_test_coroutines {
struct coroutine_thread_runner_state {
sol::state_view* prunner_thread_state;
coroutine_thread_runner_state(sol::state_view& ref_) : prunner_thread_state(&ref_) {
}
auto operator()() const {
sol::state_view& runner_thread_state = *prunner_thread_state;
sol::coroutine cr = runner_thread_state["loop"];
sol::stack::push(runner_thread_state, 50);
sol::stack::push(runner_thread_state, 25);
int r = cr();
return r;
}
};
struct coroutine_thread_runner {
sol::thread* prunner_thread;
coroutine_thread_runner(sol::thread& ref_) : prunner_thread(&ref_) {
}
auto operator()() const {
sol::thread& runner_thread = *prunner_thread;
sol::state_view th_state = runner_thread.state();
sol::coroutine cr = th_state["loop"];
int r = cr();
return r;
}
};
} // namespace sol2_test_coroutines
struct coro_h { struct coro_h {
int x = 500; int x = 500;
int func() { int func() {
@ -155,9 +188,7 @@ TEST_CASE("coroutines/transfer", "test that things created inside of a coroutine
lua.open_libraries(); lua.open_libraries();
{ {
sol::function f2; sol::function f2;
lua["f"] = [&lua, &f2](sol::object t) { lua["f"] = [&lua, &f2](sol::object t) { f2 = sol::function(lua, t); };
f2 = sol::function(lua, t);
};
{ {
auto code = R"( auto code = R"(
i = 0 i = 0
@ -242,9 +273,12 @@ co = nil
lua.new_usertype<coro_test>("coro_test", lua.new_usertype<coro_test>("coro_test",
sol::constructors<coro_test(sol::this_state, std::string)>(), sol::constructors<coro_test(sol::this_state, std::string)>(),
"store", &coro_test::store, "store",
"copy_store", &coro_test::copy_store, &coro_test::store,
"get", &coro_test::get); "copy_store",
&coro_test::copy_store,
"get",
&coro_test::get);
auto r = lua.safe_script(code, sol::script_pass_on_error); auto r = lua.safe_script(code, sol::script_pass_on_error);
REQUIRE(r.valid()); REQUIRE(r.valid());
@ -299,8 +333,7 @@ co = nil
std::string identifier; std::string identifier;
sol::reference obj; sol::reference obj;
coro_test_implicit(sol::this_state L, std::string id) coro_test_implicit(sol::this_state L, std::string id) : identifier(id), obj(L, sol::lua_nil) {
: identifier(id), obj(L, sol::lua_nil) {
} }
void store(sol::table ref) { void store(sol::table ref) {
@ -326,9 +359,12 @@ co = nil
lua.new_usertype<coro_test_implicit>("coro_test", lua.new_usertype<coro_test_implicit>("coro_test",
sol::constructors<coro_test_implicit(sol::this_state, std::string)>(), sol::constructors<coro_test_implicit(sol::this_state, std::string)>(),
"store", &coro_test_implicit::store, "store",
"copy_store", &coro_test_implicit::copy_store, &coro_test_implicit::store,
"get", &coro_test_implicit::get); "copy_store",
&coro_test_implicit::copy_store,
"get",
&coro_test_implicit::get);
auto r = lua.safe_script(code, sol::script_pass_on_error); auto r = lua.safe_script(code, sol::script_pass_on_error);
REQUIRE(r.valid()); REQUIRE(r.valid());
@ -383,9 +419,12 @@ collectgarbage()
lua.new_usertype<coro_test_implicit>("coro_test", lua.new_usertype<coro_test_implicit>("coro_test",
sol::constructors<coro_test_implicit(sol::this_state, std::string)>(), sol::constructors<coro_test_implicit(sol::this_state, std::string)>(),
"store", &coro_test_implicit::store, "store",
"copy_store", &coro_test_implicit::copy_store, &coro_test_implicit::store,
"get", &coro_test_implicit::get); "copy_store",
&coro_test_implicit::copy_store,
"get",
&coro_test_implicit::get);
auto r = lua.safe_script(code, sol::script_pass_on_error); auto r = lua.safe_script(code, sol::script_pass_on_error);
REQUIRE(r.valid()); REQUIRE(r.valid());
@ -404,7 +443,8 @@ collectgarbage()
REQUIRE(s == "SOME_TABLE"); REQUIRE(s == "SOME_TABLE");
} }
TEST_CASE("coroutines/coroutine.create protection", "ensure that a thread picked up from coroutine.create does not throw off the lua stack entirely when called from C++") { TEST_CASE("coroutines/coroutine.create protection",
"ensure that a thread picked up from coroutine.create does not throw off the lua stack entirely when called from C++") {
sol::state lua; sol::state lua;
lua.open_libraries(sol::lib::base, sol::lib::coroutine); lua.open_libraries(sol::lib::base, sol::lib::coroutine);
@ -425,12 +465,7 @@ loop_th = coroutine.create(loop)
REQUIRE(r.valid()); REQUIRE(r.valid());
sol::thread runner_thread = lua["loop_th"]; sol::thread runner_thread = lua["loop_th"];
auto test_resume = [&runner_thread]() { coroutine_thread_runner test_resume(runner_thread);
sol::state_view th_state = runner_thread.state();
sol::coroutine cr = th_state["loop"];
int r = cr();
return r;
};
lua.set_function("test_resume", std::ref(test_resume)); lua.set_function("test_resume", std::ref(test_resume));
@ -480,13 +515,7 @@ end
// Resume from lua via thread and coroutine // Resume from lua via thread and coroutine
sol::thread runner_thread = lua["loop_th"]; sol::thread runner_thread = lua["loop_th"];
sol::state_view runner_thread_state = runner_thread.state(); sol::state_view runner_thread_state = runner_thread.state();
auto test_resume = [&runner_thread_state]() { coroutine_thread_runner_state test_resume(runner_thread_state);
sol::coroutine cr = runner_thread_state["loop"];
sol::stack::push(runner_thread_state, 50);
sol::stack::push(runner_thread_state, 25);
int r = cr();
return r;
};
lua.set_function("test_resume", std::ref(test_resume)); lua.set_function("test_resume", std::ref(test_resume));
// Resume via getting a sol::function from the state // Resume via getting a sol::function from the state
@ -598,9 +627,7 @@ TEST_CASE("coroutines/yielding", "test that a sol3 bound function can yield when
lua["hobj"] = &hobj; lua["hobj"] = &hobj;
lua.new_usertype<coro_h>("coro_h", lua.new_usertype<coro_h>("coro_h", "h", sol::yielding(&coro_h::func));
"h", sol::yielding(&coro_h::func)
);
sol::string_view code = R"( sol::string_view code = R"(
co4 = coroutine.create(function() co4 = coroutine.create(function()

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

@ -117,6 +117,21 @@ namespace sol {
} // namespace stack } // namespace stack
} // namespace sol } // namespace sol
inline namespace sol2_test_customizations_private {
struct boolean_set_true {
bool* pTwoThingsWorks;
boolean_set_true(bool& ref_) : pTwoThingsWorks(&ref_) {
}
void operator()(two_things) const {
bool& TwoThingsWorks = *pTwoThingsWorks;
TwoThingsWorks = true;
}
};
} // namespace sol2_test_customizations_private
TEST_CASE("customization/split struct", "using the old 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; sol::state lua;
@ -166,8 +181,8 @@ TEST_CASE("customization/usertype", "using the old customization points to handl
TEST_CASE("customization/overloading", "using multi-size customized types in an overload") { TEST_CASE("customization/overloading", "using multi-size customized types in an overload") {
bool TwoThingsWorks = false, OverloadWorks = false; bool TwoThingsWorks = false, OverloadWorks = false;
sol::state lua; sol::state lua;
lua["test_two_things"] = [&](two_things) { TwoThingsWorks = true; }; lua["test_two_things"] = boolean_set_true(TwoThingsWorks);
lua["test_overload"] = sol::overload([&](two_things) { OverloadWorks = true; }, [] {}); lua["test_overload"] = sol::overload(boolean_set_true(OverloadWorks), [] {});
lua.script( lua.script(
"test_two_things(0, true)\n" "test_two_things(0, true)\n"

92
tests/runtime_tests/source/environments.cpp
View File

@ -27,6 +27,64 @@
#include <iostream> #include <iostream>
inline namespace sol2_test_environments {
struct check_g_env {
sol::state* plua;
sol::environment* penv_g;
check_g_env(sol::state& lua, sol::environment& env_g) : plua(&lua), penv_g(&env_g) {
}
void operator()(sol::function target) const {
sol::state& lua = *plua;
sol::environment& env_g = *penv_g;
sol::stack_guard luasg(lua);
sol::environment target_env = sol::get_environment(target);
int test_env_g = env_g["test"];
int test_target_env = target_env["test"];
REQUIRE(test_env_g == test_target_env);
REQUIRE(test_env_g == 5);
REQUIRE(env_g == target_env);
}
};
struct check_f_env {
sol::state* plua;
sol::environment* penv_f;
check_f_env(sol::state& lua, sol::environment& env_f) : plua(&lua), penv_f(&env_f) {
}
void operator()(sol::function target) const {
sol::state& lua = *plua;
sol::environment& env_f = *penv_f;
sol::stack_guard luasg(lua);
sol::environment target_env(sol::env_key, target);
int test_env_f = env_f["test"];
int test_target_env = target_env["test"];
REQUIRE(test_env_f == test_target_env);
REQUIRE(test_env_f == 31);
REQUIRE(env_f == target_env);
}
};
struct check_h_env {
sol::state* plua;
check_h_env(sol::state& lua) : plua(&lua) {
}
void operator()(sol::function target) const {
sol::state& lua = *plua;
sol::stack_guard luasg(lua);
sol::environment target_env = sol::get_environment(target);
// cannot strictly test
// if it's the global table, because different lua runtimes
// give different envs when there is no env
}
};
} // namespace sol2_test_environments
TEST_CASE("environments/get", "Envronments can be taken out of things like Lua functions properly") { TEST_CASE("environments/get", "Envronments can be taken out of things like Lua functions properly") {
sol::state lua; sol::state lua;
sol::stack_guard luasg(lua); sol::stack_guard luasg(lua);
@ -61,37 +119,15 @@ TEST_CASE("environments/get", "Envronments can be taken out of things like Lua f
auto result3 = lua.safe_script("h = function() end", sol::script_pass_on_error); auto result3 = lua.safe_script("h = function() end", sol::script_pass_on_error);
REQUIRE(result3.valid()); REQUIRE(result3.valid());
lua.set_function("check_f_env", lua.set_function("check_f_env", check_f_env(lua, env_f));
[&lua, &env_f](sol::object target) { lua.set_function("check_g_env", check_g_env(lua, env_g));
sol::stack_guard luasg(lua); lua.set_function("check_h_env", check_h_env(lua));
sol::environment target_env(sol::env_key, target);
int test_env_f = env_f["test"];
int test_target_env = target_env["test"];
REQUIRE(test_env_f == test_target_env);
REQUIRE(test_env_f == 31);
REQUIRE(env_f == target_env);
});
lua.set_function("check_g_env",
[&lua, &env_g](sol::function target) {
sol::stack_guard luasg(lua);
sol::environment target_env = sol::get_environment(target);
int test_env_g = env_g["test"];
int test_target_env = target_env["test"];
REQUIRE(test_env_g == test_target_env);
REQUIRE(test_env_g == 5);
REQUIRE(env_g == target_env);
});
lua.set_function("check_h_env",
[&lua](sol::function target) {
sol::stack_guard luasg(lua);
sol::environment target_env = sol::get_environment(target);
});
auto checkf = lua.safe_script("check_f_env(f)"); auto checkf = lua.safe_script("check_f_env(f)", sol::script_pass_on_error);
REQUIRE(checkf.valid()); REQUIRE(checkf.valid());
auto checkg = lua.safe_script("check_g_env(g)"); auto checkg = lua.safe_script("check_g_env(g)", sol::script_pass_on_error);
REQUIRE(checkg.valid()); REQUIRE(checkg.valid());
auto checkh = lua.safe_script("check_h_env(h)"); auto checkh = lua.safe_script("check_h_env(h)", sol::script_pass_on_error);
REQUIRE(checkh.valid()); REQUIRE(checkh.valid());
} }

2
tests/runtime_tests/source/functions.cpp
View File

@ -239,7 +239,7 @@ end )",
REQUIRE(v->v == 29); REQUIRE(v->v == 29);
} }
TEST_CASE("functions/pair and tuple and proxy tests", "Check if sol::reference and sol::proxy can be passed to functions as arguments") { TEST_CASE("functions/pair and tuple and table_proxy tests", "Check if sol::reference and sol::table_proxy can be passed to functions as arguments") {
sol::state lua; sol::state lua;
sol::stack_guard luasg(lua); sol::stack_guard luasg(lua);

86
tests/runtime_tests/source/large_integer.cpp
View File

@ -28,16 +28,44 @@
#include <cstdint> #include <cstdint>
#include <limits> #include <limits>
inline namespace sol2_test_large_integer {
inline bool bool_roundtrip(bool num) {
REQUIRE(num == true);
return num;
}
inline void trigger_passthrough_crash(sol::state& lua) {
sol::protected_function pf = lua["f"];
auto result = pf(0xFFFFFFFFFFFFFFFFull);
(void)result;
}
template <typename T>
inline T intT_passthrough(T num) {
return num;
}
template <typename T>
inline T intT_roundtrip(T num) {
REQUIRE(num == std::numeric_limits<T>::max());
return num;
}
inline std::uint64_t int53_roundtrip(std::uint64_t num) {
REQUIRE(num == 0x1FFFFFFFFFFFFFull);
return num;
}
} // namespace sol2_test_large_integer
TEST_CASE("large_integer/bool", "pass bool integral value to and from lua") { TEST_CASE("large_integer/bool", "pass bool integral value to and from lua") {
sol::state lua; sol::state lua;
lua.open_libraries(); lua.open_libraries();
lua.set_function("f", [&](bool num) { lua.set_function("f", bool_roundtrip);
REQUIRE(num == true); sol::optional<sol::error> result1 = lua.safe_script(
return num; "x = f(true)\n"
}); "assert(x == true)",
auto result1 = lua.safe_script("x = f(true)\n" sol::script_pass_on_error);
"assert(x == true)", sol::script_pass_on_error); REQUIRE_FALSE(result1.has_value());
REQUIRE(result1.valid());
sol::object x = lua["x"]; sol::object x = lua["x"];
REQUIRE(x.is<bool>()); REQUIRE(x.is<bool>());
REQUIRE(x.as<bool>() == true); REQUIRE(x.as<bool>() == true);
@ -52,12 +80,11 @@ TEST_CASE("large_integers/unsigned32", "pass large unsigned 32bit values to and
using T = std::uint32_t; using T = std::uint32_t;
sol::state lua; sol::state lua;
lua.open_libraries(); lua.open_libraries();
lua.set_function("f", [&](T num) -> T { lua.set_function("f", intT_roundtrip<T>);
REQUIRE(num == 0xFFFFFFFF); auto result1 = lua.safe_script(
return num; "x = f(0xFFFFFFFF)\n"
}); "assert(x == 0xFFFFFFFF)",
auto result1 = lua.safe_script("x = f(0xFFFFFFFF)\n" sol::script_pass_on_error);
"assert(x == 0xFFFFFFFF)", sol::script_pass_on_error);
REQUIRE(result1.valid()); REQUIRE(result1.valid());
sol::object x = lua["x"]; sol::object x = lua["x"];
REQUIRE(x.is<T>()); REQUIRE(x.is<T>());
@ -68,11 +95,9 @@ TEST_CASE("large_integer/unsigned53", "pass large unsigned 53bit value to and fr
using T = std::uint64_t; using T = std::uint64_t;
sol::state lua; sol::state lua;
lua.open_libraries(); lua.open_libraries();
lua.set_function("f", [&](T num) -> T { lua.set_function("f", int53_roundtrip);
REQUIRE(num == 0x1FFFFFFFFFFFFFull); auto result1 = lua.safe_script(
return num; "x = f(0x1FFFFFFFFFFFFF)\n"
});
auto result1 = lua.safe_script("x = f(0x1FFFFFFFFFFFFF)\n"
"assert(x == 0x1FFFFFFFFFFFFF)"); "assert(x == 0x1FFFFFFFFFFFFF)");
REQUIRE(result1.valid()); REQUIRE(result1.valid());
sol::object x = lua["x"]; sol::object x = lua["x"];
@ -83,30 +108,17 @@ TEST_CASE("large_integer/unsigned53", "pass large unsigned 53bit value to and fr
TEST_CASE("large_integer/unsigned64", "pass too large unsigned 64bit value to lua") { TEST_CASE("large_integer/unsigned64", "pass too large unsigned 64bit value to lua") {
using T = std::int64_t; using T = std::int64_t;
sol::state lua; sol::state lua;
lua.set_function("f", [&](T num) -> T { lua.set_function("f", intT_passthrough<T>);
return num; REQUIRE_THROWS(trigger_passthrough_crash(lua));
});
REQUIRE_THROWS([&lua]() {
sol::protected_function pf = lua["f"];
auto result = pf(0xFFFFFFFFFFFFFFFFull);
}());
} }
TEST_CASE("large_integer/double", "pass negative and large positive values as signed and unsigned from and to lua") { TEST_CASE("large_integer/double", "pass negative and large positive values as signed and unsigned from and to lua") {
sol::state lua; sol::state lua;
lua.open_libraries(); lua.open_libraries();
lua.set_function("s32", [&](std::int32_t num) { lua.set_function("s32", intT_passthrough<std::int32_t>);
return num; lua.set_function("s64", intT_passthrough<std::int64_t>);
}); lua.set_function("u32", intT_passthrough<std::uint32_t>);
lua.set_function("s64", [&](std::int64_t num) { lua.set_function("u64", intT_passthrough<std::uint64_t>);
return num;
});
lua.set_function("u32", [&](std::uint32_t num) {
return num;
});
lua.set_function("u64", [&](std::uint64_t num) {
return num;
});
{ {
// signed 32bit // signed 32bit
auto result1 = lua.safe_script("x = s32(-1)", sol::script_pass_on_error); auto result1 = lua.safe_script("x = s32(-1)", sol::script_pass_on_error);

36
tests/runtime_tests/source/tables.cpp
View File

@ -238,7 +238,8 @@ TEST_CASE("tables/optional move", "ensure pushing a sol::optional<T> rvalue corr
sol::state sol_state; sol::state sol_state;
struct move_only { struct move_only {
int secret_code; int secret_code;
move_only(int sc) : secret_code(sc) {} move_only(int sc) : secret_code(sc) {
}
move_only(const move_only&) = delete; move_only(const move_only&) = delete;
move_only(move_only&&) = default; move_only(move_only&&) = default;
@ -248,3 +249,36 @@ TEST_CASE("tables/optional move", "ensure pushing a sol::optional<T> rvalue corr
sol_state["requires_move"] = sol::optional<move_only>(move_only(0x4D)); sol_state["requires_move"] = sol::optional<move_only>(move_only(0x4D));
REQUIRE(sol_state["requires_move"].get<move_only>().secret_code == 0x4D); REQUIRE(sol_state["requires_move"].get<move_only>().secret_code == 0x4D);
} }
TEST_CASE("table/stack table size", "make sure size() works correctly on stack tables") {
sol::state lua;
sol::stack_guard luasg(lua);
sol::stack_table t(lua, sol::create);
t[1] = 42;
auto sz1 = t.size();
REQUIRE(sz1 == 1);
sol::stack::push(lua, "some string");
auto sz2 = t.size();
REQUIRE(sz2 == 1);
std::string s = sol::stack::pop<std::string>(lua);
REQUIRE(s == "some string");
sol::table t2 = sol::stack::pop<sol::table>(lua);
auto sz3 = t2.size();
REQUIRE(sz1 == sz3);
REQUIRE(sz1 == sz2);
}
TEST_CASE("table/proxy call", "test proxy calls put the variable in the right place") {
sol::state lua;
sol::stack_guard luasg(lua);
{
sol::stack_guard tsg(lua);
lua["t"] = std::initializer_list<std::pair<int, std::string_view>>{ { 1, "borf" }, { 2, "bjork" }, { 3, "waf" } };
}
{
sol::stack_guard fsg(lua);
lua["f"] = [](std::string bjork) { REQUIRE(bjork == std::string("borf")); };
}
auto prox = lua["t"][1];
lua["f"](prox);
}

14
tests/runtime_tests/source/tables.insertion.cpp
View File

@ -27,7 +27,7 @@
#include <iostream> #include <iostream>
TEST_CASE("tables/proxy override_value", "allow override_value by way of key") { TEST_CASE("tables/table_proxy override_value", "allow override_value by way of key") {
sol::state lua; sol::state lua;
sol::stack_guard luasg(lua); sol::stack_guard luasg(lua);
lua.open_libraries(sol::lib::base, sol::lib::io); lua.open_libraries(sol::lib::base, sol::lib::io);
@ -59,7 +59,7 @@ TEST_CASE("tables/insertion override", "allow override all non-table values plus
REQUIRE(*b_totally_there == 500); REQUIRE(*b_totally_there == 500);
REQUIRE_FALSE(static_cast<bool>(totally_not_there)); REQUIRE_FALSE(static_cast<bool>(totally_not_there));
} }
SECTION("proxy") { SECTION("table_proxy") {
sol::state lua; sol::state lua;
sol::stack_guard luasg(lua); sol::stack_guard luasg(lua);
@ -77,7 +77,7 @@ TEST_CASE("tables/insertion override", "allow override all non-table values plus
REQUIRE(*b_totally_there == 500); REQUIRE(*b_totally_there == 500);
REQUIRE_FALSE(static_cast<bool>(totally_not_there)); REQUIRE_FALSE(static_cast<bool>(totally_not_there));
} }
SECTION("complex proxy") { SECTION("complex table_proxy") {
sol::state lua; sol::state lua;
sol::stack_guard luasg(lua); sol::stack_guard luasg(lua);
@ -104,7 +104,7 @@ TEST_CASE("tables/insertion update_if_empty", "allow updating a value only if it
REQUIRE(static_cast<bool>(totally_there)); REQUIRE(static_cast<bool>(totally_there));
REQUIRE(*totally_there == 357); REQUIRE(*totally_there == 357);
} }
SECTION("proxy") { SECTION("table_proxy") {
sol::state lua; sol::state lua;
sol::stack_guard luasg(lua); sol::stack_guard luasg(lua);
@ -120,7 +120,7 @@ TEST_CASE("tables/insertion update_if_empty", "allow updating a value only if it
REQUIRE(static_cast<bool>(totally_there_still)); REQUIRE(static_cast<bool>(totally_there_still));
REQUIRE(*totally_there_still == 357); REQUIRE(*totally_there_still == 357);
} }
SECTION("proxy invoker") { SECTION("table_proxy invoker") {
sol::state lua; sol::state lua;
sol::stack_guard luasg(lua); sol::stack_guard luasg(lua);
@ -165,7 +165,7 @@ TEST_CASE("tables/get create_if_nil", "create tables all the way down") {
REQUIRE(static_cast<bool>(totally_created)); REQUIRE(static_cast<bool>(totally_created));
REQUIRE(static_cast<bool>(totally_there)); REQUIRE(static_cast<bool>(totally_there));
} }
SECTION("proxy non-optional") { SECTION("table_proxy non-optional") {
sol::state lua; sol::state lua;
sol::stack_guard luasg_outer(lua); sol::stack_guard luasg_outer(lua);
@ -181,7 +181,7 @@ TEST_CASE("tables/get create_if_nil", "create tables all the way down") {
} }
} }
SECTION("proxy") { SECTION("table_proxy") {
sol::state lua; sol::state lua;
sol::stack_guard luasg(lua); sol::stack_guard luasg(lua);