sol::basic_reference< main_only > Class Template Reference

#include <sol.hpp>

Inheritance diagram for sol::basic_reference< main_only >:

Public Member Functions
	basic_reference () noexcept=default
	basic_reference (lua_nil_t) noexcept
	basic_reference (const stack_reference &r) noexcept
	basic_reference (stack_reference &&r) noexcept
template<bool r_main_only>
	basic_reference (lua_State *L, const basic_reference< r_main_only > &r) noexcept
template<bool r_main_only>
	basic_reference (lua_State *L, basic_reference< r_main_only > &&r) noexcept
	basic_reference (lua_State *L, const stack_reference &r) noexcept
	basic_reference (lua_State *L, int index=-1) noexcept
	basic_reference (lua_State *L, ref_index index) noexcept
	basic_reference (lua_State *L, lua_nil_t) noexcept
	~basic_reference () noexcept
	basic_reference (const basic_reference &o) noexcept
	basic_reference (basic_reference &&o) noexcept
	basic_reference (const basic_reference<!main_only > &o) noexcept
	basic_reference (basic_reference<!main_only > &&o) noexcept
basic_reference &	operator= (basic_reference &&r) noexcept
basic_reference &	operator= (const basic_reference &r) noexcept
basic_reference &	operator= (basic_reference<!main_only > &&r) noexcept
basic_reference &	operator= (const basic_reference<!main_only > &r) noexcept
basic_reference &	operator= (const lua_nil_t &) noexcept
template<typename Super >
basic_reference &	operator= (proxy_base< Super > &&r)
template<typename Super >
basic_reference &	operator= (const proxy_base< Super > &r)
int	push () const noexcept
int	push (lua_State *Ls) const noexcept
void	pop () const noexcept
void	pop (lua_State *Ls, int n=1) const noexcept
int	registry_index () const noexcept
bool	valid () const noexcept
const void *	pointer () const noexcept
	operator bool () const noexcept
type	get_type () const noexcept
lua_State *	lua_state () const noexcept
template<typename Super >
basic_reference< b > &	operator= (proxy_base< Super > &&r)
template<typename Super >
basic_reference< b > &	operator= (const proxy_base< Super > &r)

Protected Member Functions
	basic_reference (lua_State *L, detail::global_tag) noexcept
int	stack_index () const noexcept
void	deref () const noexcept

Private Member Functions
int	copy () const noexcept
template<bool r_main_only>
void	copy_assign (const basic_reference< r_main_only > &r)
template<bool r_main_only>
void	move_assign (basic_reference< r_main_only > &&r)

Private Attributes
lua_State *	luastate = nullptr
int	ref = LUA_NOREF

Friends
template<bool o_main_only>
class	basic_reference

Constructor & Destructor Documentation

basic_reference() [1/15]

template<bool main_only = false>

sol::basic_reference< main_only >::basic_reference ( lua_State *  L, detail::global_tag    )

inlineprotectednoexcept

        : luastate(detail::pick_main_thread<main_only>(L, L)) {
            lua_pushglobaltable(lua_state());
            ref = luaL_ref(lua_state(), LUA_REGISTRYINDEX);
        }

basic_reference() [2/15]

template<bool main_only = false>

sol::basic_reference< main_only >::basic_reference ( )

defaultnoexcept

basic_reference() [3/15]

template<bool main_only = false>

sol::basic_reference< main_only >::basic_reference ( lua_nil_t  )

inlinenoexcept

        : basic_reference() {
        }

basic_reference() [4/15]

template<bool main_only = false>

sol::basic_reference< main_only >::basic_reference ( const stack_reference &  r )

inlinenoexcept

        : basic_reference(r.lua_state(), r.stack_index()) {
        }

basic_reference() [5/15]

template<bool main_only = false>

sol::basic_reference< main_only >::basic_reference ( stack_reference &&  r )

inlinenoexcept

        : basic_reference(r.lua_state(), r.stack_index()) {
        }

basic_reference() [6/15]

template<bool main_only = false>

template<bool r_main_only>

sol::basic_reference< main_only >::basic_reference ( lua_State *  L, const basic_reference< r_main_only > &  r  )

inlinenoexcept

        : luastate(detail::pick_main_thread<main_only>(L, L)) {
            if (r.ref == LUA_REFNIL) {
                ref = LUA_REFNIL;
                return;
            }
            if (r.ref == LUA_NOREF || lua_state() == nullptr) {
                ref = LUA_NOREF;
                return;
            }
            if (detail::xmovable(lua_state(), r.lua_state())) {
                r.push(lua_state());
                ref = luaL_ref(lua_state(), LUA_REGISTRYINDEX);
                return;
            }
            ref = r.copy();
        }

basic_reference() [7/15]

template<bool main_only = false>

template<bool r_main_only>

sol::basic_reference< main_only >::basic_reference ( lua_State *  L, basic_reference< r_main_only > &&  r  )

inlinenoexcept

        : luastate(detail::pick_main_thread<main_only>(L, L)) {
            if (r.ref == LUA_REFNIL) {
                ref = LUA_REFNIL;
                return;
            }
            if (r.ref == LUA_NOREF || lua_state() == nullptr) {
                ref = LUA_NOREF;
                return;
            }
            if (detail::xmovable(lua_state(), r.lua_state())) {
                r.push(lua_state());
                ref = luaL_ref(lua_state(), LUA_REGISTRYINDEX);
                return;
            }
            ref = r.ref;
            r.ref = LUA_NOREF;
            r.luastate = nullptr;
        }

basic_reference() [8/15]

template<bool main_only = false>

sol::basic_reference< main_only >::basic_reference ( lua_State *  L, const stack_reference &  r  )

inlinenoexcept

        : luastate(detail::pick_main_thread<main_only>(L, L)) {
            if (lua_state() == nullptr || r.lua_state() == nullptr || r.get_type() == type::none) {
                ref = LUA_NOREF;
                return;
            }
            if (r.get_type() == type::lua_nil) {
                ref = LUA_REFNIL;
                return;
            }
            if (lua_state() != r.lua_state() && !detail::xmovable(lua_state(), r.lua_state())) {
                return;
            }
            r.push(lua_state());
            ref = luaL_ref(lua_state(), LUA_REGISTRYINDEX);
        }

basic_reference() [9/15]

template<bool main_only = false>

sol::basic_reference< main_only >::basic_reference ( lua_State *  L, int  index = -1  )

inlinenoexcept

        : luastate(detail::pick_main_thread<main_only>(L, L)) {
            // use L to stick with that state's execution stack
            lua_pushvalue(L, index);
            ref = luaL_ref(L, LUA_REGISTRYINDEX);
        }

basic_reference() [10/15]

template<bool main_only = false>

sol::basic_reference< main_only >::basic_reference ( lua_State *  L, ref_index  index  )

inlinenoexcept

        : luastate(detail::pick_main_thread<main_only>(L, L)) {
            lua_rawgeti(lua_state(), LUA_REGISTRYINDEX, index.index);
            ref = luaL_ref(lua_state(), LUA_REGISTRYINDEX);
        }

basic_reference() [11/15]

template<bool main_only = false>

sol::basic_reference< main_only >::basic_reference ( lua_State *  L, lua_nil_t    )

inlinenoexcept

        : luastate(detail::pick_main_thread<main_only>(L, L)) {
        }

~basic_reference()

template<bool main_only = false>

sol::basic_reference< main_only >::~basic_reference ( )

inlinenoexcept

                                    {
            if (lua_state() == nullptr || ref == LUA_NOREF)
                return;
            deref();
        }

basic_reference() [12/15]

template<bool main_only = false>

sol::basic_reference< main_only >::basic_reference ( const basic_reference< main_only > &  o )

inlinenoexcept

        : luastate(o.lua_state()), ref(o.copy()) {
        }

basic_reference() [13/15]

template<bool main_only = false>

sol::basic_reference< main_only >::basic_reference ( basic_reference< main_only > &&  o )

inlinenoexcept

        : luastate(o.lua_state()), ref(o.ref) {
            o.luastate = nullptr;
            o.ref = LUA_NOREF;
        }

basic_reference() [14/15]

template<bool main_only = false>

sol::basic_reference< main_only >::basic_reference ( const basic_reference<!main_only > &  o )

inlinenoexcept

        : luastate(detail::pick_main_thread < main_only && !main_only > (o.lua_state(), o.lua_state())), ref(o.copy()) {
        }

basic_reference() [15/15]

template<bool main_only = false>

sol::basic_reference< main_only >::basic_reference ( basic_reference<!main_only > &&  o )

inlinenoexcept

        : luastate(detail::pick_main_thread < main_only && !main_only > (o.lua_state(), o.lua_state())), ref(o.ref) {
            o.luastate = nullptr;
            o.ref = LUA_NOREF;
        }

Member Function Documentation

copy()

template<bool main_only = false>

int sol::basic_reference< main_only >::copy ( ) const

inlineprivatenoexcept

                                  {
            if (ref == LUA_NOREF)
                return LUA_NOREF;
            push();
            return luaL_ref(lua_state(), LUA_REGISTRYINDEX);
        }

copy_assign()

template<bool main_only = false>

template<bool r_main_only>

void sol::basic_reference< main_only >::copy_assign ( const basic_reference< r_main_only > &  r )

inlineprivate

                                                                {
            if (valid()) {
                deref();
            }
            if (r.ref == LUA_REFNIL) {
                luastate = detail::pick_main_thread < main_only && !r_main_only > (r.lua_state(), r.lua_state());
                ref = LUA_REFNIL;
                return;
            }
            if (r.ref == LUA_NOREF) {
                luastate = r.luastate;
                ref = LUA_NOREF;
                return;
            }
            if (detail::xmovable(lua_state(), r.lua_state())) {
                r.push(lua_state());
                ref = luaL_ref(lua_state(), LUA_REGISTRYINDEX);
                return;
            }
            luastate = detail::pick_main_thread < main_only && !r_main_only > (r.lua_state(), r.lua_state());
            ref = r.copy();
        }

deref()

template<bool main_only = false>

void sol::basic_reference< main_only >::deref ( ) const

inlineprotectednoexcept

                                    {
            luaL_unref(lua_state(), LUA_REGISTRYINDEX, ref);
        }

get_type()

template<bool main_only = false>

type sol::basic_reference< main_only >::get_type ( ) const

inlinenoexcept

                                       {
            auto pp = stack::push_pop(*this);
            int result = lua_type(lua_state(), -1);
            return static_cast<type>(result);
        }

lua_state()

template<bool main_only = false>

lua_State* sol::basic_reference< main_only >::lua_state ( ) const

inlinenoexcept

                                              {
            return luastate;
        }

move_assign()

template<bool main_only = false>

template<bool r_main_only>

void sol::basic_reference< main_only >::move_assign ( basic_reference< r_main_only > &&  r )

inlineprivate

                                                           {
            if (valid()) {
                deref();
            }
            if (r.ref == LUA_REFNIL) {
                luastate = detail::pick_main_thread < main_only && !r_main_only > (r.lua_state(), r.lua_state());
                ref = LUA_REFNIL;
                return;
            }
            if (r.ref == LUA_NOREF) {
                luastate = r.luastate;
                ref = LUA_NOREF;
                return;
            }
            if (detail::xmovable(lua_state(), r.lua_state())) {
                r.push(lua_state());
                ref = luaL_ref(lua_state(), LUA_REGISTRYINDEX);
                return;
            }

            luastate = detail::pick_main_thread < main_only && !r_main_only > (r.lua_state(), r.lua_state());
            ref = r.ref;
            r.ref = LUA_NOREF;
            r.luastate = nullptr;
        }

operator bool()

template<bool main_only = false>

sol::basic_reference< main_only >::operator bool ( ) const

inlineexplicitnoexcept

                                                {
            return valid();
        }

operator=() [1/9]

template<bool main_only = false>

basic_reference& sol::basic_reference< main_only >::operator= ( basic_reference< main_only > &&  r )

inlinenoexcept

                                                                 {
            move_assign(std::move(r));
            return *this;
        }

operator=() [2/9]

template<bool main_only = false>

basic_reference& sol::basic_reference< main_only >::operator= ( const basic_reference< main_only > &  r )

inlinenoexcept

                                                                      {
            copy_assign(r);
            return *this;
        }

operator=() [3/9]

template<bool main_only = false>

basic_reference& sol::basic_reference< main_only >::operator= ( basic_reference<!main_only > &&  r )

inlinenoexcept

                                                                             {
            move_assign(std::move(r));
            return *this;
        }

operator=() [4/9]

template<bool main_only = false>

basic_reference& sol::basic_reference< main_only >::operator= ( const basic_reference<!main_only > &  r )

inlinenoexcept

                                                                                  {
            copy_assign(r);
            return *this;
        }

operator=() [5/9]

template<bool main_only = false>

basic_reference& sol::basic_reference< main_only >::operator= ( const lua_nil_t &  )

inlinenoexcept

                                                              {
            if (valid()) {
                deref();
            }
            luastate = nullptr;
            ref = LUA_NOREF;
            return *this;
        }

operator=() [6/9]

template<bool main_only = false>

template<typename Super >

basic_reference& sol::basic_reference< main_only >::operator=

(

proxy_base< Super > &&

r

)

operator=() [7/9]

template<bool main_only = false>

template<typename Super >

basic_reference& sol::basic_reference< main_only >::operator=

(

const proxy_base< Super > &

r

)

operator=() [8/9]

template<bool main_only = false>

template<typename Super >

basic_reference<b>& sol::basic_reference< main_only >::operator=

(

proxy_base< Super > &&

r

)

                                                                           {
        basic_reference<b> v = r;
        this->operator=(std::move(v));
        return *this;
    }

operator=() [9/9]

template<bool main_only = false>

template<typename Super >

basic_reference<b>& sol::basic_reference< main_only >::operator=

(

const proxy_base< Super > &

r

)

                                                                                {
        basic_reference<b> v = r;
        this->operator=(std::move(v));
        return *this;
    }

pointer()

template<bool main_only = false>

const void* sol::basic_reference< main_only >::pointer ( ) const

inlinenoexcept

                                             {
            int si = push();
            const void* vp = lua_topointer(lua_state(), -si);
            lua_pop(this->lua_state(), si);
            return vp;
        }

pop() [1/2]

template<bool main_only = false>

void sol::basic_reference< main_only >::pop ( ) const

inlinenoexcept

                                  {
            pop(lua_state());
        }

pop() [2/2]

template<bool main_only = false>

void sol::basic_reference< main_only >::pop ( lua_State *  Ls, int  n = 1  ) const

inlinenoexcept

                                                          {
            lua_pop(Ls, n);
        }

push() [1/2]

template<bool main_only = false>

int sol::basic_reference< main_only >::push ( ) const

inlinenoexcept

                                  {
            return push(lua_state());
        }

push() [2/2]

template<bool main_only = false>

int sol::basic_reference< main_only >::push ( lua_State *  Ls ) const

inlinenoexcept

                                               {
            if (lua_state() == nullptr) {
                lua_pushnil(Ls);
                return 1;
            }
            lua_rawgeti(lua_state(), LUA_REGISTRYINDEX, ref);
            if (Ls != lua_state()) {
                lua_xmove(lua_state(), Ls, 1);
            }
            return 1;
        }

registry_index()

template<bool main_only = false>

int sol::basic_reference< main_only >::registry_index ( ) const

inlinenoexcept

                                            {
            return ref;
        }

stack_index()

template<bool main_only = false>

int sol::basic_reference< main_only >::stack_index ( ) const

inlineprotectednoexcept

                                         {
            return -1;
        }

valid()

template<bool main_only = false>

bool sol::basic_reference< main_only >::valid ( ) const

inlinenoexcept

                                    {
            return !(ref == LUA_NOREF || ref == LUA_REFNIL);
        }

Friends And Related Function Documentation

basic_reference

template<bool main_only = false>

template<bool o_main_only>

friend class basic_reference

friend

Member Data Documentation

luastate

template<bool main_only = false>

lua_State* sol::basic_reference< main_only >::luastate = nullptr

private

ref

template<bool main_only = false>

int sol::basic_reference< main_only >::ref = LUA_NOREF

private

---

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

• external/sol.hpp