sol::protected_function_result Struct Reference

#include <sol.hpp>

Inheritance diagram for sol::protected_function_result:

Public Types
typedef stack_proxy	reference_type
typedef stack_proxy	value_type
typedef stack_proxy *	pointer
typedef std::ptrdiff_t	difference_type
typedef std::size_t	size_type
typedef stack_iterator< stack_proxy, false >	iterator
typedef stack_iterator< stack_proxy, true >	const_iterator
typedef std::reverse_iterator< iterator >	reverse_iterator
typedef std::reverse_iterator< const_iterator >	const_reverse_iterator

Public Member Functions
	protected_function_result ()=default
	protected_function_result (lua_State *Ls, int idx=-1, int retnum=0, int popped=0, call_status pferr=call_status::ok) noexcept
	protected_function_result (const protected_function_result &)=default
protected_function_result &	operator= (const protected_function_result &)=default
	protected_function_result (protected_function_result &&o) noexcept
protected_function_result &	operator= (protected_function_result &&o) noexcept
	protected_function_result (const unsafe_function_result &o)=delete
protected_function_result &	operator= (const unsafe_function_result &o)=delete
	protected_function_result (unsafe_function_result &&o) noexcept
protected_function_result &	operator= (unsafe_function_result &&o) noexcept
call_status	status () const noexcept
bool	valid () const noexcept
template<typename T >
decltype(auto)	get (int index_offset=0) const
type	get_type (difference_type index_offset=0) const noexcept
stack_proxy	operator[] (difference_type index_offset) const
iterator	begin ()
iterator	end ()
const_iterator	begin () const
const_iterator	end () const
const_iterator	cbegin () const
const_iterator	cend () const
reverse_iterator	rbegin ()
reverse_iterator	rend ()
const_reverse_iterator	rbegin () const
const_reverse_iterator	rend () const
const_reverse_iterator	crbegin () const
const_reverse_iterator	crend () const
lua_State *	lua_state () const noexcept
int	stack_index () const noexcept
int	return_count () const noexcept
int	pop_count () const noexcept
void	abandon () noexcept
	~protected_function_result ()
Public Member Functions inherited from sol::proxy_base< protected_function_result >
	operator std::string () const
	operator T () const
	operator T& () const
lua_State *	lua_state () const

Private Member Functions
template<typename T >
decltype(auto)	tagged_get (types< optional< T >>, int index_offset) const
template<typename T >
decltype(auto)	tagged_get (types< T >, int index_offset) const
optional< error >	tagged_get (types< optional< error >>, int index_offset) const
error	tagged_get (types< error >, int index_offset) const

Private Attributes
lua_State *	L
int	index
int	returncount
int	popcount
call_status	err

Member Typedef Documentation

const_iterator

typedef stack_iterator<stack_proxy, true> sol::protected_function_result::const_iterator

const_reverse_iterator

typedef std::reverse_iterator<const_iterator> sol::protected_function_result::const_reverse_iterator

difference_type

typedef std::ptrdiff_t sol::protected_function_result::difference_type

iterator

typedef stack_iterator<stack_proxy, false> sol::protected_function_result::iterator

pointer

typedef stack_proxy* sol::protected_function_result::pointer

reference_type

typedef stack_proxy sol::protected_function_result::reference_type

reverse_iterator

typedef std::reverse_iterator<iterator> sol::protected_function_result::reverse_iterator

size_type

typedef std::size_t sol::protected_function_result::size_type

value_type

typedef stack_proxy sol::protected_function_result::value_type

Constructor & Destructor Documentation

protected_function_result() [1/6]

sol::protected_function_result::protected_function_result ( )

default

protected_function_result() [2/6]

sol::protected_function_result::protected_function_result ( lua_State *  Ls, int  idx = -1, int  retnum = 0, int  popped = 0, call_status  pferr = call_status::ok  )

inlinenoexcept

        : L(Ls), index(idx), returncount(retnum), popcount(popped), err(pferr) {
        }

protected_function_result() [3/6]

sol::protected_function_result::protected_function_result ( const protected_function_result &  )

default

protected_function_result() [4/6]

sol::protected_function_result::protected_function_result ( protected_function_result &&  o )

inlinenoexcept

        : L(o.L), index(o.index), returncount(o.returncount), popcount(o.popcount), err(o.err) {
            // Must be manual, otherwise destructor will screw us
            // return count being 0 is enough to keep things clean
            // but we will be thorough
            o.abandon();
        }

protected_function_result() [5/6]

sol::protected_function_result::protected_function_result ( const unsafe_function_result &  o )

delete

protected_function_result() [6/6]

sol::protected_function_result::protected_function_result ( unsafe_function_result &&  o )

inlinenoexcept

    : L(o.lua_state()), index(o.stack_index()), returncount(o.return_count()), popcount(o.return_count()), err(o.status()) {
        // Must be manual, otherwise destructor will screw us
        // return count being 0 is enough to keep things clean
        // but we will be thorough
        o.abandon();
    }

~protected_function_result()

sol::protected_function_result::~protected_function_result ( )

inline

                                     {
            stack::remove(L, index, popcount);
        }

Member Function Documentation

abandon()

void sol::protected_function_result::abandon ( )

inlinenoexcept

                                {
            //L = nullptr;
            index = 0;
            returncount = 0;
            popcount = 0;
            err = call_status::runtime;
        }

begin() [1/2]

iterator sol::protected_function_result::begin ( )

inline

                         {
            return iterator(L, index, stack_index() + return_count());
        }

begin() [2/2]

const_iterator sol::protected_function_result::begin ( ) const

inline

                                     {
            return const_iterator(L, index, stack_index() + return_count());
        }

cbegin()

const_iterator sol::protected_function_result::cbegin ( ) const

inline

                                      {
            return begin();
        }

cend()

const_iterator sol::protected_function_result::cend ( ) const

inline

                                    {
            return end();
        }

crbegin()

const_reverse_iterator sol::protected_function_result::crbegin ( ) const

inline

                                               {
            return std::reverse_iterator<const_iterator>(cbegin());
        }

crend()

const_reverse_iterator sol::protected_function_result::crend ( ) const

inline

                                             {
            return std::reverse_iterator<const_iterator>(cend());
        }

end() [1/2]

iterator sol::protected_function_result::end ( )

inline

                       {
            return iterator(L, stack_index() + return_count(), stack_index() + return_count());
        }

end() [2/2]

const_iterator sol::protected_function_result::end ( ) const

inline

                                   {
            return const_iterator(L, stack_index() + return_count(), stack_index() + return_count());
        }

get()

template<typename T >

decltype(auto) sol::protected_function_result::get ( int  index_offset = 0 ) const

inline

                                                       {
            return tagged_get(types<meta::unqualified_t<T>>(), index_offset);
        }

get_type()

type sol::protected_function_result::get_type ( difference_type  index_offset = 0 ) const

inlinenoexcept

                                                                       {
            return type_of(L, index + static_cast<int>(index_offset));
        }

lua_state()

lua_State* sol::protected_function_result::lua_state ( ) const

inlinenoexcept

                                              {
            return L;
        };

operator=() [1/4]

protected_function_result& sol::protected_function_result::operator= ( const protected_function_result &  )

default

operator=() [2/4]

protected_function_result& sol::protected_function_result::operator= ( protected_function_result &&  o )

inlinenoexcept

                                                                                     {
            L = o.L;
            index = o.index;
            returncount = o.returncount;
            popcount = o.popcount;
            err = o.err;
            // Must be manual, otherwise destructor will screw us
            // return count being 0 is enough to keep things clean
            // but we will be thorough
            o.abandon();
            return *this;
        }

operator=() [3/4]

protected_function_result& sol::protected_function_result::operator= ( const unsafe_function_result &  o )

delete

operator=() [4/4]

protected_function_result & sol::protected_function_result::operator= ( unsafe_function_result &&  o )

inlinenoexcept

                                                                                                              {
        L = o.lua_state();
        index = o.stack_index();
        returncount = o.return_count();
        popcount = o.return_count();
        err = o.status();
        // Must be manual, otherwise destructor will screw us
        // return count being 0 is enough to keep things clean
        // but we will be thorough
        o.abandon();
        return *this;
    }

operator[]()

stack_proxy sol::protected_function_result::operator[] ( difference_type  index_offset ) const

inline

                                                                   {
            return stack_proxy(L, index + static_cast<int>(index_offset));
        }

pop_count()

int sol::protected_function_result::pop_count ( ) const

inlinenoexcept

                                       {
            return popcount;
        };

rbegin() [1/2]

reverse_iterator sol::protected_function_result::rbegin ( )

inline

                                  {
            return std::reverse_iterator<iterator>(begin());
        }

rbegin() [2/2]

const_reverse_iterator sol::protected_function_result::rbegin ( ) const

inline

                                              {
            return std::reverse_iterator<const_iterator>(begin());
        }

rend() [1/2]

reverse_iterator sol::protected_function_result::rend ( )

inline

                                {
            return std::reverse_iterator<iterator>(end());
        }

rend() [2/2]

const_reverse_iterator sol::protected_function_result::rend ( ) const

inline

                                            {
            return std::reverse_iterator<const_iterator>(end());
        }

return_count()

int sol::protected_function_result::return_count ( ) const

inlinenoexcept

                                          {
            return returncount;
        };

stack_index()

int sol::protected_function_result::stack_index ( ) const

inlinenoexcept

                                         {
            return index;
        };

status()

call_status sol::protected_function_result::status ( ) const

inlinenoexcept

                                            {
            return err;
        }

tagged_get() [1/4]

template<typename T >

decltype(auto) sol::protected_function_result::tagged_get ( types< optional< T >>  , int  index_offset  ) const

inlineprivate

                                                                              {
            typedef decltype(stack::get<optional<T>>(L, index)) ret_t;
            int target = index + index_offset;
            if (!valid()) {
                return ret_t(nullopt);
            }
            return stack::get<optional<T>>(L, target);
        }

tagged_get() [2/4]

template<typename T >

decltype(auto) sol::protected_function_result::tagged_get ( types< T >  , int  index_offset  ) const

inlineprivate

                                                                    {
            int target = index + index_offset;
#if defined(SOL_SAFE_PROXIES) && SOL_SAFE_PROXIES
            if (!valid()) {
                type t = type_of(L, target);
                type_panic_c_str(L, target, t, type::none, "bad get from protected_function_result (is not an error)");
            }
#endif // Check Argument Safety
            return stack::get<T>(L, target);
        }

tagged_get() [3/4]

optional<error> sol::protected_function_result::tagged_get ( types< optional< error >>  , int  index_offset  ) const

inlineprivate

                                                                                   {
            int target = index + index_offset;
            if (valid()) {
                return nullopt;
            }
            return error(detail::direct_error, stack::get<std::string>(L, target));
        }

tagged_get() [4/4]

error sol::protected_function_result::tagged_get ( types< error >  , int  index_offset  ) const

inlineprivate

                                                               {
            int target = index + index_offset;
#if defined(SOL_SAFE_PROXIES) && SOL_SAFE_PROXIES
            if (valid()) {
                type t = type_of(L, target);
                type_panic_c_str(L, target, t, type::none, "bad get from protected_function_result (is an error)");
            }
#endif // Check Argument Safety
            return error(detail::direct_error, stack::get<std::string>(L, target));
        }

valid()

bool sol::protected_function_result::valid ( ) const

inlinenoexcept

                                    {
            return status() == call_status::ok || status() == call_status::yielded;
        }

Member Data Documentation

err

call_status sol::protected_function_result::err

private

index

int sol::protected_function_result::index

private

L

lua_State* sol::protected_function_result::L

private

popcount

int sol::protected_function_result::popcount

private

returncount

int sol::protected_function_result::returncount

private

---

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

• external/sol.hpp