sol::basic_thread< base_t > Class Template Reference

#include <sol.hpp>

Inheritance diagram for sol::basic_thread< base_t >:

Public Member Functions
	basic_thread () noexcept=default
	basic_thread (const basic_thread &)=default
	basic_thread (basic_thread &&)=default
template<typename T , meta::enable< meta::neg< std::is_same< meta::unqualified_t< T >, basic_thread >>, is_lua_reference< meta::unqualified_t< T >>> = meta::enabler>
	basic_thread (T &&r)
	basic_thread (const stack_reference &r)
	basic_thread (stack_reference &&r)
basic_thread &	operator= (const basic_thread &)=default
basic_thread &	operator= (basic_thread &&)=default
template<typename T , meta::enable< is_lua_reference< meta::unqualified_t< T >>> = meta::enabler>
	basic_thread (lua_State *L, T &&r)
	basic_thread (lua_State *L, int index=-1)
	basic_thread (lua_State *L, ref_index index)
	basic_thread (lua_State *L, lua_State *actualthread)
	basic_thread (lua_State *L, this_state actualthread)
	basic_thread (lua_State *L, lua_thread_state actualthread)
state_view	state () const
bool	is_main_thread () const
lua_State *	thread_state () const
thread_status	status () const
basic_thread	create ()

Static Public Member Functions
static basic_thread	create (lua_State *L)

Constructor & Destructor Documentation

basic_thread() [1/12]

template<typename base_t >

sol::basic_thread< base_t >::basic_thread ( )

defaultnoexcept

basic_thread() [2/12]

template<typename base_t >

sol::basic_thread< base_t >::basic_thread ( const basic_thread< base_t > &  )

default

basic_thread() [3/12]

template<typename base_t >

sol::basic_thread< base_t >::basic_thread ( basic_thread< base_t > &&  )

default

basic_thread() [4/12]

template<typename base_t >

template<typename T , meta::enable< meta::neg< std::is_same< meta::unqualified_t< T >, basic_thread >>, is_lua_reference< meta::unqualified_t< T >>> = meta::enabler>

sol::basic_thread< base_t >::basic_thread ( T &&  r )

inline

        : base_t(std::forward<T>(r)) {
#if defined(SOL_SAFE_REFERENCES) && SOL_SAFE_REFERENCES
            auto pp = stack::push_pop(*this);
            constructor_handler handler{};
            stack::check<basic_thread>(lua_state(), -1, handler);
#endif // Safety
        }

basic_thread() [5/12]

template<typename base_t >

sol::basic_thread< base_t >::basic_thread ( const stack_reference &  r )

inline

        : basic_thread(r.lua_state(), r.stack_index()){};

basic_thread() [6/12]

template<typename base_t >

sol::basic_thread< base_t >::basic_thread ( stack_reference &&  r )

inline

        : basic_thread(r.lua_state(), r.stack_index()){};

basic_thread() [7/12]

template<typename base_t >

template<typename T , meta::enable< is_lua_reference< meta::unqualified_t< T >>> = meta::enabler>

sol::basic_thread< base_t >::basic_thread ( lua_State *  L, T &&  r  )

inline

        : base_t(L, std::forward<T>(r)) {
#if defined(SOL_SAFE_REFERENCES) && SOL_SAFE_REFERENCES
            auto pp = stack::push_pop(*this);
            constructor_handler handler{};
            stack::check<basic_thread>(lua_state(), -1, handler);
#endif // Safety
        }

basic_thread() [8/12]

template<typename base_t >

sol::basic_thread< base_t >::basic_thread ( lua_State *  L, int  index = -1  )

inline

        : base_t(L, index) {
#if defined(SOL_SAFE_REFERENCES) && SOL_SAFE_REFERENCES
            constructor_handler handler{};
            stack::check<basic_thread>(L, index, handler);
#endif // Safety
        }

basic_thread() [9/12]

template<typename base_t >

sol::basic_thread< base_t >::basic_thread ( lua_State *  L, ref_index  index  )

inline

        : base_t(L, index) {
#if defined(SOL_SAFE_REFERENCES) && SOL_SAFE_REFERENCES
            auto pp = stack::push_pop(*this);
            constructor_handler handler{};
            stack::check<basic_thread>(lua_state(), -1, handler);
#endif // Safety
        }

basic_thread() [10/12]

template<typename base_t >

sol::basic_thread< base_t >::basic_thread ( lua_State *  L, lua_State *  actualthread  )

inline

        : basic_thread(L, lua_thread_state{ actualthread }) {
        }

basic_thread() [11/12]

template<typename base_t >

sol::basic_thread< base_t >::basic_thread ( lua_State *  L, this_state  actualthread  )

inline

        : basic_thread(L, lua_thread_state{ actualthread.L }) {
        }

basic_thread() [12/12]

template<typename base_t >

sol::basic_thread< base_t >::basic_thread ( lua_State *  L, lua_thread_state  actualthread  )

inline

        : base_t(L, -stack::push(L, actualthread)) {
#if defined(SOL_SAFE_REFERENCES) && SOL_SAFE_REFERENCES
            constructor_handler handler{};
            stack::check<basic_thread>(lua_state(), -1, handler);
#endif // Safety
            if (!is_stack_based<base_t>::value) {
                lua_pop(lua_state(), 1);
            }
        }

Member Function Documentation

create() [1/2]

template<typename base_t >

basic_thread sol::basic_thread< base_t >::create ( )

inline

                              {
            return create(lua_state());
        }

create() [2/2]

template<typename base_t >

static basic_thread sol::basic_thread< base_t >::create ( lua_State *  L )

inlinestatic

                                                 {
            lua_newthread(L);
            basic_thread result(L);
            if (!is_stack_based<base_t>::value) {
                lua_pop(L, 1);
            }
            return result;
        }

is_main_thread()

template<typename base_t >

bool sol::basic_thread< base_t >::is_main_thread ( ) const

inline

                                    {
            return stack::is_main_thread(this->thread_state());
        }

operator=() [1/2]

template<typename base_t >

basic_thread& sol::basic_thread< base_t >::operator= ( const basic_thread< base_t > &  )

default

operator=() [2/2]

template<typename base_t >

basic_thread& sol::basic_thread< base_t >::operator= ( basic_thread< base_t > &&  )

default

state()

template<typename base_t >

state_view sol::basic_thread< base_t >::state ( ) const

inline

                                 {
            return state_view(this->thread_state());
        }

status()

template<typename base_t >

thread_status sol::basic_thread< base_t >::status ( ) const

inline

                                     {
            lua_State* lthread = thread_state();
            auto lstat = static_cast<thread_status>(lua_status(lthread));
            if (lstat == thread_status::ok) {
                lua_Debug ar;
                if (lua_getstack(lthread, 0, &ar) > 0)
                    return thread_status::ok;
                else if (lua_gettop(lthread) == 0)
                    return thread_status::dead;
                else
                    return thread_status::yielded;
            }
            return lstat;
        }

thread_state()

template<typename base_t >

lua_State* sol::basic_thread< base_t >::thread_state ( ) const

inline

                                        {
            auto pp = stack::push_pop(*this);
            lua_State* lthread = lua_tothread(lua_state(), -1);
            return lthread;
        }

---

The documentation for this class was generated from the following file:

• external/sol.hpp