|
| | 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 (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) |
| |
| template<typename... Ret, typename... Args> |
| decltype(auto) | call (Args &&...args) |
| |
| bool | error () 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) |
| |
| basic_coroutine & | operator= (const basic_coroutine &)=default |
| |
| basic_coroutine & | operator= (basic_coroutine &&)=default |
| |
| bool | runnable () const noexcept |
| |
| call_status | status () const noexcept |
| |
| | basic_object () noexcept=default |
| |
| | basic_object (T &&r) |
| |
| | basic_object (lua_State *L, T &&r) |
| |
| | basic_object (lua_nil_t r) |
| |
| | basic_object (const basic_object &)=default |
| |
| | basic_object (basic_object &&)=default |
| |
| | basic_object (const stack_reference &r) noexcept |
| |
| | basic_object (stack_reference &&r) noexcept |
| |
| | basic_object (const proxy_base< Super > &r) noexcept |
| |
| | basic_object (proxy_base< Super > &&r) noexcept |
| |
| | basic_object (lua_State *L, lua_nil_t r) noexcept |
| |
| | basic_object (lua_State *L, int index=-1) noexcept |
| |
| | basic_object (lua_State *L, absolute_index index) noexcept |
| |
| | basic_object (lua_State *L, raw_index index) noexcept |
| |
| | basic_object (lua_State *L, ref_index index) noexcept |
| |
| | basic_object (lua_State *L, in_place_type_t< T >, Args &&...args) noexcept |
| |
| | basic_object (lua_State *L, in_place_t, T &&arg, Args &&...args) noexcept |
| |
| basic_object & | operator= (const basic_object &)=default |
| |
| basic_object & | operator= (basic_object &&)=default |
| |
| basic_object & | operator= (const ref_t &b) |
| |
| basic_object & | operator= (ref_t &&b) |
| |
| basic_object & | operator= (const proxy_base< Super > &r) |
| |
| basic_object & | operator= (proxy_base< Super > &&r) |
| |
| template<typename T > |
| decltype(auto) | as () const |
| |
| | basic_object_base () noexcept=default |
| |
| | basic_object_base (const basic_object_base &)=default |
| |
| | basic_object_base (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) |
| |
| template<typename T > |
| bool | is () const |
| |
| basic_object_base & | operator= (const basic_object_base &)=default |
| |
| basic_object_base & | operator= (basic_object_base &&)=default |
| |
|
| 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) |
| |
| void | luacall (std::ptrdiff_t argcount, std::ptrdiff_t) |
| |
template<typename ref_t>
class sol::basic_coroutine< ref_t >
Definition at line 713 of file forward.hpp.
template<typename ref_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>
Public Member Functions inherited from sol::basic_object< ref_t >