sol::container_detail Namespace Reference

Classes
struct	container_decay
struct	container_decay< as_container_t< T > >
struct	container_traits_default
struct	container_traits_default< container_traits< X > >
struct	container_traits_default< X, std::enable_if_t< meta::all< is_forced_container< meta::unqualified_t< X > >, meta::has_value_type< meta::unqualified_t< container_decay_t< X > > >, meta::has_iterator< meta::unqualified_t< container_decay_t< X > > > >::value > >
struct	container_traits_default< X, std::enable_if_t< std::is_array< std::remove_pointer_t< meta::unwrap_unqualified_t< X > > >::value > >
struct	error_result
struct	has_clear_test
struct	has_empty_test
struct	has_erase_after_test
struct	has_erase_test
struct	has_find_test
struct	has_find_test< T, std::enable_if_t< meta::is_lookup< T >::value > >
struct	has_traits_add_test
struct	has_traits_at_test
struct	has_traits_erase_test
struct	has_traits_find_test
struct	has_traits_get_test
struct	has_traits_index_get_test
struct	has_traits_index_set_test
struct	has_traits_insert_test
struct	has_traits_ipairs_test
struct	has_traits_next_test
struct	has_traits_pairs_test
struct	has_traits_set_test
struct	has_traits_size_test
struct	is_forced_container
struct	is_forced_container< as_container_t< T > >

Typedefs
template<typename T >
using	has_clear = meta::boolean< has_clear_test< T >::value >
template<typename T >
using	has_empty = meta::boolean< has_empty_test< T >::value >
template<typename T >
using	has_find = meta::boolean< has_find_test< T >::value >
template<typename T >
using	has_erase = meta::boolean< has_erase_test< T >::value >
template<typename T >
using	has_erase_after = meta::boolean< has_erase_after_test< T >::value >
template<typename T >
using	has_traits_get = meta::boolean< has_traits_get_test< T >::value >
template<typename T >
using	has_traits_at = meta::boolean< has_traits_at_test< T >::value >
template<typename T >
using	has_traits_set = meta::boolean< has_traits_set_test< T >::value >
template<typename T >
using	has_traits_index_get = meta::boolean< has_traits_index_get_test< T >::value >
template<typename T >
using	has_traits_index_set = meta::boolean< has_traits_index_set_test< T >::value >
template<typename T >
using	has_traits_pairs = meta::boolean< has_traits_pairs_test< T >::value >
template<typename T >
using	has_traits_ipairs = meta::boolean< has_traits_ipairs_test< T >::value >
template<typename T >
using	has_traits_next = meta::boolean< has_traits_next_test< T >::value >
template<typename T >
using	has_traits_add = meta::boolean< has_traits_add_test< T >::value >
template<typename T >
using	has_traits_size = meta::boolean< has_traits_size_test< T >::value >
template<typename T >
using	has_traits_clear = has_clear< T >
template<typename T >
using	has_traits_empty = has_empty< T >
template<typename T >
using	has_traits_find = meta::boolean< has_traits_find_test< T >::value >
template<typename T >
using	has_traits_insert = meta::boolean< has_traits_insert_test< T >::value >
template<typename T >
using	has_traits_erase = meta::boolean< has_traits_erase_test< T >::value >
template<typename T >
using	container_decay_t = typename container_decay< meta::unqualified_t< T >>::type

Functions
template<typename T >
decltype(auto)	get_key (std::false_type, T &&t)
template<typename T >
decltype(auto)	get_key (std::true_type, T &&t)
template<typename T >
decltype(auto)	get_value (std::false_type, T &&t)
template<typename T >
decltype(auto)	get_value (std::true_type, T &&t)
int	handle_errors (lua_State *L, const error_result &er)

Typedef Documentation

container_decay_t

template<typename T >

using sol::container_detail::container_decay_t = typedef typename container_decay<meta::unqualified_t<T>>::type

has_clear

template<typename T >

using sol::container_detail::has_clear = typedef meta::boolean<has_clear_test<T>::value>

has_empty

template<typename T >

using sol::container_detail::has_empty = typedef meta::boolean<has_empty_test<T>::value>

has_erase

template<typename T >

using sol::container_detail::has_erase = typedef meta::boolean<has_erase_test<T>::value>

has_erase_after

template<typename T >

using sol::container_detail::has_erase_after = typedef meta::boolean<has_erase_after_test<T>::value>

has_find

template<typename T >

using sol::container_detail::has_find = typedef meta::boolean<has_find_test<T>::value>

has_traits_add

template<typename T >

using sol::container_detail::has_traits_add = typedef meta::boolean<has_traits_add_test<T>::value>

has_traits_at

template<typename T >

using sol::container_detail::has_traits_at = typedef meta::boolean<has_traits_at_test<T>::value>

has_traits_clear

template<typename T >

using sol::container_detail::has_traits_clear = typedef has_clear<T>

has_traits_empty

template<typename T >

using sol::container_detail::has_traits_empty = typedef has_empty<T>

has_traits_erase

template<typename T >

using sol::container_detail::has_traits_erase = typedef meta::boolean<has_traits_erase_test<T>::value>

has_traits_find

template<typename T >

using sol::container_detail::has_traits_find = typedef meta::boolean<has_traits_find_test<T>::value>

has_traits_get

template<typename T >

using sol::container_detail::has_traits_get = typedef meta::boolean<has_traits_get_test<T>::value>

has_traits_index_get

template<typename T >

using sol::container_detail::has_traits_index_get = typedef meta::boolean<has_traits_index_get_test<T>::value>

has_traits_index_set

template<typename T >

using sol::container_detail::has_traits_index_set = typedef meta::boolean<has_traits_index_set_test<T>::value>

has_traits_insert

template<typename T >

using sol::container_detail::has_traits_insert = typedef meta::boolean<has_traits_insert_test<T>::value>

has_traits_ipairs

template<typename T >

using sol::container_detail::has_traits_ipairs = typedef meta::boolean<has_traits_ipairs_test<T>::value>

has_traits_next

template<typename T >

using sol::container_detail::has_traits_next = typedef meta::boolean<has_traits_next_test<T>::value>

has_traits_pairs

template<typename T >

using sol::container_detail::has_traits_pairs = typedef meta::boolean<has_traits_pairs_test<T>::value>

has_traits_set

template<typename T >

using sol::container_detail::has_traits_set = typedef meta::boolean<has_traits_set_test<T>::value>

has_traits_size

template<typename T >

using sol::container_detail::has_traits_size = typedef meta::boolean<has_traits_size_test<T>::value>

Function Documentation

get_key() [1/2]

template<typename T >

decltype(auto) sol::container_detail::get_key	(	std::false_type	,
		T &&	t
	)

                                                     {
            return std::forward<T>(t);
        }

get_key() [2/2]

template<typename T >

decltype(auto) sol::container_detail::get_key	(	std::true_type	,
		T &&	t
	)

                                                    {
            return t.first;
        }

get_value() [1/2]

template<typename T >

decltype(auto) sol::container_detail::get_value	(	std::false_type	,
		T &&	t
	)

                                                       {
            return std::forward<T>(t);
        }

get_value() [2/2]

template<typename T >

decltype(auto) sol::container_detail::get_value	(	std::true_type	,
		T &&	t
	)

                                                      {
            return t.second;
        }

handle_errors()

int sol::container_detail::handle_errors ( lua_State *  L, const error_result &  er  )

inline

                                                                       {
            if (er.fmt_ == nullptr) {
                return er.results;
            }
            return luaL_error(L, er.fmt_, er.args[0], er.args[1], er.args[2], er.args[3]);
        }