summaryrefslogtreecommitdiffstatshomepage
path: root/3rdparty/sol2/sol/thread.hpp
diff options
context:
space:
mode:
Diffstat (limited to '3rdparty/sol2/sol/thread.hpp')
-rw-r--r--3rdparty/sol2/sol/thread.hpp81
1 files changed, 81 insertions, 0 deletions
diff --git a/3rdparty/sol2/sol/thread.hpp b/3rdparty/sol2/sol/thread.hpp
index d4834dee4f2..5e57ad1de02 100644
--- a/3rdparty/sol2/sol/thread.hpp
+++ b/3rdparty/sol2/sol/thread.hpp
@@ -26,25 +26,106 @@
#include "stack.hpp"
namespace sol {
+ struct lua_thread_state {
+ lua_State* L;
+ operator lua_State* () const {
+ return L;
+ }
+ lua_State* operator-> () const {
+ return L;
+ }
+ };
+
+ namespace stack {
+
+ template <>
+ struct pusher<lua_thread_state> {
+ int push(lua_State*, lua_thread_state lts) {
+ lua_pushthread(lts.L);
+ return 1;
+ }
+ };
+
+ template <>
+ struct getter<lua_thread_state> {
+ lua_thread_state get(lua_State* L, int index, record& tracking) {
+ tracking.use(1);
+ lua_thread_state lts{ lua_tothread(L, index) };
+ return lts;
+ }
+ };
+
+ template <>
+ struct check_getter<lua_thread_state> {
+ template <typename Handler>
+ optional<lua_thread_state> get(lua_State* L, int index, Handler&& handler, record& tracking) {
+ lua_thread_state lts{ lua_tothread(L, index) };
+ if (lts.L == nullptr) {
+ handler(L, index, type::thread, type_of(L, index));
+ return nullopt;
+ }
+ tracking.use(1);
+ return lts;
+ }
+ };
+
+ }
+
+#if SOL_LUA_VERSION < 502
+ inline lua_State* main_thread(lua_State*, lua_State* backup_if_unsupported = nullptr) {
+ return backup_if_unsupported;
+ }
+#else
+ inline lua_State* main_thread(lua_State* L, lua_State* = nullptr) {
+ lua_rawgeti(L, LUA_REGISTRYINDEX, LUA_RIDX_MAINTHREAD);
+ lua_thread_state s = stack::pop<lua_thread_state>(L);
+ return s.L;
+ }
+#endif // Lua 5.2+ has the main thread getter
+
class thread : public reference {
public:
thread() noexcept = default;
thread(const thread&) = default;
thread(thread&&) = default;
+ template <typename T, meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, thread>>, std::is_base_of<reference, meta::unqualified_t<T>>> = meta::enabler>
+ thread(T&& r) : reference(std::forward<T>(r)) {}
thread(const stack_reference& r) : thread(r.lua_state(), r.stack_index()) {};
thread(stack_reference&& r) : thread(r.lua_state(), r.stack_index()) {};
thread& operator=(const thread&) = default;
thread& operator=(thread&&) = default;
+ template <typename T, meta::enable<meta::neg<std::is_integral<meta::unqualified_t<T>>>, meta::neg<std::is_same<T, ref_index>>> = meta::enabler>
+ thread(lua_State* L, T&& r) : thread(L, sol::ref_index(r.registry_index())) {}
thread(lua_State* L, int index = -1) : reference(L, index) {
#ifdef SOL_CHECK_ARGUMENTS
type_assert(L, index, type::thread);
#endif // Safety
}
+ thread(lua_State* L, ref_index index) : reference(L, index) {
+#ifdef SOL_CHECK_ARGUMENTS
+ auto pp = stack::push_pop(*this);
+ type_assert(L, -1, type::thread);
+#endif // Safety
+ }
+ thread(lua_State* L, lua_State* actualthread) : thread(L, lua_thread_state{ actualthread }) {}
+ thread(lua_State* L, sol::this_state actualthread) : thread(L, lua_thread_state{ actualthread.L }) {}
+ thread(lua_State* L, lua_thread_state actualthread) : reference(L, -stack::push(L, actualthread)) {
+#ifdef SOL_CHECK_ARGUMENTS
+ type_assert(L, -1, type::thread);
+#endif // Safety
+ lua_pop(L, 1);
+ }
state_view state() const {
return state_view(this->thread_state());
}
+ bool is_main_thread() const {
+ int ismainthread = lua_pushthread(this->thread_state());
+ lua_pop(this->thread_state(), 1);
+ return ismainthread == 1;
+ }
+
lua_State* thread_state() const {
auto pp = stack::push_pop(*this);
lua_State* lthread = lua_tothread(lua_state(), -1);