sol::unsafe_function_result Struct Reference

#include <sol.hpp>

Inheritance diagram for sol::unsafe_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
	unsafe_function_result ()=default
	unsafe_function_result (lua_State *Ls, int idx=-1, int retnum=0)
	unsafe_function_result (const unsafe_function_result &)=default
unsafe_function_result &	operator= (const unsafe_function_result &)=default
	unsafe_function_result (unsafe_function_result &&o)
unsafe_function_result &	operator= (unsafe_function_result &&o)
	unsafe_function_result (const protected_function_result &o)=delete
unsafe_function_result &	operator= (const protected_function_result &o)=delete
	unsafe_function_result (protected_function_result &&o) noexcept
unsafe_function_result &	operator= (protected_function_result &&o) noexcept
template<typename T >
decltype(auto)	get (difference_type 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
call_status	status () const noexcept
bool	valid () const noexcept
lua_State *	lua_state () const
int	stack_index () const
int	return_count () const
void	abandon () noexcept
	~unsafe_function_result ()
Public Member Functions inherited from sol::proxy_base< unsafe_function_result >
	operator std::string () const
	operator T () const
	operator T& () const
lua_State *	lua_state () const

Private Attributes
lua_State *	L
int	index
int	returncount

Member Typedef Documentation

const_iterator

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

const_reverse_iterator

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

difference_type

typedef std::ptrdiff_t sol::unsafe_function_result::difference_type

iterator

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

pointer

typedef stack_proxy* sol::unsafe_function_result::pointer

reference_type

typedef stack_proxy sol::unsafe_function_result::reference_type

reverse_iterator

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

size_type

typedef std::size_t sol::unsafe_function_result::size_type

value_type

typedef stack_proxy sol::unsafe_function_result::value_type

Constructor & Destructor Documentation

unsafe_function_result() [1/6]

sol::unsafe_function_result::unsafe_function_result ( )

default

unsafe_function_result() [2/6]

sol::unsafe_function_result::unsafe_function_result ( lua_State *  Ls, int  idx = -1, int  retnum = 0  )

inline

            : L(Ls), index(idx), returncount(retnum) {
        }

unsafe_function_result() [3/6]

sol::unsafe_function_result::unsafe_function_result ( const unsafe_function_result &  )

default

unsafe_function_result() [4/6]

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

inline

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

unsafe_function_result() [5/6]

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

delete

unsafe_function_result() [6/6]

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

inlinenoexcept

    : L(o.lua_state()), index(o.stack_index()), returncount(o.return_count()) {
        // 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();
    }

~unsafe_function_result()

sol::unsafe_function_result::~unsafe_function_result ( )

inline

                                  {
            lua_pop(L, returncount);
        }

Member Function Documentation

abandon()

void sol::unsafe_function_result::abandon ( )

inlinenoexcept

                                {
            //L = nullptr;
            index = 0;
            returncount = 0;
        }

begin() [1/2]

iterator sol::unsafe_function_result::begin ( )

inline

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

begin() [2/2]

const_iterator sol::unsafe_function_result::begin ( ) const

inline

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

cbegin()

const_iterator sol::unsafe_function_result::cbegin ( ) const

inline

                                      {
            return begin();
        }

cend()

const_iterator sol::unsafe_function_result::cend ( ) const

inline

                                    {
            return end();
        }

crbegin()

const_reverse_iterator sol::unsafe_function_result::crbegin ( ) const

inline

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

crend()

const_reverse_iterator sol::unsafe_function_result::crend ( ) const

inline

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

end() [1/2]

iterator sol::unsafe_function_result::end ( )

inline

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

end() [2/2]

const_iterator sol::unsafe_function_result::end ( ) const

inline

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

get()

template<typename T >

decltype(auto) sol::unsafe_function_result::get ( difference_type  index_offset = 0 ) const

inline

                                                                   {
            return stack::get<T>(L, index + static_cast<int>(index_offset));
        }

get_type()

type sol::unsafe_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::unsafe_function_result::lua_state ( ) const

inline

                                     {
            return L;
        };

operator=() [1/4]

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

default

operator=() [2/4]

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

inline

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

operator=() [3/4]

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

delete

operator=() [4/4]

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

inlinenoexcept

                                                                                                           {
        L = o.lua_state();
        index = o.stack_index();
        returncount = o.return_count();
        // 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::unsafe_function_result::operator[] ( difference_type  index_offset ) const

inline

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

rbegin() [1/2]

reverse_iterator sol::unsafe_function_result::rbegin ( )

inline

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

rbegin() [2/2]

const_reverse_iterator sol::unsafe_function_result::rbegin ( ) const

inline

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

rend() [1/2]

reverse_iterator sol::unsafe_function_result::rend ( )

inline

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

rend() [2/2]

const_reverse_iterator sol::unsafe_function_result::rend ( ) const

inline

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

return_count()

int sol::unsafe_function_result::return_count ( ) const

inline

                                 {
            return returncount;
        };

stack_index()

int sol::unsafe_function_result::stack_index ( ) const

inline

                                {
            return index;
        };

status()

call_status sol::unsafe_function_result::status ( ) const

inlinenoexcept

                                            {
            return call_status::ok;
        }

valid()

bool sol::unsafe_function_result::valid ( ) const

inlinenoexcept

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

Member Data Documentation

index

int sol::unsafe_function_result::index

private

L

lua_State* sol::unsafe_function_result::L

private

returncount

int sol::unsafe_function_result::returncount

private

---

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

• external/sol.hpp