sol::basic_table_core< top_level, base_type > Class Template Reference

#include <sol.hpp>

Inheritance diagram for sol::basic_table_core< top_level, base_type >:

Public Types
typedef basic_table_iterator< base_type >	iterator
typedef iterator	const_iterator

Public Member Functions
	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

Static Public Member Functions
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
	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

Private Types
typedef basic_object_base< base_type >	base_t
template<typename... Args>
using	is_global = meta::all< meta::boolean< top_level >, meta::is_c_str< Args >... >

Private Member Functions
template<typename Fx >
void	for_each (std::true_type, Fx &&fx) const
template<typename Fx >
void	for_each (std::false_type, Fx &&fx) const
template<bool raw, typename Ret0 , typename Ret1 , typename... Ret, std::size_t... I, typename Keys >
auto	tuple_get (types< Ret0, Ret1, Ret... >, std::index_sequence< 0, 1, I... >, Keys &&keys) const -> decltype(stack::pop< std::tuple< Ret0, Ret1, Ret... >>(nullptr))
template<bool raw, typename Ret , std::size_t I, typename Keys >
decltype(auto)	tuple_get (types< Ret >, std::index_sequence< I >, Keys &&keys) const
template<bool raw, typename Pairs , std::size_t... I>
void	tuple_set (std::index_sequence< I... >, Pairs &&pairs)
template<bool global, bool raw, typename T , typename Key >
decltype(auto)	traverse_get_deep (Key &&key) const
template<bool global, bool raw, typename T , typename Key , typename... Keys>
decltype(auto)	traverse_get_deep (Key &&key, Keys &&... keys) const
template<bool global, bool raw, typename T , std::size_t I, typename Key >
decltype(auto)	traverse_get_deep_optional (int &popcount, Key &&key) const
template<bool global, bool raw, typename T , std::size_t I, typename Key , typename... Keys>
decltype(auto)	traverse_get_deep_optional (int &popcount, Key &&key, Keys &&... keys) const
template<bool global, bool raw, typename T , typename... Keys>
decltype(auto)	traverse_get_optional (std::false_type, Keys &&... keys) const
template<bool global, bool raw, typename T , typename... Keys>
decltype(auto)	traverse_get_optional (std::true_type, Keys &&... keys) const
template<bool global, bool raw, typename Key , typename Value >
void	traverse_set_deep (Key &&key, Value &&value) const
template<bool global, bool raw, typename Key , typename... Keys>
void	traverse_set_deep (Key &&key, Keys &&... keys) const
	basic_table_core (lua_State *L, detail::global_tag t) noexcept
template<typename R , typename... Args, typename Fx , typename Key , typename = std::result_of_t<Fx(Args...)>>
void	set_fx (types< R(Args...)>, Key &&key, Fx &&fx)
template<typename Fx , typename Key , meta::enable< meta::is_specialization_of< meta::unqualified_t< Fx >, overload_set >> = meta::enabler>
void	set_fx (types<>, Key &&key, Fx &&fx)
template<typename Fx , typename Key , typename... Args, meta::disable< meta::is_specialization_of< meta::unqualified_t< Fx >, overload_set >> = meta::enabler>
void	set_fx (types<>, Key &&key, Fx &&fx, Args &&... args)
template<typename... Sig, typename... Args, typename Key >
void	set_resolved_function (Key &&key, Args &&... args)

Friends
class	state
class	state_view

Member Typedef Documentation

base_t

template<bool top_level, typename base_type>

typedef basic_object_base<base_type> sol::basic_table_core< top_level, base_type >::base_t

private

const_iterator

template<bool top_level, typename base_type>

typedef iterator sol::basic_table_core< top_level, base_type >::const_iterator

is_global

template<bool top_level, typename base_type>

template<typename... Args>

using sol::basic_table_core< top_level, base_type >::is_global = meta::all<meta::boolean<top_level>, meta::is_c_str<Args>...>

private

iterator

template<bool top_level, typename base_type>

typedef basic_table_iterator<base_type> sol::basic_table_core< top_level, base_type >::iterator

Constructor & Destructor Documentation

basic_table_core() [1/17]

template<bool top_level, typename base_type>

sol::basic_table_core< top_level, base_type >::basic_table_core ( lua_State *  L, detail::global_tag  t  )

inlineprivatenoexcept

        : base_t(L, t) {
        }

basic_table_core() [2/17]

template<bool top_level, typename base_type>

sol::basic_table_core< top_level, base_type >::basic_table_core ( detail::no_safety_tag  , lua_nil_t  n  )

inlineprotected

        : base_t(n) {
        }

basic_table_core() [3/17]

template<bool top_level, typename base_type>

sol::basic_table_core< top_level, base_type >::basic_table_core ( detail::no_safety_tag  , lua_State *  L, int  index  )

inlineprotected

        : base_t(L, index) {
        }

basic_table_core() [4/17]

template<bool top_level, typename base_type>

sol::basic_table_core< top_level, base_type >::basic_table_core ( detail::no_safety_tag  , lua_State *  L, ref_index  index  )

inlineprotected

        : base_t(L, index) {
        }

basic_table_core() [5/17]

template<bool top_level, typename base_type>

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>

sol::basic_table_core< top_level, base_type >::basic_table_core ( detail::no_safety_tag  , T &&  r  )

inlineprotectednoexcept

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

basic_table_core() [6/17]

template<bool top_level, typename base_type>

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

sol::basic_table_core< top_level, base_type >::basic_table_core ( detail::no_safety_tag  , lua_State *  L, T &&  r  )

inlineprotectednoexcept

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

basic_table_core() [7/17]

template<bool top_level, typename base_type>

sol::basic_table_core< top_level, base_type >::basic_table_core ( )

defaultnoexcept

basic_table_core() [8/17]

template<bool top_level, typename base_type>

sol::basic_table_core< top_level, base_type >::basic_table_core ( const basic_table_core< top_level, base_type > &  )

default

basic_table_core() [9/17]

template<bool top_level, typename base_type>

sol::basic_table_core< top_level, base_type >::basic_table_core ( basic_table_core< top_level, base_type > &&  )

default

basic_table_core() [10/17]

template<bool top_level, typename base_type>

sol::basic_table_core< top_level, base_type >::basic_table_core ( const stack_reference &  r )

inline

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

basic_table_core() [11/17]

template<bool top_level, typename base_type>

sol::basic_table_core< top_level, base_type >::basic_table_core ( stack_reference &&  r )

inline

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

basic_table_core() [12/17]

template<bool top_level, typename base_type>

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

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

inline

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

basic_table_core() [13/17]

template<bool top_level, typename base_type>

sol::basic_table_core< top_level, base_type >::basic_table_core ( lua_State *  L, const new_table &  nt  )

inline

        : base_t(L, -stack::push(L, nt)) {
            if (!is_stack_based<meta::unqualified_t<base_type>>::value) {
                lua_pop(L, 1);
            }
        }

basic_table_core() [14/17]

template<bool top_level, typename base_type>

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

inline

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

basic_table_core() [15/17]

template<bool top_level, typename base_type>

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

inline

        : basic_table_core(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_table_core>(lua_state(), -1, handler);
#endif // Safety
        }

basic_table_core() [16/17]

template<bool top_level, typename base_type>

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>

sol::basic_table_core< top_level, base_type >::basic_table_core ( T &&  r )

inlinenoexcept

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

basic_table_core() [17/17]

template<bool top_level, typename base_type>

sol::basic_table_core< top_level, base_type >::basic_table_core ( lua_nil_t  r )

inlinenoexcept

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

Member Function Documentation

add()

template<bool top_level, typename base_type>

template<typename... Args>

basic_table_core& sol::basic_table_core< top_level, base_type >::add ( Args &&...  args )

inline

                                              {
            auto pp = stack::push_pop(*this);
            (void)detail::swallow{ 0,
                (stack::set_ref(base_t::lua_state(), std::forward<Args>(args)), 0)... };
            return *this;
        }

begin()

template<bool top_level, typename base_type>

iterator sol::basic_table_core< top_level, base_type >::begin ( ) const

inline

                               {
            return iterator(*this);
        }

cbegin()

template<bool top_level, typename base_type>

const_iterator sol::basic_table_core< top_level, base_type >::cbegin ( ) const

inline

                                      {
            return begin();
        }

cend()

template<bool top_level, typename base_type>

const_iterator sol::basic_table_core< top_level, base_type >::cend ( ) const

inline

                                    {
            return end();
        }

create() [1/6]

template<bool top_level, typename base_type>

static table sol::basic_table_core< top_level, base_type >::create ( lua_State *  L, int  narr = 0, int  nrec = 0  )

inlinestatic

                                                                             {
            lua_createtable(L, narr, nrec);
            table result(L);
            lua_pop(L, 1);
            return result;
        }

create() [2/6]

template<bool top_level, typename base_type>

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

static table sol::basic_table_core< top_level, base_type >::create ( lua_State *  L, int  narr, int  nrec, Key &&  key, Value &&  value, Args &&...  args  )

inlinestatic

                                                                                                               {
            lua_createtable(L, narr, nrec);
            table result(L);
            result.set(std::forward<Key>(key), std::forward<Value>(value), std::forward<Args>(args)...);
            lua_pop(L, 1);
            return result;
        }

create() [3/6]

template<bool top_level, typename base_type>

table sol::basic_table_core< top_level, base_type >::create ( int  narr = 0, int  nrec = 0  )

inline

                                                 {
            return create(base_t::lua_state(), narr, nrec);
        }

create() [4/6]

template<bool top_level, typename base_type>

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

table sol::basic_table_core< top_level, base_type >::create ( int  narr, int  nrec, Key &&  key, Value &&  value, Args &&...  args  )

inline

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

create() [5/6]

template<bool top_level, typename base_type>

template<typename Name >

table sol::basic_table_core< top_level, base_type >::create ( Name &&  name, int  narr = 0, int  nrec = 0  )

inline

                                                              {
            table x = create(base_t::lua_state(), narr, nrec);
            this->set(std::forward<Name>(name), x);
            return x;
        }

create() [6/6]

template<bool top_level, typename base_type>

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

table sol::basic_table_core< top_level, base_type >::create ( Name &&  name, int  narr, int  nrec, Key &&  key, Value &&  value, Args &&...  args  )

inline

                                                                                                {
            table x = create(base_t::lua_state(), narr, nrec, std::forward<Key>(key), std::forward<Value>(value), std::forward<Args>(args)...);
            this->set(std::forward<Name>(name), x);
            return x;
        }

create_named()

template<bool top_level, typename base_type>

template<typename Name , typename... Args>

table sol::basic_table_core< top_level, base_type >::create_named ( Name &&  name, Args &&...  args  )

inline

                                                        {
            static const int narr = static_cast<int>(meta::count_2_for_pack<std::is_integral, Args...>::value);
            return create(std::forward<Name>(name), narr, (sizeof...(Args) / 2) - narr, std::forward<Args>(args)...);
        }

create_simple_usertype() [1/3]

template<bool top_level, typename base_type>

template<typename Class , typename... Args>

simple_usertype<Class> sol::basic_table_core< top_level, base_type >::create_simple_usertype ( Args &&...  args )

inline

                                                                      {
            simple_usertype<Class> utype(base_t::lua_state(), std::forward<Args>(args)...);
            return utype;
        }

create_simple_usertype() [2/3]

template<bool top_level, typename base_type>

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

simple_usertype<Class> sol::basic_table_core< top_level, base_type >::create_simple_usertype ( Args &&...  args )

inline

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

create_simple_usertype() [3/3]

template<bool top_level, typename base_type>

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

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

inline

                                                                                                   {
            simple_usertype<Class> utype(base_t::lua_state(), ctor, std::forward<Args>(args)...);
            return utype;
        }

create_with() [1/2]

template<bool top_level, typename base_type>

template<typename... Args>

static table sol::basic_table_core< top_level, base_type >::create_with ( lua_State *  L, Args &&...  args  )

inlinestatic

                                                                      {
            static_assert(sizeof...(Args) % 2 == 0, "You must have an even number of arguments for a key, value ... list.");
            static const int narr = static_cast<int>(meta::count_2_for_pack<std::is_integral, Args...>::value);
            return create(L, narr, static_cast<int>((sizeof...(Args) / 2) - narr), std::forward<Args>(args)...);
        }

create_with() [2/2]

template<bool top_level, typename base_type>

template<typename... Args>

table sol::basic_table_core< top_level, base_type >::create_with ( Args &&...  args )

inline

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

empty()

template<bool top_level, typename base_type>

bool sol::basic_table_core< top_level, base_type >::empty ( ) const

inline

                           {
            return cbegin() == cend();
        }

end()

template<bool top_level, typename base_type>

iterator sol::basic_table_core< top_level, base_type >::end ( ) const

inline

                             {
            return iterator();
        }

for_each() [1/3]

template<bool top_level, typename base_type>

template<typename Fx >

void sol::basic_table_core< top_level, base_type >::for_each ( std::true_type  , Fx &&  fx  ) const

inlineprivate

                                                   {
            auto pp = stack::push_pop(*this);
            stack::push(base_t::lua_state(), lua_nil);
            while (lua_next(base_t::lua_state(), -2)) {
                object key(base_t::lua_state(), -2);
                object value(base_t::lua_state(), -1);
                std::pair<object&, object&> keyvalue(key, value);
                auto pn = stack::pop_n(base_t::lua_state(), 1);
                fx(keyvalue);
            }
        }

for_each() [2/3]

template<bool top_level, typename base_type>

template<typename Fx >

void sol::basic_table_core< top_level, base_type >::for_each ( std::false_type  , Fx &&  fx  ) const

inlineprivate

                                                    {
            auto pp = stack::push_pop(*this);
            stack::push(base_t::lua_state(), lua_nil);
            while (lua_next(base_t::lua_state(), -2)) {
                object key(base_t::lua_state(), -2);
                object value(base_t::lua_state(), -1);
                auto pn = stack::pop_n(base_t::lua_state(), 1);
                fx(key, value);
            }
        }

for_each() [3/3]

template<bool top_level, typename base_type>

template<typename Fx >

void sol::basic_table_core< top_level, base_type >::for_each ( Fx &&  fx ) const

inline

                                     {
            typedef meta::is_invokable<Fx(std::pair<object, object>)> is_paired;
            for_each(is_paired(), std::forward<Fx>(fx));
        }

get()

template<bool top_level, typename base_type>

template<typename... Ret, typename... Keys>

decltype(auto) sol::basic_table_core< top_level, base_type >::get ( Keys &&...  keys ) const

inline

                                                 {
            static_assert(sizeof...(Keys) == sizeof...(Ret), "number of keys and number of return types do not match");
            auto pp = stack::push_pop<is_global<Keys...>::value>(*this);
            return tuple_get<false>(types<Ret...>(), std::make_index_sequence<sizeof...(Ret)>(), std::forward_as_tuple(std::forward<Keys>(keys)...));
        }

get_or() [1/2]

template<bool top_level, typename base_type>

template<typename T , typename Key >

decltype(auto) sol::basic_table_core< top_level, base_type >::get_or ( Key &&  key, T &&  otherwise  ) const

inline

                                                              {
            typedef decltype(get<T>("")) U;
            optional<U> option = get<optional<U>>(std::forward<Key>(key));
            if (option) {
                return static_cast<U>(option.value());
            }
            return static_cast<U>(std::forward<T>(otherwise));
        }

get_or() [2/2]

template<bool top_level, typename base_type>

template<typename T , typename Key , typename D >

decltype(auto) sol::basic_table_core< top_level, base_type >::get_or ( Key &&  key, D &&  otherwise  ) const

inline

                                                              {
            optional<T> option = get<optional<T>>(std::forward<Key>(key));
            if (option) {
                return static_cast<T>(option.value());
            }
            return static_cast<T>(std::forward<D>(otherwise));
        }

new_enum() [1/2]

template<bool top_level, typename base_type>

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

table sol::basic_table_core< top_level, base_type >::new_enum ( const string_view &  name, Args &&...  args  )

inline

                                                                {
            table target = create_with(std::forward<Args>(args)...);
            if (read_only) {
                table x = create_with(
                    meta_function::new_index, detail::fail_on_newindex,
                    meta_function::index, target);
                table shim = create_named(name, metatable_key, x);
                return shim;
            }
            else {
                set(name, target);
                return target;
            }
        }

new_enum() [2/2]

template<bool top_level, typename base_type>

template<typename T , bool read_only = true>

table sol::basic_table_core< top_level, base_type >::new_enum ( const string_view &  name, std::initializer_list< std::pair< string_view, T >>  items  )

inline

                                                                                                    {
            table target = create(static_cast<int>(items.size()), static_cast<int>(0));
            for (const auto& kvp : items) {
                target.set(kvp.first, kvp.second);
            }
            if (read_only) {
                table x = create_with(
                    meta_function::new_index, detail::fail_on_newindex,
                    meta_function::index, target);
                table shim = create_named(name, metatable_key, x);
                return shim;
            }
            else {
                set(name, target);
                return target;
            }
        }

new_simple_usertype() [1/3]

template<bool top_level, typename base_type>

template<typename Class , typename... Args>

basic_table_core& sol::basic_table_core< top_level, base_type >::new_simple_usertype ( const std::string &  name, Args &&...  args  )

inline

                                                                                     {
            simple_usertype<Class> utype(base_t::lua_state(), std::forward<Args>(args)...);
            set_usertype(name, utype);
            return *this;
        }

new_simple_usertype() [2/3]

template<bool top_level, typename base_type>

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

basic_table_core& sol::basic_table_core< top_level, base_type >::new_simple_usertype ( const std::string &  name, Args &&...  args  )

inline

                                                                                     {
            constructors<types<CTor0, CTor...>> ctor{};
            return new_simple_usertype<Class>(name, ctor, std::forward<Args>(args)...);
        }

new_simple_usertype() [3/3]

template<bool top_level, typename base_type>

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

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

inline

                                                                                                                  {
            simple_usertype<Class> utype(base_t::lua_state(), ctor, std::forward<Args>(args)...);
            set_usertype(name, utype);
            return *this;
        }

new_usertype() [1/3]

template<bool top_level, typename base_type>

template<typename Class , typename... Args>

basic_table_core& sol::basic_table_core< top_level, base_type >::new_usertype ( const std::string &  name, Args &&...  args  )

inline

                                                                              {
            usertype<Class> utype(std::forward<Args>(args)...);
            set_usertype(name, utype);
            return *this;
        }

new_usertype() [2/3]

template<bool top_level, typename base_type>

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

basic_table_core& sol::basic_table_core< top_level, base_type >::new_usertype ( const std::string &  name, Args &&...  args  )

inline

                                                                              {
            constructors<types<CTor0, CTor...>> ctor{};
            return new_usertype<Class>(name, ctor, std::forward<Args>(args)...);
        }

new_usertype() [3/3]

template<bool top_level, typename base_type>

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

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

inline

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

operator=() [1/2]

template<bool top_level, typename base_type>

basic_table_core& sol::basic_table_core< top_level, base_type >::operator= ( const basic_table_core< top_level, base_type > &  )

default

operator=() [2/2]

template<bool top_level, typename base_type>

basic_table_core& sol::basic_table_core< top_level, base_type >::operator= ( basic_table_core< top_level, base_type > &&  )

default

operator[]() [1/3]

template<bool top_level, typename base_type>

template<typename T >

proxy<basic_table_core&, T> sol::basic_table_core< top_level, base_type >::operator[] ( T &&  key )

inline

                                                          {
            return proxy<basic_table_core&, T>(*this, std::forward<T>(key));
        }

operator[]() [2/3]

template<bool top_level, typename base_type>

template<typename T >

proxy<const basic_table_core&, T> sol::basic_table_core< top_level, base_type >::operator[] ( T &&  key ) const

inline

                                                                     {
            return proxy<const basic_table_core&, T>(*this, std::forward<T>(key));
        }

operator[]() [3/3]

template<bool top_level, typename base_type>

template<typename T >

proxy<basic_table_core, T> sol::basic_table_core< top_level, base_type >::operator[] ( T &&  key )

inline

                                                          {
            return proxy<basic_table_core, T>(*this, std::forward<T>(key));
        }

raw_get()

template<bool top_level, typename base_type>

template<typename... Ret, typename... Keys>

decltype(auto) sol::basic_table_core< top_level, base_type >::raw_get ( Keys &&...  keys ) const

inline

                                                     {
            static_assert(sizeof...(Keys) == sizeof...(Ret), "number of keys and number of return types do not match");
            auto pp = stack::push_pop<is_global<Keys...>::value>(*this);
            return tuple_get<true>(types<Ret...>(), std::make_index_sequence<sizeof...(Ret)>(), std::forward_as_tuple(std::forward<Keys>(keys)...));
        }

raw_get_or() [1/2]

template<bool top_level, typename base_type>

template<typename T , typename Key >

decltype(auto) sol::basic_table_core< top_level, base_type >::raw_get_or ( Key &&  key, T &&  otherwise  ) const

inline

                                                                  {
            typedef decltype(raw_get<T>("")) U;
            optional<U> option = raw_get<optional<U>>(std::forward<Key>(key));
            if (option) {
                return static_cast<U>(option.value());
            }
            return static_cast<U>(std::forward<T>(otherwise));
        }

raw_get_or() [2/2]

template<bool top_level, typename base_type>

template<typename T , typename Key , typename D >

decltype(auto) sol::basic_table_core< top_level, base_type >::raw_get_or ( Key &&  key, D &&  otherwise  ) const

inline

                                                                  {
            optional<T> option = raw_get<optional<T>>(std::forward<Key>(key));
            if (option) {
                return static_cast<T>(option.value());
            }
            return static_cast<T>(std::forward<D>(otherwise));
        }

raw_set()

template<bool top_level, typename base_type>

template<typename... Args>

basic_table_core& sol::basic_table_core< top_level, base_type >::raw_set ( Args &&...  args )

inline

                                                  {
            tuple_set<true>(std::make_index_sequence<sizeof...(Args) / 2>(), std::forward_as_tuple(std::forward<Args>(args)...));
            return *this;
        }

set()

template<bool top_level, typename base_type>

template<typename... Args>

basic_table_core& sol::basic_table_core< top_level, base_type >::set ( Args &&...  args )

inline

                                              {
            tuple_set<false>(std::make_index_sequence<sizeof...(Args) / 2>(), std::forward_as_tuple(std::forward<Args>(args)...));
            return *this;
        }

set_function() [1/2]

template<bool top_level, typename base_type>

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

basic_table_core& sol::basic_table_core< top_level, base_type >::set_function ( Key &&  key, Args &&...  args  )

inline

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

set_function() [2/2]

template<bool top_level, typename base_type>

template<typename Key , typename... Args>

basic_table_core& sol::basic_table_core< top_level, base_type >::set_function ( Key &&  key, Args &&...  args  )

inline

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

set_fx() [1/3]

template<bool top_level, typename base_type>

template<typename R , typename... Args, typename Fx , typename Key , typename = std::result_of_t<Fx(Args...)>>

void sol::basic_table_core< top_level, base_type >::set_fx ( types< R(Args...)>  , Key &&  key, Fx &&  fx  )

inlineprivate

                                                           {
            set_resolved_function<R(Args...)>(std::forward<Key>(key), std::forward<Fx>(fx));
        }

set_fx() [2/3]

template<bool top_level, typename base_type>

template<typename Fx , typename Key , meta::enable< meta::is_specialization_of< meta::unqualified_t< Fx >, overload_set >> = meta::enabler>

void sol::basic_table_core< top_level, base_type >::set_fx ( types<>  , Key &&  key, Fx &&  fx  )

inlineprivate

                                                 {
            set(std::forward<Key>(key), std::forward<Fx>(fx));
        }

set_fx() [3/3]

template<bool top_level, typename base_type>

template<typename Fx , typename Key , typename... Args, meta::disable< meta::is_specialization_of< meta::unqualified_t< Fx >, overload_set >> = meta::enabler>

void sol::basic_table_core< top_level, base_type >::set_fx ( types<>  , Key &&  key, Fx &&  fx, Args &&...  args  )

inlineprivate

                                                                 {
            set(std::forward<Key>(key), as_function_reference(std::forward<Fx>(fx), std::forward<Args>(args)...));
        }

set_resolved_function()

template<bool top_level, typename base_type>

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

void sol::basic_table_core< top_level, base_type >::set_resolved_function ( Key &&  key, Args &&...  args  )

inlineprivate

                                                              {
            set(std::forward<Key>(key), as_function_reference<function_sig<Sig...>>(std::forward<Args>(args)...));
        }

set_usertype() [1/2]

template<bool top_level, typename base_type>

template<typename T >

basic_table_core& sol::basic_table_core< top_level, base_type >::set_usertype ( usertype< T > &  user )

inline

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

set_usertype() [2/2]

template<bool top_level, typename base_type>

template<typename Key , typename T >

basic_table_core& sol::basic_table_core< top_level, base_type >::set_usertype ( Key &&  key, usertype< T > &  user  )

inline

                                                                     {
            return set(std::forward<Key>(key), user);
        }

size()

template<bool top_level, typename base_type>

size_t sol::basic_table_core< top_level, base_type >::size ( ) const

inline

                            {
            auto pp = stack::push_pop(*this);
            lua_len(base_t::lua_state(), -1);
            return stack::pop<size_t>(base_t::lua_state());
        }

traverse_get()

template<bool top_level, typename base_type>

template<typename T , typename... Keys>

decltype(auto) sol::basic_table_core< top_level, base_type >::traverse_get ( Keys &&...  keys ) const

inline

                                                          {
            auto pp = stack::push_pop<is_global<Keys...>::value>(*this);
            return traverse_get_optional<top_level, false, T>(meta::is_optional<meta::unqualified_t<T>>(), std::forward<Keys>(keys)...);
        }

traverse_get_deep() [1/2]

template<bool top_level, typename base_type>

template<bool global, bool raw, typename T , typename Key >

decltype(auto) sol::basic_table_core< top_level, base_type >::traverse_get_deep ( Key &&  key ) const

inlineprivate

                                                          {
            stack::get_field<global, raw>(base_t::lua_state(), std::forward<Key>(key));
            return stack::get<T>(base_t::lua_state());
        }

traverse_get_deep() [2/2]

template<bool top_level, typename base_type>

template<bool global, bool raw, typename T , typename Key , typename... Keys>

decltype(auto) sol::basic_table_core< top_level, base_type >::traverse_get_deep ( Key &&  key, Keys &&...  keys  ) const

inlineprivate

                                                                          {
            stack::get_field<global, raw>(base_t::lua_state(), std::forward<Key>(key));
            return traverse_get_deep<false, raw, T>(std::forward<Keys>(keys)...);
        }

traverse_get_deep_optional() [1/2]

template<bool top_level, typename base_type>

template<bool global, bool raw, typename T , std::size_t I, typename Key >

decltype(auto) sol::basic_table_core< top_level, base_type >::traverse_get_deep_optional ( int &  popcount, Key &&  key  ) const

inlineprivate

                                                                                  {
            typedef decltype(stack::get<T>(base_t::lua_state())) R;
            auto p = stack::probe_get_field<global, raw, T>(base_t::lua_state(), std::forward<Key>(key), lua_gettop(base_t::lua_state()));
            popcount += p.levels;
            if (!p.success)
                return R(nullopt);
            return stack::get<T>(base_t::lua_state());
        }

traverse_get_deep_optional() [2/2]

template<bool top_level, typename base_type>

template<bool global, bool raw, typename T , std::size_t I, typename Key , typename... Keys>

decltype(auto) sol::basic_table_core< top_level, base_type >::traverse_get_deep_optional ( int &  popcount, Key &&  key, Keys &&...  keys  ) const

inlineprivate

                                                                                                  {
            auto p = I > 0 ? stack::probe_get_field<global>(base_t::lua_state(), std::forward<Key>(key), -1) : stack::probe_get_field<global>(base_t::lua_state(), std::forward<Key>(key), lua_gettop(base_t::lua_state()));
            popcount += p.levels;
            if (!p.success)
                return T(nullopt);
            return traverse_get_deep_optional<false, raw, T, I + 1>(popcount, std::forward<Keys>(keys)...);
        }

traverse_get_optional() [1/2]

template<bool top_level, typename base_type>

template<bool global, bool raw, typename T , typename... Keys>

decltype(auto) sol::basic_table_core< top_level, base_type >::traverse_get_optional ( std::false_type  , Keys &&...  keys  ) const

inlineprivate

                                                                                  {
            detail::clean<sizeof...(Keys)> c(base_t::lua_state());
            return traverse_get_deep<global, raw, T>(std::forward<Keys>(keys)...);
        }

traverse_get_optional() [2/2]

template<bool top_level, typename base_type>

template<bool global, bool raw, typename T , typename... Keys>

decltype(auto) sol::basic_table_core< top_level, base_type >::traverse_get_optional ( std::true_type  , Keys &&...  keys  ) const

inlineprivate

                                                                                 {
            int popcount = 0;
            detail::ref_clean c(base_t::lua_state(), popcount);
            return traverse_get_deep_optional<global, raw, T, 0>(popcount, std::forward<Keys>(keys)...);
        }

traverse_raw_get()

template<bool top_level, typename base_type>

template<typename T , typename... Keys>

decltype(auto) sol::basic_table_core< top_level, base_type >::traverse_raw_get ( Keys &&...  keys ) const

inline

                                                              {
            auto pp = stack::push_pop<is_global<Keys...>::value>(*this);
            return traverse_get_optional<top_level, true, T>(meta::is_optional<meta::unqualified_t<T>>(), std::forward<Keys>(keys)...);
        }

traverse_raw_set()

template<bool top_level, typename base_type>

template<typename... Keys>

basic_table_core& sol::basic_table_core< top_level, base_type >::traverse_raw_set ( Keys &&...  keys )

inline

                                                           {
            auto pp = stack::push_pop<is_global<Keys...>::value>(*this);
            auto pn = stack::pop_n(base_t::lua_state(), static_cast<int>(sizeof...(Keys) - 2));
            traverse_set_deep<top_level, true>(std::forward<Keys>(keys)...);
            return *this;
        }

traverse_set()

template<bool top_level, typename base_type>

template<typename... Keys>

basic_table_core& sol::basic_table_core< top_level, base_type >::traverse_set ( Keys &&...  keys )

inline

                                                       {
            auto pp = stack::push_pop<is_global<Keys...>::value>(*this);
            auto pn = stack::pop_n(base_t::lua_state(), static_cast<int>(sizeof...(Keys) - 2));
            traverse_set_deep<top_level, false>(std::forward<Keys>(keys)...);
            return *this;
        }

traverse_set_deep() [1/2]

template<bool top_level, typename base_type>

template<bool global, bool raw, typename Key , typename Value >

void sol::basic_table_core< top_level, base_type >::traverse_set_deep ( Key &&  key, Value &&  value  ) const

inlineprivate

                                                               {
            stack::set_field<global, raw>(base_t::lua_state(), std::forward<Key>(key), std::forward<Value>(value));
        }

traverse_set_deep() [2/2]

template<bool top_level, typename base_type>

template<bool global, bool raw, typename Key , typename... Keys>

void sol::basic_table_core< top_level, base_type >::traverse_set_deep ( Key &&  key, Keys &&...  keys  ) const

inlineprivate

                                                                {
            stack::get_field<global, raw>(base_t::lua_state(), std::forward<Key>(key));
            traverse_set_deep<false, raw>(std::forward<Keys>(keys)...);
        }

tuple_get() [1/2]

template<bool top_level, typename base_type>

template<bool raw, typename Ret0 , typename Ret1 , typename... Ret, std::size_t... I, typename Keys >

auto sol::basic_table_core< top_level, base_type >::tuple_get ( types< Ret0, Ret1, Ret... >  , std::index_sequence< 0, 1, I... >  , Keys &&  keys  ) const -> decltype(stack::pop<std::tuple<Ret0, Ret1, Ret...>>(nullptr))

inlineprivate

                                                                         {
            typedef decltype(stack::pop<std::tuple<Ret0, Ret1, Ret...>>(nullptr)) Tup;
            return Tup(
                traverse_get_optional<top_level, raw, Ret0>(meta::is_optional<meta::unqualified_t<Ret0>>(), detail::forward_get<0>(keys)),
                traverse_get_optional<top_level, raw, Ret1>(meta::is_optional<meta::unqualified_t<Ret1>>(), detail::forward_get<1>(keys)),
                traverse_get_optional<top_level, raw, Ret>(meta::is_optional<meta::unqualified_t<Ret>>(), detail::forward_get<I>(keys))...);
        }

tuple_get() [2/2]

template<bool top_level, typename base_type>

template<bool raw, typename Ret , std::size_t I, typename Keys >

decltype(auto) sol::basic_table_core< top_level, base_type >::tuple_get ( types< Ret >  , std::index_sequence< I >  , Keys &&  keys  ) const

inlineprivate

                                                                                      {
            return traverse_get_optional<top_level, raw, Ret>(meta::is_optional<meta::unqualified_t<Ret>>(), detail::forward_get<I>(keys));
        }

tuple_set()

template<bool top_level, typename base_type>

template<bool raw, typename Pairs , std::size_t... I>

void sol::basic_table_core< top_level, base_type >::tuple_set ( std::index_sequence< I... >  , Pairs &&  pairs  )

inlineprivate

                                                               {
            auto pp = stack::push_pop < top_level && (is_global<decltype(detail::forward_get<I * 2>(pairs))...>::value) > (*this);
            void(detail::swallow{ (stack::set_field<top_level, raw>(base_t::lua_state(),
                                   detail::forward_get<I * 2>(pairs),
                                   detail::forward_get<I * 2 + 1>(pairs),
                                   lua_gettop(base_t::lua_state())),
                0)... });
        }

Friends And Related Function Documentation

state

template<bool top_level, typename base_type>

friend class state

friend

state_view

template<bool top_level, typename base_type>

friend class state_view

friend

---

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

• external/sol.hpp