sol::load_result Struct Reference

#include <sol.hpp>

Inheritance diagram for sol::load_result:

Public Member Functions
	load_result ()=default
	load_result (lua_State *Ls, int stackindex=-1, int retnum=0, int popnum=0, load_status lerr=load_status::ok) noexcept
	load_result (const load_result &)=default
load_result &	operator= (const load_result &)=default
	load_result (load_result &&o) noexcept
load_result &	operator= (load_result &&o) noexcept
load_status	status () const noexcept
bool	valid () const noexcept
template<typename T >
T	get () const
template<typename... Ret, typename... Args>
decltype(auto)	call (Args &&... args)
template<typename... Args>
decltype(auto)	operator() (Args &&... args)
lua_State *	lua_state () const noexcept
int	stack_index () const noexcept
	~load_result ()
Public Member Functions inherited from sol::proxy_base< load_result >
	operator std::string () const
	operator T () const
	operator T& () const
lua_State *	lua_state () const

Private Member Functions
template<typename T >
decltype(auto)	tagged_get (types< optional< T >>) const
template<typename T >
decltype(auto)	tagged_get (types< T >) const
optional< error >	tagged_get (types< optional< error >>) const
error	tagged_get (types< error >) const

Private Attributes
lua_State *	L
int	index
int	returncount
int	popcount
load_status	err

Constructor & Destructor Documentation

load_result() [1/4]

sol::load_result::load_result ( )

default

load_result() [2/4]

sol::load_result::load_result ( lua_State *  Ls, int  stackindex = -1, int  retnum = 0, int  popnum = 0, load_status  lerr = load_status::ok  )

inlinenoexcept

        : L(Ls), index(stackindex), returncount(retnum), popcount(popnum), err(lerr) {
        }

load_result() [3/4]

sol::load_result::load_result ( const load_result &  )

default

load_result() [4/4]

sol::load_result::load_result ( load_result &&  o )

inlinenoexcept

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

~load_result()

sol::load_result::~load_result ( )

inline

                       {
            stack::remove(L, index, popcount);
        }

Member Function Documentation

call()

template<typename... Ret, typename... Args>

decltype(auto) sol::load_result::call ( Args &&...  args )

inline

                                            {
#if !defined(__clang__) && defined(_MSC_FULL_VER) && _MSC_FULL_VER >= 191200000
            // MSVC is ass sometimes
            return get<protected_function>().call<Ret...>(std::forward<Args>(args)...);
#else
            return get<protected_function>().template call<Ret...>(std::forward<Args>(args)...);
#endif
        }

get()

template<typename T >

T sol::load_result::get ( ) const

inline

                      {
            return tagged_get(types<meta::unqualified_t<T>>());
        }

lua_state()

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

inlinenoexcept

                                              {
            return L;
        };

operator()()

template<typename... Args>

decltype(auto) sol::load_result::operator() ( Args &&...  args )

inline

                                                  {
            return call<>(std::forward<Args>(args)...);
        }

operator=() [1/2]

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

default

operator=() [2/2]

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

inlinenoexcept

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

stack_index()

int sol::load_result::stack_index ( ) const

inlinenoexcept

                                         {
            return index;
        };

status()

load_status sol::load_result::status ( ) const

inlinenoexcept

                                            {
            return err;
        }

tagged_get() [1/4]

template<typename T >

decltype(auto) sol::load_result::tagged_get ( types< optional< T >>  ) const

inlineprivate

                                                            {
            if (!valid()) {
                return optional<T>(nullopt);
            }
            return stack::get<optional<T>>(L, index);
        }

tagged_get() [2/4]

template<typename T >

decltype(auto) sol::load_result::tagged_get ( types< T >  ) const

inlineprivate

                                                  {
#if defined(SOL_SAFE_PROXIES) && SOL_SAFE_PROXIES != 0
            if (!valid()) {
                type_panic_c_str(L, index, type_of(L, index), type::none);
            }
#endif // Check Argument Safety
            return stack::get<T>(L, index);
        }

tagged_get() [3/4]

optional<error> sol::load_result::tagged_get ( types< optional< error >>  ) const

inlineprivate

                                                                 {
            if (valid()) {
                return nullopt;
            }
            return error(detail::direct_error, stack::get<std::string>(L, index));
        }

tagged_get() [4/4]

error sol::load_result::tagged_get ( types< error >  ) const

inlineprivate

                                             {
#if defined(SOL_SAFE_PROXIES) && SOL_SAFE_PROXIES != 0
            if (valid()) {
                type_panic_c_str(L, index, type_of(L, index), type::none, "expecting an error type (a string, from Lua)");
            }
#endif // Check Argument Safety
            return error(detail::direct_error, stack::get<std::string>(L, index));
        }

valid()

bool sol::load_result::valid ( ) const

inlinenoexcept

                                    {
            return status() == load_status::ok;
        }

Member Data Documentation

err

load_status sol::load_result::err

private

index

int sol::load_result::index

private

L

lua_State* sol::load_result::L

private

popcount

int sol::load_result::popcount

private

returncount

int sol::load_result::returncount

private

---

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

• external/sol.hpp