sol::state_view Class Reference

#include <sol.hpp>

Inheritance diagram for sol::state_view:

Public Types
typedef global_table::iterator	iterator
typedef global_table::const_iterator	const_iterator

Public Member Functions
	state_view (lua_State *Ls)
	state_view (this_state Ls)
lua_State *	lua_state () const
template<typename... Args>
void	open_libraries (Args &&... args)
object	require (const std::string &key, lua_CFunction open_function, bool create_global=true)
object	require_script (const std::string &key, const string_view &code, bool create_global=true, const std::string &chunkname=detail::default_chunk_name(), load_mode mode=load_mode::any)
object	require_file (const std::string &key, const std::string &filename, bool create_global=true, load_mode mode=load_mode::any)
template<typename E >
protected_function_result	do_string (const string_view &code, const basic_environment< E > &env, const std::string &chunkname=detail::default_chunk_name(), load_mode mode=load_mode::any)
template<typename E >
protected_function_result	do_file (const std::string &filename, const basic_environment< E > &env, load_mode mode=load_mode::any)
protected_function_result	do_string (const string_view &code, const std::string &chunkname=detail::default_chunk_name(), load_mode mode=load_mode::any)
protected_function_result	do_file (const std::string &filename, load_mode mode=load_mode::any)
template<typename Fx , meta::disable_any< meta::is_string_constructible< meta::unqualified_t< Fx >>, meta::is_specialization_of< meta::unqualified_t< Fx >, basic_environment >> = meta::enabler>
protected_function_result	safe_script (const string_view &code, Fx &&on_error, const std::string &chunkname=detail::default_chunk_name(), load_mode mode=load_mode::any)
template<typename Fx , typename E >
protected_function_result	safe_script (const string_view &code, const basic_environment< E > &env, Fx &&on_error, const std::string &chunkname=detail::default_chunk_name(), load_mode mode=load_mode::any)
template<typename E >
protected_function_result	safe_script (const string_view &code, const basic_environment< E > &env, const std::string &chunkname=detail::default_chunk_name(), load_mode mode=load_mode::any)
protected_function_result	safe_script (const string_view &code, const std::string &chunkname=detail::default_chunk_name(), load_mode mode=load_mode::any)
template<typename Fx , meta::disable_any< meta::is_string_constructible< meta::unqualified_t< Fx >>, meta::is_specialization_of< meta::unqualified_t< Fx >, basic_environment >> = meta::enabler>
protected_function_result	safe_script_file (const std::string &filename, Fx &&on_error, load_mode mode=load_mode::any)
template<typename Fx , typename E >
protected_function_result	safe_script_file (const std::string &filename, const basic_environment< E > &env, Fx &&on_error, load_mode mode=load_mode::any)
template<typename E >
protected_function_result	safe_script_file (const std::string &filename, const basic_environment< E > &env, load_mode mode=load_mode::any)
protected_function_result	safe_script_file (const std::string &filename, load_mode mode=load_mode::any)
template<typename E >
unsafe_function_result	unsafe_script (const string_view &code, const basic_environment< E > &env, const std::string &chunkname=detail::default_chunk_name(), load_mode mode=load_mode::any)
unsafe_function_result	unsafe_script (const string_view &code, const std::string &chunkname=detail::default_chunk_name(), load_mode mode=load_mode::any)
template<typename E >
unsafe_function_result	unsafe_script_file (const std::string &filename, const basic_environment< E > &env, load_mode mode=load_mode::any)
unsafe_function_result	unsafe_script_file (const std::string &filename, load_mode mode=load_mode::any)
template<typename Fx , meta::disable_any< meta::is_string_constructible< meta::unqualified_t< Fx >>, meta::is_specialization_of< meta::unqualified_t< Fx >, basic_environment >> = meta::enabler>
protected_function_result	script (const string_view &code, Fx &&on_error, const std::string &chunkname=detail::default_chunk_name(), load_mode mode=load_mode::any)
template<typename Fx , meta::disable_any< meta::is_string_constructible< meta::unqualified_t< Fx >>, meta::is_specialization_of< meta::unqualified_t< Fx >, basic_environment >> = meta::enabler>
protected_function_result	script_file (const std::string &filename, Fx &&on_error, load_mode mode=load_mode::any)
template<typename Fx , typename E >
protected_function_result	script (const string_view &code, const basic_environment< E > &env, Fx &&on_error, const std::string &chunkname=detail::default_chunk_name(), load_mode mode=load_mode::any)
template<typename Fx , typename E >
protected_function_result	script_file (const std::string &filename, const basic_environment< E > &env, Fx &&on_error, load_mode mode=load_mode::any)
protected_function_result	script (const string_view &code, const environment &env, const std::string &chunkname=detail::default_chunk_name(), load_mode mode=load_mode::any)
protected_function_result	script_file (const std::string &filename, const environment &env, load_mode mode=load_mode::any)
unsafe_function_result	script (const string_view &code, const std::string &chunkname=detail::default_chunk_name(), load_mode mode=load_mode::any)
unsafe_function_result	script_file (const std::string &filename, load_mode mode=load_mode::any)
load_result	load (const string_view &code, const std::string &chunkname=detail::default_chunk_name(), load_mode mode=load_mode::any)
load_result	load_buffer (const char *buff, size_t size, const std::string &chunkname=detail::default_chunk_name(), load_mode mode=load_mode::any)
load_result	load_file (const std::string &filename, load_mode mode=load_mode::any)
load_result	load (lua_Reader reader, void *data, const std::string &chunkname=detail::default_chunk_name(), load_mode mode=load_mode::any)
iterator	begin () const
iterator	end () const
const_iterator	cbegin () const
const_iterator	cend () const
global_table	globals () const
table	registry () const
std::size_t	memory_used () const
int	stack_top () const
int	stack_clear ()
void	collect_garbage ()
	operator lua_State * () const
void	set_panic (lua_CFunction panic)
void	set_exception_handler (exception_handler_function handler)
template<typename... Args, 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... Args>
state_view &	set (Args &&... args)
template<typename T , typename... Keys>
decltype(auto)	traverse_get (Keys &&... keys) const
template<typename... Args>
state_view &	traverse_set (Args &&... args)
template<typename T >
state_view &	set_usertype (usertype< T > &user)
template<typename Key , typename T >
state_view &	set_usertype (Key &&key, usertype< T > &user)
template<typename Class , typename... Args>
state_view &	new_usertype (const std::string &name, Args &&... args)
template<typename Class , typename CTor0 , typename... CTor, typename... Args>
state_view &	new_usertype (const std::string &name, Args &&... args)
template<typename Class , typename... CArgs, typename... Args>
state_view &	new_usertype (const std::string &name, constructors< CArgs... > ctor, Args &&... args)
template<typename Class , typename... Args>
state_view &	new_simple_usertype (const std::string &name, Args &&... args)
template<typename Class , typename CTor0 , typename... CTor, typename... Args>
state_view &	new_simple_usertype (const std::string &name, Args &&... args)
template<typename Class , typename... CArgs, typename... Args>
state_view &	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>
state_view &	new_enum (const string_view &name, Args &&... args)
template<typename T , bool read_only = true>
state_view &	new_enum (const string_view &name, std::initializer_list< std::pair< string_view, T >> items)
template<typename Fx >
void	for_each (Fx &&fx)
template<typename T >
proxy< global_table &, T >	operator[] (T &&key)
template<typename T >
proxy< const global_table &, T >	operator[] (T &&key) const
template<typename Sig , typename... Args, typename Key >
state_view &	set_function (Key &&key, Args &&... args)
template<typename... Args, typename Key >
state_view &	set_function (Key &&key, Args &&... args)
template<typename Name >
table	create_table (Name &&name, int narr=0, int nrec=0)
template<typename Name , typename Key , typename Value , typename... Args>
table	create_table (Name &&name, int narr, int nrec, Key &&key, Value &&value, Args &&... args)
template<typename Name , typename... Args>
table	create_named_table (Name &&name, Args &&... args)
table	create_table (int narr=0, int nrec=0)
template<typename Key , typename Value , typename... Args>
table	create_table (int narr, int nrec, Key &&key, Value &&value, Args &&... args)
template<typename... Args>
table	create_table_with (Args &&... args)

Static Public Member Functions
static table	create_table (lua_State *L, int narr=0, int nrec=0)
template<typename Key , typename Value , typename... Args>
static table	create_table (lua_State *L, int narr, int nrec, Key &&key, Value &&value, Args &&... args)
template<typename... Args>
static table	create_table_with (lua_State *L, Args &&... args)

Private Member Functions
optional< object >	is_loaded_package (const std::string &key)
template<typename T >
void	ensure_package (const std::string &key, T &&sr)
template<typename Fx >
object	require_core (const std::string &key, Fx &&action, bool create_global=true)

Private Attributes
lua_State *	L
table	reg
global_table	global

Member Typedef Documentation

const_iterator

typedef global_table::const_iterator sol::state_view::const_iterator

iterator

typedef global_table::iterator sol::state_view::iterator

Constructor & Destructor Documentation

state_view() [1/2]

sol::state_view::state_view ( lua_State *  Ls )

inline

        : L(Ls), reg(Ls, LUA_REGISTRYINDEX), global(Ls, detail::global_) {
        }

state_view() [2/2]

sol::state_view::state_view ( this_state  Ls )

inline

        : state_view(Ls.L) {
        }

Member Function Documentation

begin()

iterator sol::state_view::begin ( ) const

inline

                               {
            return global.begin();
        }

cbegin()

const_iterator sol::state_view::cbegin ( ) const

inline

                                      {
            return global.cbegin();
        }

cend()

const_iterator sol::state_view::cend ( ) const

inline

                                    {
            return global.cend();
        }

collect_garbage()

void sol::state_view::collect_garbage ( )

inline

                               {
            lua_gc(lua_state(), LUA_GCCOLLECT, 0);
        }

create_named_table()

template<typename Name , typename... Args>

table sol::state_view::create_named_table ( Name &&  name, Args &&...  args  )

inline

                                                              {
            table x = global.create_with(std::forward<Args>(args)...);
            global.set(std::forward<Name>(name), x);
            return x;
        }

create_simple_usertype() [1/3]

template<typename Class , typename... Args>

simple_usertype<Class> sol::state_view::create_simple_usertype ( Args &&...  args )

inline

                                                                      {
            return global.create_simple_usertype<Class>(std::forward<Args>(args)...);
        }

create_simple_usertype() [2/3]

template<typename Class , typename CTor0 , typename... CTor, typename... Args>

simple_usertype<Class> sol::state_view::create_simple_usertype ( Args &&...  args )

inline

                                                                      {
            return global.create_simple_usertype<Class, CTor0, CTor...>(std::forward<Args>(args)...);
        }

create_simple_usertype() [3/3]

template<typename Class , typename... CArgs, typename... Args>

simple_usertype<Class> sol::state_view::create_simple_usertype ( constructors< CArgs... >  ctor, Args &&...  args  )

inline

                                                                                                   {
            return global.create_simple_usertype<Class>(ctor, std::forward<Args>(args)...);
        }

create_table() [1/6]

template<typename Name >

table sol::state_view::create_table ( Name &&  name, int  narr = 0, int  nrec = 0  )

inline

                                                                    {
            return global.create(std::forward<Name>(name), narr, nrec);
        }

create_table() [2/6]

template<typename Name , typename Key , typename Value , typename... Args>

table sol::state_view::create_table ( Name &&  name, int  narr, int  nrec, Key &&  key, Value &&  value, Args &&...  args  )

inline

                                                                                                      {
            return global.create(std::forward<Name>(name), narr, nrec, std::forward<Key>(key), std::forward<Value>(value), std::forward<Args>(args)...);
        }

create_table() [3/6]

table sol::state_view::create_table ( int  narr = 0, int  nrec = 0  )

inline

                                                       {
            return create_table(lua_state(), narr, nrec);
        }

create_table() [4/6]

template<typename Key , typename Value , typename... Args>

table sol::state_view::create_table ( int  narr, int  nrec, Key &&  key, Value &&  value, Args &&...  args  )

inline

                                                                                         {
            return create_table(lua_state(), narr, nrec, std::forward<Key>(key), std::forward<Value>(value), std::forward<Args>(args)...);
        }

create_table() [5/6]

static table sol::state_view::create_table ( lua_State *  L, int  narr = 0, int  nrec = 0  )

inlinestatic

                                                                                   {
            return global_table::create(L, narr, nrec);
        }

create_table() [6/6]

template<typename Key , typename Value , typename... Args>

static table sol::state_view::create_table ( lua_State *  L, int  narr, int  nrec, Key &&  key, Value &&  value, Args &&...  args  )

inlinestatic

                                                                                                                     {
            return global_table::create(L, narr, nrec, std::forward<Key>(key), std::forward<Value>(value), std::forward<Args>(args)...);
        }

create_table_with() [1/2]

template<typename... Args>

table sol::state_view::create_table_with ( Args &&...  args )

inline

                                                {
            return create_table_with(lua_state(), std::forward<Args>(args)...);
        }

create_table_with() [2/2]

template<typename... Args>

static table sol::state_view::create_table_with ( lua_State *  L, Args &&...  args  )

inlinestatic

                                                                            {
            return global_table::create_with(L, std::forward<Args>(args)...);
        }

do_file() [1/2]

template<typename E >

protected_function_result sol::state_view::do_file ( const std::string &  filename, const basic_environment< E > &  env, load_mode  mode = load_mode::any  )

inline

                                                                                                                                     {
            load_status x = static_cast<load_status>(luaL_loadfilex(L, filename.c_str(), to_string(mode).c_str()));
            if (x != load_status::ok) {
                return protected_function_result(L, absolute_index(L, -1), 0, 1, static_cast<call_status>(x));
            }
            stack_aligned_protected_function pf(L, -1);
            set_environment(env, pf);
            return pf();
        }

do_file() [2/2]

protected_function_result sol::state_view::do_file ( const std::string &  filename, load_mode  mode = load_mode::any  )

inline

                                                                                                    {
            load_status x = static_cast<load_status>(luaL_loadfilex(L, filename.c_str(), to_string(mode).c_str()));
            if (x != load_status::ok) {
                return protected_function_result(L, absolute_index(L, -1), 0, 1, static_cast<call_status>(x));
            }
            stack_aligned_protected_function pf(L, -1);
            return pf();
        }

do_string() [1/2]

template<typename E >

protected_function_result sol::state_view::do_string ( const string_view &  code, const basic_environment< E > &  env, const std::string &  chunkname = detail::default_chunk_name(), load_mode  mode = load_mode::any  )

inline

                                                                                                                                                                                              {
            detail::typical_chunk_name_t basechunkname = {};
            const char* chunknametarget = detail::make_chunk_name(code, chunkname, basechunkname);
            load_status x = static_cast<load_status>(luaL_loadbufferx(L, code.data(), code.size(), chunknametarget, to_string(mode).c_str()));
            if (x != load_status::ok) {
                return protected_function_result(L, absolute_index(L, -1), 0, 1, static_cast<call_status>(x));
            }
            stack_aligned_protected_function pf(L, -1);
            set_environment(env, pf);
            return pf();
        }

do_string() [2/2]

protected_function_result sol::state_view::do_string ( const string_view &  code, const std::string &  chunkname = detail::default_chunk_name(), load_mode  mode = load_mode::any  )

inline

                                                                                                                                                             {
            detail::typical_chunk_name_t basechunkname = {};
            const char* chunknametarget = detail::make_chunk_name(code, chunkname, basechunkname);
            load_status x = static_cast<load_status>(luaL_loadbufferx(L, code.data(), code.size(), chunknametarget, to_string(mode).c_str()));
            if (x != load_status::ok) {
                return protected_function_result(L, absolute_index(L, -1), 0, 1, static_cast<call_status>(x));
            }
            stack_aligned_protected_function pf(L, -1);
            return pf();
        }

end()

iterator sol::state_view::end ( ) const

inline

                             {
            return global.end();
        }

ensure_package()

template<typename T >

void sol::state_view::ensure_package ( const std::string &  key, T &&  sr  )

inlineprivate

                                                          {
#if SOL_LUA_VERSION <= 501
            auto pkg = global["package"];
            if (!pkg.valid()) {
                pkg = create_table_with("loaded", create_table_with(key, sr));
            }
            else {
                auto ld = pkg["loaded"];
                if (!ld.valid()) {
                    ld = create_table_with(key, sr);
                }
                else {
                    ld[key] = sr;
                }
            }
#endif
            auto loaded = reg["_LOADED"];
            if (!loaded.valid()) {
                loaded = create_table_with(key, sr);
            }
            else {
                loaded[key] = sr;
            }
        }

for_each()

template<typename Fx >

void sol::state_view::for_each ( Fx &&  fx )

inline

                               {
            global.for_each(std::forward<Fx>(fx));
        }

get()

template<typename... Args, typename... Keys>

decltype(auto) sol::state_view::get ( Keys &&...  keys ) const

inline

                                                 {
            return global.get<Args...>(std::forward<Keys>(keys)...);
        }

get_or() [1/2]

template<typename T , typename Key >

decltype(auto) sol::state_view::get_or ( Key &&  key, T &&  otherwise  ) const

inline

                                                              {
            return global.get_or(std::forward<Key>(key), std::forward<T>(otherwise));
        }

get_or() [2/2]

template<typename T , typename Key , typename D >

decltype(auto) sol::state_view::get_or ( Key &&  key, D &&  otherwise  ) const

inline

                                                              {
            return global.get_or<T>(std::forward<Key>(key), std::forward<D>(otherwise));
        }

globals()

global_table sol::state_view::globals ( ) const

inline

                                     {
            return global;
        }

is_loaded_package()

optional<object> sol::state_view::is_loaded_package ( const std::string &  key )

inlineprivate

                                                                 {
            auto loaded = reg.traverse_get<optional<object>>("_LOADED", key);
            bool is53mod = loaded && !(loaded->is<bool>() && !loaded->as<bool>());
            if (is53mod)
                return loaded;
#if SOL_LUA_VERSION <= 501
            auto loaded51 = global.traverse_get<optional<object>>("package", "loaded", key);
            bool is51mod = loaded51 && !(loaded51->is<bool>() && !loaded51->as<bool>());
            if (is51mod)
                return loaded51;
#endif
            return nullopt;
        }

load() [1/2]

load_result sol::state_view::load ( const string_view &  code, const std::string &  chunkname = detail::default_chunk_name(), load_mode  mode = load_mode::any  )

inline

                                                                                                                                          {
            detail::typical_chunk_name_t basechunkname = {};
            const char* chunknametarget = detail::make_chunk_name(code, chunkname, basechunkname);
            load_status x = static_cast<load_status>(luaL_loadbufferx(L, code.data(), code.size(), chunknametarget, to_string(mode).c_str()));
            return load_result(L, absolute_index(L, -1), 1, 1, x);
        }

load() [2/2]

load_result sol::state_view::load ( lua_Reader  reader, void *  data, const std::string &  chunkname = detail::default_chunk_name(), load_mode  mode = load_mode::any  )

inline

                                                                                                                                                {
            detail::typical_chunk_name_t basechunkname = {};
            const char* chunknametarget = detail::make_chunk_name("lua_Reader", chunkname, basechunkname);
            load_status x = static_cast<load_status>(lua_load(L, reader, data, chunknametarget, to_string(mode).c_str()));
            return load_result(L, absolute_index(L, -1), 1, 1, x);
        }

load_buffer()

load_result sol::state_view::load_buffer ( const char *  buff, size_t  size, const std::string &  chunkname = detail::default_chunk_name(), load_mode  mode = load_mode::any  )

inline

                                                                                                                                                       {
            return load(string_view(buff, size), chunkname, mode);
        }

load_file()

load_result sol::state_view::load_file ( const std::string &  filename, load_mode  mode = load_mode::any  )

inline

                                                                                        {
            load_status x = static_cast<load_status>(luaL_loadfilex(L, filename.c_str(), to_string(mode).c_str()));
            return load_result(L, absolute_index(L, -1), 1, 1, x);
        }

lua_state()

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

inline

                                     {
            return L;
        }

memory_used()

std::size_t sol::state_view::memory_used ( ) const

inline

                                      {
            return total_memory_used(lua_state());
        }

new_enum() [1/2]

template<bool read_only = true, typename... Args>

state_view& sol::state_view::new_enum ( const string_view &  name, Args &&...  args  )

inline

                                                                      {
            global.new_enum<read_only>(name, std::forward<Args>(args)...);
            return *this;
        }

new_enum() [2/2]

template<typename T , bool read_only = true>

state_view& sol::state_view::new_enum ( const string_view &  name, std::initializer_list< std::pair< string_view, T >>  items  )

inline

                                                                                                          {
            global.new_enum<T, read_only>(name, std::move(items));
            return *this;
        }

new_simple_usertype() [1/3]

template<typename Class , typename... Args>

state_view& sol::state_view::new_simple_usertype ( const std::string &  name, Args &&...  args  )

inline

                                                                               {
            global.new_simple_usertype<Class>(name, std::forward<Args>(args)...);
            return *this;
        }

new_simple_usertype() [2/3]

template<typename Class , typename CTor0 , typename... CTor, typename... Args>

state_view& sol::state_view::new_simple_usertype ( const std::string &  name, Args &&...  args  )

inline

                                                                               {
            global.new_simple_usertype<Class, CTor0, CTor...>(name, std::forward<Args>(args)...);
            return *this;
        }

new_simple_usertype() [3/3]

template<typename Class , typename... CArgs, typename... Args>

state_view& sol::state_view::new_simple_usertype ( const std::string &  name, constructors< CArgs... >  ctor, Args &&...  args  )

inline

                                                                                                            {
            global.new_simple_usertype<Class>(name, ctor, std::forward<Args>(args)...);
            return *this;
        }

new_usertype() [1/3]

template<typename Class , typename... Args>

state_view& sol::state_view::new_usertype ( const std::string &  name, Args &&...  args  )

inline

                                                                        {
            global.new_usertype<Class>(name, std::forward<Args>(args)...);
            return *this;
        }

new_usertype() [2/3]

template<typename Class , typename CTor0 , typename... CTor, typename... Args>

state_view& sol::state_view::new_usertype ( const std::string &  name, Args &&...  args  )

inline

                                                                        {
            global.new_usertype<Class, CTor0, CTor...>(name, std::forward<Args>(args)...);
            return *this;
        }

new_usertype() [3/3]

template<typename Class , typename... CArgs, typename... Args>

state_view& sol::state_view::new_usertype ( const std::string &  name, constructors< CArgs... >  ctor, Args &&...  args  )

inline

                                                                                                     {
            global.new_usertype<Class>(name, ctor, std::forward<Args>(args)...);
            return *this;
        }

open_libraries()

template<typename... Args>

void sol::state_view::open_libraries ( Args &&...  args )

inline

                                            {
            static_assert(meta::all_same<lib, Args...>::value, "all types must be libraries");
            if (sizeof...(args) == 0) {
                luaL_openlibs(L);
                return;
            }

            lib libraries[1 + sizeof...(args)] = {lib::count, std::forward<Args>(args)...};

            for (auto&& library : libraries) {
                switch (library) {
#if SOL_LUA_VERSION <= 501 && defined(SOL_LUAJIT)
                case lib::coroutine:
#endif // luajit opens coroutine base stuff
                case lib::base:
                    luaL_requiref(L, "base", luaopen_base, 1);
                    lua_pop(L, 1);
                    break;
                case lib::package:
                    luaL_requiref(L, "package", luaopen_package, 1);
                    lua_pop(L, 1);
                    break;
#if !defined(SOL_LUAJIT)
                case lib::coroutine:
#if SOL_LUA_VERSION > 501
                    luaL_requiref(L, "coroutine", luaopen_coroutine, 1);
                    lua_pop(L, 1);
#endif // Lua 5.2+ only
                    break;
#endif // Not LuaJIT - comes builtin
                case lib::string:
                    luaL_requiref(L, "string", luaopen_string, 1);
                    lua_pop(L, 1);
                    break;
                case lib::table:
                    luaL_requiref(L, "table", luaopen_table, 1);
                    lua_pop(L, 1);
                    break;
                case lib::math:
                    luaL_requiref(L, "math", luaopen_math, 1);
                    lua_pop(L, 1);
                    break;
                case lib::bit32:
#ifdef SOL_LUAJIT
                    luaL_requiref(L, "bit32", luaopen_bit, 1);
                    lua_pop(L, 1);
#elif (SOL_LUA_VERSION == 502) || defined(LUA_COMPAT_BITLIB) || defined(LUA_COMPAT_5_2)
                    luaL_requiref(L, "bit32", luaopen_bit32, 1);
                    lua_pop(L, 1);
#else
#endif // Lua 5.2 only (deprecated in 5.3 (503)) (Can be turned on with Compat flags)
                    break;
                case lib::io:
                    luaL_requiref(L, "io", luaopen_io, 1);
                    lua_pop(L, 1);
                    break;
                case lib::os:
                    luaL_requiref(L, "os", luaopen_os, 1);
                    lua_pop(L, 1);
                    break;
                case lib::debug:
                    luaL_requiref(L, "debug", luaopen_debug, 1);
                    lua_pop(L, 1);
                    break;
                case lib::utf8:
#if SOL_LUA_VERSION > 502 && !defined(SOL_LUAJIT)
                    luaL_requiref(L, "utf8", luaopen_utf8, 1);
                    lua_pop(L, 1);
#endif // Lua 5.3+ only
                    break;
                case lib::ffi:
#ifdef SOL_LUAJIT
                    luaL_requiref(L, "ffi", luaopen_ffi, 1);
                    lua_pop(L, 1);
#endif // LuaJIT only
                    break;
                case lib::jit:
#ifdef SOL_LUAJIT
                    luaL_requiref(L, "jit", luaopen_jit, 0);
                    lua_pop(L, 1);
#endif // LuaJIT Only
                    break;
                case lib::count:
                default:
                    break;
                }
            }
        }

operator lua_State *()

sol::state_view::operator lua_State * ( ) const

inline

                                    {
            return lua_state();
        }

operator[]() [1/2]

template<typename T >

proxy<global_table&, T> sol::state_view::operator[] ( T &&  key )

inline

                                                    {
            return global[std::forward<T>(key)];
        }

operator[]() [2/2]

template<typename T >

proxy<const global_table&, T> sol::state_view::operator[] ( T &&  key ) const

inline

                                                                {
            return global[std::forward<T>(key)];
        }

registry()

table sol::state_view::registry ( ) const

inline

                               {
            return reg;
        }

require()

object sol::state_view::require ( const std::string &  key, lua_CFunction  open_function, bool  create_global = true  )

inline

                                                                                                     {
            luaL_requiref(L, key.c_str(), open_function, create_global ? 1 : 0);
            return stack::pop<object>(L);
        }

require_core()

template<typename Fx >

object sol::state_view::require_core ( const std::string &  key, Fx &&  action, bool  create_global = true  )

inlineprivate

                                                                                          {
            optional<object> loaded = is_loaded_package(key);
            if (loaded && loaded->valid())
                return std::move(*loaded);
            action();
            stack_reference sr(L, -1);
            if (create_global)
                set(key, sr);
            ensure_package(key, sr);
            return stack::pop<object>(L);
        }

require_file()

object sol::state_view::require_file ( const std::string &  key, const std::string &  filename, bool  create_global = true, load_mode  mode = load_mode::any  )

inline

                                                                                                                                       {
            auto action = [this, &filename, &mode]() {
                stack::script_file(L, filename, mode);
            };
            return require_core(key, action, create_global);
        }

require_script()

object sol::state_view::require_script ( const std::string &  key, const string_view &  code, bool  create_global = true, const std::string &  chunkname = detail::default_chunk_name(), load_mode  mode = load_mode::any  )

inline

                                                                                                                                                                                                {
            auto action = [this, &code, &chunkname, &mode]() {
                stack::script(L, code, chunkname, mode);
            };
            return require_core(key, action, create_global);
        }

safe_script() [1/4]

template<typename Fx , meta::disable_any< meta::is_string_constructible< meta::unqualified_t< Fx >>, meta::is_specialization_of< meta::unqualified_t< Fx >, basic_environment >> = meta::enabler>

protected_function_result sol::state_view::safe_script ( const string_view &  code, Fx &&  on_error, const std::string &  chunkname = detail::default_chunk_name(), load_mode  mode = load_mode::any  )

inline

                                                                                                                                                                              {
            protected_function_result pfr = do_string(code, chunkname, mode);
            if (!pfr.valid()) {
                return on_error(L, std::move(pfr));
            }
            return pfr;
        }

safe_script() [2/4]

template<typename Fx , typename E >

protected_function_result sol::state_view::safe_script ( const string_view &  code, const basic_environment< E > &  env, Fx &&  on_error, const std::string &  chunkname = detail::default_chunk_name(), load_mode  mode = load_mode::any  )

inline

                                                                                                                                                                                                               {
            protected_function_result pfr = do_string(code, env, chunkname, mode);
            if (!pfr.valid()) {
                return on_error(L, std::move(pfr));
            }
            return pfr;
        }

safe_script() [3/4]

template<typename E >

protected_function_result sol::state_view::safe_script ( const string_view &  code, const basic_environment< E > &  env, const std::string &  chunkname = detail::default_chunk_name(), load_mode  mode = load_mode::any  )

inline

                                                                                                                                                                                                {
            return safe_script(code, env, script_default_on_error, chunkname, mode);
        }

safe_script() [4/4]

protected_function_result sol::state_view::safe_script ( const string_view &  code, const std::string &  chunkname = detail::default_chunk_name(), load_mode  mode = load_mode::any  )

inline

                                                                                                                                                               {
            return safe_script(code, script_default_on_error, chunkname, mode);
        }

safe_script_file() [1/4]

template<typename Fx , meta::disable_any< meta::is_string_constructible< meta::unqualified_t< Fx >>, meta::is_specialization_of< meta::unqualified_t< Fx >, basic_environment >> = meta::enabler>

protected_function_result sol::state_view::safe_script_file ( const std::string &  filename, Fx &&  on_error, load_mode  mode = load_mode::any  )

inline

                                                                                                                            {
            protected_function_result pfr = do_file(filename, mode);
            if (!pfr.valid()) {
                return on_error(L, std::move(pfr));
            }
            return pfr;
        }

safe_script_file() [2/4]

template<typename Fx , typename E >

protected_function_result sol::state_view::safe_script_file ( const std::string &  filename, const basic_environment< E > &  env, Fx &&  on_error, load_mode  mode = load_mode::any  )

inline

                                                                                                                                                             {
            protected_function_result pfr = do_file(filename, env, mode);
            if (!pfr.valid()) {
                return on_error(L, std::move(pfr));
            }
            return pfr;
        }

safe_script_file() [3/4]

template<typename E >

protected_function_result sol::state_view::safe_script_file ( const std::string &  filename, const basic_environment< E > &  env, load_mode  mode = load_mode::any  )

inline

                                                                                                                                              {
            return safe_script_file(filename, env, script_default_on_error, mode);
        }

safe_script_file() [4/4]

protected_function_result sol::state_view::safe_script_file ( const std::string &  filename, load_mode  mode = load_mode::any  )

inline

                                                                                                             {
            return safe_script_file(filename, script_default_on_error, mode);
        }

script() [1/4]

template<typename Fx , meta::disable_any< meta::is_string_constructible< meta::unqualified_t< Fx >>, meta::is_specialization_of< meta::unqualified_t< Fx >, basic_environment >> = meta::enabler>

protected_function_result sol::state_view::script ( const string_view &  code, Fx &&  on_error, const std::string &  chunkname = detail::default_chunk_name(), load_mode  mode = load_mode::any  )

inline

                                                                                                                                                                         {
            return safe_script(code, std::forward<Fx>(on_error), chunkname, mode);
        }

script() [2/4]

template<typename Fx , typename E >

protected_function_result sol::state_view::script ( const string_view &  code, const basic_environment< E > &  env, Fx &&  on_error, const std::string &  chunkname = detail::default_chunk_name(), load_mode  mode = load_mode::any  )

inline

                                                                                                                                                                                                          {
            return safe_script(code, env, std::forward<Fx>(on_error), chunkname, mode);
        }

script() [3/4]

protected_function_result sol::state_view::script ( const string_view &  code, const environment &  env, const std::string &  chunkname = detail::default_chunk_name(), load_mode  mode = load_mode::any  )

inline

                                                                                                                                                                                  {
            return safe_script(code, env, script_default_on_error, chunkname, mode);
        }

script() [4/4]

unsafe_function_result sol::state_view::script ( const string_view &  code, const std::string &  chunkname = detail::default_chunk_name(), load_mode  mode = load_mode::any  )

inline

                                                                                                                                                       {
            return unsafe_script(code, chunkname, mode);
        }

script_file() [1/4]

template<typename Fx , meta::disable_any< meta::is_string_constructible< meta::unqualified_t< Fx >>, meta::is_specialization_of< meta::unqualified_t< Fx >, basic_environment >> = meta::enabler>

protected_function_result sol::state_view::script_file ( const std::string &  filename, Fx &&  on_error, load_mode  mode = load_mode::any  )

inline

                                                                                                                       {
            return safe_script_file(filename, std::forward<Fx>(on_error), mode);
        }

script_file() [2/4]

template<typename Fx , typename E >

protected_function_result sol::state_view::script_file ( const std::string &  filename, const basic_environment< E > &  env, Fx &&  on_error, load_mode  mode = load_mode::any  )

inline

                                                                                                                                                        {
            return safe_script_file(filename, env, std::forward<Fx>(on_error), mode);
        }

script_file() [3/4]

protected_function_result sol::state_view::script_file ( const std::string &  filename, const environment &  env, load_mode  mode = load_mode::any  )

inline

                                                                                                                                {
            return safe_script_file(filename, env, script_default_on_error, mode);
        }

script_file() [4/4]

unsafe_function_result sol::state_view::script_file ( const std::string &  filename, load_mode  mode = load_mode::any  )

inline

                                                                                                     {
            return unsafe_script_file(filename, mode);
        }

set()

template<typename... Args>

state_view& sol::state_view::set ( Args &&...  args )

inline

                                        {
            global.set(std::forward<Args>(args)...);
            return *this;
        }

set_exception_handler()

void sol::state_view::set_exception_handler ( exception_handler_function  handler )

inline

                                                                       {
            set_default_exception_handler(lua_state(), handler);
        }

set_function() [1/2]

template<typename Sig , typename... Args, typename Key >

state_view& sol::state_view::set_function ( Key &&  key, Args &&...  args  )

inline

                                                            {
            global.set_function<Sig>(std::forward<Key>(key), std::forward<Args>(args)...);
            return *this;
        }

set_function() [2/2]

template<typename... Args, typename Key >

state_view& sol::state_view::set_function ( Key &&  key, Args &&...  args  )

inline

                                                            {
            global.set_function(std::forward<Key>(key), std::forward<Args>(args)...);
            return *this;
        }

set_panic()

void sol::state_view::set_panic ( lua_CFunction  panic )

inline

                                            {
            lua_atpanic(lua_state(), panic);
        }

set_usertype() [1/2]

template<typename T >

state_view& sol::state_view::set_usertype ( usertype< T > &  user )

inline

                                                    {
            return set_usertype(usertype_traits<T>::name(), user);
        }

set_usertype() [2/2]

template<typename Key , typename T >

state_view& sol::state_view::set_usertype ( Key &&  key, usertype< T > &  user  )

inline

                                                               {
            global.set_usertype(std::forward<Key>(key), user);
            return *this;
        }

stack_clear()

int sol::state_view::stack_clear ( )

inline

                          {
            int s = stack_top();
            lua_pop(L, s);
            return s;
        }

stack_top()

int sol::state_view::stack_top ( ) const

inline

                              {
            return stack::top(L);
        }

traverse_get()

template<typename T , typename... Keys>

decltype(auto) sol::state_view::traverse_get ( Keys &&...  keys ) const

inline

                                                          {
            return global.traverse_get<T>(std::forward<Keys>(keys)...);
        }

traverse_set()

template<typename... Args>

state_view& sol::state_view::traverse_set ( Args &&...  args )

inline

                                                 {
            global.traverse_set(std::forward<Args>(args)...);
            return *this;
        }

unsafe_script() [1/2]

template<typename E >

unsafe_function_result sol::state_view::unsafe_script ( const string_view &  code, const basic_environment< E > &  env, const std::string &  chunkname = detail::default_chunk_name(), load_mode  mode = load_mode::any  )

inline

                                                                                                                                                                                               {
            detail::typical_chunk_name_t basechunkname = {};
            const char* chunknametarget = detail::make_chunk_name(code, chunkname, basechunkname);
            int index = lua_gettop(L);
            if (luaL_loadbufferx(L, code.data(), code.size(), chunknametarget, to_string(mode).c_str())) {
                lua_error(L);
            }
            set_environment(env, stack_reference(L, raw_index(index + 1)));
            if (lua_pcall(L, 0, LUA_MULTRET, 0)) {
                lua_error(L);
            }
            int postindex = lua_gettop(L);
            int returns = postindex - index;
            return unsafe_function_result(L, (std::max)(postindex - (returns - 1), 1), returns);
        }

unsafe_script() [2/2]

unsafe_function_result sol::state_view::unsafe_script ( const string_view &  code, const std::string &  chunkname = detail::default_chunk_name(), load_mode  mode = load_mode::any  )

inline

                                                                                                                                                              {
            int index = lua_gettop(L);
            stack::script(L, code, chunkname, mode);
            int postindex = lua_gettop(L);
            int returns = postindex - index;
            return unsafe_function_result(L, (std::max)(postindex - (returns - 1), 1), returns);
        }

unsafe_script_file() [1/2]

template<typename E >

unsafe_function_result sol::state_view::unsafe_script_file ( const std::string &  filename, const basic_environment< E > &  env, load_mode  mode = load_mode::any  )

inline

                                                                                                                                             {
            int index = lua_gettop(L);
            if (luaL_loadfilex(L, filename.c_str(), to_string(mode).c_str())) {
                lua_error(L);
            }
            set_environment(env, stack_reference(L, raw_index(index + 1)));
            if (lua_pcall(L, 0, LUA_MULTRET, 0)) {
                lua_error(L);
            }
            int postindex = lua_gettop(L);
            int returns = postindex - index;
            return unsafe_function_result(L, (std::max)(postindex - (returns - 1), 1), returns);
        }

unsafe_script_file() [2/2]

unsafe_function_result sol::state_view::unsafe_script_file ( const std::string &  filename, load_mode  mode = load_mode::any  )

inline

                                                                                                            {
            int index = lua_gettop(L);
            stack::script_file(L, filename, mode);
            int postindex = lua_gettop(L);
            int returns = postindex - index;
            return unsafe_function_result(L, (std::max)(postindex - (returns - 1), 1), returns);
        }

Member Data Documentation

global

global_table sol::state_view::global

private

L

lua_State* sol::state_view::L

private

reg

table sol::state_view::reg

private

---

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

• external/sol.hpp