sol::stack_iterator< proxy_t, is_const > Struct Template Reference

#include <sol.hpp>

Public Types
typedef std::conditional_t< is_const, const proxy_t, proxy_t >	reference
typedef std::conditional_t< is_const, const proxy_t *, proxy_t * >	pointer
typedef proxy_t	value_type
typedef std::ptrdiff_t	difference_type
typedef std::random_access_iterator_tag	iterator_category

Public Member Functions
	stack_iterator ()
	stack_iterator (const stack_iterator< proxy_t, true > &r)
	stack_iterator (lua_State *luastate, int idx, int topidx)
reference	operator* ()
reference	operator* () const
pointer	operator-> ()
pointer	operator-> () const
stack_iterator &	operator++ ()
stack_iterator	operator++ (int)
stack_iterator &	operator-- ()
stack_iterator	operator-- (int)
stack_iterator &	operator+= (difference_type idx)
stack_iterator &	operator-= (difference_type idx)
difference_type	operator- (const stack_iterator &r) const
stack_iterator	operator+ (difference_type idx) const
reference	operator[] (difference_type idx) const
bool	operator== (const stack_iterator &r) const
bool	operator!= (const stack_iterator &r) const
bool	operator< (const stack_iterator &r) const
bool	operator> (const stack_iterator &r) const
bool	operator<= (const stack_iterator &r) const
bool	operator>= (const stack_iterator &r) const

Public Attributes
lua_State *	L
int	index
int	stacktop
proxy_t	sp

Member Typedef Documentation

difference_type

template<typename proxy_t, bool is_const>

typedef std::ptrdiff_t sol::stack_iterator< proxy_t, is_const >::difference_type

iterator_category

template<typename proxy_t, bool is_const>

typedef std::random_access_iterator_tag sol::stack_iterator< proxy_t, is_const >::iterator_category

pointer

template<typename proxy_t, bool is_const>

typedef std::conditional_t<is_const, const proxy_t*, proxy_t*> sol::stack_iterator< proxy_t, is_const >::pointer

reference

template<typename proxy_t, bool is_const>

typedef std::conditional_t<is_const, const proxy_t, proxy_t> sol::stack_iterator< proxy_t, is_const >::reference

value_type

template<typename proxy_t, bool is_const>

typedef proxy_t sol::stack_iterator< proxy_t, is_const >::value_type

Constructor & Destructor Documentation

stack_iterator() [1/3]

template<typename proxy_t, bool is_const>

sol::stack_iterator< proxy_t, is_const >::stack_iterator ( )

inline

            : L(nullptr), index((std::numeric_limits<int>::max)()), stacktop((std::numeric_limits<int>::max)()), sp() {
        }

stack_iterator() [2/3]

template<typename proxy_t, bool is_const>

sol::stack_iterator< proxy_t, is_const >::stack_iterator ( const stack_iterator< proxy_t, true > &  r )

inline

            : L(r.L), index(r.index), stacktop(r.stacktop), sp(r.sp) {
        }

stack_iterator() [3/3]

template<typename proxy_t, bool is_const>

sol::stack_iterator< proxy_t, is_const >::stack_iterator ( lua_State *  luastate, int  idx, int  topidx  )

inline

            : L(luastate), index(idx), stacktop(topidx), sp(luastate, idx) {
        }

Member Function Documentation

operator!=()

template<typename proxy_t, bool is_const>

bool sol::stack_iterator< proxy_t, is_const >::operator!= ( const stack_iterator< proxy_t, is_const > &  r ) const

inline

                                                       {
            return !(this->operator==(r));
        }

operator*() [1/2]

template<typename proxy_t, bool is_const>

reference sol::stack_iterator< proxy_t, is_const >::operator* ( )

inline

                              {
            return proxy_t(L, index);
        }

operator*() [2/2]

template<typename proxy_t, bool is_const>

reference sol::stack_iterator< proxy_t, is_const >::operator* ( ) const

inline

                                    {
            return proxy_t(L, index);
        }

operator+()

template<typename proxy_t, bool is_const>

stack_iterator sol::stack_iterator< proxy_t, is_const >::operator+ ( difference_type  idx ) const

inline

                                                            {
            stack_iterator r = *this;
            r += idx;
            return r;
        }

operator++() [1/2]

template<typename proxy_t, bool is_const>

stack_iterator& sol::stack_iterator< proxy_t, is_const >::operator++ ( )

inline

                                     {
            ++index;
            return *this;
        }

operator++() [2/2]

template<typename proxy_t, bool is_const>

stack_iterator sol::stack_iterator< proxy_t, is_const >::operator++ ( int  )

inline

                                       {
            auto r = *this;
            this->operator++();
            return r;
        }

operator+=()

template<typename proxy_t, bool is_const>

stack_iterator& sol::stack_iterator< proxy_t, is_const >::operator+= ( difference_type  idx )

inline

                                                        {
            index += static_cast<int>(idx);
            return *this;
        }

operator-()

template<typename proxy_t, bool is_const>

difference_type sol::stack_iterator< proxy_t, is_const >::operator- ( const stack_iterator< proxy_t, is_const > &  r ) const

inline

                                                                 {
            return index - r.index;
        }

operator--() [1/2]

template<typename proxy_t, bool is_const>

stack_iterator& sol::stack_iterator< proxy_t, is_const >::operator-- ( )

inline

                                     {
            --index;
            return *this;
        }

operator--() [2/2]

template<typename proxy_t, bool is_const>

stack_iterator sol::stack_iterator< proxy_t, is_const >::operator-- ( int  )

inline

                                       {
            auto r = *this;
            this->operator--();
            return r;
        }

operator-=()

template<typename proxy_t, bool is_const>

stack_iterator& sol::stack_iterator< proxy_t, is_const >::operator-= ( difference_type  idx )

inline

                                                        {
            index -= static_cast<int>(idx);
            return *this;
        }

operator->() [1/2]

template<typename proxy_t, bool is_const>

pointer sol::stack_iterator< proxy_t, is_const >::operator-> ( )

inline

                             {
            sp = proxy_t(L, index);
            return &sp;
        }

operator->() [2/2]

template<typename proxy_t, bool is_const>

pointer sol::stack_iterator< proxy_t, is_const >::operator-> ( ) const

inline

                                   {
            const_cast<proxy_t&>(sp) = proxy_t(L, index);
            return &sp;
        }

operator<()

template<typename proxy_t, bool is_const>

bool sol::stack_iterator< proxy_t, is_const >::operator< ( const stack_iterator< proxy_t, is_const > &  r ) const

inline

                                                      {
            return index < r.index;
        }

operator<=()

template<typename proxy_t, bool is_const>

bool sol::stack_iterator< proxy_t, is_const >::operator<= ( const stack_iterator< proxy_t, is_const > &  r ) const

inline

                                                       {
            return index <= r.index;
        }

operator==()

template<typename proxy_t, bool is_const>

bool sol::stack_iterator< proxy_t, is_const >::operator== ( const stack_iterator< proxy_t, is_const > &  r ) const

inline

                                                       {
            if (stacktop == (std::numeric_limits<int>::max)()) {
                return r.index == r.stacktop;
            }
            else if (r.stacktop == (std::numeric_limits<int>::max)()) {
                return index == stacktop;
            }
            return index == r.index;
        }

operator>()

template<typename proxy_t, bool is_const>

bool sol::stack_iterator< proxy_t, is_const >::operator> ( const stack_iterator< proxy_t, is_const > &  r ) const

inline

                                                      {
            return index > r.index;
        }

operator>=()

template<typename proxy_t, bool is_const>

bool sol::stack_iterator< proxy_t, is_const >::operator>= ( const stack_iterator< proxy_t, is_const > &  r ) const

inline

                                                       {
            return index >= r.index;
        }

operator[]()

template<typename proxy_t, bool is_const>

reference sol::stack_iterator< proxy_t, is_const >::operator[] ( difference_type  idx ) const

inline

                                                        {
            return proxy_t(L, index + static_cast<int>(idx));
        }

Member Data Documentation

index

template<typename proxy_t, bool is_const>

int sol::stack_iterator< proxy_t, is_const >::index

L

template<typename proxy_t, bool is_const>

lua_State* sol::stack_iterator< proxy_t, is_const >::L

sp

template<typename proxy_t, bool is_const>

proxy_t sol::stack_iterator< proxy_t, is_const >::sp

stacktop

template<typename proxy_t, bool is_const>

int sol::stack_iterator< proxy_t, is_const >::stacktop

---

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

• external/sol.hpp