sol::detail Namespace Reference

Classes
struct	accumulate
struct	accumulate< C, v, V, T, Args... >
struct	accumulate_list
struct	accumulate_list< C, v, V, types< Args... > >
struct	add_destructor_tag
struct	as_pointer_tag
struct	as_reference_tag
struct	as_table_tag
struct	as_value_tag
struct	check_destructor_tag
struct	clean
struct	default_construct
struct	default_destruct
struct	deleter
struct	deprecate_type
struct	direct_error_tag
struct	filter_base_tag
struct	global_tag
struct	has_derived
struct	has_internal_marker
struct	has_internal_marker_impl
struct	has_internal_marker_impl< T, typename void_< typename T::SOL_INTERNAL_UNSPECIALIZED_MARKER_ >::type >
struct	implicit_wrapper
struct	in_place_of_i
struct	in_place_of_t
struct	in_place_of_tag
struct	inheritance
struct	is_constructor
struct	is_constructor< factory_wrapper< Args... > >
struct	is_constructor< filter_wrapper< F, Filters... > >
struct	is_constructor< protect_t< T > >
struct	is_container
struct	is_container< std::initializer_list< T > >
struct	is_container< T, std::enable_if_t< meta::all< meta::has_begin_end< meta::unqualified_t< T > >, meta::neg< is_initializer_list< meta::unqualified_t< T > > >, meta::neg< meta::is_string_like< meta::unqualified_t< T > > > >::value > >
struct	is_container< T, std::enable_if_t< meta::all< std::is_array< meta::unqualified_t< T > >, meta::neg< meta::any_same< std::remove_all_extents_t< meta::unqualified_t< T > >, char, wchar_t, char16_t, char32_t > > >::value > >
struct	is_container< T, std::enable_if_t< meta::is_string_like< meta::unqualified_t< T > >::value > >
struct	is_destructor
struct	is_destructor< destructor_wrapper< Fx > >
struct	is_initializer_list
struct	is_initializer_list< std::initializer_list< T > >
struct	is_non_factory_constructor
struct	is_non_factory_constructor< constructor_wrapper< Args... > >
struct	is_non_factory_constructor< constructors< Args... > >
struct	is_non_factory_constructor< no_construction >
struct	is_pointer_like
struct	is_pointer_like< std::shared_ptr< T > >
struct	is_pointer_like< std::unique_ptr< T, D > >
struct	is_speshul
struct	is_speshul< protected_function_result >
struct	is_speshul< unsafe_function_result >
struct	lua_type_of
struct	lua_type_of< as_table_t< T > >
struct	lua_type_of< basic_coroutine< Base > >
struct	lua_type_of< basic_environment< B > >
struct	lua_type_of< basic_function< Base, aligned > >
struct	lua_type_of< basic_lightuserdata< Base > >
struct	lua_type_of< basic_object< Base > >
struct	lua_type_of< basic_protected_function< Base, aligned, Handler > >
struct	lua_type_of< basic_reference< b > >
struct	lua_type_of< basic_string_view< C, T > >
struct	lua_type_of< basic_table_core< b, Base > >
struct	lua_type_of< basic_thread< Base > >
struct	lua_type_of< basic_userdata< Base > >
struct	lua_type_of< bool >
struct	lua_type_of< char >
struct	lua_type_of< char16_t >
struct	lua_type_of< char16_t[N]>
struct	lua_type_of< char32_t >
struct	lua_type_of< char32_t[N]>
struct	lua_type_of< char[N]>
struct	lua_type_of< const char * >
struct	lua_type_of< const char16_t * >
struct	lua_type_of< const char32_t * >
struct	lua_type_of< const void * >
struct	lua_type_of< detail::non_lua_nil_t >
struct	lua_type_of< env_t >
struct	lua_type_of< error >
struct	lua_type_of< light< T > >
struct	lua_type_of< lightuserdata_value >
struct	lua_type_of< lua_CFunction >
struct	lua_type_of< lua_nil_t >
struct	lua_type_of< meta_function >
struct	lua_type_of< metatable_t >
struct	lua_type_of< nested< T >, std::enable_if_t<!::sol::is_container< T >::value > >
struct	lua_type_of< nested< T >, std::enable_if_t<::sol::is_container< T >::value > >
struct	lua_type_of< new_table >
struct	lua_type_of< nullopt_t >
struct	lua_type_of< optional< T > >
struct	lua_type_of< stack_count >
struct	lua_type_of< stack_reference >
struct	lua_type_of< std::basic_string< C, T, A > >
struct	lua_type_of< std::function< Signature > >
struct	lua_type_of< std::initializer_list< T > >
struct	lua_type_of< std::nullptr_t >
struct	lua_type_of< std::pair< A, B > >
struct	lua_type_of< std::remove_pointer_t< lua_CFunction > >
struct	lua_type_of< std::tuple< Args... > >
struct	lua_type_of< T * >
struct	lua_type_of< T, std::enable_if_t< std::is_arithmetic< T >::value > >
struct	lua_type_of< T, std::enable_if_t< std::is_enum< T >::value > >
struct	lua_type_of< this_environment >
struct	lua_type_of< this_main_state >
struct	lua_type_of< this_state >
struct	lua_type_of< type >
struct	lua_type_of< user< T > >
struct	lua_type_of< userdata_value >
struct	lua_type_of< variadic_args >
struct	lua_type_of< variadic_results >
struct	lua_type_of< void * >
struct	lua_type_of< wchar_t >
struct	lua_type_of< wchar_t[N]>
struct	no_safety_tag
struct	non_lua_nil_t
struct	protected_handler
struct	ref_clean
struct	state_deleter
struct	tagged
struct	unchecked_t
struct	unique_usertype
struct	verified_tag
struct	void_
struct	yield_tag_t

Typedefs
using	swallow = std::initializer_list< int >
typedef int(*	lua_CFunction_noexcept) (lua_State *L)
template<typename... Args>
using	has_constructor = meta::any< is_constructor< meta::unqualified_t< Args >>... >
template<typename... Args>
using	has_destructor = meta::any< is_destructor< meta::unqualified_t< Args >>... >
using	inheritance_check_function = decltype(&inheritance< void >::type_check)
using	inheritance_cast_function = decltype(&inheritance< void >::type_cast)
using	inheritance_unique_cast_function = decltype(&inheritance< void >::type_unique_cast< void >)
using	unique_destructor = void(*)(void *)
using	unique_tag = const char *
using	typical_chunk_name_t = char[32]
template<typename T >
using	array_return_type = std::conditional_t< std::is_array< T >::value, std::add_lvalue_reference_t< T >, T >

Functions
template<std::size_t I, typename Tuple >
decltype(auto)	forward_get (Tuple &&tuple)
template<std::size_t... I, typename Tuple >
auto	forward_tuple_impl (std::index_sequence< I... >, Tuple &&tuple) -> decltype(std::tuple< decltype(forward_get< I >(tuple))... >(forward_get< I >(tuple)...))
template<typename Tuple >
auto	forward_tuple (Tuple &&tuple)
template<typename T >
auto	unwrap (T &&item) -> decltype(std::forward< T >(item))
template<typename T >
T &	unwrap (std::reference_wrapper< T > arg)
template<typename T , meta::enable< meta::neg< is_pointer_like< meta::unqualified_t< T >>>> = meta::enabler>
auto	deref (T &&item) -> decltype(std::forward< T >(item))
template<typename T , meta::disable< is_pointer_like< meta::unqualified_t< T >>, meta::neg< std::is_pointer< meta::unqualified_t< T >>>> = meta::enabler>
auto	deref_non_pointer (T &&item) -> decltype(std::forward< T >(item))
template<typename T >
T *	ptr (T &val)
template<typename T >
T *	ptr (std::reference_wrapper< T > val)
template<typename T >
T *	ptr (T *val)
template<typename T , typename Dx , typename... Args>
std::unique_ptr< T, Dx >	make_unique_deleter (Args &&... args)
const char(&	default_exception_handler_name ())[11]
int	default_exception_handler (lua_State *L, optional< const std::exception &>, string_view what)
int	call_exception_handler (lua_State *L, optional< const std::exception &> maybe_ex, string_view what)
template<lua_CFunction f>
int	static_trampoline (lua_State *L)
template<lua_CFunction f>
int	static_trampoline_noexcept (lua_State *L) noexcept
template<typename Fx , typename... Args>
int	trampoline (lua_State *L, Fx &&f, Args &&... args)
int	c_trampoline (lua_State *L, lua_CFunction f)
template<typename F , F fx>
int	typed_static_trampoline_raw (std::true_type, lua_State *L)
template<typename F , F fx>
int	typed_static_trampoline_raw (std::false_type, lua_State *L)
template<typename F , F fx>
int	typed_static_trampoline (lua_State *L)
template<typename T >
std::string	demangle_once ()
template<typename T >
std::string	short_demangle_once ()
template<typename T >
const std::string &	demangle ()
template<typename T >
const std::string &	short_demangle ()
decltype(auto)	base_class_check_key ()
decltype(auto)	base_class_cast_key ()
decltype(auto)	base_class_index_propogation_key ()
decltype(auto)	base_class_new_index_propogation_key ()
bool	xmovable (lua_State *leftL, lua_State *rightL)
const char(&	default_main_thread_name ())[9]
template<bool b>
lua_State *	pick_main_thread (lua_State *L, lua_State *backup_if_unsupported=nullptr)
void	stack_fail (int, int)
void *	align (std::size_t alignment, std::size_t size, void *&ptr, std::size_t &space, std::size_t &required_space)
void *	align (std::size_t alignment, std::size_t size, void *&ptr, std::size_t &space)
template<typename... Args>
std::size_t	aligned_space_for (void *alignment=nullptr)
void *	align_usertype_pointer (void *ptr)
template<bool pre_aligned = false>
void *	align_usertype_unique_destructor (void *ptr)
template<bool pre_aligned = false>
void *	align_usertype_unique_tag (void *ptr)
template<typename T , bool pre_aligned = false>
void *	align_usertype_unique (void *ptr)
template<typename T >
void *	align_user (void *ptr)
template<typename T >
T **	usertype_allocate_pointer (lua_State *L)
template<typename T >
T *	usertype_allocate (lua_State *L)
template<typename T , typename Real >
Real *	usertype_unique_allocate (lua_State *L, T **&pref, unique_destructor *&dx, unique_tag *&id)
template<typename T >
T *	user_allocate (lua_State *L)
template<typename T >
int	usertype_alloc_destruct (lua_State *L)
template<typename T >
int	unique_destruct (lua_State *L)
template<typename T >
int	user_alloc_destruct (lua_State *L)
template<typename T , typename Real >
void	usertype_unique_alloc_destroy (void *memory)
template<typename T >
int	cannot_destruct (lua_State *L)
template<typename T >
void	reserve (T &, std::size_t)
template<typename T , typename Al >
void	reserve (std::vector< T, Al > &arr, std::size_t hint)
template<typename T , typename Tr , typename Al >
void	reserve (std::basic_string< T, Tr, Al > &arr, std::size_t hint)
const std::string &	default_chunk_name ()
template<std::size_t N>
const char *	make_chunk_name (const string_view &code, const std::string &chunkname, char(&basechunkname)[N])
template<std::size_t I, typename... Args, typename T >
stack_proxy	get (types< Args... >, index_value< 0 >, index_value< I >, const T &fr)
template<std::size_t I, std::size_t N, typename Arg , typename... Args, typename T , meta::enable< meta::boolean<(N > 0)> >
stack_proxy	get (types< Arg, Args... >, index_value< N >, index_value< I >, const T &fr)
template<typename R , typename... Args, typename F , typename = std::result_of_t<meta::unqualified_t<F>(Args...)>>
constexpr auto	resolve_i (types< R(Args...)>, F &&) -> R(meta::unqualified_t< F >::*)(Args...)
template<typename F , typename U = meta::unqualified_t<F>>
constexpr auto	resolve_f (std::true_type, F &&f) -> decltype(resolve_i(types< meta::function_signature_t< decltype(&U::operator())>>(), std::forward< F >(f)))
template<typename F >
constexpr void	resolve_f (std::false_type, F &&)
template<typename F , typename U = meta::unqualified_t<F>>
constexpr auto	resolve_i (types<>, F &&f) -> decltype(resolve_f(meta::has_deducible_signature< U >(), std::forward< F >(f)))
template<typename... Args, typename F , typename R = std::result_of_t<F&(Args...)>>
constexpr auto	resolve_i (types< Args... >, F &&f) -> decltype(resolve_i(types< R(Args...)>(), std::forward< F >(f)))
template<typename Sig , typename C >
constexpr Sig C::*	resolve_v (std::false_type, Sig C::*mem_func_ptr)
template<typename Sig , typename C >
constexpr Sig C::*	resolve_v (std::true_type, Sig C::*mem_variable_ptr)
const char(&	default_handler_name ())[9]
template<typename base_t , typename T >
basic_function< base_t >	force_cast (T &p)
template<typename Reference , bool is_main_ref = false>
static Reference	get_default_handler (lua_State *L)
template<typename T >
static void	set_default_handler (lua_State *L, const T &ref)
int	fail_on_newindex (lua_State *L)

Variables
const auto	direct_error = direct_error_tag{}
const bool	default_safe_function_calls
const unchecked_t	unchecked = unchecked_t{}
const yield_tag_t	yield_tag = yield_tag_t{}
struct sol::detail::verified_tag	verified
struct sol::detail::global_tag	global_
struct sol::detail::no_safety_tag	no_safety

Typedef Documentation

array_return_type

template<typename T >

using sol::detail::array_return_type = typedef std::conditional_t<std::is_array<T>::value, std::add_lvalue_reference_t<T>, T>

has_constructor

template<typename... Args>

using sol::detail::has_constructor = typedef meta::any<is_constructor<meta::unqualified_t<Args>>...>

has_destructor

template<typename... Args>

using sol::detail::has_destructor = typedef meta::any<is_destructor<meta::unqualified_t<Args>>...>

inheritance_cast_function

using sol::detail::inheritance_cast_function = typedef decltype(&inheritance<void>::type_cast)

inheritance_check_function

using sol::detail::inheritance_check_function = typedef decltype(&inheritance<void>::type_check)

inheritance_unique_cast_function

using sol::detail::inheritance_unique_cast_function = typedef decltype(&inheritance<void>::type_unique_cast<void>)

lua_CFunction_noexcept

typedef int(* sol::detail::lua_CFunction_noexcept) (lua_State *L)

swallow

using sol::detail::swallow = typedef std::initializer_list<int>

typical_chunk_name_t

using sol::detail::typical_chunk_name_t = typedef char[32]

unique_destructor

using sol::detail::unique_destructor = typedef void (*)(void*)

unique_tag

using sol::detail::unique_tag = typedef const char*

Function Documentation

align() [1/2]

void* sol::detail::align ( std::size_t  alignment, std::size_t  size, void *&  ptr, std::size_t &  space, std::size_t &  required_space  )

inline

                                                                                                                         {
            // this handels arbitrary alignments...
            // make this into a power-of-2-only?
            // actually can't: this is a C++14-compatible framework,
            // power of 2 alignment is C++17
            std::uintptr_t initial = reinterpret_cast<std::uintptr_t>(ptr);
            std::uintptr_t offby = static_cast<std::uintptr_t>(initial % alignment);
            std::uintptr_t padding = (alignment - offby) % alignment;
            required_space += size + padding;
            if (space < required_space) {
                return nullptr;
            }
            ptr = static_cast<void*>(static_cast<char*>(ptr) + padding);
            space -= padding;
            return ptr;
        }

align() [2/2]

void* sol::detail::align ( std::size_t  alignment, std::size_t  size, void *&  ptr, std::size_t &  space  )

inline

                                                                                              {
            std::size_t required_space = 0;
            return align(alignment, size, ptr, space, required_space);
        }

align_user()

template<typename T >

void* sol::detail::align_user ( void *  ptr )

inline

                                           {
            typedef std::integral_constant<bool,
#if defined(SOL_NO_MEMORY_ALIGNMENT) && SOL_NO_MEMORY_ALIGNMENT
                false
#else
                (std::alignment_of<T>::value > 1)
#endif
                >
                use_align;
            if (!use_align::value) {
                return ptr;
            }
            std::size_t space = (std::numeric_limits<std::size_t>::max)();
            return align(std::alignment_of<T>::value, sizeof(T), ptr, space);
        }

align_usertype_pointer()

void* sol::detail::align_usertype_pointer ( void *  ptr )

inline

                                                       {
            typedef std::integral_constant<bool,
#if defined(SOL_NO_MEMORY_ALIGNMENT) && SOL_NO_MEMORY_ALIGNMENT
                false
#else
                (std::alignment_of<void*>::value > 1)
#endif
                >
                use_align;
            if (!use_align::value) {
                return ptr;
            }
            std::size_t space = (std::numeric_limits<std::size_t>::max)();
            return align(std::alignment_of<void*>::value, sizeof(void*), ptr, space);
        }

align_usertype_unique()

template<typename T , bool pre_aligned = false>

void* sol::detail::align_usertype_unique ( void *  ptr )

inline

                                                      {
            typedef std::integral_constant<bool,
#if defined(SOL_NO_MEMORY_ALIGNMENT) && SOL_NO_MEMORY_ALIGNMENT
                false
#else
                (std::alignment_of<T>::value > 1)
#endif
                >
                use_align;
            if (!pre_aligned) {
                ptr = align_usertype_unique_tag(ptr);
                ptr = static_cast<void*>(static_cast<char*>(ptr) + sizeof(unique_tag));
            }
            if (!use_align::value) {
                return ptr;
            }
            std::size_t space = (std::numeric_limits<std::size_t>::max)();
            return align(std::alignment_of<T>::value, sizeof(T), ptr, space);
        }

align_usertype_unique_destructor()

template<bool pre_aligned = false>

void* sol::detail::align_usertype_unique_destructor ( void *  ptr )

inline

                                                                 {
            typedef std::integral_constant<bool,
#if defined(SOL_NO_MEMORY_ALIGNMENT) && SOL_NO_MEMORY_ALIGNMENT
                false
#else
                (std::alignment_of<unique_destructor>::value > 1)
#endif
                >
                use_align;
            if (!pre_aligned) {
                ptr = align_usertype_pointer(ptr);
                ptr = static_cast<void*>(static_cast<char*>(ptr) + sizeof(void*));
            }
            if (!use_align::value) {
                return static_cast<void*>(static_cast<void**>(ptr) + 1);
            }
            std::size_t space = (std::numeric_limits<std::size_t>::max)();
            return align(std::alignment_of<unique_destructor>::value, sizeof(unique_destructor), ptr, space);
        }

align_usertype_unique_tag()

template<bool pre_aligned = false>

void* sol::detail::align_usertype_unique_tag ( void *  ptr )

inline

                                                          {
            typedef std::integral_constant<bool,
#if defined(SOL_NO_MEMORY_ALIGNMENT) && SOL_NO_MEMORY_ALIGNMENT
                false
#else
                (std::alignment_of<unique_tag>::value > 1)
#endif
                >
                use_align;
            if (!pre_aligned) {
                ptr = align_usertype_unique_destructor(ptr);
                ptr = static_cast<void*>(static_cast<char*>(ptr) + sizeof(unique_destructor));
            }
            if (!use_align::value) {
                return ptr;
            }
            std::size_t space = (std::numeric_limits<std::size_t>::max)();
            return align(std::alignment_of<unique_tag>::value, sizeof(unique_tag), ptr, space);
        }

aligned_space_for()

template<typename... Args>

std::size_t sol::detail::aligned_space_for ( void *  alignment = nullptr )

inline

                                                                      {
            char* start = static_cast<char*>(alignment);
            auto specific_align = [&alignment](std::size_t a, std::size_t s) {
                std::size_t space = (std::numeric_limits<std::size_t>::max)();
                alignment = align(a, s, alignment, space);
                alignment = static_cast<void*>(static_cast<char*>(alignment) + s);
            };
            (void)detail::swallow{ int{}, (specific_align(std::alignment_of<Args>::value, sizeof(Args)), int{})... };
            return static_cast<char*>(alignment) - start;
        }

base_class_cast_key()

decltype(auto) sol::detail::base_class_cast_key ( )

inline

                                                    {
            static const auto& key = "class_cast";
            return key;
        }

base_class_check_key()

decltype(auto) sol::detail::base_class_check_key ( )

inline

                                                     {
            static const auto& key = "class_check";
            return key;
        }

base_class_index_propogation_key()

decltype(auto) sol::detail::base_class_index_propogation_key ( )

inline

                                                                 {
            static const auto& key = u8"\xF0\x9F\x8C\xB2.index";
            return key;
        }

base_class_new_index_propogation_key()

decltype(auto) sol::detail::base_class_new_index_propogation_key ( )

inline

                                                                     {
            static const auto& key = u8"\xF0\x9F\x8C\xB2.new_index";
            return key;
        }

c_trampoline()

int sol::detail::c_trampoline ( lua_State *  L, lua_CFunction  f  )

inline

                                                               {
            return trampoline(L, f);
        }

call_exception_handler()

int sol::detail::call_exception_handler ( lua_State *  L, optional< const std::exception &>  maybe_ex, string_view  what  )

inline

                                                                                                                  {
            lua_getglobal(L, default_exception_handler_name());
            type t = static_cast<type>(lua_type(L, -1));
            if (t != type::lightuserdata) {
                lua_pop(L, 1);
                return default_exception_handler(L, std::move(maybe_ex), std::move(what));
            }
            void* vfunc = lua_touserdata(L, -1);
            lua_pop(L, 1);
            if (vfunc == nullptr) {
                return default_exception_handler(L, std::move(maybe_ex), std::move(what));
            }
            exception_handler_function exfunc = reinterpret_cast<exception_handler_function>(vfunc);
            return exfunc(L, std::move(maybe_ex), std::move(what));
        }

cannot_destruct()

template<typename T >

int sol::detail::cannot_destruct ( lua_State *  L )

inline

                                                 {
            return luaL_error(L, "cannot call the destructor for '%s': it is either hidden (protected/private) or removed with '= delete' and thusly this type is being destroyed without properly destructing, invoking undefined behavior: please bind a usertype and specify a custom destructor to define the behavior properly", detail::demangle<T>().data());
        }

default_chunk_name()

const std::string& sol::detail::default_chunk_name ( )

inline

                                                     {
            static const std::string name = "";
            return name;
        }

default_exception_handler()

int sol::detail::default_exception_handler ( lua_State *  L, optional< const std::exception &>  , string_view  what  )

inline

                                                                                                            {
#if defined(SOL_PRINT_ERRORS) && SOL_PRINT_ERRORS
            std::cerr << "[sol2] An exception occurred: ";
            std::cerr.write(what.data(), what.size());
            std::cerr << std::endl;
#endif
            lua_pushlstring(L, what.data(), what.size());
            return 1;
        }

default_exception_handler_name()

const char(& sol::detail::default_exception_handler_name ( ) )[11]

inline

                                                                {
            static const char name[11] = "sol.\xE2\x98\xA2\xE2\x98\xA2";
            return name;
        }

default_handler_name()

const char(& sol::detail::default_handler_name ( ) )[9]

inline

                                                     {
            static const char name[9] = "sol.\xF0\x9F\x94\xA9";
            return name;
        }

default_main_thread_name()

const char(& sol::detail::default_main_thread_name ( ) )[9]

inline

                                                           {
            static const char name[9] = "sol.\xF0\x9F\x93\x8C";
            return name;
        }

demangle()

template<typename T >

const std::string& sol::detail::demangle ( )

inline

                                       {
        static const std::string d = demangle_once<T>();
        return d;
    }

demangle_once()

template<typename T >

std::string sol::detail::demangle_once ( )

inline

                                     {
        std::string realname = ctti_get_type_name<T>();
        return realname;
    }

deref()

template<typename T , meta::enable< meta::neg< is_pointer_like< meta::unqualified_t< T >>>> = meta::enabler>

auto sol::detail::deref ( T &&  item ) -> decltype(std::forward<T>(item))

inline

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

deref_non_pointer()

template<typename T , meta::disable< is_pointer_like< meta::unqualified_t< T >>, meta::neg< std::is_pointer< meta::unqualified_t< T >>>> = meta::enabler>

auto sol::detail::deref_non_pointer ( T &&  item ) -> decltype(std::forward<T>(item))

inline

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

fail_on_newindex()

int sol::detail::fail_on_newindex ( lua_State *  L )

inline

                                                  {
            return luaL_error(L, "sol: cannot modify the elements of an enumeration table");
        }

force_cast()

template<typename base_t , typename T >

basic_function<base_t> sol::detail::force_cast

(

T &

p

)

                                                {
            return p;
        }

forward_get()

template<std::size_t I, typename Tuple >

decltype(auto) sol::detail::forward_get

(

Tuple &&

tuple

)

                                                  {
            return std::forward<meta::tuple_element_t<I, Tuple>>(std::get<I>(tuple));
        }

forward_tuple()

template<typename Tuple >

auto sol::detail::forward_tuple

(

Tuple &&

tuple

)

                                          {
            auto x = forward_tuple_impl(std::make_index_sequence<std::tuple_size<meta::unqualified_t<Tuple>>::value>(), std::forward<Tuple>(tuple));
            return x;
        }

forward_tuple_impl()

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

auto sol::detail::forward_tuple_impl	(	std::index_sequence< I... >	,
		Tuple &&	tuple
	)		-> decltype(std::tuple<decltype(forward_get<I>(tuple))...>(forward_get<I>(tuple)...))

                                                                                                                                                            {
            return std::tuple<decltype(forward_get<I>(tuple))...>(std::move(std::get<I>(tuple))...);
        }

get() [1/2]

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

stack_proxy sol::detail::get	(	types< Args... >	,
		index_value< 0 >	,
		index_value< I >	,
		const T &	fr
	)

                                                                                     {
            return stack_proxy(fr.lua_state(), static_cast<int>(fr.stack_index() + I));
        }

get() [2/2]

template<std::size_t I, std::size_t N, typename Arg , typename... Args, typename T , meta::enable< meta::boolean<(N > 0)> >

stack_proxy sol::detail::get	(	types< Arg, Args... >	,
		index_value< N >	,
		index_value< I >	,
		const T &	fr
	)

                                                                                          {
            return get(types<Args...>(), index_value<N - 1>(), index_value<I + lua_size<Arg>::value>(), fr);
        }

get_default_handler()

template<typename Reference , bool is_main_ref = false>

static Reference sol::detail::get_default_handler ( lua_State *  L )

static

                                                           {
            if (is_stack_based<Reference>::value || L == nullptr)
                return Reference(L, lua_nil);
            L = is_main_ref ? main_thread(L, L) : L;
            lua_getglobal(L, default_handler_name());
            auto pp = stack::pop_n(L, 1);
            return Reference(L, -1);
        }

make_chunk_name()

template<std::size_t N>

const char* sol::detail::make_chunk_name	(	const string_view &	code,
		const std::string &	chunkname,
		char(&)	basechunkname[N]
	)

                                                                                                                   {
            if (chunkname.empty()) {
                auto it = code.cbegin();
                auto e = code.cend();
                std::size_t i = 0;
                static const std::size_t n = N - 4;
                for (i = 0; i < n && it != e; ++i, ++it) {
                    basechunkname[i] = *it;
                }
                if (it != e) {
                    for (std::size_t c = 0; c < 3; ++i, ++c) {
                        basechunkname[i] = '.';
                    }
                }
                basechunkname[i] = '\0';
                return &basechunkname[0];
            }
            else {
                return chunkname.c_str();
            }
        }

make_unique_deleter()

template<typename T , typename Dx , typename... Args>

std::unique_ptr<T, Dx> sol::detail::make_unique_deleter ( Args &&...  args )

inline

                                                                        {
            return std::unique_ptr<T, Dx>(new T(std::forward<Args>(args)...));
        }

pick_main_thread()

template<bool b>

lua_State* sol::detail::pick_main_thread ( lua_State *  L, lua_State *  backup_if_unsupported = nullptr  )

inline

                                                                                                     {
            (void)L;
            (void)backup_if_unsupported;
            if (b) {
                return main_thread(L, backup_if_unsupported);
            }
            return L;
        }

ptr() [1/3]

template<typename T >

T* sol::detail::ptr ( T &  val )

inline

                              {
            return std::addressof(val);
        }

ptr() [2/3]

template<typename T >

T* sol::detail::ptr ( std::reference_wrapper< T >  val )

inline

                                                   {
            return std::addressof(val.get());
        }

ptr() [3/3]

template<typename T >

T* sol::detail::ptr ( T *  val )

inline

                              {
            return val;
        }

reserve() [1/3]

template<typename T >

void sol::detail::reserve	(	T &	,
		std::size_t
	)

                                    {
        }

reserve() [2/3]

template<typename T , typename Al >

void sol::detail::reserve	(	std::vector< T, Al > &	arr,
		std::size_t	hint
	)

                                                            {
            arr.reserve(hint);
        }

reserve() [3/3]

template<typename T , typename Tr , typename Al >

void sol::detail::reserve	(	std::basic_string< T, Tr, Al > &	arr,
		std::size_t	hint
	)

                                                                      {
            arr.reserve(hint);
        }

resolve_f() [1/2]

template<typename F , typename U = meta::unqualified_t<F>>

constexpr auto sol::detail::resolve_f ( std::true_type  , F &&  f  ) -> decltype(resolve_i(types<meta::function_signature_t<decltype(&U::operator())>>(), std::forward<F>(f)))

inline

                                                                                                                {
            return resolve_i(types<meta::function_signature_t<decltype(&U::operator())>>(), std::forward<F>(f));
        }

resolve_f() [2/2]

template<typename F >

constexpr void sol::detail::resolve_f ( std::false_type  , F &&    )

inline

                                                            {
            static_assert(meta::has_deducible_signature<F>::value,
                "Cannot use no-template-parameter call with an overloaded functor: specify the signature");
        }

resolve_i() [1/3]

template<typename R , typename... Args, typename F , typename = std::result_of_t<meta::unqualified_t<F>(Args...)>>

constexpr auto sol::detail::resolve_i ( types< R(Args...)>  , F &&    ) -> R (meta::unqualified_t<F>::*)(Args...)

inline

                                                                                                       {
            using Sig = R(Args...);
            typedef meta::unqualified_t<F> Fu;
            return static_cast<Sig Fu::*>(&Fu::operator());
        }

resolve_i() [2/3]

template<typename F , typename U = meta::unqualified_t<F>>

constexpr auto sol::detail::resolve_i ( types<>  , F &&  f  ) -> decltype(resolve_f(meta::has_deducible_signature<U>(), std::forward<F>(f)))

inline

                                                                                                                                   {
            return resolve_f(meta::has_deducible_signature<U>{}, std::forward<F>(f));
        }

resolve_i() [3/3]

template<typename... Args, typename F , typename R = std::result_of_t<F&(Args...)>>

constexpr auto sol::detail::resolve_i ( types< Args... >  , F &&  f  ) -> decltype(resolve_i(types<R(Args...)>(), std::forward<F>(f)))

inline

                                                                                                                             {
            return resolve_i(types<R(Args...)>(), std::forward<F>(f));
        }

resolve_v() [1/2]

template<typename Sig , typename C >

constexpr Sig C::* sol::detail::resolve_v ( std::false_type  , Sig C::*  mem_func_ptr  )

inline

                                                                            {
            return mem_func_ptr;
        }

resolve_v() [2/2]

template<typename Sig , typename C >

constexpr Sig C::* sol::detail::resolve_v ( std::true_type  , Sig C::*  mem_variable_ptr  )

inline

                                                                               {
            return mem_variable_ptr;
        }

set_default_handler()

template<typename T >

static void sol::detail::set_default_handler ( lua_State *  L, const T &  ref  )

static

                                                                    {
            if (L == nullptr) {
                return;
            }
            if (!ref.valid()) {
                lua_pushnil(L);
                lua_setglobal(L, default_handler_name());
            }
            else {
                ref.push(L);
                lua_setglobal(L, default_handler_name());
            }
        }

short_demangle()

template<typename T >

const std::string& sol::detail::short_demangle ( )

inline

                                             {
        static const std::string d = short_demangle_once<T>();
        return d;
    }

short_demangle_once()

template<typename T >

std::string sol::detail::short_demangle_once ( )

inline

                                           {
        std::string realname = ctti_get_type_name<T>();
        // This isn't the most complete but it'll do for now...?
        static const std::array<std::string, 10> ops = {{"operator<", "operator<<", "operator<<=", "operator<=", "operator>", "operator>>", "operator>>=", "operator>=", "operator->", "operator->*"}};
        int level = 0;
        std::ptrdiff_t idx = 0;
        for (idx = static_cast<std::ptrdiff_t>(realname.empty() ? 0 : realname.size() - 1); idx > 0; --idx) {
            if (level == 0 && realname[idx] == ':') {
                break;
            }
            bool isleft = realname[idx] == '<';
            bool isright = realname[idx] == '>';
            if (!isleft && !isright)
                continue;
            bool earlybreak = false;
            for (const auto& op : ops) {
                std::size_t nisop = realname.rfind(op, idx);
                if (nisop == std::string::npos)
                    continue;
                std::size_t nisopidx = idx - op.size() + 1;
                if (nisop == nisopidx) {
                    idx = static_cast<std::ptrdiff_t>(nisopidx);
                    earlybreak = true;
                }
                break;
            }
            if (earlybreak) {
                continue;
            }
            level += isleft ? -1 : 1;
        }
        if (idx > 0) {
            realname.erase(0, realname.length() < static_cast<std::size_t>(idx) ? realname.length() : idx + 1);
        }
        return realname;
    }

stack_fail()

void sol::detail::stack_fail ( int  , int    )

inline

                                         {
#if !(defined(SOL_NO_EXCEPTIONS) && SOL_NO_EXCEPTIONS)
            throw error(detail::direct_error, "imbalanced stack after operation finish");
#else
            // Lol, what do you want, an error printout? :3c
            // There's no sane default here. The right way would be C-style abort(), and that's not acceptable, so
            // hopefully someone will register their own stack_fail thing for the `fx` parameter of stack_guard.
#endif // No Exceptions
        }

static_trampoline()

template<lua_CFunction f>

int sol::detail::static_trampoline

(

lua_State *

L

)

                                            {
#if defined(SOL_EXCEPTIONS_SAFE_PROPAGATION) && !defined(SOL_LUAJIT)
            return f(L);

#else
            try {
                return f(L);
            }
            catch (const char* cs) {
                call_exception_handler(L, optional<const std::exception&>(nullopt), string_view(cs));
            }
            catch (const std::string& s) {
                call_exception_handler(L, optional<const std::exception&>(nullopt), string_view(s.c_str(), s.size()));
            }
            catch (const std::exception& e) {
                call_exception_handler(L, optional<const std::exception&>(e), e.what());
            }
#if !defined(SOL_EXCEPTIONS_SAFE_PROPAGATION)
            // LuaJIT cannot have the catchall when the safe propagation is on
            // but LuaJIT will swallow all C++ errors 
            // if we don't at least catch std::exception ones
            catch (...) {
                call_exception_handler(L, optional<const std::exception&>(nullopt), "caught (...) exception");
            }
#endif // LuaJIT cannot have the catchall, but we must catch std::exceps for it
            return lua_error(L);
#endif // Safe exceptions
        }

static_trampoline_noexcept()

template<lua_CFunction f>

int sol::detail::static_trampoline_noexcept ( lua_State *  L )

noexcept

                                                              {
            return f(L);
        }

trampoline()

template<typename Fx , typename... Args>

int sol::detail::trampoline	(	lua_State *	L,
		Fx &&	f,
		Args &&...	args
	)

                                                             {
            if (meta::bind_traits<meta::unqualified_t<Fx>>::is_noexcept) {
                return f(L, std::forward<Args>(args)...);
            }
#if defined(SOL_EXCEPTIONS_SAFE_PROPAGATION) && !defined(SOL_LUAJIT)
            return f(L, std::forward<Args>(args)...);
#else
            try {
                return f(L, std::forward<Args>(args)...);
            }
            catch (const char* cs) {
                call_exception_handler(L, optional<const std::exception&>(nullopt), string_view(cs));
            }
            catch (const std::string& s) {
                call_exception_handler(L, optional<const std::exception&>(nullopt), string_view(s.c_str(), s.size()));
            }
            catch (const std::exception& e) {
                call_exception_handler(L, optional<const std::exception&>(e), e.what());
            }
#if !defined(SOL_EXCEPTIONS_SAFE_PROPAGATION)
            // LuaJIT cannot have the catchall when the safe propagation is on
            // but LuaJIT will swallow all C++ errors 
            // if we don't at least catch std::exception ones
            catch (...) {
                call_exception_handler(L, optional<const std::exception&>(nullopt), "caught (...) exception");
            }
#endif
            return lua_error(L);
#endif
        }

typed_static_trampoline()

template<typename F , F fx>

int sol::detail::typed_static_trampoline ( lua_State *  L )

inline

                                                         {
            return typed_static_trampoline_raw<F, fx>(std::integral_constant<bool, meta::bind_traits<F>::is_noexcept>(), L);
        }

typed_static_trampoline_raw() [1/2]

template<typename F , F fx>

int sol::detail::typed_static_trampoline_raw ( std::true_type  , lua_State *  L  )

inline

                                                                           {
            return static_trampoline_noexcept<fx>(L);
        }

typed_static_trampoline_raw() [2/2]

template<typename F , F fx>

int sol::detail::typed_static_trampoline_raw ( std::false_type  , lua_State *  L  )

inline

                                                                            {
            return static_trampoline<fx>(L);
        }

unique_destruct()

template<typename T >

int sol::detail::unique_destruct ( lua_State *  L )

inline

                                                 {
            void* memory = lua_touserdata(L, 1);
            memory = align_usertype_unique_destructor(memory);
            unique_destructor& dx = *static_cast<unique_destructor*>(memory);
            memory = static_cast<void*>(static_cast<char*>(memory) + sizeof(unique_destructor));
            memory = align_usertype_unique_tag<true>(memory);
            memory = static_cast<void*>(static_cast<char*>(memory) + sizeof(unique_tag));
            (dx)(memory);
            return 0;
        }

unwrap() [1/2]

template<typename T >

auto sol::detail::unwrap

(

T &&

item

)

-> decltype(std::forward<T>(item))

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

unwrap() [2/2]

template<typename T >

T& sol::detail::unwrap

(

std::reference_wrapper< T >

arg

)

                                               {
            return arg.get();
        }

user_alloc_destruct()

template<typename T >

int sol::detail::user_alloc_destruct ( lua_State *  L )

inline

                                                     {
            void* memory = lua_touserdata(L, 1);
            memory = align_user<T>(memory);
            T* data = static_cast<T*>(memory);
            std::allocator<T> alloc;
            std::allocator_traits<std::allocator<T>>::destroy(alloc, data);
            return 0;
        }

user_allocate()

template<typename T >

T* sol::detail::user_allocate ( lua_State *  L )

inline

                                              {
            typedef std::integral_constant<bool,
#if defined(SOL_NO_MEMORY_ALIGNMENT) && SOL_NO_MEMORY_ALIGNMENT
                false
#else
                (std::alignment_of<T>::value > 1)
#endif
                >
                use_align;
            if (!use_align::value) {
                T* pointer = static_cast<T*>(lua_newuserdata(L, sizeof(T)));
                return pointer;
            }

            static const std::size_t initial_size = aligned_space_for<T>(nullptr);
            static const std::size_t misaligned_size = aligned_space_for<T>(reinterpret_cast<void*>(0x1));

            std::size_t allocated_size = initial_size;
            void* unadjusted = lua_newuserdata(L, allocated_size);
            void* adjusted = align(std::alignment_of<T>::value, sizeof(T), unadjusted, allocated_size);
            if (adjusted == nullptr) {
                lua_pop(L, 1);
                // try again, add extra space for alignment padding
                allocated_size = misaligned_size;
                unadjusted = lua_newuserdata(L, allocated_size);
                adjusted = align(std::alignment_of<T>::value, sizeof(T), unadjusted, allocated_size);
                if (adjusted == nullptr) {
                    lua_pop(L, 1);
                    luaL_error(L, "cannot properly align memory for '%s'", detail::demangle<T>().data());
                }
            }
            return static_cast<T*>(adjusted);
        }

usertype_alloc_destruct()

template<typename T >

int sol::detail::usertype_alloc_destruct ( lua_State *  L )

inline

                                                         {
            void* memory = lua_touserdata(L, 1);
            memory = align_usertype_pointer(memory);
            T** pdata = static_cast<T**>(memory);
            T* data = *pdata;
            std::allocator<T> alloc{};
            std::allocator_traits<std::allocator<T>>::destroy(alloc, data);
            return 0;
        }

usertype_allocate()

template<typename T >

T* sol::detail::usertype_allocate ( lua_State *  L )

inline

                                                  {
            typedef std::integral_constant<bool,
#if defined(SOL_NO_MEMORY_ALIGNMENT) && SOL_NO_MEMORY_ALIGNMENT
                false
#else
                (std::alignment_of<T*>::value > 1 || std::alignment_of<T>::value > 1)
#endif
                >
                use_align;
            if (!use_align::value) {
                T** pointerpointer = static_cast<T**>(lua_newuserdata(L, sizeof(T*) + sizeof(T)));
                T*& pointerreference = *pointerpointer;
                T* allocationtarget = reinterpret_cast<T*>(pointerpointer + 1);
                pointerreference = allocationtarget;
                return allocationtarget;
            }

            /* the assumption is that `lua_newuserdata` -- unless someone
            passes a specific lua_Alloc that gives us bogus, un-aligned pointers
            -- uses malloc, which tends to hand out more or less aligned pointers to memory
            (most of the time, anyhow)

            but it's not guaranteed, so we have to do a post-adjustment check and increase padding

            we do this preliminarily with compile-time stuff, to see
            if we strike lucky with the allocator and alignment values

            otherwise, we have to re-allocate the userdata and
            over-allocate some space for additional padding because
            compilers are optimized for aligned reads/writes
            (and clang will barf UBsan errors on us for not being aligned)
            */
            static const std::size_t initial_size = aligned_space_for<T*, T>(nullptr);
            static const std::size_t misaligned_size = aligned_space_for<T*, T>(reinterpret_cast<void*>(0x1));

            void* pointer_adjusted;
            void* data_adjusted;
            auto attempt_alloc = [](lua_State* L, std::size_t allocated_size, void*& pointer_adjusted, void*& data_adjusted) -> bool {
                void* adjusted = lua_newuserdata(L, allocated_size);
                pointer_adjusted = align(std::alignment_of<T*>::value, sizeof(T*), adjusted, allocated_size);
                if (pointer_adjusted == nullptr) {
                    lua_pop(L, 1);
                    return false;
                }
                // subtract size of what we're going to allocate there
                allocated_size -= sizeof(T*);
                adjusted = static_cast<void*>(static_cast<char*>(pointer_adjusted) + sizeof(T*));
                data_adjusted = align(std::alignment_of<T>::value, sizeof(T), adjusted, allocated_size);
                if (data_adjusted == nullptr) {
                    lua_pop(L, 1);
                    return false;
                }
                return true;
            };
            bool result = attempt_alloc(L, initial_size, pointer_adjusted, data_adjusted);
            if (!result) {
                // we're likely to get something that fails to perform the proper allocation a second time,
                // so we use the suggested_new_size bump to help us out here
                pointer_adjusted = nullptr;
                data_adjusted = nullptr;
                result = attempt_alloc(L, misaligned_size, pointer_adjusted, data_adjusted);
                if (!result) {
                    if (pointer_adjusted == nullptr) {
                        luaL_error(L, "aligned allocation of userdata block (pointer section) for '%s' failed", detail::demangle<T>().c_str());
                    }
                    else {
                        luaL_error(L, "aligned allocation of userdata block (data section) for '%s' failed", detail::demangle<T>().c_str());
                    }
                    return nullptr;
                }
            }

            T** pointerpointer = reinterpret_cast<T**>(pointer_adjusted);
            T*& pointerreference = *pointerpointer;
            T* allocationtarget = reinterpret_cast<T*>(data_adjusted);
            pointerreference = allocationtarget;
            return allocationtarget;
        }

usertype_allocate_pointer()

template<typename T >

T** sol::detail::usertype_allocate_pointer ( lua_State *  L )

inline

                                                           {
            typedef std::integral_constant<bool,
#if defined(SOL_NO_MEMORY_ALIGNMENT) && SOL_NO_MEMORY_ALIGNMENT
                false
#else
                (std::alignment_of<T*>::value > 1)
#endif
                >
                use_align;
            if (!use_align::value) {
                T** pointerpointer = static_cast<T**>(lua_newuserdata(L, sizeof(T*)));
                return pointerpointer;
            }
            static const std::size_t initial_size = aligned_space_for<T*>(nullptr);
            static const std::size_t misaligned_size = aligned_space_for<T*>(reinterpret_cast<void*>(0x1));

            std::size_t allocated_size = initial_size;
            void* unadjusted = lua_newuserdata(L, initial_size);
            void* adjusted = align(std::alignment_of<T*>::value, sizeof(T*), unadjusted, allocated_size);
            if (adjusted == nullptr) {
                lua_pop(L, 1);
                // what kind of absolute garbage trash allocator are we dealing with?
                // whatever, add some padding in the case of MAXIMAL alignment waste...
                allocated_size = misaligned_size;
                unadjusted = lua_newuserdata(L, allocated_size);
                adjusted = align(std::alignment_of<T*>::value, sizeof(T*), unadjusted, allocated_size);
                if (adjusted == nullptr) {
                    // trash allocator can burn in hell
                    lua_pop(L, 1);
                    //luaL_error(L, "if you are the one that wrote this allocator you should feel bad for doing a worse job than malloc/realloc and should go read some books, yeah?");
                    luaL_error(L, "cannot properly align memory for '%s'", detail::demangle<T*>().data());
                }
            }
            return static_cast<T**>(adjusted);
        }

usertype_unique_alloc_destroy()

template<typename T , typename Real >

void sol::detail::usertype_unique_alloc_destroy ( void *  memory )

inline

                                                                {
            memory = align_usertype_unique<Real, true>(memory);
            Real* target = static_cast<Real*>(memory);
            std::allocator<Real> alloc;
            std::allocator_traits<std::allocator<Real>>::destroy(alloc, target);
        }

usertype_unique_allocate()

template<typename T , typename Real >

Real* sol::detail::usertype_unique_allocate ( lua_State *  L, T **&  pref, unique_destructor *&  dx, unique_tag *&  id  )

inline

                                                                                                                {
            typedef std::integral_constant<bool,
#if defined(SOL_NO_MEMORY_ALIGNMENT) && SOL_NO_MEMORY_ALIGNMENT
                false
#else
                (std::alignment_of<T*>::value > 1 || std::alignment_of<unique_tag>::value > 1 || std::alignment_of<unique_destructor>::value > 1 || std::alignment_of<Real>::value > 1)
#endif
                >
                use_align;
            if (!use_align::value) {
                pref = static_cast<T**>(lua_newuserdata(L, sizeof(T*) + sizeof(detail::unique_destructor) + sizeof(unique_tag) + sizeof(Real)));
                dx = static_cast<detail::unique_destructor*>(static_cast<void*>(pref + 1));
                id = static_cast<unique_tag*>(static_cast<void*>(dx + 1));
                Real* mem = static_cast<Real*>(static_cast<void*>(id + 1));
                return mem;
            }

            static const std::size_t initial_size = aligned_space_for<T*, unique_destructor, unique_tag, Real>(nullptr);
            static const std::size_t misaligned_size = aligned_space_for<T*, unique_destructor, unique_tag, Real>(reinterpret_cast<void*>(0x1));

            void* pointer_adjusted;
            void* dx_adjusted;
            void* id_adjusted;
            void* data_adjusted;
            auto attempt_alloc = [](lua_State* L, std::size_t allocated_size, void*& pointer_adjusted, void*& dx_adjusted, void*& id_adjusted, void*& data_adjusted) -> bool {
                void* adjusted = lua_newuserdata(L, allocated_size);
                pointer_adjusted = align(std::alignment_of<T*>::value, sizeof(T*), adjusted, allocated_size);
                if (pointer_adjusted == nullptr) {
                    lua_pop(L, 1);
                    return false;
                }
                allocated_size -= sizeof(T*);

                adjusted = static_cast<void*>(static_cast<char*>(pointer_adjusted) + sizeof(T*));
                dx_adjusted = align(std::alignment_of<unique_destructor>::value, sizeof(unique_destructor), adjusted, allocated_size);
                if (dx_adjusted == nullptr) {
                    lua_pop(L, 1);
                    return false;
                }
                allocated_size -= sizeof(unique_destructor);

                adjusted = static_cast<void*>(static_cast<char*>(dx_adjusted) + sizeof(unique_destructor));

                id_adjusted = align(std::alignment_of<unique_tag>::value, sizeof(unique_tag), adjusted, allocated_size);
                if (id_adjusted == nullptr) {
                    lua_pop(L, 1);
                    return false;
                }
                allocated_size -= sizeof(unique_tag);

                adjusted = static_cast<void*>(static_cast<char*>(id_adjusted) + sizeof(unique_tag));
                data_adjusted = align(std::alignment_of<Real>::value, sizeof(Real), adjusted, allocated_size);
                if (data_adjusted == nullptr) {
                    lua_pop(L, 1);
                    return false;
                }
                return true;
            };
            bool result = attempt_alloc(L, initial_size, pointer_adjusted, dx_adjusted, id_adjusted, data_adjusted);
            if (!result) {
                // we're likely to get something that fails to perform the proper allocation a second time,
                // so we use the suggested_new_size bump to help us out here
                pointer_adjusted = nullptr;
                dx_adjusted = nullptr;
                id_adjusted = nullptr;
                data_adjusted = nullptr;
                result = attempt_alloc(L, misaligned_size, pointer_adjusted, dx_adjusted, id_adjusted, data_adjusted);
                if (!result) {
                    if (pointer_adjusted == nullptr) {
                        luaL_error(L, "aligned allocation of userdata block (pointer section) for '%s' failed", detail::demangle<T>().c_str());
                    }
                    else if (dx_adjusted == nullptr) {
                        luaL_error(L, "aligned allocation of userdata block (deleter section) for '%s' failed", detail::demangle<T>().c_str());
                    }
                    else {
                        luaL_error(L, "aligned allocation of userdata block (data section) for '%s' failed", detail::demangle<T>().c_str());
                    }
                    return nullptr;
                }
            }

            pref = static_cast<T**>(pointer_adjusted);
            dx = static_cast<detail::unique_destructor*>(dx_adjusted);
            id = static_cast<unique_tag*>(id_adjusted);
            Real* mem = static_cast<Real*>(data_adjusted);
            return mem;
        }

xmovable()

bool sol::detail::xmovable ( lua_State *  leftL, lua_State *  rightL  )

inline

                                                                  {
            if (rightL == nullptr || leftL == nullptr || leftL == rightL) {
                return false;
            }
            const void* leftregistry = lua_topointer(leftL, LUA_REGISTRYINDEX);
            const void* rightregistry = lua_topointer(rightL, LUA_REGISTRYINDEX);
            return leftregistry == rightregistry;
        }

Variable Documentation

default_safe_function_calls

const bool sol::detail::default_safe_function_calls

Initial value:

=



            false

direct_error

const auto sol::detail::direct_error = direct_error_tag{}

global_

struct sol::detail::global_tag sol::detail::global_

no_safety

struct sol::detail::no_safety_tag sol::detail::no_safety

unchecked

const unchecked_t sol::detail::unchecked = unchecked_t{}

verified

struct sol::detail::verified_tag sol::detail::verified

yield_tag

const yield_tag_t sol::detail::yield_tag = yield_tag_t{}