sol::usertype_detail Namespace Reference

Classes
struct	call_information
struct	callable_binding
struct	no_comp
struct	registrar
struct	simple_map
struct	variable_wrapper

Typedefs
template<typename K , typename V , typename H = std::hash<K>, typename E = std::equal_to<>>
using	map_t = std::unordered_map< K, V, H, E >
typedef void(*	base_walk) (lua_State *, bool &, int &, string_view &)
typedef int(*	member_search) (lua_State *, void *, usertype_metatable_core &, int)
typedef map_t< std::string, call_information >	mapping_t
typedef map_t< std::string, std::unique_ptr< variable_wrapper > >	variable_map
typedef map_t< std::string, object >	function_map

Functions
template<typename T , typename Regs , typename Fx >
void	insert_default_registrations (Regs &l, int &index, Fx &&fx)
template<typename T , typename Regs , meta::enable< meta::neg< std::is_pointer< T >>, std::is_destructible< T >> = meta::enabler>
void	make_destructor (Regs &l, int &index)
template<typename T >
int	is_check (lua_State *L)
template<typename T >
int	member_default_to_string (std::true_type, lua_State *L)
template<typename T >
int	member_default_to_string (std::false_type, lua_State *L)
template<typename T >
int	adl_default_to_string (std::true_type, lua_State *L)
template<typename T >
int	adl_default_to_string (std::false_type, lua_State *L)
template<typename T >
int	oss_default_to_string (std::true_type, lua_State *L)
template<typename T >
int	oss_default_to_string (std::false_type, lua_State *L)
template<typename T >
int	default_to_string (lua_State *L)
template<typename T , typename Op >
int	comparsion_operator_wrap (lua_State *L)
template<typename T , typename Op , typename Supports , typename Regs , meta::enable< Supports > = meta::enabler>
void	make_reg_op (Regs &l, int &index, const char *name)
template<typename T , typename Supports , typename Regs , meta::enable< Supports > = meta::enabler>
void	make_to_string_op (Regs &l, int &index)
template<typename T , typename Regs , meta::enable< meta::has_deducible_signature< T >> = meta::enabler>
void	make_call_op (Regs &l, int &index)
template<typename T , typename Regs >
void	make_length_op_const (std::true_type, Regs &l, int &index)
template<typename T , typename Regs >
void	make_length_op_const (std::false_type, Regs &l, int &index)
template<typename T , typename Regs , meta::enable< meta::has_size< T >, meta::has_size< const T >> = meta::enabler>
void	make_length_op (Regs &l, int &index)
template<typename T , typename Regs , typename Fx >
void	insert_default_registrations (std::false_type, Regs &, int &, Fx &&)
template<typename T , typename Regs , typename Fx >
void	insert_default_registrations (std::true_type, Regs &l, int &index, Fx &&fx)
int	is_indexer (string_view s)
int	is_indexer (meta_function mf)
int	is_indexer (call_construction)
int	is_indexer (base_classes_tag)
auto	make_string_view (string_view s)
auto	make_string_view (call_construction)
auto	make_string_view (meta_function mf)
auto	make_string_view (base_classes_tag)
template<typename Arg >
std::string	make_string (Arg &&arg)
template<typename N >
luaL_Reg	make_reg (N &&n, lua_CFunction f)
bool	is_toplevel (lua_State *L, int index=magic_index)
int	runtime_object_call (lua_State *L, void *, usertype_metatable_core &umc, int runtimetarget)
template<typename T , bool is_index>
int	indexing_fail (lua_State *L)
int	runtime_new_index (lua_State *L, void *, usertype_metatable_core &, int runtimetarget)
template<typename T , bool is_simple>
int	metatable_new_index (lua_State *L)
template<bool is_index, typename Base >
static void	walk_single_base (lua_State *L, bool &found, int &ret, string_view &)
template<bool is_index, typename... Bases>
static void	walk_all_bases (lua_State *L, bool &found, int &ret, string_view &accessor)
int	call_indexing_object (lua_State *L, object &f)
template<typename T , bool is_index, bool toplevel = false, bool has_indexing = false>
int	simple_core_indexing_call (lua_State *L)
template<typename T , bool has_indexing = false>
int	simple_real_index_call (lua_State *L)
template<typename T , bool has_indexing = false>
int	simple_real_new_index_call (lua_State *L)
template<typename T , bool has_indexing = false>
int	simple_index_call (lua_State *L)
template<typename T , bool has_indexing = false>
int	simple_new_index_call (lua_State *L)

Variables
const int	metatable_index = 2
const int	metatable_core_index = 3
const int	filler_index = 4
const int	magic_index = 5
const int	simple_metatable_index = 2
const int	index_function_index = 3
const int	newindex_function_index = 4
const lua_Integer	toplevel_magic = static_cast<lua_Integer>(0xCCC2CCC1)

Typedef Documentation

base_walk

typedef void(* sol::usertype_detail::base_walk) (lua_State *, bool &, int &, string_view &)

function_map

typedef map_t<std::string, object> sol::usertype_detail::function_map

map_t

template<typename K , typename V , typename H = std::hash<K>, typename E = std::equal_to<>>

using sol::usertype_detail::map_t = typedef std::unordered_map<K, V, H, E>

mapping_t

typedef map_t<std::string, call_information> sol::usertype_detail::mapping_t

member_search

typedef int(* sol::usertype_detail::member_search) (lua_State *, void *, usertype_metatable_core &, int)

variable_map

typedef map_t<std::string, std::unique_ptr<variable_wrapper> > sol::usertype_detail::variable_map

Function Documentation

adl_default_to_string() [1/2]

template<typename T >

int sol::usertype_detail::adl_default_to_string ( std::true_type  , lua_State *  L  )

inline

                                                                     {
            using namespace std;
            decltype(auto) ts = to_string(stack::get<T>(L, 1));
            return stack::push(L, std::forward<decltype(ts)>(ts));
        }

adl_default_to_string() [2/2]

template<typename T >

int sol::usertype_detail::adl_default_to_string ( std::false_type  , lua_State *  L  )

inline

                                                                      {
            return member_default_to_string<T>(meta::supports_to_string_member<T>(), L);
        }

call_indexing_object()

int sol::usertype_detail::call_indexing_object ( lua_State *  L, object &  f  )

inline

                                                                 {
            int before = lua_gettop(L);
            f.push();
            for (int i = 1; i <= before; ++i) {
                lua_pushvalue(L, i);
            }
            lua_call(L, before, LUA_MULTRET);
            int after = lua_gettop(L);
            return after - before;
        }

comparsion_operator_wrap()

template<typename T , typename Op >

int sol::usertype_detail::comparsion_operator_wrap

(

lua_State *

L

)

                                                   {
            auto maybel = stack::unqualified_check_get<T&>(L, 1);
            if (maybel) {
                auto mayber = stack::unqualified_check_get<T&>(L, 2);
                if (mayber) {
                    auto& l = *maybel;
                    auto& r = *mayber;
                    if (std::is_same<no_comp, Op>::value) {
                        return stack::push(L, detail::ptr(l) == detail::ptr(r));
                    }
                    else {
                        Op op;
                        return stack::push(L, (detail::ptr(l) == detail::ptr(r)) || op(detail::deref(l), detail::deref(r)));
                    }
                }
            }
            return stack::push(L, false);
        }

default_to_string()

template<typename T >

int sol::usertype_detail::default_to_string ( lua_State *  L )

inline

                                                   {
            return oss_default_to_string<T>(meta::supports_ostream_op<T>(), L);
        }

indexing_fail()

template<typename T , bool is_index>

int sol::usertype_detail::indexing_fail ( lua_State *  L )

inline

                                               {
            if (is_index) {
#if 0 //defined(SOL_SAFE_USERTYPE) && SOL_SAFE_USERTYPE
                auto maybeaccessor = stack::get<optional<string_view>>(L, is_index ? -1 : -2);
                string_view accessor = maybeaccessor.value_or(string_detail::string_shim("(unknown)"));
                return luaL_error(L, "sol: attempt to index (get) nil value \"%s\" on userdata (bad (misspelled?) key name or does not exist)", accessor.data());
#else
                if (is_toplevel(L)) {
                    if (lua_getmetatable(L, 1) == 1) {
                        int metatarget = lua_gettop(L);
                        stack::get_field(L, stack_reference(L, raw_index(2)), metatarget);
                        return 1;
                    }
                }
                // With runtime extensibility, we can't hard-error things. They have to return nil, like regular table types, unfortunately...
                return stack::push(L, lua_nil);
#endif
            }
            else {
                auto maybeaccessor = stack::get<optional<string_view>>(L, is_index ? -1 : -2);
                string_view accessor = maybeaccessor.value_or(string_view("(unknown)"));
                return luaL_error(L, "sol: attempt to index (set) nil value \"%s\" on userdata (bad (misspelled?) key name or does not exist)", accessor.data());
            }
        }

insert_default_registrations() [1/3]

template<typename T , typename Regs , typename Fx >

void sol::usertype_detail::insert_default_registrations	(	Regs &	l,
		int &	index,
		Fx &&	fx
	)

                                                                        {
            insert_default_registrations<T>(is_automagical<T>(), l, index, std::forward<Fx>(fx));
        }

insert_default_registrations() [2/3]

template<typename T , typename Regs , typename Fx >

void sol::usertype_detail::insert_default_registrations	(	std::false_type	,
		Regs &	,
		int &	,
		Fx &&
	)

                                                                            {
            // no-op
        }

insert_default_registrations() [3/3]

template<typename T , typename Regs , typename Fx >

void sol::usertype_detail::insert_default_registrations	(	std::true_type	,
		Regs &	l,
		int &	index,
		Fx &&	fx
	)

                                                                                      {
            if (fx(meta_function::less_than)) {
                const char* name = to_string(meta_function::less_than).c_str();
                usertype_detail::make_reg_op<T, std::less<>, meta::supports_op_less<T>>(l, index, name);
            }
            if (fx(meta_function::less_than_or_equal_to)) {
                const char* name = to_string(meta_function::less_than_or_equal_to).c_str();
                usertype_detail::make_reg_op<T, std::less_equal<>, meta::supports_op_less_equal<T>>(l, index, name);
            }
            if (fx(meta_function::equal_to)) {
                const char* name = to_string(meta_function::equal_to).c_str();
                usertype_detail::make_reg_op<T, std::conditional_t<meta::supports_op_equal<T>::value, std::equal_to<>, usertype_detail::no_comp>, std::true_type>(l, index, name);
            }
            if (fx(meta_function::pairs)) {
                const char* name = to_string(meta_function::pairs).c_str();
                l[index] = luaL_Reg{ name, container_usertype_metatable<as_container_t<T>>::pairs_call };
                ++index;
            }
            if (fx(meta_function::length)) {
                usertype_detail::make_length_op<T>(l, index);
            }
            if (fx(meta_function::to_string)) {
                usertype_detail::make_to_string_op<T, is_to_stringable<T>>(l, index);
            }
            if (fx(meta_function::call_function)) {
                usertype_detail::make_call_op<T>(l, index);
            }
        }

is_check()

template<typename T >

int sol::usertype_detail::is_check

(

lua_State *

L

)

                                   {
            return stack::push(L, stack::check<T>(L, 1, &no_panic));
        }

is_indexer() [1/4]

int sol::usertype_detail::is_indexer ( string_view  s )

inline

                                             {
            if (s == to_string(meta_function::index)) {
                return 1;
            }
            else if (s == to_string(meta_function::new_index)) {
                return 2;
            }
            return 0;
        }

is_indexer() [2/4]

int sol::usertype_detail::is_indexer ( meta_function  mf )

inline

                                                {
            if (mf == meta_function::index) {
                return 1;
            }
            else if (mf == meta_function::new_index) {
                return 2;
            }
            return 0;
        }

is_indexer() [3/4]

int sol::usertype_detail::is_indexer ( call_construction  )

inline

                                                 {
            return 0;
        }

is_indexer() [4/4]

int sol::usertype_detail::is_indexer ( base_classes_tag  )

inline

                                                {
            return 0;
        }

is_toplevel()

bool sol::usertype_detail::is_toplevel ( lua_State *  L, int  index = magic_index  )

inline

                                                                       {
            int isnum = 0;
            lua_Integer magic = lua_tointegerx(L, upvalue_index(index), &isnum);
            return isnum != 0 && magic == toplevel_magic;
        }

make_call_op()

template<typename T , typename Regs , meta::enable< meta::has_deducible_signature< T >> = meta::enabler>

void sol::usertype_detail::make_call_op ( Regs &  l, int &  index  )

inline

                                                      {
            const char* name = to_string(meta_function::call).c_str();
            lua_CFunction f = &c_call<decltype(&T::operator()), &T::operator()>;
            l[index] = luaL_Reg{ name, f };
            ++index;
        }

make_destructor()

template<typename T , typename Regs , meta::enable< meta::neg< std::is_pointer< T >>, std::is_destructible< T >> = meta::enabler>

void sol::usertype_detail::make_destructor	(	Regs &	l,
		int &	index
	)

                                                  {
            const char* name = to_string(meta_function::garbage_collect).c_str();
            l[index] = luaL_Reg{ name, is_unique_usertype<T>::value ? &detail::unique_destruct<T> : &detail::usertype_alloc_destruct<T> };
            ++index;
        }

make_length_op()

template<typename T , typename Regs , meta::enable< meta::has_size< T >, meta::has_size< const T >> = meta::enabler>

void sol::usertype_detail::make_length_op ( Regs &  l, int &  index  )

inline

                                                        {
            make_length_op_const<T>(meta::has_size<const T>(), l, index);
        }

make_length_op_const() [1/2]

template<typename T , typename Regs >

void sol::usertype_detail::make_length_op_const ( std::true_type  , Regs &  l, int &  index  )

inline

                                                                            {
            const char* name = to_string(meta_function::length).c_str();
#if defined(__clang__)
            l[index] = luaL_Reg{ name, &c_call<decltype(&T::size), &T::size> };
#else
            typedef decltype(std::declval<T>().size()) R;
            using sz_func = R(T::*)()const;
            l[index] = luaL_Reg{ name, &c_call<decltype(static_cast<sz_func>(&T::size)), static_cast<sz_func>(&T::size)> };
#endif
            ++index;
        }

make_length_op_const() [2/2]

template<typename T , typename Regs >

void sol::usertype_detail::make_length_op_const ( std::false_type  , Regs &  l, int &  index  )

inline

                                                                             {
            const char* name = to_string(meta_function::length).c_str();
#if defined(__clang__)
            l[index] = luaL_Reg{ name, &c_call<decltype(&T::size), &T::size> };
#else
            typedef decltype(std::declval<T>().size()) R;
            using sz_func = R(T::*)();
            l[index] = luaL_Reg{ name, &c_call<decltype(static_cast<sz_func>(&T::size)), static_cast<sz_func>(&T::size)> };
#endif
            ++index;
        }

make_reg()

template<typename N >

luaL_Reg sol::usertype_detail::make_reg ( N &&  n, lua_CFunction  f  )

inline

                                                         {
            luaL_Reg l{make_string_view(std::forward<N>(n)).data(), f};
            return l;
        }

make_reg_op()

template<typename T , typename Op , typename Supports , typename Regs , meta::enable< Supports > = meta::enabler>

void sol::usertype_detail::make_reg_op ( Regs &  l, int &  index, const char *  name  )

inline

                                                                       {
            lua_CFunction f = &comparsion_operator_wrap<T, Op>;
            l[index] = luaL_Reg{ name, f };
            ++index;
        }

make_string()

template<typename Arg >

std::string sol::usertype_detail::make_string ( Arg &&  arg )

inline

                                                {
            string_view s = make_string_view(arg);
            return std::string(s.data(), s.size());
        }

make_string_view() [1/4]

auto sol::usertype_detail::make_string_view ( string_view  s )

inline

                                                    {
            return s;
        }

make_string_view() [2/4]

auto sol::usertype_detail::make_string_view ( call_construction  )

inline

                                                        {
            return string_view(to_string(meta_function::call_function));
        }

make_string_view() [3/4]

auto sol::usertype_detail::make_string_view ( meta_function  mf )

inline

                                                       {
            return string_view(to_string(mf));
        }

make_string_view() [4/4]

auto sol::usertype_detail::make_string_view ( base_classes_tag  )

inline

                                                       {
            return string_view(detail::base_class_cast_key());
        }

make_to_string_op()

template<typename T , typename Supports , typename Regs , meta::enable< Supports > = meta::enabler>

void sol::usertype_detail::make_to_string_op ( Regs &  l, int &  index  )

inline

                                                           {
            const char* name = to_string(meta_function::to_string).c_str();
            lua_CFunction f = &detail::static_trampoline<&default_to_string<T>>;
            l[index] = luaL_Reg{ name, f };
            ++index;
        }

member_default_to_string() [1/2]

template<typename T >

int sol::usertype_detail::member_default_to_string ( std::true_type  , lua_State *  L  )

inline

                                                                        {
            decltype(auto) ts = stack::get<T>(L, 1).to_string();
            return stack::push(L, std::forward<decltype(ts)>(ts));
        }

member_default_to_string() [2/2]

template<typename T >

int sol::usertype_detail::member_default_to_string ( std::false_type  , lua_State *  L  )

inline

                                                                         {
            return luaL_error(L, "cannot perform to_string on '%s': no 'to_string' overload in namespace, 'to_string' member function, or operator<<(ostream&, ...) present", detail::demangle<T>().data());
        }

metatable_new_index()

template<typename T , bool is_simple>

int sol::usertype_detail::metatable_new_index ( lua_State *  L )

inline

                                                     {
            if (is_toplevel(L)) {
                auto non_indexable = [&L]() {
                    if (is_simple) {
                        simple_map& sm = stack::get<user<simple_map>>(L, upvalue_index(simple_metatable_index));
                        function_map& functions = sm.functions;
                        optional<string_view> maybeaccessor = stack::get<optional<string_view>>(L, 2);
                        if (!maybeaccessor) {
                            return;
                        }
                        string_view& accessor_view = maybeaccessor.value();
#if defined(SOL_UNORDERED_MAP_COMPATIBLE_HASH) && SOL_UNORDERED_MAP_COMPATIBLE_HASH
                        auto preexistingit = functions.find(accessor_view, string_view_hash(), std::equal_to<string_view>());
#else
                        std::string accessor(accessor_view.data(), accessor_view.size());
                        auto preexistingit = functions.find(accessor);
#endif
                        if (preexistingit == functions.cend()) {
#if defined(SOL_UNORDERED_MAP_COMPATIBLE_HASH) && SOL_UNORDERED_MAP_COMPATIBLE_HASH
                            std::string accessor(accessor_view.data(), accessor_view.size());
#endif
                            functions.emplace_hint(preexistingit, std::move(accessor), object(L, 3));
                        }
                        else {
                            preexistingit->second = object(L, 3);
                        }
                        return;
                    }
                    usertype_metatable_core& umc = stack::get<light<usertype_metatable_core>>(L, upvalue_index(metatable_core_index));
                    bool mustindex = umc.mustindex;
                    if (!mustindex)
                        return;
                    optional<string_view> maybeaccessor = stack::get<optional<string_view>>(L, 2);
                    if (!maybeaccessor) {
                        return;
                    }
                    string_view& accessor_view = maybeaccessor.value();
                    mapping_t& mapping = umc.mapping;
                    std::vector<object>& runtime = umc.runtime;
                    int target = static_cast<int>(runtime.size());
#if defined(SOL_UNORDERED_MAP_COMPATIBLE_HASH) && SOL_UNORDERED_MAP_COMPATIBLE_HASH
                    auto preexistingit = mapping.find(accessor_view, string_view_hash(), std::equal_to<string_view>());
#else
                    std::string accessor(accessor_view.data(), accessor_view.size());
                    auto preexistingit = mapping.find(accessor);
#endif
                    if (preexistingit == mapping.cend()) {
#if defined(SOL_UNORDERED_MAP_COMPATIBLE_HASH) && SOL_UNORDERED_MAP_COMPATIBLE_HASH
                        std::string accessor(accessor_view.data(), accessor_view.size());
#endif
                        runtime.emplace_back(L, 3);
                        mapping.emplace_hint(mapping.cend(), std::move(accessor), call_information(&runtime_object_call, &runtime_new_index, target));
                    }
                    else {
                        target = preexistingit->second.runtime_target;
                        runtime[target] = object(L, 3);
                        preexistingit->second = call_information(&runtime_object_call, &runtime_new_index, target);
                    }
                };
                non_indexable();
                for (std::size_t i = 0; i < 4; lua_settop(L, 3), ++i) {
                    const char* metakey = nullptr;
                    switch (i) {
                    case 0:
                        metakey = &usertype_traits<T*>::metatable()[0];
                        luaL_getmetatable(L, metakey);
                        break;
                    case 1:
                        metakey = &usertype_traits<detail::unique_usertype<T>>::metatable()[0];
                        luaL_getmetatable(L, metakey);
                        break;
                    case 2:
                        metakey = &usertype_traits<T>::metatable()[0];
                        luaL_getmetatable(L, metakey);
                        break;
                    case 3:
                    default:
                        metakey = &usertype_traits<T>::user_metatable()[0];
                        {
                            luaL_getmetatable(L, metakey);
                            lua_getmetatable(L, -1);
                        }
                        break;
                    }
                    int tableindex = lua_gettop(L);
                    if (type_of(L, tableindex) == type::lua_nil) {
                        continue;
                    }
                    stack::set_field<false, true>(L, stack_reference(L, raw_index(2)), stack_reference(L, raw_index(3)), tableindex);
                }
                lua_settop(L, 0);
                return 0;
            }
            return indexing_fail<T, false>(L);
        }

oss_default_to_string() [1/2]

template<typename T >

int sol::usertype_detail::oss_default_to_string ( std::true_type  , lua_State *  L  )

inline

                                                                     {
            std::ostringstream oss;
            oss << stack::unqualified_get<T>(L, 1);
            return stack::push(L, oss.str());
        }

oss_default_to_string() [2/2]

template<typename T >

int sol::usertype_detail::oss_default_to_string ( std::false_type  , lua_State *  L  )

inline

                                                                      {
            return adl_default_to_string<T>(meta::supports_adl_to_string<T>(), L);
        }

runtime_new_index()

int sol::usertype_detail::runtime_new_index ( lua_State *  L, void *  , usertype_metatable_core &  umc, int  runtimetarget  )

inline

                                                                                                           {
            std::vector<object>& runtime = umc.runtime;
            object& runtimeobj = runtime[runtimetarget];
            runtimeobj = object(L, 3);
            return 0;
        }

runtime_object_call()

int sol::usertype_detail::runtime_object_call ( lua_State *  L, void *  , usertype_metatable_core &  umc, int  runtimetarget  )

inline

                                                                                                             {
            std::vector<object>& runtime = umc.runtime;
            object& runtimeobj = runtime[runtimetarget];
            return stack::push(L, runtimeobj);
        }

simple_core_indexing_call()

template<typename T , bool is_index, bool toplevel = false, bool has_indexing = false>

int sol::usertype_detail::simple_core_indexing_call ( lua_State *  L )

inline

                                                           {
            simple_map& sm = toplevel
                ? stack::get<user<simple_map>>(L, upvalue_index(simple_metatable_index))
                : stack::pop<user<simple_map>>(L);
            variable_map& variables = sm.variables;
            function_map& functions = sm.functions;
            static const int keyidx = -2 + static_cast<int>(is_index);
            if (toplevel) {
                if (type_of(L, keyidx) != type::string) {
                    if (has_indexing) {
                        object& indexingfunc = is_index
                            ? sm.index
                            : sm.newindex;
                        return call_indexing_object(L, indexingfunc);
                    }
                    else {
                        return is_index
                            ? indexing_fail<T, is_index>(L)
                            : metatable_new_index<T, true>(L);
                    }
                }
            }
            string_view accessor = stack::get<string_view>(L, keyidx);
            variable_wrapper* varwrap = nullptr;
            {
#if defined(SOL_UNORDERED_MAP_COMPATIBLE_HASH) && SOL_UNORDERED_MAP_COMPATIBLE_HASH
                string_view& accessorkey = accessor;
                auto vit = variables.find(accessorkey, string_view_hash(), std::equal_to<string_view>());
#else
                std::string accessorkey(accessor.data(), accessor.size());
                auto vit = variables.find(accessorkey);
#endif // Compatible Hash
                if (vit != variables.cend()) {
                    varwrap = vit->second.get();
                }
            }
            if (varwrap != nullptr) {
                return is_index ? varwrap->index(L) : varwrap->new_index(L);
            }
            bool function_failed = false;
            {
#if defined(SOL_UNORDERED_MAP_COMPATIBLE_HASH) && SOL_UNORDERED_MAP_COMPATIBLE_HASH
                string_view& accessorkey = accessor;
                auto fit = functions.find(accessorkey, string_view_hash(), std::equal_to<string_view>());
#else
                std::string accessorkey(accessor.data(), accessor.size());
                auto fit = functions.find(accessorkey);
#endif // Compatible Hash
                if (fit != functions.cend()) {
                    object& func = fit->second;
                    if (is_index) {
                        return stack::push(L, func);
                    }
                    else {
                        function_failed = true;
                    }
                }
            }
            if (function_failed) {
                if (has_indexing && !is_toplevel(L)) {
                    object& indexingfunc = is_index
                        ? sm.index
                        : sm.newindex;
                    return call_indexing_object(L, indexingfunc);
                }
                else {
                    return is_index
                        ? indexing_fail<T, is_index>(L)
                        : metatable_new_index<T, true>(L);
                }
            }
            /* Check table storage first for a method that works
            luaL_getmetatable(L, sm.metakey);
            if (type_of(L, -1) != type::lua_nil) {
                stack::get_field<false, true>(L, accessor.c_str(), lua_gettop(L));
                if (type_of(L, -1) != type::lua_nil) {
                    // Woo, we found it?
                    lua_remove(L, -2);
                    return 1;
                }
                lua_pop(L, 1);
            }
            lua_pop(L, 1);
            */

            int ret = 0;
            bool found = false;
            // Otherwise, we need to do propagating calls through the bases
            if (is_index) {
                sm.indexbaseclasspropogation(L, found, ret, accessor);
            }
            else {
                sm.newindexbaseclasspropogation(L, found, ret, accessor);
            }
            if (found) {
                return ret;
            }
            if (toplevel) {
                if (has_indexing && !is_toplevel(L)) {
                    object& indexingfunc = is_index
                        ? sm.index
                        : sm.newindex;
                    return call_indexing_object(L, indexingfunc);
                }
                else {
                    return is_index
                        ? indexing_fail<T, is_index>(L)
                        : metatable_new_index<T, true>(L);
                }
            }
            return -1;
        }

simple_index_call()

template<typename T , bool has_indexing = false>

int sol::usertype_detail::simple_index_call ( lua_State *  L )

inline

                                                   {
#if defined(__clang__)
            return detail::trampoline(L, &simple_real_index_call<T, has_indexing>);
#else
            return detail::typed_static_trampoline<decltype(&simple_real_index_call<T, has_indexing>), (&simple_real_index_call<T, has_indexing>)>(L);
#endif
        }

simple_new_index_call()

template<typename T , bool has_indexing = false>

int sol::usertype_detail::simple_new_index_call ( lua_State *  L )

inline

                                                       {
#if defined(__clang__)
            return detail::trampoline(L, &simple_real_new_index_call<T, has_indexing>);
#else
            return detail::typed_static_trampoline<decltype(&simple_real_new_index_call<T, has_indexing>), (&simple_real_new_index_call<T, has_indexing>)>(L);
#endif
        }

simple_real_index_call()

template<typename T , bool has_indexing = false>

int sol::usertype_detail::simple_real_index_call ( lua_State *  L )

inline

                                                        {
            return simple_core_indexing_call<T, true, true, has_indexing>(L);
        }

simple_real_new_index_call()

template<typename T , bool has_indexing = false>

int sol::usertype_detail::simple_real_new_index_call ( lua_State *  L )

inline

                                                            {
            return simple_core_indexing_call<T, false, true, has_indexing>(L);
        }

walk_all_bases()

template<bool is_index, typename... Bases>

static void sol::usertype_detail::walk_all_bases ( lua_State *  L, bool &  found, int &  ret, string_view &  accessor  )

static

                                                                                               {
            (void)L;
            (void)found;
            (void)ret;
            (void)accessor;
            (void)detail::swallow{0, (walk_single_base<is_index, Bases>(L, found, ret, accessor), 0)...};
        }

walk_single_base()

template<bool is_index, typename Base >

static void sol::usertype_detail::walk_single_base ( lua_State *  L, bool &  found, int &  ret, string_view &    )

static

                                                                                        {
            if (found)
                return;
            const char* metakey = &usertype_traits<Base>::metatable()[0];
            const char* gcmetakey = &usertype_traits<Base>::gc_table()[0];
            const char* basewalkkey = is_index ? detail::base_class_index_propogation_key() : detail::base_class_new_index_propogation_key();

            luaL_getmetatable(L, metakey);
            if (type_of(L, -1) == type::lua_nil) {
                lua_pop(L, 1);
                return;
            }

            stack::get_field(L, basewalkkey);
            if (type_of(L, -1) == type::lua_nil) {
                lua_pop(L, 2);
                return;
            }
            lua_CFunction basewalkfunc = stack::pop<lua_CFunction>(L);
            lua_pop(L, 1);

            stack::get_field<true>(L, gcmetakey);
            int value = basewalkfunc(L);
            if (value > -1) {
                found = true;
                ret = value;
            }
        }

Variable Documentation

filler_index

const int sol::usertype_detail::filler_index = 4

index_function_index

const int sol::usertype_detail::index_function_index = 3

magic_index

const int sol::usertype_detail::magic_index = 5

metatable_core_index

const int sol::usertype_detail::metatable_core_index = 3

metatable_index

const int sol::usertype_detail::metatable_index = 2

newindex_function_index

const int sol::usertype_detail::newindex_function_index = 4

simple_metatable_index

const int sol::usertype_detail::simple_metatable_index = 2

toplevel_magic

const lua_Integer sol::usertype_detail::toplevel_magic = static_cast<lua_Integer>(0xCCC2CCC1)