#include <forward.hpp>

Inheritance diagram for sol::basic_protected_function< ref_t, aligned, handler_t >:

Public Types
using	is_stack_handler = is_stack_based< handler_t >

Public Member Functions
	basic_protected_function ()=default

template<typename T , meta::enable< meta::neg< std::is_same< meta::unqualified_t< T >, basic_protected_function >>, 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_protected_function (T &&r) noexcept

	basic_protected_function (const basic_protected_function &)=default

	basic_protected_function (basic_protected_function &&)=default

	basic_protected_function (const basic_function< base_t > &b)

	basic_protected_function (basic_function< base_t > &&b)

	basic_protected_function (const basic_function< base_t > &b, handler_t eh)

	basic_protected_function (basic_function< base_t > &&b, handler_t eh)

	basic_protected_function (const stack_reference &r)

	basic_protected_function (stack_reference &&r)

	basic_protected_function (const stack_reference &r, handler_t eh)

	basic_protected_function (stack_reference &&r, handler_t eh)

template<typename Super >
	basic_protected_function (const proxy_base< Super > &p)

template<typename Super >
	basic_protected_function (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_protected_function (Proxy &&p, Handler &&eh)

template<typename T , meta::enable< is_lua_reference< meta::unqualified_t< T >>> = meta::enabler>
	basic_protected_function (lua_State *L, T &&r)

template<typename T , meta::enable< is_lua_reference< meta::unqualified_t< T >>> = meta::enabler>
	basic_protected_function (lua_State *L, T &&r, handler_t eh)

	basic_protected_function (lua_nil_t n)

	basic_protected_function (lua_State *L, int index=-1)

	basic_protected_function (lua_State *L, int index, handler_t eh)

	basic_protected_function (lua_State *L, absolute_index index)

	basic_protected_function (lua_State *L, absolute_index index, handler_t eh)

	basic_protected_function (lua_State *L, raw_index index)

	basic_protected_function (lua_State *L, raw_index index, handler_t eh)

	basic_protected_function (lua_State *L, ref_index index)

	basic_protected_function (lua_State *L, ref_index index, handler_t eh)

template<typename... Ret, typename... Args>
decltype(auto)	call (Args &&...args) const

template<typename Fx >
int	dump (lua_Writer writer, void *userdata, bool strip, Fx &&on_error) const

int	dump (lua_Writer writer, void *userdata, bool strip=false) const

template<typename Container = bytecode>
Container	dump () const

template<typename Container = bytecode, typename Fx >
Container	dump (Fx &&on_error) const

template<typename... Args>
protected_function_result	operator() (Args &&...args) const

template<typename... Ret, typename... Args>
decltype(auto)	operator() (types< Ret... >, Args &&...args) const

basic_protected_function &	operator= (const basic_protected_function &)=default

basic_protected_function &	operator= (basic_protected_function &&)=default

Public Member Functions inherited from sol::basic_object< ref_t >
	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)

Public Member Functions inherited from sol::basic_object_base< ref_t >
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

Static Public Member Functions
static handler_t	get_default_handler (lua_State *L)

template<typename T >
static void	set_default_handler (const T &ref)

Public Attributes
handler_t	error_handler

Private Types
using	base_t = basic_object< ref_t >

Private Member Functions
template<std::size_t... I, bool b, typename... Ret>
auto	invoke (types< Ret... >, std::index_sequence< I... >, std::ptrdiff_t n, detail::protected_handler< b, handler_t > &h) const

template<std::size_t I, bool b, typename Ret >
Ret	invoke (types< Ret >, std::index_sequence< I >, std::ptrdiff_t n, detail::protected_handler< b, handler_t > &h) const

template<std::size_t I, bool b>
void	invoke (types< void >, std::index_sequence< I >, std::ptrdiff_t n, detail::protected_handler< b, handler_t > &h) const

template<bool b>
protected_function_result	invoke (types<>, std::index_sequence<>, std::ptrdiff_t n, detail::protected_handler< b, handler_t > &h) const

template<bool b>
call_status	luacall (std::ptrdiff_t argcount, std::ptrdiff_t resultcount, detail::protected_handler< b, handler_t > &h) const

Additional Inherited Members
Protected Member Functions inherited from sol::basic_object< ref_t >
	basic_object (detail::no_safety_tag, lua_nil_t n)

	basic_object (detail::no_safety_tag, lua_State *L, int index)

	basic_object (lua_State *L, detail::global_tag t)

	basic_object (detail::no_safety_tag, lua_State *L, ref_index index)

	basic_object (detail::no_safety_tag, T &&r) noexcept

	basic_object (detail::no_safety_tag, lua_State *L, T &&r) noexcept