sol::basic_environment< base_type > Struct Template Reference

#include <sol.hpp>

Inheritance diagram for sol::basic_environment< base_type >:

Public Member Functions
	basic_environment () noexcept=default
	basic_environment (const basic_environment &)=default
	basic_environment (basic_environment &&)=default
basic_environment &	operator= (const basic_environment &)=default
basic_environment &	operator= (basic_environment &&)=default
	basic_environment (const stack_reference &r)
	basic_environment (stack_reference &&r)
	basic_environment (lua_State *L, new_table nt)
template<bool b>
	basic_environment (lua_State *L, new_table t, const basic_reference< b > &fallback)
	basic_environment (env_t, const stack_reference &extraction_target)
template<bool b>
	basic_environment (env_t, const basic_reference< b > &extraction_target)
	basic_environment (lua_State *L, int index=-1)
	basic_environment (lua_State *L, ref_index index)
template<typename T , meta::enable< meta::neg< meta::any_same< meta::unqualified_t< T >, basic_environment >>, meta::neg< std::is_same< base_type, stack_reference >>, meta::neg< std::is_same< lua_nil_t, meta::unqualified_t< T >>>, is_lua_reference< meta::unqualified_t< T >>> = meta::enabler>
	basic_environment (T &&r) noexcept
	basic_environment (lua_nil_t r) noexcept
template<typename T , meta::enable< is_lua_reference< meta::unqualified_t< T >>> = meta::enabler>
	basic_environment (lua_State *L, T &&r) noexcept
template<typename T >
void	set_on (const T &target) const
Public Member Functions inherited from sol::basic_table_core< top_level, base_type >
	basic_table_core () noexcept=default
	basic_table_core (const basic_table_core &)=default
	basic_table_core (basic_table_core &&)=default
basic_table_core &	operator= (const basic_table_core &)=default
basic_table_core &	operator= (basic_table_core &&)=default
	basic_table_core (const stack_reference &r)
	basic_table_core (stack_reference &&r)
template<typename T , meta::enable_any< is_lua_reference< meta::unqualified_t< T >>> = meta::enabler>
	basic_table_core (lua_State *L, T &&r)
	basic_table_core (lua_State *L, const new_table &nt)
	basic_table_core (lua_State *L, int index=-1)
	basic_table_core (lua_State *L, ref_index index)
template<typename T , meta::enable< meta::neg< meta::any_same< meta::unqualified_t< T >, basic_table_core >>, meta::neg< std::is_same< base_type, stack_reference >>, meta::neg< std::is_same< lua_nil_t, meta::unqualified_t< T >>>, is_lua_reference< meta::unqualified_t< T >>> = meta::enabler>
	basic_table_core (T &&r) noexcept
	basic_table_core (lua_nil_t r) noexcept
iterator	begin () const
iterator	end () const
const_iterator	cbegin () const
const_iterator	cend () const
template<typename... Ret, typename... Keys>
decltype(auto)	get (Keys &&... keys) const
template<typename T , typename Key >
decltype(auto)	get_or (Key &&key, T &&otherwise) const
template<typename T , typename Key , typename D >
decltype(auto)	get_or (Key &&key, D &&otherwise) const
template<typename T , typename... Keys>
decltype(auto)	traverse_get (Keys &&... keys) const
template<typename... Keys>
basic_table_core &	traverse_set (Keys &&... keys)
template<typename... Args>
basic_table_core &	set (Args &&... args)
template<typename... Ret, typename... Keys>
decltype(auto)	raw_get (Keys &&... keys) const
template<typename T , typename Key >
decltype(auto)	raw_get_or (Key &&key, T &&otherwise) const
template<typename T , typename Key , typename D >
decltype(auto)	raw_get_or (Key &&key, D &&otherwise) const
template<typename T , typename... Keys>
decltype(auto)	traverse_raw_get (Keys &&... keys) const
template<typename... Keys>
basic_table_core &	traverse_raw_set (Keys &&... keys)
template<typename... Args>
basic_table_core &	raw_set (Args &&... args)
template<typename T >
basic_table_core &	set_usertype (usertype< T > &user)
template<typename Key , typename T >
basic_table_core &	set_usertype (Key &&key, usertype< T > &user)
template<typename Class , typename... Args>
basic_table_core &	new_usertype (const std::string &name, Args &&... args)
template<typename Class , typename CTor0 , typename... CTor, typename... Args>
basic_table_core &	new_usertype (const std::string &name, Args &&... args)
template<typename Class , typename... CArgs, typename... Args>
basic_table_core &	new_usertype (const std::string &name, constructors< CArgs... > ctor, Args &&... args)
template<typename Class , typename... Args>
basic_table_core &	new_simple_usertype (const std::string &name, Args &&... args)
template<typename Class , typename CTor0 , typename... CTor, typename... Args>
basic_table_core &	new_simple_usertype (const std::string &name, Args &&... args)
template<typename Class , typename... CArgs, typename... Args>
basic_table_core &	new_simple_usertype (const std::string &name, constructors< CArgs... > ctor, Args &&... args)
template<typename Class , typename... Args>
simple_usertype< Class >	create_simple_usertype (Args &&... args)
template<typename Class , typename CTor0 , typename... CTor, typename... Args>
simple_usertype< Class >	create_simple_usertype (Args &&... args)
template<typename Class , typename... CArgs, typename... Args>
simple_usertype< Class >	create_simple_usertype (constructors< CArgs... > ctor, Args &&... args)
template<bool read_only = true, typename... Args>
table	new_enum (const string_view &name, Args &&... args)
template<typename T , bool read_only = true>
table	new_enum (const string_view &name, std::initializer_list< std::pair< string_view, T >> items)
template<typename Fx >
void	for_each (Fx &&fx) const
size_t	size () const
bool	empty () const
template<typename T >
proxy< basic_table_core &, T >	operator[] (T &&key) &
template<typename T >
proxy< const basic_table_core &, T >	operator[] (T &&key) const &
template<typename T >
proxy< basic_table_core, T >	operator[] (T &&key) &&
template<typename Sig , typename Key , typename... Args>
basic_table_core &	set_function (Key &&key, Args &&... args)
template<typename Key , typename... Args>
basic_table_core &	set_function (Key &&key, Args &&... args)
template<typename... Args>
basic_table_core &	add (Args &&... args)
table	create (int narr=0, int nrec=0)
template<typename Key , typename Value , typename... Args>
table	create (int narr, int nrec, Key &&key, Value &&value, Args &&... args)
template<typename Name >
table	create (Name &&name, int narr=0, int nrec=0)
template<typename Name , typename Key , typename Value , typename... Args>
table	create (Name &&name, int narr, int nrec, Key &&key, Value &&value, Args &&... args)
template<typename... Args>
table	create_with (Args &&... args)
template<typename Name , typename... Args>
table	create_named (Name &&name, Args &&... args)
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_table< base_type >	base_t

Additional Inherited Members
Public Types inherited from sol::basic_table_core< top_level, base_type >
typedef basic_table_iterator< base_type >	iterator
typedef iterator	const_iterator
Static Public Member Functions inherited from sol::basic_table_core< top_level, base_type >
static table	create (lua_State *L, int narr=0, int nrec=0)
template<typename Key , typename Value , typename... Args>
static table	create (lua_State *L, int narr, int nrec, Key &&key, Value &&value, Args &&... args)
template<typename... Args>
static table	create_with (lua_State *L, Args &&... args)
Protected Member Functions inherited from sol::basic_table_core< top_level, base_type >
	basic_table_core (detail::no_safety_tag, lua_nil_t n)
	basic_table_core (detail::no_safety_tag, lua_State *L, int index)
	basic_table_core (detail::no_safety_tag, lua_State *L, ref_index index)
template<typename T , meta::enable< meta::neg< meta::any_same< meta::unqualified_t< T >, basic_table_core >>, meta::neg< std::is_same< base_type, stack_reference >>, meta::neg< std::is_same< lua_nil_t, meta::unqualified_t< T >>>, is_lua_reference< meta::unqualified_t< T >>> = meta::enabler>
	basic_table_core (detail::no_safety_tag, T &&r) noexcept
template<typename T , meta::enable< is_lua_reference< meta::unqualified_t< T >>> = meta::enabler>
	basic_table_core (detail::no_safety_tag, lua_State *L, T &&r) noexcept

Member Typedef Documentation

base_t

template<typename base_type>

typedef basic_table<base_type> sol::basic_environment< base_type >::base_t

private

Constructor & Destructor Documentation

basic_environment() [1/14]

template<typename base_type>

sol::basic_environment< base_type >::basic_environment ( )

defaultnoexcept

basic_environment() [2/14]

template<typename base_type>

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

default

basic_environment() [3/14]

template<typename base_type>

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

default

basic_environment() [4/14]

template<typename base_type>

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

inline

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

basic_environment() [5/14]

template<typename base_type>

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

inline

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

basic_environment() [6/14]

template<typename base_type>

sol::basic_environment< base_type >::basic_environment ( lua_State *  L, new_table  nt  )

inline

        : base_t(L, std::move(nt)) {
        }

basic_environment() [7/14]

template<typename base_type>

template<bool b>

sol::basic_environment< base_type >::basic_environment ( lua_State *  L, new_table  t, const basic_reference< b > &  fallback  )

inline

        : basic_environment(L, std::move(t)) {
            stack_table mt(L, new_table(0, 1));
            mt.set(meta_function::index, fallback);
            this->set(metatable_key, mt);
            mt.pop();
        }

basic_environment() [8/14]

template<typename base_type>

sol::basic_environment< base_type >::basic_environment ( env_t  , const stack_reference &  extraction_target  )

inline

        : base_t(detail::no_safety, extraction_target.lua_state(), (stack::push_environment_of(extraction_target), -1)) {
#if defined(SOL_SAFE_REFERENCES) && SOL_SAFE_REFERENCES
            constructor_handler handler{};
            stack::check<env_t>(this->lua_state(), -1, handler);
#endif // Safety
            lua_pop(this->lua_state(), 2);
        }

basic_environment() [9/14]

template<typename base_type>

template<bool b>

sol::basic_environment< base_type >::basic_environment ( env_t  , const basic_reference< b > &  extraction_target  )

inline

        : base_t(detail::no_safety, extraction_target.lua_state(), (stack::push_environment_of(extraction_target), -1)) {
#if defined(SOL_SAFE_REFERENCES) && SOL_SAFE_REFERENCES
            constructor_handler handler{};
            stack::check<env_t>(this->lua_state(), -1, handler);
#endif // Safety
            lua_pop(this->lua_state(), 2);
        }

basic_environment() [10/14]

template<typename base_type>

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

inline

        : base_t(detail::no_safety, L, index) {
#if defined(SOL_SAFE_REFERENCES) && SOL_SAFE_REFERENCES
            constructor_handler handler{};
            stack::check<basic_environment>(L, index, handler);
#endif // Safety
        }

basic_environment() [11/14]

template<typename base_type>

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

inline

        : base_t(detail::no_safety, L, index) {
#if defined(SOL_SAFE_REFERENCES) && SOL_SAFE_REFERENCES
            auto pp = stack::push_pop(*this);
            constructor_handler handler{};
            stack::check<basic_environment>(L, -1, handler);
#endif // Safety
        }

basic_environment() [12/14]

template<typename base_type>

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

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

inlinenoexcept

        : base_t(detail::no_safety, std::forward<T>(r)) {
#if defined(SOL_SAFE_REFERENCES) && SOL_SAFE_REFERENCES
            if (!is_environment<meta::unqualified_t<T>>::value) {
                auto pp = stack::push_pop(*this);
                constructor_handler handler{};
                stack::check<basic_environment>(lua_state(), -1, handler);
            }
#endif // Safety
        }

basic_environment() [13/14]

template<typename base_type>

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

inlinenoexcept

        : base_t(detail::no_safety, r) {
        }

basic_environment() [14/14]

template<typename base_type>

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

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

inlinenoexcept

            : base_t(detail::no_safety, L, std::forward<T>(r)) {
#if defined(SOL_SAFE_REFERENCES) && SOL_SAFE_REFERENCES
            if (!is_environment<meta::unqualified_t<T>>::value) {
                auto pp = stack::push_pop(*this);
                constructor_handler handler{};
                stack::check<basic_environment>(lua_state(), -1, handler);
            }
#endif // Safety
        }

Member Function Documentation

operator=() [1/2]

template<typename base_type>

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

default

operator=() [2/2]

template<typename base_type>

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

default

set_on()

template<typename base_type>

template<typename T >

void sol::basic_environment< base_type >::set_on ( const T &  target ) const

inline

                                           {
            lua_State* L = target.lua_state();
            auto pp = stack::push_pop(target);
#if SOL_LUA_VERSION < 502
            // Use lua_setfenv
            this->push();
            lua_setfenv(L, -2);
#else
            // Use upvalues as explained in Lua 5.2 and beyond's manual
            this->push();
            const char* name = lua_setupvalue(L, -2, 1);
            if (name == nullptr) {
                this->pop();
            }
#endif
        }

---

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

• external/sol.hpp