sol::container_usertype_metatable< X > Struct Template Reference

#include <sol.hpp>

Public Types
typedef std::remove_pointer_t< meta::unqualified_t< X > >	T
typedef container_traits< T >	traits
typedef container_detail::container_traits_default< T >	default_traits

Static Public Member Functions
static int	real_index_get_traits (std::true_type, lua_State *L)
static int	real_index_get_traits (std::false_type, lua_State *L)
static int	real_index_call (lua_State *L)
static int	real_at_traits (std::true_type, lua_State *L)
static int	real_at_traits (std::false_type, lua_State *L)
static int	real_at_call (lua_State *L)
static int	real_get_traits (std::true_type, lua_State *L)
static int	real_get_traits (std::false_type, lua_State *L)
static int	real_get_call (lua_State *L)
static int	real_set_traits (std::true_type, lua_State *L)
static int	real_set_traits (std::false_type, lua_State *L)
static int	real_set_call (lua_State *L)
static int	real_index_set_traits (std::true_type, lua_State *L)
static int	real_index_set_traits (std::false_type, lua_State *L)
static int	real_new_index_call (lua_State *L)
static int	real_pairs_traits (std::true_type, lua_State *L)
static int	real_pairs_traits (std::false_type, lua_State *L)
static int	real_pairs_call (lua_State *L)
static int	real_ipairs_traits (std::true_type, lua_State *L)
static int	real_ipairs_traits (std::false_type, lua_State *L)
static int	real_ipairs_call (lua_State *L)
static int	real_next_traits (std::true_type, lua_State *L)
static int	real_next_traits (std::false_type, lua_State *L)
static int	real_next_call (lua_State *L)
static int	real_size_traits (std::true_type, lua_State *L)
static int	real_size_traits (std::false_type, lua_State *L)
static int	real_length_call (lua_State *L)
static int	real_add_traits (std::true_type, lua_State *L)
static int	real_add_traits (std::false_type, lua_State *L)
static int	real_add_call (lua_State *L)
static int	real_insert_traits (std::true_type, lua_State *L)
static int	real_insert_traits (std::false_type, lua_State *L)
static int	real_insert_call (lua_State *L)
static int	real_clear_traits (std::true_type, lua_State *L)
static int	real_clear_traits (std::false_type, lua_State *L)
static int	real_clear_call (lua_State *L)
static int	real_empty_traits (std::true_type, lua_State *L)
static int	real_empty_traits (std::false_type, lua_State *L)
static int	real_empty_call (lua_State *L)
static int	real_erase_traits (std::true_type, lua_State *L)
static int	real_erase_traits (std::false_type, lua_State *L)
static int	real_erase_call (lua_State *L)
static int	real_find_traits (std::true_type, lua_State *L)
static int	real_find_traits (std::false_type, lua_State *L)
static int	real_find_call (lua_State *L)
static int	add_call (lua_State *L)
static int	erase_call (lua_State *L)
static int	insert_call (lua_State *L)
static int	clear_call (lua_State *L)
static int	empty_call (lua_State *L)
static int	find_call (lua_State *L)
static int	length_call (lua_State *L)
static int	pairs_call (lua_State *L)
static int	ipairs_call (lua_State *L)
static int	next_call (lua_State *L)
static int	at_call (lua_State *L)
static int	get_call (lua_State *L)
static int	set_call (lua_State *L)
static int	index_call (lua_State *L)
static int	new_index_call (lua_State *L)

Member Typedef Documentation

default_traits

template<typename X >

typedef container_detail::container_traits_default<T> sol::container_usertype_metatable< X >::default_traits

T

template<typename X >

typedef std::remove_pointer_t<meta::unqualified_t<X> > sol::container_usertype_metatable< X >::T

traits

template<typename X >

typedef container_traits<T> sol::container_usertype_metatable< X >::traits

Member Function Documentation

add_call()

template<typename X >

static int sol::container_usertype_metatable< X >::add_call ( lua_State *  L )

inlinestatic

                                          {
            return detail::typed_static_trampoline<decltype(&real_add_call), (&real_add_call)>(L);
        }

at_call()

template<typename X >

static int sol::container_usertype_metatable< X >::at_call ( lua_State *  L )

inlinestatic

                                         {
            return detail::typed_static_trampoline<decltype(&real_at_call), (&real_at_call)>(L);
        }

clear_call()

template<typename X >

static int sol::container_usertype_metatable< X >::clear_call ( lua_State *  L )

inlinestatic

                                            {
            return detail::typed_static_trampoline<decltype(&real_clear_call), (&real_clear_call)>(L);
        }

empty_call()

template<typename X >

static int sol::container_usertype_metatable< X >::empty_call ( lua_State *  L )

inlinestatic

                                            {
            return detail::typed_static_trampoline<decltype(&real_empty_call), (&real_empty_call)>(L);
        }

erase_call()

template<typename X >

static int sol::container_usertype_metatable< X >::erase_call ( lua_State *  L )

inlinestatic

                                            {
            return detail::typed_static_trampoline<decltype(&real_erase_call), (&real_erase_call)>(L);
        }

find_call()

template<typename X >

static int sol::container_usertype_metatable< X >::find_call ( lua_State *  L )

inlinestatic

                                           {
            return detail::typed_static_trampoline<decltype(&real_find_call), (&real_find_call)>(L);
        }

get_call()

template<typename X >

static int sol::container_usertype_metatable< X >::get_call ( lua_State *  L )

inlinestatic

                                          {
            return detail::typed_static_trampoline<decltype(&real_get_call), (&real_get_call)>(L);
        }

index_call()

template<typename X >

static int sol::container_usertype_metatable< X >::index_call ( lua_State *  L )

inlinestatic

                                            {
            return detail::typed_static_trampoline<decltype(&real_index_call), (&real_index_call)>(L);
        }

insert_call()

template<typename X >

static int sol::container_usertype_metatable< X >::insert_call ( lua_State *  L )

inlinestatic

                                             {
            return detail::typed_static_trampoline<decltype(&real_insert_call), (&real_insert_call)>(L);
        }

ipairs_call()

template<typename X >

static int sol::container_usertype_metatable< X >::ipairs_call ( lua_State *  L )

inlinestatic

                                             {
            return detail::typed_static_trampoline<decltype(&real_ipairs_call), (&real_ipairs_call)>(L);
        }

length_call()

template<typename X >

static int sol::container_usertype_metatable< X >::length_call ( lua_State *  L )

inlinestatic

                                             {
            return detail::typed_static_trampoline<decltype(&real_length_call), (&real_length_call)>(L);
        }

new_index_call()

template<typename X >

static int sol::container_usertype_metatable< X >::new_index_call ( lua_State *  L )

inlinestatic

                                                {
            return detail::typed_static_trampoline<decltype(&real_new_index_call), (&real_new_index_call)>(L);
        }

next_call()

template<typename X >

static int sol::container_usertype_metatable< X >::next_call ( lua_State *  L )

inlinestatic

                                           {
            return detail::typed_static_trampoline<decltype(&real_next_call), (&real_next_call)>(L);
        }

pairs_call()

template<typename X >

static int sol::container_usertype_metatable< X >::pairs_call ( lua_State *  L )

inlinestatic

                                            {
            return detail::typed_static_trampoline<decltype(&real_pairs_call), (&real_pairs_call)>(L);
        }

real_add_call()

template<typename X >

static int sol::container_usertype_metatable< X >::real_add_call ( lua_State *  L )

inlinestatic

                                               {
            return real_add_traits(container_detail::has_traits_add<traits>(), L);
        }

real_add_traits() [1/2]

template<typename X >

static int sol::container_usertype_metatable< X >::real_add_traits ( std::true_type  , lua_State *  L  )

inlinestatic

                                                               {
            return traits::add(L);
        }

real_add_traits() [2/2]

template<typename X >

static int sol::container_usertype_metatable< X >::real_add_traits ( std::false_type  , lua_State *  L  )

inlinestatic

                                                                {
            return default_traits::add(L);
        }

real_at_call()

template<typename X >

static int sol::container_usertype_metatable< X >::real_at_call ( lua_State *  L )

inlinestatic

                                              {
            return real_at_traits(container_detail::has_traits_at<traits>(), L);
        }

real_at_traits() [1/2]

template<typename X >

static int sol::container_usertype_metatable< X >::real_at_traits ( std::true_type  , lua_State *  L  )

inlinestatic

                                                              {
            return traits::at(L);
        }

real_at_traits() [2/2]

template<typename X >

static int sol::container_usertype_metatable< X >::real_at_traits ( std::false_type  , lua_State *  L  )

inlinestatic

                                                               {
            return default_traits::at(L);
        }

real_clear_call()

template<typename X >

static int sol::container_usertype_metatable< X >::real_clear_call ( lua_State *  L )

inlinestatic

                                                 {
            return real_clear_traits(container_detail::has_traits_clear<traits>(), L);
        }

real_clear_traits() [1/2]

template<typename X >

static int sol::container_usertype_metatable< X >::real_clear_traits ( std::true_type  , lua_State *  L  )

inlinestatic

                                                                 {
            return traits::clear(L);
        }

real_clear_traits() [2/2]

template<typename X >

static int sol::container_usertype_metatable< X >::real_clear_traits ( std::false_type  , lua_State *  L  )

inlinestatic

                                                                  {
            return default_traits::clear(L);
        }

real_empty_call()

template<typename X >

static int sol::container_usertype_metatable< X >::real_empty_call ( lua_State *  L )

inlinestatic

                                                 {
            return real_empty_traits(container_detail::has_traits_empty<traits>(), L);
        }

real_empty_traits() [1/2]

template<typename X >

static int sol::container_usertype_metatable< X >::real_empty_traits ( std::true_type  , lua_State *  L  )

inlinestatic

                                                                 {
            return traits::empty(L);
        }

real_empty_traits() [2/2]

template<typename X >

static int sol::container_usertype_metatable< X >::real_empty_traits ( std::false_type  , lua_State *  L  )

inlinestatic

                                                                  {
            return default_traits::empty(L);
        }

real_erase_call()

template<typename X >

static int sol::container_usertype_metatable< X >::real_erase_call ( lua_State *  L )

inlinestatic

                                                 {
            return real_erase_traits(container_detail::has_traits_erase<traits>(), L);
        }

real_erase_traits() [1/2]

template<typename X >

static int sol::container_usertype_metatable< X >::real_erase_traits ( std::true_type  , lua_State *  L  )

inlinestatic

                                                                 {
            return traits::erase(L);
        }

real_erase_traits() [2/2]

template<typename X >

static int sol::container_usertype_metatable< X >::real_erase_traits ( std::false_type  , lua_State *  L  )

inlinestatic

                                                                  {
            return default_traits::erase(L);
        }

real_find_call()

template<typename X >

static int sol::container_usertype_metatable< X >::real_find_call ( lua_State *  L )

inlinestatic

                                                {
            return real_find_traits(container_detail::has_traits_find<traits>(), L);
        }

real_find_traits() [1/2]

template<typename X >

static int sol::container_usertype_metatable< X >::real_find_traits ( std::true_type  , lua_State *  L  )

inlinestatic

                                                                {
            return traits::find(L);
        }

real_find_traits() [2/2]

template<typename X >

static int sol::container_usertype_metatable< X >::real_find_traits ( std::false_type  , lua_State *  L  )

inlinestatic

                                                                 {
            return default_traits::find(L);
        }

real_get_call()

template<typename X >

static int sol::container_usertype_metatable< X >::real_get_call ( lua_State *  L )

inlinestatic

                                               {
            return real_get_traits(container_detail::has_traits_get<traits>(), L);
        }

real_get_traits() [1/2]

template<typename X >

static int sol::container_usertype_metatable< X >::real_get_traits ( std::true_type  , lua_State *  L  )

inlinestatic

                                                               {
            return traits::get(L);
        }

real_get_traits() [2/2]

template<typename X >

static int sol::container_usertype_metatable< X >::real_get_traits ( std::false_type  , lua_State *  L  )

inlinestatic

                                                                {
            return default_traits::get(L);
        }

real_index_call()

template<typename X >

static int sol::container_usertype_metatable< X >::real_index_call ( lua_State *  L )

inlinestatic

                                                 {
            typedef usertype_detail::map_t<std::string, lua_CFunction> call_map;
            static const call_map calls{
                { "at", &at_call },
                { "get", &real_get_call },
                { "set", &real_set_call },
                { "size", &real_length_call },
                { "add", &real_add_call },
                { "empty", &real_empty_call },
                { "insert", &real_insert_call },
                { "clear", &real_clear_call },
                { "find", &real_find_call },
                { "erase", &real_erase_call },
                { "pairs", &pairs_call },
                { "next", &next_call },
            };
            auto maybenameview = stack::unqualified_check_get<string_view>(L, 2);
            if (maybenameview) {
                const string_view& nameview = *maybenameview;
#if defined(SOL_UNORDERED_MAP_COMPATIBLE_HASH) && SOL_UNORDERED_MAP_COMPATIBLE_HASH
                auto it = calls.find(nameview, string_view_hash(), std::equal_to<string_view>());
#else
                std::string name(nameview.data(), nameview.size());
                auto it = calls.find(name);
#endif
                if (it != calls.cend()) {
                    return stack::push(L, it->second);
                }
            }
            return real_index_get_traits(container_detail::has_traits_index_get<traits>(), L);
        }

real_index_get_traits() [1/2]

template<typename X >

static int sol::container_usertype_metatable< X >::real_index_get_traits ( std::true_type  , lua_State *  L  )

inlinestatic

                                                                     {
            return traits::index_get(L);
        }

real_index_get_traits() [2/2]

template<typename X >

static int sol::container_usertype_metatable< X >::real_index_get_traits ( std::false_type  , lua_State *  L  )

inlinestatic

                                                                      {
            return default_traits::index_get(L);
        }

real_index_set_traits() [1/2]

template<typename X >

static int sol::container_usertype_metatable< X >::real_index_set_traits ( std::true_type  , lua_State *  L  )

inlinestatic

                                                                     {
            return traits::index_set(L);
        }

real_index_set_traits() [2/2]

template<typename X >

static int sol::container_usertype_metatable< X >::real_index_set_traits ( std::false_type  , lua_State *  L  )

inlinestatic

                                                                      {
            return default_traits::index_set(L);
        }

real_insert_call()

template<typename X >

static int sol::container_usertype_metatable< X >::real_insert_call ( lua_State *  L )

inlinestatic

                                                  {
            return real_insert_traits(container_detail::has_traits_insert<traits>(), L);
        }

real_insert_traits() [1/2]

template<typename X >

static int sol::container_usertype_metatable< X >::real_insert_traits ( std::true_type  , lua_State *  L  )

inlinestatic

                                                                  {
            return traits::insert(L);
        }

real_insert_traits() [2/2]

template<typename X >

static int sol::container_usertype_metatable< X >::real_insert_traits ( std::false_type  , lua_State *  L  )

inlinestatic

                                                                   {
            return default_traits::insert(L);
        }

real_ipairs_call()

template<typename X >

static int sol::container_usertype_metatable< X >::real_ipairs_call ( lua_State *  L )

inlinestatic

                                                  {
            return real_ipairs_traits(container_detail::has_traits_ipairs<traits>(), L);
        }

real_ipairs_traits() [1/2]

template<typename X >

static int sol::container_usertype_metatable< X >::real_ipairs_traits ( std::true_type  , lua_State *  L  )

inlinestatic

                                                                  {
            return traits::ipairs(L);
        }

real_ipairs_traits() [2/2]

template<typename X >

static int sol::container_usertype_metatable< X >::real_ipairs_traits ( std::false_type  , lua_State *  L  )

inlinestatic

                                                                   {
            return default_traits::ipairs(L);
        }

real_length_call()

template<typename X >

static int sol::container_usertype_metatable< X >::real_length_call ( lua_State *  L )

inlinestatic

                                                  {
            return real_size_traits(container_detail::has_traits_size<traits>(), L);
        }

real_new_index_call()

template<typename X >

static int sol::container_usertype_metatable< X >::real_new_index_call ( lua_State *  L )

inlinestatic

                                                     {
            return real_index_set_traits(container_detail::has_traits_index_set<traits>(), L);
        }

real_next_call()

template<typename X >

static int sol::container_usertype_metatable< X >::real_next_call ( lua_State *  L )

inlinestatic

                                                {
            return real_next_traits(container_detail::has_traits_next<traits>(), L);
        }

real_next_traits() [1/2]

template<typename X >

static int sol::container_usertype_metatable< X >::real_next_traits ( std::true_type  , lua_State *  L  )

inlinestatic

                                                                {
            return traits::next(L);
        }

real_next_traits() [2/2]

template<typename X >

static int sol::container_usertype_metatable< X >::real_next_traits ( std::false_type  , lua_State *  L  )

inlinestatic

                                                                 {
            return default_traits::next(L);
        }

real_pairs_call()

template<typename X >

static int sol::container_usertype_metatable< X >::real_pairs_call ( lua_State *  L )

inlinestatic

                                                 {
            return real_pairs_traits(container_detail::has_traits_pairs<traits>(), L);
        }

real_pairs_traits() [1/2]

template<typename X >

static int sol::container_usertype_metatable< X >::real_pairs_traits ( std::true_type  , lua_State *  L  )

inlinestatic

                                                                 {
            return traits::pairs(L);
        }

real_pairs_traits() [2/2]

template<typename X >

static int sol::container_usertype_metatable< X >::real_pairs_traits ( std::false_type  , lua_State *  L  )

inlinestatic

                                                                  {
            return default_traits::pairs(L);
        }

real_set_call()

template<typename X >

static int sol::container_usertype_metatable< X >::real_set_call ( lua_State *  L )

inlinestatic

                                               {
            return real_set_traits(container_detail::has_traits_set<traits>(), L);
        }

real_set_traits() [1/2]

template<typename X >

static int sol::container_usertype_metatable< X >::real_set_traits ( std::true_type  , lua_State *  L  )

inlinestatic

                                                               {
            return traits::set(L);
        }

real_set_traits() [2/2]

template<typename X >

static int sol::container_usertype_metatable< X >::real_set_traits ( std::false_type  , lua_State *  L  )

inlinestatic

                                                                {
            return default_traits::set(L);
        }

real_size_traits() [1/2]

template<typename X >

static int sol::container_usertype_metatable< X >::real_size_traits ( std::true_type  , lua_State *  L  )

inlinestatic

                                                                {
            return traits::size(L);
        }

real_size_traits() [2/2]

template<typename X >

static int sol::container_usertype_metatable< X >::real_size_traits ( std::false_type  , lua_State *  L  )

inlinestatic

                                                                 {
            return default_traits::size(L);
        }

set_call()

template<typename X >

static int sol::container_usertype_metatable< X >::set_call ( lua_State *  L )

inlinestatic

                                          {
            return detail::typed_static_trampoline<decltype(&real_set_call), (&real_set_call)>(L);
        }

---

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

• external/sol.hpp