sol::basic_object< base_type > Class Template Reference

#include <sol.hpp>

Inheritance diagram for sol::basic_object< base_type >:

Public Member Functions
	basic_object () noexcept=default
template<typename T , meta::enable< meta::neg< std::is_same< meta::unqualified_t< T >, basic_object >>, meta::neg< std::is_same< base_type, stack_reference >>, is_lua_reference< meta::unqualified_t< T >>> = meta::enabler>
	basic_object (T &&r)
template<typename T , meta::enable< is_lua_reference< meta::unqualified_t< T >>> = meta::enabler>
	basic_object (lua_State *L, T &&r)
	basic_object (lua_nil_t r)
	basic_object (const basic_object &)=default
	basic_object (basic_object &&)=default
	basic_object (const stack_reference &r) noexcept
	basic_object (stack_reference &&r) noexcept
template<typename Super >
	basic_object (const proxy_base< Super > &r) noexcept
template<typename Super >
	basic_object (proxy_base< Super > &&r) noexcept
	basic_object (lua_State *L, lua_nil_t r) noexcept
	basic_object (lua_State *L, int index=-1) noexcept
	basic_object (lua_State *L, absolute_index index) noexcept
	basic_object (lua_State *L, raw_index index) noexcept
	basic_object (lua_State *L, ref_index index) noexcept
template<typename T , typename... Args>
	basic_object (lua_State *L, in_place_type_t< T >, Args &&... args) noexcept
template<typename T , typename... Args>
	basic_object (lua_State *L, in_place_t, T &&arg, Args &&... args) noexcept
basic_object &	operator= (const basic_object &)=default
basic_object &	operator= (basic_object &&)=default
basic_object &	operator= (const base_type &b)
basic_object &	operator= (base_type &&b)
template<typename Super >
basic_object &	operator= (const proxy_base< Super > &r)
template<typename Super >
basic_object &	operator= (proxy_base< Super > &&r)
Public Member Functions inherited from sol::basic_object_base< base_type >
	basic_object_base () noexcept=default
	basic_object_base (const basic_object_base &)=default
	basic_object_base (basic_object_base &&)=default
	basic_object_base (T &&arg, Args &&... args)
basic_object_base &	operator= (const basic_object_base &)=default
basic_object_base &	operator= (basic_object_base &&)=default
decltype(auto)	as () const
bool	is () const

Private Types
typedef basic_object_base< base_type >	base_t

Private Member Functions
template<bool invert_and_pop = false>
	basic_object (std::integral_constant< bool, invert_and_pop >, lua_State *L, int index=-1) noexcept

Member Typedef Documentation

base_t

template<typename base_type>

typedef basic_object_base<base_type> sol::basic_object< base_type >::base_t

private

Constructor & Destructor Documentation

basic_object() [1/18]

template<typename base_type>

template<bool invert_and_pop = false>

sol::basic_object< base_type >::basic_object ( std::integral_constant< bool, invert_and_pop >  , lua_State *  L, int  index = -1  )

inlineprivatenoexcept

        : base_t(L, index) {
            if (invert_and_pop) {
                lua_pop(L, -index);
            }
        }

basic_object() [2/18]

template<typename base_type>

sol::basic_object< base_type >::basic_object ( )

defaultnoexcept

basic_object() [3/18]

template<typename base_type>

template<typename T , meta::enable< meta::neg< std::is_same< meta::unqualified_t< T >, basic_object >>, meta::neg< std::is_same< base_type, stack_reference >>, is_lua_reference< meta::unqualified_t< T >>> = meta::enabler>

sol::basic_object< base_type >::basic_object ( T &&  r )

inline

        : base_t(std::forward<T>(r)) {
        }

basic_object() [4/18]

template<typename base_type>

template<typename T , meta::enable< is_lua_reference< meta::unqualified_t< T >>> = meta::enabler>

sol::basic_object< base_type >::basic_object ( lua_State *  L, T &&  r  )

inline

        : base_t(L, std::forward<T>(r)) {
        }

basic_object() [5/18]

template<typename base_type>

sol::basic_object< base_type >::basic_object ( lua_nil_t  r )

inline

        : base_t(r) {
        }

basic_object() [6/18]

template<typename base_type>

sol::basic_object< base_type >::basic_object ( const basic_object< base_type > &  )

default

basic_object() [7/18]

template<typename base_type>

sol::basic_object< base_type >::basic_object ( basic_object< base_type > &&  )

default

basic_object() [8/18]

template<typename base_type>

sol::basic_object< base_type >::basic_object ( const stack_reference &  r )

inlinenoexcept

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

basic_object() [9/18]

template<typename base_type>

sol::basic_object< base_type >::basic_object ( stack_reference &&  r )

inlinenoexcept

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

basic_object() [10/18]

template<typename base_type>

template<typename Super >

sol::basic_object< base_type >::basic_object ( const proxy_base< Super > &  r )

inlinenoexcept

        : basic_object(r.operator basic_object()) {
        }

basic_object() [11/18]

template<typename base_type>

template<typename Super >

sol::basic_object< base_type >::basic_object ( proxy_base< Super > &&  r )

inlinenoexcept

        : basic_object(r.operator basic_object()) {
        }

basic_object() [12/18]

template<typename base_type>

sol::basic_object< base_type >::basic_object ( lua_State *  L, lua_nil_t  r  )

inlinenoexcept

        : base_t(L, r) {
        }

basic_object() [13/18]

template<typename base_type>

sol::basic_object< base_type >::basic_object ( lua_State *  L, int  index = -1  )

inlinenoexcept

        : base_t(L, index) {
        }

basic_object() [14/18]

template<typename base_type>

sol::basic_object< base_type >::basic_object ( lua_State *  L, absolute_index  index  )

inlinenoexcept

        : base_t(L, index) {
        }

basic_object() [15/18]

template<typename base_type>

sol::basic_object< base_type >::basic_object ( lua_State *  L, raw_index  index  )

inlinenoexcept

        : base_t(L, index) {
        }

basic_object() [16/18]

template<typename base_type>

sol::basic_object< base_type >::basic_object ( lua_State *  L, ref_index  index  )

inlinenoexcept

        : base_t(L, index) {
        }

basic_object() [17/18]

template<typename base_type>

template<typename T , typename... Args>

sol::basic_object< base_type >::basic_object ( lua_State *  L, in_place_type_t< T >  , Args &&...  args  )

inlinenoexcept

        : basic_object(std::integral_constant<bool, !is_stack_based<base_t>::value>(), L, -stack::push<T>(L, std::forward<Args>(args)...)) {
        }

basic_object() [18/18]

template<typename base_type>

template<typename T , typename... Args>

sol::basic_object< base_type >::basic_object ( lua_State *  L, in_place_t  , T &&  arg, Args &&...  args  )

inlinenoexcept

        : basic_object(L, in_place_type<T>, std::forward<T>(arg), std::forward<Args>(args)...) {
        }

Member Function Documentation

operator=() [1/6]

template<typename base_type>

basic_object& sol::basic_object< base_type >::operator= ( const basic_object< base_type > &  )

default

operator=() [2/6]

template<typename base_type>

basic_object& sol::basic_object< base_type >::operator= ( basic_object< base_type > &&  )

default

operator=() [3/6]

template<typename base_type>

basic_object& sol::basic_object< base_type >::operator= ( const base_type &  b )

inline

                                                    {
            base_t::operator=(b);
            return *this;
        }

operator=() [4/6]

template<typename base_type>

basic_object& sol::basic_object< base_type >::operator= ( base_type &&  b )

inline

                                               {
            base_t::operator=(std::move(b));
            return *this;
        }

operator=() [5/6]

template<typename base_type>

template<typename Super >

basic_object& sol::basic_object< base_type >::operator= ( const proxy_base< Super > &  r )

inline

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

operator=() [6/6]

template<typename base_type>

template<typename Super >

basic_object& sol::basic_object< base_type >::operator= ( proxy_base< Super > &&  r )

inline

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

---

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

• external/sol.hpp