sol::proxy< Table, Key > Struct Template Reference

#include <sol.hpp>

Inheritance diagram for sol::proxy< Table, Key >:

Public Member Functions
template<typename T >
	proxy (Table table, T &&k)
template<typename T >
proxy &	set (T &&item)
template<typename... Args>
proxy &	set_function (Args &&... args)
template<typename U , meta::enable< meta::neg< is_lua_reference_or_proxy< meta::unwrap_unqualified_t< U >>>, meta::is_callable< meta::unwrap_unqualified_t< U >>> = meta::enabler>
proxy &	operator= (U &&other)
template<typename U , meta::disable< meta::neg< is_lua_reference_or_proxy< meta::unwrap_unqualified_t< U >>>, meta::is_callable< meta::unwrap_unqualified_t< U >>> = meta::enabler>
proxy &	operator= (U &&other)
template<typename T >
proxy &	operator= (std::initializer_list< T > other)
template<typename T >
decltype(auto)	get () const
template<typename T >
decltype(auto)	get_or (T &&otherwise) const
template<typename T , typename D >
decltype(auto)	get_or (D &&otherwise) const
template<typename T >
decltype(auto)	get_or_create ()
template<typename T , typename Otherwise >
decltype(auto)	get_or_create (Otherwise &&other)
template<typename K >
decltype(auto)	operator[] (K &&k) const
template<typename... Ret, typename... Args>
decltype(auto)	call (Args &&... args)
template<typename... Args>
decltype(auto)	operator() (Args &&... args)
bool	valid () const
int	push () const noexcept
int	push (lua_State *L) const noexcept
type	get_type () const
lua_State *	lua_state () const
proxy &	force ()
Public Member Functions inherited from sol::proxy_base< proxy< Table, Key > >
	operator std::string () const
	operator T () const
	operator T& () const
lua_State *	lua_state () const

Public Attributes
Table	tbl
key_type	key

Private Types
typedef meta::condition< meta::is_specialization_of< Key, std::tuple >, Key, std::tuple< meta::condition< std::is_array< meta::unqualified_t< Key > >, Key &, meta::unqualified_t< Key > > > >	key_type

Private Member Functions
template<typename T , std::size_t... I>
decltype(auto)	tuple_get (std::index_sequence< I... >) const
template<std::size_t... I, typename T >
void	tuple_set (std::index_sequence< I... >, T &&value)
auto	setup_table (std::true_type)
bool	is_valid (std::false_type)

Member Typedef Documentation

key_type

template<typename Table, typename Key>

typedef meta::condition<meta::is_specialization_of<Key, std::tuple>, Key, std::tuple<meta::condition<std::is_array<meta::unqualified_t<Key> >, Key&, meta::unqualified_t<Key> > > > sol::proxy< Table, Key >::key_type

private

Constructor & Destructor Documentation

proxy()

template<typename Table, typename Key>

template<typename T >

sol::proxy< Table, Key >::proxy ( Table  table, T &&  k  )

inline

        : tbl(table), key(std::forward<T>(k)) {
        }

Member Function Documentation

call()

template<typename Table, typename Key>

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

decltype(auto) sol::proxy< Table, Key >::call ( Args &&...  args )

inline

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

force()

template<typename Table, typename Key>

proxy& sol::proxy< Table, Key >::force ( )

inline

                       {
            if (this->valid()) {
                this->set(new_table());
            }
            return *this;
        }

get()

template<typename Table, typename Key>

template<typename T >

decltype(auto) sol::proxy< Table, Key >::get ( ) const

inline

                                   {
            return tuple_get<T>(std::make_index_sequence<std::tuple_size<meta::unqualified_t<key_type>>::value>());
        }

get_or() [1/2]

template<typename Table, typename Key>

template<typename T >

decltype(auto) sol::proxy< Table, Key >::get_or ( T &&  otherwise ) const

inline

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

get_or() [2/2]

template<typename Table, typename Key>

template<typename T , typename D >

decltype(auto) sol::proxy< Table, Key >::get_or ( D &&  otherwise ) const

inline

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

get_or_create() [1/2]

template<typename Table, typename Key>

template<typename T >

decltype(auto) sol::proxy< Table, Key >::get_or_create ( )

inline

                                       {
            return get_or_create<T>(new_table());
        }

get_or_create() [2/2]

template<typename Table, typename Key>

template<typename T , typename Otherwise >

decltype(auto) sol::proxy< Table, Key >::get_or_create ( Otherwise &&  other )

inline

                                                        {
            if (!this->valid()) {
                this->set(std::forward<Otherwise>(other));
            }
            return get<T>();
        }

get_type()

template<typename Table, typename Key>

type sol::proxy< Table, Key >::get_type ( ) const

inline

                              {
            type t = type::none;
            auto pp = stack::push_pop(tbl);
            auto p = stack::probe_get_field<std::is_same<meta::unqualified_t<Table>, global_table>::value>(lua_state(), key, lua_gettop(lua_state()));
            if (p) {
                t = type_of(lua_state(), -1);
            }
            lua_pop(lua_state(), p.levels);
            return t;
        }

is_valid()

template<typename Table, typename Key>

bool sol::proxy< Table, Key >::is_valid ( std::false_type  )

inlineprivate

                                     {
            auto pp = stack::push_pop(tbl);
            auto p = stack::probe_get_field<std::is_same<meta::unqualified_t<Table>, global_table>::value>(lua_state(), key, lua_gettop(lua_state()));
            lua_pop(lua_state(), p.levels);
            return p;
        }

lua_state()

template<typename Table, typename Key>

lua_State* sol::proxy< Table, Key >::lua_state ( ) const

inline

                                     {
            return tbl.lua_state();
        }

operator()()

template<typename Table, typename Key>

template<typename... Args>

decltype(auto) sol::proxy< Table, Key >::operator() ( Args &&...  args )

inline

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

operator=() [1/3]

template<typename Table, typename Key>

template<typename U , meta::enable< meta::neg< is_lua_reference_or_proxy< meta::unwrap_unqualified_t< U >>>, meta::is_callable< meta::unwrap_unqualified_t< U >>> = meta::enabler>

proxy& sol::proxy< Table, Key >::operator= ( U &&  other )

inline

                                    {
            return set_function(std::forward<U>(other));
        }

operator=() [2/3]

template<typename Table, typename Key>

template<typename U , meta::disable< meta::neg< is_lua_reference_or_proxy< meta::unwrap_unqualified_t< U >>>, meta::is_callable< meta::unwrap_unqualified_t< U >>> = meta::enabler>

proxy& sol::proxy< Table, Key >::operator= ( U &&  other )

inline

                                    {
            return set(std::forward<U>(other));
        }

operator=() [3/3]

template<typename Table, typename Key>

template<typename T >

proxy& sol::proxy< Table, Key >::operator= ( std::initializer_list< T >  other )

inline

                                                       {
            return set(std::move(other));
        }

operator[]()

template<typename Table, typename Key>

template<typename K >

decltype(auto) sol::proxy< Table, Key >::operator[] ( K &&  k ) const

inline

                                               {
            auto keys = meta::tuplefy(key, std::forward<K>(k));
            return proxy<Table, decltype(keys)>(tbl, std::move(keys));
        }

push() [1/2]

template<typename Table, typename Key>

int sol::proxy< Table, Key >::push ( ) const

inlinenoexcept

                                  {
            return push(this->lua_state());
        }

push() [2/2]

template<typename Table, typename Key>

int sol::proxy< Table, Key >::push ( lua_State *  L ) const

inlinenoexcept

                                              {
            return get<reference>().push(L);
        }

set()

template<typename Table, typename Key>

template<typename T >

proxy& sol::proxy< Table, Key >::set ( T &&  item )

inline

                             {
            tuple_set(std::make_index_sequence<std::tuple_size<meta::unqualified_t<key_type>>::value>(), std::forward<T>(item));
            return *this;
        }

set_function()

template<typename Table, typename Key>

template<typename... Args>

proxy& sol::proxy< Table, Key >::set_function ( Args &&...  args )

inline

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

setup_table()

template<typename Table, typename Key>

auto sol::proxy< Table, Key >::setup_table ( std::true_type  )

inlineprivate

                                       {
            auto p = stack::probe_get_field<std::is_same<meta::unqualified_t<Table>, global_table>::value>(lua_state(), key, tbl.stack_index());
            lua_pop(lua_state(), p.levels);
            return p;
        }

tuple_get()

template<typename Table, typename Key>

template<typename T , std::size_t... I>

decltype(auto) sol::proxy< Table, Key >::tuple_get ( std::index_sequence< I... >  ) const

inlineprivate

                                                                {
            return tbl.template traverse_get<T>(std::get<I>(key)...);
        }

tuple_set()

template<typename Table, typename Key>

template<std::size_t... I, typename T >

void sol::proxy< Table, Key >::tuple_set ( std::index_sequence< I... >  , T &&  value  )

inlineprivate

                                                           {
            tbl.traverse_set(std::get<I>(key)..., std::forward<T>(value));
        }

valid()

template<typename Table, typename Key>

bool sol::proxy< Table, Key >::valid ( ) const

inline

                           {
            auto pp = stack::push_pop(tbl);
            auto p = stack::probe_get_field<std::is_same<meta::unqualified_t<Table>, global_table>::value>(lua_state(), key, lua_gettop(lua_state()));
            lua_pop(lua_state(), p.levels);
            return p;
        }

Member Data Documentation

key

template<typename Table, typename Key>

key_type sol::proxy< Table, Key >::key

tbl

template<typename Table, typename Key>

Table sol::proxy< Table, Key >::tbl

---

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

• external/sol.hpp