sol::variadic_args Struct Reference

#include <sol.hpp>

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
	variadic_args ()=default
	variadic_args (lua_State *luastate, int stackindex=-1)
	variadic_args (lua_State *luastate, int stackindex, int lastindex)
	variadic_args (const variadic_args &)=default
variadic_args &	operator= (const variadic_args &)=default
	variadic_args (variadic_args &&o)
variadic_args &	operator= (variadic_args &&o)
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
int	push () const
int	push (lua_State *target) const
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
lua_State *	lua_state () const
int	stack_index () const
int	leftover_count () const
std::size_t	size () const
int	top () const

Private Attributes
lua_State *	L
int	index
int	stacktop

Member Typedef Documentation

const_iterator

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

const_reverse_iterator

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

difference_type

typedef std::ptrdiff_t sol::variadic_args::difference_type

iterator

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

pointer

typedef stack_proxy* sol::variadic_args::pointer

reference_type

typedef stack_proxy sol::variadic_args::reference_type

reverse_iterator

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

size_type

typedef std::size_t sol::variadic_args::size_type

value_type

typedef stack_proxy sol::variadic_args::value_type

Constructor & Destructor Documentation

variadic_args() [1/5]

sol::variadic_args::variadic_args ( )

default

variadic_args() [2/5]

sol::variadic_args::variadic_args ( lua_State *  luastate, int  stackindex = -1  )

inline

            : L(luastate), index(lua_absindex(luastate, stackindex)), stacktop(lua_gettop(luastate)) {
        }

variadic_args() [3/5]

sol::variadic_args::variadic_args ( lua_State *  luastate, int  stackindex, int  lastindex  )

inline

            : L(luastate), index(lua_absindex(luastate, stackindex)), stacktop(lastindex) {
        }

variadic_args() [4/5]

sol::variadic_args::variadic_args ( const variadic_args &  )

default

variadic_args() [5/5]

sol::variadic_args::variadic_args ( variadic_args &&  o )

inline

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

Member Function Documentation

begin() [1/2]

iterator sol::variadic_args::begin ( )

inline

                         {
            return iterator(L, index, stacktop + 1);
        }

begin() [2/2]

const_iterator sol::variadic_args::begin ( ) const

inline

                                     {
            return const_iterator(L, index, stacktop + 1);
        }

cbegin()

const_iterator sol::variadic_args::cbegin ( ) const

inline

                                      {
            return begin();
        }

cend()

const_iterator sol::variadic_args::cend ( ) const

inline

                                    {
            return end();
        }

crbegin()

const_reverse_iterator sol::variadic_args::crbegin ( ) const

inline

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

crend()

const_reverse_iterator sol::variadic_args::crend ( ) const

inline

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

end() [1/2]

iterator sol::variadic_args::end ( )

inline

                       {
            return iterator(L, stacktop + 1, stacktop + 1);
        }

end() [2/2]

const_iterator sol::variadic_args::end ( ) const

inline

                                   {
            return const_iterator(L, stacktop + 1, stacktop + 1);
        }

get()

template<typename T >

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

inline

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

get_type()

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

inlinenoexcept

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

leftover_count()

int sol::variadic_args::leftover_count ( ) const

inline

                                   {
            return stacktop - (index - 1);
        }

lua_state()

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

inline

                                     {
            return L;
        };

operator=() [1/2]

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

default

operator=() [2/2]

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

inline

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

operator[]()

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

inline

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

push() [1/2]

int sol::variadic_args::push ( ) const

inline

                         {
            return push(L);
        }

push() [2/2]

int sol::variadic_args::push ( lua_State *  target ) const

inline

                                          {
            int pushcount = 0;
            for (int i = index; i <= stacktop; ++i) {
                lua_pushvalue(L, i);
                pushcount += 1;
            }
            if (target != L) {
                lua_xmove(L, target, pushcount);
            }
            return pushcount;
        }

rbegin() [1/2]

reverse_iterator sol::variadic_args::rbegin ( )

inline

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

rbegin() [2/2]

const_reverse_iterator sol::variadic_args::rbegin ( ) const

inline

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

rend() [1/2]

reverse_iterator sol::variadic_args::rend ( )

inline

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

rend() [2/2]

const_reverse_iterator sol::variadic_args::rend ( ) const

inline

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

size()

std::size_t sol::variadic_args::size ( ) const

inline

                               {
            return static_cast<std::size_t>(leftover_count());
        }

stack_index()

int sol::variadic_args::stack_index ( ) const

inline

                                {
            return index;
        };

top()

int sol::variadic_args::top ( ) const

inline

                        {
            return stacktop;
        }

Member Data Documentation

index

int sol::variadic_args::index

private

L

lua_State* sol::variadic_args::L

private

stacktop

int sol::variadic_args::stacktop

private

---

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

• external/sol.hpp