sol::simple_usertype_metatable< T > Struct Template Reference

#include <sol.hpp>

Inheritance diagram for sol::simple_usertype_metatable< T >:

Public Member Functions
template<typename N >
void	insert (N &&n, object &&o)
template<typename N , typename F , typename... Args>
void	insert_prepare (std::true_type, lua_State *L, N &&, F &&f, Args &&... args)
template<typename N , typename F , typename... Args>
void	insert_prepare (std::false_type, lua_State *L, N &&n, F &&f, Args &&... args)
template<typename N , typename F >
void	add_member_function (std::true_type, lua_State *L, N &&n, F &&f)
template<typename N , typename F >
void	add_member_function (std::false_type, lua_State *L, N &&n, F &&f)
template<typename N , typename F , meta::enable< meta::is_callable< meta::unwrap_unqualified_t< F >>> = meta::enabler>
void	add_function (lua_State *L, N &&n, F &&f)
template<typename N , typename F , meta::disable< meta::is_callable< meta::unwrap_unqualified_t< F >>> = meta::enabler>
void	add_function (lua_State *L, N &&n, F &&f)
template<typename N , typename F , meta::disable< is_variable_binding< meta::unqualified_t< F >>> = meta::enabler>
void	add (lua_State *L, N &&n, F &&f)
template<typename N , typename F , meta::enable< is_variable_binding< meta::unqualified_t< F >>> = meta::enabler>
void	add (lua_State *, N &&n, F &&f)
template<typename N , typename... Fxs>
void	add (lua_State *L, N &&n, constructor_wrapper< Fxs... > c)
template<typename N , typename... Lists>
void	add (lua_State *L, N &&n, constructor_list< Lists... > c)
template<typename N >
void	add (lua_State *L, N &&n, destructor_wrapper< void > c)
template<typename N , typename Fx >
void	add (lua_State *L, N &&n, destructor_wrapper< Fx > c)
template<typename... Bases>
void	add (lua_State *, base_classes_tag, bases< Bases... >)
	simple_usertype_metatable (lua_State *L)
template<typename Arg , typename... Args, meta::disable_any< meta::any_same< meta::unqualified_t< Arg >, detail::verified_tag, detail::add_destructor_tag, detail::check_destructor_tag >, meta::is_specialization_of< meta::unqualified_t< Arg >, constructors >, meta::is_specialization_of< meta::unqualified_t< Arg >, constructor_wrapper >> = meta::enabler>
	simple_usertype_metatable (lua_State *L, Arg &&arg, Args &&... args)
template<typename... Args, typename... CArgs>
	simple_usertype_metatable (lua_State *L, constructors< CArgs... > constructorlist, Args &&... args)
template<typename... Args, typename... Fxs>
	simple_usertype_metatable (lua_State *L, constructor_wrapper< Fxs... > constructorlist, Args &&... args)
	simple_usertype_metatable (const simple_usertype_metatable &)=default
	simple_usertype_metatable (simple_usertype_metatable &&)=default
simple_usertype_metatable &	operator= (const simple_usertype_metatable &)=default
simple_usertype_metatable &	operator= (simple_usertype_metatable &&)=default
virtual int	push_um (lua_State *L) override
Public Member Functions inherited from sol::usertype_detail::registrar
	registrar ()=default
	registrar (const registrar &)=default
	registrar (registrar &&)=default
registrar &	operator= (const registrar &)=default
registrar &	operator= (registrar &&)=default
virtual	~registrar ()

Public Attributes
usertype_detail::function_map	registrations
usertype_detail::variable_map	varmap
object	callconstructfunc
object	indexfunc
object	newindexfunc
lua_CFunction	indexbase
lua_CFunction	newindexbase
usertype_detail::base_walk	indexbaseclasspropogation
usertype_detail::base_walk	newindexbaseclasspropogation
void *	baseclasscheck
void *	baseclasscast
bool	mustindex
bool	secondarymeta
std::array< bool, 32 >	properties

Private Member Functions
template<std::size_t... I, typename Tuple >
	simple_usertype_metatable (detail::verified_tag, std::index_sequence< I... >, lua_State *L, Tuple &&args)
template<typename... Args>
	simple_usertype_metatable (lua_State *L, detail::verified_tag v, Args &&... args)
template<typename... Args>
	simple_usertype_metatable (lua_State *L, detail::add_destructor_tag, Args &&... args)
template<typename... Args>
	simple_usertype_metatable (lua_State *L, detail::check_destructor_tag, Args &&... args)

Constructor & Destructor Documentation

simple_usertype_metatable() [1/10]

template<typename T >

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

sol::simple_usertype_metatable< T >::simple_usertype_metatable ( detail::verified_tag  , std::index_sequence< I... >  , lua_State *  L, Tuple &&  args  )

inlineprivate

        : callconstructfunc(lua_nil), indexfunc(lua_nil), newindexfunc(lua_nil), indexbase(&usertype_detail::simple_core_indexing_call<T, true>), newindexbase(&usertype_detail::simple_core_indexing_call<T, false>), indexbaseclasspropogation(usertype_detail::walk_all_bases<true>), newindexbaseclasspropogation(&usertype_detail::walk_all_bases<false>), baseclasscheck(nullptr), baseclasscast(nullptr), mustindex(false), secondarymeta(false), properties() {
            properties.fill(false);

            (void)detail::swallow{0,
                (add(L, detail::forward_get<I * 2>(args), detail::forward_get<I * 2 + 1>(args)), 0)...};
        }

simple_usertype_metatable() [2/10]

template<typename T >

template<typename... Args>

sol::simple_usertype_metatable< T >::simple_usertype_metatable ( lua_State *  L, detail::verified_tag  v, Args &&...  args  )

inlineprivate

        : simple_usertype_metatable(v, std::make_index_sequence<sizeof...(Args) / 2>(), L, std::forward_as_tuple(std::forward<Args>(args)...)) {
        }

simple_usertype_metatable() [3/10]

template<typename T >

template<typename... Args>

sol::simple_usertype_metatable< T >::simple_usertype_metatable ( lua_State *  L, detail::add_destructor_tag  , Args &&...  args  )

inlineprivate

        : simple_usertype_metatable(L, detail::verified, std::forward<Args>(args)..., "__gc", default_destructor) {
        }

simple_usertype_metatable() [4/10]

template<typename T >

template<typename... Args>

sol::simple_usertype_metatable< T >::simple_usertype_metatable ( lua_State *  L, detail::check_destructor_tag  , Args &&...  args  )

inlineprivate

        : simple_usertype_metatable(L, meta::condition<meta::all<std::is_destructible<T>, meta::neg<detail::has_destructor<Args...>>>, detail::add_destructor_tag, detail::verified_tag>(), std::forward<Args>(args)...) {
        }

simple_usertype_metatable() [5/10]

template<typename T >

sol::simple_usertype_metatable< T >::simple_usertype_metatable ( lua_State *  L )

inline

        : simple_usertype_metatable(L, meta::condition<meta::all<std::is_default_constructible<T>>, decltype(default_constructor), detail::check_destructor_tag>()) {
        }

simple_usertype_metatable() [6/10]

template<typename T >

template<typename Arg , typename... Args, meta::disable_any< meta::any_same< meta::unqualified_t< Arg >, detail::verified_tag, detail::add_destructor_tag, detail::check_destructor_tag >, meta::is_specialization_of< meta::unqualified_t< Arg >, constructors >, meta::is_specialization_of< meta::unqualified_t< Arg >, constructor_wrapper >> = meta::enabler>

sol::simple_usertype_metatable< T >::simple_usertype_metatable ( lua_State *  L, Arg &&  arg, Args &&...  args  )

inline

        : simple_usertype_metatable(L, meta::condition<meta::all<std::is_default_constructible<T>, meta::neg<detail::has_constructor<Args...>>>, decltype(default_constructor), detail::check_destructor_tag>(), std::forward<Arg>(arg), std::forward<Args>(args)...) {
        }

simple_usertype_metatable() [7/10]

template<typename T >

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

sol::simple_usertype_metatable< T >::simple_usertype_metatable ( lua_State *  L, constructors< CArgs... >  constructorlist, Args &&...  args  )

inline

        : simple_usertype_metatable(L, detail::check_destructor_tag(), std::forward<Args>(args)..., "new", constructorlist) {
        }

simple_usertype_metatable() [8/10]

template<typename T >

template<typename... Args, typename... Fxs>

sol::simple_usertype_metatable< T >::simple_usertype_metatable ( lua_State *  L, constructor_wrapper< Fxs... >  constructorlist, Args &&...  args  )

inline

        : simple_usertype_metatable(L, detail::check_destructor_tag(), std::forward<Args>(args)..., "new", constructorlist) {
        }

simple_usertype_metatable() [9/10]

template<typename T >

sol::simple_usertype_metatable< T >::simple_usertype_metatable ( const simple_usertype_metatable< T > &  )

default

simple_usertype_metatable() [10/10]

template<typename T >

sol::simple_usertype_metatable< T >::simple_usertype_metatable ( simple_usertype_metatable< T > &&  )

default

Member Function Documentation

add() [1/7]

template<typename T >

template<typename N , typename F , meta::disable< is_variable_binding< meta::unqualified_t< F >>> = meta::enabler>

void sol::simple_usertype_metatable< T >::add ( lua_State *  L, N &&  n, F &&  f  )

inline

                                             {
            add_function(L, std::forward<N>(n), std::forward<F>(f));
        }

add() [2/7]

template<typename T >

template<typename N , typename F , meta::enable< is_variable_binding< meta::unqualified_t< F >>> = meta::enabler>

void sol::simple_usertype_metatable< T >::add ( lua_State *  , N &&  n, F &&  f  )

inline

                                           {
            mustindex = true;
            secondarymeta = true;
            std::string key = usertype_detail::make_string(std::forward<N>(n));
            auto o = std::make_unique<usertype_detail::callable_binding<T, std::decay_t<F>>>(std::forward<F>(f));
            auto hint = varmap.find(key);
            if (hint == varmap.cend()) {
                varmap.emplace_hint(hint, std::move(key), std::move(o));
                return;
            }
            hint->second = std::move(o);
        }

add() [3/7]

template<typename T >

template<typename N , typename... Fxs>

void sol::simple_usertype_metatable< T >::add ( lua_State *  L, N &&  n, constructor_wrapper< Fxs... >  c  )

inline

                                                                     {
            object o(L, in_place_type<detail::tagged<T, constructor_wrapper<Fxs...>>>, std::move(c));
            if (std::is_same<meta::unqualified_t<N>, call_construction>::value) {
                callconstructfunc = std::move(o);
                return;
            }
            insert(std::forward<N>(n), std::move(o));
        }

add() [4/7]

template<typename T >

template<typename N , typename... Lists>

void sol::simple_usertype_metatable< T >::add ( lua_State *  L, N &&  n, constructor_list< Lists... >  c  )

inline

                                                                    {
            object o(L, in_place_type<detail::tagged<T, constructor_list<Lists...>>>, std::move(c));
            if (std::is_same<meta::unqualified_t<N>, call_construction>::value) {
                callconstructfunc = std::move(o);
                return;
            }
            insert(std::forward<N>(n), std::move(o));
        }

add() [5/7]

template<typename T >

template<typename N >

void sol::simple_usertype_metatable< T >::add ( lua_State *  L, N &&  n, destructor_wrapper< void >  c  )

inline

                                                                  {
            object o(L, in_place_type<detail::tagged<T, destructor_wrapper<void>>>, std::move(c));
            if (std::is_same<meta::unqualified_t<N>, call_construction>::value) {
                callconstructfunc = std::move(o);
                return;
            }
            insert(std::forward<N>(n), std::move(o));
        }

add() [6/7]

template<typename T >

template<typename N , typename Fx >

void sol::simple_usertype_metatable< T >::add ( lua_State *  L, N &&  n, destructor_wrapper< Fx >  c  )

inline

                                                                {
            object o(L, in_place_type<detail::tagged<T, destructor_wrapper<Fx>>>, std::move(c));
            if (std::is_same<meta::unqualified_t<N>, call_construction>::value) {
                callconstructfunc = std::move(o);
                return;
            }
            insert(std::forward<N>(n), std::move(o));
        }

add() [7/7]

template<typename T >

template<typename... Bases>

void sol::simple_usertype_metatable< T >::add ( lua_State *  , base_classes_tag  , bases< Bases... >    )

inline

                                                                {
            static_assert(sizeof(usertype_detail::base_walk) <= sizeof(void*), "size of function pointer is greater than sizeof(void*); cannot work on this platform. Please file a bug report.");
            static_assert(!meta::any_same<T, Bases...>::value, "base classes cannot list the original class as part of the bases");
            if (sizeof...(Bases) < 1) {
                return;
            }
            mustindex = true;
            (void)detail::swallow{0, ((detail::has_derived<Bases>::value = true), 0)...};

            static_assert(sizeof(void*) <= sizeof(detail::inheritance_check_function), "The size of this data pointer is too small to fit the inheritance checking function: Please file a bug report.");
            static_assert(sizeof(void*) <= sizeof(detail::inheritance_cast_function), "The size of this data pointer is too small to fit the inheritance checking function: Please file a bug report.");
            baseclasscheck = reinterpret_cast<void*>(&detail::inheritance<T, Bases...>::type_check);
            baseclasscast = reinterpret_cast<void*>(&detail::inheritance<T, Bases...>::type_cast);
            indexbaseclasspropogation = usertype_detail::walk_all_bases<true, Bases...>;
            newindexbaseclasspropogation = usertype_detail::walk_all_bases<false, Bases...>;
        }

add_function() [1/2]

template<typename T >

template<typename N , typename F , meta::enable< meta::is_callable< meta::unwrap_unqualified_t< F >>> = meta::enabler>

void sol::simple_usertype_metatable< T >::add_function ( lua_State *  L, N &&  n, F &&  f  )

inline

                                                      {
            object o = make_object(L, as_function_reference(std::forward<F>(f)));
            if (std::is_same<meta::unqualified_t<N>, call_construction>::value) {
                callconstructfunc = std::move(o);
                return;
            }
            insert(std::forward<N>(n), std::move(o));
        }

add_function() [2/2]

template<typename T >

template<typename N , typename F , meta::disable< meta::is_callable< meta::unwrap_unqualified_t< F >>> = meta::enabler>

void sol::simple_usertype_metatable< T >::add_function ( lua_State *  L, N &&  n, F &&  f  )

inline

                                                      {
            add_member_function(std::is_member_pointer<meta::unwrap_unqualified_t<F>>(), L, std::forward<N>(n), std::forward<F>(f));
        }

add_member_function() [1/2]

template<typename T >

template<typename N , typename F >

void sol::simple_usertype_metatable< T >::add_member_function ( std::true_type  , lua_State *  L, N &&  n, F &&  f  )

inline

                                                                           {
            insert_prepare(std::is_same<meta::unqualified_t<N>, call_construction>(), L, std::forward<N>(n), std::forward<F>(f), function_detail::class_indicator<T>());
        }

add_member_function() [2/2]

template<typename T >

template<typename N , typename F >

void sol::simple_usertype_metatable< T >::add_member_function ( std::false_type  , lua_State *  L, N &&  n, F &&  f  )

inline

                                                                            {
            insert_prepare(std::is_same<meta::unqualified_t<N>, call_construction>(), L, std::forward<N>(n), std::forward<F>(f));
        }

insert()

template<typename T >

template<typename N >

void sol::simple_usertype_metatable< T >::insert ( N &&  n, object &&  o  )

inline

                                       {
            std::string key = usertype_detail::make_string(std::forward<N>(n));
            int is_indexer = static_cast<int>(usertype_detail::is_indexer(n));
            if (is_indexer == 1) {
                indexfunc = o;
                mustindex = true;
            }
            else if (is_indexer == 2) {
                newindexfunc = o;
                mustindex = true;
            }
            auto hint = registrations.find(key);
            if (hint == registrations.cend()) {
                registrations.emplace_hint(hint, std::move(key), std::move(o));
                return;
            }
            hint->second = std::move(o);
        }

insert_prepare() [1/2]

template<typename T >

template<typename N , typename F , typename... Args>

void sol::simple_usertype_metatable< T >::insert_prepare ( std::true_type  , lua_State *  L, N &&  , F &&  f, Args &&...  args  )

inline

                                                                                    {
            object o = make_object<F>(L, std::forward<F>(f), function_detail::call_indicator(), std::forward<Args>(args)...);
            callconstructfunc = std::move(o);
        }

insert_prepare() [2/2]

template<typename T >

template<typename N , typename F , typename... Args>

void sol::simple_usertype_metatable< T >::insert_prepare ( std::false_type  , lua_State *  L, N &&  n, F &&  f, Args &&...  args  )

inline

                                                                                       {
            object o = make_object<F>(L, std::forward<F>(f), std::forward<Args>(args)...);
            insert(std::forward<N>(n), std::move(o));
        }

operator=() [1/2]

template<typename T >

simple_usertype_metatable& sol::simple_usertype_metatable< T >::operator= ( const simple_usertype_metatable< T > &  )

default

operator=() [2/2]

template<typename T >

simple_usertype_metatable& sol::simple_usertype_metatable< T >::operator= ( simple_usertype_metatable< T > &&  )

default

push_um()

template<typename T >

virtual int sol::simple_usertype_metatable< T >::push_um ( lua_State *  L )

inlineoverridevirtual

Implements sol::usertype_detail::registrar.

                                                   {
            return stack::push(L, std::move(*this));
        }

Member Data Documentation

baseclasscast

template<typename T >

void* sol::simple_usertype_metatable< T >::baseclasscast

baseclasscheck

template<typename T >

void* sol::simple_usertype_metatable< T >::baseclasscheck

callconstructfunc

template<typename T >

object sol::simple_usertype_metatable< T >::callconstructfunc

indexbase

template<typename T >

lua_CFunction sol::simple_usertype_metatable< T >::indexbase

indexbaseclasspropogation

template<typename T >

usertype_detail::base_walk sol::simple_usertype_metatable< T >::indexbaseclasspropogation

indexfunc

template<typename T >

object sol::simple_usertype_metatable< T >::indexfunc

mustindex

template<typename T >

bool sol::simple_usertype_metatable< T >::mustindex

newindexbase

template<typename T >

lua_CFunction sol::simple_usertype_metatable< T >::newindexbase

newindexbaseclasspropogation

template<typename T >

usertype_detail::base_walk sol::simple_usertype_metatable< T >::newindexbaseclasspropogation

newindexfunc

template<typename T >

object sol::simple_usertype_metatable< T >::newindexfunc

properties

template<typename T >

std::array<bool, 32> sol::simple_usertype_metatable< T >::properties

registrations

template<typename T >

usertype_detail::function_map sol::simple_usertype_metatable< T >::registrations

secondarymeta

template<typename T >

bool sol::simple_usertype_metatable< T >::secondarymeta

varmap

template<typename T >

usertype_detail::variable_map sol::simple_usertype_metatable< T >::varmap

---

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

• external/sol.hpp