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

add single

Browse Source
This commit is contained in:
ThePhD 2017-04-02 16:30:14 -04:00
parent 34c7b741d2
commit f4434393ce
1 changed files with 330 additions and 156 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

484
single/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 2017-04-01 02:39:08.628086 UTC // Generated 2017-04-02 20:29:59.118420 UTC
// This header was generated with sol v2.16.0 (revision 91aff61) // This header was generated with sol v2.16.0 (revision 34c7b74)
// https://github.com/ThePhD/sol2 // https://github.com/ThePhD/sol2
#ifndef SOL_SINGLE_INCLUDE_HPP #ifndef SOL_SINGLE_INCLUDE_HPP
@ -799,7 +799,7 @@ namespace sol {
#include <lauxlib.h> #include <lauxlib.h>
#else #else
#include <lua.hpp> #include <lua.hpp>
#endif // C++-compiler Lua #endif // C++ Mangming for Lua
#if defined(_WIN32) || defined(_MSC_VER) #if defined(_WIN32) || defined(_MSC_VER)
#ifndef SOL_CODECVT_SUPPORT #ifndef SOL_CODECVT_SUPPORT
@ -890,9 +890,8 @@ namespace sol {
#ifndef SOL_NO_COMPAT #ifndef SOL_NO_COMPAT
#ifdef __cplusplus #ifdef SOL_USING_CXX_LUA
extern "C" {
#endif
// beginning of sol/compatibility/5.1.0.h // beginning of sol/compatibility/5.1.0.h
#ifndef SOL_5_1_0_H #ifndef SOL_5_1_0_H
@ -1812,10 +1811,17 @@ inline void luaL_pushresult(luaL_Buffer_52 *B) {
#endif // SOL_5_X_X_INL #endif // SOL_5_X_X_INL
// end of sol/compatibility/5.x.x.inl // end of sol/compatibility/5.x.x.inl
#else
#ifdef __cplusplus
extern "C" {
#endif
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif // C++ Mangling for Lua
#endif // SOL_NO_COMPAT #endif // SOL_NO_COMPAT
// end of sol/compatibility.hpp // end of sol/compatibility.hpp
@ -3083,6 +3089,9 @@ namespace sol {
return std::addressof(item); return std::addressof(item);
} }
}; };
struct unchecked_t {};
const unchecked_t unchecked = unchecked_t{};
} // detail } // detail
struct lua_nil_t {}; struct lua_nil_t {};
@ -3550,10 +3559,16 @@ namespace sol {
using table_core = basic_table_core<b, reference>; using table_core = basic_table_core<b, reference>;
template <bool b> template <bool b>
using stack_table_core = basic_table_core<b, stack_reference>; using stack_table_core = basic_table_core<b, stack_reference>;
template <typename T>
using basic_table = basic_table_core<false, T>;
typedef table_core<false> table; typedef table_core<false> table;
typedef table_core<true> global_table; typedef table_core<true> global_table;
typedef stack_table_core<false> stack_table; typedef stack_table_core<false> stack_table;
typedef stack_table_core<true> stack_global_table; typedef stack_table_core<true> stack_global_table;
template <typename base_t>
struct basic_environment;
using environment = basic_environment<reference>;
using stack_environment = basic_environment<stack_reference>;
template <typename T> template <typename T>
class basic_function; class basic_function;
template <typename T> template <typename T>
@ -3974,6 +3989,22 @@ namespace sol {
inline bool operator!= (const stack_reference& l, const stack_reference& r) { inline bool operator!= (const stack_reference& l, const stack_reference& r) {
return !operator==(l, r); return !operator==(l, r);
} }
inline bool operator==(const stack_reference& lhs, const lua_nil_t&) {
return !lhs.valid();
}
inline bool operator==(const lua_nil_t&, const stack_reference& rhs) {
return !rhs.valid();
}
inline bool operator!=(const stack_reference& lhs, const lua_nil_t&) {
return lhs.valid();
}
inline bool operator!=(const lua_nil_t&, const stack_reference& rhs) {
return rhs.valid();
}
} // sol } // sol
// end of sol/stack_reference.hpp // end of sol/stack_reference.hpp
@ -4142,6 +4173,22 @@ namespace sol {
inline bool operator!= (const reference& l, const reference& r) { inline bool operator!= (const reference& l, const reference& r) {
return !operator==(l, r); return !operator==(l, r);
} }
inline bool operator==(const reference& lhs, const lua_nil_t&) {
return !lhs.valid();
}
inline bool operator==(const lua_nil_t&, const reference& rhs) {
return !rhs.valid();
}
inline bool operator!=(const reference& lhs, const lua_nil_t&) {
return lhs.valid();
}
inline bool operator!=(const lua_nil_t&, const reference& rhs) {
return rhs.valid();
}
} // sol } // sol
// end of sol/reference.hpp // end of sol/reference.hpp
@ -4150,81 +4197,6 @@ namespace sol {
// beginning of sol/stack_core.hpp // beginning of sol/stack_core.hpp
// beginning of sol/userdata.hpp
namespace sol {
template <typename base_t>
class basic_userdata : public base_t {
public:
basic_userdata() noexcept = default;
template <typename T, meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, basic_userdata>>, meta::neg<std::is_same<base_t, stack_reference>>, std::is_base_of<base_t, meta::unqualified_t<T>>> = meta::enabler>
basic_userdata(T&& r) noexcept : base_t(std::forward<T>(r)) {
#ifdef SOL_CHECK_ARGUMENTS
if (!is_userdata<meta::unqualified_t<T>>::value) {
auto pp = stack::push_pop(*this);
type_assert(base_t::lua_state(), -1, type::userdata);
}
#endif // Safety
}
basic_userdata(const basic_userdata&) = default;
basic_userdata(basic_userdata&&) = default;
basic_userdata& operator=(const basic_userdata&) = default;
basic_userdata& operator=(basic_userdata&&) = default;
basic_userdata(const stack_reference& r) : basic_userdata(r.lua_state(), r.stack_index()) {}
basic_userdata(stack_reference&& r) : basic_userdata(r.lua_state(), r.stack_index()) {}
template <typename T, meta::enable<meta::neg<std::is_integral<meta::unqualified_t<T>>>, meta::neg<std::is_same<T, ref_index>>> = meta::enabler>
basic_userdata(lua_State* L, T&& r) : basic_userdata(L, sol::ref_index(r.registry_index())) {}
basic_userdata(lua_State* L, int index = -1) : base_t(L, index) {
#ifdef SOL_CHECK_ARGUMENTS
type_assert(L, index, type::userdata);
#endif // Safety
}
basic_userdata(lua_State* L, ref_index index) : base_t(L, index) {
#ifdef SOL_CHECK_ARGUMENTS
auto pp = stack::push_pop(*this);
type_assert(L, -1, type::userdata);
#endif // Safety
}
};
template <typename base_t>
class basic_lightuserdata : public base_t {
public:
basic_lightuserdata() noexcept = default;
template <typename T, meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, basic_lightuserdata>>, meta::neg<std::is_same<base_t, stack_reference>>, std::is_base_of<base_t, meta::unqualified_t<T>>> = meta::enabler>
basic_lightuserdata(T&& r) noexcept : base_t(std::forward<T>(r)) {
#ifdef SOL_CHECK_ARGUMENTS
if (!is_userdata<meta::unqualified_t<T>>::value) {
auto pp = stack::push_pop(*this);
type_assert(base_t::lua_state(), -1, type::lightuserdata);
}
#endif // Safety
}
basic_lightuserdata(const basic_lightuserdata&) = default;
basic_lightuserdata(basic_lightuserdata&&) = default;
basic_lightuserdata& operator=(const basic_lightuserdata&) = default;
basic_lightuserdata& operator=(basic_lightuserdata&&) = default;
basic_lightuserdata(const stack_reference& r) : basic_lightuserdata(r.lua_state(), r.stack_index()) {}
basic_lightuserdata(stack_reference&& r) : basic_lightuserdata(r.lua_state(), r.stack_index()) {}
template <typename T, meta::enable<meta::neg<std::is_integral<meta::unqualified_t<T>>>, meta::neg<std::is_same<T, ref_index>>> = meta::enabler>
basic_lightuserdata(lua_State* L, T&& r) : basic_lightuserdata(L, sol::ref_index(r.registry_index())) {}
basic_lightuserdata(lua_State* L, int index = -1) : base_t(L, index) {
#ifdef SOL_CHECK_ARGUMENTS
type_assert(L, index, type::lightuserdata);
#endif // Safety
}
basic_lightuserdata(lua_State* L, ref_index index) : base_t(L, index) {
#ifdef SOL_CHECK_ARGUMENTS
auto pp = stack::push_pop(*this);
type_assert(L, -1, type::lightuserdata);
#endif // Safety
}
};
} // sol
// end of sol/userdata.hpp
// beginning of sol/tie.hpp // beginning of sol/tie.hpp
namespace sol { namespace sol {
@ -7323,6 +7295,140 @@ namespace sol {
// end of sol/stack.hpp // end of sol/stack.hpp
// beginning of sol/object_base.hpp
namespace sol {
template <typename base_t>
class basic_object_base : public base_t {
private:
template<typename T>
decltype(auto) as_stack(std::true_type) const {
return stack::get<T>(base_t::lua_state(), base_t::stack_index());
}
template<typename T>
decltype(auto) as_stack(std::false_type) const {
base_t::push();
return stack::pop<T>(base_t::lua_state());
}
template<typename T>
bool is_stack(std::true_type) const {
return stack::check<T>(base_t::lua_state(), base_t::stack_index(), no_panic);
}
template<typename T>
bool is_stack(std::false_type) const {
int r = base_t::registry_index();
if (r == LUA_REFNIL)
return meta::any_same<meta::unqualified_t<T>, lua_nil_t, nullopt_t, std::nullptr_t>::value ? true : false;
if (r == LUA_NOREF)
return false;
auto pp = stack::push_pop(*this);
return stack::check<T>(base_t::lua_state(), -1, no_panic);
}
public:
basic_object_base() noexcept = default;
basic_object_base(const basic_object_base&) = default;
basic_object_base(basic_object_base&&) = default;
basic_object_base& operator=(const basic_object_base&) = default;
basic_object_base& operator=(basic_object_base&&) = default;
template <typename T, typename... Args, meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, basic_object_base>>> = meta::enabler>
basic_object_base(T&& arg, Args&&... args) : base_t(std::forward<T>(arg), std::forward<Args>(args)...) { }
template<typename T>
decltype(auto) as() const {
return as_stack<T>(std::is_same<base_t, stack_reference>());
}
template<typename T>
bool is() const {
return is_stack<T>(std::is_same<base_t, stack_reference>());
}
};
} // sol
// end of sol/object_base.hpp
// beginning of sol/userdata.hpp
namespace sol {
template <typename base_type>
class basic_userdata : public basic_table<base_type> {
typedef basic_table<base_type> base_t;
public:
basic_userdata() noexcept = default;
template <typename T, meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, basic_userdata>>, meta::neg<std::is_same<base_t, stack_reference>>, std::is_base_of<base_type, meta::unqualified_t<T>>> = meta::enabler>
basic_userdata(T&& r) noexcept : base_t(std::forward<T>(r)) {
#ifdef SOL_CHECK_ARGUMENTS
if (!is_userdata<meta::unqualified_t<T>>::value) {
auto pp = stack::push_pop(*this);
type_assert(base_t::lua_state(), -1, type::userdata);
}
#endif // Safety
}
basic_userdata(const basic_userdata&) = default;
basic_userdata(basic_userdata&&) = default;
basic_userdata& operator=(const basic_userdata&) = default;
basic_userdata& operator=(basic_userdata&&) = default;
basic_userdata(const stack_reference& r) : basic_userdata(r.lua_state(), r.stack_index()) {}
basic_userdata(stack_reference&& r) : basic_userdata(r.lua_state(), r.stack_index()) {}
template <typename T, meta::enable<meta::neg<std::is_integral<meta::unqualified_t<T>>>, meta::neg<std::is_same<meta::unqualified_t<T>, ref_index>>> = meta::enabler>
basic_userdata(lua_State* L, T&& r) : basic_userdata(L, sol::ref_index(r.registry_index())) {}
basic_userdata(lua_State* L, int index = -1) : base_t(L, index) {
#ifdef SOL_CHECK_ARGUMENTS
type_assert(L, index, type::userdata);
#endif // Safety
}
basic_userdata(lua_State* L, ref_index index) : base_t(L, index) {
#ifdef SOL_CHECK_ARGUMENTS
auto pp = stack::push_pop(*this);
type_assert(L, -1, type::userdata);
#endif // Safety
}
};
template <typename base_type>
class basic_lightuserdata : public basic_object_base< base_type > {
typedef basic_object_base<base_type> base_t;
public:
basic_lightuserdata() noexcept = default;
template <typename T, meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, basic_lightuserdata>>, meta::neg<std::is_same<base_t, stack_reference>>, std::is_base_of<base_type, meta::unqualified_t<T>>> = meta::enabler>
basic_lightuserdata(T&& r) noexcept : base_t(std::forward<T>(r)) {
#ifdef SOL_CHECK_ARGUMENTS
if (!is_lightuserdata<meta::unqualified_t<T>>::value) {
auto pp = stack::push_pop(*this);
type_assert(base_t::lua_state(), -1, type::lightuserdata);
}
#endif // Safety
}
basic_lightuserdata(const basic_lightuserdata&) = default;
basic_lightuserdata(basic_lightuserdata&&) = default;
basic_lightuserdata& operator=(const basic_lightuserdata&) = default;
basic_lightuserdata& operator=(basic_lightuserdata&&) = default;
basic_lightuserdata(const stack_reference& r) : basic_lightuserdata(r.lua_state(), r.stack_index()) {}
basic_lightuserdata(stack_reference&& r) : basic_lightuserdata(r.lua_state(), r.stack_index()) {}
template <typename T, meta::enable<meta::neg<std::is_integral<meta::unqualified_t<T>>>, meta::neg<std::is_same<meta::unqualified_t<T>, ref_index>>> = meta::enabler>
basic_lightuserdata(lua_State* L, T&& r) : basic_lightuserdata(L, sol::ref_index(r.registry_index())) {}
basic_lightuserdata(lua_State* L, int index = -1) : base_t(L, index) {
#ifdef SOL_CHECK_ARGUMENTS
type_assert(L, index, type::lightuserdata);
#endif // Safety
}
basic_lightuserdata(lua_State* L, ref_index index) : base_t(L, index) {
#ifdef SOL_CHECK_ARGUMENTS
auto pp = stack::push_pop(*this);
type_assert(L, -1, type::lightuserdata);
#endif // Safety
}
};
} // sol
// end of sol/userdata.hpp
// beginning of sol/as_args.hpp // beginning of sol/as_args.hpp
namespace sol { namespace sol {
@ -9987,35 +10093,10 @@ namespace sol {
return r; return r;
} }
template <typename base_t> template <typename base_type>
class basic_object : public base_t { class basic_object : public basic_object_base<base_type> {
private: private:
template<typename T> typedef basic_object_base<base_type> base_t;
decltype(auto) as_stack(std::true_type) const {
return stack::get<T>(base_t::lua_state(), base_t::stack_index());
}
template<typename T>
decltype(auto) as_stack(std::false_type) const {
base_t::push();
return stack::pop<T>(base_t::lua_state());
}
template<typename T>
bool is_stack(std::true_type) const {
return stack::check<T>(base_t::lua_state(), base_t::stack_index(), no_panic);
}
template<typename T>
bool is_stack(std::false_type) const {
int r = base_t::registry_index();
if (r == LUA_REFNIL)
return meta::any_same<meta::unqualified_t<T>, lua_nil_t, nullopt_t, std::nullptr_t>::value ? true : false;
if (r == LUA_NOREF)
return false;
auto pp = stack::push_pop(*this);
return stack::check<T>(base_t::lua_state(), -1, no_panic);
}
template <bool invert_and_pop = false> template <bool invert_and_pop = false>
basic_object(std::integral_constant<bool, invert_and_pop>, lua_State* L, int index = -1) noexcept : base_t(L, index) { basic_object(std::integral_constant<bool, invert_and_pop>, lua_State* L, int index = -1) noexcept : base_t(L, index) {
@ -10026,7 +10107,7 @@ namespace sol {
public: public:
basic_object() noexcept = default; basic_object() noexcept = default;
template <typename T, meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, basic_object>>, meta::neg<std::is_same<base_t, stack_reference>>, std::is_base_of<base_t, meta::unqualified_t<T>>> = meta::enabler> template <typename T, meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, basic_object>>, meta::neg<std::is_same<base_type, stack_reference>>, std::is_base_of<base_type, meta::unqualified_t<T>>> = meta::enabler>
basic_object(T&& r) : base_t(std::forward<T>(r)) {} basic_object(T&& r) : base_t(std::forward<T>(r)) {}
basic_object(lua_nil_t r) : base_t(r) {} basic_object(lua_nil_t r) : base_t(r) {}
basic_object(const basic_object&) = default; basic_object(const basic_object&) = default;
@ -10045,22 +10126,12 @@ namespace sol {
basic_object(lua_State* L, in_place_t, T&& arg, Args&&... args) noexcept : basic_object(L, in_place<T>, std::forward<T>(arg), std::forward<Args>(args)...) {} basic_object(lua_State* L, in_place_t, T&& arg, Args&&... args) noexcept : basic_object(L, in_place<T>, std::forward<T>(arg), std::forward<Args>(args)...) {}
basic_object& operator=(const basic_object&) = default; basic_object& operator=(const basic_object&) = default;
basic_object& operator=(basic_object&&) = default; basic_object& operator=(basic_object&&) = default;
basic_object& operator=(const base_t& b) { base_t::operator=(b); return *this; } basic_object& operator=(const base_type& b) { base_t::operator=(b); return *this; }
basic_object& operator=(base_t&& b) { base_t::operator=(std::move(b)); return *this; } basic_object& operator=(base_type&& b) { base_t::operator=(std::move(b)); return *this; }
template <typename Super> template <typename Super>
basic_object& operator=(const proxy_base<Super>& r) { this->operator=(r.operator basic_object()); return *this; } basic_object& operator=(const proxy_base<Super>& r) { this->operator=(r.operator basic_object()); return *this; }
template <typename Super> template <typename Super>
basic_object& operator=(proxy_base<Super>&& r) { this->operator=(r.operator basic_object()); return *this; } basic_object& operator=(proxy_base<Super>&& r) { this->operator=(r.operator basic_object()); return *this; }
template<typename T>
decltype(auto) as() const {
return as_stack<T>(std::is_same<base_t, stack_reference>());
}
template<typename T>
bool is() const {
return is_stack<T>(std::is_same<base_t, stack_reference>());
}
}; };
template <typename T> template <typename T>
@ -10072,22 +10143,6 @@ namespace sol {
object make_object(lua_State* L, Args&&... args) { object make_object(lua_State* L, Args&&... args) {
return make_reference<T, object, true>(L, std::forward<Args>(args)...); return make_reference<T, object, true>(L, std::forward<Args>(args)...);
} }
inline bool operator==(const object& lhs, const lua_nil_t&) {
return !lhs.valid();
}
inline bool operator==(const lua_nil_t&, const object& rhs) {
return !rhs.valid();
}
inline bool operator!=(const object& lhs, const lua_nil_t&) {
return lhs.valid();
}
inline bool operator!=(const lua_nil_t&, const object& rhs) {
return rhs.valid();
}
} // sol } // sol
// end of sol/object.hpp // end of sol/object.hpp
@ -12151,8 +12206,24 @@ namespace sol {
} }
} }
template <bool top_level, typename base_t> struct new_table {
class basic_table_core : public base_t { int sequence_hint = 0;
int map_hint = 0;
new_table() = default;
new_table(const new_table&) = default;
new_table(new_table&&) = default;
new_table& operator=(const new_table&) = default;
new_table& operator=(new_table&&) = default;
new_table(int sequence_hint, int map_hint = 0) : sequence_hint(sequence_hint), map_hint(map_hint) {}
};
const new_table create = new_table{};
template <bool top_level, typename base_type>
class basic_table_core : public basic_object_base<base_type> {
typedef basic_object_base<base_type> base_t;
friend class state; friend class state;
friend class state_view; friend class state_view;
@ -12265,30 +12336,26 @@ namespace sol {
traverse_set_deep<false>(std::forward<Keys>(keys)...); traverse_set_deep<false>(std::forward<Keys>(keys)...);
} }
basic_table_core(lua_State* L, detail::global_tag t) noexcept : reference(L, t) { } basic_table_core(lua_State* L, detail::global_tag t) noexcept : base_t(L, t) { }
public: public:
typedef basic_table_iterator<base_t> iterator; typedef basic_table_iterator<base_type> iterator;
typedef iterator const_iterator; typedef iterator const_iterator;
basic_table_core() noexcept : base_t() { } basic_table_core() noexcept = default;
template <typename T, meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, basic_table_core>>, meta::neg<std::is_same<base_t, stack_reference>>, std::is_base_of<base_t, meta::unqualified_t<T>>> = meta::enabler>
basic_table_core(T&& r) noexcept : base_t(std::forward<T>(r)) {
#ifdef SOL_CHECK_ARGUMENTS
if (!is_table<meta::unqualified_t<T>>::value) {
auto pp = stack::push_pop(*this);
stack::check<basic_table_core>(base_t::lua_state(), -1, type_panic);
}
#endif // Safety
}
basic_table_core(const basic_table_core&) = default; basic_table_core(const basic_table_core&) = default;
basic_table_core(basic_table_core&&) = default; basic_table_core(basic_table_core&&) = default;
basic_table_core& operator=(const basic_table_core&) = default; basic_table_core& operator=(const basic_table_core&) = default;
basic_table_core& operator=(basic_table_core&&) = default; basic_table_core& operator=(basic_table_core&&) = default;
basic_table_core(const stack_reference& r) : basic_table_core(r.lua_state(), r.stack_index()) {} basic_table_core(const stack_reference& r) : basic_table_core(r.lua_state(), r.stack_index()) {}
basic_table_core(stack_reference&& r) : basic_table_core(r.lua_state(), r.stack_index()) {} basic_table_core(stack_reference&& r) : basic_table_core(r.lua_state(), r.stack_index()) {}
template <typename T, meta::enable<meta::neg<std::is_integral<meta::unqualified_t<T>>>, meta::neg<std::is_same<T, ref_index>>> = meta::enabler> template <typename T, meta::enable<meta::neg<std::is_integral<meta::unqualified_t<T>>>, meta::neg<std::is_same<meta::unqualified_t<T>, ref_index>>> = meta::enabler>
basic_table_core(lua_State* L, T&& r) : basic_table_core(L, sol::ref_index(r.registry_index())) {} basic_table_core(lua_State* L, T&& r) : basic_table_core(L, sol::ref_index(r.registry_index())) {}
basic_table_core(lua_State* L, new_table nt) : base_t(L, (lua_createtable(L, nt.sequence_hint, nt.map_hint), -1)) {
if (!std::is_base_of<stack_reference, base_type>::value) {
lua_pop(L, 1);
}
}
basic_table_core(lua_State* L, int index = -1) : base_t(L, index) { basic_table_core(lua_State* L, int index = -1) : base_t(L, index) {
#ifdef SOL_CHECK_ARGUMENTS #ifdef SOL_CHECK_ARGUMENTS
stack::check<basic_table_core>(L, index, type_panic); stack::check<basic_table_core>(L, index, type_panic);
@ -12300,6 +12367,15 @@ namespace sol {
stack::check<basic_table_core>(L, -1, type_panic); stack::check<basic_table_core>(L, -1, type_panic);
#endif // Safety #endif // Safety
} }
template <typename T, meta::enable<meta::neg<meta::any_same<meta::unqualified_t<T>, basic_table_core>>, meta::neg<std::is_same<base_type, stack_reference>>, std::is_base_of<base_type, meta::unqualified_t<T>>> = meta::enabler>
basic_table_core(T&& r) noexcept : base_t(std::forward<T>(r)) {
#ifdef SOL_CHECK_ARGUMENTS
if (!is_table<meta::unqualified_t<T>>::value) {
auto pp = stack::push_pop(*this);
stack::check<basic_table_core>(base_t::lua_state(), -1, type_panic);
}
#endif // Safety
}
iterator begin() const { iterator begin() const {
return iterator(*this); return iterator(*this);
@ -12593,6 +12669,56 @@ namespace sol {
// end of sol/table.hpp // end of sol/table.hpp
// beginning of sol/environment.hpp
namespace sol {
template <typename base_type>
struct basic_environment : basic_table<base_type> {
private:
typedef basic_table<base_type> table_t;
public:
basic_environment() noexcept = default;
basic_environment(const basic_environment&) = default;
basic_environment(basic_environment&&) = default;
basic_environment& operator=(const basic_environment&) = default;
basic_environment& operator=(basic_environment&&) = default;
basic_environment(lua_State* L, sol::new_table t, const sol::reference& fallback) : table_t(L, std::move(t)) {
sol::stack_table mt(L, sol::new_table(0, 1));
mt.set(sol::meta_function::index, fallback);
this->set(metatable_key, mt);
mt.pop();
}
template <typename T, typename... Args, meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, basic_environment>>, meta::boolean<!(sizeof...(Args) == 2 && meta::any_same<new_table, meta::unqualified_t<Args>...>::value)>> = meta::enabler>
basic_environment(T&& arg, Args&&... args) : table_t(std::forward<T>(arg), std::forward<Args>(args)...) { }
};
template <typename E>
void set_environment(const reference& target, const basic_environment<E>& env) {
lua_State* L = target.lua_state();
#if SOL_LUA_VERSION < 502
// Use lua_setfenv
target.push();
env.push();
lua_setfenv(L, -2);
env.pop();
target.pop();
#else
// Use upvalues as explained in Lua 5.2 and beyond's manual
target.push();
env.push();
if (lua_setupvalue(L, -2, 1) == nullptr) {
env.pop();
}
target.pop();
#endif
}
} // sol
// end of sol/environment.hpp
// beginning of sol/load_result.hpp // beginning of sol/load_result.hpp
namespace sol { namespace sol {
@ -12935,6 +13061,28 @@ namespace sol {
return require_core(key, [this, &filename]() {stack::script_file(L, filename); }, create_global); return require_core(key, [this, &filename]() {stack::script_file(L, filename); }, create_global);
} }
template <typename E>
protected_function_result do_string(const std::string& code, const basic_environment<E>& env) {
load_status x = static_cast<load_status>(luaL_loadstring(L, code.c_str()));
if (x != load_status::ok) {
return protected_function_result(L, -1, 0, 1, static_cast<call_status>(x));
}
protected_function pf(L, -1);
set_environment(pf, env);
return pf();
}
template <typename E>
protected_function_result do_file(const std::string& filename, const basic_environment<E>& env) {
load_status x = static_cast<load_status>(luaL_loadfile(L, filename.c_str()));
if (x != load_status::ok) {
return protected_function_result(L, -1, 0, 1, static_cast<call_status>(x));
}
protected_function pf(L, -1);
set_environment(pf, env);
return pf();
}
protected_function_result do_string(const std::string& code) { protected_function_result do_string(const std::string& code) {
load_status x = static_cast<load_status>(luaL_loadstring(L, code.c_str())); load_status x = static_cast<load_status>(luaL_loadstring(L, code.c_str()));
if (x != load_status::ok) { if (x != load_status::ok) {
@ -12953,7 +13101,15 @@ namespace sol {
return pf(); return pf();
} }
template <typename Fx> protected_function_result script(const std::string& code, const environment& env) {
return script(code, env, sol::default_on_error);
}
protected_function_result script_file(const std::string& filename, const environment& env) {
return script_file(filename, env, sol::default_on_error);
}
template <typename Fx, meta::disable<meta::is_specialization_of<basic_environment, meta::unqualified_t<Fx>>> = meta::enabler>
protected_function_result script(const std::string& code, Fx&& on_error) { protected_function_result script(const std::string& code, Fx&& on_error) {
protected_function_result pfr = do_string(code); protected_function_result pfr = do_string(code);
if (!pfr.valid()) { if (!pfr.valid()) {
@ -12962,7 +13118,7 @@ namespace sol {
return pfr; return pfr;
} }
template <typename Fx> template <typename Fx, meta::disable<meta::is_specialization_of<basic_environment, meta::unqualified_t<Fx>>> = meta::enabler>
protected_function_result script_file(const std::string& filename, Fx&& on_error) { protected_function_result script_file(const std::string& filename, Fx&& on_error) {
protected_function_result pfr = do_file(filename); protected_function_result pfr = do_file(filename);
if (!pfr.valid()) { if (!pfr.valid()) {
@ -12971,6 +13127,24 @@ namespace sol {
return pfr; return pfr;
} }
template <typename Fx, typename E>
protected_function_result script(const std::string& code, const basic_environment<E>& env, Fx&& on_error) {
protected_function_result pfr = do_string(code, env);
if (!pfr.valid()) {
return on_error(L, std::move(pfr));
}
return pfr;
}
template <typename Fx, typename E>
protected_function_result script_file(const std::string& filename, const basic_environment<E>& env, Fx&& on_error) {
protected_function_result pfr = do_file(filename, env);
if (!pfr.valid()) {
return on_error(L, std::move(pfr));
}
return pfr;
}
function_result script(const std::string& code) { function_result script(const std::string& code) {
int index = lua_gettop(L); int index = lua_gettop(L);
stack::script(L, code); stack::script(L, code);