sol::basic_coroutine< base_t > Class Template Reference

#include <sol.hpp>

Inheritance diagram for sol::basic_coroutine< base_t >:

Public Types
typedef reference	handler_t

Public Member Functions
	basic_coroutine ()=default
template<typename T , meta::enable< meta::neg< std::is_same< meta::unqualified_t< T >, basic_coroutine >>, meta::neg< std::is_base_of< proxy_base_tag, meta::unqualified_t< T >>>, meta::neg< std::is_same< base_t, stack_reference >>, meta::neg< std::is_same< lua_nil_t, meta::unqualified_t< T >>>, is_lua_reference< meta::unqualified_t< T >>> = meta::enabler>
	basic_coroutine (T &&r) noexcept
	basic_coroutine (const basic_coroutine &)=default
basic_coroutine &	operator= (const basic_coroutine &)=default
	basic_coroutine (basic_coroutine &&)=default
basic_coroutine &	operator= (basic_coroutine &&)=default
	basic_coroutine (const basic_function< base_t > &b)
	basic_coroutine (basic_function< base_t > &&b)
	basic_coroutine (const basic_function< base_t > &b, handler_t eh)
	basic_coroutine (basic_function< base_t > &&b, handler_t eh)
	basic_coroutine (const stack_reference &r)
	basic_coroutine (stack_reference &&r)
	basic_coroutine (const stack_reference &r, handler_t eh)
	basic_coroutine (stack_reference &&r, handler_t eh)
template<typename Super >
	basic_coroutine (const proxy_base< Super > &p)
template<typename Super >
	basic_coroutine (proxy_base< Super > &&p)
template<typename Proxy , typename Handler , meta::enable< std::is_base_of< proxy_base_tag, meta::unqualified_t< Proxy >>, meta::neg< is_lua_index< meta::unqualified_t< Handler >>>> = meta::enabler>
	basic_coroutine (Proxy &&p, Handler &&eh)
template<typename T , meta::enable< is_lua_reference< meta::unqualified_t< T >>> = meta::enabler>
	basic_coroutine (lua_State *L, T &&r)
template<typename T , meta::enable< is_lua_reference< meta::unqualified_t< T >>> = meta::enabler>
	basic_coroutine (lua_State *L, T &&r, handler_t eh)
	basic_coroutine (lua_nil_t n)
	basic_coroutine (lua_State *L, int index=-1)
	basic_coroutine (lua_State *L, int index, handler_t eh)
	basic_coroutine (lua_State *L, absolute_index index)
	basic_coroutine (lua_State *L, absolute_index index, handler_t eh)
	basic_coroutine (lua_State *L, raw_index index)
	basic_coroutine (lua_State *L, raw_index index, handler_t eh)
	basic_coroutine (lua_State *L, ref_index index)
	basic_coroutine (lua_State *L, ref_index index, handler_t eh)
call_status	status () const noexcept
bool	error () const noexcept
bool	runnable () const noexcept
	operator bool () const noexcept
template<typename... Args>
protected_function_result	operator() (Args &&... args)
template<typename... Ret, typename... Args>
decltype(auto)	operator() (types< Ret... >, Args &&... args)
template<typename... Ret, typename... Args>
decltype(auto)	call (Args &&... args)

Public Attributes
handler_t	error_handler

Private Member Functions
void	luacall (std::ptrdiff_t argcount, std::ptrdiff_t)
template<std::size_t... I, typename... Ret>
auto	invoke (types< Ret... >, std::index_sequence< I... >, std::ptrdiff_t n)
template<std::size_t I, typename Ret >
Ret	invoke (types< Ret >, std::index_sequence< I >, std::ptrdiff_t n)
template<std::size_t I>
void	invoke (types< void >, std::index_sequence< I >, std::ptrdiff_t n)
protected_function_result	invoke (types<>, std::index_sequence<>, std::ptrdiff_t n)

Private Attributes
call_status	stats = call_status::yielded

Member Typedef Documentation

handler_t

template<typename base_t >

typedef reference sol::basic_coroutine< base_t >::handler_t

Constructor & Destructor Documentation

basic_coroutine() [1/26]

template<typename base_t >

sol::basic_coroutine< base_t >::basic_coroutine ( )

default

basic_coroutine() [2/26]

template<typename base_t >

template<typename T , meta::enable< meta::neg< std::is_same< meta::unqualified_t< T >, basic_coroutine >>, meta::neg< std::is_base_of< proxy_base_tag, meta::unqualified_t< T >>>, meta::neg< std::is_same< base_t, stack_reference >>, meta::neg< std::is_same< lua_nil_t, meta::unqualified_t< T >>>, is_lua_reference< meta::unqualified_t< T >>> = meta::enabler>

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

inlinenoexcept

        : base_t(std::forward<T>(r)), error_handler(detail::get_default_handler<reference, is_main_threaded<base_t>::value>(r.lua_state())) {
#if defined(SOL_SAFE_REFERENCES) && SOL_SAFE_REFERENCES
            if (!is_function<meta::unqualified_t<T>>::value) {
                auto pp = stack::push_pop(*this);
                constructor_handler handler{};
                stack::check<basic_coroutine>(lua_state(), -1, handler);
            }
#endif // Safety
        }

basic_coroutine() [3/26]

template<typename base_t >

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

default

basic_coroutine() [4/26]

template<typename base_t >

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

default

basic_coroutine() [5/26]

template<typename base_t >

sol::basic_coroutine< base_t >::basic_coroutine ( const basic_function< base_t > &  b )

inline

        : basic_coroutine(b, detail::get_default_handler<reference, is_main_threaded<base_t>::value>(b.lua_state())) {
        }

basic_coroutine() [6/26]

template<typename base_t >

sol::basic_coroutine< base_t >::basic_coroutine ( basic_function< base_t > &&  b )

inline

        : basic_coroutine(std::move(b), detail::get_default_handler<reference, is_main_threaded<base_t>::value>(b.lua_state())) {
        }

basic_coroutine() [7/26]

template<typename base_t >

sol::basic_coroutine< base_t >::basic_coroutine ( const basic_function< base_t > &  b, handler_t  eh  )

inline

        : base_t(b), error_handler(std::move(eh)) {
        }

basic_coroutine() [8/26]

template<typename base_t >

sol::basic_coroutine< base_t >::basic_coroutine ( basic_function< base_t > &&  b, handler_t  eh  )

inline

        : base_t(std::move(b)), error_handler(std::move(eh)) {
        }

basic_coroutine() [9/26]

template<typename base_t >

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

inline

        : basic_coroutine(r.lua_state(), r.stack_index(), detail::get_default_handler<reference, is_main_threaded<base_t>::value>(r.lua_state())) {
        }

basic_coroutine() [10/26]

template<typename base_t >

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

inline

        : basic_coroutine(r.lua_state(), r.stack_index(), detail::get_default_handler<reference, is_main_threaded<base_t>::value>(r.lua_state())) {
        }

basic_coroutine() [11/26]

template<typename base_t >

sol::basic_coroutine< base_t >::basic_coroutine ( const stack_reference &  r, handler_t  eh  )

inline

        : basic_coroutine(r.lua_state(), r.stack_index(), std::move(eh)) {
        }

basic_coroutine() [12/26]

template<typename base_t >

sol::basic_coroutine< base_t >::basic_coroutine ( stack_reference &&  r, handler_t  eh  )

inline

        : basic_coroutine(r.lua_state(), r.stack_index(), std::move(eh)) {
        }

basic_coroutine() [13/26]

template<typename base_t >

template<typename Super >

sol::basic_coroutine< base_t >::basic_coroutine ( const proxy_base< Super > &  p )

inline

        : basic_coroutine(p, detail::get_default_handler<reference, is_main_threaded<base_t>::value>(p.lua_state())) {
        }

basic_coroutine() [14/26]

template<typename base_t >

template<typename Super >

sol::basic_coroutine< base_t >::basic_coroutine ( proxy_base< Super > &&  p )

inline

        : basic_coroutine(std::move(p), detail::get_default_handler<reference, is_main_threaded<base_t>::value>(p.lua_state())) {
        }

basic_coroutine() [15/26]

template<typename base_t >

template<typename Proxy , typename Handler , meta::enable< std::is_base_of< proxy_base_tag, meta::unqualified_t< Proxy >>, meta::neg< is_lua_index< meta::unqualified_t< Handler >>>> = meta::enabler>

sol::basic_coroutine< base_t >::basic_coroutine ( Proxy &&  p, Handler &&  eh  )

inline

        : basic_coroutine(detail::force_cast<base_t>(p), std::forward<Handler>(eh)) {
        }

basic_coroutine() [16/26]

template<typename base_t >

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

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

inline

        : basic_coroutine(L, std::forward<T>(r), detail::get_default_handler<reference, is_main_threaded<base_t>::value>(L)) {
        }

basic_coroutine() [17/26]

template<typename base_t >

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

sol::basic_coroutine< base_t >::basic_coroutine ( lua_State *  L, T &&  r, handler_t  eh  )

inline

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

basic_coroutine() [18/26]

template<typename base_t >

sol::basic_coroutine< base_t >::basic_coroutine ( lua_nil_t  n )

inline

        : base_t(n), error_handler(n) {
        }

basic_coroutine() [19/26]

template<typename base_t >

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

inline

        : basic_coroutine(L, index, detail::get_default_handler<reference, is_main_threaded<base_t>::value>(L)) {
        }

basic_coroutine() [20/26]

template<typename base_t >

sol::basic_coroutine< base_t >::basic_coroutine ( lua_State *  L, int  index, handler_t  eh  )

inline

        : base_t(L, index), error_handler(std::move(eh)) {
#ifdef SOL_SAFE_REFERENCES
            constructor_handler handler{};
            stack::check<basic_coroutine>(L, index, handler);
#endif // Safety
        }

basic_coroutine() [21/26]

template<typename base_t >

sol::basic_coroutine< base_t >::basic_coroutine ( lua_State *  L, absolute_index  index  )

inline

        : basic_coroutine(L, index, detail::get_default_handler<reference, is_main_threaded<base_t>::value>(L)) {
        }

basic_coroutine() [22/26]

template<typename base_t >

sol::basic_coroutine< base_t >::basic_coroutine ( lua_State *  L, absolute_index  index, handler_t  eh  )

inline

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

basic_coroutine() [23/26]

template<typename base_t >

sol::basic_coroutine< base_t >::basic_coroutine ( lua_State *  L, raw_index  index  )

inline

        : basic_coroutine(L, index, detail::get_default_handler<reference, is_main_threaded<base_t>::value>(L)) {
        }

basic_coroutine() [24/26]

template<typename base_t >

sol::basic_coroutine< base_t >::basic_coroutine ( lua_State *  L, raw_index  index, handler_t  eh  )

inline

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

basic_coroutine() [25/26]

template<typename base_t >

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

inline

        : basic_coroutine(L, index, detail::get_default_handler<reference, is_main_threaded<base_t>::value>(L)) {
        }

basic_coroutine() [26/26]

template<typename base_t >

sol::basic_coroutine< base_t >::basic_coroutine ( lua_State *  L, ref_index  index, handler_t  eh  )

inline

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

Member Function Documentation

call()

template<typename base_t >

template<typename... Ret, typename... Args>

decltype(auto) sol::basic_coroutine< base_t >::call ( Args &&...  args )

inline

                                            {
            // some users screw up coroutine.create
            // and try to use it with sol::coroutine without ever calling the first resume in Lua
            // this makes the stack incompatible with other kinds of stacks: protect against this
            // make sure coroutines don't screw us over
            base_t::push();
            int pushcount = stack::multi_push_reference(lua_state(), std::forward<Args>(args)...);
            return invoke(types<Ret...>(), std::make_index_sequence<sizeof...(Ret)>(), pushcount);
        }

error()

template<typename base_t >

bool sol::basic_coroutine< base_t >::error ( ) const

inlinenoexcept

                                    {
            call_status cs = status();
            return cs != call_status::ok && cs != call_status::yielded;
        }

invoke() [1/4]

template<typename base_t >

template<std::size_t... I, typename... Ret>

auto sol::basic_coroutine< base_t >::invoke ( types< Ret... >  , std::index_sequence< I... >  , std::ptrdiff_t  n  )

inlineprivate

                                                                            {
            luacall(n, sizeof...(Ret));
            return stack::pop<std::tuple<Ret...>>(lua_state());
        }

invoke() [2/4]

template<typename base_t >

template<std::size_t I, typename Ret >

Ret sol::basic_coroutine< base_t >::invoke ( types< Ret >  , std::index_sequence< I >  , std::ptrdiff_t  n  )

inlineprivate

                                                                     {
            luacall(n, 1);
            return stack::pop<Ret>(lua_state());
        }

invoke() [3/4]

template<typename base_t >

template<std::size_t I>

void sol::basic_coroutine< base_t >::invoke ( types< void >  , std::index_sequence< I >  , std::ptrdiff_t  n  )

inlineprivate

                                                                       {
            luacall(n, 0);
        }

invoke() [4/4]

template<typename base_t >

protected_function_result sol::basic_coroutine< base_t >::invoke ( types<>  , std::index_sequence<>  , std::ptrdiff_t  n  )

inlineprivate

                                                                                       {
            int firstreturn = 1;
            luacall(n, LUA_MULTRET);
            int poststacksize = lua_gettop(this->lua_state());
            int returncount = poststacksize - (firstreturn - 1);
            if (error()) {
                if (error_handler.valid()) {
                    string_view err = stack::get<string_view>(this->lua_state(), poststacksize);
                    error_handler.push();
                    stack::push(this->lua_state(), err);
                    lua_call(lua_state(), 1, 1);
                }
                return protected_function_result(this->lua_state(), lua_absindex(this->lua_state(), -1), 1, returncount, status());
            }
            return protected_function_result(this->lua_state(), firstreturn, returncount, returncount, status());
        }

luacall()

template<typename base_t >

void sol::basic_coroutine< base_t >::luacall ( std::ptrdiff_t  argcount, std::ptrdiff_t    )

inlineprivate

                                                          {
#if SOL_LUA_VERSION >= 504
            int nres;
            stats = static_cast<call_status>(lua_resume(lua_state(), nullptr, static_cast<int>(argcount), &nres));
#else
            stats = static_cast<call_status>(lua_resume(lua_state(), nullptr, static_cast<int>(argcount)));
#endif
        }

operator bool()

template<typename base_t >

sol::basic_coroutine< base_t >::operator bool ( ) const

inlineexplicitnoexcept

                                                {
            return runnable();
        }

operator()() [1/2]

template<typename base_t >

template<typename... Args>

protected_function_result sol::basic_coroutine< base_t >::operator() ( Args &&...  args )

inline

                                                             {
            return call<>(std::forward<Args>(args)...);
        }

operator()() [2/2]

template<typename base_t >

template<typename... Ret, typename... Args>

decltype(auto) sol::basic_coroutine< base_t >::operator() ( types< Ret... >  , Args &&...  args  )

inline

                                                                 {
            return call<Ret...>(std::forward<Args>(args)...);
        }

operator=() [1/2]

template<typename base_t >

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

default

operator=() [2/2]

template<typename base_t >

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

default

runnable()

template<typename base_t >

bool sol::basic_coroutine< base_t >::runnable ( ) const

inlinenoexcept

                                       {
            return base_t::valid()
                && (status() == call_status::yielded);
        }

status()

template<typename base_t >

call_status sol::basic_coroutine< base_t >::status ( ) const

inlinenoexcept

                                            {
            return stats;
        }

Member Data Documentation

error_handler

template<typename base_t >

handler_t sol::basic_coroutine< base_t >::error_handler

stats

template<typename base_t >

call_status sol::basic_coroutine< base_t >::stats = call_status::yielded

private

---

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

• external/sol.hpp