sol::basic_object_base< base_t > Class Template Reference

#include <sol.hpp>

Inheritance diagram for sol::basic_object_base< base_t >:

Public Member Functions
	basic_object_base () noexcept=default
	basic_object_base (const basic_object_base &)=default
	basic_object_base (basic_object_base &&)=default
basic_object_base &	operator= (const basic_object_base &)=default
basic_object_base &	operator= (basic_object_base &&)=default
template<typename T , typename... Args, meta::enable< meta::neg< std::is_same< meta::unqualified_t< T >, basic_object_base >>> = meta::enabler>
	basic_object_base (T &&arg, Args &&... args)
template<typename T >
decltype(auto)	as () const
template<typename T >
bool	is () const

Private Member Functions
template<typename T >
decltype(auto)	as_stack (std::true_type) const
template<typename T >
decltype(auto)	as_stack (std::false_type) const
template<typename T >
bool	is_stack (std::true_type) const
template<typename T >
bool	is_stack (std::false_type) const

Constructor & Destructor Documentation

basic_object_base() [1/4]

template<typename base_t>

sol::basic_object_base< base_t >::basic_object_base ( )

defaultnoexcept

basic_object_base() [2/4]

template<typename base_t>

sol::basic_object_base< base_t >::basic_object_base ( const basic_object_base< base_t > &  )

default

basic_object_base() [3/4]

template<typename base_t>

sol::basic_object_base< base_t >::basic_object_base ( basic_object_base< base_t > &&  )

default

basic_object_base() [4/4]

template<typename base_t>

template<typename T , typename... Args, meta::enable< meta::neg< std::is_same< meta::unqualified_t< T >, basic_object_base >>> = meta::enabler>

sol::basic_object_base< base_t >::basic_object_base ( T &&  arg, Args &&...  args  )

inline

        : base_t(std::forward<T>(arg), std::forward<Args>(args)...) {
        }

Member Function Documentation

as()

template<typename base_t>

template<typename T >

decltype(auto) sol::basic_object_base< base_t >::as ( ) const

inline

                                  {
            return as_stack<T>(is_stack_based<base_t>());
        }

as_stack() [1/2]

template<typename base_t>

template<typename T >

decltype(auto) sol::basic_object_base< base_t >::as_stack ( std::true_type  ) const

inlineprivate

                                                    {
            return stack::get<T>(base_t::lua_state(), base_t::stack_index());
        }

as_stack() [2/2]

template<typename base_t>

template<typename T >

decltype(auto) sol::basic_object_base< base_t >::as_stack ( std::false_type  ) const

inlineprivate

                                                     {
            base_t::push();
            return stack::pop<T>(base_t::lua_state());
        }

is()

template<typename base_t>

template<typename T >

bool sol::basic_object_base< base_t >::is ( ) const

inline

                        {
            return is_stack<T>(is_stack_based<base_t>());
        }

is_stack() [1/2]

template<typename base_t>

template<typename T >

bool sol::basic_object_base< base_t >::is_stack ( std::true_type  ) const

inlineprivate

                                          {
            return stack::check<T>(base_t::lua_state(), base_t::stack_index(), no_panic);
        }

is_stack() [2/2]

template<typename base_t>

template<typename T >

bool sol::basic_object_base< base_t >::is_stack ( std::false_type  ) const

inlineprivate

                                           {
            int r = base_t::registry_index();
            if (r == LUA_REFNIL)
                return meta::any_same<meta::unqualified_t<T>, lua_nil_t, nullopt_t, std::nullptr_t>::value ? true : false;
            if (r == LUA_NOREF)
                return false;
            auto pp = stack::push_pop(*this);
            return stack::check<T>(base_t::lua_state(), -1, no_panic);
        }

operator=() [1/2]

template<typename base_t>

basic_object_base& sol::basic_object_base< base_t >::operator= ( const basic_object_base< base_t > &  )

default

operator=() [2/2]

template<typename base_t>

basic_object_base& sol::basic_object_base< base_t >::operator= ( basic_object_base< base_t > &&  )

default

---

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

• external/sol.hpp