// The MIT License (MIT)// Copyright (c) 2013-2016 Rapptz, ThePhD and contributors// Permission is hereby granted, free of charge, to any person obtaining a copy of// this software and associated documentation files (the "Software"), to deal in// the Software without restriction, including without limitation the rights to// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of// the Software, and to permit persons to whom the Software is furnished to do so,// subject to the following conditions:// The above copyright notice and this permission notice shall be included in all// copies or substantial portions of the Software.// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.// This file was generated with a script.// Generated 2017-02-01 11:49:07.483904 UTC// This header was generated with sol v2.15.7 (revision 8d6f304)// https://github.com/ThePhD/sol2#ifndef SOL_SINGLE_INCLUDE_HPP#define SOL_SINGLE_INCLUDE_HPP// beginning of sol.hpp#ifndef SOL_HPP#define SOL_HPP#if defined(UE_BUILD_DEBUG) || defined(UE_BUILD_DEVELOPMENT) || defined(UE_BUILD_TEST) || defined(UE_BUILD_SHIPPING) || defined(UE_SERVER)#define SOL_INSIDE_UNREAL#endif // Unreal Engine 4 bullshit#ifdef SOL_INSIDE_UNREAL#ifdef check#define SOL_INSIDE_UNREAL_REMOVED_CHECK#undef check#endif #endif // Unreal Engine 4 Bullshit#ifdef __GNUC__#pragma GCC diagnostic push#pragma GCC diagnostic ignored "-Wshadow"#pragma GCC diagnostic ignored "-Wconversion"#elif defined _MSC_VER#pragma warning( push )#pragma warning( disable : 4324 ) // structure was padded due to alignment specifier#endif // g++// beginning of sol/state.hpp// beginning of sol/state_view.hpp// beginning of sol/error.hpp#include<stdexcept>#include<string>namespacesol{namespacedetail{structdirect_error_tag{};constautodirect_error=direct_error_tag{};}// detailclasserror:publicstd::runtime_error{private:// Because VC++ is a fuccboistd::stringw;public:error(conststd::string&str):error(detail::direct_error,"lua: error: "+str){}error(std::string&&str):error(detail::direct_error,"lua: error: "+std::move(str)){}error(detail::direct_error_tag,conststd::string&str):std::runtime_error(""),w(str){}error(detail::direct_error_tag,std::string&&str):std::runtime_error(""),w(std::move(str)){}error(consterror&e)=default;error(error&&e)=default;error&operator=(consterror&e)=default;error&operator=(error&&e)=default;virtualconstchar*what()constnoexceptoverride{returnw.c_str();}};}// sol// end of sol/error.hpp// beginning of sol/table.hpp// beginning of sol/table_core.hpp// beginning of sol/proxy.hpp// beginning of sol/traits.hpp// beginning of sol/tuple.hpp#include<tuple>#include<cstddef>namespacesol{namespacedetail{usingswallow=std::initializer_list<int>;}// detailtemplate<typename...Args>structtypes{typedefstd::make_index_sequence<sizeof...(Args)>indices;staticconstexprstd::size_tsize(){returnsizeof...(Args);}};namespacemeta{namespacedetail{template<typename...Args>structtuple_types_{typedeftypes<Args...>type;};template<typename...Args>structtuple_types_<std::tuple<Args...>>{typedeftypes<Args...>type;};}// detailtemplate<typenameT>usingunqualified=std::remove_cv<std::remove_reference_t<T>>;template<typenameT>usingunqualified_t=typenameunqualified<T>::type;template<typename...Args>usingtuple_types=typenamedetail::tuple_types_<Args...>::type;template<typenameArg>structpop_front_type;template<typenameArg>usingpop_front_type_t=typenamepop_front_type<Arg>::type;template<typename...Args>structpop_front_type<types<Args...>>{typedefvoidfront_type;typedeftypes<Args...>type;};template<typenameArg,typename...Args>structpop_front_type<types<Arg,Args...>>{typedefArgfront_type;typedeftypes<Args...>type;};template<std::size_tN,typenameTuple>usingtuple_element=std::tuple_element<N,unqualified_t<Tuple>>;template<std::size_tN,typenameTuple>usingtuple_element_t=std::tuple_element_t<N,unqualified_t<Tuple>>;template<std::size_tN,typenameTuple>usingunqualified_tuple_element=unqualified<tuple_element_t<N,Tuple>>;template<std::size_tN,typenameTuple>usingunqualified_tuple_element_t=unqualified_t<tuple_element_t<N,Tuple>>;}// meta}// sol// end of sol/tuple.hpp// beginning of sol/bind_traits.hppnamespacesol{namespacemeta{namespacemeta_detail{template<classF>structcheck_deducible_signature{structnat{};template<classG>staticautotest(int)->decltype(&G::operator(),void());template<class>staticautotest(...)->nat;usingtype=std::is_void<decltype(test<F>(0))>;};}// meta_detailtemplate<classF>structhas_deducible_signature:meta_detail::check_deducible_signature<F>::type{};namespacemeta_detail{template<std::size_tI,typenameT>structvoid_tuple_element:meta::tuple_element<I,T>{};template<std::size_tI>structvoid_tuple_element<I,std::tuple<>>{typedefvoidtype;};template<std::size_tI,typenameT>usingvoid_tuple_element_t=typenamevoid_tuple_element<I,T>::type;template<boolhas_c_variadic,typenameT,typenameR,typename...Args>structbasic_traits{private:typedefstd::conditional_t<std::is_void<T>::value,int,T>&first_type;public:staticconstboolis_member_function=std::is_void<T>::value;staticconstboolhas_c_var_arg=has_c_variadic;staticconststd::size_tarity=sizeof...(Args);staticconststd::size_tfree_arity=sizeof...(Args)+static_cast<std::size_t>(!std::is_void<T>::value);typedeftypes<Args...>args_list;typedefstd::tuple<Args...>args_tuple;typedefTobject_type;typedefRreturn_type;typedeftuple_types<R>returns_list;typedefR(function_type)(Args...);typedefstd::conditional_t<std::is_void<T>::value,args_list,types<first_type,Args...>>free_args_list;typedefstd::conditional_t<std::is_void<T>::value,R(Args...),R(first_type,Args...)>free_function_type;typedefstd::conditional_t<std::is_void<T>::value,R(*)(Args...),R(*)(first_type,Args...)>free_function_pointer_type;typedefstd::remove_pointer_t<free_function_pointer_type>signature_type;template<std::size_ti>usingarg_at=void_tuple_element_t<i,args_tuple>;};template<typenameSignature,boolb=has_deducible_signature<Signature>::value>structfx_traits:basic_traits<false,void,void>{};// Free Functionstemplate<typenameR,typename...Args>structfx_traits<R(Args...),false>:basic_traits<false,void,R,Args...>{typedefR(*function_pointer_type)(Args...);};template<typenameR,typename...Args>structfx_traits<R(*)(Args...),false>:basic_traits<false,void,R,Args...>{typedefR(*function_pointer_type)(Args...);};template<typenameR,typename...Args>structfx_traits<R(Args...,...),false>:basic_traits<true,void,R,Args...>{typedefR(*function_pointer_type)(Args...,...);};template<typenameR,typename...Args>structfx_traits<R(*)(Args...,...),false>:basic_traits<true,void,R,Args...>{typedefR(*function_pointer_type)(Args...,...);};// Member Functions/* C-Style Variadics */template<typenameT,typenameR,typename...Args>structfx_traits<R(T::*)(Args...),false>:basic_traits<false,T,R,Args...>{typedefR(T::*function_pointer_type)(Args...);};template<typenameT,typenameR,typename...Args>structfx_traits<R(T::*)(Args...,...),false>:basic_traits<true,T,R,Args...>{typedefR(T::*function_pointer_type)(Args...,...);};/* Const Volatile */template<typenameT,typenameR,typename...Args>structfx_traits<R(T::*)(Args...)const,false>:basic_traits<false,T,R,Args...>{typedefR(T::*function_pointer_type)(Args...)const;};template<typenameT,typenameR,typename...Args>structfx_traits<R(T::*)(Args...,...)const,false>:basic_traits<true,T,R,Args...>{typedefR(T::*function_pointer_type)(Args...,...)const;};template<typenameT,typenameR,typename...Args>structfx_traits<R(T::*)(Args...)constvolatile,false>:basic_traits<false,T,R,Args...>{typedefR(T::*function_pointer_type)(Args...)constvolatile;};template<typenameT,typenameR,typename...Args>structfx_traits<R(T::*)(Args...,...)constvolatile,false>:basic_traits<true,T,R,Args...>{typedefR(T::*function_pointer_type)(Args...,...)constvolatile;};/* Member Function Qualifiers */template<typenameT,typenameR,typename...Args>structfx_traits<R(T::*)(Args...)&,false>:basic_traits<false,T,R,Args...>{typedefR(T::*function_pointer_type)(Args...)&;};template<typenameT,typenameR,typename...Args>structfx_traits<R(T::*)(Args...,...)&,false>:basic_traits<true,T,R,Args...>{typedefR(T::*function_pointer_type)(Args...,...)&;};template<typenameT,typenameR,typename...Args>structfx_traits<R(T::*)(Args...)const&,false>:basic_traits<false,T,R,Args...>{typedefR(T::*function_pointer_type)(Args...)const&;};template<typenameT,typenameR,typename...Args>structfx_traits<R(T::*)(Args...,...)const&,false>:basic_traits<true,T,R,Args...>{typedefR(T::*function_pointer_type)(Args...,...)const&;};template<typenameT,typenameR,typename...Args>structfx_traits<R(T::*)(Args...)constvolatile&,false>:basic_traits<false,T,R,Args...>{typedefR(T::*function_pointer_type)(Args...)constvolatile&;};template<typenameT,typenameR,typename...Args>structfx_traits<R(T::*)(Args...,...)constvolatile&,false>:basic_traits<true,T,R,Args...>{typedefR(T::*function_pointer_type)(Args...,...)constvolatile&;};template<typenameT,typenameR,typename...Args>structfx_traits<R(T::*)(Args...)&&,false>:basic_traits<false,T,R,Args...>{typedefR(T::*function_pointer_type)(Args...)&&;};template<typenameT,typenameR,typename...Args>structfx_traits<R(T::*)(Args...,...)&&,false>:basic_traits<true,T,R,Args...>{typedefR(T::*function_pointer_type)(Args...,...)&&;};template<typenameT,typenameR,typename...Args>structfx_traits<R(T::*)(Args...)const&&,false>:basic_traits<false,T,R,Args...>{typedefR(T::*function_pointer_type)(Args...)const&&;};template<typenameT,typenameR,typename...Args>structfx_traits<R(T::*)(Args...,...)const&&,false>:basic_traits<true,T,R,Args...>{typedefR(T::*function_pointer_type)(Args...,...)const&&;};template<typenameT,typenameR,typename...Args>structfx_traits<R(T::*)(Args...)constvolatile&&,false>:basic_traits<false,T,R,Args...>{typedefR(T::*function_pointer_type)(Args...)constvolatile&&;};template<typenameT,typenameR,typename...Args>structfx_traits<R(T::*)(Args...,...)constvolatile&&,false>:basic_traits<true,T,R,Args...>{typedefR(T::*function_pointer_type)(Args...,...)constvolatile&&;};template<typenameSignature>structfx_traits<Signature,true>:fx_traits<typenamefx_traits<decltype(&Signature::operator())>::function_type,false>{};template<typenameSignature,boolb=std::is_member_object_pointer<Signature>::value>structcallable_traits:fx_traits<std::decay_t<Signature>>{};template<typenameR,typenameT>structcallable_traits<R(T::*),true>{typedefRArg;typedefTobject_type;usingsignature_type=R(T::*);staticconstboolis_member_function=false;staticconststd::size_tarity=1;staticconststd::size_tfree_arity=2;typedefstd::tuple<Arg>args_tuple;typedefRreturn_type;typedeftypes<Arg>args_list;typedeftypes<T,Arg>free_args_list;typedefmeta::tuple_types<R>returns_list;typedefR(function_type)(T&,R);typedefR(*function_pointer_type)(T&,R);typedefR(*free_function_pointer_type)(T&,R);template<std::size_ti>usingarg_at=void_tuple_element_t<i,args_tuple>;};}// meta_detailtemplate<typenameSignature>structbind_traits:meta_detail::callable_traits<Signature>{};template<typenameSignature>usingfunction_args_t=typenamebind_traits<Signature>::args_list;template<typenameSignature>usingfunction_signature_t=typenamebind_traits<Signature>::signature_type;template<typenameSignature>usingfunction_return_t=typenamebind_traits<Signature>::return_type;}// meta}// sol// end of sol/bind_traits.hpp#include<type_traits>#include<memory>#include<functional>namespacesol{template<std::size_tI>usingindex_value=std::integral_constant<std::size_t,I>;namespacemeta{template<typenameT>structidentity{typedefTtype;};template<typenameT>usingidentity_t=typenameidentity<T>::type;template<typename...Args>structis_tuple:std::false_type{};template<typename...Args>structis_tuple<std::tuple<Args...>>:std::true_type{};template<typenameT>structis_builtin_type:std::integral_constant<bool,std::is_arithmetic<T>::value||std::is_pointer<T>::value||std::is_array<T>::value>{};template<typenameT>structunwrapped{typedefTtype;};template<typenameT>structunwrapped<std::reference_wrapper<T>>{typedefTtype;};template<typenameT>usingunwrapped_t=typenameunwrapped<T>::type;template<typenameT>structunwrap_unqualified:unwrapped<unqualified_t<T>>{};template<typenameT>usingunwrap_unqualified_t=typenameunwrap_unqualified<T>::type;template<typenameT>structremove_member_pointer;template<typenameR,typenameT>structremove_member_pointer<RT::*>{typedefRtype;};template<typenameR,typenameT>structremove_member_pointer<RT::*const>{typedefRtype;};template<typenameT>usingremove_member_pointer_t=remove_member_pointer<T>;template<template<typename...>classTempl,typenameT>structis_specialization_of:std::false_type{};template<typename...T,template<typename...>classTempl>structis_specialization_of<Templ,Templ<T...>>:std::true_type{};template<classT,class...>structall_same:std::true_type{};template<classT,classU,class...Args>structall_same<T,U,Args...>:std::integral_constant<bool,std::is_same<T,U>::value&&all_same<T,Args...>::value>{};template<classT,class...>structany_same:std::false_type{};template<classT,classU,class...Args>structany_same<T,U,Args...>:std::integral_constant<bool,std::is_same<T,U>::value||any_same<T,Args...>::value>{};template<typenameT>usinginvoke_t=typenameT::type;template<boolB>usingboolean=std::integral_constant<bool,B>;template<typenameT>usingneg=boolean<!T::value>;template<typenameCondition,typenameThen,typenameElse>usingcondition=std::conditional_t<Condition::value,Then,Else>;template<typename...Args>structall:boolean<true>{};template<typenameT,typename...Args>structall<T,Args...>:condition<T,all<Args...>,boolean<false>>{};template<typename...Args>structany:boolean<false>{};template<typenameT,typename...Args>structany<T,Args...>:condition<T,boolean<true>,any<Args...>>{};enumclassenable_t{_};constexprconstautoenabler=enable_t::_;template<boolvalue,typenameT=void>usingdisable_if_t=std::enable_if_t<!value,T>;template<typename...Args>usingenable=std::enable_if_t<all<Args...>::value,enable_t>;template<typename...Args>usingdisable=std::enable_if_t<neg<all<Args...>>::value,enable_t>;template<typename...Args>usingdisable_any=std::enable_if_t<neg<any<Args...>>::value,enable_t>;template<typenameV,typename...Vs>structfind_in_pack_v:boolean<false>{};template<typenameV,typenameVs1,typename...Vs>structfind_in_pack_v<V,Vs1,Vs...>:any<boolean<(V::value==Vs1::value)>,find_in_pack_v<V,Vs...>>{};namespacemeta_detail{template<std::size_tI,typenameT,typename...Args>structindex_in_pack:std::integral_constant<std::size_t,SIZE_MAX>{};template<std::size_tI,typenameT,typenameT1,typename...Args>structindex_in_pack<I,T,T1,Args...>:std::conditional_t<std::is_same<T,T1>::value,std::integral_constant<std::ptrdiff_t,I>,index_in_pack<I+1,T,Args...>>{};}template<typenameT,typename...Args>structindex_in_pack:meta_detail::index_in_pack<0,T,Args...>{};template<typenameT,typenameList>structindex_in:meta_detail::index_in_pack<0,T,List>{};template<typenameT,typename...Args>structindex_in<T,types<Args...>>:meta_detail::index_in_pack<0,T,Args...>{};template<std::size_tI,typename...Args>structat_in_pack{};template<std::size_tI,typename...Args>usingat_in_pack_t=typenameat_in_pack<I,Args...>::type;template<std::size_tI,typenameArg,typename...Args>structat_in_pack<I,Arg,Args...>:std::conditional<I==0,Arg,at_in_pack_t<I-1,Args...>>{};template<typenameArg,typename...Args>structat_in_pack<0,Arg,Args...>{typedefArgtype;};namespacemeta_detail{template<std::size_tLimit,std::size_tI,template<typename...>classPred,typename...Ts>structcount_for_pack:std::integral_constant<std::size_t,0>{};template<std::size_tLimit,std::size_tI,template<typename...>classPred,typenameT,typename...Ts>structcount_for_pack<Limit,I,Pred,T,Ts...>:std::conditional_t<sizeof...(Ts)==0||Limit<2,std::integral_constant<std::size_t,I+static_cast<std::size_t>(Limit!=0&&Pred<T>::value)>,count_for_pack<Limit-1,I+static_cast<std::size_t>(Pred<T>::value),Pred,Ts...>>{};template<std::size_tI,template<typename...>classPred,typename...Ts>structcount_2_for_pack:std::integral_constant<std::size_t,0>{};template<std::size_tI,template<typename...>classPred,typenameT,typenameU,typename...Ts>structcount_2_for_pack<I,Pred,T,U,Ts...>:std::conditional_t<sizeof...(Ts)==0,std::integral_constant<std::size_t,I+static_cast<std::size_t>(Pred<T>::value)>,count_2_for_pack<I+static_cast<std::size_t>(Pred<T>::value),Pred,Ts...>>{};}// meta_detailtemplate<template<typename...>classPred,typename...Ts>structcount_for_pack:meta_detail::count_for_pack<sizeof...(Ts),0,Pred,Ts...>{};template<template<typename...>classPred,typenameList>structcount_for;template<template<typename...>classPred,typename...Args>structcount_for<Pred,types<Args...>>:count_for_pack<Pred,Args...>{};template<std::size_tLimit,template<typename...>classPred,typename...Ts>structcount_for_to_pack:meta_detail::count_for_pack<Limit,0,Pred,Ts...>{};template<template<typename...>classPred,typename...Ts>structcount_2_for_pack:meta_detail::count_2_for_pack<0,Pred,Ts...>{};template<typename...Args>structreturn_type{typedefstd::tuple<Args...>type;};template<typenameT>structreturn_type<T>{typedefTtype;};template<>structreturn_type<>{typedefvoidtype;};template<typename...Args>usingreturn_type_t=typenamereturn_type<Args...>::type;namespacemeta_detail{template<typename>structalways_true:std::true_type{};structis_invokable_tester{template<typenameFun,typename...Args>always_true<decltype(std::declval<Fun>()(std::declval<Args>()...))>statictest(int);template<typename...>std::false_typestatictest(...);};}// meta_detailtemplate<typenameT>structis_invokable;template<typenameFun,typename...Args>structis_invokable<Fun(Args...)>:decltype(meta_detail::is_invokable_tester::test<Fun,Args...>(0)){};namespacemeta_detail{template<typenameT,boolisclass=std::is_class<unqualified_t<T>>::value>structis_callable:std::is_function<std::remove_pointer_t<T>>{};template<typenameT>structis_callable<T,true>{usingyes=char;usingno=struct{chars[2];};structF{voidoperator()();};structDerived:T,F{};template<typenameU,U>structCheck;template<typenameV>staticnotest(Check<void(F::*)(),&V::operator()>*);template<typename>staticyestest(...);staticconstboolvalue=sizeof(test<Derived>(0))==sizeof(yes);};structhas_begin_end_impl{template<typenameT,typenameU=unqualified_t<T>,typenameB=decltype(std::declval<U&>().begin()),typenameE=decltype(std::declval<U&>().end())>staticstd::true_typetest(int);template<typename...>staticstd::false_typetest(...);};structhas_key_value_pair_impl{template<typenameT,typenameU=unqualified_t<T>,typenameV=typenameU::value_type,typenameF=decltype(std::declval<V&>().first),typenameS=decltype(std::declval<V&>().second)>staticstd::true_typetest(int);template<typename...>staticstd::false_typetest(...);};template<typenameT,typenameU=T,typename=decltype(std::declval<T&>()<std::declval<U&>())>std::true_typesupports_op_less_test(constT&);std::false_typesupports_op_less_test(...);template<typenameT,typenameU=T,typename=decltype(std::declval<T&>()==std::declval<U&>())>std::true_typesupports_op_equal_test(constT&);std::false_typesupports_op_equal_test(...);template<typenameT,typenameU=T,typename=decltype(std::declval<T&>()<=std::declval<U&>())>std::true_typesupports_op_less_equal_test(constT&);std::false_typesupports_op_less_equal_test(...);}// meta_detailtemplate<typenameT>usingsupports_op_less=decltype(meta_detail::supports_op_less_test(std::declval<T&>()));template<typenameT>usingsupports_op_equal=decltype(meta_detail::supports_op_equal_test(std::declval<T&>()));template<typenameT>usingsupports_op_less_equal=decltype(meta_detail::supports_op_less_equal_test(std::declval<T&>()));template<typenameT>structis_callable:boolean<meta_detail::is_callable<T>::value>{};template<typenameT>structhas_begin_end:decltype(meta_detail::has_begin_end_impl::test<T>(0)){};template<typenameT>structhas_key_value_pair:decltype(meta_detail::has_key_value_pair_impl::test<T>(0)){};template<typenameT>usingis_string_constructible=any<std::is_same<unqualified_t<T>,constchar*>,std::is_same<unqualified_t<T>,char>,std::is_same<unqualified_t<T>,std::string>,std::is_same<unqualified_t<T>,std::initializer_list<char>>>;template<typenameT>usingis_c_str=any<std::is_same<std::decay_t<unqualified_t<T>>,constchar*>,std::is_same<std::decay_t<unqualified_t<T>>,char*>,std::is_same<unqualified_t<T>,std::string>>;template<typenameT>structis_move_only:all<neg<std::is_reference<T>>,neg<std::is_copy_constructible<unqualified_t<T>>>,std::is_move_constructible<unqualified_t<T>>>{};template<typenameT>usingis_not_move_only=neg<is_move_only<T>>;namespacemeta_detail{template<typenameT,meta::disable<meta::is_specialization_of<std::tuple,meta::unqualified_t<T>>>=meta::enabler>decltype(auto)force_tuple(T&&x){returnstd::forward_as_tuple(std::forward<T>(x));}template<typenameT,meta::enable<meta::is_specialization_of<std::tuple,meta::unqualified_t<T>>>=meta::enabler>decltype(auto)force_tuple(T&&x){returnstd::forward<T>(x);}}// meta_detailtemplate<typename...X>decltype(auto)tuplefy(X&&...x){returnstd::tuple_cat(meta_detail::force_tuple(std::forward<X>(x))...);}}// metanamespacedetail{template<std::size_tI,typenameTuple>decltype(auto)forward_get(Tuple&&tuple){returnstd::forward<meta::tuple_element_t<I,Tuple>>(std::get<I>(tuple));}template<std::size_t...I,typenameTuple>autoforward_tuple_impl(std::index_sequence<I...>,Tuple&&tuple)->decltype(std::tuple<decltype(forward_get<I>(tuple))...>(forward_get<I>(tuple)...)){returnstd::tuple<decltype(forward_get<I>(tuple))...>(std::move(std::get<I>(tuple))...);}template<typenameTuple>autoforward_tuple(Tuple&&tuple){autox=forward_tuple_impl(std::make_index_sequence<std::tuple_size<meta::unqualified_t<Tuple>>::value>(),std::forward<Tuple>(tuple));returnx;}template<typenameT>autounwrap(T&&item)->decltype(std::forward<T>(item)){returnstd::forward<T>(item);}template<typenameT>T&unwrap(std::reference_wrapper<T>arg){returnarg.get();}template<typenameT>autoderef(T&&item)->decltype(std::forward<T>(item)){returnstd::forward<T>(item);}template<typenameT>inlineT&deref(T*item){return*item;}template<typenameT,typenameDx>inlinestd::add_lvalue_reference_t<T>deref(std::unique_ptr<T,Dx>&item){return*item;}template<typenameT>inlinestd::add_lvalue_reference_t<T>deref(std::shared_ptr<T>&item){return*item;}template<typenameT,typenameDx>inlinestd::add_lvalue_reference_t<T>deref(conststd::unique_ptr<T,Dx>&item){return*item;}template<typenameT>inlinestd::add_lvalue_reference_t<T>deref(conststd::shared_ptr<T>&item){return*item;}template<typenameT>inlineT*ptr(T&val){returnstd::addressof(val);}template<typenameT>inlineT*ptr(std::reference_wrapper<T>val){returnstd::addressof(val.get());}template<typenameT>inlineT*ptr(T*val){returnval;}}// detail}// sol// end of sol/traits.hpp// beginning of sol/object.hpp// beginning of sol/reference.hpp// beginning of sol/types.hpp// beginning of sol/optional.hpp// beginning of sol/compatibility.hpp// beginning of sol/compatibility/version.hpp#ifdef SOL_USING_CXX_LUA#include<lua.h>#include<lualib.h>#include<lauxlib.h>#else#include<lua.hpp>#endif // C++-compiler Lua#if defined(_WIN32) || defined(_MSC_VER)#ifndef SOL_CODECVT_SUPPORT#define SOL_CODECVT_SUPPORT 1#endif // sol codecvt support#elif defined(__GNUC__)#if __GNUC__ >= 5#ifndef SOL_CODECVT_SUPPORT#define SOL_CODECVT_SUPPORT 1#endif // codecvt support#endif // g++ 5.x.x (MinGW too)#else#endif // Windows/VC++ vs. g++ vs Others#ifdef LUAJIT_VERSION#ifndef SOL_LUAJIT#define SOL_LUAJIT#define SOL_LUAJIT_VERSION LUAJIT_VERSION_NUM#endif // sol luajit#endif // luajit#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 502#define SOL_LUA_VERSION LUA_VERSION_NUM#elif defined(LUA_VERSION_NUM) && LUA_VERSION_NUM == 501#define SOL_LUA_VERSION LUA_VERSION_NUM#elif !defined(LUA_VERSION_NUM)#define SOL_LUA_VERSION 500#else#define SOL_LUA_VERSION 502#endif // Lua Version 502, 501 || luajit, 500 #ifdef _MSC_VER#ifdef _DEBUG#ifndef NDEBUG#ifndef SOL_CHECK_ARGUMENTS#endif // Check Arguments#ifndef SOL_SAFE_USERTYPE#define SOL_SAFE_USERTYPE#endif // Safe Usertypes#endif // NDEBUG#endif // Debug#ifndef _CPPUNWIND#ifndef SOL_NO_EXCEPTIONS#define SOL_NO_EXCEPTIONS 1#endif#endif // Automatic Exceptions#ifndef _CPPRTTI#ifndef SOL_NO_RTTI#define SOL_NO_RTTI 1#endif#endif // Automatic RTTI#elif defined(__GNUC__) || defined(__clang__)#ifndef NDEBUG#ifndef __OPTIMIZE__#ifndef SOL_CHECK_ARGUMENTS#endif // Check Arguments#ifndef SOL_SAFE_USERTYPE#define SOL_SAFE_USERTYPE#endif // Safe Usertypes#endif // g++ optimizer flag#endif // Not Debug#ifndef __EXCEPTIONS#ifndef SOL_NO_EXCEPTIONS#define SOL_NO_EXCEPTIONS 1#endif#endif // No Exceptions#ifndef __GXX_RTTI#ifndef SOL_NO_RTII#define SOL_NO_RTTI 1#endif#endif // No RTTI#endif // vc++ || clang++/g++#ifndef SOL_SAFE_USERTYPE#ifdef SOL_CHECK_ARGUMENTS#define SOL_SAFE_USERTYPE#endif // Turn on Safety for all#endif // Safe Usertypes// end of sol/compatibility/version.hpp#ifndef SOL_NO_COMPAT#ifdef __cplusplusextern"C"{#endif// beginning of sol/compatibility/5.1.0.h#ifndef SOL_5_1_0_H#define SOL_5_1_0_H#if SOL_LUA_VERSION == 501/* Lua 5.1 */#include<stddef.h>#include<string.h>#include<stdio.h>/* LuaJIT doesn't define these unofficial macros ... */#if !defined(LUAI_INT32)#include<limits.h>#if INT_MAX-20 < 32760#define LUAI_INT32 long#define LUAI_UINT32 unsigned long#elif INT_MAX > 2147483640L#define LUAI_INT32 int#define LUAI_UINT32 unsigned int#else#error "could not detect suitable lua_Unsigned datatype"#endif#endif/* LuaJIT does not have the updated error codes for thread status/function returns */#ifndef LUA_ERRGCMM#define LUA_ERRGCMM (LUA_ERRERR + 1)#endif // LUA_ERRGCMM/* LuaJIT does not support continuation contexts / return error codes? */#ifndef LUA_KCONTEXT#define LUA_KCONTEXT std::ptrdiff_ttypedefLUA_KCONTEXTlua_KContext;typedefint(*lua_KFunction)(lua_State*L,intstatus,lua_KContextctx);#endif // LUA_KCONTEXT#define LUA_OPADD 0#define LUA_OPSUB 1#define LUA_OPMUL 2#define LUA_OPDIV 3#define LUA_OPMOD 4#define LUA_OPPOW 5#define LUA_OPUNM 6#define LUA_OPEQ 0#define LUA_OPLT 1#define LUA_OPLE 2typedefLUAI_UINT32lua_Unsigned;typedefstructluaL_Buffer_52{luaL_Bufferb;/* make incorrect code crash! */char*ptr;size_tnelems;size_tcapacity;lua_State*L2;}luaL_Buffer_52;#define luaL_Buffer luaL_Buffer_52#define lua_tounsigned(L, i) lua_tounsignedx(L, i, NULL)#define lua_rawlen(L, i) lua_objlen(L, i)inlinevoidlua_callk(lua_State*L,intnargs,intnresults,lua_KContext,lua_KFunction){// should probably warn the user of Lua 5.1 that continuation isn't supported...lua_call(L,nargs,nresults);}inlineintlua_pcallk(lua_State*L,intnargs,intnresults,interrfunc,lua_KContext,lua_KFunction){// should probably warn the user of Lua 5.1 that continuation isn't supported...returnlua_pcall(L,nargs,nresults,errfunc);}voidlua_arith(lua_State*L,intop);intlua_compare(lua_State*L,intidx1,intidx2,intop);voidlua_pushunsigned(lua_State*L,lua_Unsignedn);lua_UnsignedluaL_checkunsigned(lua_State*L,inti);lua_Unsignedlua_tounsignedx(lua_State*L,inti,int*isnum);lua_UnsignedluaL_optunsigned(lua_State*L,inti,lua_Unsigneddef);lua_Integerlua_tointegerx(lua_State*L,inti,int*isnum);voidlua_len(lua_State*L,inti);intluaL_len(lua_State*L,inti);constchar*luaL_tolstring(lua_State*L,intidx,size_t*len);voidluaL_requiref(lua_State*L,charconst*modname,lua_CFunctionopenf,intglb);#define luaL_buffinit luaL_buffinit_52voidluaL_buffinit(lua_State*L,luaL_Buffer_52*B);#define luaL_prepbuffsize luaL_prepbuffsize_52char*luaL_prepbuffsize(luaL_Buffer_52*B,size_ts);#define luaL_addlstring luaL_addlstring_52voidluaL_addlstring(luaL_Buffer_52*B,constchar*s,size_tl);#define luaL_addvalue luaL_addvalue_52voidluaL_addvalue(luaL_Buffer_52*B);#define luaL_pushresult luaL_pushresult_52voidluaL_pushresult(luaL_Buffer_52*B);#undef luaL_buffinitsize#define luaL_buffinitsize(L, B, s) \ (luaL_buffinit(L, B), luaL_prepbuffsize(B, s))#undef luaL_prepbuffer#define luaL_prepbuffer(B) \ luaL_prepbuffsize(B, LUAL_BUFFERSIZE)#undef luaL_addchar#define luaL_addchar(B, c) \ ((void)((B)->nelems < (B)->capacity || luaL_prepbuffsize(B, 1)), \ ((B)->ptr[(B)->nelems++] = (c)))#undef luaL_addsize#define luaL_addsize(B, s) \ ((B)->nelems += (s))#undef luaL_addstring#define luaL_addstring(B, s) \ luaL_addlstring(B, s, strlen(s))#undef luaL_pushresultsize#define luaL_pushresultsize(B, s) \ (luaL_addsize(B, s), luaL_pushresult(B))typedefstructkepler_lua_compat_get_string_view{constchar*s;size_tsize;}kepler_lua_compat_get_string_view;inlineconstchar*kepler_lua_compat_get_string(lua_State*L,void*ud,size_t*size){kepler_lua_compat_get_string_view*ls=(kepler_lua_compat_get_string_view*)ud;(void)L;if(ls->size==0)returnNULL;*size=ls->size;ls->size=0;returnls->s;}#if !defined(SOL_LUAJIT) || (SOL_LUAJIT_VERSION < 20100)inlineintluaL_loadbufferx(lua_State*L,constchar*buff,size_tsize,constchar*name,constchar*){kepler_lua_compat_get_string_viewls;ls.s=buff;ls.size=size;returnlua_load(L,kepler_lua_compat_get_string,&ls,name/*, mode*/);}#endif // LuaJIT 2.1.x beta and beyond#endif /* Lua 5.1 */#endif // SOL_5_1_0_H// end of sol/compatibility/5.1.0.h// beginning of sol/compatibility/5.0.0.h#ifndef SOL_5_0_0_H#define SOL_5_0_0_H#if SOL_LUA_VERSION < 501/* Lua 5.0 */#define LUA_QL(x) "'" x "'"#define LUA_QS LUA_QL("%s")#define luaL_Reg luaL_reg#define luaL_opt(L, f, n, d) \ (lua_isnoneornil(L, n) ? (d) : f(L, n))#define luaL_addchar(B,c) \ ((void)((B)->p < ((B)->buffer+LUAL_BUFFERSIZE) || luaL_prepbuffer(B)), \ (*(B)->p++ = (char)(c)))#endif // Lua 5.0#endif // SOL_5_0_0_H// end of sol/compatibility/5.0.0.h// beginning of sol/compatibility/5.x.x.h#ifndef SOL_5_X_X_H#define SOL_5_X_X_H#if SOL_LUA_VERSION < 502#define LUA_RIDX_GLOBALS LUA_GLOBALSINDEX#define LUA_OK 0#define lua_pushglobaltable(L) \ lua_pushvalue(L, LUA_GLOBALSINDEX)#define luaL_newlib(L, l) \ (lua_newtable((L)),luaL_setfuncs((L), (l), 0))voidluaL_checkversion(lua_State*L);intlua_absindex(lua_State*L,inti);voidlua_copy(lua_State*L,intfrom,intto);voidlua_rawgetp(lua_State*L,inti,constvoid*p);voidlua_rawsetp(lua_State*L,inti,constvoid*p);void*luaL_testudata(lua_State*L,inti,constchar*tname);lua_Numberlua_tonumberx(lua_State*L,inti,int*isnum);voidlua_getuservalue(lua_State*L,inti);voidlua_setuservalue(lua_State*L,inti);voidluaL_setfuncs(lua_State*L,constluaL_Reg*l,intnup);voidluaL_setmetatable(lua_State*L,constchar*tname);intluaL_getsubtable(lua_State*L,inti,constchar*name);voidluaL_traceback(lua_State*L,lua_State*L1,constchar*msg,intlevel);intluaL_fileresult(lua_State*L,intstat,constchar*fname);#endif // Lua 5.1 and below#endif // SOL_5_X_X_H// end of sol/compatibility/5.x.x.h// beginning of sol/compatibility/5.x.x.inl#ifndef SOL_5_X_X_INL#define SOL_5_X_X_INL// beginning of sol/compatibility/5.2.0.h#ifndef SOL_5_2_0_H#define SOL_5_2_0_H#if SOL_LUA_VERSION < 503inlineintlua_isinteger(lua_State*L,intidx){if(lua_type(L,idx)!=LUA_TNUMBER)return0;// This is a very slipshod way to do the testing// but lua_totingerx doesn't play ball nicely// on older versions...lua_Numbern=lua_tonumber(L,idx);lua_Integeri=lua_tointeger(L,idx);if(i!=n)return0;// it's DEFINITELY an integerreturn1;}#endif // SOL_LUA_VERSION == 502#endif // SOL_5_2_0_H// end of sol/compatibility/5.2.0.h#if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM == 501#include<errno.h>#define PACKAGE_KEY "_sol.package"inlineintlua_absindex(lua_State*L,inti){if(i<0&&i>LUA_REGISTRYINDEX)i+=lua_gettop(L)+1;returni;}inlinevoidlua_copy(lua_State*L,intfrom,intto){intabs_to=lua_absindex(L,to);luaL_checkstack(L,1,"not enough stack slots");lua_pushvalue(L,from);lua_replace(L,abs_to);}inlinevoidlua_rawgetp(lua_State*L,inti,constvoid*p){intabs_i=lua_absindex(L,i);lua_pushlightuserdata(L,(void*)p);lua_rawget(L,abs_i);}inlinevoidlua_rawsetp(lua_State*L,inti,constvoid*p){intabs_i=lua_absindex(L,i);luaL_checkstack(L,1,"not enough stack slots");lua_pushlightuserdata(L,(void*)p);lua_insert(L,-2);lua_rawset(L,abs_i);}inlinevoid*luaL_testudata(lua_State*L,inti,constchar*tname){void*p=lua_touserdata(L,i);luaL_checkstack(L,2,"not enough stack slots");if(p==NULL||!lua_getmetatable(L,i))returnNULL;else{intres=0;luaL_getmetatable(L,tname);res=lua_rawequal(L,-1,-2);lua_pop(L,2);if(!res)p=NULL;}returnp;}inlinelua_Numberlua_tonumberx(lua_State*L,inti,int*isnum){lua_Numbern=lua_tonumber(L,i);if(isnum!=NULL){*isnum=(n!=0||lua_isnumber(L,i));}returnn;}inlinestaticvoidpush_package_table(lua_State*L){lua_pushliteral(L,PACKAGE_KEY);lua_rawget(L,LUA_REGISTRYINDEX);if(!lua_istable(L,-1)){lua_pop(L,1);/* try to get package table from globals */lua_pushliteral(L,"package");lua_rawget(L,LUA_GLOBALSINDEX);if(lua_istable(L,-1)){lua_pushliteral(L,PACKAGE_KEY);lua_pushvalue(L,-2);lua_rawset(L,LUA_REGISTRYINDEX);}}}inlinevoidlua_getuservalue(lua_State*L,inti){luaL_checktype(L,i,LUA_TUSERDATA);luaL_checkstack(L,2,"not enough stack slots");lua_getfenv(L,i);lua_pushvalue(L,LUA_GLOBALSINDEX);if(lua_rawequal(L,-1,-2)){lua_pop(L,1);lua_pushnil(L);lua_replace(L,-2);}else{lua_pop(L,1);push_package_table(L);if(lua_rawequal(L,-1,-2)){lua_pop(L,1);lua_pushnil(L);lua_replace(L,-2);}elselua_pop(L,1);}}inlinevoidlua_setuservalue(lua_State*L,inti){luaL_checktype(L,i,LUA_TUSERDATA);if(lua_isnil(L,-1)){luaL_checkstack(L,1,"not enough stack slots");lua_pushvalue(L,LUA_GLOBALSINDEX);lua_replace(L,-2);}lua_setfenv(L,i);}/*** Adapted from Lua 5.2.0*/inlinevoidluaL_setfuncs(lua_State*L,constluaL_Reg*l,intnup){luaL_checkstack(L,nup+1,"too many upvalues");for(;l->name!=NULL;l++){/* fill the table with given functions */inti;lua_pushstring(L,l->name);for(i=0;i<nup;i++)/* copy upvalues to the top */lua_pushvalue(L,-(nup+1));lua_pushcclosure(L,l->func,nup);/* closure with those upvalues */lua_settable(L,-(nup+3));/* table must be below the upvalues, the name and the closure */}lua_pop(L,nup);/* remove upvalues */}inlinevoidluaL_setmetatable(lua_State*L,constchar*tname){luaL_checkstack(L,1,"not enough stack slots");luaL_getmetatable(L,tname);lua_setmetatable(L,-2);}inlineintluaL_getsubtable(lua_State*L,inti,constchar*name){intabs_i=lua_absindex(L,i);luaL_checkstack(L,3,"not enough stack slots");lua_pushstring(L,name);lua_gettable(L,abs_i);if(lua_istable(L,-1))return1;lua_pop(L,1);lua_newtable(L);lua_pushstring(L,name);lua_pushvalue(L,-2);lua_settable(L,abs_i);return0;}#ifndef SOL_LUAJITinlinestaticintcountlevels(lua_State*L){lua_Debugar;intli=1,le=1;/* find an upper bound */while(lua_getstack(L,le,&ar)){li=le;le*=2;}/* do a binary search */while(li<le){intm=(li+le)/2;if(lua_getstack(L,m,&ar))li=m+1;elsele=m;}returnle-1;}inlinestaticintfindfield(lua_State*L,intobjidx,intlevel){if(level==0||!lua_istable(L,-1))return0;/* not found */lua_pushnil(L);/* start 'next' loop */while(lua_next(L,-2)){/* for each pair in table */if(lua_type(L,-2)==LUA_TSTRING){/* ignore non-string keys */if(lua_rawequal(L,objidx,-1)){/* found object? */lua_pop(L,1);/* remove value (but keep name) */return1;}elseif(findfield(L,objidx,level-1)){/* try recursively */lua_remove(L,-2);/* remove table (but keep name) */lua_pushliteral(L,".");lua_insert(L,-2);/* place '.' between the two names */lua_concat(L,3);return1;}}lua_pop(L,1);/* remove value */}return0;/* not found */}inlinestaticintpushglobalfuncname(lua_State*L,lua_Debug*ar){inttop=lua_gettop(L);lua_getinfo(L,"f",ar);/* push function */lua_pushvalue(L,LUA_GLOBALSINDEX);if(findfield(L,top+1,2)){lua_copy(L,-1,top+1);/* move name to proper place */lua_pop(L,2);/* remove pushed values */return1;}else{lua_settop(L,top);/* remove function and global table */return0;}}inlinestaticvoidpushfuncname(lua_State*L,lua_Debug*ar){if(*ar->namewhat!='\0')/* is there a name? */lua_pushfstring(L,"function "LUA_QS,ar->name);elseif(*ar->what=='m')/* main? */lua_pushliteral(L,"main chunk");elseif(*ar->what=='C'){if(pushglobalfuncname(L,ar)){lua_pushfstring(L,"function "LUA_QS,lua_tostring(L,-1));lua_remove(L,-2);/* remove name */}elselua_pushliteral(L,"?");}elselua_pushfstring(L,"function <%s:%d>",ar->short_src,ar->linedefined);}#define LEVELS1 12 /* size of the first part of the stack */#define LEVELS2 10 /* size of the second part of the stack */inlinevoidluaL_traceback(lua_State*L,lua_State*L1,constchar*msg,intlevel){lua_Debugar;inttop=lua_gettop(L);intnumlevels=countlevels(L1);intmark=(numlevels>LEVELS1+LEVELS2)?LEVELS1:0;if(msg)lua_pushfstring(L,"%s\n",msg);lua_pushliteral(L,"stack traceback:");while(lua_getstack(L1,level++,&ar)){if(level==mark){/* too many levels? */lua_pushliteral(L,"\n\t...");/* add a '...' */level=numlevels-LEVELS2;/* and skip to last ones */}else{lua_getinfo(L1,"Slnt",&ar);lua_pushfstring(L,"\n\t%s:",ar.short_src);if(ar.currentline>0)lua_pushfstring(L,"%d:",ar.currentline);lua_pushliteral(L," in ");pushfuncname(L,&ar);lua_concat(L,lua_gettop(L)-top);}}lua_concat(L,lua_gettop(L)-top);}#endifinlineconstlua_Number*lua_version(lua_State*L){staticconstlua_Numberversion=LUA_VERSION_NUM;if(L==NULL)return&version;// TODO: wonky hacks to get at the inside of the incomplete type lua_State?//else return L->l_G->version;elsereturn&version;}inlinestaticvoidluaL_checkversion_(lua_State*L,lua_Numberver){constlua_Number*v=lua_version(L);if(v!=lua_version(NULL))luaL_error(L,"multiple Lua VMs detected");elseif(*v!=ver)luaL_error(L,"version mismatch: app. needs %f, Lua core provides %f",ver,*v);/* check conversions number -> integer types */lua_pushnumber(L,-(lua_Number)0x1234);if(lua_tointeger(L,-1)!=-0x1234||lua_tounsigned(L,-1)!=(lua_Unsigned)-0x1234)luaL_error(L,"bad conversion number->int;"" must recompile Lua with proper settings");lua_pop(L,1);}inlinevoidluaL_checkversion(lua_State*L){luaL_checkversion_(L,LUA_VERSION_NUM);}#ifndef SOL_LUAJITinlineintluaL_fileresult(lua_State*L,intstat,constchar*fname){inten=errno;/* calls to Lua API may change this value */if(stat){lua_pushboolean(L,1);return1;}else{charbuf[1024];#if defined(__GLIBC__) || defined(_POSIX_VERSION)strerror_r(en,buf,1024);#elsestrerror_s(buf,1024,en);#endiflua_pushnil(L);if(fname)lua_pushfstring(L,"%s: %s",fname,buf);elselua_pushstring(L,buf);lua_pushnumber(L,(lua_Number)en);return3;}}#endif // luajit#endif // Lua 5.0 or Lua 5.1#if SOL_LUA_VERSION == 501typedefLUAI_INT32LUA_INT32;/********************************************************************//* extract of 5.2's luaconf.h *//* detects proper defines for faster unsigned<->number conversion *//* see copyright notice at the end of this file *//********************************************************************/#if !defined(LUA_ANSI) && defined(_WIN32) && !defined(_WIN32_WCE)#define LUA_WIN /* enable goodies for regular Windows platforms */#endif#if defined(LUA_NUMBER_DOUBLE) && !defined(LUA_ANSI) /* { *//* Microsoft compiler on a Pentium (32 bit) ? */#if defined(LUA_WIN) && defined(_MSC_VER) && defined(_M_IX86) /* { */#define LUA_MSASMTRICK#define LUA_IEEEENDIAN 0#define LUA_NANTRICK/* pentium 32 bits? */#elif defined(__i386__) || defined(__i386) || defined(__X86__) /* }{ */#define LUA_IEEE754TRICK#define LUA_IEEELL#define LUA_IEEEENDIAN 0#define LUA_NANTRICK/* pentium 64 bits? */#elif defined(__x86_64) /* }{ */#define LUA_IEEE754TRICK#define LUA_IEEEENDIAN 0#elif defined(__POWERPC__) || defined(__ppc__) /* }{ */#define LUA_IEEE754TRICK#define LUA_IEEEENDIAN 1#else /* }{ *//* assume IEEE754 and a 32-bit integer type */#define LUA_IEEE754TRICK#endif /* } */#endif /* } *//********************************************************************//* extract of 5.2's llimits.h *//* gives us lua_number2unsigned and lua_unsigned2number *//* see copyright notice just below this one here *//********************************************************************//********************************************************************** This file contains parts of Lua 5.2's source code:** Copyright (C) 1994-2013 Lua.org, PUC-Rio.** Permission is hereby granted, free of charge, to any person obtaining* a copy of this software and associated documentation files (the* "Software"), to deal in the Software without restriction, including* without limitation the rights to use, copy, modify, merge, publish,* distribute, sublicense, and/or sell copies of the Software, and to* permit persons to whom the Software is furnished to do so, subject to* the following conditions:** The above copyright notice and this permission notice shall be* included in all copies or substantial portions of the Software.** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.*********************************************************************/#if defined(MS_ASMTRICK) || defined(LUA_MSASMTRICK) /* { *//* trick with Microsoft assembler for X86 */#define lua_number2unsigned(i,n) \ {__int64 l; __asm {__asm fld n __asm fistp l} i = (unsigned int)l;}#elif defined(LUA_IEEE754TRICK) /* }{ *//* the next trick should work on any machine using IEEE754 witha 32-bit int type */unioncompat52_luai_Cast{doublel_d;LUA_INT32l_p[2];};#if !defined(LUA_IEEEENDIAN) /* { */#define LUAI_EXTRAIEEE \ static const union compat52_luai_Cast ieeeendian = {-(33.0 + 6755399441055744.0)};#define LUA_IEEEENDIANLOC (ieeeendian.l_p[1] == 33)#else#define LUA_IEEEENDIANLOC LUA_IEEEENDIAN#define LUAI_EXTRAIEEE /* empty */#endif /* } */#define lua_number2int32(i,n,t) \ { LUAI_EXTRAIEEE \ volatile union compat52_luai_Cast u; u.l_d = (n) + 6755399441055744.0; \ (i) = (t)u.l_p[LUA_IEEEENDIANLOC]; }#define lua_number2unsigned(i,n) lua_number2int32(i, n, lua_Unsigned)#endif /* } *//* the following definitions always work, but may be slow */#if !defined(lua_number2unsigned) /* { *//* the following definition assures proper modulo behavior */#if defined(LUA_NUMBER_DOUBLE) || defined(LUA_NUMBER_FLOAT)#include<math.h>#define SUPUNSIGNED ((lua_Number)(~(lua_Unsigned)0) + 1)#define lua_number2unsigned(i,n) \ ((i)=(lua_Unsigned)((n) - floor((n)/SUPUNSIGNED)*SUPUNSIGNED))#else#define lua_number2unsigned(i,n) ((i)=(lua_Unsigned)(n))#endif#endif /* } */#if !defined(lua_unsigned2number)/* on several machines, coercion from unsigned to double is slow,so it may be worth to avoid */#define lua_unsigned2number(u) \ (((u) <= (lua_Unsigned)INT_MAX) ? (lua_Number)(int)(u) : (lua_Number)(u))#endif/********************************************************************/inlinestaticvoidcompat52_call_lua(lua_State*L,charconstcode[],size_tlen,intnargs,intnret){lua_rawgetp(L,LUA_REGISTRYINDEX,(void*)code);if(lua_type(L,-1)!=LUA_TFUNCTION){lua_pop(L,1);if(luaL_loadbuffer(L,code,len,"=none"))lua_error(L);lua_pushvalue(L,-1);lua_rawsetp(L,LUA_REGISTRYINDEX,(void*)code);}lua_insert(L,-nargs-1);lua_call(L,nargs,nret);}staticconstcharcompat52_arith_code[]={"local op,a,b=...\n""if op==0 then return a+b\n""elseif op==1 then return a-b\n""elseif op==2 then return a*b\n""elseif op==3 then return a/b\n""elseif op==4 then return a%b\n""elseif op==5 then return a^b\n""elseif op==6 then return -a\n""end\n"};inlinevoidlua_arith(lua_State*L,intop){if(op<LUA_OPADD||op>LUA_OPUNM)luaL_error(L,"invalid 'op' argument for lua_arith");luaL_checkstack(L,5,"not enough stack slots");if(op==LUA_OPUNM)lua_pushvalue(L,-1);lua_pushnumber(L,op);lua_insert(L,-3);compat52_call_lua(L,compat52_arith_code,sizeof(compat52_arith_code)-1,3,1);}staticconstcharcompat52_compare_code[]={"local a,b=...\n""return a<=b\n"};inlineintlua_compare(lua_State*L,intidx1,intidx2,intop){intresult=0;switch(op){caseLUA_OPEQ:returnlua_equal(L,idx1,idx2);caseLUA_OPLT:returnlua_lessthan(L,idx1,idx2);caseLUA_OPLE:luaL_checkstack(L,5,"not enough stack slots");idx1=lua_absindex(L,idx1);idx2=lua_absindex(L,idx2);lua_pushvalue(L,idx1);lua_pushvalue(L,idx2);compat52_call_lua(L,compat52_compare_code,sizeof(compat52_compare_code)-1,2,1);result=lua_toboolean(L,-1);lua_pop(L,1);returnresult;default:luaL_error(L,"invalid 'op' argument for lua_compare");}return0;}inlinevoidlua_pushunsigned(lua_State*L,lua_Unsignedn){lua_pushnumber(L,lua_unsigned2number(n));}inlinelua_UnsignedluaL_checkunsigned(lua_State*L,inti){lua_Unsignedresult;lua_Numbern=lua_tonumber(L,i);if(n==0&&!lua_isnumber(L,i))luaL_checktype(L,i,LUA_TNUMBER);lua_number2unsigned(result,n);returnresult;}inlinelua_Unsignedlua_tounsignedx(lua_State*L,inti,int*isnum){lua_Unsignedresult;lua_Numbern=lua_tonumberx(L,i,isnum);lua_number2unsigned(result,n);returnresult;}inlinelua_UnsignedluaL_optunsigned(lua_State*L,inti,lua_Unsigneddef){returnluaL_opt(L,luaL_checkunsigned,i,def);}inlinelua_Integerlua_tointegerx(lua_State*L,inti,int*isnum){lua_Integern=lua_tointeger(L,i);if(isnum!=NULL){*isnum=(n!=0||lua_isnumber(L,i));}returnn;}inlinevoidlua_len(lua_State*L,inti){switch(lua_type(L,i)){caseLUA_TSTRING:/* fall through */caseLUA_TTABLE:if(!luaL_callmeta(L,i,"__len"))lua_pushnumber(L,(int)lua_objlen(L,i));break;caseLUA_TUSERDATA:if(luaL_callmeta(L,i,"__len"))break;/* maybe fall through */default:luaL_error(L,"attempt to get length of a %s value",lua_typename(L,lua_type(L,i)));}}inlineintluaL_len(lua_State*L,inti){intres=0,isnum=0;luaL_checkstack(L,1,"not enough stack slots");lua_len(L,i);res=(int)lua_tointegerx(L,-1,&isnum);lua_pop(L,1);if(!isnum)luaL_error(L,"object length is not a number");returnres;}inlineconstchar*luaL_tolstring(lua_State*L,intidx,size_t*len){if(!luaL_callmeta(L,idx,"__tostring")){intt=lua_type(L,idx);switch(t){caseLUA_TNIL:lua_pushliteral(L,"nil");break;caseLUA_TSTRING:caseLUA_TNUMBER:lua_pushvalue(L,idx);break;caseLUA_TBOOLEAN:if(lua_toboolean(L,idx))lua_pushliteral(L,"true");elselua_pushliteral(L,"false");break;default:lua_pushfstring(L,"%s: %p",lua_typename(L,t),lua_topointer(L,idx));break;}}returnlua_tolstring(L,-1,len);}inlinevoidluaL_requiref(lua_State*L,charconst*modname,lua_CFunctionopenf,intglb){luaL_checkstack(L,3,"not enough stack slots");lua_pushcfunction(L,openf);lua_pushstring(L,modname);lua_call(L,1,1);lua_getglobal(L,"package");if(lua_istable(L,-1)==0){lua_pop(L,1);lua_createtable(L,0,16);lua_setglobal(L,"package");lua_getglobal(L,"package");}lua_getfield(L,-1,"loaded");if(lua_istable(L,-1)==0){lua_pop(L,1);lua_createtable(L,0,1);lua_setfield(L,-2,"loaded");lua_getfield(L,-1,"loaded");}lua_replace(L,-2);lua_pushvalue(L,-2);lua_setfield(L,-2,modname);lua_pop(L,1);if(glb){lua_pushvalue(L,-1);lua_setglobal(L,modname);}}inlinevoidluaL_buffinit(lua_State*L,luaL_Buffer_52*B){/* make it crash if used via pointer to a 5.1-style luaL_Buffer */B->b.p=NULL;B->b.L=NULL;B->b.lvl=0;/* reuse the buffer from the 5.1-style luaL_Buffer though! */B->ptr=B->b.buffer;B->capacity=LUAL_BUFFERSIZE;B->nelems=0;B->L2=L;}inlinechar*luaL_prepbuffsize(luaL_Buffer_52*B,size_ts){if(B->capacity-B->nelems<s){/* needs to grow */char*newptr=NULL;size_tnewcap=B->capacity*2;if(newcap-B->nelems<s)newcap=B->nelems+s;if(newcap<B->capacity)/* overflow */luaL_error(B->L2,"buffer too large");newptr=(char*)lua_newuserdata(B->L2,newcap);memcpy(newptr,B->ptr,B->nelems);if(B->ptr!=B->b.buffer)lua_replace(B->L2,-2);/* remove old buffer */B->ptr=newptr;B->capacity=newcap;}returnB->ptr+B->nelems;}inlinevoidluaL_addlstring(luaL_Buffer_52*B,constchar*s,size_tl){memcpy(luaL_prepbuffsize(B,l),s,l);luaL_addsize(B,l);}inlinevoidluaL_addvalue(luaL_Buffer_52*B){size_tlen=0;constchar*s=lua_tolstring(B->L2,-1,&len);if(!s)luaL_error(B->L2,"cannot convert value to string");if(B->ptr!=B->b.buffer)lua_insert(B->L2,-2);/* userdata buffer must be at stack top */luaL_addlstring(B,s,len);lua_remove(B->L2,B->ptr!=B->b.buffer?-2:-1);}inlinevoidluaL_pushresult(luaL_Buffer_52*B){lua_pushlstring(B->L2,B->ptr,B->nelems);if(B->ptr!=B->b.buffer)lua_replace(B->L2,-2);/* remove userdata buffer */}#endif /* SOL_LUA_VERSION == 501 */#endif // SOL_5_X_X_INL// end of sol/compatibility/5.x.x.inl#ifdef __cplusplus}#endif#endif // SOL_NO_COMPAT// end of sol/compatibility.hpp// beginning of sol/in_place.hppnamespacesol{namespacedetail{structin_place_of{};template<std::size_tI>structin_place_of_i{};template<typenameT>structin_place_of_t{};}// detailstructin_place_tag{structinit{};constexprin_place_tag(init){}in_place_tag()=delete;};constexprinlinein_place_tagin_place(detail::in_place_of){returnin_place_tag(in_place_tag::init());}template<typenameT>constexprinlinein_place_tagin_place(detail::in_place_of_t<T>){returnin_place_tag(in_place_tag::init());}template<std::size_tI>constexprinlinein_place_tagin_place(detail::in_place_of_i<I>){returnin_place_tag(in_place_tag::init());}usingin_place_t=in_place_tag(&)(detail::in_place_of);template<typenameT>usingin_place_type_t=in_place_tag(&)(detail::in_place_of_t<T>);template<std::size_tI>usingin_place_index_t=in_place_tag(&)(detail::in_place_of_i<I>);}// sol// end of sol/in_place.hpp#if defined(SOL_USE_BOOST)#include<boost/optional.hpp>#else// beginning of sol/optional_implementation.hpp# ifndef SOL_OPTIONAL_IMPLEMENTATION_HPP# define SOL_OPTIONAL_IMPLEMENTATION_HPP#include<utility>#include<type_traits>#include<initializer_list>#include<cassert>#include<functional>#include<string>#include<stdexcept>#ifdef SOL_NO_EXCEPTIONS#include<cstdlib>#endif // Exceptions# define TR2_OPTIONAL_REQUIRES(...) typename ::std::enable_if<__VA_ARGS__::value, bool>::type = false# if defined __GNUC__ // NOTE: GNUC is also defined for Clang# if (__GNUC__ >= 5)# define TR2_OPTIONAL_GCC_5_0_AND_HIGHER___# define TR2_OPTIONAL_GCC_4_8_AND_HIGHER___# elif (__GNUC__ == 4) && (__GNUC_MINOR__ >= 8)# define TR2_OPTIONAL_GCC_4_8_AND_HIGHER___# elif (__GNUC__ > 4)# define TR2_OPTIONAL_GCC_4_8_AND_HIGHER___# endif## if (__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)# define TR2_OPTIONAL_GCC_4_7_AND_HIGHER___# elif (__GNUC__ > 4)# define TR2_OPTIONAL_GCC_4_7_AND_HIGHER___# endif## if (__GNUC__ == 4) && (__GNUC_MINOR__ == 8) && (__GNUC_PATCHLEVEL__ >= 1)# define TR2_OPTIONAL_GCC_4_8_1_AND_HIGHER___# elif (__GNUC__ == 4) && (__GNUC_MINOR__ >= 9)# define TR2_OPTIONAL_GCC_4_8_1_AND_HIGHER___# elif (__GNUC__ > 4)# define TR2_OPTIONAL_GCC_4_8_1_AND_HIGHER___# endif# endif## if defined __clang_major__# if (__clang_major__ == 3 && __clang_minor__ >= 5)# define TR2_OPTIONAL_CLANG_3_5_AND_HIGHTER_# elif (__clang_major__ > 3)# define TR2_OPTIONAL_CLANG_3_5_AND_HIGHTER_# endif# if defined TR2_OPTIONAL_CLANG_3_5_AND_HIGHTER_# define TR2_OPTIONAL_CLANG_3_4_2_AND_HIGHER_# elif (__clang_major__ == 3 && __clang_minor__ == 4 && __clang_patchlevel__ >= 2)# define TR2_OPTIONAL_CLANG_3_4_2_AND_HIGHER_# endif# endif## if defined _MSC_VER# if (_MSC_VER >= 1900)# define TR2_OPTIONAL_MSVC_2015_AND_HIGHER___# endif# endif# if defined __clang__# if (__clang_major__ > 2) || (__clang_major__ == 2) && (__clang_minor__ >= 9)# define OPTIONAL_HAS_THIS_RVALUE_REFS 1# else# define OPTIONAL_HAS_THIS_RVALUE_REFS 0# endif# elif defined TR2_OPTIONAL_GCC_4_8_1_AND_HIGHER___# define OPTIONAL_HAS_THIS_RVALUE_REFS 1# elif defined TR2_OPTIONAL_MSVC_2015_AND_HIGHER___# define OPTIONAL_HAS_THIS_RVALUE_REFS 1# else# define OPTIONAL_HAS_THIS_RVALUE_REFS 0# endif# if defined TR2_OPTIONAL_GCC_4_8_1_AND_HIGHER___# define OPTIONAL_HAS_CONSTEXPR_INIT_LIST 1# define OPTIONAL_CONSTEXPR_INIT_LIST constexpr# else# define OPTIONAL_HAS_CONSTEXPR_INIT_LIST 0# define OPTIONAL_CONSTEXPR_INIT_LIST# endif# if defined(TR2_OPTIONAL_MSVC_2015_AND_HIGHER___) || (defined TR2_OPTIONAL_CLANG_3_5_AND_HIGHTER_ && (defined __cplusplus) && (__cplusplus != 201103L))# define OPTIONAL_HAS_MOVE_ACCESSORS 1# else# define OPTIONAL_HAS_MOVE_ACCESSORS 0# endif# // In C++11 constexpr implies const, so we need to make non-const members also non-constexpr# if defined(TR2_OPTIONAL_MSVC_2015_AND_HIGHER___) || ((defined __cplusplus) && (__cplusplus == 201103L))# define OPTIONAL_MUTABLE_CONSTEXPR# else# define OPTIONAL_MUTABLE_CONSTEXPR constexpr# endif# if defined TR2_OPTIONAL_MSVC_2015_AND_HIGHER___#pragma warning( push )#pragma warning( disable : 4814 )#endifnamespacesol{// BEGIN workaround for missing is_trivially_destructible# if defined TR2_OPTIONAL_GCC_4_8_AND_HIGHER___// leave it: it is already there# elif defined TR2_OPTIONAL_CLANG_3_4_2_AND_HIGHER_// leave it: it is already there# elif defined TR2_OPTIONAL_MSVC_2015_AND_HIGHER___// leave it: it is already there# elif defined TR2_OPTIONAL_DISABLE_EMULATION_OF_TYPE_TRAITS// leave it: the user doesn't want it# elsetemplate<typenameT>usingis_trivially_destructible=::std::has_trivial_destructor<T>;# endif// END workaround for missing is_trivially_destructible# if (defined TR2_OPTIONAL_GCC_4_7_AND_HIGHER___)// leave it; our metafunctions are already defined.# elif defined TR2_OPTIONAL_CLANG_3_4_2_AND_HIGHER_// leave it; our metafunctions are already defined.# elif defined TR2_OPTIONAL_MSVC_2015_AND_HIGHER___// leave it: it is already there# elif defined TR2_OPTIONAL_DISABLE_EMULATION_OF_TYPE_TRAITS// leave it: the user doesn't want it# elsetemplate<classT>structis_nothrow_move_constructible{constexprstaticboolvalue=::std::is_nothrow_constructible<T,T&&>::value;};template<classT,classU>structis_assignable{template<classX,classY>constexprstaticboolhas_assign(...){returnfalse;}template<classX,classY,size_tS=sizeof((::std::declval<X>()=::std::declval<Y>(),true))>// the comma operator is necessary for the cases where operator= returns voidconstexprstaticboolhas_assign(bool){returntrue;}constexprstaticboolvalue=has_assign<T,U>(true);};template<classT>structis_nothrow_move_assignable{template<classX,boolhas_any_move_assign>structhas_nothrow_move_assign{constexprstaticboolvalue=false;};template<classX>structhas_nothrow_move_assign<X,true>{constexprstaticboolvalue=noexcept(::std::declval<X&>()=::std::declval<X&&>());};constexprstaticboolvalue=has_nothrow_move_assign<T,is_assignable<T&,T&&>::value>::value;};// end workaround# endiftemplate<classT>classoptional;// 20.5.5, optional for lvalue reference typestemplate<classT>classoptional<T&>;// workaround: std utility functions aren't constexpr yettemplate<classT>inlineconstexprT&&constexpr_forward(typename::std::remove_reference<T>::type&t)noexcept{returnstatic_cast<T&&>(t);}template<classT>inlineconstexprT&&constexpr_forward(typename::std::remove_reference<T>::type&&t)noexcept{static_assert(!::std::is_lvalue_reference<T>::value,"!!");returnstatic_cast<T&&>(t);}template<classT>inlineconstexprtypename::std::remove_reference<T>::type&&constexpr_move(T&&t)noexcept{returnstatic_cast<typename::std::remove_reference<T>::type&&>(t);}#if defined NDEBUG# define TR2_OPTIONAL_ASSERTED_EXPRESSION(CHECK, EXPR) (EXPR)#else# define TR2_OPTIONAL_ASSERTED_EXPRESSION(CHECK, EXPR) ((CHECK) ? (EXPR) : ([]{assert(!#CHECK);}(), (EXPR)))#endifnamespacedetail_{// static_addressof: a constexpr version of addressoftemplate<typenameT>structhas_overloaded_addressof{template<classX>constexprstaticboolhas_overload(...){returnfalse;}template<classX,size_tS=sizeof(::std::declval<X&>().operator&())>constexprstaticboolhas_overload(bool){returntrue;}constexprstaticboolvalue=has_overload<T>(true);};template<typenameT,TR2_OPTIONAL_REQUIRES(!has_overloaded_addressof<T>)>constexprT*static_addressof(T&ref){return&ref;}template<typenameT,TR2_OPTIONAL_REQUIRES(has_overloaded_addressof<T>)>T*static_addressof(T&ref){return::std::addressof(ref);}// the call to convert<A>(b) has return type A and converts b to type A iff b decltype(b) is implicitly convertible to A template<classU>constexprUconvert(Uv){returnv;}}// namespace detail_constexprstructtrivial_init_t{}trivial_init{};// 20.5.7, Disengaged state indicatorstructnullopt_t{structinit{};constexprexplicitnullopt_t(init){}};constexprnullopt_tnullopt{nullopt_t::init()};// 20.5.8, class bad_optional_accessclassbad_optional_access:public::std::logic_error{public:explicitbad_optional_access(const::std::string&what_arg):::std::logic_error{what_arg}{}explicitbad_optional_access(constchar*what_arg):::std::logic_error{what_arg}{}};template<classT>structalignas(T)optional_base{charstorage_[sizeof(T)];boolinit_;constexproptional_base()noexcept:storage_(),init_(false){};explicitoptional_base(constT&v):storage_(),init_(true){new(&storage())T(v);}explicitoptional_base(T&&v):storage_(),init_(true){new(&storage())T(constexpr_move(v));}template<class...Args>explicitoptional_base(in_place_t,Args&&...args):init_(true),storage_(){new(&storage())T(constexpr_forward<Args>(args)...);}template<classU,class...Args,TR2_OPTIONAL_REQUIRES(::std::is_constructible<T,::std::initializer_list<U>>)>explicitoptional_base(in_place_t,::std::initializer_list<U>il,Args&&...args):init_(true),storage_(){new(&storage())T(il,constexpr_forward<Args>(args)...);}#if defined __GNUC__ #pragma GCC diagnostic push#pragma GCC diagnostic ignored "-Wstrict-aliasing"#endifT&storage(){return*reinterpret_cast<T*>(&storage_[0]);}constexprconstT&storage()const{return*reinterpret_cast<Tconst*>(&storage_[0]);}#if defined __GNUC__#pragma GCC diagnostic pop#endif~optional_base(){if(init_){storage().T::~T();}}};#if defined __GNUC__ && !defined TR2_OPTIONAL_GCC_5_0_AND_HIGHER___// Sorry, GCC 4.x; you're just a piece of shittemplate<typenameT>usingconstexpr_optional_base=optional_base<T>;#elsetemplate<classT>structalignas(T)constexpr_optional_base{charstorage_[sizeof(T)];boolinit_;constexprconstexpr_optional_base()noexcept:storage_(),init_(false){}explicitconstexprconstexpr_optional_base(constT&v):storage_(),init_(true){new(&storage())T(v);}explicitconstexprconstexpr_optional_base(T&&v):storage_(),init_(true){new(&storage())T(constexpr_move(v));}template<class...Args>explicitconstexprconstexpr_optional_base(in_place_t,Args&&...args):init_(true),storage_(){new(&storage())T(constexpr_forward<Args>(args)...);}template<classU,class...Args,TR2_OPTIONAL_REQUIRES(::std::is_constructible<T,::std::initializer_list<U>>)>OPTIONAL_CONSTEXPR_INIT_LISTexplicitconstexpr_optional_base(in_place_t,::std::initializer_list<U>il,Args&&...args):init_(true),storage_(){new(&storage())T(il,constexpr_forward<Args>(args)...);}#if defined __GNUC__ #pragma GCC diagnostic push#pragma GCC diagnostic ignored "-Wstrict-aliasing"#endifT&storage(){return(*reinterpret_cast<T*>(&storage_[0]));}constexprconstT&storage()const{return(*reinterpret_cast<Tconst*>(&storage_[0]));}#if defined __GNUC__#pragma GCC diagnostic pop#endif~constexpr_optional_base()=default;};#endiftemplate<classT>usingOptionalBase=typename::std::conditional<::std::is_trivially_destructible<T>::value,constexpr_optional_base<typename::std::remove_const<T>::type>,optional_base<typename::std::remove_const<T>::type>>::type;template<classT>classoptional:privateOptionalBase<T>{static_assert(!::std::is_same<typename::std::decay<T>::type,nullopt_t>::value,"bad T");static_assert(!::std::is_same<typename::std::decay<T>::type,in_place_t>::value,"bad T");constexprboolinitialized()constnoexcept{returnOptionalBase<T>::init_;}typename::std::remove_const<T>::type*dataptr(){return::std::addressof(OptionalBase<T>::storage());}constexprconstT*dataptr()const{returndetail_::static_addressof(OptionalBase<T>::storage());}# if OPTIONAL_HAS_THIS_RVALUE_REFS == 1constexprconstT&contained_val()const&{returnOptionalBase<T>::storage();}# if OPTIONAL_HAS_MOVE_ACCESSORS == 1OPTIONAL_MUTABLE_CONSTEXPRT&&contained_val()&&{return::std::move(OptionalBase<T>::storage());}OPTIONAL_MUTABLE_CONSTEXPRT&contained_val()&{returnOptionalBase<T>::storage();}# elseT&contained_val()&{returnOptionalBase<T>::storage();}T&&contained_val()&&{return::std::move(OptionalBase<T>::storage());}# endif# elseconstexprconstT&contained_val()const{returnOptionalBase<T>::storage();}T&contained_val(){returnOptionalBase<T>::storage();}# endifvoidclear()noexcept{if(initialized())dataptr()->T::~T();OptionalBase<T>::init_=false;}template<class...Args>voidinitialize(Args&&...args)noexcept(noexcept(T(::std::forward<Args>(args)...))){assert(!OptionalBase<T>::init_);::new(static_cast<void*>(dataptr()))T(::std::forward<Args>(args)...);OptionalBase<T>::init_=true;}template<classU,class...Args>voidinitialize(::std::initializer_list<U>il,Args&&...args)noexcept(noexcept(T(il,::std::forward<Args>(args)...))){assert(!OptionalBase<T>::init_);::new(static_cast<void*>(dataptr()))T(il,::std::forward<Args>(args)...);OptionalBase<T>::init_=true;}public:typedefTvalue_type;// 20.5.5.1, constructorsconstexproptional()noexcept:OptionalBase<T>(){};constexproptional(nullopt_t)noexcept:OptionalBase<T>(){};optional(constoptional&rhs):OptionalBase<T>(){if(rhs.initialized()){::new(static_cast<void*>(dataptr()))T(*rhs);OptionalBase<T>::init_=true;}}optional(constoptional<T&>&rhs):optional(){if(rhs){::new(static_cast<void*>(dataptr()))T(*rhs);OptionalBase<T>::init_=true;}}optional(optional&&rhs)noexcept(::std::is_nothrow_move_constructible<T>::value):OptionalBase<T>(){if(rhs.initialized()){::new(static_cast<void*>(dataptr()))T(::std::move(*rhs));OptionalBase<T>::init_=true;}}constexproptional(constT&v):OptionalBase<T>(v){}constexproptional(T&&v):OptionalBase<T>(constexpr_move(v)){}template<class...Args>explicitconstexproptional(in_place_t,Args&&...args):OptionalBase<T>(in_place,constexpr_forward<Args>(args)...){}template<classU,class...Args,TR2_OPTIONAL_REQUIRES(::std::is_constructible<T,::std::initializer_list<U>>)>OPTIONAL_CONSTEXPR_INIT_LISTexplicitoptional(in_place_t,::std::initializer_list<U>il,Args&&...args):OptionalBase<T>(in_place,il,constexpr_forward<Args>(args)...){}// 20.5.4.2, Destructor~optional()=default;// 20.5.4.3, assignmentoptional&operator=(nullopt_t)noexcept{clear();return*this;}optional&operator=(constoptional&rhs){if(initialized()==true&&rhs.initialized()==false)clear();elseif(initialized()==false&&rhs.initialized()==true)initialize(*rhs);elseif(initialized()==true&&rhs.initialized()==true)contained_val()=*rhs;return*this;}optional&operator=(optional&&rhs)noexcept(::std::is_nothrow_move_assignable<T>::value&&::std::is_nothrow_move_constructible<T>::value){if(initialized()==true&&rhs.initialized()==false)clear();elseif(initialized()==false&&rhs.initialized()==true)initialize(::std::move(*rhs));elseif(initialized()==true&&rhs.initialized()==true)contained_val()=::std::move(*rhs);return*this;}template<classU>autooperator=(U&&v)->typename::std::enable_if<::std::is_same<typename::std::decay<U>::type,T>::value,optional&>::type{if(initialized()){contained_val()=::std::forward<U>(v);}else{initialize(::std::forward<U>(v));}return*this;}template<class...Args>voidemplace(Args&&...args){clear();initialize(::std::forward<Args>(args)...);}template<classU,class...Args>voidemplace(::std::initializer_list<U>il,Args&&...args){clear();initialize<U,Args...>(il,::std::forward<Args>(args)...);}// 20.5.4.4, Swapvoidswap(optional<T>&rhs)noexcept(::std::is_nothrow_move_constructible<T>::value&&noexcept(swap(::std::declval<T&>(),::std::declval<T&>()))){if(initialized()==true&&rhs.initialized()==false){rhs.initialize(::std::move(**this));clear();}elseif(initialized()==false&&rhs.initialized()==true){initialize(::std::move(*rhs));rhs.clear();}elseif(initialized()==true&&rhs.initialized()==true){using::std::swap;swap(**this,*rhs);}}// 20.5.4.5, Observersexplicitconstexproperatorbool()constnoexcept{returninitialized();}constexprTconst*operator->()const{returnTR2_OPTIONAL_ASSERTED_EXPRESSION(initialized(),dataptr());}# if OPTIONAL_HAS_MOVE_ACCESSORS == 1OPTIONAL_MUTABLE_CONSTEXPRT*operator->(){assert(initialized());returndataptr();}constexprTconst&operator*()const&{returnTR2_OPTIONAL_ASSERTED_EXPRESSION(initialized(),contained_val());}OPTIONAL_MUTABLE_CONSTEXPRT&operator*()&{assert(initialized());returncontained_val();}OPTIONAL_MUTABLE_CONSTEXPRT&&operator*()&&{assert(initialized());returnconstexpr_move(contained_val());}constexprTconst&value()const&{returninitialized()?contained_val()#ifdef SOL_NO_EXCEPTIONS// we can't abort here// because there's no constexpr abort:*(T*)nullptr;#else:(throwbad_optional_access("bad optional access"),contained_val());#endif}OPTIONAL_MUTABLE_CONSTEXPRT&value()&{returninitialized()?contained_val()#ifdef SOL_NO_EXCEPTIONS:*(T*)nullptr;#else:(throwbad_optional_access("bad optional access"),contained_val());#endif}OPTIONAL_MUTABLE_CONSTEXPRT&&value()&&{returninitialized()?contained_val()#ifdef SOL_NO_EXCEPTIONS// we can't abort here// because there's no constexpr abort:std::move(*(T*)nullptr);#else:(throwbad_optional_access("bad optional access"),contained_val());#endif}# elseT*operator->(){assert(initialized());returndataptr();}constexprTconst&operator*()const{returnTR2_OPTIONAL_ASSERTED_EXPRESSION(initialized(),contained_val());}T&operator*(){assert(initialized());returncontained_val();}constexprTconst&value()const{returninitialized()?contained_val()#ifdef SOL_NO_EXCEPTIONS// we can't abort here// because there's no constexpr abort:*(T*)nullptr;#else:(throwbad_optional_access("bad optional access"),contained_val());#endif}T&value(){returninitialized()?contained_val()#ifdef SOL_NO_EXCEPTIONS// we can abort here// but the others are constexpr, so we can't...:(std::abort(),*(T*)nullptr);#else:(throwbad_optional_access("bad optional access"),contained_val());#endif}# endif# if OPTIONAL_HAS_THIS_RVALUE_REFS == 1template<classV>constexprTvalue_or(V&&v)const&{return*this?**this:detail_::convert<T>(constexpr_forward<V>(v));}# if OPTIONAL_HAS_MOVE_ACCESSORS == 1template<classV>OPTIONAL_MUTABLE_CONSTEXPRTvalue_or(V&&v)&&{return*this?constexpr_move(const_cast<optional<T>&>(*this).contained_val()):detail_::convert<T>(constexpr_forward<V>(v));}# elsetemplate<classV>Tvalue_or(V&&v)&&{return*this?constexpr_move(const_cast<optional<T>&>(*this).contained_val()):detail_::convert<T>(constexpr_forward<V>(v));}# endif# elsetemplate<classV>constexprTvalue_or(V&&v)const{return*this?**this:detail_::convert<T>(constexpr_forward<V>(v));}# endif};template<classT>classoptional<T&>{static_assert(!::std::is_same<T,nullopt_t>::value,"bad T");static_assert(!::std::is_same<T,in_place_t>::value,"bad T");T*ref;public:// 20.5.5.1, construction/destructionconstexproptional()noexcept:ref(nullptr){}constexproptional(nullopt_t)noexcept:ref(nullptr){}constexproptional(T&v)noexcept:ref(detail_::static_addressof(v)){}optional(T&&)=delete;constexproptional(constoptional&rhs)noexcept:ref(rhs.ref){}explicitconstexproptional(in_place_t,T&v)noexcept:ref(detail_::static_addressof(v)){}explicitoptional(in_place_t,T&&)=delete;~optional()=default;// 20.5.5.2, mutationoptional&operator=(nullopt_t)noexcept{ref=nullptr;return*this;}// optional& operator=(const optional& rhs) noexcept {// ref = rhs.ref;// return *this;// }// optional& operator=(optional&& rhs) noexcept {// ref = rhs.ref;// return *this;// }template<typenameU>autooperator=(U&&rhs)noexcept->typename::std::enable_if<::std::is_same<typename::std::decay<U>::type,optional<T&>>::value,optional&>::type{ref=rhs.ref;return*this;}template<typenameU>autooperator=(U&&rhs)noexcept->typename::std::enable_if<!::std::is_same<typename::std::decay<U>::type,optional<T&>>::value,optional&>::type=delete;voidemplace(T&v)noexcept{ref=detail_::static_addressof(v);}voidemplace(T&&)=delete;voidswap(optional<T&>&rhs)noexcept{::std::swap(ref,rhs.ref);}// 20.5.5.3, observersconstexprT*operator->()const{returnTR2_OPTIONAL_ASSERTED_EXPRESSION(ref,ref);}constexprT&operator*()const{returnTR2_OPTIONAL_ASSERTED_EXPRESSION(ref,*ref);}constexprT&value()const{returnref?*ref#ifdef SOL_NO_EXCEPTIONS// we can't abort here// because there's no constexpr abort:*(T*)nullptr;#else:throwbad_optional_access("bad optional access");#endif}explicitconstexproperatorbool()constnoexcept{returnref!=nullptr;}template<typenameV>constexprT&value_or(V&&v)const{return*this?**this:detail_::convert<T&>(constexpr_forward<V>(v));}};template<classT>classoptional<T&&>{static_assert(sizeof(T)==0,"optional rvalue references disallowed");};// 20.5.8, Relational operatorstemplate<classT>constexprbooloperator==(constoptional<T>&x,constoptional<T>&y){returnbool(x)!=bool(y)?false:bool(x)==false?true:*x==*y;}template<classT>constexprbooloperator!=(constoptional<T>&x,constoptional<T>&y){return!(x==y);}template<classT>constexprbooloperator<(constoptional<T>&x,constoptional<T>&y){return(!y)?false:(!x)?true:*x<*y;}template<classT>constexprbooloperator>(constoptional<T>&x,constoptional<T>&y){return(y<x);}template<classT>constexprbooloperator<=(constoptional<T>&x,constoptional<T>&y){return!(y<x);}template<classT>constexprbooloperator>=(constoptional<T>&x,constoptional<T>&y){return!(x<y);}// 20.5.9, Comparison with nullopttemplate<classT>constexprbooloperator==(constoptional<T>&x,nullopt_t)noexcept{return(!x);}template<classT>constexprbooloperator==(nullopt_t,constoptional<T>&x)noexcept{return(!x);}template<classT>constexprbooloperator!=(constoptional<T>&x,nullopt_t)noexcept{returnbool(x);}template<classT>constexprbooloperator!=(nullopt_t,constoptional<T>&x)noexcept{returnbool(x);}template<classT>constexprbooloperator<(constoptional<T>&,nullopt_t)noexcept{returnfalse;}template<classT>constexprbooloperator<(nullopt_t,constoptional<T>&x)noexcept{returnbool(x);}template<classT>constexprbooloperator<=(constoptional<T>&x,nullopt_t)noexcept{return(!x);}template<classT>constexprbooloperator<=(nullopt_t,constoptional<T>&)noexcept{returntrue;}template<classT>constexprbooloperator>(constoptional<T>&x,nullopt_t)noexcept{returnbool(x);}template<classT>constexprbooloperator>(nullopt_t,constoptional<T>&)noexcept{returnfalse;}template<classT>constexprbooloperator>=(constoptional<T>&,nullopt_t)noexcept{returntrue;}template<classT>constexprbooloperator>=(nullopt_t,constoptional<T>&x)noexcept{return(!x);}// 20.5.10, Comparison with Ttemplate<classT>constexprbooloperator==(constoptional<T>&x,constT&v){returnbool(x)?*x==v:false;}template<classT>constexprbooloperator==(constT&v,constoptional<T>&x){returnbool(x)?v==*x:false;}template<classT>constexprbooloperator!=(constoptional<T>&x,constT&v){returnbool(x)?*x!=v:true;}template<classT>constexprbooloperator!=(constT&v,constoptional<T>&x){returnbool(x)?v!=*x:true;}template<classT>constexprbooloperator<(constoptional<T>&x,constT&v){returnbool(x)?*x<v:true;}template<classT>constexprbooloperator>(constT&v,constoptional<T>&x){returnbool(x)?v>*x:true;}template<classT>constexprbooloperator>(constoptional<T>&x,constT&v){returnbool(x)?*x>v:false;}template<classT>constexprbooloperator<(constT&v,constoptional<T>&x){returnbool(x)?v<*x:false;}template<classT>constexprbooloperator>=(constoptional<T>&x,constT&v){returnbool(x)?*x>=v:false;}template<classT>constexprbooloperator<=(constT&v,constoptional<T>&x){returnbool(x)?v<=*x:false;}template<classT>constexprbooloperator<=(constoptional<T>&x,constT&v){returnbool(x)?*x<=v:true;}template<classT>constexprbooloperator>=(constT&v,constoptional<T>&x){returnbool(x)?v>=*x:true;}// Comparison of optional<T&> with Ttemplate<classT>constexprbooloperator==(constoptional<T&>&x,constT&v){returnbool(x)?*x==v:false;}template<classT>constexprbooloperator==(constT&v,constoptional<T&>&x){returnbool(x)?v==*x:false;}template<classT>constexprbooloperator!=(constoptional<T&>&x,constT&v){returnbool(x)?*x!=v:true;}template<classT>constexprbooloperator!=(constT&v,constoptional<T&>&x){returnbool(x)?v!=*x:true;}template<classT>constexprbooloperator<(constoptional<T&>&x,constT&v){returnbool(x)?*x<v:true;}template<classT>constexprbooloperator>(constT&v,constoptional<T&>&x){returnbool(x)?v>*x:true;}template<classT>constexprbooloperator>(constoptional<T&>&x,constT&v){returnbool(x)?*x>v:false;}template<classT>constexprbooloperator<(constT&v,constoptional<T&>&x){returnbool(x)?v<*x:false;}template<classT>constexprbooloperator>=(constoptional<T&>&x,constT&v){returnbool(x)?*x>=v:false;}template<classT>constexprbooloperator<=(constT&v,constoptional<T&>&x){returnbool(x)?v<=*x:false;}template<classT>constexprbooloperator<=(constoptional<T&>&x,constT&v){returnbool(x)?*x<=v:true;}template<classT>constexprbooloperator>=(constT&v,constoptional<T&>&x){returnbool(x)?v>=*x:true;}// Comparison of optional<T const&> with Ttemplate<classT>constexprbooloperator==(constoptional<constT&>&x,constT&v){returnbool(x)?*x==v:false;}template<classT>constexprbooloperator==(constT&v,constoptional<constT&>&x){returnbool(x)?v==*x:false;}template<classT>constexprbooloperator!=(constoptional<constT&>&x,constT&v){returnbool(x)?*x!=v:true;}template<classT>constexprbooloperator!=(constT&v,constoptional<constT&>&x){returnbool(x)?v!=*x:true;}template<classT>constexprbooloperator<(constoptional<constT&>&x,constT&v){returnbool(x)?*x<v:true;}template<classT>constexprbooloperator>(constT&v,constoptional<constT&>&x){returnbool(x)?v>*x:true;}template<classT>constexprbooloperator>(constoptional<constT&>&x,constT&v){returnbool(x)?*x>v:false;}template<classT>constexprbooloperator<(constT&v,constoptional<constT&>&x){returnbool(x)?v<*x:false;}template<classT>constexprbooloperator>=(constoptional<constT&>&x,constT&v){returnbool(x)?*x>=v:false;}template<classT>constexprbooloperator<=(constT&v,constoptional<constT&>&x){returnbool(x)?v<=*x:false;}template<classT>constexprbooloperator<=(constoptional<constT&>&x,constT&v){returnbool(x)?*x<=v:true;}template<classT>constexprbooloperator>=(constT&v,constoptional<constT&>&x){returnbool(x)?v>=*x:true;}// 20.5.12, Specialized algorithmstemplate<classT>voidswap(optional<T>&x,optional<T>&y)noexcept(noexcept(x.swap(y))){x.swap(y);}template<classT>constexproptional<typename::std::decay<T>::type>make_optional(T&&v){returnoptional<typename::std::decay<T>::type>(constexpr_forward<T>(v));}template<classX>constexproptional<X&>make_optional(::std::reference_wrapper<X>v){returnoptional<X&>(v.get());}}// namespace namespacestd{template<typenameT>structhash<sol::optional<T>>{typedeftypenamehash<T>::result_typeresult_type;typedefsol::optional<T>argument_type;constexprresult_typeoperator()(argument_typeconst&arg)const{returnarg?::std::hash<T>{}(*arg):result_type{};}};template<typenameT>structhash<sol::optional<T&>>{typedeftypenamehash<T>::result_typeresult_type;typedefsol::optional<T&>argument_type;constexprresult_typeoperator()(argument_typeconst&arg)const{returnarg?::std::hash<T>{}(*arg):result_type{};}};}# if defined TR2_OPTIONAL_MSVC_2015_AND_HIGHER___#pragma warning( pop )#endif# undef TR2_OPTIONAL_REQUIRES# undef TR2_OPTIONAL_ASSERTED_EXPRESSION# endif // SOL_OPTIONAL_IMPLEMENTATION_HPP// end of sol/optional_implementation.hpp#endif // Boost vs. Better optionalnamespacesol{#if defined(SOL_USE_BOOST)template<typenameT>usingoptional=boost::optional<T>;usingnullopt_t=boost::none_t;constnullopt_tnullopt=boost::none;#endif // Boost vs. Better optional}// sol// end of sol/optional.hpp// beginning of sol/string_shim.hppnamespacesol{namespacestring_detail{structstring_shim{std::size_ts;constchar*p;string_shim(conststd::string&r):string_shim(r.data(),r.size()){}string_shim(constchar*ptr):string_shim(ptr,std::char_traits<char>::length(ptr)){}string_shim(constchar*ptr,std::size_tsz):s(sz),p(ptr){}staticintcompare(constchar*lhs_p,std::size_tlhs_sz,constchar*rhs_p,std::size_trhs_sz){intresult=std::char_traits<char>::compare(lhs_p,rhs_p,lhs_sz<rhs_sz?lhs_sz:rhs_sz);if(result!=0)returnresult;if(lhs_sz<rhs_sz)return-1;if(lhs_sz>rhs_sz)return1;return0;}constchar*c_str()const{returnp;}constchar*data()const{returnp;}std::size_tsize()const{returns;}booloperator==(conststring_shim&r)const{returncompare(p,s,r.data(),r.size())==0;}booloperator==(constchar*r)const{returncompare(r,std::char_traits<char>::length(r),p,s)==0;}booloperator==(conststd::string&r)const{returncompare(r.data(),r.size(),p,s)==0;}booloperator!=(conststring_shim&r)const{return!(*this==r);}booloperator!=(constchar*r)const{return!(*this==r);}booloperator!=(conststd::string&r)const{return!(*this==r);}};}}// end of sol/string_shim.hpp#include<array>namespacesol{namespacedetail{#ifdef SOL_NO_EXCEPTIONStemplate<lua_CFunctionf>intstatic_trampoline(lua_State*L){returnf(L);}template<typenameFx,typename...Args>inttrampoline(lua_State*L,Fx&&f,Args&&...args){returnf(L,std::forward<Args>(args)...);}inlineintc_trampoline(lua_State*L,lua_CFunctionf){returntrampoline(L,f);}#elsetemplate<lua_CFunctionf>intstatic_trampoline(lua_State*L){try{returnf(L);}catch(constchar*s){lua_pushstring(L,s);}catch(conststd::exception&e){lua_pushstring(L,e.what());}#if !defined(SOL_EXCEPTIONS_SAFE_PROPAGATION)catch(...){lua_pushstring(L,"caught (...) exception");}#endifreturnlua_error(L);}template<typenameFx,typename...Args>inttrampoline(lua_State*L,Fx&&f,Args&&...args){try{returnf(L,std::forward<Args>(args)...);}catch(constchar*s){lua_pushstring(L,s);}catch(conststd::exception&e){lua_pushstring(L,e.what());}#if !defined(SOL_EXCEPTIONS_SAFE_PROPAGATION)catch(...){lua_pushstring(L,"caught (...) exception");}#endifreturnlua_error(L);}inlineintc_trampoline(lua_State*L,lua_CFunctionf){returntrampoline(L,f);}#endif // Exceptions vs. No Exceptionstemplate<typenameT>structunique_usertype{};template<typenameT>structimplicit_wrapper{T&item;implicit_wrapper(T*item):item(*item){}implicit_wrapper(T&item):item(item){}operatorT&(){returnitem;}operatorT*(){returnstd::addressof(item);}};}// detailstructlua_nil_t{};constlua_nil_tlua_nil{};inlinebooloperator==(lua_nil_t,lua_nil_t){returntrue;}inlinebooloperator!=(lua_nil_t,lua_nil_t){returnfalse;}#ifndef __OBJC__typedeflua_nil_tnil_t;constnil_tnil{};#endifstructmetatable_key_t{};constmetatable_key_tmetatable_key={};structno_metatable_t{};constno_metatable_tno_metatable={};typedefstd::remove_pointer_t<lua_CFunction>lua_r_CFunction;template<typenameT>structunique_usertype_traits{typedefTtype;typedefTactual_type;staticconstboolvalue=false;template<typenameU>staticboolis_null(U&&){returnfalse;}template<typenameU>staticautoget(U&&value){returnstd::addressof(detail::deref(value));}};template<typenameT>structunique_usertype_traits<std::shared_ptr<T>>{typedefTtype;typedefstd::shared_ptr<T>actual_type;staticconstboolvalue=true;staticboolis_null(constactual_type&p){returnp==nullptr;}statictype*get(constactual_type&p){returnp.get();}};template<typenameT,typenameD>structunique_usertype_traits<std::unique_ptr<T,D>>{typedefTtype;typedefstd::unique_ptr<T,D>actual_type;staticconstboolvalue=true;staticboolis_null(constactual_type&p){returnp==nullptr;}statictype*get(constactual_type&p){returnp.get();}};template<typenameT>structnon_null{};template<typename...Args>structfunction_sig{};structupvalue_index{intindex;upvalue_index(intidx):index(lua_upvalueindex(idx)){}operatorint()const{returnindex;}};structraw_index{intindex;raw_index(inti):index(i){}operatorint()const{returnindex;}};structabsolute_index{intindex;absolute_index(lua_State*L,intidx):index(lua_absindex(L,idx)){}operatorint()const{returnindex;}};structref_index{intindex;ref_index(intidx):index(idx){}operatorint()const{returnindex;}};structlightuserdata_value{void*value;lightuserdata_value(void*data):value(data){}operatorvoid*()const{returnvalue;}};structuserdata_value{void*value;userdata_value(void*data):value(data){}operatorvoid*()const{returnvalue;}};template<typenameL>structlight{L*value;light(L&x):value(std::addressof(x)){}light(L*x):value(x){}light(void*x):value(static_cast<L*>(x)){}operatorL*()const{returnvalue;}operatorL&()const{return*value;}};template<typenameT>automake_light(T&l){typedefmeta::unwrapped_t<std::remove_pointer_t<std::remove_pointer_t<T>>>L;returnlight<L>(l);}template<typenameU>structuser{Uvalue;user(Ux):value(std::move(x)){}operatorU*(){returnstd::addressof(value);}operatorU&(){returnvalue;}operatorconstU&()const{returnvalue;}};template<typenameT>automake_user(T&&u){typedefmeta::unwrapped_t<meta::unqualified_t<T>>U;returnuser<U>(std::forward<T>(u));}template<typenameT>structmetatable_registry_key{Tkey;metatable_registry_key(Tkey):key(std::forward<T>(key)){}};template<typenameT>autometa_registry_key(T&&key){typedefmeta::unqualified_t<T>K;returnmetatable_registry_key<K>(std::forward<T>(key));}template<typename...Upvalues>structclosure{lua_CFunctionc_function;std::tuple<Upvalues...>upvalues;closure(lua_CFunctionf,Upvalues...targetupvalues):c_function(f),upvalues(std::forward<Upvalues>(targetupvalues)...){}};template<>structclosure<>{lua_CFunctionc_function;intupvalues;closure(lua_CFunctionf,intupvalue_count=0):c_function(f),upvalues(upvalue_count){}};typedefclosure<>c_closure;template<typename...Args>closure<Args...>make_closure(lua_CFunctionf,Args&&...args){returnclosure<Args...>(f,std::forward<Args>(args)...);}template<typenameSig,typename...Ps>structfunction_arguments{std::tuple<Ps...>arguments;template<typenameArg,typename...Args,meta::disable<std::is_same<meta::unqualified_t<Arg>,function_arguments>>=meta::enabler>function_arguments(Arg&&arg,Args&&...args):arguments(std::forward<Arg>(arg),std::forward<Args>(args)...){}};template<typenameSig=function_sig<>,typename...Args>autoas_function(Args&&...args){returnfunction_arguments<Sig,std::decay_t<Args>...>(std::forward<Args>(args)...);}template<typenameSig=function_sig<>,typename...Args>autoas_function_reference(Args&&...args){returnfunction_arguments<Sig,Args...>(std::forward<Args>(args)...);}template<typenameT>structas_table_t{Tsource;template<typename...Args>as_table_t(Args&&...args):source(std::forward<Args>(args)...){}operatorstd::add_lvalue_reference_t<T>(){returnsource;}};template<typenameT>as_table_t<T>as_table(T&&container){returnas_table_t<T>(std::forward<T>(container));}structthis_state{lua_State*L;operatorlua_State*()const{returnL;}lua_State*operator->()const{returnL;}};enumclasscall_syntax{dot=0,colon=1};enumclasscall_status:int{ok=LUA_OK,yielded=LUA_YIELD,runtime=LUA_ERRRUN,memory=LUA_ERRMEM,handler=LUA_ERRERR,gc=LUA_ERRGCMM};enumclassthread_status:int{ok=LUA_OK,yielded=LUA_YIELD,runtime=LUA_ERRRUN,memory=LUA_ERRMEM,gc=LUA_ERRGCMM,handler=LUA_ERRERR,dead=-1,};enumclassload_status:int{ok=LUA_OK,syntax=LUA_ERRSYNTAX,memory=LUA_ERRMEM,gc=LUA_ERRGCMM,file=LUA_ERRFILE,};enumclasstype:int{none=LUA_TNONE,lua_nil=LUA_TNIL,#ifndef __OBJC__nil=lua_nil,#endif // Objective C++ Keywordstring=LUA_TSTRING,number=LUA_TNUMBER,thread=LUA_TTHREAD,boolean=LUA_TBOOLEAN,function=LUA_TFUNCTION,userdata=LUA_TUSERDATA,lightuserdata=LUA_TLIGHTUSERDATA,table=LUA_TTABLE,poly=none|lua_nil|string|number|thread|table|boolean|function|userdata|lightuserdata};enumclassmeta_function{construct,index,new_index,mode,call,call_function=call,metatable,to_string,length,unary_minus,addition,subtraction,multiplication,division,modulus,power_of,involution=power_of,concatenation,equal_to,less_than,less_than_or_equal_to,garbage_collect,floor_division,bitwise_left_shift,bitwise_right_shift,bitwise_not,bitwise_and,bitwise_or,bitwise_xor,pairs,next};typedefmeta_functionmeta_method;conststd::array<std::string,2>meta_variable_names={{"__index","__newindex",}};conststd::array<std::string,29>meta_function_names={{"new","__index","__newindex","__mode","__call","__mt","__tostring","__len","__unm","__add","__sub","__mul","__div","__mod","__pow","__concat","__eq","__lt","__le","__gc","__idiv","__shl","__shr","__bnot","__band","__bor","__bxor","__pairs","__next"}};inlineconststd::string&name_of(meta_functionmf){returnmeta_function_names[static_cast<int>(mf)];}inlinetypetype_of(lua_State*L,intindex){returnstatic_cast<type>(lua_type(L,index));}inlineinttype_panic(lua_State*L,intindex,typeexpected,typeactual){returnluaL_error(L,"stack index %d, expected %s, received %s",index,expected==type::poly?"anything":lua_typename(L,static_cast<int>(expected)),expected==type::poly?"anything":lua_typename(L,static_cast<int>(actual)));}// Specify this function as the handler for lua::check if you know there's nothing wronginlineintno_panic(lua_State*,int,type,type)noexcept{return0;}inlinevoidtype_error(lua_State*L,intexpected,intactual){luaL_error(L,"expected %s, received %s",lua_typename(L,expected),lua_typename(L,actual));}inlinevoidtype_error(lua_State*L,typeexpected,typeactual){type_error(L,static_cast<int>(expected),static_cast<int>(actual));}inlinevoidtype_assert(lua_State*L,intindex,typeexpected,typeactual){if(expected!=type::poly&&expected!=actual){type_panic(L,index,expected,actual);}}inlinevoidtype_assert(lua_State*L,intindex,typeexpected){typeactual=type_of(L,index);type_assert(L,index,expected,actual);}inlinestd::stringtype_name(lua_State*L,typet){returnlua_typename(L,static_cast<int>(t));}classreference;classstack_reference;template<typenameTable,typenameKey>structproxy;template<typenameT>classusertype;template<bool,typenameT>classbasic_table_core;template<boolb>usingtable_core=basic_table_core<b,reference>;template<boolb>usingstack_table_core=basic_table_core<b,stack_reference>;typedeftable_core<false>table;typedeftable_core<true>global_table;typedefstack_table_core<false>stack_table;typedefstack_table_core<true>stack_global_table;template<typenameT>classbasic_function;template<typenameT>classbasic_protected_function;usingfunction=basic_function<reference>;usingprotected_function=basic_protected_function<reference>;usingstack_function=basic_function<stack_reference>;usingstack_protected_function=basic_protected_function<stack_reference>;template<typenamebase_t>classbasic_object;template<typenamebase_t>classbasic_userdata;template<typenamebase_t>classbasic_lightuserdata;structvariadic_args;usingobject=basic_object<reference>;usingstack_object=basic_object<stack_reference>;usinguserdata=basic_userdata<reference>;usingstack_userdata=basic_userdata<stack_reference>;usinglightuserdata=basic_lightuserdata<reference>;usingstack_lightuserdata=basic_lightuserdata<stack_reference>;classcoroutine;classthread;structvariadic_args;structthis_state;namespacedetail{template<typenameT,typename=void>structlua_type_of:std::integral_constant<type,type::userdata>{};template<>structlua_type_of<std::string>:std::integral_constant<type,type::string>{};template<>structlua_type_of<std::wstring>:std::integral_constant<type,type::string>{};template<>structlua_type_of<std::u16string>:std::integral_constant<type,type::string>{};template<>structlua_type_of<std::u32string>:std::integral_constant<type,type::string>{};template<std::size_tN>structlua_type_of<char[N]>:std::integral_constant<type,type::string>{};template<std::size_tN>structlua_type_of<wchar_t[N]>:std::integral_constant<type,type::string>{};template<std::size_tN>structlua_type_of<char16_t[N]>:std::integral_constant<type,type::string>{};template<std::size_tN>structlua_type_of<char32_t[N]>:std::integral_constant<type,type::string>{};template<>structlua_type_of<char>:std::integral_constant<type,type::string>{};template<>structlua_type_of<wchar_t>:std::integral_constant<type,type::string>{};template<>structlua_type_of<char16_t>:std::integral_constant<type,type::string>{};template<>structlua_type_of<char32_t>:std::integral_constant<type,type::string>{};template<>structlua_type_of<constchar*>:std::integral_constant<type,type::string>{};template<>structlua_type_of<constchar16_t*>:std::integral_constant<type,type::string>{};template<>structlua_type_of<constchar32_t*>:std::integral_constant<type,type::string>{};template<>structlua_type_of<string_detail::string_shim>:std::integral_constant<type,type::string>{};template<>structlua_type_of<bool>:std::integral_constant<type,type::boolean>{};template<>structlua_type_of<lua_nil_t>:std::integral_constant<type,type::lua_nil>{};template<>structlua_type_of<nullopt_t>:std::integral_constant<type,type::lua_nil>{};template<>structlua_type_of<std::nullptr_t>:std::integral_constant<type,type::lua_nil>{};template<>structlua_type_of<sol::error>:std::integral_constant<type,type::string>{};template<boolb,typenameBase>structlua_type_of<basic_table_core<b,Base>>:std::integral_constant<type,type::table>{};template<>structlua_type_of<reference>:std::integral_constant<type,type::poly>{};template<>structlua_type_of<stack_reference>:std::integral_constant<type,type::poly>{};template<typenameBase>structlua_type_of<basic_object<Base>>:std::integral_constant<type,type::poly>{};template<typename...Args>structlua_type_of<std::tuple<Args...>>:std::integral_constant<type,type::poly>{};template<typenameA,typenameB>structlua_type_of<std::pair<A,B>>:std::integral_constant<type,type::poly>{};template<>structlua_type_of<void*>:std::integral_constant<type,type::lightuserdata>{};template<>structlua_type_of<lightuserdata_value>:std::integral_constant<type,type::lightuserdata>{};template<>structlua_type_of<userdata_value>:std::integral_constant<type,type::userdata>{};template<typenameT>structlua_type_of<light<T>>:std::integral_constant<type,type::lightuserdata>{};template<typenameT>structlua_type_of<user<T>>:std::integral_constant<type,type::userdata>{};template<typenameBase>structlua_type_of<basic_lightuserdata<Base>>:std::integral_constant<type,type::lightuserdata>{};template<typenameBase>structlua_type_of<basic_userdata<Base>>:std::integral_constant<type,type::userdata>{};template<>structlua_type_of<lua_CFunction>:std::integral_constant<type,type::function>{};template<>structlua_type_of<std::remove_pointer_t<lua_CFunction>>:std::integral_constant<type,type::function>{};template<typenameBase>structlua_type_of<basic_function<Base>>:std::integral_constant<type,type::function>{};template<typenameBase>structlua_type_of<basic_protected_function<Base>>:std::integral_constant<type,type::function>{};template<>structlua_type_of<coroutine>:std::integral_constant<type,type::function>{};template<>structlua_type_of<thread>:std::integral_constant<type,type::thread>{};template<typenameSignature>structlua_type_of<std::function<Signature>>:std::integral_constant<type,type::function>{};template<typenameT>structlua_type_of<optional<T>>:std::integral_constant<type,type::poly>{};template<>structlua_type_of<variadic_args>:std::integral_constant<type,type::poly>{};template<>structlua_type_of<this_state>:std::integral_constant<type,type::poly>{};template<>structlua_type_of<type>:std::integral_constant<type,type::poly>{};template<typenameT>structlua_type_of<T*>:std::integral_constant<type,type::userdata>{};template<typenameT>structlua_type_of<T,std::enable_if_t<std::is_arithmetic<T>::value>>:std::integral_constant<type,type::number>{};template<typenameT>structlua_type_of<T,std::enable_if_t<std::is_enum<T>::value>>:std::integral_constant<type,type::number>{};template<typenameT,typenameC=void>structis_container:std::false_type{};template<typenameT>structis_container<T,std::enable_if_t<meta::has_begin_end<meta::unqualified_t<T>>::value>>:std::true_type{};template<>structlua_type_of<meta_function>:std::integral_constant<type,type::string>{};template<typenameC,Cv,template<typename...>classV,typename...Args>structaccumulate:std::integral_constant<C,v>{};template<typenameC,Cv,template<typename...>classV,typenameT,typename...Args>structaccumulate<C,v,V,T,Args...>:accumulate<C,v+V<T>::value,V,Args...>{};}// detailtemplate<typenameT>structis_unique_usertype:std::integral_constant<bool,unique_usertype_traits<T>::value>{};template<typenameT>structlua_type_of:detail::lua_type_of<T>{};template<typenameT>structlua_size:std::integral_constant<int,1>{};template<typenameA,typenameB>structlua_size<std::pair<A,B>>:std::integral_constant<int,lua_size<A>::value+lua_size<B>::value>{};template<typename...Args>structlua_size<std::tuple<Args...>>:std::integral_constant<int,detail::accumulate<int,0,lua_size,Args...>::value>{};template<typenameT>structis_lua_primitive:std::integral_constant<bool,type::userdata!=lua_type_of<meta::unqualified_t<T>>::value||(lua_size<T>::value>1)||std::is_base_of<reference,meta::unqualified_t<T>>::value||std::is_base_of<stack_reference,meta::unqualified_t<T>>::value||meta::is_specialization_of<std::tuple,meta::unqualified_t<T>>::value||meta::is_specialization_of<std::pair,meta::unqualified_t<T>>::value>{};template<typenameT>structis_lua_reference:std::integral_constant<bool,std::is_base_of<reference,meta::unqualified_t<T>>::value||std::is_base_of<stack_reference,meta::unqualified_t<T>>::value||meta::is_specialization_of<proxy,meta::unqualified_t<T>>::value>{};template<typenameT>structis_lua_primitive<T*>:std::true_type{};template<typenameT>structis_lua_primitive<std::reference_wrapper<T>>:std::true_type{};template<typenameT>structis_lua_primitive<user<T>>:std::true_type{};template<typenameT>structis_lua_primitive<light<T>>:is_lua_primitive<T*>{};template<typenameT>structis_lua_primitive<optional<T>>:std::true_type{};template<>structis_lua_primitive<userdata_value>:std::true_type{};template<>structis_lua_primitive<lightuserdata_value>:std::true_type{};template<typenameT>structis_lua_primitive<non_null<T>>:is_lua_primitive<T*>{};template<typenameT>structis_proxy_primitive:is_lua_primitive<T>{};template<typenameT>structis_transparent_argument:std::false_type{};template<>structis_transparent_argument<this_state>:std::true_type{};template<>structis_transparent_argument<variadic_args>:std::true_type{};template<typenameT>structis_variadic_arguments:std::is_same<T,variadic_args>{};template<typenameSignature>structlua_bind_traits:meta::bind_traits<Signature>{private:typedefmeta::bind_traits<Signature>base_t;public:typedefstd::integral_constant<bool,meta::count_for<is_transparent_argument,typenamebase_t::args_list>::value!=0>runtime_variadics_t;staticconststd::size_ttrue_arity=base_t::arity;staticconststd::size_tarity=base_t::arity-meta::count_for<is_transparent_argument,typenamebase_t::args_list>::value;staticconststd::size_ttrue_free_arity=base_t::free_arity;staticconststd::size_tfree_arity=base_t::free_arity-meta::count_for<is_transparent_argument,typenamebase_t::args_list>::value;};template<typenameT>structis_table:std::false_type{};template<boolx,typenameT>structis_table<basic_table_core<x,T>>:std::true_type{};template<typenameT>structis_function:std::false_type{};template<typenameT>structis_function<basic_function<T>>:std::true_type{};template<typenameT>structis_function<basic_protected_function<T>>:std::true_type{};template<typenameT>structis_lightuserdata:std::false_type{};template<typenameT>structis_lightuserdata<basic_lightuserdata<T>>:std::true_type{};template<typenameT>structis_userdata:std::false_type{};template<typenameT>structis_userdata<basic_userdata<T>>:std::true_type{};template<typenameT>structis_container:detail::is_container<T>{};template<typenameT>inlinetypetype_of(){returnlua_type_of<meta::unqualified_t<T>>::value;}}// sol// end of sol/types.hpp// beginning of sol/stack_reference.hppnamespacesol{classstack_reference{private:lua_State*L=nullptr;intindex=0;protected:intregistry_index()constnoexcept{returnLUA_NOREF;}public:stack_reference()noexcept=default;stack_reference(lua_nil_t)noexcept:stack_reference(){};stack_reference(lua_State*L,inti)noexcept:L(L),index(lua_absindex(L,i)){}stack_reference(lua_State*L,absolute_indexi)noexcept:L(L),index(i){}stack_reference(lua_State*L,raw_indexi)noexcept:L(L),index(i){}stack_reference(lua_State*L,ref_indexi)noexcept=delete;stack_reference(stack_reference&&o)noexcept=default;stack_reference&operator=(stack_reference&&)noexcept=default;stack_reference(conststack_reference&)noexcept=default;stack_reference&operator=(conststack_reference&)noexcept=default;intpush()constnoexcept{returnpush(lua_state());}intpush(lua_State*Ls)constnoexcept{lua_pushvalue(lua_state(),index);if(Ls!=lua_state()){lua_xmove(lua_state(),Ls,1);}return1;}voidpop()constnoexcept{pop(lua_state());}voidpop(lua_State*Ls,intn=1)constnoexcept{lua_pop(Ls,n);}intstack_index()constnoexcept{returnindex;}typeget_type()constnoexcept{intresult=lua_type(L,index);returnstatic_cast<type>(result);}lua_State*lua_state()constnoexcept{returnL;}boolvalid()constnoexcept{typet=get_type();returnt!=type::lua_nil&&t!=type::none;}};inlinebooloperator==(conststack_reference&l,conststack_reference&r){returnlua_compare(l.lua_state(),l.stack_index(),r.stack_index(),LUA_OPEQ)==0;}inlinebooloperator!=(conststack_reference&l,conststack_reference&r){return!operator==(l,r);}}// sol// end of sol/stack_reference.hppnamespacesol{namespacestack{template<booltop_level>structpush_popper_n{lua_State*L;intt;push_popper_n(lua_State*luastate,intx):L(luastate),t(x){}~push_popper_n(){lua_pop(L,t);}};template<>structpush_popper_n<true>{push_popper_n(lua_State*,int){}};template<booltop_level,typenameT>structpush_popper{Tt;push_popper(Tx):t(x){t.push();}~push_popper(){t.pop();}};template<typenameT>structpush_popper<true,T>{push_popper(T){}~push_popper(){}};template<booltop_level=false,typenameT>push_popper<top_level,T>push_pop(T&&x){returnpush_popper<top_level,T>(std::forward<T>(x));}template<booltop_level=false>push_popper_n<top_level>pop_n(lua_State*L,intx){returnpush_popper_n<top_level>(L,x);}}// stacknamespacedetail{structglobal_tag{}constglobal_{};}// detailclassreference{private:lua_State*luastate=nullptr;// non-owningintref=LUA_NOREF;intcopy()constnoexcept{if(ref==LUA_NOREF)returnLUA_NOREF;push();returnluaL_ref(lua_state(),LUA_REGISTRYINDEX);}protected:reference(lua_State*L,detail::global_tag)noexcept:luastate(L){lua_pushglobaltable(lua_state());ref=luaL_ref(lua_state(),LUA_REGISTRYINDEX);}intstack_index()constnoexcept{return-1;}voidderef()constnoexcept{luaL_unref(lua_state(),LUA_REGISTRYINDEX,ref);}public:reference()noexcept=default;reference(lua_nil_t)noexcept:reference(){}reference(conststack_reference&r)noexcept:reference(r.lua_state(),r.stack_index()){}reference(stack_reference&&r)noexcept:reference(r.lua_state(),r.stack_index()){}reference(lua_State*L,intindex=-1)noexcept:luastate(L){lua_pushvalue(lua_state(),index);ref=luaL_ref(lua_state(),LUA_REGISTRYINDEX);}reference(lua_State*L,ref_indexindex)noexcept:luastate(L){lua_rawgeti(L,LUA_REGISTRYINDEX,index.index);ref=luaL_ref(lua_state(),LUA_REGISTRYINDEX);}~reference()noexcept{deref();}reference(reference&&o)noexcept{luastate=o.luastate;ref=o.ref;o.luastate=nullptr;o.ref=LUA_NOREF;}reference&operator=(reference&&o)noexcept{luastate=o.luastate;ref=o.ref;o.luastate=nullptr;o.ref=LUA_NOREF;return*this;}reference(constreference&o)noexcept{luastate=o.luastate;ref=o.copy();}reference&operator=(constreference&o)noexcept{luastate=o.luastate;deref();ref=o.copy();return*this;}intpush()constnoexcept{returnpush(lua_state());}intpush(lua_State*Ls)constnoexcept{lua_rawgeti(Ls,LUA_REGISTRYINDEX,ref);return1;}voidpop()constnoexcept{pop(lua_state());}voidpop(lua_State*Ls,intn=1)constnoexcept{lua_pop(Ls,n);}intregistry_index()constnoexcept{returnref;}boolvalid()constnoexcept{return!(ref==LUA_NOREF||ref==LUA_REFNIL);}explicitoperatorbool()constnoexcept{returnvalid();}typeget_type()constnoexcept{autopp=stack::push_pop(*this);intresult=lua_type(lua_state(),-1);returnstatic_cast<type>(result);}lua_State*lua_state()constnoexcept{returnluastate;}};inlinebooloperator==(constreference&l,constreference&r){autoppl=stack::push_pop(l);autoppr=stack::push_pop(r);returnlua_compare(l.lua_state(),-1,-2,LUA_OPEQ)==1;}inlinebooloperator!=(constreference&l,constreference&r){return!operator==(l,r);}}// sol// end of sol/reference.hpp// beginning of sol/stack.hpp// beginning of sol/stack_core.hpp// beginning of sol/userdata.hppnamespacesol{template<typenamebase_t>classbasic_userdata:publicbase_t{public:basic_userdata()noexcept=default;template<typenameT,meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>,basic_userdata>>,meta::neg<std::is_same<base_t,stack_reference>>,std::is_base_of<base_t,meta::unqualified_t<T>>>=meta::enabler>basic_userdata(T&&r)noexcept:base_t(std::forward<T>(r)){#ifdef SOL_CHECK_ARGUMENTSif(!is_userdata<meta::unqualified_t<T>>::value){autopp=stack::push_pop(*this);type_assert(base_t::lua_state(),-1,type::userdata);}#endif // Safety}basic_userdata(constbasic_userdata&)=default;basic_userdata(basic_userdata&&)=default;basic_userdata&operator=(constbasic_userdata&)=default;basic_userdata&operator=(basic_userdata&&)=default;basic_userdata(conststack_reference&r):basic_userdata(r.lua_state(),r.stack_index()){}basic_userdata(stack_reference&&r):basic_userdata(r.lua_state(),r.stack_index()){}template<typenameT,meta::enable<meta::neg<std::is_integral<meta::unqualified_t<T>>>,meta::neg<std::is_same<T,ref_index>>>=meta::enabler>basic_userdata(lua_State*L,T&&r):basic_userdata(L,sol::ref_index(r.registry_index())){}basic_userdata(lua_State*L,intindex=-1):base_t(L,index){#ifdef SOL_CHECK_ARGUMENTStype_assert(L,index,type::userdata);#endif // Safety}basic_userdata(lua_State*L,ref_indexindex):base_t(L,index){#ifdef SOL_CHECK_ARGUMENTSautopp=stack::push_pop(*this);type_assert(L,-1,type::userdata);#endif // Safety}};template<typenamebase_t>classbasic_lightuserdata:publicbase_t{public:basic_lightuserdata()noexcept=default;template<typenameT,meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>,basic_lightuserdata>>,meta::neg<std::is_same<base_t,stack_reference>>,std::is_base_of<base_t,meta::unqualified_t<T>>>=meta::enabler>basic_lightuserdata(T&&r)noexcept:base_t(std::forward<T>(r)){#ifdef SOL_CHECK_ARGUMENTSif(!is_userdata<meta::unqualified_t<T>>::value){autopp=stack::push_pop(*this);type_assert(base_t::lua_state(),-1,type::lightuserdata);}#endif // Safety}basic_lightuserdata(constbasic_lightuserdata&)=default;basic_lightuserdata(basic_lightuserdata&&)=default;basic_lightuserdata&operator=(constbasic_lightuserdata&)=default;basic_lightuserdata&operator=(basic_lightuserdata&&)=default;basic_lightuserdata(conststack_reference&r):basic_lightuserdata(r.lua_state(),r.stack_index()){}basic_lightuserdata(stack_reference&&r):basic_lightuserdata(r.lua_state(),r.stack_index()){}template<typenameT,meta::enable<meta::neg<std::is_integral<meta::unqualified_t<T>>>,meta::neg<std::is_same<T,ref_index>>>=meta::enabler>basic_lightuserdata(lua_State*L,T&&r):basic_lightuserdata(L,sol::ref_index(r.registry_index())){}basic_lightuserdata(lua_State*L,intindex=-1):base_t(L,index){#ifdef SOL_CHECK_ARGUMENTStype_assert(L,index,type::lightuserdata);#endif // Safety}basic_lightuserdata(lua_State*L,ref_indexindex):base_t(L,index){#ifdef SOL_CHECK_ARGUMENTSautopp=stack::push_pop(*this);type_assert(L,-1,type::lightuserdata);#endif // Safety}};}// sol// end of sol/userdata.hpp// beginning of sol/tie.hppnamespacesol{namespacedetail{template<typenameT>structis_speshul:std::false_type{};}template<typenameT>structtie_size:std::tuple_size<T>{};template<typenameT>structis_tieable:std::integral_constant<bool,(::sol::tie_size<T>::value>0)>{};template<typename...Tn>structtie_t:publicstd::tuple<std::add_lvalue_reference_t<Tn>...>{private:typedefstd::tuple<std::add_lvalue_reference_t<Tn>...>base_t;template<typenameT>voidset(std::false_type,T&&target){std::get<0>(*this)=std::forward<T>(target);}template<typenameT>voidset(std::true_type,T&&target){typedeftie_size<meta::unqualified_t<T>>value_size;typedeftie_size<std::tuple<Tn...>>tie_size;typedefstd::conditional_t<(value_size::value<tie_size::value),value_size,tie_size>indices_size;typedefstd::make_index_sequence<indices_size::value>indices;set_extra(detail::is_speshul<meta::unqualified_t<T>>(),indices(),std::forward<T>(target));}template<std::size_t...I,typenameT>voidset_extra(std::true_type,std::index_sequence<I...>,T&&target){usingstd::get;(void)detail::swallow{0,(get<I>(static_cast<base_t&>(*this))=get<I>(types<Tn...>(),target),0)...,0};}template<std::size_t...I,typenameT>voidset_extra(std::false_type,std::index_sequence<I...>,T&&target){usingstd::get;(void)detail::swallow{0,(get<I>(static_cast<base_t&>(*this))=get<I>(target),0)...,0};}public:usingbase_t::base_t;template<typenameT>tie_t&operator=(T&&value){typedefis_tieable<meta::unqualified_t<T>>tieable;set(tieable(),std::forward<T>(value));return*this;}};template<typename...Tn>structtie_size<tie_t<Tn...>>:std::tuple_size<std::tuple<Tn...>>{};namespaceadl_barrier_detail{template<typename...Tn>inlinetie_t<std::remove_reference_t<Tn>...>tie(Tn&&...argn){returntie_t<std::remove_reference_t<Tn>...>(std::forward<Tn>(argn)...);}}usingnamespaceadl_barrier_detail;}// sol// end of sol/tie.hpp// beginning of sol/stack_guard.hppnamespacesol{namespacedetail{inlinevoidstack_fail(int,int){#ifndef SOL_NO_EXCEPTIONSthrowerror(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}}// detailstructstack_guard{lua_State*L;inttop;std::function<void(int,int)>on_mismatch;stack_guard(lua_State*L):stack_guard(L,lua_gettop(L)){}stack_guard(lua_State*L,inttop,std::function<void(int,int)>fx=detail::stack_fail):L(L),top(top),on_mismatch(std::move(fx)){}boolcheck_stack(intmodification=0)const{intbottom=lua_gettop(L)+modification;if(top==bottom){returntrue;}on_mismatch(top,bottom);returnfalse;}~stack_guard(){check_stack();}};}// sol// end of sol/stack_guard.hpp#include<vector>namespacesol{namespacedetail{structas_reference_tag{};template<typenameT>structas_pointer_tag{};template<typenameT>structas_value_tag{};usingspecial_destruct_func=void(*)(void*);template<typenameT,typenameReal>inlinevoidspecial_destruct(void*memory){T**pointerpointer=static_cast<T**>(memory);special_destruct_func*dx=static_cast<special_destruct_func*>(static_cast<void*>(pointerpointer+1));Real*target=static_cast<Real*>(static_cast<void*>(dx+1));target->~Real();}template<typenameT>inlineintunique_destruct(lua_State*L){void*memory=lua_touserdata(L,1);T**pointerpointer=static_cast<T**>(memory);special_destruct_func&dx=*static_cast<special_destruct_func*>(static_cast<void*>(pointerpointer+1));(dx)(memory);return0;}template<typenameT>inlineintuser_alloc_destroy(lua_State*L){void*rawdata=lua_touserdata(L,1);T*data=static_cast<T*>(rawdata);std::allocator<T>alloc;alloc.destroy(data);return0;}template<typenameT>inlineintusertype_alloc_destroy(lua_State*L){void*rawdata=lua_touserdata(L,1);T**pdata=static_cast<T**>(rawdata);T*data=*pdata;std::allocator<T>alloc{};alloc.destroy(data);return0;}template<typenameT>voidreserve(T&,std::size_t){}template<typenameT,typenameAl>voidreserve(std::vector<T,Al>&arr,std::size_thint){arr.reserve(hint);}template<typenameT,typenameTr,typenameAl>voidreserve(std::basic_string<T,Tr,Al>&arr,std::size_thint){arr.reserve(hint);}}// detailnamespacestack{template<typenameT,boolglobal=false,boolraw=false,typename=void>structfield_getter;template<typenameT,boolglobal=false,boolraw=false,typename=void>structprobe_field_getter;template<typenameT,boolglobal=false,boolraw=false,typename=void>structfield_setter;template<typenameT,typename=void>structgetter;template<typenameT,typename=void>structpopper;template<typenameT,typename=void>structpusher;template<typenameT,type=lua_type_of<T>::value,typename=void>structchecker;template<typenameT,typename=void>structcheck_getter;structprobe{boolsuccess;intlevels;probe(bools,intl):success(s),levels(l){}operatorbool()const{returnsuccess;};};structrecord{intlast;intused;record():last(),used(){}voiduse(intcount){last=count;used+=count;}};namespacestack_detail{template<typenameT>structstrip{typedefTtype;};template<typenameT>structstrip<std::reference_wrapper<T>>{typedefT&type;};template<typenameT>structstrip<user<T>>{typedefT&type;};template<typenameT>structstrip<non_null<T>>{typedefTtype;};template<typenameT>usingstrip_t=typenamestrip<T>::type;constbooldefault_check_arguments=#ifdef SOL_CHECK_ARGUMENTStrue;#elsefalse;#endiftemplate<typenameT>inlinedecltype(auto)unchecked_get(lua_State*L,intindex,record&tracking){returngetter<meta::unqualified_t<T>>{}.get(L,index,tracking);}}// stack_detailinlineboolmaybe_indexable(lua_State*L,intindex=-1){typet=type_of(L,index);returnt==type::userdata||t==type::table;}template<typenameT,typename...Args>inlineintpush(lua_State*L,T&&t,Args&&...args){returnpusher<meta::unqualified_t<T>>{}.push(L,std::forward<T>(t),std::forward<Args>(args)...);}// overload allows to use a pusher of a specific type, but pass in any kind of argstemplate<typenameT,typenameArg,typename...Args,typename=std::enable_if_t<!std::is_same<T,Arg>::value>>inlineintpush(lua_State*L,Arg&&arg,Args&&...args){returnpusher<meta::unqualified_t<T>>{}.push(L,std::forward<Arg>(arg),std::forward<Args>(args)...);}template<typenameT,typename...Args>inlineintpush_reference(lua_State*L,T&&t,Args&&...args){typedefmeta::all<std::is_lvalue_reference<T>,meta::neg<std::is_const<T>>,meta::neg<is_lua_primitive<meta::unqualified_t<T>>>,meta::neg<is_unique_usertype<meta::unqualified_t<T>>>>use_reference_tag;returnpusher<std::conditional_t<use_reference_tag::value,detail::as_reference_tag,meta::unqualified_t<T>>>{}.push(L,std::forward<T>(t),std::forward<Args>(args)...);}inlineintmulti_push(lua_State*){// do nothingreturn0;}template<typenameT,typename...Args>inlineintmulti_push(lua_State*L,T&&t,Args&&...args){intpushcount=push(L,std::forward<T>(t));void(sol::detail::swallow{(pushcount+=sol::stack::push(L,std::forward<Args>(args)),0)...});returnpushcount;}inlineintmulti_push_reference(lua_State*){// do nothingreturn0;}template<typenameT,typename...Args>inlineintmulti_push_reference(lua_State*L,T&&t,Args&&...args){intpushcount=push_reference(L,std::forward<T>(t));void(sol::detail::swallow{(pushcount+=sol::stack::push_reference(L,std::forward<Args>(args)),0)...});returnpushcount;}template<typenameT,typenameHandler>boolcheck(lua_State*L,intindex,Handler&&handler,record&tracking){typedefmeta::unqualified_t<T>Tu;checker<Tu>c;// VC++ has a bad warning here: shut it up(void)c;returnc.check(L,index,std::forward<Handler>(handler),tracking);}template<typenameT,typenameHandler>boolcheck(lua_State*L,intindex,Handler&&handler){recordtracking{};returncheck<T>(L,index,std::forward<Handler>(handler),tracking);}template<typenameT>boolcheck(lua_State*L,intindex=-lua_size<meta::unqualified_t<T>>::value){autohandler=no_panic;returncheck<T>(L,index,handler);}template<typenameT,typenameHandler>inlinedecltype(auto)check_get(lua_State*L,intindex,Handler&&handler,record&tracking){returncheck_getter<meta::unqualified_t<T>>{}.get(L,index,std::forward<Handler>(handler),tracking);}template<typenameT,typenameHandler>inlinedecltype(auto)check_get(lua_State*L,intindex,Handler&&handler){recordtracking{};returncheck_get<T>(L,index,handler,tracking);}template<typenameT>inlinedecltype(auto)check_get(lua_State*L,intindex=-lua_size<meta::unqualified_t<T>>::value){autohandler=no_panic;returncheck_get<T>(L,index,handler);}namespacestack_detail{#ifdef SOL_CHECK_ARGUMENTStemplate<typenameT>inlineautotagged_get(types<T>,lua_State*L,intindex,record&tracking)->decltype(stack_detail::unchecked_get<T>(L,index,tracking)){autoop=check_get<T>(L,index,type_panic,tracking);return*std::move(op);}#elsetemplate<typenameT>inlinedecltype(auto)tagged_get(types<T>,lua_State*L,intindex,record&tracking){returnstack_detail::unchecked_get<T>(L,index,tracking);}#endiftemplate<typenameT>inlinedecltype(auto)tagged_get(types<optional<T>>,lua_State*L,intindex,record&tracking){returnstack_detail::unchecked_get<optional<T>>(L,index,tracking);}template<boolb>structcheck_types{template<typenameT,typename...Args,typenameHandler>staticboolcheck(types<T,Args...>,lua_State*L,intfirstargument,Handler&&handler,record&tracking){if(!stack::check<T>(L,firstargument+tracking.used,handler,tracking))returnfalse;returncheck(types<Args...>(),L,firstargument,std::forward<Handler>(handler),tracking);}template<typenameHandler>staticboolcheck(types<>,lua_State*,int,Handler&&,record&){returntrue;}};template<>structcheck_types<false>{template<typename...Args,typenameHandler>staticboolcheck(types<Args...>,lua_State*,int,Handler&&,record&){returntrue;}};}// stack_detailtemplate<boolb,typename...Args,typenameHandler>boolmulti_check(lua_State*L,intindex,Handler&&handler,record&tracking){returnstack_detail::check_types<b>{}.check(types<meta::unqualified_t<Args>...>(),L,index,std::forward<Handler>(handler),tracking);}template<boolb,typename...Args,typenameHandler>boolmulti_check(lua_State*L,intindex,Handler&&handler){recordtracking{};returnmulti_check<b,Args...>(L,index,std::forward<Handler>(handler),tracking);}template<boolb,typename...Args>boolmulti_check(lua_State*L,intindex){autohandler=no_panic;returnmulti_check<b,Args...>(L,index,handler);}template<typename...Args,typenameHandler>boolmulti_check(lua_State*L,intindex,Handler&&handler,record&tracking){returnmulti_check<true,Args...>(L,index,std::forward<Handler>(handler),tracking);}template<typename...Args,typenameHandler>boolmulti_check(lua_State*L,intindex,Handler&&handler){returnmulti_check<true,Args...>(L,index,std::forward<Handler>(handler));}template<typename...Args>boolmulti_check(lua_State*L,intindex){returnmulti_check<true,Args...>(L,index);}template<typenameT>inlinedecltype(auto)get(lua_State*L,intindex,record&tracking){returnstack_detail::tagged_get(types<T>(),L,index,tracking);}template<typenameT>inlinedecltype(auto)get(lua_State*L,intindex=-lua_size<meta::unqualified_t<T>>::value){recordtracking{};returnget<T>(L,index,tracking);}template<typenameT>inlinedecltype(auto)pop(lua_State*L){returnpopper<meta::unqualified_t<T>>{}.pop(L);}template<boolglobal=false,boolraw=false,typenameKey>voidget_field(lua_State*L,Key&&key){field_getter<meta::unqualified_t<Key>,global,raw>{}.get(L,std::forward<Key>(key));}template<boolglobal=false,boolraw=false,typenameKey>voidget_field(lua_State*L,Key&&key,inttableindex){field_getter<meta::unqualified_t<Key>,global,raw>{}.get(L,std::forward<Key>(key),tableindex);}template<boolglobal=false,typenameKey>voidraw_get_field(lua_State*L,Key&&key){get_field<global,true>(L,std::forward<Key>(key));}template<boolglobal=false,typenameKey>voidraw_get_field(lua_State*L,Key&&key,inttableindex){get_field<global,true>(L,std::forward<Key>(key),tableindex);}template<boolglobal=false,boolraw=false,typenameKey>probeprobe_get_field(lua_State*L,Key&&key){returnprobe_field_getter<meta::unqualified_t<Key>,global,raw>{}.get(L,std::forward<Key>(key));}template<boolglobal=false,boolraw=false,typenameKey>probeprobe_get_field(lua_State*L,Key&&key,inttableindex){returnprobe_field_getter<meta::unqualified_t<Key>,global,raw>{}.get(L,std::forward<Key>(key),tableindex);}template<boolglobal=false,typenameKey>probeprobe_raw_get_field(lua_State*L,Key&&key){returnprobe_get_field<global,true>(L,std::forward<Key>(key));}template<boolglobal=false,typenameKey>probeprobe_raw_get_field(lua_State*L,Key&&key,inttableindex){returnprobe_get_field<global,true>(L,std::forward<Key>(key),tableindex);}template<boolglobal=false,boolraw=false,typenameKey,typenameValue>voidset_field(lua_State*L,Key&&key,Value&&value){field_setter<meta::unqualified_t<Key>,global,raw>{}.set(L,std::forward<Key>(key),std::forward<Value>(value));}template<boolglobal=false,boolraw=false,typenameKey,typenameValue>voidset_field(lua_State*L,Key&&key,Value&&value,inttableindex){field_setter<meta::unqualified_t<Key>,global,raw>{}.set(L,std::forward<Key>(key),std::forward<Value>(value),tableindex);}template<boolglobal=false,typenameKey,typenameValue>voidraw_set_field(lua_State*L,Key&&key,Value&&value){set_field<global,true>(L,std::forward<Key>(key),std::forward<Value>(value));}template<boolglobal=false,typenameKey,typenameValue>voidraw_set_field(lua_State*L,Key&&key,Value&&value,inttableindex){set_field<global,true>(L,std::forward<Key>(key),std::forward<Value>(value),tableindex);}}// stack}// sol// end of sol/stack_core.hpp// beginning of sol/stack_check.hpp// beginning of sol/usertype_traits.hpp// beginning of sol/demangle.hpp#include<cctype>namespacesol{namespacedetail{#ifdef _MSC_VERtemplate<typenameT>inlinestd::stringctti_get_type_name(){conststaticstd::array<std::string,7>removals={{"public:","private:","protected:","struct ","class ","`anonymous-namespace'","`anonymous namespace'"}};std::stringname=__FUNCSIG__;std::size_tstart=name.find("get_type_name");if(start==std::string::npos)start=0;elsestart+=13;if(start<name.size()-1)start+=1;std::size_tend=name.find_last_of('>');if(end==std::string::npos)end=name.size();name=name.substr(start,end-start);if(name.find("struct",0)==0)name.replace(0,6,"",0);if(name.find("class",0)==0)name.replace(0,5,"",0);while(!name.empty()&&std::isblank(name.front()))name.erase(name.begin());while(!name.empty()&&std::isblank(name.back()))name.pop_back();for(std::size_tr=0;r<removals.size();++r){autofound=name.find(removals[r]);while(found!=std::string::npos){name.erase(found,removals[r].size());found=name.find(removals[r]);}}returnname;}#elif defined(__GNUC__) || defined(__clang__)template<typenameT,classseperator_mark=int>inlinestd::stringctti_get_type_name(){conststaticstd::array<std::string,2>removals={{"{anonymous}","(anonymous namespace)"}};std::stringname=__PRETTY_FUNCTION__;std::size_tstart=name.find_first_of('[');start=name.find_first_of('=',start);std::size_tend=name.find_last_of(']');if(end==std::string::npos)end=name.size();if(start==std::string::npos)start=0;if(start<name.size()-1)start+=1;name=name.substr(start,end-start);start=name.rfind("seperator_mark");if(start!=std::string::npos){name.erase(start-2,name.length());}while(!name.empty()&&std::isblank(name.front()))name.erase(name.begin());while(!name.empty()&&std::isblank(name.back()))name.pop_back();for(std::size_tr=0;r<removals.size();++r){autofound=name.find(removals[r]);while(found!=std::string::npos){name.erase(found,removals[r].size());found=name.find(removals[r]);}}returnname;}#else#error Compiler not supported for demangling#endif // compilerstemplate<typenameT>inlinestd::stringdemangle_once(){std::stringrealname=ctti_get_type_name<T>();returnrealname;}template<typenameT>inlinestd::stringshort_demangle_once(){std::stringrealname=ctti_get_type_name<T>();// This isn't the most complete but it'll do for now...?staticconststd::array<std::string,10>ops={{"operator<","operator<<","operator<<=","operator<=","operator>","operator>>","operator>>=","operator>=","operator->","operator->*"}};intlevel=0;std::ptrdiff_tidx=0;for(idx=static_cast<std::ptrdiff_t>(realname.empty()?0:realname.size()-1);idx>0;--idx){if(level==0&&realname[idx]==':'){break;}boolisleft=realname[idx]=='<';boolisright=realname[idx]=='>';if(!isleft&&!isright)continue;boolearlybreak=false;for(constauto&op:ops){std::size_tnisop=realname.rfind(op,idx);if(nisop==std::string::npos)continue;std::size_tnisopidx=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);}returnrealname;}template<typenameT>inlineconststd::string&demangle(){staticconststd::stringd=demangle_once<T>();returnd;}template<typenameT>inlineconststd::string&short_demangle(){staticconststd::stringd=short_demangle_once<T>();returnd;}}// detail}// sol// end of sol/demangle.hppnamespacesol{template<typenameT>structusertype_traits{staticconststd::string&name(){staticconststd::string&n=detail::short_demangle<T>();returnn;}staticconststd::string&qualified_name(){staticconststd::string&q_n=detail::demangle<T>();returnq_n;}staticconststd::string&metatable(){staticconststd::stringm=std::string("sol.").append(detail::demangle<T>());returnm;}staticconststd::string&user_metatable(){staticconststd::stringu_m=std::string("sol.").append(detail::demangle<T>()).append(".user");returnu_m;}staticconststd::string&user_gc_metatable(){staticconststd::stringu_g_m=std::string("sol.").append(detail::demangle<T>()).append(".user\xE2\x99\xBB");returnu_g_m;}staticconststd::string&gc_table(){staticconststd::stringg_t=std::string("sol.").append(detail::demangle<T>()).append(".\xE2\x99\xBB");returng_t;}};}// end of sol/usertype_traits.hpp// beginning of sol/inheritance.hpp#include<atomic>namespacesol{template<typename...Args>structbase_list{};template<typename...Args>usingbases=base_list<Args...>;typedefbases<>base_classes_tag;constautobase_classes=base_classes_tag();namespacedetail{template<typenameT>structhas_derived{staticboolvalue;};template<typenameT>boolhas_derived<T>::value=false;inlinestd::size_tunique_id(){staticstd::atomic<std::size_t>x(0);return++x;}template<typenameT>structid_for{staticconststd::size_tvalue;};template<typenameT>conststd::size_tid_for<T>::value=unique_id();inlinedecltype(auto)base_class_check_key(){staticconstauto&key="class_check";returnkey;}inlinedecltype(auto)base_class_cast_key(){staticconstauto&key="class_cast";returnkey;}inlinedecltype(auto)base_class_index_propogation_key(){staticconstauto&key=u8"\xF0\x9F\x8C\xB2.index";returnkey;}inlinedecltype(auto)base_class_new_index_propogation_key(){staticconstauto&key=u8"\xF0\x9F\x8C\xB2.new_index";returnkey;}template<typenameT,typename...Bases>structinheritance{staticbooltype_check_bases(types<>,std::size_t){returnfalse;}template<typenameBase,typename...Args>staticbooltype_check_bases(types<Base,Args...>,std::size_tti){returnti==id_for<Base>::value||type_check_bases(types<Args...>(),ti);}staticbooltype_check(std::size_tti){returnti==id_for<T>::value||type_check_bases(types<Bases...>(),ti);}staticvoid*type_cast_bases(types<>,T*,std::size_t){returnnullptr;}template<typenameBase,typename...Args>staticvoid*type_cast_bases(types<Base,Args...>,T*data,std::size_tti){// Make sure to convert to T first, and then dynamic cast to the proper typereturnti!=id_for<Base>::value?type_cast_bases(types<Args...>(),data,ti):static_cast<void*>(static_cast<Base*>(data));}staticvoid*type_cast(void*voiddata,std::size_tti){T*data=static_cast<T*>(voiddata);returnstatic_cast<void*>(ti!=id_for<T>::value?type_cast_bases(types<Bases...>(),data,ti):data);}};usinginheritance_check_function=decltype(&inheritance<void>::type_check);usinginheritance_cast_function=decltype(&inheritance<void>::type_cast);}// detail}// sol// end of sol/inheritance.hpp#include<utility>namespacesol{namespacestack{namespacestack_detail{template<typenameT,boolpoptable=true>inlineboolcheck_metatable(lua_State*L,intindex=-2){constauto&metakey=usertype_traits<T>::metatable();luaL_getmetatable(L,&metakey[0]);consttypeexpectedmetatabletype=static_cast<type>(lua_type(L,-1));if(expectedmetatabletype!=type::lua_nil){if(lua_rawequal(L,-1,index)==1){lua_pop(L,1+static_cast<int>(poptable));returntrue;}}lua_pop(L,1);returnfalse;}template<typeexpected,int(*check_func)(lua_State*,int)>structbasic_check{template<typenameHandler>staticboolcheck(lua_State*L,intindex,Handler&&handler,record&tracking){tracking.use(1);boolsuccess=check_func(L,index)==1;if(!success){// expected type, actual typehandler(L,index,expected,type_of(L,index));}returnsuccess;}};}// stack_detailtemplate<typenameT,typeexpected,typename>structchecker{template<typenameHandler>staticboolcheck(lua_State*L,intindex,Handler&&handler,record&tracking){tracking.use(1);consttypeindextype=type_of(L,index);boolsuccess=expected==indextype;if(!success){// expected type, actual typehandler(L,index,expected,indextype);}returnsuccess;}};template<typenameT>structchecker<T,type::number,std::enable_if_t<std::is_integral<T>::value>>{template<typenameHandler>staticboolcheck(lua_State*L,intindex,Handler&&handler,record&tracking){tracking.use(1);boolsuccess=lua_isinteger(L,index)==1;if(!success){// expected type, actual typehandler(L,index,type::number,type_of(L,index));}returnsuccess;}};template<typenameT>structchecker<T,type::number,std::enable_if_t<std::is_floating_point<T>::value>>{template<typenameHandler>staticboolcheck(lua_State*L,intindex,Handler&&handler,record&tracking){tracking.use(1);boolsuccess=lua_isnumber(L,index)==1;if(!success){// expected type, actual typehandler(L,index,type::number,type_of(L,index));}returnsuccess;}};template<typeexpected,typenameC>structchecker<lua_nil_t,expected,C>{template<typenameHandler>staticboolcheck(lua_State*L,intindex,Handler&&handler,record&tracking){boolsuccess=lua_isnil(L,index);if(success){tracking.use(1);returnsuccess;}tracking.use(0);success=lua_isnone(L,index);if(!success){// expected type, actual typehandler(L,index,expected,type_of(L,index));}returnsuccess;}};template<typeexpected,typenameC>structchecker<nullopt_t,expected,C>:checker<lua_nil_t>{};template<typenameC>structchecker<this_state,type::poly,C>{template<typenameHandler>staticboolcheck(lua_State*,int,Handler&&,record&tracking){tracking.use(0);returntrue;}};template<typenameC>structchecker<variadic_args,type::poly,C>{template<typenameHandler>staticboolcheck(lua_State*,int,Handler&&,record&tracking){tracking.use(0);returntrue;}};template<typenameC>structchecker<type,type::poly,C>{template<typenameHandler>staticboolcheck(lua_State*,int,Handler&&,record&tracking){tracking.use(0);returntrue;}};template<typenameT,typenameC>structchecker<T,type::poly,C>{template<typenameHandler>staticboolcheck(lua_State*L,intindex,Handler&&handler,record&tracking){tracking.use(1);boolsuccess=!lua_isnone(L,index);if(!success){// expected type, actual typehandler(L,index,type::none,type_of(L,index));}returnsuccess;}};template<typenameT,typenameC>structchecker<T,type::lightuserdata,C>{template<typenameHandler>staticboolcheck(lua_State*L,intindex,Handler&&handler,record&tracking){tracking.use(1);typet=type_of(L,index);boolsuccess=t==type::userdata||t==type::lightuserdata;if(!success){// expected type, actual typehandler(L,index,type::lightuserdata,t);}returnsuccess;}};template<typenameC>structchecker<userdata_value,type::userdata,C>{template<typenameHandler>staticboolcheck(lua_State*L,intindex,Handler&&handler,record&tracking){tracking.use(1);typet=type_of(L,index);boolsuccess=t==type::userdata;if(!success){// expected type, actual typehandler(L,index,type::userdata,t);}returnsuccess;}};template<typenameT,typenameC>structchecker<user<T>,type::userdata,C>:checker<user<T>,type::lightuserdata,C>{};template<typenameT,typenameC>structchecker<non_null<T>,type::userdata,C>:checker<T,lua_type_of<T>::value,C>{};template<typenameC>structchecker<lua_CFunction,type::function,C>:stack_detail::basic_check<type::function,lua_iscfunction>{};template<typenameC>structchecker<std::remove_pointer_t<lua_CFunction>,type::function,C>:checker<lua_CFunction,type::function,C>{};template<typenameC>structchecker<c_closure,type::function,C>:checker<lua_CFunction,type::function,C>{};template<typenameT,typenameC>structchecker<T,type::function,C>{template<typenameHandler>staticboolcheck(lua_State*L,intindex,Handler&&handler,record&tracking){tracking.use(1);typet=type_of(L,index);if(t==type::lua_nil||t==type::none||t==type::function){// allow for lua_nil to be returnedreturntrue;}if(t!=type::userdata&&t!=type::table){handler(L,index,type::function,t);returnfalse;}// Do advanced check for call-style userdata?staticconstauto&callkey=name_of(meta_function::call);if(lua_getmetatable(L,index)==0){// No metatable, no __call key possiblehandler(L,index,type::function,t);returnfalse;}if(lua_isnoneornil(L,-1)){lua_pop(L,1);handler(L,index,type::function,t);returnfalse;}lua_getfield(L,-1,&callkey[0]);if(lua_isnoneornil(L,-1)){lua_pop(L,2);handler(L,index,type::function,t);returnfalse;}// has call, is definitely a functionlua_pop(L,2);returntrue;}};template<typenameT,typenameC>structchecker<T,type::table,C>{template<typenameHandler>staticboolcheck(lua_State*L,intindex,Handler&&handler,record&tracking){tracking.use(1);typet=type_of(L,index);if(t==type::table){returntrue;}if(t!=type::userdata){handler(L,index,type::function,t);returnfalse;}returntrue;}};template<typenameT,typenameC>structchecker<detail::as_value_tag<T>,type::userdata,C>{template<typenameU,typenameHandler>staticboolcheck(types<U>,lua_State*L,typeindextype,intindex,Handler&&handler,record&tracking){tracking.use(1);if(indextype!=type::userdata){handler(L,index,type::userdata,indextype);returnfalse;}if(meta::any<std::is_same<T,lightuserdata_value>,std::is_same<T,userdata_value>,std::is_same<T,userdata>,std::is_same<T,lightuserdata>>::value)returntrue;if(lua_getmetatable(L,index)==0){returntrue;}intmetatableindex=lua_gettop(L);if(stack_detail::check_metatable<U>(L,metatableindex))returntrue;if(stack_detail::check_metatable<U*>(L,metatableindex))returntrue;if(stack_detail::check_metatable<detail::unique_usertype<U>>(L,metatableindex))returntrue;boolsuccess=false;if(detail::has_derived<T>::value){autopn=stack::pop_n(L,1);lua_pushstring(L,&detail::base_class_check_key()[0]);lua_rawget(L,metatableindex);if(type_of(L,-1)!=type::lua_nil){void*basecastdata=lua_touserdata(L,-1);detail::inheritance_check_functionic=(detail::inheritance_check_function)basecastdata;success=ic(detail::id_for<T>::value);}}if(!success){lua_pop(L,1);handler(L,index,type::userdata,indextype);returnfalse;}lua_pop(L,1);returntrue;}};template<typenameT,typenameC>structchecker<T,type::userdata,C>{template<typenameHandler>staticboolcheck(lua_State*L,intindex,Handler&&handler,record&tracking){consttypeindextype=type_of(L,index);returnchecker<detail::as_value_tag<T>,type::userdata,C>{}.check(types<T>(),L,indextype,index,std::forward<Handler>(handler),tracking);}};template<typenameT,typenameC>structchecker<T*,type::userdata,C>{template<typenameHandler>staticboolcheck(lua_State*L,intindex,Handler&&handler,record&tracking){consttypeindextype=type_of(L,index);// Allow lua_nil to be transformed to nullptrif(indextype==type::lua_nil){tracking.use(1);returntrue;}returnchecker<meta::unqualified_t<T>,type::userdata,C>{}.check(L,index,std::forward<Handler>(handler),tracking);}};template<typenameT>structchecker<T,type::userdata,std::enable_if_t<is_unique_usertype<T>::value>>{template<typenameHandler>staticboolcheck(lua_State*L,intindex,Handler&&handler,record&tracking){returnchecker<typenameunique_usertype_traits<T>::type,type::userdata>{}.check(L,index,std::forward<Handler>(handler),tracking);}};template<typenameT,typenameC>structchecker<std::reference_wrapper<T>,type::userdata,C>{template<typenameHandler>staticboolcheck(lua_State*L,intindex,Handler&&handler,record&tracking){returnchecker<T,type::userdata,C>{}.check(L,index,std::forward<Handler>(handler),tracking);}};template<typename...Args,typenameC>structchecker<std::tuple<Args...>,type::poly,C>{template<typenameHandler>staticboolcheck(lua_State*L,intindex,Handler&&handler,record&tracking){returnstack::multi_check<Args...>(L,index,std::forward<Handler>(handler),tracking);}};template<typenameA,typenameB,typenameC>structchecker<std::pair<A,B>,type::poly,C>{template<typenameHandler>staticboolcheck(lua_State*L,intindex,Handler&&handler,record&tracking){returnstack::multi_check<A,B>(L,index,std::forward<Handler>(handler),tracking);}};template<typenameT,typenameC>structchecker<optional<T>,type::poly,C>{template<typenameHandler>staticboolcheck(lua_State*L,intindex,Handler&&,record&tracking){typet=type_of(L,index);if(t==type::none){tracking.use(0);returntrue;}if(t==type::lua_nil){tracking.use(1);returntrue;}returnstack::check<T>(L,index,no_panic,tracking);}};}// stack}// sol// end of sol/stack_check.hpp// beginning of sol/stack_get.hpp// beginning of sol/overload.hppnamespacesol{template<typename...Functions>structoverload_set{std::tuple<Functions...>functions;template<typenameArg,typename...Args,meta::disable<std::is_same<overload_set,meta::unqualified_t<Arg>>>=meta::enabler>overload_set(Arg&&arg,Args&&...args):functions(std::forward<Arg>(arg),std::forward<Args>(args)...){}overload_set(constoverload_set&)=default;overload_set(overload_set&&)=default;overload_set&operator=(constoverload_set&)=default;overload_set&operator=(overload_set&&)=default;};template<typename...Args>decltype(auto)overload(Args&&...args){returnoverload_set<std::decay_t<Args>...>(std::forward<Args>(args)...);}}// end of sol/overload.hpp#ifdef SOL_CODECVT_SUPPORT#include<codecvt>#include<locale>#endifnamespacesol{namespacestack{template<typenameT,typename>structgetter{staticT&get(lua_State*L,intindex,record&tracking){returngetter<sol::detail::as_value_tag<T>>{}.get(L,index,tracking);}};template<typenameT>structgetter<T,std::enable_if_t<std::is_floating_point<T>::value>>{staticTget(lua_State*L,intindex,record&tracking){tracking.use(1);returnstatic_cast<T>(lua_tonumber(L,index));}};template<typenameT>structgetter<T,std::enable_if_t<meta::all<std::is_integral<T>,std::is_signed<T>>::value>>{staticTget(lua_State*L,intindex,record&tracking){tracking.use(1);returnstatic_cast<T>(lua_tointeger(L,index));}};template<typenameT>structgetter<T,std::enable_if_t<meta::all<std::is_integral<T>,std::is_unsigned<T>>::value>>{staticTget(lua_State*L,intindex,record&tracking){tracking.use(1);returnstatic_cast<T>(lua_tointeger(L,index));}};template<typenameT>structgetter<T,std::enable_if_t<std::is_enum<T>::value>>{staticTget(lua_State*L,intindex,record&tracking){tracking.use(1);returnstatic_cast<T>(lua_tointegerx(L,index,nullptr));}};template<typenameT>structgetter<as_table_t<T>,std::enable_if_t<!meta::has_key_value_pair<meta::unqualified_t<T>>::value>>{staticTget(lua_State*L,intindex,record&tracking){typedeftypenameT::value_typeV;tracking.use(1);index=lua_absindex(L,index);Tarr;get_field<false,true>(L,static_cast<lua_Integer>(-1),index);intisnum;std::size_tsizehint=static_cast<std::size_t>(lua_tointegerx(L,-1,&isnum));if(isnum!=0){detail::reserve(arr,sizehint);}lua_pop(L,1);#if SOL_LUA_VERSION >= 503// This method is HIGHLY performant over regular table iteration thanks to the Lua API changes in 5.3for(lua_Integeri=0;;i+=lua_size<V>::value,lua_pop(L,lua_size<V>::value)){for(intvi=0;vi<lua_size<V>::value;++vi){typet=static_cast<type>(lua_geti(L,index,i+vi));if(t==type::lua_nil){if(i==0){continue;}else{lua_pop(L,(vi+1));returnarr;}}}arr.push_back(stack::get<V>(L,-lua_size<V>::value));}#else// Zzzz slower but necessary thanks to the lower version API and missing functions qqfor(lua_Integeri=0;;i+=lua_size<V>::value,lua_pop(L,lua_size<V>::value)){for(intvi=0;vi<lua_size<V>::value;++vi){lua_pushinteger(L,i);lua_gettable(L,index);typet=type_of(L,-1);if(t==type::lua_nil){if(i==0){continue;}else{lua_pop(L,(vi+1));returnarr;}}}arr.push_back(stack::get<V>(L,-1));}#endifreturnarr;}};template<typenameT>structgetter<as_table_t<T>,std::enable_if_t<meta::has_key_value_pair<meta::unqualified_t<T>>::value>>{staticTget(lua_State*L,intindex,record&tracking){typedeftypenameT::value_typeP;typedeftypenameP::first_typeK;typedeftypenameP::second_typeV;tracking.use(1);Tassociative;index=lua_absindex(L,index);lua_pushnil(L);while(lua_next(L,index)!=0){decltype(auto)key=stack::check_get<K>(L,-2);if(!key){lua_pop(L,1);continue;}associative.emplace(std::forward<decltype(*key)>(*key),stack::get<V>(L,-1));lua_pop(L,1);}returnassociative;}};template<typenameT>structgetter<T,std::enable_if_t<std::is_base_of<reference,T>::value||std::is_base_of<stack_reference,T>::value>>{staticTget(lua_State*L,intindex,record&tracking){tracking.use(1);returnT(L,index);}};template<>structgetter<userdata_value>{staticuserdata_valueget(lua_State*L,intindex,record&tracking){tracking.use(1);returnuserdata_value(lua_touserdata(L,index));}};template<>structgetter<lightuserdata_value>{staticlightuserdata_valueget(lua_State*L,intindex,record&tracking){tracking.use(1);returnlightuserdata_value(lua_touserdata(L,index));}};template<typenameT>structgetter<light<T>>{staticlight<T>get(lua_State*L,intindex,record&tracking){tracking.use(1);returnlight<T>(static_cast<T*>(lua_touserdata(L,index)));}};template<typenameT>structgetter<user<T>>{staticT&get(lua_State*L,intindex,record&tracking){tracking.use(1);return*static_cast<T*>(lua_touserdata(L,index));}};template<typenameT>structgetter<user<T*>>{staticT*get(lua_State*L,intindex,record&tracking){tracking.use(1);returnstatic_cast<T*>(lua_touserdata(L,index));}};template<>structgetter<type>{statictypeget(lua_State*L,intindex,record&tracking){tracking.use(1);returnstatic_cast<type>(lua_type(L,index));}};template<>structgetter<bool>{staticboolget(lua_State*L,intindex,record&tracking){tracking.use(1);returnlua_toboolean(L,index)!=0;}};template<>structgetter<std::string>{staticstd::stringget(lua_State*L,intindex,record&tracking){tracking.use(1);std::size_tlen;autostr=lua_tolstring(L,index,&len);returnstd::string(str,len);}};template<>structgetter<string_detail::string_shim>{string_detail::string_shimget(lua_State*L,intindex,record&tracking){tracking.use(1);size_tlen;constchar*p=lua_tolstring(L,index,&len);returnstring_detail::string_shim(p,len);}};template<>structgetter<constchar*>{staticconstchar*get(lua_State*L,intindex,record&tracking){tracking.use(1);returnlua_tostring(L,index);}};template<>structgetter<char>{staticcharget(lua_State*L,intindex,record&tracking){tracking.use(1);size_tlen;autostr=lua_tolstring(L,index,&len);returnlen>0?str[0]:'\0';}};#ifdef SOL_CODECVT_SUPPORTtemplate<>structgetter<std::wstring>{staticstd::wstringget(lua_State*L,intindex,record&tracking){tracking.use(1);size_tlen;autostr=lua_tolstring(L,index,&len);if(len<1)returnstd::wstring();if(sizeof(wchar_t)==2){staticstd::wstring_convert<std::codecvt_utf8_utf16<wchar_t>>convert;std::wstringr=convert.from_bytes(str,str+len);#ifdef __MINGW32__// Fuck you, MinGW, and fuck you libstdc++ for introducing this absolutely asinine bug// https://sourceforge.net/p/mingw-w64/bugs/538/// http://chat.stackoverflow.com/transcript/message/32271369#32271369for(auto&c:r){uint8_t*b=reinterpret_cast<uint8_t*>(&c);std::swap(b[0],b[1]);}#endif returnr;}staticstd::wstring_convert<std::codecvt_utf8<wchar_t>>convert;std::wstringr=convert.from_bytes(str,str+len);returnr;}};template<>structgetter<std::u16string>{staticstd::u16stringget(lua_State*L,intindex,record&tracking){tracking.use(1);size_tlen;autostr=lua_tolstring(L,index,&len);if(len<1)returnstd::u16string();#ifdef _MSC_VERstaticstd::wstring_convert<std::codecvt_utf8_utf16<int16_t>,int16_t>convert;autointd=convert.from_bytes(str,str+len);std::u16stringr(intd.size(),'\0');std::memcpy(&r[0],intd.data(),intd.size()*sizeof(char16_t));#elsestaticstd::wstring_convert<std::codecvt_utf8_utf16<char16_t>,char16_t>convert;std::u16stringr=convert.from_bytes(str,str+len);#endif // VC++ is a shitreturnr;}};template<>structgetter<std::u32string>{staticstd::u32stringget(lua_State*L,intindex,record&tracking){tracking.use(1);size_tlen;autostr=lua_tolstring(L,index,&len);if(len<1)returnstd::u32string();#ifdef _MSC_VERstaticstd::wstring_convert<std::codecvt_utf8<int32_t>,int32_t>convert;autointd=convert.from_bytes(str,str+len);std::u32stringr(intd.size(),'\0');std::memcpy(&r[0],intd.data(),r.size()*sizeof(char32_t));#elsestaticstd::wstring_convert<std::codecvt_utf8<char32_t>,char32_t>convert;std::u32stringr=convert.from_bytes(str,str+len);#endif // VC++ is a shitreturnr;}};template<>structgetter<wchar_t>{staticwchar_tget(lua_State*L,intindex,record&tracking){autostr=getter<std::wstring>{}.get(L,index,tracking);returnstr.size()>0?str[0]:wchar_t(0);}};template<>structgetter<char16_t>{staticchar16_tget(lua_State*L,intindex,record&tracking){autostr=getter<std::u16string>{}.get(L,index,tracking);returnstr.size()>0?str[0]:char16_t(0);}};template<>structgetter<char32_t>{staticchar32_tget(lua_State*L,intindex,record&tracking){autostr=getter<std::u32string>{}.get(L,index,tracking);returnstr.size()>0?str[0]:char32_t(0);}};#endif // codecvt header supporttemplate<>structgetter<meta_function>{staticmeta_functionget(lua_State*L,intindex,record&tracking){tracking.use(1);constchar*name=getter<constchar*>{}.get(L,index,tracking);for(std::size_ti=0;i<meta_function_names.size();++i)if(meta_function_names[i]==name)returnstatic_cast<meta_function>(i);returnmeta_function::construct;}};template<>structgetter<lua_nil_t>{staticlua_nil_tget(lua_State*,int,record&tracking){tracking.use(1);returnlua_nil;}};template<>structgetter<std::nullptr_t>{staticstd::nullptr_tget(lua_State*,int,record&tracking){tracking.use(1);returnnullptr;}};template<>structgetter<nullopt_t>{staticnullopt_tget(lua_State*,int,record&tracking){tracking.use(1);returnnullopt;}};template<>structgetter<this_state>{staticthis_stateget(lua_State*L,int,record&tracking){tracking.use(0);returnthis_state{L};}};template<>structgetter<lua_CFunction>{staticlua_CFunctionget(lua_State*L,intindex,record&tracking){tracking.use(1);returnlua_tocfunction(L,index);}};template<>structgetter<c_closure>{staticc_closureget(lua_State*L,intindex,record&tracking){tracking.use(1);returnc_closure(lua_tocfunction(L,index),-1);}};template<>structgetter<error>{staticerrorget(lua_State*L,intindex,record&tracking){tracking.use(1);size_tsz=0;constchar*err=lua_tolstring(L,index,&sz);if(err==nullptr){returnerror(detail::direct_error,"");}returnerror(detail::direct_error,std::string(err,sz));}};template<>structgetter<void*>{staticvoid*get(lua_State*L,intindex,record&tracking){tracking.use(1);returnlua_touserdata(L,index);}};template<typenameT>structgetter<detail::as_value_tag<T>>{staticT*get_no_lua_nil(lua_State*L,intindex,record&tracking){tracking.use(1);void**pudata=static_cast<void**>(lua_touserdata(L,index));void*udata=*pudata;returnget_no_lua_nil_from(L,udata,index,tracking);}staticT*get_no_lua_nil_from(lua_State*L,void*udata,intindex,record&){if(detail::has_derived<T>::value&&luaL_getmetafield(L,index,&detail::base_class_cast_key()[0])!=0){void*basecastdata=lua_touserdata(L,-1);detail::inheritance_cast_functionic=(detail::inheritance_cast_function)basecastdata;// use the casting function to properly adjust the pointer for the desired Tudata=ic(udata,detail::id_for<T>::value);lua_pop(L,1);}T*obj=static_cast<T*>(udata);returnobj;}staticT&get(lua_State*L,intindex,record&tracking){return*get_no_lua_nil(L,index,tracking);}};template<typenameT>structgetter<detail::as_pointer_tag<T>>{staticT*get(lua_State*L,intindex,record&tracking){typet=type_of(L,index);if(t==type::lua_nil){tracking.use(1);returnnullptr;}returngetter<detail::as_value_tag<T>>::get_no_lua_nil(L,index,tracking);}};template<typenameT>structgetter<non_null<T*>>{staticT*get(lua_State*L,intindex,record&tracking){returngetter<detail::as_value_tag<T>>::get_no_lua_nil(L,index,tracking);}};template<typenameT>structgetter<T&>{staticT&get(lua_State*L,intindex,record&tracking){returngetter<detail::as_value_tag<T>>::get(L,index,tracking);}};template<typenameT>structgetter<std::reference_wrapper<T>>{staticT&get(lua_State*L,intindex,record&tracking){returngetter<T&>{}.get(L,index,tracking);}};template<typenameT>structgetter<T*>{staticT*get(lua_State*L,intindex,record&tracking){returngetter<detail::as_pointer_tag<T>>::get(L,index,tracking);}};template<typenameT>structgetter<T,std::enable_if_t<is_unique_usertype<T>::value>>{typedeftypenameunique_usertype_traits<T>::typeP;typedeftypenameunique_usertype_traits<T>::actual_typeReal;staticReal&get(lua_State*L,intindex,record&tracking){tracking.use(1);P**pref=static_cast<P**>(lua_touserdata(L,index));detail::special_destruct_func*fx=static_cast<detail::special_destruct_func*>(static_cast<void*>(pref+1));Real*mem=static_cast<Real*>(static_cast<void*>(fx+1));return*mem;}};template<typename...Args>structgetter<std::tuple<Args...>>{typedefstd::tuple<decltype(stack::get<Args>(nullptr,0))...>R;template<typename...TArgs>staticRapply(std::index_sequence<>,lua_State*,int,record&,TArgs&&...args){// Fuck you too, VC++returnR{std::forward<TArgs>(args)...};}template<std::size_tI,std::size_t...Ix,typename...TArgs>staticRapply(std::index_sequence<I,Ix...>,lua_State*L,intindex,record&tracking,TArgs&&...args){// Fuck you too, VC++typedefstd::tuple_element_t<I,std::tuple<Args...>>T;returnapply(std::index_sequence<Ix...>(),L,index,tracking,std::forward<TArgs>(args)...,stack::get<T>(L,index+tracking.used,tracking));}staticRget(lua_State*L,intindex,record&tracking){returnapply(std::make_index_sequence<sizeof...(Args)>(),L,index,tracking);}};template<typenameA,typenameB>structgetter<std::pair<A,B>>{staticdecltype(auto)get(lua_State*L,intindex,record&tracking){returnstd::pair<decltype(stack::get<A>(L,index)),decltype(stack::get<B>(L,index))>{stack::get<A>(L,index,tracking),stack::get<B>(L,index+tracking.used,tracking)};}};}// stack}// sol// end of sol/stack_get.hpp// beginning of sol/stack_check_get.hppnamespacesol{namespacestack{template<typenameT,typename>structcheck_getter{typedefdecltype(stack_detail::unchecked_get<T>(nullptr,0,std::declval<record&>()))R;template<typenameHandler>staticoptional<R>get(lua_State*L,intindex,Handler&&handler,record&tracking){if(!check<T>(L,index,std::forward<Handler>(handler))){tracking.use(static_cast<int>(!lua_isnone(L,index)));returnnullopt;}returnstack_detail::unchecked_get<T>(L,index,tracking);}};template<typenameT>structcheck_getter<optional<T>>{template<typenameHandler>staticdecltype(auto)get(lua_State*L,intindex,Handler&&,record&tracking){returncheck_get<T>(L,index,no_panic,tracking);}};template<typenameT>structcheck_getter<T,std::enable_if_t<std::is_integral<T>::value&&lua_type_of<T>::value==type::number>>{template<typenameHandler>staticoptional<T>get(lua_State*L,intindex,Handler&&handler,record&tracking){intisnum=0;lua_Integervalue=lua_tointegerx(L,index,&isnum);if(isnum==0){typet=type_of(L,index);tracking.use(static_cast<int>(t!=type::none));handler(L,index,type::number,t);returnnullopt;}tracking.use(1);returnstatic_cast<T>(value);}};template<typenameT>structcheck_getter<T,std::enable_if_t<std::is_enum<T>::value&&!meta::any_same<T,meta_function,type>::value>>{template<typenameHandler>staticoptional<T>get(lua_State*L,intindex,Handler&&handler,record&tracking){intisnum=0;lua_Integervalue=lua_tointegerx(L,index,&isnum);if(isnum==0){typet=type_of(L,index);tracking.use(static_cast<int>(t!=type::none));handler(L,index,type::number,t);returnnullopt;}tracking.use(1);returnstatic_cast<T>(value);}};template<typenameT>structcheck_getter<T,std::enable_if_t<std::is_floating_point<T>::value>>{template<typenameHandler>staticoptional<T>get(lua_State*L,intindex,Handler&&handler,record&tracking){intisnum=0;lua_Numbervalue=lua_tonumberx(L,index,&isnum);if(isnum==0){typet=type_of(L,index);tracking.use(static_cast<int>(t!=type::none));handler(L,index,type::number,t);returnnullopt;}tracking.use(1);returnstatic_cast<T>(value);}};template<typenameT>structgetter<optional<T>>{staticdecltype(auto)get(lua_State*L,intindex,record&tracking){returncheck_get<T>(L,index,no_panic,tracking);}};}// stack}// sol// end of sol/stack_check_get.hpp// beginning of sol/stack_push.hpp// beginning of sol/raii.hppnamespacesol{namespacedetail{structdefault_construct{template<typenameT,typename...Args>staticvoidconstruct(T&&obj,Args&&...args){std::allocator<meta::unqualified_t<T>>alloc{};alloc.construct(obj,std::forward<Args>(args)...);}template<typenameT,typename...Args>voidoperator()(T&&obj,Args&&...args)const{construct(std::forward<T>(obj),std::forward<Args>(args)...);}};structdefault_destruct{template<typenameT>staticvoiddestroy(T&&obj){std::allocator<meta::unqualified_t<T>>alloc{};alloc.destroy(obj);}template<typenameT>voidoperator()(T&&obj)const{destroy(std::forward<T>(obj));}};structdeleter{template<typenameT>voidoperator()(T*p)const{deletep;}};template<typenameT,typenameDx,typename...Args>inlinestd::unique_ptr<T,Dx>make_unique_deleter(Args&&...args){returnstd::unique_ptr<T,Dx>(newT(std::forward<Args>(args)...));}template<typenameTag,typenameT>structtagged{Tvalue;template<typenameArg,typename...Args,meta::disable<std::is_same<meta::unqualified_t<Arg>,tagged>>=meta::enabler>tagged(Arg&&arg,Args&&...args):value(std::forward<Arg>(arg),std::forward<Args>(args)...){}};}// detailtemplate<typename...Args>structconstructor_list{};template<typename...Args>usingconstructors=constructor_list<Args...>;constautodefault_constructor=constructors<types<>>{};structno_construction{};constautono_constructor=no_construction{};structcall_construction{};constautocall_constructor=call_construction{};template<typename...Functions>structconstructor_wrapper{std::tuple<Functions...>functions;template<typenameArg,typename...Args,meta::disable<std::is_same<meta::unqualified_t<Arg>,constructor_wrapper>>=meta::enabler>constructor_wrapper(Arg&&arg,Args&&...args):functions(std::forward<Arg>(arg),std::forward<Args>(args)...){}};template<typename...Functions>inlineautoinitializers(Functions&&...functions){returnconstructor_wrapper<std::decay_t<Functions>...>(std::forward<Functions>(functions)...);}template<typename...Functions>structfactory_wrapper{std::tuple<Functions...>functions;template<typenameArg,typename...Args,meta::disable<std::is_same<meta::unqualified_t<Arg>,factory_wrapper>>=meta::enabler>factory_wrapper(Arg&&arg,Args&&...args):functions(std::forward<Arg>(arg),std::forward<Args>(args)...){}};template<typename...Functions>inlineautofactories(Functions&&...functions){returnfactory_wrapper<std::decay_t<Functions>...>(std::forward<Functions>(functions)...);}template<typenameFunction>structdestructor_wrapper{Functionfx;destructor_wrapper(Functionf):fx(std::move(f)){}};template<>structdestructor_wrapper<void>{};constdestructor_wrapper<void>default_destructor{};template<typenameFx>inlineautodestructor(Fx&&fx){returndestructor_wrapper<std::decay_t<Fx>>(std::forward<Fx>(fx));}}// sol// end of sol/raii.hpp#ifdef SOL_CODECVT_SUPPORT#endifnamespacesol{namespacestack{template<typenameT>structpusher<detail::as_value_tag<T>>{template<typenameF,typename...Args>staticintpush_fx(lua_State*L,F&&f,Args&&...args){// Basically, we store all user-data like this:// If it's a movable/copyable value (no std::ref(x)), then we store the pointer to the new// data in the first sizeof(T*) bytes, and then however many bytes it takes to// do the actual object. Things that are std::ref or plain T* are stored as // just the sizeof(T*), and nothing else.T**pointerpointer=static_cast<T**>(lua_newuserdata(L,sizeof(T*)+sizeof(T)));T*&referencereference=*pointerpointer;T*allocationtarget=reinterpret_cast<T*>(pointerpointer+1);referencereference=allocationtarget;std::allocator<T>alloc{};alloc.construct(allocationtarget,std::forward<Args>(args)...);f();return1;}template<typenameK,typename...Args>staticintpush_keyed(lua_State*L,K&&k,Args&&...args){returnpush_fx(L,[&L,&k](){luaL_newmetatable(L,&k[0]);lua_setmetatable(L,-2);},std::forward<Args>(args)...);}template<typename...Args>staticintpush(lua_State*L,Args&&...args){returnpush_keyed(L,usertype_traits<T>::metatable(),std::forward<Args>(args)...);}};template<typenameT>structpusher<detail::as_pointer_tag<T>>{template<typenameF>staticintpush_fx(lua_State*L,F&&f,T*obj){if(obj==nullptr)returnstack::push(L,lua_nil);T**pref=static_cast<T**>(lua_newuserdata(L,sizeof(T*)));*pref=obj;f();return1;}template<typenameK>staticintpush_keyed(lua_State*L,K&&k,T*obj){returnpush_fx(L,[&L,&k](){luaL_newmetatable(L,&k[0]);lua_setmetatable(L,-2);},obj);}staticintpush(lua_State*L,T*obj){returnpush_keyed(L,usertype_traits<meta::unqualified_t<T>*>::metatable(),obj);}};template<>structpusher<detail::as_reference_tag>{template<typenameT>staticintpush(lua_State*L,T&&obj){returnstack::push(L,detail::ptr(obj));}};template<typenameT,typename>structpusher{template<typename...Args>staticintpush(lua_State*L,Args&&...args){returnpusher<detail::as_value_tag<T>>{}.push(L,std::forward<Args>(args)...);}};template<typenameT>structpusher<T*,meta::disable_if_t<meta::all<is_container<meta::unqualified_t<T>>,meta::neg<meta::any<std::is_base_of<reference,meta::unqualified_t<T>>,std::is_base_of<stack_reference,meta::unqualified_t<T>>>>>::value>>{template<typename...Args>staticintpush(lua_State*L,Args&&...args){returnpusher<detail::as_pointer_tag<T>>{}.push(L,std::forward<Args>(args)...);}};template<typenameT>structpusher<T,std::enable_if_t<is_unique_usertype<T>::value>>{typedeftypenameunique_usertype_traits<T>::typeP;typedeftypenameunique_usertype_traits<T>::actual_typeReal;template<typenameArg,meta::enable<std::is_base_of<Real,meta::unqualified_t<Arg>>>=meta::enabler>staticintpush(lua_State*L,Arg&&arg){if(unique_usertype_traits<T>::is_null(arg))returnstack::push(L,lua_nil);returnpush_deep(L,std::forward<Arg>(arg));}template<typenameArg0,typenameArg1,typename...Args>staticintpush(lua_State*L,Arg0&&arg0,Arg0&&arg1,Args&&...args){returnpush_deep(L,std::forward<Arg0>(arg0),std::forward<Arg1>(arg1),std::forward<Args>(args)...);}template<typename...Args>staticintpush_deep(lua_State*L,Args&&...args){P**pref=static_cast<P**>(lua_newuserdata(L,sizeof(P*)+sizeof(detail::special_destruct_func)+sizeof(Real)));detail::special_destruct_func*fx=static_cast<detail::special_destruct_func*>(static_cast<void*>(pref+1));Real*mem=static_cast<Real*>(static_cast<void*>(fx+1));*fx=detail::special_destruct<P,Real>;detail::default_construct::construct(mem,std::forward<Args>(args)...);*pref=unique_usertype_traits<T>::get(*mem);if(luaL_newmetatable(L,&usertype_traits<detail::unique_usertype<P>>::metatable()[0])==1){set_field(L,"__gc",detail::unique_destruct<P>);}lua_setmetatable(L,-2);return1;}};template<typenameT>structpusher<std::reference_wrapper<T>>{staticintpush(lua_State*L,conststd::reference_wrapper<T>&t){returnstack::push(L,std::addressof(detail::deref(t.get())));}};template<typenameT>structpusher<T,std::enable_if_t<std::is_floating_point<T>::value>>{staticintpush(lua_State*L,constT&value){lua_pushnumber(L,value);return1;}};template<typenameT>structpusher<T,std::enable_if_t<meta::all<std::is_integral<T>,std::is_signed<T>>::value>>{staticintpush(lua_State*L,constT&value){lua_pushinteger(L,static_cast<lua_Integer>(value));return1;}};template<typenameT>structpusher<T,std::enable_if_t<std::is_enum<T>::value>>{staticintpush(lua_State*L,constT&value){if(std::is_same<char,T>::value){returnstack::push(L,static_cast<int>(value));}returnstack::push(L,static_cast<std::underlying_type_t<T>>(value));}};template<typenameT>structpusher<T,std::enable_if_t<meta::all<std::is_integral<T>,std::is_unsigned<T>>::value>>{staticintpush(lua_State*L,constT&value){lua_pushinteger(L,static_cast<lua_Integer>(value));return1;}};template<typenameT>structpusher<as_table_t<T>,std::enable_if_t<!meta::has_key_value_pair<meta::unqualified_t<std::remove_pointer_t<T>>>::value>>{staticintpush(lua_State*L,constas_table_t<T>&tablecont){auto&cont=detail::deref(detail::unwrap(tablecont.source));lua_createtable(L,static_cast<int>(cont.size()),0);inttableindex=lua_gettop(L);std::size_tindex=1;for(constauto&i:cont){#if SOL_LUA_VERSION >= 503intp=stack::push(L,i);for(intpi=0;pi<p;++pi){lua_seti(L,tableindex,static_cast<lua_Integer>(index++));}#elselua_pushinteger(L,static_cast<lua_Integer>(index));intp=stack::push(L,i);if(p==1){++index;lua_settable(L,tableindex);}else{intfirstindex=tableindex+1+1;for(intpi=0;pi<p;++pi){stack::push(L,index);lua_pushvalue(L,firstindex);lua_settable(L,tableindex);++index;++firstindex;}lua_pop(L,1+p);}#endif}// TODO: figure out a better way to do this...?//set_field(L, -1, cont.size());return1;}};template<typenameT>structpusher<as_table_t<T>,std::enable_if_t<meta::has_key_value_pair<meta::unqualified_t<std::remove_pointer_t<T>>>::value>>{staticintpush(lua_State*L,constas_table_t<T>&tablecont){auto&cont=detail::deref(detail::unwrap(tablecont.source));lua_createtable(L,static_cast<int>(cont.size()),0);inttableindex=lua_gettop(L);for(constauto&pair:cont){set_field(L,pair.first,pair.second,tableindex);}return1;}};template<typenameT>structpusher<T,std::enable_if_t<std::is_base_of<reference,T>::value||std::is_base_of<stack_reference,T>::value>>{staticintpush(lua_State*L,constT&ref){returnref.push(L);}staticintpush(lua_State*L,T&&ref){returnref.push(L);}};template<>structpusher<bool>{staticintpush(lua_State*L,boolb){lua_pushboolean(L,b);return1;}};template<>structpusher<lua_nil_t>{staticintpush(lua_State*L,lua_nil_t){lua_pushnil(L);return1;}};template<>structpusher<metatable_key_t>{staticintpush(lua_State*L,metatable_key_t){lua_pushlstring(L,"__mt",4);return1;}};template<>structpusher<std::remove_pointer_t<lua_CFunction>>{staticintpush(lua_State*L,lua_CFunctionfunc,intn=0){lua_pushcclosure(L,func,n);return1;}};template<>structpusher<lua_CFunction>{staticintpush(lua_State*L,lua_CFunctionfunc,intn=0){lua_pushcclosure(L,func,n);return1;}};template<>structpusher<c_closure>{staticintpush(lua_State*L,c_closurecc){lua_pushcclosure(L,cc.c_function,cc.upvalues);return1;}};template<typenameArg,typename...Args>structpusher<closure<Arg,Args...>>{template<std::size_t...I,typenameT>staticintpush(std::index_sequence<I...>,lua_State*L,T&&c){intpushcount=multi_push(L,detail::forward_get<I>(c.upvalues)...);returnstack::push(L,c_closure(c.c_function,pushcount));}template<typenameT>staticintpush(lua_State*L,T&&c){returnpush(std::make_index_sequence<1+sizeof...(Args)>(),L,std::forward<T>(c));}};template<>structpusher<void*>{staticintpush(lua_State*L,void*userdata){lua_pushlightuserdata(L,userdata);return1;}};template<>structpusher<lightuserdata_value>{staticintpush(lua_State*L,lightuserdata_valueuserdata){lua_pushlightuserdata(L,userdata);return1;}};template<typenameT>structpusher<light<T>>{staticintpush(lua_State*L,light<T>l){lua_pushlightuserdata(L,static_cast<void*>(l.value));return1;}};template<typenameT>structpusher<user<T>>{template<boolwith_meta=true,typenameKey,typename...Args>staticintpush_with(lua_State*L,Key&&name,Args&&...args){// A dumb pushervoid*rawdata=lua_newuserdata(L,sizeof(T));T*data=static_cast<T*>(rawdata);std::allocator<T>alloc;alloc.construct(data,std::forward<Args>(args)...);if(with_meta){lua_CFunctioncdel=detail::user_alloc_destroy<T>;// Make sure we have a plain GC set for this dataif(luaL_newmetatable(L,name)!=0){lua_pushcclosure(L,cdel,0);lua_setfield(L,-2,"__gc");}lua_setmetatable(L,-2);}return1;}template<typenameArg,typename...Args,meta::disable<meta::any_same<meta::unqualified_t<Arg>,no_metatable_t,metatable_key_t>>=meta::enabler>staticintpush(lua_State*L,Arg&&arg,Args&&...args){constautoname=&usertype_traits<meta::unqualified_t<T>>::user_gc_metatable()[0];returnpush_with(L,name,std::forward<Arg>(arg),std::forward<Args>(args)...);}template<typename...Args>staticintpush(lua_State*L,no_metatable_t,Args&&...args){constautoname=&usertype_traits<meta::unqualified_t<T>>::user_gc_metatable()[0];returnpush_with<false>(L,name,std::forward<Args>(args)...);}template<typenameKey,typename...Args>staticintpush(lua_State*L,metatable_key_t,Key&&key,Args&&...args){constautoname=&key[0];returnpush_with<true>(L,name,std::forward<Args>(args)...);}staticintpush(lua_State*L,constuser<T>&u){constautoname=&usertype_traits<meta::unqualified_t<T>>::user_gc_metatable()[0];returnpush_with(L,name,u.value);}staticintpush(lua_State*L,user<T>&&u){constautoname=&usertype_traits<meta::unqualified_t<T>>::user_gc_metatable()[0];returnpush_with(L,name,std::move(u.value));}staticintpush(lua_State*L,no_metatable_t,constuser<T>&u){constautoname=&usertype_traits<meta::unqualified_t<T>>::user_gc_metatable()[0];returnpush_with<false>(L,name,u.value);}staticintpush(lua_State*L,no_metatable_t,user<T>&&u){constautoname=&usertype_traits<meta::unqualified_t<T>>::user_gc_metatable()[0];returnpush_with<false>(L,name,std::move(u.value));}};template<>structpusher<userdata_value>{staticintpush(lua_State*L,userdata_valuedata){void**ud=static_cast<void**>(lua_newuserdata(L,sizeof(void*)));*ud=data.value;return1;}};template<>structpusher<constchar*>{staticintpush_sized(lua_State*L,constchar*str,std::size_tlen){lua_pushlstring(L,str,len);return1;}staticintpush(lua_State*L,constchar*str){if(str==nullptr)returnstack::push(L,lua_nil);returnpush_sized(L,str,std::char_traits<char>::length(str));}staticintpush(lua_State*L,constchar*strb,constchar*stre){returnpush_sized(L,strb,stre-strb);}staticintpush(lua_State*L,constchar*str,std::size_tlen){returnpush_sized(L,str,len);}};template<size_tN>structpusher<char[N]>{staticintpush(lua_State*L,constchar(&str)[N]){lua_pushlstring(L,str,N-1);return1;}staticintpush(lua_State*L,constchar(&str)[N],std::size_tsz){lua_pushlstring(L,str,sz);return1;}};template<>structpusher<char>{staticintpush(lua_State*L,charc){constcharstr[2]={c,'\0'};returnstack::push(L,str,1);}};template<>structpusher<std::string>{staticintpush(lua_State*L,conststd::string&str){lua_pushlstring(L,str.c_str(),str.size());return1;}staticintpush(lua_State*L,conststd::string&str,std::size_tsz){lua_pushlstring(L,str.c_str(),sz);return1;}};template<>structpusher<meta_function>{staticintpush(lua_State*L,meta_functionm){conststd::string&str=name_of(m);lua_pushlstring(L,str.c_str(),str.size());return1;}};#ifdef SOL_CODECVT_SUPPORTtemplate<>structpusher<constwchar_t*>{staticintpush(lua_State*L,constwchar_t*wstr){returnpush(L,wstr,std::char_traits<wchar_t>::length(wstr));}staticintpush(lua_State*L,constwchar_t*wstr,std::size_tsz){returnpush(L,wstr,wstr+sz);}staticintpush(lua_State*L,constwchar_t*strb,constwchar_t*stre){if(sizeof(wchar_t)==2){staticstd::wstring_convert<std::codecvt_utf8_utf16<wchar_t>>convert;std::stringu8str=convert.to_bytes(strb,stre);returnstack::push(L,u8str);}staticstd::wstring_convert<std::codecvt_utf8<wchar_t>>convert;std::stringu8str=convert.to_bytes(strb,stre);returnstack::push(L,u8str);}};template<>structpusher<constchar16_t*>{staticintpush(lua_State*L,constchar16_t*u16str){returnpush(L,u16str,std::char_traits<char16_t>::length(u16str));}staticintpush(lua_State*L,constchar16_t*u16str,std::size_tsz){returnpush(L,u16str,u16str+sz);}staticintpush(lua_State*L,constchar16_t*strb,constchar16_t*stre){#ifdef _MSC_VERstaticstd::wstring_convert<std::codecvt_utf8_utf16<int16_t>,int16_t>convert;std::stringu8str=convert.to_bytes(reinterpret_cast<constint16_t*>(strb),reinterpret_cast<constint16_t*>(stre));#elsestaticstd::wstring_convert<std::codecvt_utf8_utf16<char16_t>,char16_t>convert;std::stringu8str=convert.to_bytes(strb,stre);#endif // VC++ is a shitreturnstack::push(L,u8str);}};template<>structpusher<constchar32_t*>{staticintpush(lua_State*L,constchar32_t*u32str){returnpush(L,u32str,u32str+std::char_traits<char32_t>::length(u32str));}staticintpush(lua_State*L,constchar32_t*u32str,std::size_tsz){returnpush(L,u32str,u32str+sz);}staticintpush(lua_State*L,constchar32_t*strb,constchar32_t*stre){#ifdef _MSC_VERstaticstd::wstring_convert<std::codecvt_utf8<int32_t>,int32_t>convert;std::stringu8str=convert.to_bytes(reinterpret_cast<constint32_t*>(strb),reinterpret_cast<constint32_t*>(stre));#elsestaticstd::wstring_convert<std::codecvt_utf8<char32_t>,char32_t>convert;std::stringu8str=convert.to_bytes(strb,stre);#endif // VC++ is a shitreturnstack::push(L,u8str);}};template<size_tN>structpusher<wchar_t[N]>{staticintpush(lua_State*L,constwchar_t(&str)[N]){returnpush(L,str,N-1);}staticintpush(lua_State*L,constwchar_t(&str)[N],std::size_tsz){returnstack::push<constwchar_t*>(L,str,str+sz);}};template<size_tN>structpusher<char16_t[N]>{staticintpush(lua_State*L,constchar16_t(&str)[N]){returnpush(L,str,N-1);}staticintpush(lua_State*L,constchar16_t(&str)[N],std::size_tsz){returnstack::push<constchar16_t*>(L,str,str+sz);}};template<size_tN>structpusher<char32_t[N]>{staticintpush(lua_State*L,constchar32_t(&str)[N]){returnpush(L,str,N-1);}staticintpush(lua_State*L,constchar32_t(&str)[N],std::size_tsz){returnstack::push<constchar32_t*>(L,str,str+sz);}};template<>structpusher<wchar_t>{staticintpush(lua_State*L,wchar_tc){constwchar_tstr[2]={c,'\0'};returnstack::push(L,str,1);}};template<>structpusher<char16_t>{staticintpush(lua_State*L,char16_tc){constchar16_tstr[2]={c,'\0'};returnstack::push(L,str,1);}};template<>structpusher<char32_t>{staticintpush(lua_State*L,char32_tc){constchar32_tstr[2]={c,'\0'};returnstack::push(L,str,1);}};template<>structpusher<std::wstring>{staticintpush(lua_State*L,conststd::wstring&wstr){returnpush(L,wstr.data(),wstr.size());}staticintpush(lua_State*L,conststd::wstring&wstr,std::size_tsz){returnstack::push(L,wstr.data(),wstr.data()+sz);}};template<>structpusher<std::u16string>{staticintpush(lua_State*L,conststd::u16string&u16str){returnpush(L,u16str,u16str.size());}staticintpush(lua_State*L,conststd::u16string&u16str,std::size_tsz){returnstack::push(L,u16str.data(),u16str.data()+sz);}};template<>structpusher<std::u32string>{staticintpush(lua_State*L,conststd::u32string&u32str){returnpush(L,u32str,u32str.size());}staticintpush(lua_State*L,conststd::u32string&u32str,std::size_tsz){returnstack::push(L,u32str.data(),u32str.data()+sz);}};#endif // codecvt Header Supporttemplate<typename...Args>structpusher<std::tuple<Args...>>{template<std::size_t...I,typenameT>staticintpush(std::index_sequence<I...>,lua_State*L,T&&t){intpushcount=0;(void)detail::swallow{0,(pushcount+=stack::push(L,detail::forward_get<I>(t)),0)...};returnpushcount;}template<typenameT>staticintpush(lua_State*L,T&&t){returnpush(std::index_sequence_for<Args...>(),L,std::forward<T>(t));}};template<typenameA,typenameB>structpusher<std::pair<A,B>>{template<typenameT>staticintpush(lua_State*L,T&&t){intpushcount=stack::push(L,detail::forward_get<0>(t));pushcount+=stack::push(L,detail::forward_get<1>(t));returnpushcount;}};template<typenameO>structpusher<optional<O>>{template<typenameT>staticintpush(lua_State*L,T&&t){if(t==nullopt){returnstack::push(L,nullopt);}returnstack::push(L,t.value());}};template<>structpusher<nullopt_t>{staticintpush(lua_State*L,nullopt_t){returnstack::push(L,lua_nil);}};template<>structpusher<std::nullptr_t>{staticintpush(lua_State*L,std::nullptr_t){returnstack::push(L,lua_nil);}};template<>structpusher<this_state>{staticintpush(lua_State*,constthis_state&){return0;}};}// stack}// sol// end of sol/stack_push.hpp// beginning of sol/stack_pop.hppnamespacesol{namespacestack{template<typenameT,typename>structpopper{inlinestaticdecltype(auto)pop(lua_State*L){recordtracking{};decltype(auto)r=get<T>(L,-lua_size<T>::value,tracking);lua_pop(L,tracking.used);returnr;}};template<typenameT>structpopper<T,std::enable_if_t<std::is_base_of<stack_reference,meta::unqualified_t<T>>::value>>{static_assert(meta::neg<std::is_base_of<stack_reference,meta::unqualified_t<T>>>::value,"You cannot pop something that derives from stack_reference: it will not remain on the stack and thusly will go out of scope!");};}// stack}// sol// end of sol/stack_pop.hpp// beginning of sol/stack_field.hppnamespacesol{namespacestack{template<typenameT,bool,bool,typename>structfield_getter{template<typenameKey>voidget(lua_State*L,Key&&key,inttableindex=-2){push(L,std::forward<Key>(key));lua_gettable(L,tableindex);}};template<typenameT,boolglobal,typenameC>structfield_getter<T,global,true,C>{template<typenameKey>voidget(lua_State*L,Key&&key,inttableindex=-2){push(L,std::forward<Key>(key));lua_rawget(L,tableindex);}};template<boolb,boolraw,typenameC>structfield_getter<metatable_key_t,b,raw,C>{voidget(lua_State*L,metatable_key_t,inttableindex=-1){if(lua_getmetatable(L,tableindex)==0)push(L,lua_nil);}};template<typenameT,boolraw>structfield_getter<T,true,raw,std::enable_if_t<meta::is_c_str<T>::value>>{template<typenameKey>voidget(lua_State*L,Key&&key,int=-1){lua_getglobal(L,&key[0]);}};template<typenameT>structfield_getter<T,false,false,std::enable_if_t<meta::is_c_str<T>::value>>{template<typenameKey>voidget(lua_State*L,Key&&key,inttableindex=-1){lua_getfield(L,tableindex,&key[0]);}};#if SOL_LUA_VERSION >= 503template<typenameT>structfield_getter<T,false,false,std::enable_if_t<std::is_integral<T>::value>>{template<typenameKey>voidget(lua_State*L,Key&&key,inttableindex=-1){lua_geti(L,tableindex,static_cast<lua_Integer>(key));}};#endif // Lua 5.3.x#if SOL_LUA_VERSION >= 502template<typenameC>structfield_getter<void*,false,true,C>{voidget(lua_State*L,void*key,inttableindex=-1){lua_rawgetp(L,tableindex,key);}};#endif // Lua 5.3.xtemplate<typenameT>structfield_getter<T,false,true,std::enable_if_t<std::is_integral<T>::value>>{template<typenameKey>voidget(lua_State*L,Key&&key,inttableindex=-1){lua_rawgeti(L,tableindex,static_cast<lua_Integer>(key));}};template<typename...Args,boolb,boolraw,typenameC>structfield_getter<std::tuple<Args...>,b,raw,C>{template<std::size_t...I,typenameKeys>voidapply(std::index_sequence<0,I...>,lua_State*L,Keys&&keys,inttableindex){get_field<b,raw>(L,detail::forward_get<0>(keys),tableindex);void(detail::swallow{(get_field<false,raw>(L,detail::forward_get<I>(keys)),0)...});referencesaved(L,-1);lua_pop(L,static_cast<int>(sizeof...(I)));saved.push();}template<typenameKeys>voidget(lua_State*L,Keys&&keys){apply(std::make_index_sequence<sizeof...(Args)>(),L,std::forward<Keys>(keys),lua_absindex(L,-1));}template<typenameKeys>voidget(lua_State*L,Keys&&keys,inttableindex){apply(std::make_index_sequence<sizeof...(Args)>(),L,std::forward<Keys>(keys),tableindex);}};template<typenameA,typenameB,boolb,boolraw,typenameC>structfield_getter<std::pair<A,B>,b,raw,C>{template<typenameKeys>voidget(lua_State*L,Keys&&keys,inttableindex){get_field<b,raw>(L,detail::forward_get<0>(keys),tableindex);get_field<false,raw>(L,detail::forward_get<1>(keys));referencesaved(L,-1);lua_pop(L,static_cast<int>(2));saved.push();}template<typenameKeys>voidget(lua_State*L,Keys&&keys){get_field<b,raw>(L,detail::forward_get<0>(keys));get_field<false,raw>(L,detail::forward_get<1>(keys));referencesaved(L,-1);lua_pop(L,static_cast<int>(2));saved.push();}};template<typenameT,bool,bool,typename>structfield_setter{template<typenameKey,typenameValue>voidset(lua_State*L,Key&&key,Value&&value,inttableindex=-3){push(L,std::forward<Key>(key));push(L,std::forward<Value>(value));lua_settable(L,tableindex);}};template<typenameT,boolb,typenameC>structfield_setter<T,b,true,C>{template<typenameKey,typenameValue>voidset(lua_State*L,Key&&key,Value&&value,inttableindex=-3){push(L,std::forward<Key>(key));push(L,std::forward<Value>(value));lua_rawset(L,tableindex);}};template<boolb,boolraw,typenameC>structfield_setter<metatable_key_t,b,raw,C>{template<typenameValue>voidset(lua_State*L,metatable_key_t,Value&&value,inttableindex=-2){push(L,std::forward<Value>(value));lua_setmetatable(L,tableindex);}};template<typenameT,boolraw>structfield_setter<T,true,raw,std::enable_if_t<meta::is_c_str<T>::value>>{template<typenameKey,typenameValue>voidset(lua_State*L,Key&&key,Value&&value,int=-2){push(L,std::forward<Value>(value));lua_setglobal(L,&key[0]);}};template<typenameT>structfield_setter<T,false,false,std::enable_if_t<meta::is_c_str<T>::value>>{template<typenameKey,typenameValue>voidset(lua_State*L,Key&&key,Value&&value,inttableindex=-2){push(L,std::forward<Value>(value));lua_setfield(L,tableindex,&key[0]);}};#if SOL_LUA_VERSION >= 503template<typenameT>structfield_setter<T,false,false,std::enable_if_t<std::is_integral<T>::value>>{template<typenameKey,typenameValue>voidset(lua_State*L,Key&&key,Value&&value,inttableindex=-2){push(L,std::forward<Value>(value));lua_seti(L,tableindex,static_cast<lua_Integer>(key));}};#endif // Lua 5.3.xtemplate<typenameT>structfield_setter<T,false,true,std::enable_if_t<std::is_integral<T>::value>>{template<typenameKey,typenameValue>voidset(lua_State*L,Key&&key,Value&&value,inttableindex=-2){push(L,std::forward<Value>(value));lua_rawseti(L,tableindex,static_cast<lua_Integer>(key));}};#if SOL_LUA_VERSION >= 502template<typenameC>structfield_setter<void*,false,true,C>{template<typenameKey,typenameValue>voidset(lua_State*L,void*key,Value&&value,inttableindex=-2){push(L,std::forward<Value>(value));lua_rawsetp(L,tableindex,key);}};#endif // Lua 5.2.xtemplate<typename...Args,boolb,boolraw,typenameC>structfield_setter<std::tuple<Args...>,b,raw,C>{template<boolg,std::size_tI,typenameKey,typenameValue>voidapply(std::index_sequence<I>,lua_State*L,Key&&keys,Value&&value,inttableindex){I<1?set_field<g,raw>(L,detail::forward_get<I>(keys),std::forward<Value>(value),tableindex):set_field<g,raw>(L,detail::forward_get<I>(keys),std::forward<Value>(value));}template<boolg,std::size_tI0,std::size_tI1,std::size_t...I,typenameKeys,typenameValue>voidapply(std::index_sequence<I0,I1,I...>,lua_State*L,Keys&&keys,Value&&value,inttableindex){I0<1?get_field<g,raw>(L,detail::forward_get<I0>(keys),tableindex):get_field<g,raw>(L,detail::forward_get<I0>(keys),-1);apply<false>(std::index_sequence<I1,I...>(),L,std::forward<Keys>(keys),std::forward<Value>(value),-1);}template<boolg,std::size_tI0,std::size_t...I,typenameKeys,typenameValue>voidtop_apply(std::index_sequence<I0,I...>,lua_State*L,Keys&&keys,Value&&value,inttableindex){apply<g>(std::index_sequence<I0,I...>(),L,std::forward<Keys>(keys),std::forward<Value>(value),tableindex);lua_pop(L,static_cast<int>(sizeof...(I)));}template<typenameKeys,typenameValue>voidset(lua_State*L,Keys&&keys,Value&&value,inttableindex=-3){top_apply<b>(std::make_index_sequence<sizeof...(Args)>(),L,std::forward<Keys>(keys),std::forward<Value>(value),tableindex);}};template<typenameA,typenameB,boolb,boolraw,typenameC>structfield_setter<std::pair<A,B>,b,raw,C>{template<typenameKeys,typenameValue>voidset(lua_State*L,Keys&&keys,Value&&value,inttableindex=-1){get_field<b,raw>(L,detail::forward_get<0>(keys),tableindex);set_field<false,raw>(L,detail::forward_get<1>(keys),std::forward<Value>(value));lua_pop(L,1);}};}// stack}// sol// end of sol/stack_field.hpp// beginning of sol/stack_probe.hppnamespacesol{namespacestack{template<typenameT,boolb,boolraw,typename>structprobe_field_getter{template<typenameKey>probeget(lua_State*L,Key&&key,inttableindex=-2){if(!b&&!maybe_indexable(L,tableindex)){returnprobe(false,0);}get_field<b,raw>(L,std::forward<Key>(key),tableindex);returnprobe(!check<lua_nil_t>(L),1);}};template<typenameA,typenameB,boolb,boolraw,typenameC>structprobe_field_getter<std::pair<A,B>,b,raw,C>{template<typenameKeys>probeget(lua_State*L,Keys&&keys,inttableindex=-2){if(!b&&!maybe_indexable(L,tableindex)){returnprobe(false,0);}get_field<b,raw>(L,std::get<0>(keys),tableindex);if(!maybe_indexable(L)){returnprobe(false,1);}get_field<false,raw>(L,std::get<1>(keys),tableindex);returnprobe(!check<lua_nil_t>(L),2);}};template<typename...Args,boolb,boolraw,typenameC>structprobe_field_getter<std::tuple<Args...>,b,raw,C>{template<std::size_tI,typenameKeys>probeapply(std::index_sequence<I>,intsofar,lua_State*L,Keys&&keys,inttableindex){get_field<I<1&&b,raw>(L,std::get<I>(keys),tableindex);returnprobe(!check<lua_nil_t>(L),sofar);}template<std::size_tI,std::size_tI1,std::size_t...In,typenameKeys>probeapply(std::index_sequence<I,I1,In...>,intsofar,lua_State*L,Keys&&keys,inttableindex){get_field<I<1&&b,raw>(L,std::get<I>(keys),tableindex);if(!maybe_indexable(L)){returnprobe(false,sofar);}returnapply(std::index_sequence<I1,In...>(),sofar+1,L,std::forward<Keys>(keys),-1);}template<typenameKeys>probeget(lua_State*L,Keys&&keys,inttableindex=-2){if(!b&&!maybe_indexable(L,tableindex)){returnprobe(false,0);}returnapply(std::index_sequence_for<Args...>(),1,L,std::forward<Keys>(keys),tableindex);}};}// stack}// sol// end of sol/stack_probe.hpp#include<cstring>namespacesol{namespacestack{namespacestack_detail{template<typenameT>inlineintpush_as_upvalues(lua_State*L,T&item){typedefstd::decay_t<T>TValue;conststaticstd::size_titemsize=sizeof(TValue);conststaticstd::size_tvoidsize=sizeof(void*);conststaticstd::size_tvoidsizem1=voidsize-1;conststaticstd::size_tdata_t_count=(sizeof(TValue)+voidsizem1)/voidsize;typedefstd::array<void*,data_t_count>data_t;data_tdata{{}};std::memcpy(&data[0],std::addressof(item),itemsize);intpushcount=0;for(auto&&v:data){pushcount+=push(L,lightuserdata_value(v));}returnpushcount;}template<typenameT>inlinestd::pair<T,int>get_as_upvalues(lua_State*L,intindex=1){conststaticstd::size_tdata_t_count=(sizeof(T)+(sizeof(void*)-1))/sizeof(void*);typedefstd::array<void*,data_t_count>data_t;data_tvoiddata{{}};for(std::size_ti=0,d=0;d<sizeof(T);++i,d+=sizeof(void*)){voiddata[i]=get<lightuserdata_value>(L,upvalue_index(index++));}returnstd::pair<T,int>(*reinterpret_cast<T*>(static_cast<void*>(voiddata.data())),index);}structevaluator{template<typenameFx,typename...Args>staticdecltype(auto)eval(types<>,std::index_sequence<>,lua_State*,int,record&,Fx&&fx,Args&&...args){returnstd::forward<Fx>(fx)(std::forward<Args>(args)...);}template<typenameFx,typenameArg,typename...Args,std::size_tI,std::size_t...Is,typename...FxArgs>staticdecltype(auto)eval(types<Arg,Args...>,std::index_sequence<I,Is...>,lua_State*L,intstart,record&tracking,Fx&&fx,FxArgs&&...fxargs){returneval(types<Args...>(),std::index_sequence<Is...>(),L,start,tracking,std::forward<Fx>(fx),std::forward<FxArgs>(fxargs)...,stack_detail::unchecked_get<Arg>(L,start+tracking.used,tracking));}};template<boolcheckargs=default_check_arguments,std::size_t...I,typenameR,typename...Args,typenameFx,typename...FxArgs,typename=std::enable_if_t<!std::is_void<R>::value>>inlinedecltype(auto)call(types<R>,types<Args...>ta,std::index_sequence<I...>tai,lua_State*L,intstart,Fx&&fx,FxArgs&&...args){#ifndef _MSC_VERstatic_assert(meta::all<meta::is_not_move_only<Args>...>::value,"One of the arguments being bound is a move-only type, and it is not being taken by reference: this will break your code. Please take a reference and std::move it manually if this was your intention.");#endif // This compiler make me so fucking sadmulti_check<checkargs,Args...>(L,start,type_panic);recordtracking{};returnevaluator{}.eval(ta,tai,L,start,tracking,std::forward<Fx>(fx),std::forward<FxArgs>(args)...);}template<boolcheckargs=default_check_arguments,std::size_t...I,typename...Args,typenameFx,typename...FxArgs>inlinevoidcall(types<void>,types<Args...>ta,std::index_sequence<I...>tai,lua_State*L,intstart,Fx&&fx,FxArgs&&...args){#ifndef _MSC_VERstatic_assert(meta::all<meta::is_not_move_only<Args>...>::value,"One of the arguments being bound is a move-only type, and it is not being taken by reference: this will break your code. Please take a reference and std::move it manually if this was your intention.");#endif // This compiler make me so fucking sadmulti_check<checkargs,Args...>(L,start,type_panic);recordtracking{};evaluator{}.eval(ta,tai,L,start,tracking,std::forward<Fx>(fx),std::forward<FxArgs>(args)...);}}// stack_detailtemplate<typenameT>intset_ref(lua_State*L,T&&arg,inttableindex=-2){push(L,std::forward<T>(arg));returnluaL_ref(L,tableindex);}inlinevoidremove(lua_State*L,intindex,intcount){if(count<1)return;inttop=lua_gettop(L);if(index==-1||top==index){// Slice them right off the toplua_pop(L,static_cast<int>(count));return;}// Remove each item one at a time using stack operations// Probably slower, maybe, haven't benchmarked,// but necessaryif(index<0){index=lua_gettop(L)+(index+1);}intlast=index+count;for(inti=index;i<last;++i){lua_remove(L,index);}}template<boolcheck_args=stack_detail::default_check_arguments,typenameR,typename...Args,typenameFx,typename...FxArgs,typename=std::enable_if_t<!std::is_void<R>::value>>inlinedecltype(auto)call(types<R>tr,types<Args...>ta,lua_State*L,intstart,Fx&&fx,FxArgs&&...args){typedefstd::make_index_sequence<sizeof...(Args)>args_indices;returnstack_detail::call<check_args>(tr,ta,args_indices(),L,start,std::forward<Fx>(fx),std::forward<FxArgs>(args)...);}template<boolcheck_args=stack_detail::default_check_arguments,typenameR,typename...Args,typenameFx,typename...FxArgs,typename=std::enable_if_t<!std::is_void<R>::value>>inlinedecltype(auto)call(types<R>tr,types<Args...>ta,lua_State*L,Fx&&fx,FxArgs&&...args){returncall<check_args>(tr,ta,L,1,std::forward<Fx>(fx),std::forward<FxArgs>(args)...);}template<boolcheck_args=stack_detail::default_check_arguments,typename...Args,typenameFx,typename...FxArgs>inlinevoidcall(types<void>tr,types<Args...>ta,lua_State*L,intstart,Fx&&fx,FxArgs&&...args){typedefstd::make_index_sequence<sizeof...(Args)>args_indices;stack_detail::call<check_args>(tr,ta,args_indices(),L,start,std::forward<Fx>(fx),std::forward<FxArgs>(args)...);}template<boolcheck_args=stack_detail::default_check_arguments,typename...Args,typenameFx,typename...FxArgs>inlinevoidcall(types<void>tr,types<Args...>ta,lua_State*L,Fx&&fx,FxArgs&&...args){call<check_args>(tr,ta,L,1,std::forward<Fx>(fx),std::forward<FxArgs>(args)...);}template<boolcheck_args=stack_detail::default_check_arguments,typenameR,typename...Args,typenameFx,typename...FxArgs,typename=std::enable_if_t<!std::is_void<R>::value>>inlinedecltype(auto)call_from_top(types<R>tr,types<Args...>ta,lua_State*L,Fx&&fx,FxArgs&&...args){returncall<check_args>(tr,ta,L,static_cast<int>(lua_gettop(L)-sizeof...(Args)),std::forward<Fx>(fx),std::forward<FxArgs>(args)...);}template<boolcheck_args=stack_detail::default_check_arguments,typename...Args,typenameFx,typename...FxArgs>inlinevoidcall_from_top(types<void>tr,types<Args...>ta,lua_State*L,Fx&&fx,FxArgs&&...args){call<check_args>(tr,ta,L,static_cast<int>(lua_gettop(L)-sizeof...(Args)),std::forward<Fx>(fx),std::forward<FxArgs>(args)...);}template<boolcheck_args=stack_detail::default_check_arguments,typename...Args,typenameFx,typename...FxArgs>inlineintcall_into_lua(types<void>tr,types<Args...>ta,lua_State*L,intstart,Fx&&fx,FxArgs&&...fxargs){call<check_args>(tr,ta,L,start,std::forward<Fx>(fx),std::forward<FxArgs>(fxargs)...);lua_settop(L,0);return0;}template<boolcheck_args=stack_detail::default_check_arguments,typenameRet0,typename...Ret,typename...Args,typenameFx,typename...FxArgs,typename=std::enable_if_t<meta::neg<std::is_void<Ret0>>::value>>inlineintcall_into_lua(types<Ret0,Ret...>,types<Args...>ta,lua_State*L,intstart,Fx&&fx,FxArgs&&...fxargs){decltype(auto)r=call<check_args>(types<meta::return_type_t<Ret0,Ret...>>(),ta,L,start,std::forward<Fx>(fx),std::forward<FxArgs>(fxargs)...);lua_settop(L,0);returnpush_reference(L,std::forward<decltype(r)>(r));}template<boolcheck_args=stack_detail::default_check_arguments,typenameFx,typename...FxArgs>inlineintcall_lua(lua_State*L,intstart,Fx&&fx,FxArgs&&...fxargs){typedeflua_bind_traits<meta::unqualified_t<Fx>>traits_type;typedeftypenametraits_type::args_listargs_list;typedeftypenametraits_type::returns_listreturns_list;returncall_into_lua(returns_list(),args_list(),L,start,std::forward<Fx>(fx),std::forward<FxArgs>(fxargs)...);}inlinecall_syntaxget_call_syntax(lua_State*L,conststd::string&key,intindex){if(lua_gettop(L)==0){returncall_syntax::dot;}luaL_getmetatable(L,key.c_str());autopn=pop_n(L,1);if(lua_compare(L,-1,index,LUA_OPEQ)!=1){returncall_syntax::dot;}returncall_syntax::colon;}inlinevoidscript(lua_State*L,conststd::string&code){if(luaL_dostring(L,code.c_str())){lua_error(L);}}inlinevoidscript_file(lua_State*L,conststd::string&filename){if(luaL_dofile(L,filename.c_str())){lua_error(L);}}inlinevoidluajit_exception_handler(lua_State*L,int(*handler)(lua_State*,lua_CFunction)=detail::c_trampoline){#ifdef SOL_LUAJITlua_pushlightuserdata(L,(void*)handler);autopn=pop_n(L,1);luaJIT_setmode(L,-1,LUAJIT_MODE_WRAPCFUNC|LUAJIT_MODE_ON);#else(void)L;(void)handler;#endif}inlinevoidluajit_exception_off(lua_State*L){#ifdef SOL_LUAJITluaJIT_setmode(L,-1,LUAJIT_MODE_WRAPCFUNC|LUAJIT_MODE_OFF);#else(void)L;#endif}}// stack}// sol// end of sol/stack.hpp// beginning of sol/as_args.hppnamespacesol{template<typenameT>structto_args_t{Tsrc;};template<typenameSource>autoas_args(Source&&source){returnto_args_t<Source>{std::forward<Source>(source)};}namespacestack{template<typenameT>structpusher<to_args_t<T>>{intpush(lua_State*L,constto_args_t<T>&e){intp=0;for(constauto&i:e.src){p+=stack::push(L,i);}returnp;}};}}// sol// end of sol/as_args.hpp// beginning of sol/variadic_args.hpp// beginning of sol/stack_proxy.hpp// beginning of sol/function.hpp// beginning of sol/function_result.hpp// beginning of sol/proxy_base.hppnamespacesol{template<typenameSuper>structproxy_base{operatorstd::string()const{constSuper&super=*static_cast<constSuper*>(static_cast<constvoid*>(this));returnsuper.templateget<std::string>();}template<typenameT,meta::enable<meta::neg<meta::is_string_constructible<T>>,is_proxy_primitive<meta::unqualified_t<T>>>=meta::enabler>operatorT()const{constSuper&super=*static_cast<constSuper*>(static_cast<constvoid*>(this));returnsuper.templateget<T>();}template<typenameT,meta::enable<meta::neg<meta::is_string_constructible<T>>,meta::neg<is_proxy_primitive<meta::unqualified_t<T>>>>=meta::enabler>operatorT&()const{constSuper&super=*static_cast<constSuper*>(static_cast<constvoid*>(this));returnsuper.templateget<T&>();}};}// sol// end of sol/proxy_base.hpp#include<cstdint>namespacesol{structfunction_result:publicproxy_base<function_result>{private:lua_State*L;intindex;intreturncount;public:function_result()=default;function_result(lua_State*Ls,intidx=-1,intretnum=0):L(Ls),index(idx),returncount(retnum){}function_result(constfunction_result&)=default;function_result&operator=(constfunction_result&)=default;function_result(function_result&&o):L(o.L),index(o.index),returncount(o.returncount){// Must be manual, otherwise destructor will screw us// return count being 0 is enough to keep things clean// but will be thorougho.L=nullptr;o.index=0;o.returncount=0;}function_result&operator=(function_result&&o){L=o.L;index=o.index;returncount=o.returncount;// Must be manual, otherwise destructor will screw us// return count being 0 is enough to keep things clean// but will be thorougho.L=nullptr;o.index=0;o.returncount=0;return*this;}template<typenameT>decltype(auto)get()const{returnstack::get<T>(L,index);}call_statusstatus()constnoexcept{returncall_status::ok;}boolvalid()constnoexcept{returnstatus()==call_status::ok||status()==call_status::yielded;}lua_State*lua_state()const{returnL;};intstack_index()const{returnindex;};~function_result(){lua_pop(L,returncount);}};}// sol// end of sol/function_result.hpp// beginning of sol/function_types.hpp// beginning of sol/function_types_core.hpp// beginning of sol/wrapper.hppnamespacesol{template<typenameF,typename=void>structwrapper{typedeflua_bind_traits<F>traits_type;typedeftypenametraits_type::args_listargs_list;typedeftypenametraits_type::args_listfree_args_list;typedeftypenametraits_type::returns_listreturns_list;template<typename...Args>staticdecltype(auto)call(F&f,Args&&...args){returnf(std::forward<Args>(args)...);}structcaller{template<typename...Args>decltype(auto)operator()(F&fx,Args&&...args)const{returncall(fx,std::forward<Args>(args)...);}};};template<typenameF>structwrapper<F,std::enable_if_t<std::is_function<meta::unqualified_t<std::remove_pointer_t<F>>>::value>>{typedeflua_bind_traits<F>traits_type;typedeftypenametraits_type::args_listargs_list;typedeftypenametraits_type::args_listfree_args_list;typedeftypenametraits_type::returns_listreturns_list;template<Ffx,typename...Args>staticdecltype(auto)invoke(Args&&...args){returnfx(std::forward<Args>(args)...);}template<typename...Args>staticdecltype(auto)call(F&fx,Args&&...args){returnfx(std::forward<Args>(args)...);}structcaller{template<typename...Args>decltype(auto)operator()(F&fx,Args&&...args)const{returncall(fx,std::forward<Args>(args)...);}};template<Ffx>structinvoker{template<typename...Args>decltype(auto)operator()(Args&&...args)const{returninvoke<fx>(std::forward<Args>(args)...);}};};template<typenameF>structwrapper<F,std::enable_if_t<std::is_member_object_pointer<meta::unqualified_t<F>>::value>>{typedeflua_bind_traits<F>traits_type;typedeftypenametraits_type::object_typeobject_type;typedeftypenametraits_type::return_typereturn_type;typedeftypenametraits_type::args_listargs_list;typedeftypes<object_type&,return_type>free_args_list;typedeftypenametraits_type::returns_listreturns_list;template<Ffx,typename...Args>staticdecltype(auto)invoke(object_type&mem,Args&&...args){return(mem.*fx)(std::forward<Args>(args)...);}template<typenameFx>staticdecltype(auto)call(Fx&&fx,object_type&mem){return(mem.*fx);}template<typenameFx,typenameArg,typename...Args>staticvoidcall(Fx&&fx,object_type&mem,Arg&&arg,Args&&...){(mem.*fx)=std::forward<Arg>(arg);}structcaller{template<typenameFx,typename...Args>decltype(auto)operator()(Fx&&fx,object_type&mem,Args&&...args)const{returncall(std::forward<Fx>(fx),mem,std::forward<Args>(args)...);}};template<Ffx>structinvoker{template<typename...Args>decltype(auto)operator()(Args&&...args)const{returninvoke<fx>(std::forward<Args>(args)...);}};};template<typenameF,typenameR,typenameO,typename...FArgs>structmember_function_wrapper{typedefOobject_type;typedeflua_bind_traits<F>traits_type;typedeftypenametraits_type::args_listargs_list;typedeftypes<object_type&,FArgs...>free_args_list;typedefmeta::tuple_types<R>returns_list;template<Ffx,typename...Args>staticRinvoke(O&mem,Args&&...args){return(mem.*fx)(std::forward<Args>(args)...);}template<typenameFx,typename...Args>staticRcall(Fx&&fx,O&mem,Args&&...args){return(mem.*fx)(std::forward<Args>(args)...);}structcaller{template<typenameFx,typename...Args>decltype(auto)operator()(Fx&&fx,O&mem,Args&&...args)const{returncall(std::forward<Fx>(fx),mem,std::forward<Args>(args)...);}};template<Ffx>structinvoker{template<typename...Args>decltype(auto)operator()(O&mem,Args&&...args)const{returninvoke<fx>(mem,std::forward<Args>(args)...);}};};template<typenameR,typenameO,typename...Args>structwrapper<R(O::*)(Args...)>:publicmember_function_wrapper<R(O::*)(Args...),R,O,Args...>{};template<typenameR,typenameO,typename...Args>structwrapper<R(O::*)(Args...)const>:publicmember_function_wrapper<R(O::*)(Args...)const,R,O,Args...>{};template<typenameR,typenameO,typename...Args>structwrapper<R(O::*)(Args...)constvolatile>:publicmember_function_wrapper<R(O::*)(Args...)constvolatile,R,O,Args...>{};template<typenameR,typenameO,typename...Args>structwrapper<R(O::*)(Args...)&>:publicmember_function_wrapper<R(O::*)(Args...)&,R,O,Args...>{};template<typenameR,typenameO,typename...Args>structwrapper<R(O::*)(Args...)const&>:publicmember_function_wrapper<R(O::*)(Args...)const&,R,O,Args...>{};template<typenameR,typenameO,typename...Args>structwrapper<R(O::*)(Args...)constvolatile&>:publicmember_function_wrapper<R(O::*)(Args...)constvolatile&,R,O,Args...>{};template<typenameR,typenameO,typename...Args>structwrapper<R(O::*)(Args...,...)&>:publicmember_function_wrapper<R(O::*)(Args...,...)&,R,O,Args...>{};template<typenameR,typenameO,typename...Args>structwrapper<R(O::*)(Args...,...)const&>:publicmember_function_wrapper<R(O::*)(Args...,...)const&,R,O,Args...>{};template<typenameR,typenameO,typename...Args>structwrapper<R(O::*)(Args...,...)constvolatile&>:publicmember_function_wrapper<R(O::*)(Args...,...)constvolatile&,R,O,Args...>{};template<typenameR,typenameO,typename...Args>structwrapper<R(O::*)(Args...)&&>:publicmember_function_wrapper<R(O::*)(Args...)&,R,O,Args...>{};template<typenameR,typenameO,typename...Args>structwrapper<R(O::*)(Args...)const&&>:publicmember_function_wrapper<R(O::*)(Args...)const&,R,O,Args...>{};template<typenameR,typenameO,typename...Args>structwrapper<R(O::*)(Args...)constvolatile&&>:publicmember_function_wrapper<R(O::*)(Args...)constvolatile&,R,O,Args...>{};template<typenameR,typenameO,typename...Args>structwrapper<R(O::*)(Args...,...)&&>:publicmember_function_wrapper<R(O::*)(Args...,...)&,R,O,Args...>{};template<typenameR,typenameO,typename...Args>structwrapper<R(O::*)(Args...,...)const&&>:publicmember_function_wrapper<R(O::*)(Args...,...)const&,R,O,Args...>{};template<typenameR,typenameO,typename...Args>structwrapper<R(O::*)(Args...,...)constvolatile&&>:publicmember_function_wrapper<R(O::*)(Args...,...)constvolatile&,R,O,Args...>{};}// sol// end of sol/wrapper.hppnamespacesol{namespacefunction_detail{template<typenameFx>inlineintcall(lua_State*L){Fx&fx=stack::get<user<Fx>>(L,upvalue_index(1));returnfx(L);}}// function_detail}// sol// end of sol/function_types_core.hpp// beginning of sol/function_types_templated.hpp// beginning of sol/call.hpp// beginning of sol/protect.hppnamespacesol{template<typenameT>structprotect_t{Tvalue;template<typenameArg,typename...Args,meta::disable<std::is_same<protect_t,meta::unqualified_t<Arg>>>=meta::enabler>protect_t(Arg&&arg,Args&&...args):value(std::forward<Arg>(arg),std::forward<Args>(args)...){}protect_t(constprotect_t&)=default;protect_t(protect_t&&)=default;protect_t&operator=(constprotect_t&)=default;protect_t&operator=(protect_t&&)=default;};template<typenameT>autoprotect(T&&value){returnprotect_t<std::decay_t<T>>(std::forward<T>(value));}}// sol// end of sol/protect.hpp// beginning of sol/property.hppnamespacesol{structno_prop{};template<typenameR,typenameW>structproperty_wrapper{typedefstd::integral_constant<bool,!std::is_void<R>::value>can_read;typedefstd::integral_constant<bool,!std::is_void<W>::value>can_write;typedefstd::conditional_t<can_read::value,R,no_prop>Read;typedefstd::conditional_t<can_write::value,W,no_prop>Write;Readread;Writewrite;template<typenameRx,typenameWx>property_wrapper(Rx&&r,Wx&&w):read(std::forward<Rx>(r)),write(std::forward<Wx>(w)){}};namespaceproperty_detail{template<typenameR,typenameW>inlinedecltype(auto)property(std::true_type,R&&read,W&&write){returnproperty_wrapper<std::decay_t<R>,std::decay_t<W>>(std::forward<R>(read),std::forward<W>(write));}template<typenameW,typenameR>inlinedecltype(auto)property(std::false_type,W&&write,R&&read){returnproperty_wrapper<std::decay_t<R>,std::decay_t<W>>(std::forward<R>(read),std::forward<W>(write));}template<typenameR>inlinedecltype(auto)property(std::true_type,R&&read){returnproperty_wrapper<std::decay_t<R>,void>(std::forward<R>(read),no_prop());}template<typenameW>inlinedecltype(auto)property(std::false_type,W&&write){returnproperty_wrapper<void,std::decay_t<W>>(no_prop(),std::forward<W>(write));}}// property_detailtemplate<typenameF,typenameG>inlinedecltype(auto)property(F&&f,G&&g){typedeflua_bind_traits<meta::unqualified_t<F>>left_traits;typedeflua_bind_traits<meta::unqualified_t<G>>right_traits;returnproperty_detail::property(meta::boolean<(left_traits::free_arity<right_traits::free_arity)>(),std::forward<F>(f),std::forward<G>(g));}template<typenameF>inlinedecltype(auto)property(F&&f){typedeflua_bind_traits<meta::unqualified_t<F>>left_traits;returnproperty_detail::property(meta::boolean<(left_traits::free_arity<2)>(),std::forward<F>(f));}template<typenameF>inlinedecltype(auto)readonly_property(F&&f){returnproperty_detail::property(std::true_type(),std::forward<F>(f));}// Allow someone to make a member variable readonly (const)template<typenameR,typenameT>inlineautoreadonly(RT::*v){typedefconstRC;returnstatic_cast<CT::*>(v);}template<typenameT>structvar_wrapper{Tvalue;template<typename...Args>var_wrapper(Args&&...args):value(std::forward<Args>(args)...){}var_wrapper(constvar_wrapper&)=default;var_wrapper(var_wrapper&&)=default;var_wrapper&operator=(constvar_wrapper&)=default;var_wrapper&operator=(var_wrapper&&)=default;};template<typenameV>inlineautovar(V&&v){typedefmeta::unqualified_t<V>T;returnvar_wrapper<T>(std::forward<V>(v));}}// sol// end of sol/property.hppnamespacesol{namespacecall_detail{template<typenameR,typenameW>inlineauto&pick(std::true_type,property_wrapper<R,W>&f){returnf.read;}template<typenameR,typenameW>inlineauto&pick(std::false_type,property_wrapper<R,W>&f){returnf.write;}template<typenameT,typenameList>structvoid_call;template<typenameT,typename...Args>structvoid_call<T,types<Args...>>{staticvoidcall(Args...){}};template<typenameT>structconstructor_match{T*obj;constructor_match(T*o):obj(o){}template<typenameFx,std::size_tI,typename...R,typename...Args>intoperator()(types<Fx>,index_value<I>,types<R...>r,types<Args...>a,lua_State*L,int,intstart)const{detail::default_constructfunc{};returnstack::call_into_lua<stack::stack_detail::default_check_arguments>(r,a,L,start,func,obj);}};namespaceoverload_detail{template<std::size_t...M,typenameMatch,typename...Args>inlineintoverload_match_arity(types<>,std::index_sequence<>,std::index_sequence<M...>,Match&&,lua_State*L,int,int,Args&&...){returnluaL_error(L,"sol: no matching function call takes this number of arguments and the specified types");}template<typenameFx,typename...Fxs,std::size_tI,std::size_t...In,std::size_t...M,typenameMatch,typename...Args>inlineintoverload_match_arity(types<Fx,Fxs...>,std::index_sequence<I,In...>,std::index_sequence<M...>,Match&&matchfx,lua_State*L,intfxarity,intstart,Args&&...args){typedeflua_bind_traits<meta::unqualified_t<Fx>>traits;typedefmeta::tuple_types<typenametraits::return_type>return_types;typedeftypenametraits::free_args_listargs_list;// compile-time eliminate any functions that we know ahead of time are of improper arityif(meta::find_in_pack_v<index_value<traits::free_arity>,index_value<M>...>::value){returnoverload_match_arity(types<Fxs...>(),std::index_sequence<In...>(),std::index_sequence<M...>(),std::forward<Match>(matchfx),L,fxarity,start,std::forward<Args>(args)...);}if(!traits::runtime_variadics_t::value&&traits::free_arity!=fxarity){returnoverload_match_arity(types<Fxs...>(),std::index_sequence<In...>(),std::index_sequence<traits::free_arity,M...>(),std::forward<Match>(matchfx),L,fxarity,start,std::forward<Args>(args)...);}stack::recordtracking{};if(!stack::stack_detail::check_types<true>{}.check(args_list(),L,start,no_panic,tracking)){returnoverload_match_arity(types<Fxs...>(),std::index_sequence<In...>(),std::index_sequence<M...>(),std::forward<Match>(matchfx),L,fxarity,start,std::forward<Args>(args)...);}returnmatchfx(types<Fx>(),index_value<I>(),return_types(),args_list(),L,fxarity,start,std::forward<Args>(args)...);}template<std::size_t...M,typenameMatch,typename...Args>inlineintoverload_match_arity_single(types<>,std::index_sequence<>,std::index_sequence<M...>,Match&&matchfx,lua_State*L,intfxarity,intstart,Args&&...args){returnoverload_match_arity(types<>(),std::index_sequence<>(),std::index_sequence<M...>(),std::forward<Match>(matchfx),L,fxarity,start,std::forward<Args>(args)...);}template<typenameFx,std::size_tI,std::size_t...M,typenameMatch,typename...Args>inlineintoverload_match_arity_single(types<Fx>,std::index_sequence<I>,std::index_sequence<M...>,Match&&matchfx,lua_State*L,intfxarity,intstart,Args&&...args){typedeflua_bind_traits<meta::unqualified_t<Fx>>traits;typedefmeta::tuple_types<typenametraits::return_type>return_types;typedeftypenametraits::free_args_listargs_list;// compile-time eliminate any functions that we know ahead of time are of improper arityif(meta::find_in_pack_v<index_value<traits::free_arity>,index_value<M>...>::value){returnoverload_match_arity(types<>(),std::index_sequence<>(),std::index_sequence<M...>(),std::forward<Match>(matchfx),L,fxarity,start,std::forward<Args>(args)...);}if(!traits::runtime_variadics_t::value&&traits::free_arity!=fxarity){returnoverload_match_arity(types<>(),std::index_sequence<>(),std::index_sequence<traits::free_arity,M...>(),std::forward<Match>(matchfx),L,fxarity,start,std::forward<Args>(args)...);}returnmatchfx(types<Fx>(),index_value<I>(),return_types(),args_list(),L,fxarity,start,std::forward<Args>(args)...);}template<typenameFx,typenameFx1,typename...Fxs,std::size_tI,std::size_tI1,std::size_t...In,std::size_t...M,typenameMatch,typename...Args>inlineintoverload_match_arity_single(types<Fx,Fx1,Fxs...>,std::index_sequence<I,I1,In...>,std::index_sequence<M...>,Match&&matchfx,lua_State*L,intfxarity,intstart,Args&&...args){typedeflua_bind_traits<meta::unqualified_t<Fx>>traits;typedefmeta::tuple_types<typenametraits::return_type>return_types;typedeftypenametraits::free_args_listargs_list;// compile-time eliminate any functions that we know ahead of time are of improper arityif(meta::find_in_pack_v<index_value<traits::free_arity>,index_value<M>...>::value){returnoverload_match_arity(types<Fx1,Fxs...>(),std::index_sequence<I1,In...>(),std::index_sequence<M...>(),std::forward<Match>(matchfx),L,fxarity,start,std::forward<Args>(args)...);}if(!traits::runtime_variadics_t::value&&traits::free_arity!=fxarity){returnoverload_match_arity(types<Fx1,Fxs...>(),std::index_sequence<I1,In...>(),std::index_sequence<traits::free_arity,M...>(),std::forward<Match>(matchfx),L,fxarity,start,std::forward<Args>(args)...);}stack::recordtracking{};if(!stack::stack_detail::check_types<true>{}.check(args_list(),L,start,no_panic,tracking)){returnoverload_match_arity(types<Fx1,Fxs...>(),std::index_sequence<I1,In...>(),std::index_sequence<M...>(),std::forward<Match>(matchfx),L,fxarity,start,std::forward<Args>(args)...);}returnmatchfx(types<Fx>(),index_value<I>(),return_types(),args_list(),L,fxarity,start,std::forward<Args>(args)...);}}// overload_detailtemplate<typename...Functions,typenameMatch,typename...Args>inlineintoverload_match_arity(Match&&matchfx,lua_State*L,intfxarity,intstart,Args&&...args){returnoverload_detail::overload_match_arity_single(types<Functions...>(),std::make_index_sequence<sizeof...(Functions)>(),std::index_sequence<>(),std::forward<Match>(matchfx),L,fxarity,start,std::forward<Args>(args)...);}template<typename...Functions,typenameMatch,typename...Args>inlineintoverload_match(Match&&matchfx,lua_State*L,intstart,Args&&...args){intfxarity=lua_gettop(L)-(start-1);returnoverload_match_arity<Functions...>(std::forward<Match>(matchfx),L,fxarity,start,std::forward<Args>(args)...);}template<typenameT,typename...TypeLists,typenameMatch,typename...Args>inlineintconstruct_match(Match&&matchfx,lua_State*L,intfxarity,intstart,Args&&...args){// use same overload resolution matching as all other parts of the frameworkreturnoverload_match_arity<decltype(void_call<T,TypeLists>::call)...>(std::forward<Match>(matchfx),L,fxarity,start,std::forward<Args>(args)...);}template<typenameT,typename...TypeLists>inlineintconstruct(lua_State*L){staticconstauto&meta=usertype_traits<T>::metatable();intargcount=lua_gettop(L);call_syntaxsyntax=argcount>0?stack::get_call_syntax(L,&usertype_traits<T>::user_metatable()[0],1):call_syntax::dot;argcount-=static_cast<int>(syntax);T**pointerpointer=reinterpret_cast<T**>(lua_newuserdata(L,sizeof(T*)+sizeof(T)));T*&referencepointer=*pointerpointer;T*obj=reinterpret_cast<T*>(pointerpointer+1);referencepointer=obj;referenceuserdataref(L,-1);userdataref.pop();construct_match<T,TypeLists...>(constructor_match<T>(obj),L,argcount,1+static_cast<int>(syntax));userdataref.push();luaL_getmetatable(L,&meta[0]);if(type_of(L,-1)==type::lua_nil){lua_pop(L,1);returnluaL_error(L,"sol: unable to get usertype metatable");}lua_setmetatable(L,-2);return1;}template<typenameF,boolis_index,boolis_variable,boolchecked,intboost,typename=void>structagnostic_lua_call_wrapper{template<typenameFx,typename...Args>staticintcall(lua_State*L,Fx&&f,Args&&...args){typedefwrapper<meta::unqualified_t<F>>wrap;typedeftypenamewrap::returns_listreturns_list;typedeftypenamewrap::free_args_listargs_list;typedeftypenamewrap::callercaller;returnstack::call_into_lua<checked>(returns_list(),args_list(),L,boost+1,caller(),std::forward<Fx>(f),std::forward<Args>(args)...);}};template<typenameT,boolis_variable,boolchecked,intboost,typenameC>structagnostic_lua_call_wrapper<var_wrapper<T>,true,is_variable,checked,boost,C>{template<typenameF>staticintcall(lua_State*L,F&&f){returnstack::push_reference(L,detail::unwrap(f.value));}};template<typenameT,boolis_variable,boolchecked,intboost,typenameC>structagnostic_lua_call_wrapper<var_wrapper<T>,false,is_variable,checked,boost,C>{template<typenameV>staticintcall_assign(std::true_type,lua_State*L,V&&f){detail::unwrap(f.value)=stack::get<meta::unwrapped_t<T>>(L,boost+(is_variable?3:1));return0;}template<typename...Args>staticintcall_assign(std::false_type,lua_State*L,Args&&...){returnluaL_error(L,"sol: cannot write to this variable: copy assignment/constructor not available");}template<typename...Args>staticintcall_const(std::false_type,lua_State*L,Args&&...args){typedefmeta::unwrapped_t<T>R;returncall_assign(std::is_assignable<std::add_lvalue_reference_t<meta::unqualified_t<R>>,R>(),L,std::forward<Args>(args)...);}template<typename...Args>staticintcall_const(std::true_type,lua_State*L,Args&&...){returnluaL_error(L,"sol: cannot write to a readonly (const) variable");}template<typenameV>staticintcall(lua_State*L,V&&f){returncall_const(std::is_const<meta::unwrapped_t<T>>(),L,f);}};template<boolis_index,boolis_variable,boolchecked,intboost,typenameC>structagnostic_lua_call_wrapper<lua_r_CFunction,is_index,is_variable,checked,boost,C>{staticintcall(lua_State*L,lua_r_CFunctionf){returnf(L);}};template<boolis_index,boolis_variable,boolchecked,intboost,typenameC>structagnostic_lua_call_wrapper<lua_CFunction,is_index,is_variable,checked,boost,C>{staticintcall(lua_State*L,lua_CFunctionf){returnf(L);}};template<boolis_index,boolis_variable,boolchecked,intboost,typenameC>structagnostic_lua_call_wrapper<no_prop,is_index,is_variable,checked,boost,C>{staticintcall(lua_State*L,constno_prop&){returnluaL_error(L,is_index?"sol: cannot read from a writeonly property":"sol: cannot write to a readonly property");}};template<boolis_index,boolis_variable,boolchecked,intboost,typenameC>structagnostic_lua_call_wrapper<no_construction,is_index,is_variable,checked,boost,C>{staticintcall(lua_State*L,constno_construction&){returnluaL_error(L,"sol: cannot call this constructor (tagged as non-constructible)");}};template<typename...Args,boolis_index,boolis_variable,boolchecked,intboost,typenameC>structagnostic_lua_call_wrapper<bases<Args...>,is_index,is_variable,checked,boost,C>{staticintcall(lua_State*,constbases<Args...>&){// Uh. How did you even call this, lulreturn0;}};template<typenameT,typenameF,boolis_index,boolis_variable,boolchecked=stack::stack_detail::default_check_arguments,intboost=0,typename=void>structlua_call_wrapper:agnostic_lua_call_wrapper<F,is_index,is_variable,checked,boost>{};template<typenameT,typenameF,boolis_index,boolis_variable,boolchecked,intboost>structlua_call_wrapper<T,F,is_index,is_variable,checked,boost,std::enable_if_t<std::is_member_function_pointer<F>::value>>{typedefwrapper<meta::unqualified_t<F>>wrap;typedeftypenamewrap::object_typeobject_type;template<typenameFx>staticintcall(lua_State*L,Fx&&f,object_type&o){typedeftypenamewrap::returns_listreturns_list;typedeftypenamewrap::args_listargs_list;typedeftypenamewrap::callercaller;returnstack::call_into_lua<checked>(returns_list(),args_list(),L,boost+(is_variable?3:2),caller(),std::forward<Fx>(f),o);}template<typenameFx>staticintcall(lua_State*L,Fx&&f){typedefstd::conditional_t<std::is_void<T>::value,object_type,T>Ta;#ifdef SOL_SAFE_USERTYPEautomaybeo=stack::check_get<Ta*>(L,1);if(!maybeo||maybeo.value()==nullptr){returnluaL_error(L,"sol: received nil for 'self' argument (use ':' for accessing member functions, make sure member variables are preceeded by the actual object with '.' syntax)");}object_type*o=static_cast<object_type*>(maybeo.value());returncall(L,std::forward<Fx>(f),*o);#elseobject_type&o=static_cast<object_type&>(*stack::get<non_null<Ta*>>(L,1));returncall(L,std::forward<Fx>(f),o);#endif // Safety}};template<typenameT,typenameF,boolis_variable,boolchecked,intboost>structlua_call_wrapper<T,F,false,is_variable,checked,boost,std::enable_if_t<std::is_member_object_pointer<F>::value>>{typedeflua_bind_traits<F>traits_type;typedefwrapper<meta::unqualified_t<F>>wrap;typedeftypenamewrap::object_typeobject_type;template<typenameV>staticintcall_assign(std::true_type,lua_State*L,V&&f,object_type&o){typedeftypenamewrap::args_listargs_list;typedeftypenamewrap::callercaller;returnstack::call_into_lua<checked>(types<void>(),args_list(),L,boost+(is_variable?3:2),caller(),f,o);}template<typenameV>staticintcall_assign(std::true_type,lua_State*L,V&&f){typedefstd::conditional_t<std::is_void<T>::value,object_type,T>Ta;#ifdef SOL_SAFE_USERTYPEautomaybeo=stack::check_get<Ta*>(L,1);if(!maybeo||maybeo.value()==nullptr){if(is_variable){returnluaL_error(L,"sol: received nil for 'self' argument (bad '.' access?)");}returnluaL_error(L,"sol: received nil for 'self' argument (pass 'self' as first argument)");}object_type*o=static_cast<object_type*>(maybeo.value());returncall_assign(std::true_type(),L,f,*o);#elseobject_type&o=static_cast<object_type&>(*stack::get<non_null<Ta*>>(L,1));returncall_assign(std::true_type(),L,f,o);#endif // Safety}template<typename...Args>staticintcall_assign(std::false_type,lua_State*L,Args&&...){returnluaL_error(L,"sol: cannot write to this variable: copy assignment/constructor not available");}template<typename...Args>staticintcall_const(std::false_type,lua_State*L,Args&&...args){typedeftypenametraits_type::return_typeR;returncall_assign(std::is_assignable<std::add_lvalue_reference_t<meta::unqualified_t<R>>,R>(),L,std::forward<Args>(args)...);}template<typename...Args>staticintcall_const(std::true_type,lua_State*L,Args&&...){returnluaL_error(L,"sol: cannot write to a readonly (const) variable");}template<typenameV>staticintcall(lua_State*L,V&&f){returncall_const(std::is_const<typenametraits_type::return_type>(),L,f);}template<typenameV>staticintcall(lua_State*L,V&&f,object_type&o){returncall_const(std::is_const<typenametraits_type::return_type>(),L,f,o);}};template<typenameT,typenameF,boolis_variable,boolchecked,intboost>structlua_call_wrapper<T,F,true,is_variable,checked,boost,std::enable_if_t<std::is_member_object_pointer<F>::value>>{typedeflua_bind_traits<F>traits_type;typedefwrapper<meta::unqualified_t<F>>wrap;typedeftypenamewrap::object_typeobject_type;template<typenameV>staticintcall(lua_State*L,V&&f,object_type&o){typedeftypenamewrap::returns_listreturns_list;typedeftypenamewrap::callercaller;returnstack::call_into_lua<checked>(returns_list(),types<>(),L,boost+(is_variable?3:2),caller(),f,o);}template<typenameV>staticintcall(lua_State*L,V&&f){typedefstd::conditional_t<std::is_void<T>::value,object_type,T>Ta;#ifdef SOL_SAFE_USERTYPEautomaybeo=stack::check_get<Ta*>(L,1);if(!maybeo||maybeo.value()==nullptr){if(is_variable){returnluaL_error(L,"sol: 'self' argument is lua_nil (bad '.' access?)");}returnluaL_error(L,"sol: 'self' argument is lua_nil (pass 'self' as first argument)");}object_type*o=static_cast<object_type*>(maybeo.value());returncall(L,f,*o);#elseobject_type&o=static_cast<object_type&>(*stack::get<non_null<Ta*>>(L,1));returncall(L,f,o);#endif // Safety}};template<typenameT,typename...Args,boolis_index,boolis_variable,boolchecked,intboost,typenameC>structlua_call_wrapper<T,constructor_list<Args...>,is_index,is_variable,checked,boost,C>{typedefconstructor_list<Args...>F;staticintcall(lua_State*L,F&){constauto&metakey=usertype_traits<T>::metatable();intargcount=lua_gettop(L);call_syntaxsyntax=argcount>0?stack::get_call_syntax(L,&usertype_traits<T>::user_metatable()[0],1):call_syntax::dot;argcount-=static_cast<int>(syntax);T**pointerpointer=reinterpret_cast<T**>(lua_newuserdata(L,sizeof(T*)+sizeof(T)));referenceuserdataref(L,-1);T*&referencepointer=*pointerpointer;T*obj=reinterpret_cast<T*>(pointerpointer+1);referencepointer=obj;construct_match<T,Args...>(constructor_match<T>(obj),L,argcount,boost+1+static_cast<int>(syntax));userdataref.push();luaL_getmetatable(L,&metakey[0]);if(type_of(L,-1)==type::lua_nil){lua_pop(L,1);returnluaL_error(L,"sol: unable to get usertype metatable");}lua_setmetatable(L,-2);return1;}};template<typenameT,typename...Cxs,boolis_index,boolis_variable,boolchecked,intboost,typenameC>structlua_call_wrapper<T,constructor_wrapper<Cxs...>,is_index,is_variable,checked,boost,C>{typedefconstructor_wrapper<Cxs...>F;structonmatch{template<typenameFx,std::size_tI,typename...R,typename...Args>intoperator()(types<Fx>,index_value<I>,types<R...>r,types<Args...>a,lua_State*L,int,intstart,F&f){constauto&metakey=usertype_traits<T>::metatable();T**pointerpointer=reinterpret_cast<T**>(lua_newuserdata(L,sizeof(T*)+sizeof(T)));referenceuserdataref(L,-1);T*&referencepointer=*pointerpointer;T*obj=reinterpret_cast<T*>(pointerpointer+1);referencepointer=obj;auto&func=std::get<I>(f.functions);stack::call_into_lua<checked>(r,a,L,boost+start,func,detail::implicit_wrapper<T>(obj));userdataref.push();luaL_getmetatable(L,&metakey[0]);if(type_of(L,-1)==type::lua_nil){lua_pop(L,1);std::stringerr="sol: unable to get usertype metatable for ";err+=usertype_traits<T>::name();returnluaL_error(L,err.c_str());}lua_setmetatable(L,-2);return1;}};staticintcall(lua_State*L,F&f){call_syntaxsyntax=stack::get_call_syntax(L,&usertype_traits<T>::user_metatable()[0],1);intsyntaxval=static_cast<int>(syntax);intargcount=lua_gettop(L)-syntaxval;returnconstruct_match<T,meta::pop_front_type_t<meta::function_args_t<Cxs>>...>(onmatch(),L,argcount,1+syntaxval,f);}};template<typenameT,typenameFx,boolis_index,boolis_variable,boolchecked,intboost>structlua_call_wrapper<T,destructor_wrapper<Fx>,is_index,is_variable,checked,boost,std::enable_if_t<std::is_void<Fx>::value>>{typedefdestructor_wrapper<Fx>F;staticintcall(lua_State*L,constF&){returndetail::usertype_alloc_destroy<T>(L);}};template<typenameT,typenameFx,boolis_index,boolis_variable,boolchecked,intboost>structlua_call_wrapper<T,destructor_wrapper<Fx>,is_index,is_variable,checked,boost,std::enable_if_t<!std::is_void<Fx>::value>>{typedefdestructor_wrapper<Fx>F;staticintcall(lua_State*L,constF&f){T&obj=stack::get<T>(L);f.fx(detail::implicit_wrapper<T>(obj));return0;}};template<typenameT,typename...Fs,boolis_index,boolis_variable,boolchecked,intboost,typenameC>structlua_call_wrapper<T,overload_set<Fs...>,is_index,is_variable,checked,boost,C>{typedefoverload_set<Fs...>F;structon_match{template<typenameFx,std::size_tI,typename...R,typename...Args>intoperator()(types<Fx>,index_value<I>,types<R...>,types<Args...>,lua_State*L,int,int,F&fx){auto&f=std::get<I>(fx.functions);returnlua_call_wrapper<T,Fx,is_index,is_variable,checked,boost>{}.call(L,f);}};staticintcall(lua_State*L,F&fx){returnoverload_match_arity<Fs...>(on_match(),L,lua_gettop(L),1,fx);}};template<typenameT,typename...Fs,boolis_index,boolis_variable,boolchecked,intboost,typenameC>structlua_call_wrapper<T,factory_wrapper<Fs...>,is_index,is_variable,checked,boost,C>{typedeffactory_wrapper<Fs...>F;structon_match{template<typenameFx,std::size_tI,typename...R,typename...Args>intoperator()(types<Fx>,index_value<I>,types<R...>,types<Args...>,lua_State*L,int,int,F&fx){auto&f=std::get<I>(fx.functions);returnlua_call_wrapper<T,Fx,is_index,is_variable,checked,boost>{}.call(L,f);}};staticintcall(lua_State*L,F&fx){returnoverload_match_arity<Fs...>(on_match(),L,lua_gettop(L)-boost,1+boost,fx);}};template<typenameT,typenameR,typenameW,boolis_index,boolis_variable,boolchecked,intboost,typenameC>structlua_call_wrapper<T,property_wrapper<R,W>,is_index,is_variable,checked,boost,C>{typedefstd::conditional_t<is_index,R,W>P;typedefmeta::unqualified_t<P>U;typedeflua_bind_traits<U>traits_type;template<typenameF>staticintself_call(lua_State*L,F&&f){typedefwrapper<U>wrap;typedefmeta::unqualified_t<typenametraits_type::templatearg_at<0>>object_type;typedefmeta::pop_front_type_t<typenametraits_type::free_args_list>args_list;typedefTTa;#ifdef SOL_SAFE_USERTYPEautomaybeo=stack::check_get<Ta*>(L,1);if(!maybeo||maybeo.value()==nullptr){if(is_variable){returnluaL_error(L,"sol: 'self' argument is lua_nil (bad '.' access?)");}returnluaL_error(L,"sol: 'self' argument is lua_nil (pass 'self' as first argument)");}object_type*o=static_cast<object_type*>(maybeo.value());#elseobject_type*o=static_cast<object_type*>(stack::get<non_null<Ta*>>(L,1));#endif // Safetytypedeftypenamewrap::returns_listreturns_list;typedeftypenamewrap::callercaller;returnstack::call_into_lua<checked>(returns_list(),args_list(),L,boost+(is_variable?3:2),caller(),f,*o);}template<typenameF,typename...Args>staticintdefer_call(std::false_type,lua_State*L,F&&f,Args&&...args){returnself_call(L,pick(meta::boolean<is_index>(),f),std::forward<Args>(args)...);}template<typenameF,typename...Args>staticintdefer_call(std::true_type,lua_State*L,F&&f,Args&&...args){auto&p=pick(meta::boolean<is_index>(),std::forward<F>(f));returnlua_call_wrapper<T,meta::unqualified_t<decltype(p)>,is_index,is_variable,checked,boost>{}.call(L,p,std::forward<Args>(args)...);}template<typenameF,typename...Args>staticintcall(lua_State*L,F&&f,Args&&...args){typedefmeta::any<std::is_void<U>,std::is_same<U,no_prop>,meta::is_specialization_of<var_wrapper,U>,meta::is_specialization_of<constructor_wrapper,U>,meta::is_specialization_of<constructor_list,U>,std::is_member_pointer<U>>is_specialized;returndefer_call(is_specialized(),L,std::forward<F>(f),std::forward<Args>(args)...);}};template<typenameT,typenameV,boolis_index,boolis_variable,boolchecked,intboost,typenameC>structlua_call_wrapper<T,protect_t<V>,is_index,is_variable,checked,boost,C>{typedefprotect_t<V>F;template<typename...Args>staticintcall(lua_State*L,F&fx,Args&&...args){returnlua_call_wrapper<T,V,is_index,is_variable,true,boost>{}.call(L,fx.value,std::forward<Args>(args)...);}};template<typenameT,typenameSig,typenameP,boolis_index,boolis_variable,boolchecked,intboost,typenameC>structlua_call_wrapper<T,function_arguments<Sig,P>,is_index,is_variable,checked,boost,C>{template<typenameF>staticintcall(lua_State*L,F&&f){returnlua_call_wrapper<T,meta::unqualified_t<P>,is_index,is_variable,stack::stack_detail::default_check_arguments,boost>{}.call(L,std::get<0>(f.arguments));}};template<typenameT,boolis_index,boolis_variable,intboost=0,typenameFx,typename...Args>inlineintcall_wrapped(lua_State*L,Fx&&fx,Args&&...args){returnlua_call_wrapper<T,meta::unqualified_t<Fx>,is_index,is_variable,stack::stack_detail::default_check_arguments,boost>{}.call(L,std::forward<Fx>(fx),std::forward<Args>(args)...);}template<typenameT,boolis_index,boolis_variable,typenameF>inlineintcall_user(lua_State*L){auto&fx=stack::get<user<F>>(L,upvalue_index(1));returncall_wrapped<T,is_index,is_variable>(L,fx);}template<typenameT,typename=void>structis_var_bind:std::false_type{};template<typenameT>structis_var_bind<T,std::enable_if_t<std::is_member_object_pointer<T>::value>>:std::true_type{};template<>structis_var_bind<no_prop>:std::true_type{};template<typenameR,typenameW>structis_var_bind<property_wrapper<R,W>>:std::true_type{};template<typenameT>structis_var_bind<var_wrapper<T>>:std::true_type{};}// call_detailtemplate<typenameT>structis_variable_binding:call_detail::is_var_bind<meta::unqualified_t<T>>{};template<typenameT>structis_function_binding:meta::neg<is_variable_binding<T>>{};}// sol// end of sol/call.hppnamespacesol{namespacefunction_detail{template<typenameF,Ffx>inlineintcall_wrapper_variable(std::false_type,lua_State*L){typedefmeta::bind_traits<meta::unqualified_t<F>>traits_type;typedeftypenametraits_type::args_listargs_list;typedefmeta::tuple_types<typenametraits_type::return_type>return_type;returnstack::call_into_lua(return_type(),args_list(),L,1,fx);}template<typenameR,typenameV,V,typenameT>inlineintcall_set_assignable(std::false_type,T&&,lua_State*L){returnluaL_error(L,"cannot write to this type: copy assignment/constructor not available");}template<typenameR,typenameV,Vvariable,typenameT>inlineintcall_set_assignable(std::true_type,lua_State*L,T&&mem){(mem.*variable)=stack::get<R>(L,2);return0;}template<typenameR,typenameV,V,typenameT>inlineintcall_set_variable(std::false_type,lua_State*L,T&&){returnluaL_error(L,"cannot write to a const variable");}template<typenameR,typenameV,Vvariable,typenameT>inlineintcall_set_variable(std::true_type,lua_State*L,T&&mem){returncall_set_assignable<R,V,variable>(std::is_assignable<std::add_lvalue_reference_t<R>,R>(),L,std::forward<T>(mem));}template<typenameV,Vvariable>inlineintcall_wrapper_variable(std::true_type,lua_State*L){typedefmeta::bind_traits<meta::unqualified_t<V>>traits_type;typedeftypenametraits_type::object_typeT;typedeftypenametraits_type::return_typeR;auto&mem=stack::get<T>(L,1);switch(lua_gettop(L)){case1:{decltype(auto)r=(mem.*variable);stack::push_reference(L,std::forward<decltype(r)>(r));return1;}case2:returncall_set_variable<R,V,variable>(meta::neg<std::is_const<R>>(),L,mem);default:returnluaL_error(L,"incorrect number of arguments to member variable function call");}}template<typenameF,Ffx>inlineintcall_wrapper_function(std::false_type,lua_State*L){returncall_wrapper_variable<F,fx>(std::is_member_object_pointer<F>(),L);}template<typenameF,Ffx>inlineintcall_wrapper_function(std::true_type,lua_State*L){returncall_detail::call_wrapped<void,false,false>(L,fx);}template<typenameF,Ffx>intcall_wrapper_entry(lua_State*L){returncall_wrapper_function<F,fx>(std::is_member_function_pointer<meta::unqualified_t<F>>(),L);}template<typename...Fxs>structc_call_matcher{template<typenameFx,std::size_tI,typenameR,typename...Args>intoperator()(types<Fx>,index_value<I>,types<R>,types<Args...>,lua_State*L,int,int)const{typedefmeta::at_in_pack_t<I,Fxs...>target;returntarget::call(L);}};}// function_detailtemplate<typenameF,Ffx>inlineintc_call(lua_State*L){#ifdef __clang__returndetail::trampoline(L,function_detail::call_wrapper_entry<F,fx>);#elsereturndetail::static_trampoline<(&function_detail::call_wrapper_entry<F,fx>)>(L);#endif // fuck you clang :c}template<typenameF,Ff>structwrap{typedefFtype;staticintcall(lua_State*L){returnc_call<type,f>(L);}};template<typename...Fxs>inlineintc_call(lua_State*L){if(sizeof...(Fxs)<2){returnmeta::at_in_pack_t<0,Fxs...>::call(L);}else{returncall_detail::overload_match_arity<typenameFxs::type...>(function_detail::c_call_matcher<Fxs...>(),L,lua_gettop(L),1);}}}// sol// end of sol/function_types_templated.hpp// beginning of sol/function_types_stateless.hppnamespacesol{namespacefunction_detail{template<typenameFunction>structupvalue_free_function{typedefstd::remove_pointer_t<std::decay_t<Function>>function_type;typedeflua_bind_traits<function_type>traits_type;staticintreal_call(lua_State*L){autoudata=stack::stack_detail::get_as_upvalues<function_type*>(L);function_type*fx=udata.first;returncall_detail::call_wrapped<void,true,false>(L,fx);}staticintcall(lua_State*L){returndetail::static_trampoline<(&real_call)>(L);}intoperator()(lua_State*L){returncall(L);}};template<typenameT,typenameFunction>structupvalue_member_function{typedefstd::remove_pointer_t<std::decay_t<Function>>function_type;typedeflua_bind_traits<function_type>traits_type;staticintreal_call(lua_State*L){// Layout:// idx 1...n: verbatim data of member function pointer// idx n + 1: is the object's void pointer// We don't need to store the size, because the other side is templated// with the same member function pointer typeautomemberdata=stack::stack_detail::get_as_upvalues<function_type>(L,1);autoobjdata=stack::stack_detail::get_as_upvalues<T*>(L,memberdata.second);function_type&memfx=memberdata.first;auto&item=*objdata.first;returncall_detail::call_wrapped<T,true,false,-1>(L,memfx,item);}staticintcall(lua_State*L){returndetail::static_trampoline<(&real_call)>(L);}intoperator()(lua_State*L){returncall(L);}};template<typenameT,typenameFunction>structupvalue_member_variable{typedefstd::remove_pointer_t<std::decay_t<Function>>function_type;typedeflua_bind_traits<function_type>traits_type;staticintreal_call(lua_State*L){// Layout:// idx 1...n: verbatim data of member variable pointer// idx n + 1: is the object's void pointer// We don't need to store the size, because the other side is templated// with the same member function pointer typeautomemberdata=stack::stack_detail::get_as_upvalues<function_type>(L,1);autoobjdata=stack::stack_detail::get_as_upvalues<T*>(L,memberdata.second);auto&mem=*objdata.first;function_type&var=memberdata.first;switch(lua_gettop(L)){case0:returncall_detail::call_wrapped<T,true,false,-1>(L,var,mem);case1:returncall_detail::call_wrapped<T,false,false,-1>(L,var,mem);default:returnluaL_error(L,"sol: incorrect number of arguments to member variable function");}}staticintcall(lua_State*L){returndetail::static_trampoline<(&real_call)>(L);}intoperator()(lua_State*L){returncall(L);}};template<typenameT,typenameFunction>structupvalue_this_member_function{typedefstd::remove_pointer_t<std::decay_t<Function>>function_type;typedeflua_bind_traits<function_type>traits_type;staticintreal_call(lua_State*L){// Layout:// idx 1...n: verbatim data of member variable pointerautomemberdata=stack::stack_detail::get_as_upvalues<function_type>(L,1);function_type&memfx=memberdata.first;returncall_detail::call_wrapped<T,false,false>(L,memfx);}staticintcall(lua_State*L){returndetail::static_trampoline<(&real_call)>(L);}intoperator()(lua_State*L){returncall(L);}};template<typenameT,typenameFunction>structupvalue_this_member_variable{typedefstd::remove_pointer_t<std::decay_t<Function>>function_type;typedeflua_bind_traits<function_type>traits_type;staticintreal_call(lua_State*L){// Layout:// idx 1...n: verbatim data of member variable pointerautomemberdata=stack::stack_detail::get_as_upvalues<function_type>(L,1);function_type&var=memberdata.first;switch(lua_gettop(L)){case1:returncall_detail::call_wrapped<T,true,false>(L,var);case2:returncall_detail::call_wrapped<T,false,false>(L,var);default:returnluaL_error(L,"sol: incorrect number of arguments to member variable function");}}staticintcall(lua_State*L){returndetail::static_trampoline<(&real_call)>(L);}intoperator()(lua_State*L){returncall(L);}};}// function_detail}// sol// end of sol/function_types_stateless.hpp// beginning of sol/function_types_stateful.hppnamespacesol{namespacefunction_detail{template<typenameFunc>structfunctor_function{typedefmeta::unwrapped_t<meta::unqualified_t<Func>>Function;Functionfx;template<typename...Args>functor_function(Functionf,Args&&...args):fx(std::move(f),std::forward<Args>(args)...){}intcall(lua_State*L){returncall_detail::call_wrapped<void,true,false>(L,fx);}intoperator()(lua_State*L){autof=[&](lua_State*)->int{returnthis->call(L);};returndetail::trampoline(L,f);}};template<typenameT,typenameFunction>structmember_function{typedefstd::remove_pointer_t<std::decay_t<Function>>function_type;typedefmeta::function_return_t<function_type>return_type;typedefmeta::function_args_t<function_type>args_lists;function_typeinvocation;Tmember;template<typename...Args>member_function(function_typef,Args&&...args):invocation(std::move(f)),member(std::forward<Args>(args)...){}intcall(lua_State*L){returncall_detail::call_wrapped<T,true,false,-1>(L,invocation,detail::unwrap(detail::deref(member)));}intoperator()(lua_State*L){autof=[&](lua_State*)->int{returnthis->call(L);};returndetail::trampoline(L,f);}};template<typenameT,typenameFunction>structmember_variable{typedefstd::remove_pointer_t<std::decay_t<Function>>function_type;typedeftypenamemeta::bind_traits<function_type>::return_typereturn_type;typedeftypenamemeta::bind_traits<function_type>::args_listargs_lists;function_typevar;Tmember;typedefstd::add_lvalue_reference_t<meta::unwrapped_t<std::remove_reference_t<decltype(detail::deref(member))>>>M;template<typename...Args>member_variable(function_typev,Args&&...args):var(std::move(v)),member(std::forward<Args>(args)...){}intcall(lua_State*L){Mmem=detail::unwrap(detail::deref(member));switch(lua_gettop(L)){case0:returncall_detail::call_wrapped<T,true,false,-1>(L,var,mem);case1:returncall_detail::call_wrapped<T,false,false,-1>(L,var,mem);default:returnluaL_error(L,"sol: incorrect number of arguments to member variable function");}}intoperator()(lua_State*L){autof=[&](lua_State*)->int{returnthis->call(L);};returndetail::trampoline(L,f);}};}// function_detail}// sol// end of sol/function_types_stateful.hpp// beginning of sol/function_types_overloaded.hppnamespacesol{namespacefunction_detail{template<typename...Functions>structoverloaded_function{typedefstd::tuple<Functions...>overload_list;typedefstd::make_index_sequence<sizeof...(Functions)>indices;overload_listoverloads;overloaded_function(overload_listset):overloads(std::move(set)){}overloaded_function(Functions...fxs):overloads(fxs...){}template<typenameFx,std::size_tI,typename...R,typename...Args>intcall(types<Fx>,index_value<I>,types<R...>,types<Args...>,lua_State*L,int,int){auto&func=std::get<I>(overloads);returncall_detail::call_wrapped<void,true,false>(L,func);}intoperator()(lua_State*L){automfx=[&](auto&&...args){returnthis->call(std::forward<decltype(args)>(args)...);};returncall_detail::overload_match<Functions...>(mfx,L,1);}};}// function_detail}// sol// end of sol/function_types_overloaded.hpp// beginning of sol/resolve.hppnamespacesol{#ifndef __clang__// constexpr is fine for not-clangnamespacedetail{template<typenameR,typename...Args,typenameF,typename=std::result_of_t<meta::unqualified_t<F>(Args...)>>inlineconstexprautoresolve_i(types<R(Args...)>,F&&)->R(meta::unqualified_t<F>::*)(Args...){usingSig=R(Args...);typedefmeta::unqualified_t<F>Fu;returnstatic_cast<SigFu::*>(&Fu::operator());}template<typenameF,typenameU=meta::unqualified_t<F>>inlineconstexprautoresolve_f(std::true_type,F&&f)->decltype(resolve_i(types<meta::function_signature_t<decltype(&U::operator())>>(),std::forward<F>(f))){returnresolve_i(types<meta::function_signature_t<decltype(&U::operator())>>(),std::forward<F>(f));}template<typenameF>inlineconstexprvoidresolve_f(std::false_type,F&&){static_assert(meta::has_deducible_signature<F>::value,"Cannot use no-template-parameter call with an overloaded functor: specify the signature");}template<typenameF,typenameU=meta::unqualified_t<F>>inlineconstexprautoresolve_i(types<>,F&&f)->decltype(resolve_f(meta::has_deducible_signature<U>(),std::forward<F>(f))){returnresolve_f(meta::has_deducible_signature<U>{},std::forward<F>(f));}template<typename...Args,typenameF,typenameR=std::result_of_t<F&(Args...)>>inlineconstexprautoresolve_i(types<Args...>,F&&f)->decltype(resolve_i(types<R(Args...)>(),std::forward<F>(f))){returnresolve_i(types<R(Args...)>(),std::forward<F>(f));}template<typenameSig,typenameC>inlineconstexprSigC::*resolve_v(std::false_type,SigC::*mem_func_ptr){returnmem_func_ptr;}template<typenameSig,typenameC>inlineconstexprSigC::*resolve_v(std::true_type,SigC::*mem_variable_ptr){returnmem_variable_ptr;}}// detailtemplate<typename...Args,typenameR>inlineconstexprautoresolve(Rfun_ptr(Args...))->R(*)(Args...){returnfun_ptr;}template<typenameSig>inlineconstexprSig*resolve(Sig*fun_ptr){returnfun_ptr;}template<typename...Args,typenameR,typenameC>inlineconstexprautoresolve(R(C::*mem_ptr)(Args...))->R(C::*)(Args...){returnmem_ptr;}template<typenameSig,typenameC>inlineconstexprSigC::*resolve(SigC::*mem_ptr){returndetail::resolve_v(std::is_member_object_pointer<SigC::*>(),mem_ptr);}template<typename...Sig,typenameF,meta::disable<std::is_function<meta::unqualified_t<F>>>=meta::enabler>inlineconstexprautoresolve(F&&f)->decltype(detail::resolve_i(types<Sig...>(),std::forward<F>(f))){returndetail::resolve_i(types<Sig...>(),std::forward<F>(f));}#else// Clang has distinct problems with constexpr arguments,// so don't use the constexpr versions inside of clang.namespacedetail{template<typenameR,typename...Args,typenameF,typename=std::result_of_t<meta::unqualified_t<F>(Args...)>>inlineautoresolve_i(types<R(Args...)>,F&&)->R(meta::unqualified_t<F>::*)(Args...){usingSig=R(Args...);typedefmeta::unqualified_t<F>Fu;returnstatic_cast<SigFu::*>(&Fu::operator());}template<typenameF,typenameU=meta::unqualified_t<F>>inlineautoresolve_f(std::true_type,F&&f)->decltype(resolve_i(types<meta::function_signature_t<decltype(&U::operator())>>(),std::forward<F>(f))){returnresolve_i(types<meta::function_signature_t<decltype(&U::operator())>>(),std::forward<F>(f));}template<typenameF>inlinevoidresolve_f(std::false_type,F&&){static_assert(meta::has_deducible_signature<F>::value,"Cannot use no-template-parameter call with an overloaded functor: specify the signature");}template<typenameF,typenameU=meta::unqualified_t<F>>inlineautoresolve_i(types<>,F&&f)->decltype(resolve_f(meta::has_deducible_signature<U>(),std::forward<F>(f))){returnresolve_f(meta::has_deducible_signature<U>{},std::forward<F>(f));}template<typename...Args,typenameF,typenameR=std::result_of_t<F&(Args...)>>inlineautoresolve_i(types<Args...>,F&&f)->decltype(resolve_i(types<R(Args...)>(),std::forward<F>(f))){returnresolve_i(types<R(Args...)>(),std::forward<F>(f));}template<typenameSig,typenameC>inlineSigC::*resolve_v(std::false_type,SigC::*mem_func_ptr){returnmem_func_ptr;}template<typenameSig,typenameC>inlineSigC::*resolve_v(std::true_type,SigC::*mem_variable_ptr){returnmem_variable_ptr;}}// detailtemplate<typename...Args,typenameR>inlineautoresolve(Rfun_ptr(Args...))->R(*)(Args...){returnfun_ptr;}template<typenameSig>inlineSig*resolve(Sig*fun_ptr){returnfun_ptr;}template<typename...Args,typenameR,typenameC>inlineautoresolve(R(C::*mem_ptr)(Args...))->R(C::*)(Args...){returnmem_ptr;}template<typenameSig,typenameC>inlineSigC::*resolve(SigC::*mem_ptr){returndetail::resolve_v(std::is_member_object_pointer<SigC::*>(),mem_ptr);}template<typename...Sig,typenameF>inlineautoresolve(F&&f)->decltype(detail::resolve_i(types<Sig...>(),std::forward<F>(f))){returndetail::resolve_i(types<Sig...>(),std::forward<F>(f));}#endif}// sol// end of sol/resolve.hppnamespacesol{namespacestack{template<typename...Sigs>structpusher<function_sig<Sigs...>>{template<typename...Sig,typenameFx,typename...Args>staticvoidselect_convertible(std::false_type,types<Sig...>,lua_State*L,Fx&&fx,Args&&...args){typedefstd::remove_pointer_t<std::decay_t<Fx>>clean_fx;typedeffunction_detail::functor_function<clean_fx>F;set_fx<F>(L,std::forward<Fx>(fx),std::forward<Args>(args)...);}template<typenameR,typename...A,typenameFx,typename...Args>staticvoidselect_convertible(std::true_type,types<R(A...)>,lua_State*L,Fx&&fx,Args&&...args){usingfx_ptr_t=R(*)(A...);fx_ptr_tfxptr=detail::unwrap(std::forward<Fx>(fx));select_function(std::true_type(),L,fxptr,std::forward<Args>(args)...);}template<typenameR,typename...A,typenameFx,typename...Args>staticvoidselect_convertible(types<R(A...)>t,lua_State*L,Fx&&fx,Args&&...args){typedefstd::decay_t<meta::unwrap_unqualified_t<Fx>>raw_fx_t;typedefR(*fx_ptr_t)(A...);typedefstd::is_convertible<raw_fx_t,fx_ptr_t>is_convertible;select_convertible(is_convertible(),t,L,std::forward<Fx>(fx),std::forward<Args>(args)...);}template<typenameFx,typename...Args>staticvoidselect_convertible(types<>,lua_State*L,Fx&&fx,Args&&...args){typedefmeta::function_signature_t<meta::unwrap_unqualified_t<Fx>>Sig;select_convertible(types<Sig>(),L,std::forward<Fx>(fx),std::forward<Args>(args)...);}template<typenameFx,typenameT,typename...Args>staticvoidselect_reference_member_variable(std::false_type,lua_State*L,Fx&&fx,T&&obj,Args&&...args){typedefstd::remove_pointer_t<std::decay_t<Fx>>clean_fx;typedeffunction_detail::member_variable<meta::unwrap_unqualified_t<T>,clean_fx>F;set_fx<F>(L,std::forward<Fx>(fx),std::forward<T>(obj),std::forward<Args>(args)...);}template<typenameFx,typenameT,typename...Args>staticvoidselect_reference_member_variable(std::true_type,lua_State*L,Fx&&fx,T&&obj,Args&&...args){typedefstd::decay_t<Fx>dFx;dFxmemfxptr(std::forward<Fx>(fx));autouserptr=detail::ptr(std::forward<T>(obj),std::forward<Args>(args)...);lua_CFunctionfreefunc=&function_detail::upvalue_member_variable<std::decay_t<decltype(*userptr)>,meta::unqualified_t<Fx>>::call;intupvalues=stack::stack_detail::push_as_upvalues(L,memfxptr);upvalues+=stack::push(L,lightuserdata_value(static_cast<void*>(userptr)));stack::push(L,c_closure(freefunc,upvalues));}template<typenameFx,typename...Args>staticvoidselect_member_variable(std::false_type,lua_State*L,Fx&&fx,Args&&...args){select_convertible(types<Sigs...>(),L,std::forward<Fx>(fx),std::forward<Args>(args)...);}template<typenameFx,typenameT,typename...Args>staticvoidselect_member_variable(std::true_type,lua_State*L,Fx&&fx,T&&obj,Args&&...args){typedefmeta::boolean<meta::is_specialization_of<std::reference_wrapper,meta::unqualified_t<T>>::value||std::is_pointer<T>::value>is_reference;select_reference_member_variable(is_reference(),L,std::forward<Fx>(fx),std::forward<T>(obj),std::forward<Args>(args)...);}template<typenameFx>staticvoidselect_member_variable(std::true_type,lua_State*L,Fx&&fx){typedeftypenamemeta::bind_traits<meta::unqualified_t<Fx>>::object_typeC;lua_CFunctionfreefunc=&function_detail::upvalue_this_member_variable<C,Fx>::call;intupvalues=stack::stack_detail::push_as_upvalues(L,fx);stack::push(L,c_closure(freefunc,upvalues));}template<typenameFx,typenameT,typename...Args>staticvoidselect_reference_member_function(std::false_type,lua_State*L,Fx&&fx,T&&obj,Args&&...args){typedefstd::decay_t<Fx>clean_fx;typedeffunction_detail::member_function<meta::unwrap_unqualified_t<T>,clean_fx>F;set_fx<F>(L,std::forward<Fx>(fx),std::forward<T>(obj),std::forward<Args>(args)...);}template<typenameFx,typenameT,typename...Args>staticvoidselect_reference_member_function(std::true_type,lua_State*L,Fx&&fx,T&&obj,Args&&...args){typedefstd::decay_t<Fx>dFx;dFxmemfxptr(std::forward<Fx>(fx));autouserptr=detail::ptr(std::forward<T>(obj),std::forward<Args>(args)...);lua_CFunctionfreefunc=&function_detail::upvalue_member_function<std::decay_t<decltype(*userptr)>,meta::unqualified_t<Fx>>::call;intupvalues=stack::stack_detail::push_as_upvalues(L,memfxptr);upvalues+=stack::push(L,lightuserdata_value(static_cast<void*>(userptr)));stack::push(L,c_closure(freefunc,upvalues));}template<typenameFx,typename...Args>staticvoidselect_member_function(std::false_type,lua_State*L,Fx&&fx,Args&&...args){select_member_variable(std::is_member_object_pointer<meta::unqualified_t<Fx>>(),L,std::forward<Fx>(fx),std::forward<Args>(args)...);}template<typenameFx,typenameT,typename...Args>staticvoidselect_member_function(std::true_type,lua_State*L,Fx&&fx,T&&obj,Args&&...args){typedefmeta::boolean<meta::is_specialization_of<std::reference_wrapper,meta::unqualified_t<T>>::value||std::is_pointer<T>::value>is_reference;select_reference_member_function(is_reference(),L,std::forward<Fx>(fx),std::forward<T>(obj),std::forward<Args>(args)...);}template<typenameFx>staticvoidselect_member_function(std::true_type,lua_State*L,Fx&&fx){typedeftypenamemeta::bind_traits<meta::unqualified_t<Fx>>::object_typeC;lua_CFunctionfreefunc=&function_detail::upvalue_this_member_function<C,Fx>::call;intupvalues=stack::stack_detail::push_as_upvalues(L,fx);stack::push(L,c_closure(freefunc,upvalues));}template<typenameFx,typename...Args>staticvoidselect_function(std::false_type,lua_State*L,Fx&&fx,Args&&...args){select_member_function(std::is_member_function_pointer<meta::unqualified_t<Fx>>(),L,std::forward<Fx>(fx),std::forward<Args>(args)...);}template<typenameFx,typename...Args>staticvoidselect_function(std::true_type,lua_State*L,Fx&&fx,Args&&...args){std::decay_t<Fx>target(std::forward<Fx>(fx),std::forward<Args>(args)...);lua_CFunctionfreefunc=&function_detail::upvalue_free_function<Fx>::call;intupvalues=stack::stack_detail::push_as_upvalues(L,target);stack::push(L,c_closure(freefunc,upvalues));}staticvoidselect_function(std::true_type,lua_State*L,lua_CFunctionf){stack::push(L,f);}template<typenameFx,typename...Args>staticvoidselect(lua_State*L,Fx&&fx,Args&&...args){select_function(std::is_function<meta::unqualified_t<Fx>>(),L,std::forward<Fx>(fx),std::forward<Args>(args)...);}template<typenameFx,typename...Args>staticvoidset_fx(lua_State*L,Args&&...args){lua_CFunctionfreefunc=function_detail::call<meta::unqualified_t<Fx>>;stack::push<user<Fx>>(L,std::forward<Args>(args)...);stack::push(L,c_closure(freefunc,1));}template<typename...Args>staticintpush(lua_State*L,Args&&...args){// Set will always place one thing (function) on the stackselect(L,std::forward<Args>(args)...);return1;}};template<typenameT,typename...Args>structpusher<function_arguments<T,Args...>>{template<std::size_t...I,typenameFP>staticintpush_func(std::index_sequence<I...>,lua_State*L,FP&&fp){returnstack::push<T>(L,detail::forward_get<I>(fp.arguments)...);}staticintpush(lua_State*L,constfunction_arguments<T,Args...>&fp){returnpush_func(std::make_index_sequence<sizeof...(Args)>(),L,fp);}staticintpush(lua_State*L,function_arguments<T,Args...>&&fp){returnpush_func(std::make_index_sequence<sizeof...(Args)>(),L,std::move(fp));}};template<typenameSignature>structpusher<std::function<Signature>>{staticintpush(lua_State*L,std::function<Signature>fx){returnpusher<function_sig<Signature>>{}.push(L,std::move(fx));}};template<typenameSignature>structpusher<Signature,std::enable_if_t<std::is_member_pointer<Signature>::value>>{template<typenameF>staticintpush(lua_State*L,F&&f){returnpusher<function_sig<>>{}.push(L,std::forward<F>(f));}};template<typenameSignature>structpusher<Signature,std::enable_if_t<meta::all<std::is_function<Signature>,meta::neg<std::is_same<Signature,lua_CFunction>>,meta::neg<std::is_same<Signature,std::remove_pointer_t<lua_CFunction>>>>::value>>{template<typenameF>staticintpush(lua_State*L,F&&f){returnpusher<function_sig<>>{}.push(L,std::forward<F>(f));}};template<typename...Functions>structpusher<overload_set<Functions...>>{staticintpush(lua_State*L,overload_set<Functions...>&&set){typedeffunction_detail::overloaded_function<Functions...>F;pusher<function_sig<>>{}.set_fx<F>(L,std::move(set.functions));return1;}staticintpush(lua_State*L,constoverload_set<Functions...>&set){typedeffunction_detail::overloaded_function<Functions...>F;pusher<function_sig<>>{}.set_fx<F>(L,set.functions);return1;}};template<typenameT>structpusher<protect_t<T>>{staticintpush(lua_State*L,protect_t<T>&&pw){lua_CFunctioncf=call_detail::call_user<void,false,false,protect_t<T>>;intclosures=stack::push<user<protect_t<T>>>(L,std::move(pw.value));returnstack::push(L,c_closure(cf,closures));}staticintpush(lua_State*L,constprotect_t<T>&pw){lua_CFunctioncf=call_detail::call_user<void,false,false,protect_t<T>>;intclosures=stack::push<user<protect_t<T>>>(L,pw.value);returnstack::push(L,c_closure(cf,closures));}};template<typenameF,typenameG>structpusher<property_wrapper<F,G>,std::enable_if_t<!std::is_void<F>::value&&!std::is_void<G>::value>>{staticintpush(lua_State*L,property_wrapper<F,G>&&pw){returnstack::push(L,sol::overload(std::move(pw.read),std::move(pw.write)));}staticintpush(lua_State*L,constproperty_wrapper<F,G>&pw){returnstack::push(L,sol::overload(pw.read,pw.write));}};template<typenameF>structpusher<property_wrapper<F,void>>{staticintpush(lua_State*L,property_wrapper<F,void>&&pw){returnstack::push(L,std::move(pw.read));}staticintpush(lua_State*L,constproperty_wrapper<F,void>&pw){returnstack::push(L,pw.read);}};template<typenameF>structpusher<property_wrapper<void,F>>{staticintpush(lua_State*L,property_wrapper<void,F>&&pw){returnstack::push(L,std::move(pw.write));}staticintpush(lua_State*L,constproperty_wrapper<void,F>&pw){returnstack::push(L,pw.write);}};template<typenameT>structpusher<var_wrapper<T>>{staticintpush(lua_State*L,var_wrapper<T>&&vw){returnstack::push(L,std::move(vw.value));}staticintpush(lua_State*L,constvar_wrapper<T>&vw){returnstack::push(L,vw.value);}};template<typename...Functions>structpusher<factory_wrapper<Functions...>>{staticintpush(lua_State*L,constfactory_wrapper<Functions...>&fw){typedeffunction_detail::overloaded_function<Functions...>F;pusher<function_sig<>>{}.set_fx<F>(L,fw.functions);return1;}staticintpush(lua_State*L,factory_wrapper<Functions...>&&fw){typedeffunction_detail::overloaded_function<Functions...>F;pusher<function_sig<>>{}.set_fx<F>(L,std::move(fw.functions));return1;}};template<typenameT,typename...Lists>structpusher<detail::tagged<T,constructor_list<Lists...>>>{staticintpush(lua_State*L,detail::tagged<T,constructor_list<Lists...>>){lua_CFunctioncf=call_detail::construct<T,Lists...>;returnstack::push(L,cf);}};template<typenameT,typename...Fxs>structpusher<detail::tagged<T,constructor_wrapper<Fxs...>>>{template<typenameC>staticintpush(lua_State*L,C&&c){lua_CFunctioncf=call_detail::call_user<T,false,false,constructor_wrapper<Fxs...>>;intclosures=stack::push<user<constructor_wrapper<Fxs...>>>(L,std::forward<C>(c));returnstack::push(L,c_closure(cf,closures));}};template<typenameT>structpusher<detail::tagged<T,destructor_wrapper<void>>>{staticintpush(lua_State*L,destructor_wrapper<void>){lua_CFunctioncf=detail::usertype_alloc_destroy<T>;returnstack::push(L,cf);}};template<typenameT,typenameFx>structpusher<detail::tagged<T,destructor_wrapper<Fx>>>{staticintpush(lua_State*L,destructor_wrapper<Fx>c){lua_CFunctioncf=call_detail::call_user<T,false,false,destructor_wrapper<Fx>>;intclosures=stack::push<user<T>>(L,std::move(c));returnstack::push(L,c_closure(cf,closures));}};}// stack}// sol// end of sol/function_types.hppnamespacesol{template<typenamebase_t>classbasic_function:publicbase_t{private:voidluacall(std::ptrdiff_targcount,std::ptrdiff_tresultcount)const{lua_callk(base_t::lua_state(),static_cast<int>(argcount),static_cast<int>(resultcount),0,nullptr);}template<std::size_t...I,typename...Ret>autoinvoke(types<Ret...>,std::index_sequence<I...>,std::ptrdiff_tn)const{luacall(n,lua_size<std::tuple<Ret...>>::value);returnstack::pop<std::tuple<Ret...>>(base_t::lua_state());}template<std::size_tI,typenameRet>Retinvoke(types<Ret>,std::index_sequence<I>,std::ptrdiff_tn)const{luacall(n,lua_size<Ret>::value);returnstack::pop<Ret>(base_t::lua_state());}template<std::size_tI>voidinvoke(types<void>,std::index_sequence<I>,std::ptrdiff_tn)const{luacall(n,0);}function_resultinvoke(types<>,std::index_sequence<>,std::ptrdiff_tn)const{intstacksize=lua_gettop(base_t::lua_state());intfirstreturn=(std::max)(1,stacksize-static_cast<int>(n));luacall(n,LUA_MULTRET);intpoststacksize=lua_gettop(base_t::lua_state());intreturncount=poststacksize-(firstreturn-1);returnfunction_result(base_t::lua_state(),firstreturn,returncount);}public:basic_function()=default;template<typenameT,meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>,basic_function>>,meta::neg<std::is_same<base_t,stack_reference>>,std::is_base_of<base_t,meta::unqualified_t<T>>>=meta::enabler>basic_function(T&&r)noexcept:base_t(std::forward<T>(r)){#ifdef SOL_CHECK_ARGUMENTSif(!is_function<meta::unqualified_t<T>>::value){autopp=stack::push_pop(*this);stack::check<basic_function>(base_t::lua_state(),-1,type_panic);}#endif // Safety}basic_function(constbasic_function&)=default;basic_function&operator=(constbasic_function&)=default;basic_function(basic_function&&)=default;basic_function&operator=(basic_function&&)=default;basic_function(conststack_reference&r):basic_function(r.lua_state(),r.stack_index()){}basic_function(stack_reference&&r):basic_function(r.lua_state(),r.stack_index()){}template<typenameT,meta::enable<meta::neg<std::is_integral<meta::unqualified_t<T>>>,meta::neg<std::is_same<T,ref_index>>>=meta::enabler>basic_function(lua_State*L,T&&r):basic_function(L,sol::ref_index(r.registry_index())){}basic_function(lua_State*L,intindex=-1):base_t(L,index){#ifdef SOL_CHECK_ARGUMENTSstack::check<basic_function>(L,index,type_panic);#endif // Safety}basic_function(lua_State*L,ref_indexindex):base_t(L,index){#ifdef SOL_CHECK_ARGUMENTSautopp=stack::push_pop(*this);stack::check<basic_function>(L,-1,type_panic);#endif // Safety}template<typename...Args>function_resultoperator()(Args&&...args)const{returncall<>(std::forward<Args>(args)...);}template<typename...Ret,typename...Args>decltype(auto)operator()(types<Ret...>,Args&&...args)const{returncall<Ret...>(std::forward<Args>(args)...);}template<typename...Ret,typename...Args>decltype(auto)call(Args&&...args)const{base_t::push();intpushcount=stack::multi_push_reference(base_t::lua_state(),std::forward<Args>(args)...);returninvoke(types<Ret...>(),std::make_index_sequence<sizeof...(Ret)>(),pushcount);}};namespacestack{template<typenameSignature>structgetter<std::function<Signature>>{typedefmeta::bind_traits<Signature>fx_t;typedeftypenamefx_t::args_listargs_lists;typedefmeta::tuple_types<typenamefx_t::return_type>return_types;template<typename...Args,typename...Ret>staticstd::function<Signature>get_std_func(types<Ret...>,types<Args...>,lua_State*L,intindex){sol::functionf(L,index);autofx=[f,L,index](Args&&...args)->meta::return_type_t<Ret...>{returnf.call<Ret...>(std::forward<Args>(args)...);};returnstd::move(fx);}template<typename...FxArgs>staticstd::function<Signature>get_std_func(types<void>,types<FxArgs...>,lua_State*L,intindex){sol::functionf(L,index);autofx=[f,L,index](FxArgs&&...args)->void{f(std::forward<FxArgs>(args)...);};returnstd::move(fx);}template<typename...FxArgs>staticstd::function<Signature>get_std_func(types<>,types<FxArgs...>t,lua_State*L,intindex){returnget_std_func(types<void>(),t,L,index);}staticstd::function<Signature>get(lua_State*L,intindex,record&tracking){tracking.last=1;tracking.used+=1;typet=type_of(L,index);if(t==type::none||t==type::lua_nil){returnnullptr;}returnget_std_func(return_types(),args_lists(),L,index);}};}// stack}// sol// end of sol/function.hpp// beginning of sol/protected_function.hpp// beginning of sol/protected_function_result.hppnamespacesol{structprotected_function_result:publicproxy_base<protected_function_result>{private:lua_State*L;intindex;intreturncount;intpopcount;call_statuserr;template<typenameT>decltype(auto)tagged_get(types<sol::optional<T>>)const{if(!valid()){returnsol::optional<T>(nullopt);}returnstack::get<sol::optional<T>>(L,index);}template<typenameT>decltype(auto)tagged_get(types<T>)const{#ifdef SOL_CHECK_ARGUMENTSif(!valid()){type_panic(L,index,type_of(L,index),type::none);}#endif // Check Argument Safetyreturnstack::get<T>(L,index);}optional<error>tagged_get(types<optional<error>>)const{if(valid()){returnnullopt;}returnerror(detail::direct_error,stack::get<std::string>(L,index));}errortagged_get(types<error>)const{#ifdef SOL_CHECK_ARGUMENTSif(valid()){type_panic(L,index,type_of(L,index),type::none);}#endif // Check Argument Safetyreturnerror(detail::direct_error,stack::get<std::string>(L,index));}public:protected_function_result()=default;protected_function_result(lua_State*Ls,intidx=-1,intretnum=0,intpopped=0,call_statuspferr=call_status::ok)noexcept:L(Ls),index(idx),returncount(retnum),popcount(popped),err(pferr){}protected_function_result(constprotected_function_result&)=default;protected_function_result&operator=(constprotected_function_result&)=default;protected_function_result(protected_function_result&&o)noexcept:L(o.L),index(o.index),returncount(o.returncount),popcount(o.popcount),err(o.err){// Must be manual, otherwise destructor will screw us// return count being 0 is enough to keep things clean// but we will be thorougho.L=nullptr;o.index=0;o.returncount=0;o.popcount=0;o.err=call_status::runtime;}protected_function_result&operator=(protected_function_result&&o)noexcept{L=o.L;index=o.index;returncount=o.returncount;popcount=o.popcount;err=o.err;// Must be manual, otherwise destructor will screw us// return count being 0 is enough to keep things clean// but we will be thorougho.L=nullptr;o.index=0;o.returncount=0;o.popcount=0;o.err=call_status::runtime;return*this;}call_statusstatus()constnoexcept{returnerr;}boolvalid()constnoexcept{returnstatus()==call_status::ok||status()==call_status::yielded;}template<typenameT>decltype(auto)get()const{returntagged_get(types<meta::unqualified_t<T>>());}lua_State*lua_state()constnoexcept{returnL;};intstack_index()constnoexcept{returnindex;};~protected_function_result(){stack::remove(L,index,popcount);}};}// sol// end of sol/protected_function_result.hpp#include<algorithm>namespacesol{namespacedetail{inlinereference&handler_storage(){staticsol::referenceh;returnh;}structhandler{constreference⌖intstackindex;handler(constreference&target):target(target),stackindex(0){if(target.valid()){stackindex=lua_gettop(target.lua_state())+1;target.push();}}boolvalid()const{returnstackindex!=0;}~handler(){if(valid()){lua_remove(target.lua_state(),stackindex);}}};}template<typenamebase_t>classbasic_protected_function:publicbase_t{public:staticreference&get_default_handler(){returndetail::handler_storage();}staticvoidset_default_handler(constreference&ref){detail::handler_storage()=ref;}staticvoidset_default_handler(reference&&ref){detail::handler_storage()=std::move(ref);}private:call_statusluacall(std::ptrdiff_targcount,std::ptrdiff_tresultcount,detail::handler&h)const{returnstatic_cast<call_status>(lua_pcallk(base_t::lua_state(),static_cast<int>(argcount),static_cast<int>(resultcount),h.stackindex,0,nullptr));}template<std::size_t...I,typename...Ret>autoinvoke(types<Ret...>,std::index_sequence<I...>,std::ptrdiff_tn,detail::handler&h)const{luacall(n,sizeof...(Ret),h);returnstack::pop<std::tuple<Ret...>>(base_t::lua_state());}template<std::size_tI,typenameRet>Retinvoke(types<Ret>,std::index_sequence<I>,std::ptrdiff_tn,detail::handler&h)const{luacall(n,1,h);returnstack::pop<Ret>(base_t::lua_state());}template<std::size_tI>voidinvoke(types<void>,std::index_sequence<I>,std::ptrdiff_tn,detail::handler&h)const{luacall(n,0,h);}protected_function_resultinvoke(types<>,std::index_sequence<>,std::ptrdiff_tn,detail::handler&h)const{intstacksize=lua_gettop(base_t::lua_state());intpoststacksize=stacksize;intfirstreturn=1;intreturncount=0;call_statuscode=call_status::ok;#ifndef SOL_NO_EXCEPTIONSautoonexcept=[&](constchar*error){h.stackindex=0;if(h.target.valid()){h.target.push();stack::push(base_t::lua_state(),error);lua_call(base_t::lua_state(),1,1);}else{stack::push(base_t::lua_state(),error);}};try{#endif // No Exceptionsfirstreturn=(std::max)(1,static_cast<int>(stacksize-n-static_cast<int>(h.valid())));code=luacall(n,LUA_MULTRET,h);poststacksize=lua_gettop(base_t::lua_state())-static_cast<int>(h.valid());returncount=poststacksize-(firstreturn-1);#ifndef SOL_NO_EXCEPTIONS}// Handle C++ errors thrown from C++ functions bound inside of luacatch(constchar*error){onexcept(error);firstreturn=lua_gettop(base_t::lua_state());returnprotected_function_result(base_t::lua_state(),firstreturn,0,1,call_status::runtime);}catch(conststd::exception&error){onexcept(error.what());firstreturn=lua_gettop(base_t::lua_state());returnprotected_function_result(base_t::lua_state(),firstreturn,0,1,call_status::runtime);}catch(...){onexcept("caught (...) unknown error during protected_function call");firstreturn=lua_gettop(base_t::lua_state());returnprotected_function_result(base_t::lua_state(),firstreturn,0,1,call_status::runtime);}#endif // No Exceptionsreturnprotected_function_result(base_t::lua_state(),firstreturn,returncount,returncount,code);}public:referenceerror_handler;basic_protected_function()=default;template<typenameT,meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>,basic_protected_function>>,meta::neg<std::is_same<base_t,stack_reference>>,std::is_base_of<base_t,meta::unqualified_t<T>>>=meta::enabler>basic_protected_function(T&&r)noexcept:base_t(std::forward<T>(r)){#ifdef SOL_CHECK_ARGUMENTSif(!is_function<meta::unqualified_t<T>>::value){autopp=stack::push_pop(*this);stack::check<basic_protected_function>(base_t::lua_state(),-1,type_panic);}#endif // Safety}basic_protected_function(constbasic_protected_function&)=default;basic_protected_function&operator=(constbasic_protected_function&)=default;basic_protected_function(basic_protected_function&&)=default;basic_protected_function&operator=(basic_protected_function&&)=default;basic_protected_function(constbasic_function<base_t>&b,referenceeh=get_default_handler()):base_t(b),error_handler(std::move(eh)){}basic_protected_function(basic_function<base_t>&&b,referenceeh=get_default_handler()):base_t(std::move(b)),error_handler(std::move(eh)){}basic_protected_function(conststack_reference&r,referenceeh=get_default_handler()):basic_protected_function(r.lua_state(),r.stack_index(),std::move(eh)){}basic_protected_function(stack_reference&&r,referenceeh=get_default_handler()):basic_protected_function(r.lua_state(),r.stack_index(),std::move(eh)){}template<typenameSuper>basic_protected_function(proxy_base<Super>&&p,referenceeh=get_default_handler()):basic_protected_function(p.operatorbasic_function<base_t>(),std::move(eh)){}template<typenameSuper>basic_protected_function(constproxy_base<Super>&p,referenceeh=get_default_handler()):basic_protected_function(static_cast<basic_function<base_t>>(p),std::move(eh)){}template<typenameT,meta::enable<meta::neg<std::is_integral<meta::unqualified_t<T>>>,meta::neg<std::is_same<T,ref_index>>>=meta::enabler>basic_protected_function(lua_State*L,T&&r,referenceeh):basic_protected_function(L,sol::ref_index(r.registry_index()),std::move(eh)){}basic_protected_function(lua_State*L,intindex=-1,referenceeh=get_default_handler()):base_t(L,index),error_handler(std::move(eh)){#ifdef SOL_CHECK_ARGUMENTSstack::check<basic_protected_function>(L,index,type_panic);#endif // Safety}basic_protected_function(lua_State*L,ref_indexindex,referenceeh=get_default_handler()):base_t(L,index),error_handler(std::move(eh)){#ifdef SOL_CHECK_ARGUMENTSautopp=stack::push_pop(*this);stack::check<basic_protected_function>(L,-1,type_panic);#endif // Safety}template<typename...Args>protected_function_resultoperator()(Args&&...args)const{returncall<>(std::forward<Args>(args)...);}template<typename...Ret,typename...Args>decltype(auto)operator()(types<Ret...>,Args&&...args)const{returncall<Ret...>(std::forward<Args>(args)...);}template<typename...Ret,typename...Args>decltype(auto)call(Args&&...args)const{detail::handlerh(error_handler);base_t::push();intpushcount=stack::multi_push_reference(base_t::lua_state(),std::forward<Args>(args)...);returninvoke(types<Ret...>(),std::make_index_sequence<sizeof...(Ret)>(),pushcount,h);}};}// sol// end of sol/protected_function.hppnamespacesol{structstack_proxy:publicproxy_base<stack_proxy>{private:lua_State*L;intindex;public:stack_proxy():L(nullptr),index(0){}stack_proxy(lua_State*L,intindex):L(L),index(index){}template<typenameT>decltype(auto)get()const{returnstack::get<T>(L,stack_index());}intpush()const{returnpush(L);}intpush(lua_State*Ls)const{lua_pushvalue(Ls,index);return1;}lua_State*lua_state()const{returnL;}intstack_index()const{returnindex;}template<typename...Ret,typename...Args>decltype(auto)call(Args&&...args){returnget<function>().templatecall<Ret...>(std::forward<Args>(args)...);}template<typename...Args>decltype(auto)operator()(Args&&...args){returncall<>(std::forward<Args>(args)...);}};namespacestack{template<>structgetter<stack_proxy>{staticstack_proxyget(lua_State*L,intindex=-1){returnstack_proxy(L,index);}};template<>structpusher<stack_proxy>{staticintpush(lua_State*,conststack_proxy&ref){returnref.push();}};}// stacknamespacedetail{template<>structis_speshul<function_result>:std::true_type{};template<>structis_speshul<protected_function_result>:std::true_type{};template<std::size_tI,typename...Args,typenameT>stack_proxyget(types<Args...>,index_value<0>,index_value<I>,constT&fr){returnstack_proxy(fr.lua_state(),static_cast<int>(fr.stack_index()+I));}template<std::size_tI,std::size_tN,typenameArg,typename...Args,typenameT,meta::enable<meta::boolean<(N>0)>>=meta::enabler>stack_proxyget(types<Arg,Args...>,index_value<N>,index_value<I>,constT&fr){returnget(types<Args...>(),index_value<N-1>(),index_value<I+lua_size<Arg>::value>(),fr);}}template<>structtie_size<function_result>:std::integral_constant<std::size_t,SIZE_MAX>{};template<std::size_tI>stack_proxyget(constfunction_result&fr){returnstack_proxy(fr.lua_state(),static_cast<int>(fr.stack_index()+I));}template<std::size_tI,typename...Args>stack_proxyget(types<Args...>t,constfunction_result&fr){returndetail::get(t,index_value<I>(),index_value<0>(),fr);}template<>structtie_size<protected_function_result>:std::integral_constant<std::size_t,SIZE_MAX>{};template<std::size_tI>stack_proxyget(constprotected_function_result&fr){returnstack_proxy(fr.lua_state(),static_cast<int>(fr.stack_index()+I));}template<std::size_tI,typename...Args>stack_proxyget(types<Args...>t,constprotected_function_result&fr){returndetail::get(t,index_value<I>(),index_value<0>(),fr);}}// sol// end of sol/stack_proxy.hpp#include<limits>#include<iterator>namespacesol{template<boolis_const>structva_iterator:std::iterator<std::random_access_iterator_tag,std::conditional_t<is_const,conststack_proxy,stack_proxy>,std::ptrdiff_t,std::conditional_t<is_const,conststack_proxy*,stack_proxy*>,std::conditional_t<is_const,conststack_proxy,stack_proxy>>{typedefstd::iterator<std::random_access_iterator_tag,std::conditional_t<is_const,conststack_proxy,stack_proxy>,std::ptrdiff_t,std::conditional_t<is_const,conststack_proxy*,stack_proxy*>,std::conditional_t<is_const,conststack_proxy,stack_proxy>>base_t;typedeftypenamebase_t::referencereference;typedeftypenamebase_t::pointerpointer;typedeftypenamebase_t::value_typevalue_type;typedeftypenamebase_t::difference_typedifference_type;typedeftypenamebase_t::iterator_categoryiterator_category;lua_State*L;intindex;intstacktop;stack_proxysp;va_iterator():L(nullptr),index((std::numeric_limits<int>::max)()),stacktop((std::numeric_limits<int>::max)()){}va_iterator(lua_State*luastate,intidx,inttopidx):L(luastate),index(idx),stacktop(topidx),sp(luastate,idx){}referenceoperator*(){returnstack_proxy(L,index);}pointeroperator->(){sp=stack_proxy(L,index);return&sp;}va_iterator&operator++(){++index;return*this;}va_iteratoroperator++(int){autor=*this;this->operator++();returnr;}va_iterator&operator--(){--index;return*this;}va_iteratoroperator--(int){autor=*this;this->operator--();returnr;}va_iterator&operator+=(difference_typeidx){index+=static_cast<int>(idx);return*this;}va_iterator&operator-=(difference_typeidx){index-=static_cast<int>(idx);return*this;}difference_typeoperator-(constva_iterator&r)const{returnindex-r.index;}va_iteratoroperator+(difference_typeidx)const{va_iteratorr=*this;r+=idx;returnr;}referenceoperator[](difference_typeidx){returnstack_proxy(L,index+static_cast<int>(idx));}booloperator==(constva_iterator&r)const{if(stacktop==(std::numeric_limits<int>::max)()){returnr.index==r.stacktop;}elseif(r.stacktop==(std::numeric_limits<int>::max)()){returnindex==stacktop;}returnindex==r.index;}booloperator!=(constva_iterator&r)const{return!(this->operator==(r));}booloperator<(constva_iterator&r)const{returnindex<r.index;}booloperator>(constva_iterator&r)const{returnindex>r.index;}booloperator<=(constva_iterator&r)const{returnindex<=r.index;}booloperator>=(constva_iterator&r)const{returnindex>=r.index;}};template<boolis_const>inlineva_iterator<is_const>operator+(typenameva_iterator<is_const>::difference_typen,constva_iterator<is_const>&r){returnr+n;}structvariadic_args{private:lua_State*L;intindex;intstacktop;public:typedefstack_proxyreference_type;typedefstack_proxyvalue_type;typedefstack_proxy*pointer;typedefstd::ptrdiff_tdifference_type;typedefstd::size_tsize_type;typedefva_iterator<false>iterator;typedefva_iterator<true>const_iterator;typedefstd::reverse_iterator<iterator>reverse_iterator;typedefstd::reverse_iterator<const_iterator>const_reverse_iterator;variadic_args()=default;variadic_args(lua_State*luastate,intstackindex=-1):L(luastate),index(lua_absindex(luastate,stackindex)),stacktop(lua_gettop(luastate)){}variadic_args(constvariadic_args&)=default;variadic_args&operator=(constvariadic_args&)=default;variadic_args(variadic_args&&o):L(o.L),index(o.index),stacktop(o.stacktop){// Must be manual, otherwise destructor will screw us// return count being 0 is enough to keep things clean// but will be thorougho.L=nullptr;o.index=0;o.stacktop=0;}variadic_args&operator=(variadic_args&&o){L=o.L;index=o.index;stacktop=o.stacktop;// Must be manual, otherwise destructor will screw us// return count being 0 is enough to keep things clean// but will be thorougho.L=nullptr;o.index=0;o.stacktop=0;return*this;}iteratorbegin(){returniterator(L,index,stacktop+1);}iteratorend(){returniterator(L,stacktop+1,stacktop+1);}const_iteratorbegin()const{returnconst_iterator(L,index,stacktop+1);}const_iteratorend()const{returnconst_iterator(L,stacktop+1,stacktop+1);}const_iteratorcbegin()const{returnbegin();}const_iteratorcend()const{returnend();}reverse_iteratorrbegin(){returnstd::reverse_iterator<iterator>(begin());}reverse_iteratorrend(){returnstd::reverse_iterator<iterator>(end());}const_reverse_iteratorrbegin()const{returnstd::reverse_iterator<const_iterator>(begin());}const_reverse_iteratorrend()const{returnstd::reverse_iterator<const_iterator>(end());}const_reverse_iteratorcrbegin()const{returnstd::reverse_iterator<const_iterator>(cbegin());}const_reverse_iteratorcrend()const{returnstd::reverse_iterator<const_iterator>(cend());}intpush()const{returnpush(L);}intpush(lua_State*target)const{intpushcount=0;for(inti=index;i<=stacktop;++i){lua_pushvalue(L,i);pushcount+=1;}if(target!=L){lua_xmove(L,target,pushcount);}returnpushcount;}template<typenameT>decltype(auto)get(difference_typestart=0)const{returnstack::get<T>(L,index+static_cast<int>(start));}stack_proxyoperator[](difference_typestart)const{returnstack_proxy(L,index+static_cast<int>(start));}lua_State*lua_state()const{returnL;};intstack_index()const{returnindex;};intleftover_count()const{returnstacktop-(index-1);}inttop()const{returnstacktop;}};namespacestack{template<>structgetter<variadic_args>{staticvariadic_argsget(lua_State*L,intindex,record&tracking){tracking.last=0;returnvariadic_args(L,index);}};template<>structpusher<variadic_args>{staticintpush(lua_State*L,constvariadic_args&ref){returnref.push(L);}};}// stack}// sol// end of sol/variadic_args.hppnamespacesol{template<typenameR=reference,boolshould_pop=!std::is_base_of<stack_reference,R>::value,typenameT>Rmake_reference(lua_State*L,T&&value){intbackpedal=stack::push(L,std::forward<T>(value));Rr=stack::get<R>(L,-backpedal);if(should_pop){lua_pop(L,backpedal);}returnr;}template<typenameT,typenameR=reference,boolshould_pop=!std::is_base_of<stack_reference,R>::value,typename...Args>Rmake_reference(lua_State*L,Args&&...args){intbackpedal=stack::push<T>(L,std::forward<Args>(args)...);Rr=stack::get<R>(L,-backpedal);if(should_pop){lua_pop(L,backpedal);}returnr;}template<typenamebase_t>classbasic_object:publicbase_t{private:template<typenameT>decltype(auto)as_stack(std::true_type)const{returnstack::get<T>(base_t::lua_state(),base_t::stack_index());}template<typenameT>decltype(auto)as_stack(std::false_type)const{base_t::push();returnstack::pop<T>(base_t::lua_state());}template<typenameT>boolis_stack(std::true_type)const{returnstack::check<T>(base_t::lua_state(),base_t::stack_index(),no_panic);}template<typenameT>boolis_stack(std::false_type)const{autopp=stack::push_pop(*this);returnstack::check<T>(base_t::lua_state(),-1,no_panic);}template<boolinvert_and_pop=false>basic_object(std::integral_constant<bool,invert_and_pop>,lua_State*L,intindex=-1)noexcept:base_t(L,index){if(invert_and_pop){lua_pop(L,-index);}}public:basic_object()noexcept=default;template<typenameT,meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>,basic_object>>,meta::neg<std::is_same<base_t,stack_reference>>,std::is_base_of<base_t,meta::unqualified_t<T>>>=meta::enabler>basic_object(T&&r):base_t(std::forward<T>(r)){}basic_object(lua_nil_tr):base_t(r){}basic_object(constbasic_object&)=default;basic_object(basic_object&&)=default;basic_object(conststack_reference&r)noexcept:basic_object(r.lua_state(),r.stack_index()){}basic_object(stack_reference&&r)noexcept:basic_object(r.lua_state(),r.stack_index()){}template<typenameSuper>basic_object(constproxy_base<Super>&r)noexcept:basic_object(r.operatorbasic_object()){}template<typenameSuper>basic_object(proxy_base<Super>&&r)noexcept:basic_object(r.operatorbasic_object()){}basic_object(lua_State*L,intindex=-1)noexcept:base_t(L,index){}basic_object(lua_State*L,ref_indexindex)noexcept:base_t(L,index){}template<typenameT,typename...Args>basic_object(lua_State*L,in_place_type_t<T>,Args&&...args)noexcept:basic_object(std::integral_constant<bool,!std::is_base_of<stack_reference,base_t>::value>(),L,-stack::push<T>(L,std::forward<Args>(args)...)){}template<typenameT,typename...Args>basic_object(lua_State*L,in_place_t,T&&arg,Args&&...args)noexcept:basic_object(L,in_place<T>,std::forward<T>(arg),std::forward<Args>(args)...){}basic_object&operator=(constbasic_object&)=default;basic_object&operator=(basic_object&&)=default;basic_object&operator=(constbase_t&b){base_t::operator=(b);return*this;}basic_object&operator=(base_t&&b){base_t::operator=(std::move(b));return*this;}template<typenameSuper>basic_object&operator=(constproxy_base<Super>&r){this->operator=(r.operatorbasic_object());return*this;}template<typenameSuper>basic_object&operator=(proxy_base<Super>&&r){this->operator=(r.operatorbasic_object());return*this;}template<typenameT>decltype(auto)as()const{returnas_stack<T>(std::is_same<base_t,stack_reference>());}template<typenameT>boolis()const{if(!base_t::valid())returnfalse;returnis_stack<T>(std::is_same<base_t,stack_reference>());}};template<typenameT>objectmake_object(lua_State*L,T&&value){returnmake_reference<object,true>(L,std::forward<T>(value));}template<typenameT,typename...Args>objectmake_object(lua_State*L,Args&&...args){returnmake_reference<T,object,true>(L,std::forward<Args>(args)...);}inlinebooloperator==(constobject&lhs,constlua_nil_t&){return!lhs.valid();}inlinebooloperator==(constlua_nil_t&,constobject&rhs){return!rhs.valid();}inlinebooloperator!=(constobject&lhs,constlua_nil_t&){returnlhs.valid();}inlinebooloperator!=(constlua_nil_t&,constobject&rhs){returnrhs.valid();}}// sol// end of sol/object.hppnamespacesol{template<typenameTable,typenameKey>structproxy:publicproxy_base<proxy<Table,Key>>{private:typedefmeta::condition<meta::is_specialization_of<std::tuple,Key>,Key,std::tuple<meta::condition<std::is_array<meta::unqualified_t<Key>>,Key&,meta::unqualified_t<Key>>>>key_type;template<typenameT,std::size_t...I>decltype(auto)tuple_get(std::index_sequence<I...>)const{returntbl.templatetraverse_get<T>(std::get<I>(key)...);}template<std::size_t...I,typenameT>voidtuple_set(std::index_sequence<I...>,T&&value){tbl.traverse_set(std::get<I>(key)...,std::forward<T>(value));}public:Tabletbl;key_typekey;template<typenameT>proxy(Tabletable,T&&k):tbl(table),key(std::forward<T>(k)){}template<typenameT>proxy&set(T&&item){tuple_set(std::make_index_sequence<std::tuple_size<meta::unqualified_t<key_type>>::value>(),std::forward<T>(item));return*this;}template<typename...Args>proxy&set_function(Args&&...args){tbl.set_function(key,std::forward<Args>(args)...);return*this;}template<typenameU,meta::enable<meta::neg<is_lua_reference<meta::unwrap_unqualified_t<U>>>,meta::is_callable<meta::unwrap_unqualified_t<U>>>=meta::enabler>proxy&operator=(U&&other){returnset_function(std::forward<U>(other));}template<typenameU,meta::disable<meta::neg<is_lua_reference<meta::unwrap_unqualified_t<U>>>,meta::is_callable<meta::unwrap_unqualified_t<U>>>=meta::enabler>proxy&operator=(U&&other){returnset(std::forward<U>(other));}template<typenameT>decltype(auto)get()const{returntuple_get<T>(std::make_index_sequence<std::tuple_size<meta::unqualified_t<key_type>>::value>());}template<typenameT>decltype(auto)get_or(T&&otherwise)const{typedefdecltype(get<T>())U;sol::optional<U>option=get<sol::optional<U>>();if(option){returnstatic_cast<U>(option.value());}returnstatic_cast<U>(std::forward<T>(otherwise));}template<typenameT,typenameD>decltype(auto)get_or(D&&otherwise)const{sol::optional<T>option=get<sol::optional<T>>();if(option){returnstatic_cast<T>(option.value());}returnstatic_cast<T>(std::forward<D>(otherwise));}template<typenameK>decltype(auto)operator[](K&&k)const{autokeys=meta::tuplefy(key,std::forward<K>(k));returnproxy<Table,decltype(keys)>(tbl,std::move(keys));}template<typename...Ret,typename...Args>decltype(auto)call(Args&&...args){returnget<function>().templatecall<Ret...>(std::forward<Args>(args)...);}template<typename...Args>decltype(auto)operator()(Args&&...args){returncall<>(std::forward<Args>(args)...);}boolvalid()const{autopp=stack::push_pop(tbl);autop=stack::probe_get_field<std::is_same<meta::unqualified_t<Table>,global_table>::value>(tbl.lua_state(),key,lua_gettop(tbl.lua_state()));lua_pop(tbl.lua_state(),p.levels);returnp;}};template<typenameTable,typenameKey,typenameT>inlinebooloperator==(T&&left,constproxy<Table,Key>&right){typedefdecltype(stack::get<T>(nullptr,0))U;returnright.templateget<optional<U>>()==left;}template<typenameTable,typenameKey,typenameT>inlinebooloperator==(constproxy<Table,Key>&right,T&&left){typedefdecltype(stack::get<T>(nullptr,0))U;returnright.templateget<optional<U>>()==left;}template<typenameTable,typenameKey,typenameT>inlinebooloperator!=(T&&left,constproxy<Table,Key>&right){typedefdecltype(stack::get<T>(nullptr,0))U;returnright.templateget<optional<U>>()==left;}template<typenameTable,typenameKey,typenameT>inlinebooloperator!=(constproxy<Table,Key>&right,T&&left){typedefdecltype(stack::get<T>(nullptr,0))U;returnright.templateget<optional<U>>()==left;}template<typenameTable,typenameKey>inlinebooloperator==(lua_nil_t,constproxy<Table,Key>&right){return!right.valid();}template<typenameTable,typenameKey>inlinebooloperator==(constproxy<Table,Key>&right,lua_nil_t){return!right.valid();}template<typenameTable,typenameKey>inlinebooloperator!=(lua_nil_t,constproxy<Table,Key>&right){returnright.valid();}template<typenameTable,typenameKey>inlinebooloperator!=(constproxy<Table,Key>&right,lua_nil_t){returnright.valid();}namespacestack{template<typenameTable,typenameKey>structpusher<proxy<Table,Key>>{staticintpush(lua_State*L,constproxy<Table,Key>&p){sol::referencer=p;returnr.push(L);}};}// stack}// sol// end of sol/proxy.hpp// beginning of sol/usertype.hpp// beginning of sol/usertype_metatable.hpp// beginning of sol/deprecate.hpp#ifndef SOL_DEPRECATED#ifdef _MSC_VER#define SOL_DEPRECATED __declspec(deprecated)#elif __GNUC__#define SOL_DEPRECATED __attribute__((deprecated)) #else#define SOL_DEPRECATED [[deprecated]]#endif // compilers#endif // SOL_DEPRECATEDnamespacesol{namespacedetail{template<typenameT>structSOL_DEPRECATEDdeprecate_type{usingtype=T;};}// detail}// sol// end of sol/deprecate.hpp#include<unordered_map>#include<cstdio>namespacesol{namespaceusertype_detail{structno_comp{template<typenameA,typenameB>booloperator()(A&&,B&&)const{returnfalse;}};typedefvoid(*base_walk)(lua_State*,bool&,int&,string_detail::string_shim&);typedefint(*member_search)(lua_State*,void*);structfind_call_pair{member_searchfirst;member_searchsecond;find_call_pair(member_searchfirst,member_searchsecond):first(first),second(second){}};inlineboolis_indexer(string_detail::string_shims){returns==name_of(meta_function::index)||s==name_of(meta_function::new_index);}inlineboolis_indexer(meta_functionmf){returnmf==meta_function::index||mf==meta_function::new_index;}inlineboolis_indexer(call_construction){returnfalse;}inlineboolis_indexer(base_classes_tag){returnfalse;}inlineautomake_shim(string_detail::string_shims){returns;}inlineautomake_shim(call_construction){returnstring_detail::string_shim(name_of(meta_function::call_function));}inlineautomake_shim(meta_functionmf){returnstring_detail::string_shim(name_of(mf));}inlineautomake_shim(base_classes_tag){returnstring_detail::string_shim(detail::base_class_cast_key());}template<typenameArg>inlinestd::stringmake_string(Arg&&arg){string_detail::string_shims=make_shim(arg);returnstd::string(s.c_str(),s.size());}template<typenameN>inlineluaL_Regmake_reg(N&&n,lua_CFunctionf){luaL_Regl{make_shim(std::forward<N>(n)).c_str(),f};returnl;}structregistrar{virtualintpush_um(lua_State*L)=0;virtual~registrar(){}};template<boolis_index>inlineintindexing_fail(lua_State*L){automaybeaccessor=stack::get<optional<string_detail::string_shim>>(L,is_index?-1:-2);string_detail::string_shimaccessor=maybeaccessor.value_or(string_detail::string_shim("(unknown)"));if(is_index)returnluaL_error(L,"sol: attempt to index (get) lua_nil value \"%s\" on userdata (bad (misspelled?) key name or does not exist)",accessor.c_str());elsereturnluaL_error(L,"sol: attempt to index (set) lua_nil value \"%s\" on userdata (bad (misspelled?) key name or does not exist)",accessor.c_str());}template<boolis_index,typenameBase>staticvoidwalk_single_base(lua_State*L,bool&found,int&ret,string_detail::string_shim&){if(found)return;constchar*metakey=&usertype_traits<Base>::metatable()[0];constchar*gcmetakey=&usertype_traits<Base>::gc_table()[0];constchar*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_CFunctionbasewalkfunc=stack::pop<lua_CFunction>(L);lua_pop(L,1);stack::get_field<true>(L,gcmetakey);intvalue=basewalkfunc(L);if(value>-1){found=true;ret=value;}}template<boolis_index,typename...Bases>staticvoidwalk_all_bases(lua_State*L,bool&found,int&ret,string_detail::string_shim&accessor){(void)L;(void)found;(void)ret;(void)accessor;(void)detail::swallow{0,(walk_single_base<is_index,Bases>(L,found,ret,accessor),0)...};}template<typenameT,typenameOp>inlineintoperator_wrap(lua_State*L){automaybel=stack::check_get<T>(L,1);if(maybel){automayber=stack::check_get<T>(L,2);if(mayber){auto&l=*maybel;auto&r=*mayber;if(std::is_same<no_comp,Op>::value){returnstack::push(L,detail::ptr(l)==detail::ptr(r));}else{Opop;returnstack::push(L,(detail::ptr(l)==detail::ptr(r))||op(detail::deref(l),detail::deref(r)));}}}returnstack::push(L,false);}template<typenameT,typenameOp,typenameSupports,typenameRegs,meta::enable<Supports>=meta::enabler>inlinevoidmake_reg_op(Regs&l,int&index,constchar*name){l[index]={name,&operator_wrap<T,Op>};++index;}template<typenameT,typenameOp,typenameSupports,typenameRegs,meta::disable<Supports>=meta::enabler>inlinevoidmake_reg_op(Regs&,int&,constchar*){// Do nothing if there's no support}structadd_destructor_tag{};structcheck_destructor_tag{};structverified_tag{}constverified{};template<typenameT>structis_non_factory_constructor:std::false_type{};template<typename...Args>structis_non_factory_constructor<constructors<Args...>>:std::true_type{};template<typename...Args>structis_non_factory_constructor<constructor_wrapper<Args...>>:std::true_type{};template<>structis_non_factory_constructor<no_construction>:std::true_type{};template<typenameT>structis_constructor:is_non_factory_constructor<T>{};template<typename...Args>structis_constructor<factory_wrapper<Args...>>:std::true_type{};template<typename...Args>usinghas_constructor=meta::any<is_constructor<meta::unqualified_t<Args>>...>;template<typenameT>structis_destructor:std::false_type{};template<typenameFx>structis_destructor<destructor_wrapper<Fx>>:std::true_type{};template<typename...Args>usinghas_destructor=meta::any<is_destructor<meta::unqualified_t<Args>>...>;}// usertype_detailtemplate<typenameT>structclean_type{typedefstd::conditional_t<std::is_array<meta::unqualified_t<T>>::value,T&,std::decay_t<T>>type;};template<typenameT>usingclean_type_t=typenameclean_type<T>::type;template<typenameT,typenameIndexSequence,typename...Tn>structusertype_metatable:usertype_detail::registrar{};template<typenameT,std::size_t...I,typename...Tn>structusertype_metatable<T,std::index_sequence<I...>,Tn...>:usertype_detail::registrar{typedefstd::make_index_sequence<sizeof...(I)*2>indices;typedefstd::index_sequence<I...>half_indices;typedefstd::array<luaL_Reg,sizeof...(Tn)/2+1+3>regs_t;typedefstd::tuple<Tn...>RawTuple;typedefstd::tuple<clean_type_t<Tn>...>Tuple;template<std::size_tIdx>structcheck_binding:is_variable_binding<meta::unqualified_tuple_element_t<Idx,Tuple>>{};typedefstd::unordered_map<std::string,usertype_detail::find_call_pair>mapping_t;Tuplefunctions;mapping_tmapping;lua_CFunctionindexfunc;lua_CFunctionnewindexfunc;lua_CFunctiondestructfunc;lua_CFunctioncallconstructfunc;lua_CFunctionindexbase;lua_CFunctionnewindexbase;usertype_detail::base_walkindexbaseclasspropogation;usertype_detail::base_walknewindexbaseclasspropogation;void*baseclasscheck;void*baseclasscast;boolmustindex;boolsecondarymeta;boolhasequals;boolhasless;boolhaslessequals;template<std::size_tIdx,meta::enable<std::is_same<lua_CFunction,meta::unqualified_tuple_element<Idx+1,RawTuple>>>=meta::enabler>inlinelua_CFunctionmake_func(){returnstd::get<Idx+1>(functions);}template<std::size_tIdx,meta::disable<std::is_same<lua_CFunction,meta::unqualified_tuple_element<Idx+1,RawTuple>>>=meta::enabler>inlinelua_CFunctionmake_func(){returncall<Idx+1>;}staticboolcontains_variable(){typedefmeta::any<check_binding<(I*2+1)>...>has_variables;returnhas_variables::value;}boolcontains_index()const{boolidx=false;(void)detail::swallow{0,((idx|=usertype_detail::is_indexer(std::get<I*2>(functions))),0)...};returnidx;}intfinish_regs(regs_t&l,int&index){if(!hasless){constchar*name=name_of(meta_function::less_than).c_str();usertype_detail::make_reg_op<T,std::less<>,meta::supports_op_less<T>>(l,index,name);}if(!haslessequals){constchar*name=name_of(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(!hasequals){constchar*name=name_of(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(destructfunc!=nullptr){l[index]={name_of(meta_function::garbage_collect).c_str(),destructfunc};++index;}returnindex;}template<std::size_tIdx,typenameF>voidmake_regs(regs_t&,int&,call_construction,F&&){callconstructfunc=call<Idx+1>;secondarymeta=true;}template<std::size_t,typename...Bases>voidmake_regs(regs_t&,int&,base_classes_tag,bases<Bases...>){if(sizeof...(Bases)<1){return;}mustindex=true;(void)detail::swallow{0,((detail::has_derived<Bases>::value=true),0)...};static_assert(sizeof(void*)<=sizeof(detail::inheritance_check_function),"The size of this data pointer is too small to fit the inheritance checking function: file a bug report.");static_assert(sizeof(void*)<=sizeof(detail::inheritance_cast_function),"The size of this data pointer is too small to fit the inheritance checking function: file a bug report.");baseclasscheck=(void*)&detail::inheritance<T,Bases...>::type_check;baseclasscast=(void*)&detail::inheritance<T,Bases...>::type_cast;indexbaseclasspropogation=usertype_detail::walk_all_bases<true,Bases...>;newindexbaseclasspropogation=usertype_detail::walk_all_bases<false,Bases...>;}template<std::size_tIdx,typenameN,typenameF,typename=std::enable_if_t<!meta::any_same<meta::unqualified_t<N>,base_classes_tag,call_construction>::value>>voidmake_regs(regs_t&l,int&index,N&&n,F&&){if(is_variable_binding<meta::unqualified_t<F>>::value){return;}luaL_Regreg=usertype_detail::make_reg(std::forward<N>(n),make_func<Idx>());// Returnable scope// That would be a neat keyword for C++// returnable { ... };if(reg.name==name_of(meta_function::equal_to)){hasequals=true;}if(reg.name==name_of(meta_function::less_than)){hasless=true;}if(reg.name==name_of(meta_function::less_than_or_equal_to)){haslessequals=true;}if(reg.name==name_of(meta_function::garbage_collect)){destructfunc=reg.func;return;}elseif(reg.name==name_of(meta_function::index)){indexfunc=reg.func;mustindex=true;return;}elseif(reg.name==name_of(meta_function::new_index)){newindexfunc=reg.func;mustindex=true;return;}l[index]=reg;++index;}template<typename...Args,typename=std::enable_if_t<sizeof...(Args)==sizeof...(Tn)>>usertype_metatable(Args&&...args):functions(std::forward<Args>(args)...),mapping(),indexfunc(usertype_detail::indexing_fail<true>),newindexfunc(usertype_detail::indexing_fail<false>),destructfunc(nullptr),callconstructfunc(nullptr),indexbase(&core_indexing_call<true>),newindexbase(&core_indexing_call<false>),indexbaseclasspropogation(usertype_detail::walk_all_bases<true>),newindexbaseclasspropogation(usertype_detail::walk_all_bases<false>),baseclasscheck(nullptr),baseclasscast(nullptr),mustindex(contains_variable()||contains_index()),secondarymeta(contains_variable()),hasequals(false),hasless(false),haslessequals(false){std::initializer_list<typenamemapping_t::value_type>ilist{{std::pair<std::string,usertype_detail::find_call_pair>(usertype_detail::make_string(std::get<I*2>(functions)),usertype_detail::find_call_pair(&usertype_metatable::real_find_call<I*2,I*2+1,false>,&usertype_metatable::real_find_call<I*2,I*2+1,true>))}...};mapping.insert(ilist);}template<std::size_tI0,std::size_tI1,boolis_index>staticintreal_find_call(lua_State*L,void*um){auto&f=*static_cast<usertype_metatable*>(um);if(is_variable_binding<decltype(std::get<I1>(f.functions))>::value){returnreal_call_with<I1,is_index,true>(L,f);}returnstack::push(L,c_closure(call<I1,is_index>,stack::push(L,light<usertype_metatable>(f))));}template<boolis_index,booltoplevel=false>staticintcore_indexing_call(lua_State*L){usertype_metatable&f=toplevel?stack::get<light<usertype_metatable>>(L,upvalue_index(1)):stack::pop<light<usertype_metatable>>(L);staticconstintkeyidx=-2+static_cast<int>(is_index);if(toplevel&&stack::get<type>(L,keyidx)!=type::string){returnis_index?f.indexfunc(L):f.newindexfunc(L);}std::stringname=stack::get<std::string>(L,keyidx);automemberit=f.mapping.find(name);if(memberit!=f.mapping.cend()){auto&member=is_index?memberit->second.second:memberit->second.first;return(member)(L,static_cast<void*>(&f));}string_detail::string_shimaccessor=name;intret=0;boolfound=false;// Otherwise, we need to do propagating calls through the basesif(is_index)f.indexbaseclasspropogation(L,found,ret,accessor);elsef.newindexbaseclasspropogation(L,found,ret,accessor);if(found){returnret;}returntoplevel?(is_index?f.indexfunc(L):f.newindexfunc(L)):-1;}staticintreal_index_call(lua_State*L){returncore_indexing_call<true,true>(L);}staticintreal_new_index_call(lua_State*L){returncore_indexing_call<false,true>(L);}template<std::size_tIdx,boolis_index=true,boolis_variable=false>staticintreal_call(lua_State*L){usertype_metatable&f=stack::get<light<usertype_metatable>>(L,upvalue_index(1));returnreal_call_with<Idx,is_index,is_variable>(L,f);}template<std::size_tIdx,boolis_index=true,boolis_variable=false>staticintreal_call_with(lua_State*L,usertype_metatable&um){typedefmeta::unqualified_tuple_element_t<Idx-1,Tuple>K;typedefmeta::unqualified_tuple_element_t<Idx,Tuple>F;staticconstintboost=!usertype_detail::is_non_factory_constructor<F>::value&&std::is_same<K,call_construction>::value?1:0;auto&f=std::get<Idx>(um.functions);returncall_detail::call_wrapped<T,is_index,is_variable,boost>(L,f);}template<std::size_tIdx,boolis_index=true,boolis_variable=false>staticintcall(lua_State*L){returndetail::static_trampoline<(&real_call<Idx,is_index,is_variable>)>(L);}template<std::size_tIdx,boolis_index=true,boolis_variable=false>staticintcall_with(lua_State*L){returndetail::static_trampoline<(&real_call_with<Idx,is_index,is_variable>)>(L);}staticintindex_call(lua_State*L){returndetail::static_trampoline<(&real_index_call)>(L);}staticintnew_index_call(lua_State*L){returndetail::static_trampoline<(&real_new_index_call)>(L);}virtualintpush_um(lua_State*L)override{returnstack::push(L,std::move(*this));}~usertype_metatable()override{}};namespacestack{template<typenameT,std::size_t...I,typename...Args>structpusher<usertype_metatable<T,std::index_sequence<I...>,Args...>>{typedefusertype_metatable<T,std::index_sequence<I...>,Args...>umt_t;typedeftypenameumt_t::regs_tregs_t;staticumt_t&make_cleanup(lua_State*L,umt_t&&umx){// ensure some sort of uniquenessstaticintuniqueness=0;std::stringuniquegcmetakey=usertype_traits<T>::user_gc_metatable();// std::to_string doesn't exist in android still, with NDK, so this bullshit// is necessary// thanks, Android :vintappended=snprintf(nullptr,0,"%d",uniqueness);std::size_tinsertionpoint=uniquegcmetakey.length()-1;uniquegcmetakey.append(appended,'\0');char*uniquetarget=&uniquegcmetakey[insertionpoint];snprintf(uniquetarget,uniquegcmetakey.length(),"%d",uniqueness);++uniqueness;constchar*gcmetakey=&usertype_traits<T>::gc_table()[0];// Make sure userdata's memory is properly in lua first,// otherwise all the light userdata we make later will become invalidstack::push<user<umt_t>>(L,metatable_key,uniquegcmetakey,std::move(umx));// Create the top level thing that will act as our deleter later onstack_referenceumt(L,-1);stack::set_field<true>(L,gcmetakey,umt);umt.pop();stack::get_field<true>(L,gcmetakey);returnstack::pop<light<umt_t>>(L);}staticintpush(lua_State*L,umt_t&&umx){umt_t&um=make_cleanup(L,std::move(umx));regs_tvalue_table{{}};intlastreg=0;(void)detail::swallow{0,(um.templatemake_regs<(I*2)>(value_table,lastreg,std::get<(I*2)>(um.functions),std::get<(I*2+1)>(um.functions)),0)...};um.finish_regs(value_table,lastreg);value_table[lastreg]={nullptr,nullptr};regs_tref_table=value_table;regs_tunique_table=value_table;boolhasdestructor=!value_table.empty()&&name_of(meta_function::garbage_collect)==value_table[lastreg-1].name;if(hasdestructor){ref_table[lastreg-1]={nullptr,nullptr};unique_table[lastreg-1]={value_table[lastreg-1].name,detail::unique_destruct<T>};}// Now use umconstbool&mustindex=um.mustindex;for(std::size_ti=0;i<3;++i){// Pointer types, AKA "references" from C++constchar*metakey=nullptr;luaL_Reg*metaregs=nullptr;switch(i){case0:metakey=&usertype_traits<T*>::metatable()[0];metaregs=ref_table.data();break;case1:metakey=&usertype_traits<detail::unique_usertype<T>>::metatable()[0];metaregs=unique_table.data();break;case2:default:metakey=&usertype_traits<T>::metatable()[0];metaregs=value_table.data();break;}luaL_newmetatable(L,metakey);stack_referencet(L,-1);stack::push(L,make_light(um));luaL_setfuncs(L,metaregs,1);if(um.baseclasscheck!=nullptr){stack::set_field(L,detail::base_class_check_key(),um.baseclasscheck,t.stack_index());}if(um.baseclasscast!=nullptr){stack::set_field(L,detail::base_class_cast_key(),um.baseclasscast,t.stack_index());}stack::set_field(L,detail::base_class_index_propogation_key(),make_closure(um.indexbase,make_light(um)),t.stack_index());stack::set_field(L,detail::base_class_new_index_propogation_key(),make_closure(um.newindexbase,make_light(um)),t.stack_index());if(mustindex){// Basic index pushing: specialize// index and newindex to give variables and stuffstack::set_field(L,meta_function::index,make_closure(umt_t::index_call,make_light(um)),t.stack_index());stack::set_field(L,meta_function::new_index,make_closure(umt_t::new_index_call,make_light(um)),t.stack_index());}else{// If there's only functions, we can use the fast index versionstack::set_field(L,meta_function::index,t,t.stack_index());}// metatable on the metatable// for call constructor purposes and suchlua_createtable(L,0,3);stack_referencemetabehind(L,-1);if(um.callconstructfunc!=nullptr){stack::set_field(L,meta_function::call_function,make_closure(um.callconstructfunc,make_light(um)),metabehind.stack_index());}if(um.secondarymeta){stack::set_field(L,meta_function::index,make_closure(umt_t::index_call,make_light(um)),metabehind.stack_index());stack::set_field(L,meta_function::new_index,make_closure(umt_t::new_index_call,make_light(um)),metabehind.stack_index());}stack::set_field(L,metatable_key,metabehind,t.stack_index());metabehind.pop();// We want to just leave the table// in the registry only, otherwise we return itt.pop();}// Now for the shim-table that actually gets assigned to the nameluaL_newmetatable(L,&usertype_traits<T>::user_metatable()[0]);stack_referencet(L,-1);stack::push(L,make_light(um));luaL_setfuncs(L,value_table.data(),1);{lua_createtable(L,0,3);stack_referencemetabehind(L,-1);if(um.callconstructfunc!=nullptr){stack::set_field(L,meta_function::call_function,make_closure(um.callconstructfunc,make_light(um)),metabehind.stack_index());}if(um.secondarymeta){stack::set_field(L,meta_function::index,make_closure(umt_t::index_call,make_light(um)),metabehind.stack_index());stack::set_field(L,meta_function::new_index,make_closure(umt_t::new_index_call,make_light(um)),metabehind.stack_index());}stack::set_field(L,metatable_key,metabehind,t.stack_index());metabehind.pop();}return1;}};}// stack}// sol// end of sol/usertype_metatable.hpp// beginning of sol/simple_usertype_metatable.hppnamespacesol{namespaceusertype_detail{constlua_Integertoplevel_magic=static_cast<lua_Integer>(0x00000001);structvariable_wrapper{virtualintindex(lua_State*L)=0;virtualintnew_index(lua_State*L)=0;virtual~variable_wrapper(){};};template<typenameT,typenameF>structcallable_binding:variable_wrapper{Ffx;template<typenameArg>callable_binding(Arg&&arg):fx(std::forward<Arg>(arg)){}virtualintindex(lua_State*L)override{returncall_detail::call_wrapped<T,true,true>(L,fx);}virtualintnew_index(lua_State*L)override{returncall_detail::call_wrapped<T,false,true>(L,fx);}};typedefstd::unordered_map<std::string,std::unique_ptr<variable_wrapper>>variable_map;typedefstd::unordered_map<std::string,object>function_map;structsimple_map{constchar*metakey;variable_mapvariables;function_mapfunctions;base_walkindexbaseclasspropogation;base_walknewindexbaseclasspropogation;simple_map(constchar*mkey,base_walkindex,base_walknewindex,variable_map&&vars,function_map&&funcs):metakey(mkey),variables(std::move(vars)),functions(std::move(funcs)),indexbaseclasspropogation(index),newindexbaseclasspropogation(newindex){}};template<typenameT>inlineintsimple_metatable_newindex(lua_State*L){intisnum=0;lua_Integermagic=lua_tointegerx(L,lua_upvalueindex(4),&isnum);if(isnum!=0&&magic==toplevel_magic){for(std::size_ti=0;i<3;lua_pop(L,1),++i){// Pointer types, AKA "references" from C++constchar*metakey=nullptr;switch(i){case0:metakey=&usertype_traits<T*>::metatable()[0];break;case1:metakey=&usertype_traits<detail::unique_usertype<T>>::metatable()[0];break;case2:default:metakey=&usertype_traits<T>::metatable()[0];break;}luaL_getmetatable(L,metakey);inttableindex=lua_gettop(L);if(type_of(L,tableindex)==type::lua_nil){continue;}stack::set_field<false,true>(L,stack_reference(L,2),stack_reference(L,3),tableindex);}lua_settop(L,0);return0;}lua_pop(L,1);returnindexing_fail<false>(L);}template<boolis_index,booltoplevel=false>inlineintsimple_core_indexing_call(lua_State*L){simple_map&sm=toplevel?stack::get<user<simple_map>>(L,upvalue_index(1)):stack::pop<user<simple_map>>(L);variable_map&variables=sm.variables;function_map&functions=sm.functions;staticconstintkeyidx=-2+static_cast<int>(is_index);if(toplevel){if(stack::get<type>(L,keyidx)!=type::string){lua_CFunctionindexingfunc=is_index?stack::get<lua_CFunction>(L,upvalue_index(2)):stack::get<lua_CFunction>(L,upvalue_index(3));returnindexingfunc(L);}}string_detail::string_shimaccessor=stack::get<string_detail::string_shim>(L,keyidx);std::stringaccessorkey=accessor.c_str();autovit=variables.find(accessorkey);if(vit!=variables.cend()){auto&varwrap=*(vit->second);if(is_index){returnvarwrap.index(L);}returnvarwrap.new_index(L);}autofit=functions.find(accessorkey);if(fit!=functions.cend()){auto&func=(fit->second);returnstack::push(L,func);}// Check table storage first for a method that worksluaL_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);return1;}lua_pop(L,1);}lua_pop(L,1);intret=0;boolfound=false;// Otherwise, we need to do propagating calls through the basesif(is_index){sm.indexbaseclasspropogation(L,found,ret,accessor);}else{sm.newindexbaseclasspropogation(L,found,ret,accessor);}if(found){returnret;}if(toplevel){lua_CFunctionindexingfunc=is_index?stack::get<lua_CFunction>(L,upvalue_index(2)):stack::get<lua_CFunction>(L,upvalue_index(3));returnindexingfunc(L);}return-1;}inlineintsimple_real_index_call(lua_State*L){returnsimple_core_indexing_call<true,true>(L);}inlineintsimple_real_new_index_call(lua_State*L){returnsimple_core_indexing_call<false,true>(L);}inlineintsimple_index_call(lua_State*L){returndetail::static_trampoline<(&simple_real_index_call)>(L);}inlineintsimple_new_index_call(lua_State*L){returndetail::static_trampoline<(&simple_real_new_index_call)>(L);}}structsimple_tag{}constsimple{};template<typenameT>structsimple_usertype_metatable:usertype_detail::registrar{public:usertype_detail::function_mapregistrations;usertype_detail::variable_mapvarmap;objectcallconstructfunc;lua_CFunctionindexfunc;lua_CFunctionnewindexfunc;lua_CFunctionindexbase;lua_CFunctionnewindexbase;usertype_detail::base_walkindexbaseclasspropogation;usertype_detail::base_walknewindexbaseclasspropogation;void*baseclasscheck;void*baseclasscast;boolmustindex;boolsecondarymeta;template<typenameN>voidinsert(N&&n,object&&o){std::stringkey=usertype_detail::make_string(std::forward<N>(n));autohint=registrations.find(key);if(hint==registrations.cend()){registrations.emplace_hint(hint,std::move(key),std::move(o));return;}hint->second=std::move(o);}template<typenameN,typenameF,meta::enable<meta::is_callable<meta::unwrap_unqualified_t<F>>>=meta::enabler>voidadd_function(lua_State*L,N&&n,F&&f){insert(std::forward<N>(n),make_object(L,as_function_reference(std::forward<F>(f))));}template<typenameN,typenameF,meta::disable<meta::is_callable<meta::unwrap_unqualified_t<F>>>=meta::enabler>voidadd_function(lua_State*L,N&&n,F&&f){objecto=make_object(L,std::forward<F>(f));if(std::is_same<meta::unqualified_t<N>,call_construction>::value){callconstructfunc=std::move(o);return;}insert(std::forward<N>(n),std::move(o));}template<typenameN,typenameF,meta::disable<is_variable_binding<meta::unqualified_t<F>>>=meta::enabler>voidadd(lua_State*L,N&&n,F&&f){add_function(L,std::forward<N>(n),std::forward<F>(f));}template<typenameN,typenameF,meta::enable<is_variable_binding<meta::unqualified_t<F>>>=meta::enabler>voidadd(lua_State*,N&&n,F&&f){mustindex=true;secondarymeta=true;std::stringkey=usertype_detail::make_string(std::forward<N>(n));autoo=std::make_unique<usertype_detail::callable_binding<T,std::decay_t<F>>>(std::forward<F>(f));autohint=varmap.find(key);if(hint==varmap.cend()){varmap.emplace_hint(hint,std::move(key),std::move(o));return;}hint->second=std::move(o);}template<typenameN,typename...Fxs>voidadd(lua_State*L,N&&n,constructor_wrapper<Fxs...>c){objecto(L,in_place<detail::tagged<T,constructor_wrapper<Fxs...>>>,std::move(c));if(std::is_same<meta::unqualified_t<N>,call_construction>::value){callconstructfunc=std::move(o);return;}insert(std::forward<N>(n),std::move(o));}template<typenameN,typename...Lists>voidadd(lua_State*L,N&&n,constructor_list<Lists...>c){objecto(L,in_place<detail::tagged<T,constructor_list<Lists...>>>,std::move(c));if(std::is_same<meta::unqualified_t<N>,call_construction>::value){callconstructfunc=std::move(o);return;}insert(std::forward<N>(n),std::move(o));}template<typenameN>voidadd(lua_State*L,N&&n,destructor_wrapper<void>c){objecto(L,in_place<detail::tagged<T,destructor_wrapper<void>>>,std::move(c));if(std::is_same<meta::unqualified_t<N>,call_construction>::value){callconstructfunc=std::move(o);return;}insert(std::forward<N>(n),std::move(o));}template<typenameN,typenameFx>voidadd(lua_State*L,N&&n,destructor_wrapper<Fx>c){objecto(L,in_place<detail::tagged<T,destructor_wrapper<Fx>>>,std::move(c));if(std::is_same<meta::unqualified_t<N>,call_construction>::value){callconstructfunc=std::move(o);return;}insert(std::forward<N>(n),std::move(o));}template<typename...Bases>voidadd(lua_State*,base_classes_tag,bases<Bases...>){static_assert(sizeof(usertype_detail::base_walk)<=sizeof(void*),"size of function pointer is greater than sizeof(void*); cannot work on this platform. Please file a bug report.");if(sizeof...(Bases)<1){return;}mustindex=true;(void)detail::swallow{0,((detail::has_derived<Bases>::value=true),0)...};static_assert(sizeof(void*)<=sizeof(detail::inheritance_check_function),"The size of this data pointer is too small to fit the inheritance checking function: Please file a bug report.");static_assert(sizeof(void*)<=sizeof(detail::inheritance_cast_function),"The size of this data pointer is too small to fit the inheritance checking function: Please file a bug report.");baseclasscheck=(void*)&detail::inheritance<T,Bases...>::type_check;baseclasscast=(void*)&detail::inheritance<T,Bases...>::type_cast;indexbaseclasspropogation=usertype_detail::walk_all_bases<true,Bases...>;newindexbaseclasspropogation=usertype_detail::walk_all_bases<false,Bases...>;}private:template<std::size_t...I,typenameTuple>simple_usertype_metatable(usertype_detail::verified_tag,std::index_sequence<I...>,lua_State*L,Tuple&&args):callconstructfunc(lua_nil),indexfunc(&usertype_detail::indexing_fail<true>),newindexfunc(&usertype_detail::indexing_fail<false>),indexbase(&usertype_detail::simple_core_indexing_call<true>),newindexbase(&usertype_detail::simple_core_indexing_call<false>),indexbaseclasspropogation(usertype_detail::walk_all_bases<true>),newindexbaseclasspropogation(&usertype_detail::walk_all_bases<false>),baseclasscheck(nullptr),baseclasscast(nullptr),mustindex(false),secondarymeta(false){(void)detail::swallow{0,(add(L,detail::forward_get<I*2>(args),detail::forward_get<I*2+1>(args)),0)...};}template<typename...Args>simple_usertype_metatable(lua_State*L,usertype_detail::verified_tagv,Args&&...args):simple_usertype_metatable(v,std::make_index_sequence<sizeof...(Args)/2>(),L,std::forward_as_tuple(std::forward<Args>(args)...)){}template<typename...Args>simple_usertype_metatable(lua_State*L,usertype_detail::add_destructor_tag,Args&&...args):simple_usertype_metatable(L,usertype_detail::verified,std::forward<Args>(args)...,"__gc",default_destructor){}template<typename...Args>simple_usertype_metatable(lua_State*L,usertype_detail::check_destructor_tag,Args&&...args):simple_usertype_metatable(L,meta::condition<meta::all<std::is_destructible<T>,meta::neg<usertype_detail::has_destructor<Args...>>>,usertype_detail::add_destructor_tag,usertype_detail::verified_tag>(),std::forward<Args>(args)...){}public:simple_usertype_metatable(lua_State*L):simple_usertype_metatable(L,meta::condition<meta::all<std::is_default_constructible<T>>,decltype(default_constructor),usertype_detail::check_destructor_tag>()){}template<typenameArg,typename...Args,meta::disable_any<meta::any_same<meta::unqualified_t<Arg>,usertype_detail::verified_tag,usertype_detail::add_destructor_tag,usertype_detail::check_destructor_tag>,meta::is_specialization_of<constructors,meta::unqualified_t<Arg>>,meta::is_specialization_of<constructor_wrapper,meta::unqualified_t<Arg>>>=meta::enabler>simple_usertype_metatable(lua_State*L,Arg&&arg,Args&&...args):simple_usertype_metatable(L,meta::condition<meta::all<std::is_default_constructible<T>,meta::neg<usertype_detail::has_constructor<Args...>>>,decltype(default_constructor),usertype_detail::check_destructor_tag>(),std::forward<Arg>(arg),std::forward<Args>(args)...){}template<typename...Args,typename...CArgs>simple_usertype_metatable(lua_State*L,constructors<CArgs...>constructorlist,Args&&...args):simple_usertype_metatable(L,usertype_detail::check_destructor_tag(),std::forward<Args>(args)...,"new",constructorlist){}template<typename...Args,typename...Fxs>simple_usertype_metatable(lua_State*L,constructor_wrapper<Fxs...>constructorlist,Args&&...args):simple_usertype_metatable(L,usertype_detail::check_destructor_tag(),std::forward<Args>(args)...,"new",constructorlist){}virtualintpush_um(lua_State*L)override{returnstack::push(L,std::move(*this));}};namespacestack{template<typenameT>structpusher<simple_usertype_metatable<T>>{typedefsimple_usertype_metatable<T>umt_t;staticusertype_detail::simple_map&make_cleanup(lua_State*L,umt_t&umx){staticintuniqueness=0;std::stringuniquegcmetakey=usertype_traits<T>::user_gc_metatable();// std::to_string doesn't exist in android still, with NDK, so this bullshit// is necessary// thanks, Android :vintappended=snprintf(nullptr,0,"%d",uniqueness);std::size_tinsertionpoint=uniquegcmetakey.length()-1;uniquegcmetakey.append(appended,'\0');char*uniquetarget=&uniquegcmetakey[insertionpoint];snprintf(uniquetarget,uniquegcmetakey.length(),"%d",uniqueness);++uniqueness;constchar*gcmetakey=&usertype_traits<T>::gc_table()[0];stack::push<user<usertype_detail::simple_map>>(L,metatable_key,uniquegcmetakey,&usertype_traits<T>::metatable()[0],umx.indexbaseclasspropogation,umx.newindexbaseclasspropogation,std::move(umx.varmap),std::move(umx.registrations));stack_referencestackvarmap(L,-1);stack::set_field<true>(L,gcmetakey,stackvarmap);stackvarmap.pop();stack::get_field<true>(L,gcmetakey);usertype_detail::simple_map&varmap=stack::pop<light<usertype_detail::simple_map>>(L);returnvarmap;}staticintpush(lua_State*L,umt_t&&umx){auto&varmap=make_cleanup(L,umx);boolhasequals=false;boolhasless=false;boolhaslessequals=false;autoregister_kvp=[&](std::size_ti,stack_reference&t,conststd::string&first,object&second){if(first==name_of(meta_function::equal_to)){hasequals=true;}elseif(first==name_of(meta_function::less_than)){hasless=true;}elseif(first==name_of(meta_function::less_than_or_equal_to)){haslessequals=true;}elseif(first==name_of(meta_function::index)){umx.indexfunc=second.templateas<lua_CFunction>();}elseif(first==name_of(meta_function::new_index)){umx.newindexfunc=second.templateas<lua_CFunction>();}switch(i){case0:if(first==name_of(meta_function::garbage_collect)){return;}break;case1:if(first==name_of(meta_function::garbage_collect)){stack::set_field(L,first,detail::unique_destruct<T>,t.stack_index());return;}break;case2:default:break;}stack::set_field(L,first,second,t.stack_index());};for(std::size_ti=0;i<3;++i){// Pointer types, AKA "references" from C++constchar*metakey=nullptr;switch(i){case0:metakey=&usertype_traits<T*>::metatable()[0];break;case1:metakey=&usertype_traits<detail::unique_usertype<T>>::metatable()[0];break;case2:default:metakey=&usertype_traits<T>::metatable()[0];break;}luaL_newmetatable(L,metakey);stack_referencet(L,-1);for(auto&kvp:varmap.functions){auto&first=std::get<0>(kvp);auto&second=std::get<1>(kvp);register_kvp(i,t,first,second);}luaL_Regopregs[4]{};intopregsindex=0;if(!hasless){constchar*name=name_of(meta_function::less_than).c_str();usertype_detail::make_reg_op<T,std::less<>,meta::supports_op_less<T>>(opregs,opregsindex,name);}if(!haslessequals){constchar*name=name_of(meta_function::less_than_or_equal_to).c_str();usertype_detail::make_reg_op<T,std::less_equal<>,meta::supports_op_less_equal<T>>(opregs,opregsindex,name);}if(!hasequals){constchar*name=name_of(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>(opregs,opregsindex,name);}t.push();luaL_setfuncs(L,opregs,0);t.pop();if(umx.baseclasscheck!=nullptr){stack::set_field(L,detail::base_class_check_key(),umx.baseclasscheck,t.stack_index());}if(umx.baseclasscast!=nullptr){stack::set_field(L,detail::base_class_cast_key(),umx.baseclasscast,t.stack_index());}// Base class propagation featuresstack::set_field(L,detail::base_class_index_propogation_key(),umx.indexbase,t.stack_index());stack::set_field(L,detail::base_class_new_index_propogation_key(),umx.newindexbase,t.stack_index());if(umx.mustindex){// use indexing functionstack::set_field(L,meta_function::index,make_closure(&usertype_detail::simple_index_call,make_light(varmap),umx.indexfunc,umx.newindexfunc),t.stack_index());stack::set_field(L,meta_function::new_index,make_closure(&usertype_detail::simple_new_index_call,make_light(varmap),umx.indexfunc,umx.newindexfunc),t.stack_index());}else{// Metatable indexes itselfstack::set_field(L,meta_function::index,t,t.stack_index());}// metatable on the metatable// for call constructor purposes and suchlua_createtable(L,0,2*static_cast<int>(umx.secondarymeta)+static_cast<int>(umx.callconstructfunc.valid()));stack_referencemetabehind(L,-1);if(umx.callconstructfunc.valid()){stack::set_field(L,sol::meta_function::call_function,umx.callconstructfunc,metabehind.stack_index());}if(umx.secondarymeta){stack::set_field(L,meta_function::index,make_closure(&usertype_detail::simple_index_call,make_light(varmap),umx.indexfunc,umx.newindexfunc),metabehind.stack_index());stack::set_field(L,meta_function::new_index,make_closure(&usertype_detail::simple_new_index_call,make_light(varmap),umx.indexfunc,umx.newindexfunc),metabehind.stack_index());}stack::set_field(L,metatable_key,metabehind,t.stack_index());metabehind.pop();t.pop();}// Now for the shim-table that actually gets pushedluaL_newmetatable(L,&usertype_traits<T>::user_metatable()[0]);stack_referencet(L,-1);for(auto&kvp:varmap.functions){auto&first=std::get<0>(kvp);auto&second=std::get<1>(kvp);register_kvp(2,t,first,second);}{lua_createtable(L,0,2+static_cast<int>(umx.callconstructfunc.valid()));stack_referencemetabehind(L,-1);if(umx.callconstructfunc.valid()){stack::set_field(L,sol::meta_function::call_function,umx.callconstructfunc,metabehind.stack_index());}// use indexing functionstack::set_field(L,meta_function::index,make_closure(&usertype_detail::simple_index_call,make_light(varmap),&usertype_detail::simple_index_call,&usertype_detail::simple_metatable_newindex<T>,usertype_detail::toplevel_magic),metabehind.stack_index());stack::set_field(L,meta_function::new_index,make_closure(&usertype_detail::simple_new_index_call,make_light(varmap),&usertype_detail::simple_index_call,&usertype_detail::simple_metatable_newindex<T>,usertype_detail::toplevel_magic),metabehind.stack_index());stack::set_field(L,metatable_key,metabehind,t.stack_index());metabehind.pop();}// Don't pop the table when we're done;// return itreturn1;}};}// stack}// sol// end of sol/simple_usertype_metatable.hpp// beginning of sol/container_usertype_metatable.hppnamespacesol{namespacedetail{template<typenameT>structhas_find{private:typedefstd::array<char,1>one;typedefstd::array<char,2>two;template<typenameC>staticonetest(decltype(&C::find));template<typenameC>statictwotest(...);public:staticconstboolvalue=sizeof(test<T>(0))==sizeof(char);};template<typenameT>structhas_push_back{private:typedefstd::array<char,1>one;typedefstd::array<char,2>two;template<typenameC>staticonetest(decltype(std::declval<C>().push_back(std::declval<std::add_rvalue_reference_t<typenameC::value_type>>()))*);template<typenameC>statictwotest(...);public:staticconstboolvalue=sizeof(test<T>(0))==sizeof(char);};template<typenameT>structhas_clear{private:typedefstd::array<char,1>one;typedefstd::array<char,2>two;template<typenameC>staticonetest(decltype(&C::clear));template<typenameC>statictwotest(...);public:staticconstboolvalue=sizeof(test<T>(0))==sizeof(char);};template<typenameT>structhas_insert{private:typedefstd::array<char,1>one;typedefstd::array<char,2>two;template<typenameC>staticonetest(decltype(std::declval<C>().insert(std::declval<std::add_rvalue_reference_t<typenameC::const_iterator>>(),std::declval<std::add_rvalue_reference_t<typenameC::value_type>>()))*);template<typenameC>statictwotest(...);public:staticconstboolvalue=sizeof(test<T>(0))==sizeof(char);};template<typenameT>T&get_first(constT&t){returnstd::forward<T>(t);}template<typenameA,typenameB>decltype(auto)get_first(conststd::pair<A,B>&t){returnt.first;}template<typenameC,typenameI,meta::enable<has_find<meta::unqualified_t<C>>>=meta::enabler>autofind(C&c,I&&i){returnc.find(std::forward<I>(i));}template<typenameC,typenameI,meta::disable<has_find<meta::unqualified_t<C>>>=meta::enabler>autofind(C&c,I&&i){usingstd::begin;usingstd::end;returnstd::find_if(begin(c),end(c),[&i](auto&&x){returni==get_first(x);});}}template<typenameRaw,typenameC=void>structcontainer_usertype_metatable{typedefmeta::has_key_value_pair<meta::unqualified_t<Raw>>is_associative;typedefmeta::unqualified_t<Raw>T;typedeftypenameT::iteratorI;typedefstd::conditional_t<is_associative::value,typenameT::value_type,std::pair<std::size_t,typenameT::value_type>>KV;typedeftypenameKV::first_typeK;typedeftypenameKV::second_typeV;typedefstd::remove_reference_t<decltype(*std::declval<I&>())>IR;structiter{T&source;Iit;iter(T&source,Iit):source(source),it(std::move(it)){}};staticauto&get_src(lua_State*L){#ifdef SOL_SAFE_USERTYPEautop=stack::check_get<T*>(L,1);if(!p||p.value()==nullptr){luaL_error(L,"sol: 'self' argument is not the proper type (pass 'self' as first argument with ':' or call on proper type)");}return*p.value();#elsereturnstack::get<T>(L,1);#endif}staticintreal_index_call_associative(std::true_type,lua_State*L){autok=stack::check_get<K>(L,2);if(k){auto&src=get_src(L);usingstd::end;autoit=detail::find(src,*k);if(it!=end(src)){auto&v=*it;returnstack::push_reference(L,v.second);}}else{automaybename=stack::check_get<string_detail::string_shim>(L,2);if(maybename){auto&name=*maybename;if(name=="add"){returnstack::push(L,&add_call);}elseif(name=="insert"){returnstack::push(L,&insert_call);}elseif(name=="clear"){returnstack::push(L,&clear_call);}}}returnstack::push(L,lua_nil);}staticintreal_index_call_associative(std::false_type,lua_State*L){auto&src=get_src(L);automaybek=stack::check_get<K>(L,2);if(maybek){usingstd::begin;autoit=begin(src);Kk=*maybek;#ifdef SOL_SAFE_USERTYPEif(k>src.size()||k<1){returnstack::push(L,lua_nil);}#else#endif // Safety--k;std::advance(it,k);returnstack::push_reference(L,*it);}else{automaybename=stack::check_get<string_detail::string_shim>(L,2);if(maybename){auto&name=*maybename;if(name=="add"){returnstack::push(L,&add_call);}elseif(name=="insert"){returnstack::push(L,&insert_call);}elseif(name=="clear"){returnstack::push(L,&clear_call);}}}returnstack::push(L,lua_nil);}staticintreal_index_call(lua_State*L){returnreal_index_call_associative(is_associative(),L);}staticintreal_new_index_call_const(std::false_type,std::false_type,lua_State*L){returnluaL_error(L,"sol: cannot write to a const value type or an immutable iterator (e.g., std::set)");}staticintreal_new_index_call_const(std::false_type,std::true_type,lua_State*L){returnluaL_error(L,"sol: cannot write to a const value type or an immutable iterator (e.g., std::set)");}staticintreal_new_index_call_const(std::true_type,std::true_type,lua_State*L){auto&src=get_src(L);autok=stack::check_get<K>(L,2);if(k){usingstd::end;autoit=detail::find(src,*k);if(it!=end(src)){auto&v=*it;v.second=stack::get<V>(L,3);}else{src.insert(it,{std::move(*k),stack::get<V>(L,3)});}}return0;}staticintreal_new_index_call_const(std::true_type,std::false_type,lua_State*L){auto&src=get_src(L);#ifdef SOL_SAFE_USERTYPEautomaybek=stack::check_get<K>(L,2);if(!maybek){returnstack::push(L,lua_nil);}Kk=*maybek;#elseKk=stack::get<K>(L,2);#endifusingstd::begin;autoit=begin(src);if(k==src.size()){real_add_call_push(std::integral_constant<bool,detail::has_push_back<T>::value>(),L,src,1);return0;}--k;std::advance(it,k);*it=stack::get<V>(L,3);return0;}staticintreal_new_index_call(lua_State*L){returnreal_new_index_call_const(meta::neg<meta::any<std::is_const<V>,std::is_const<IR>>>(),is_associative(),L);}staticintreal_pairs_next_call_assoc(std::true_type,lua_State*L){usingstd::end;iter&i=stack::get<user<iter>>(L,1);auto&source=i.source;auto&it=i.it;if(it==end(source)){return0;}intp=stack::multi_push_reference(L,it->first,it->second);std::advance(it,1);returnp;}staticintreal_pairs_call_assoc(std::true_type,lua_State*L){auto&src=get_src(L);usingstd::begin;stack::push(L,pairs_next_call);stack::push<user<iter>>(L,src,begin(src));stack::push(L,1);return3;}staticintreal_pairs_next_call_assoc(std::false_type,lua_State*L){usingstd::end;iter&i=stack::get<user<iter>>(L,1);auto&source=i.source;auto&it=i.it;Kk=stack::get<K>(L,2);if(it==end(source)){return0;}intp=stack::multi_push_reference(L,k+1,*it);std::advance(it,1);returnp;}staticintreal_pairs_call_assoc(std::false_type,lua_State*L){auto&src=get_src(L);usingstd::begin;stack::push(L,pairs_next_call);stack::push<user<iter>>(L,src,begin(src));stack::push(L,0);return3;}staticintreal_pairs_next_call(lua_State*L){returnreal_pairs_next_call_assoc(is_associative(),L);}staticintreal_pairs_call(lua_State*L){returnreal_pairs_call_assoc(is_associative(),L);}staticintreal_length_call(lua_State*L){auto&src=get_src(L);returnstack::push(L,src.size());}staticintreal_add_call_insert(std::true_type,lua_State*L,T&src,intboost=0){usingstd::end;src.insert(end(src),stack::get<V>(L,2+boost));return0;}staticintreal_add_call_insert(std::false_type,lua_State*L,T&,int=0){staticconststd::string&s=detail::demangle<T>();returnluaL_error(L,"sol: cannot call insert on type %s",s.c_str());}staticintreal_add_call_push(std::true_type,lua_State*L,T&src,intboost=0){src.push_back(stack::get<V>(L,2+boost));return0;}staticintreal_add_call_push(std::false_type,lua_State*L,T&src,intboost=0){returnreal_add_call_insert(std::integral_constant<bool,detail::has_insert<T>::value>(),L,src,boost);}staticintreal_add_call_associative(std::true_type,lua_State*L){returnreal_insert_call(L);}staticintreal_add_call_associative(std::false_type,lua_State*L){auto&src=get_src(L);returnreal_add_call_push(std::integral_constant<bool,detail::has_push_back<T>::value>(),L,src);}staticintreal_add_call_capable(std::true_type,lua_State*L){returnreal_add_call_associative(is_associative(),L);}staticintreal_add_call_capable(std::false_type,lua_State*L){staticconststd::string&s=detail::demangle<T>();returnluaL_error(L,"sol: cannot call add on type %s",s.c_str());}staticintreal_add_call(lua_State*L){returnreal_add_call_capable(std::integral_constant<bool,detail::has_push_back<T>::value||detail::has_insert<T>::value>(),L);}staticintreal_insert_call_capable(std::false_type,std::false_type,lua_State*L){staticconststd::string&s=detail::demangle<T>();returnluaL_error(L,"sol: cannot call insert on type %s",s.c_str());}staticintreal_insert_call_capable(std::false_type,std::true_type,lua_State*L){returnreal_insert_call_capable(std::false_type(),std::false_type(),L);}staticintreal_insert_call_capable(std::true_type,std::false_type,lua_State*L){usingstd::begin;auto&src=get_src(L);src.insert(std::next(begin(src),stack::get<K>(L,2)),stack::get<V>(L,3));return0;}staticintreal_insert_call_capable(std::true_type,std::true_type,lua_State*L){returnreal_new_index_call(L);}staticintreal_insert_call(lua_State*L){returnreal_insert_call_capable(std::integral_constant<bool,detail::has_insert<T>::value>(),is_associative(),L);}staticintreal_clear_call_capable(std::false_type,lua_State*L){staticconststd::string&s=detail::demangle<T>();returnluaL_error(L,"sol: cannot call clear on type %s",s.c_str());}staticintreal_clear_call_capable(std::true_type,lua_State*L){auto&src=get_src(L);src.clear();return0;}staticintreal_clear_call(lua_State*L){returnreal_clear_call_capable(std::integral_constant<bool,detail::has_clear<T>::value>(),L);}staticintadd_call(lua_State*L){returndetail::static_trampoline<(&real_add_call)>(L);}staticintinsert_call(lua_State*L){returndetail::static_trampoline<(&real_insert_call)>(L);}staticintclear_call(lua_State*L){returndetail::static_trampoline<(&real_clear_call)>(L);}staticintlength_call(lua_State*L){returndetail::static_trampoline<(&real_length_call)>(L);}staticintpairs_next_call(lua_State*L){returndetail::static_trampoline<(&real_pairs_next_call)>(L);}staticintpairs_call(lua_State*L){returndetail::static_trampoline<(&real_pairs_call)>(L);}staticintindex_call(lua_State*L){returndetail::static_trampoline<(&real_index_call)>(L);}staticintnew_index_call(lua_State*L){returndetail::static_trampoline<(&real_new_index_call)>(L);}};namespacestack{namespacestack_detail{template<typenameT>inlineautocontainer_metatable(){typedefcontainer_usertype_metatable<std::remove_pointer_t<T>>meta_cumt;std::array<luaL_Reg,10>reg={{{"__index",&meta_cumt::index_call},{"__newindex",&meta_cumt::new_index_call},{"__pairs",&meta_cumt::pairs_call},{"__ipairs",&meta_cumt::pairs_call},{"__len",&meta_cumt::length_call},{"clear",&meta_cumt::clear_call},{"insert",&meta_cumt::insert_call},{"add",&meta_cumt::add_call},std::is_pointer<T>::value?luaL_Reg{nullptr,nullptr}:luaL_Reg{"__gc",&detail::usertype_alloc_destroy<T>},{nullptr,nullptr}}};returnreg;}template<typenameT>inlineautocontainer_metatable_behind(){typedefcontainer_usertype_metatable<std::remove_pointer_t<T>>meta_cumt;std::array<luaL_Reg,3>reg={{{"__index",&meta_cumt::index_call},{"__newindex",&meta_cumt::new_index_call},{nullptr,nullptr}}};returnreg;}template<typenameT>structmetatable_setup{lua_State*L;metatable_setup(lua_State*L):L(L){}voidoperator()(){staticconstautoreg=container_metatable<T>();staticconstautocontainerreg=container_metatable_behind<T>();staticconstchar*metakey=&usertype_traits<T>::metatable()[0];if(luaL_newmetatable(L,metakey)==1){stack_referencemetatable(L,-1);luaL_setfuncs(L,reg.data(),0);lua_createtable(L,0,static_cast<int>(containerreg.size()));stack_referencemetabehind(L,-1);luaL_setfuncs(L,containerreg.data(),0);stack::set_field(L,metatable_key,metabehind,metatable.stack_index());metabehind.pop();}lua_setmetatable(L,-2);}};}template<typenameT>structpusher<T,std::enable_if_t<meta::all<is_container<meta::unqualified_t<T>>,meta::neg<meta::any<std::is_base_of<reference,meta::unqualified_t<T>>,std::is_base_of<stack_reference,meta::unqualified_t<T>>>>>::value>>{staticintpush(lua_State*L,constT&cont){stack_detail::metatable_setup<T>fx(L);returnpusher<detail::as_value_tag<T>>{}.push_fx(L,fx,cont);}staticintpush(lua_State*L,T&&cont){stack_detail::metatable_setup<T>fx(L);returnpusher<detail::as_value_tag<T>>{}.push_fx(L,fx,std::move(cont));}};template<typenameT>structpusher<T*,std::enable_if_t<meta::all<is_container<meta::unqualified_t<T>>,meta::neg<meta::any<std::is_base_of<reference,meta::unqualified_t<T>>,std::is_base_of<stack_reference,meta::unqualified_t<T>>>>>::value>>{staticintpush(lua_State*L,T*cont){stack_detail::metatable_setup<meta::unqualified_t<std::remove_pointer_t<T>>*>fx(L);returnpusher<detail::as_pointer_tag<T>>{}.push_fx(L,fx,cont);}};}// stack}// sol// end of sol/container_usertype_metatable.hppnamespacesol{template<typenameT>classusertype{private:std::unique_ptr<usertype_detail::registrar,detail::deleter>metatableregister;template<typename...Args>usertype(usertype_detail::verified_tag,Args&&...args):metatableregister(detail::make_unique_deleter<usertype_metatable<T,std::make_index_sequence<sizeof...(Args)/2>,Args...>,detail::deleter>(std::forward<Args>(args)...)){}template<typename...Args>usertype(usertype_detail::add_destructor_tag,Args&&...args):usertype(usertype_detail::verified,std::forward<Args>(args)...,"__gc",default_destructor){}template<typename...Args>usertype(usertype_detail::check_destructor_tag,Args&&...args):usertype(meta::condition<meta::all<std::is_destructible<T>,meta::neg<usertype_detail::has_destructor<Args...>>>,usertype_detail::add_destructor_tag,usertype_detail::verified_tag>(),std::forward<Args>(args)...){}public:template<typename...Args>usertype(Args&&...args):usertype(meta::condition<meta::all<std::is_default_constructible<T>,meta::neg<usertype_detail::has_constructor<Args...>>>,decltype(default_constructor),usertype_detail::check_destructor_tag>(),std::forward<Args>(args)...){}template<typename...Args,typename...CArgs>usertype(constructors<CArgs...>constructorlist,Args&&...args):usertype(usertype_detail::check_destructor_tag(),std::forward<Args>(args)...,"new",constructorlist){}template<typename...Args,typename...Fxs>usertype(constructor_wrapper<Fxs...>constructorlist,Args&&...args):usertype(usertype_detail::check_destructor_tag(),std::forward<Args>(args)...,"new",constructorlist){}template<typename...Args>usertype(simple_tag,lua_State*L,Args&&...args):metatableregister(detail::make_unique_deleter<simple_usertype_metatable<T>,detail::deleter>(L,std::forward<Args>(args)...)){}usertype_detail::registrar*registrar_data(){returnmetatableregister.get();}intpush(lua_State*L){returnmetatableregister->push_um(L);}};template<typenameT>classsimple_usertype:publicusertype<T>{private:typedefusertype<T>base_t;lua_State*state;public:template<typename...Args>simple_usertype(lua_State*L,Args&&...args):base_t(simple,L,std::forward<Args>(args)...),state(L){}template<typenameN,typenameF>voidset(N&&n,F&&f){autometa=static_cast<simple_usertype_metatable<T>*>(base_t::registrar_data());meta->add(state,n,f);}};namespacestack{template<typenameT>structpusher<usertype<T>>{staticintpush(lua_State*L,usertype<T>&user){returnuser.push(L);}};}// stack}// sol// end of sol/usertype.hpp// beginning of sol/table_iterator.hppnamespacesol{template<typenamereference_type>classbasic_table_iterator:publicstd::iterator<std::input_iterator_tag,std::pair<object,object>>{private:typedefstd::iterator<std::input_iterator_tag,std::pair<object,object>>base_t;public:typedefobjectkey_type;typedefobjectmapped_type;typedefbase_t::value_typevalue_type;typedefbase_t::iterator_categoryiterator_category;typedefbase_t::difference_typedifference_type;typedefbase_t::pointerpointer;typedefbase_t::referencereference;typedefconstvalue_type&const_reference;private:std::pair<object,object>kvp;reference_typeref;inttableidx=0;intkeyidx=0;std::ptrdiff_tidx=0;public:basic_table_iterator():keyidx(-1),idx(-1){}basic_table_iterator(reference_typex):ref(std::move(x)){ref.push();tableidx=lua_gettop(ref.lua_state());stack::push(ref.lua_state(),lua_nil);this->operator++();if(idx==-1){return;}--idx;}basic_table_iterator&operator++(){if(idx==-1)return*this;if(lua_next(ref.lua_state(),tableidx)==0){idx=-1;keyidx=-1;return*this;}++idx;kvp.first=object(ref.lua_state(),-2);kvp.second=object(ref.lua_state(),-1);lua_pop(ref.lua_state(),1);// leave key on the stackkeyidx=lua_gettop(ref.lua_state());return*this;}basic_table_iteratoroperator++(int){autosaved=*this;this->operator++();returnsaved;}referenceoperator*(){returnkvp;}const_referenceoperator*()const{returnkvp;}booloperator==(constbasic_table_iterator&right)const{returnidx==right.idx;}booloperator!=(constbasic_table_iterator&right)const{returnidx!=right.idx;}~basic_table_iterator(){if(keyidx!=-1){stack::remove(ref.lua_state(),keyidx,1);}if(ref.valid()){stack::remove(ref.lua_state(),tableidx,1);}}};}// sol// end of sol/table_iterator.hppnamespacesol{namespacedetail{template<std::size_tn>structclean{lua_State*L;clean(lua_State*luastate):L(luastate){}~clean(){lua_pop(L,static_cast<int>(n));}};structref_clean{lua_State*L;int&n;ref_clean(lua_State*luastate,int&n):L(luastate),n(n){}~ref_clean(){lua_pop(L,static_cast<int>(n));}};inlineintfail_on_newindex(lua_State*L){returnluaL_error(L,"sol: cannot modify the elements of an enumeration table");}}template<booltop_level,typenamebase_t>classbasic_table_core:publicbase_t{friendclassstate;friendclassstate_view;template<typename...Args>usingis_global=meta::all<meta::boolean<top_level>,meta::is_c_str<Args>...>;template<typenameFx>voidfor_each(std::true_type,Fx&&fx)const{autopp=stack::push_pop(*this);stack::push(base_t::lua_state(),lua_nil);while(lua_next(base_t::lua_state(),-2)){sol::objectkey(base_t::lua_state(),-2);sol::objectvalue(base_t::lua_state(),-1);std::pair<sol::object&,sol::object&>keyvalue(key,value);autopn=stack::pop_n(base_t::lua_state(),1);fx(keyvalue);}}template<typenameFx>voidfor_each(std::false_type,Fx&&fx)const{autopp=stack::push_pop(*this);stack::push(base_t::lua_state(),lua_nil);while(lua_next(base_t::lua_state(),-2)){sol::objectkey(base_t::lua_state(),-2);sol::objectvalue(base_t::lua_state(),-1);autopn=stack::pop_n(base_t::lua_state(),1);fx(key,value);}}template<typenameRet0,typenameRet1,typename...Ret,std::size_t...I,typenameKeys>autotuple_get(types<Ret0,Ret1,Ret...>,std::index_sequence<0,1,I...>,Keys&&keys)const->decltype(stack::pop<std::tuple<Ret0,Ret1,Ret...>>(nullptr)){typedefdecltype(stack::pop<std::tuple<Ret0,Ret1,Ret...>>(nullptr))Tup;returnTup(traverse_get_optional<top_level,Ret0>(meta::is_specialization_of<sol::optional,meta::unqualified_t<Ret0>>(),detail::forward_get<0>(keys)),traverse_get_optional<top_level,Ret1>(meta::is_specialization_of<sol::optional,meta::unqualified_t<Ret1>>(),detail::forward_get<1>(keys)),traverse_get_optional<top_level,Ret>(meta::is_specialization_of<sol::optional,meta::unqualified_t<Ret>>(),detail::forward_get<I>(keys))...);}template<typenameRet,std::size_tI,typenameKeys>decltype(auto)tuple_get(types<Ret>,std::index_sequence<I>,Keys&&keys)const{returntraverse_get_optional<top_level,Ret>(meta::is_specialization_of<sol::optional,meta::unqualified_t<Ret>>(),detail::forward_get<I>(keys));}template<typenamePairs,std::size_t...I>voidtuple_set(std::index_sequence<I...>,Pairs&&pairs){autopp=stack::push_pop<top_level&&(is_global<decltype(detail::forward_get<I*2>(pairs))...>::value)>(*this);void(detail::swallow{(stack::set_field<top_level>(base_t::lua_state(),detail::forward_get<I*2>(pairs),detail::forward_get<I*2+1>(pairs),lua_gettop(base_t::lua_state())),0)...});}template<boolglobal,typenameT,typenameKey>decltype(auto)traverse_get_deep(Key&&key)const{stack::get_field<global>(base_t::lua_state(),std::forward<Key>(key));returnstack::get<T>(base_t::lua_state());}template<boolglobal,typenameT,typenameKey,typename...Keys>decltype(auto)traverse_get_deep(Key&&key,Keys&&...keys)const{stack::get_field<global>(base_t::lua_state(),std::forward<Key>(key));returntraverse_get_deep<false,T>(std::forward<Keys>(keys)...);}template<boolglobal,typenameT,std::size_tI,typenameKey>decltype(auto)traverse_get_deep_optional(int&popcount,Key&&key)const{typedefdecltype(stack::get<T>(base_t::lua_state()))R;autop=stack::probe_get_field<global>(base_t::lua_state(),std::forward<Key>(key),lua_gettop(base_t::lua_state()));popcount+=p.levels;if(!p.success)returnR(nullopt);returnstack::get<T>(base_t::lua_state());}template<boolglobal,typenameT,std::size_tI,typenameKey,typename...Keys>decltype(auto)traverse_get_deep_optional(int&popcount,Key&&key,Keys&&...keys)const{autop=I>0?stack::probe_get_field<global>(base_t::lua_state(),std::forward<Key>(key),-1):stack::probe_get_field<global>(base_t::lua_state(),std::forward<Key>(key),lua_gettop(base_t::lua_state()));popcount+=p.levels;if(!p.success)returnT(nullopt);returntraverse_get_deep_optional<false,T,I+1>(popcount,std::forward<Keys>(keys)...);}template<boolglobal,typenameT,typename...Keys>decltype(auto)traverse_get_optional(std::false_type,Keys&&...keys)const{detail::clean<sizeof...(Keys)>c(base_t::lua_state());returntraverse_get_deep<top_level,T>(std::forward<Keys>(keys)...);}template<boolglobal,typenameT,typename...Keys>decltype(auto)traverse_get_optional(std::true_type,Keys&&...keys)const{intpopcount=0;detail::ref_cleanc(base_t::lua_state(),popcount);returntraverse_get_deep_optional<top_level,T,0>(popcount,std::forward<Keys>(keys)...);}template<boolglobal,typenameKey,typenameValue>voidtraverse_set_deep(Key&&key,Value&&value)const{stack::set_field<global>(base_t::lua_state(),std::forward<Key>(key),std::forward<Value>(value));}template<boolglobal,typenameKey,typename...Keys>voidtraverse_set_deep(Key&&key,Keys&&...keys)const{stack::get_field<global>(base_t::lua_state(),std::forward<Key>(key));traverse_set_deep<false>(std::forward<Keys>(keys)...);}basic_table_core(lua_State*L,detail::global_tagt)noexcept:reference(L,t){}public:typedefbasic_table_iterator<base_t>iterator;typedefiteratorconst_iterator;basic_table_core()noexcept:base_t(){}template<typenameT,meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>,basic_table_core>>,meta::neg<std::is_same<base_t,stack_reference>>,std::is_base_of<base_t,meta::unqualified_t<T>>>=meta::enabler>basic_table_core(T&&r)noexcept:base_t(std::forward<T>(r)){#ifdef SOL_CHECK_ARGUMENTSif(!is_table<meta::unqualified_t<T>>::value){autopp=stack::push_pop(*this);stack::check<basic_table_core>(base_t::lua_state(),-1,type_panic);}#endif // Safety}basic_table_core(constbasic_table_core&)=default;basic_table_core(basic_table_core&&)=default;basic_table_core&operator=(constbasic_table_core&)=default;basic_table_core&operator=(basic_table_core&&)=default;basic_table_core(conststack_reference&r):basic_table_core(r.lua_state(),r.stack_index()){}basic_table_core(stack_reference&&r):basic_table_core(r.lua_state(),r.stack_index()){}template<typenameT,meta::enable<meta::neg<std::is_integral<meta::unqualified_t<T>>>,meta::neg<std::is_same<T,ref_index>>>=meta::enabler>basic_table_core(lua_State*L,T&&r):basic_table_core(L,sol::ref_index(r.registry_index())){}basic_table_core(lua_State*L,intindex=-1):base_t(L,index){#ifdef SOL_CHECK_ARGUMENTSstack::check<basic_table_core>(L,index,type_panic);#endif // Safety}basic_table_core(lua_State*L,ref_indexindex):base_t(L,index){#ifdef SOL_CHECK_ARGUMENTSautopp=stack::push_pop(*this);stack::check<basic_table_core>(L,-1,type_panic);#endif // Safety}iteratorbegin()const{returniterator(*this);}iteratorend()const{returniterator();}const_iteratorcbegin()const{returnbegin();}const_iteratorcend()const{returnend();}template<typename...Ret,typename...Keys>decltype(auto)get(Keys&&...keys)const{static_assert(sizeof...(Keys)==sizeof...(Ret),"number of keys and number of return types do not match");autopp=stack::push_pop<is_global<Keys...>::value>(*this);returntuple_get(types<Ret...>(),std::make_index_sequence<sizeof...(Ret)>(),std::forward_as_tuple(std::forward<Keys>(keys)...));}template<typenameT,typenameKey>decltype(auto)get_or(Key&&key,T&&otherwise)const{typedefdecltype(get<T>(""))U;sol::optional<U>option=get<sol::optional<U>>(std::forward<Key>(key));if(option){returnstatic_cast<U>(option.value());}returnstatic_cast<U>(std::forward<T>(otherwise));}template<typenameT,typenameKey,typenameD>decltype(auto)get_or(Key&&key,D&&otherwise)const{sol::optional<T>option=get<sol::optional<T>>(std::forward<Key>(key));if(option){returnstatic_cast<T>(option.value());}returnstatic_cast<T>(std::forward<D>(otherwise));}template<typenameT,typename...Keys>decltype(auto)traverse_get(Keys&&...keys)const{autopp=stack::push_pop<is_global<Keys...>::value>(*this);returntraverse_get_optional<top_level,T>(meta::is_specialization_of<sol::optional,meta::unqualified_t<T>>(),std::forward<Keys>(keys)...);}template<typename...Keys>basic_table_core&traverse_set(Keys&&...keys){autopp=stack::push_pop<is_global<Keys...>::value>(*this);autopn=stack::pop_n(base_t::lua_state(),static_cast<int>(sizeof...(Keys)-2));traverse_set_deep<top_level>(std::forward<Keys>(keys)...);return*this;}template<typename...Args>basic_table_core&set(Args&&...args){tuple_set(std::make_index_sequence<sizeof...(Args)/2>(),std::forward_as_tuple(std::forward<Args>(args)...));return*this;}template<typenameT>basic_table_core&set_usertype(usertype<T>&user){returnset_usertype(usertype_traits<T>::name(),user);}template<typenameKey,typenameT>basic_table_core&set_usertype(Key&&key,usertype<T>&user){returnset(std::forward<Key>(key),user);}template<typenameClass,typename...Args>basic_table_core&new_usertype(conststd::string&name,Args&&...args){usertype<Class>utype(std::forward<Args>(args)...);set_usertype(name,utype);return*this;}template<typenameClass,typenameCTor0,typename...CTor,typename...Args>basic_table_core&new_usertype(conststd::string&name,Args&&...args){constructors<types<CTor0,CTor...>>ctor{};returnnew_usertype<Class>(name,ctor,std::forward<Args>(args)...);}template<typenameClass,typename...CArgs,typename...Args>basic_table_core&new_usertype(conststd::string&name,constructors<CArgs...>ctor,Args&&...args){usertype<Class>utype(ctor,std::forward<Args>(args)...);set_usertype(name,utype);return*this;}template<typenameClass,typename...Args>basic_table_core&new_simple_usertype(conststd::string&name,Args&&...args){simple_usertype<Class>utype(base_t::lua_state(),std::forward<Args>(args)...);set_usertype(name,utype);return*this;}template<typenameClass,typenameCTor0,typename...CTor,typename...Args>basic_table_core&new_simple_usertype(conststd::string&name,Args&&...args){constructors<types<CTor0,CTor...>>ctor{};returnnew_simple_usertype<Class>(name,ctor,std::forward<Args>(args)...);}template<typenameClass,typename...CArgs,typename...Args>basic_table_core&new_simple_usertype(conststd::string&name,constructors<CArgs...>ctor,Args&&...args){simple_usertype<Class>utype(base_t::lua_state(),ctor,std::forward<Args>(args)...);set_usertype(name,utype);return*this;}template<typenameClass,typename...Args>simple_usertype<Class>create_simple_usertype(Args&&...args){simple_usertype<Class>utype(base_t::lua_state(),std::forward<Args>(args)...);returnutype;}template<typenameClass,typenameCTor0,typename...CTor,typename...Args>simple_usertype<Class>create_simple_usertype(Args&&...args){constructors<types<CTor0,CTor...>>ctor{};returncreate_simple_usertype<Class>(ctor,std::forward<Args>(args)...);}template<typenameClass,typename...CArgs,typename...Args>simple_usertype<Class>create_simple_usertype(constructors<CArgs...>ctor,Args&&...args){simple_usertype<Class>utype(base_t::lua_state(),ctor,std::forward<Args>(args)...);returnutype;}template<boolread_only=true,typename...Args>basic_table_core&new_enum(conststd::string&name,Args&&...args){if(read_only){tableidx=create_with(std::forward<Args>(args)...);tablex=create_with(meta_function::new_index,detail::fail_on_newindex,meta_function::index,idx);tabletarget=create_named(name);target[metatable_key]=x;}else{create_named(name,std::forward<Args>(args)...);}return*this;}template<typenameFx>voidfor_each(Fx&&fx)const{typedefmeta::is_invokable<Fx(std::pair<sol::object,sol::object>)>is_paired;for_each(is_paired(),std::forward<Fx>(fx));}size_tsize()const{autopp=stack::push_pop(*this);lua_len(base_t::lua_state(),-1);returnstack::pop<size_t>(base_t::lua_state());}boolempty()const{returncbegin()==cend();}template<typenameT>proxy<basic_table_core&,T>operator[](T&&key)&{returnproxy<basic_table_core&,T>(*this,std::forward<T>(key));}template<typenameT>proxy<constbasic_table_core&,T>operator[](T&&key)const&{returnproxy<constbasic_table_core&,T>(*this,std::forward<T>(key));}template<typenameT>proxy<basic_table_core,T>operator[](T&&key)&&{returnproxy<basic_table_core,T>(*this,std::forward<T>(key));}template<typenameSig,typenameKey,typename...Args>basic_table_core&set_function(Key&&key,Args&&...args){set_fx(types<Sig>(),std::forward<Key>(key),std::forward<Args>(args)...);return*this;}template<typenameKey,typename...Args>basic_table_core&set_function(Key&&key,Args&&...args){set_fx(types<>(),std::forward<Key>(key),std::forward<Args>(args)...);return*this;}template<typename...Args>basic_table_core&add(Args&&...args){autopp=stack::push_pop(*this);(void)detail::swallow{0,(stack::set_ref(base_t::lua_state(),std::forward<Args>(args)),0)...};return*this;}private:template<typenameR,typename...Args,typenameFx,typenameKey,typename=std::result_of_t<Fx(Args...)>>voidset_fx(types<R(Args...)>,Key&&key,Fx&&fx){set_resolved_function<R(Args...)>(std::forward<Key>(key),std::forward<Fx>(fx));}template<typenameFx,typenameKey,meta::enable<meta::is_specialization_of<overload_set,meta::unqualified_t<Fx>>>=meta::enabler>voidset_fx(types<>,Key&&key,Fx&&fx){set(std::forward<Key>(key),std::forward<Fx>(fx));}template<typenameFx,typenameKey,typename...Args,meta::disable<meta::is_specialization_of<overload_set,meta::unqualified_t<Fx>>>=meta::enabler>voidset_fx(types<>,Key&&key,Fx&&fx,Args&&...args){set(std::forward<Key>(key),as_function_reference(std::forward<Fx>(fx),std::forward<Args>(args)...));}template<typename...Sig,typename...Args,typenameKey>voidset_resolved_function(Key&&key,Args&&...args){set(std::forward<Key>(key),as_function_reference<function_sig<Sig...>>(std::forward<Args>(args)...));}public:staticinlinetablecreate(lua_State*L,intnarr=0,intnrec=0){lua_createtable(L,narr,nrec);tableresult(L);lua_pop(L,1);returnresult;}template<typenameKey,typenameValue,typename...Args>staticinlinetablecreate(lua_State*L,intnarr,intnrec,Key&&key,Value&&value,Args&&...args){lua_createtable(L,narr,nrec);tableresult(L);result.set(std::forward<Key>(key),std::forward<Value>(value),std::forward<Args>(args)...);lua_pop(L,1);returnresult;}template<typename...Args>staticinlinetablecreate_with(lua_State*L,Args&&...args){static_assert(sizeof...(Args)%2==0,"You must have an even number of arguments for a key, value ... list.");staticconstintnarr=static_cast<int>(meta::count_2_for_pack<std::is_integral,Args...>::value);returncreate(L,narr,static_cast<int>((sizeof...(Args)/2)-narr),std::forward<Args>(args)...);}tablecreate(intnarr=0,intnrec=0){returncreate(base_t::lua_state(),narr,nrec);}template<typenameKey,typenameValue,typename...Args>tablecreate(intnarr,intnrec,Key&&key,Value&&value,Args&&...args){returncreate(base_t::lua_state(),narr,nrec,std::forward<Key>(key),std::forward<Value>(value),std::forward<Args>(args)...);}template<typenameName>tablecreate(Name&&name,intnarr=0,intnrec=0){tablex=create(base_t::lua_state(),narr,nrec);this->set(std::forward<Name>(name),x);returnx;}template<typenameName,typenameKey,typenameValue,typename...Args>tablecreate(Name&&name,intnarr,intnrec,Key&&key,Value&&value,Args&&...args){tablex=create(base_t::lua_state(),narr,nrec,std::forward<Key>(key),std::forward<Value>(value),std::forward<Args>(args)...);this->set(std::forward<Name>(name),x);returnx;}template<typename...Args>tablecreate_with(Args&&...args){returncreate_with(base_t::lua_state(),std::forward<Args>(args)...);}template<typenameName,typename...Args>tablecreate_named(Name&&name,Args&&...args){staticconstintnarr=static_cast<int>(meta::count_2_for_pack<std::is_integral,Args...>::value);returncreate(std::forward<Name>(name),narr,sizeof...(Args)/2-narr,std::forward<Args>(args)...);}~basic_table_core(){}};}// sol// end of sol/table_core.hppnamespacesol{typedeftable_core<false>table;}// sol// end of sol/table.hpp// beginning of sol/load_result.hppnamespacesol{structload_result:publicproxy_base<load_result>{private:lua_State*L;intindex;intreturncount;intpopcount;load_statuserr;template<typenameT>decltype(auto)tagged_get(types<sol::optional<T>>)const{if(!valid()){returnsol::optional<T>(nullopt);}returnstack::get<sol::optional<T>>(L,index);}template<typenameT>decltype(auto)tagged_get(types<T>)const{#ifdef SOL_CHECK_ARGUMENTSif(!valid()){type_panic(L,index,type_of(L,index),type::none);}#endif // Check Argument Safetyreturnstack::get<T>(L,index);}sol::optional<sol::error>tagged_get(types<sol::optional<sol::error>>)const{if(valid()){returnnullopt;}returnsol::error(detail::direct_error,stack::get<std::string>(L,index));}sol::errortagged_get(types<sol::error>)const{#ifdef SOL_CHECK_ARGUMENTSif(valid()){type_panic(L,index,type_of(L,index),type::none);}#endif // Check Argument Safetyreturnsol::error(detail::direct_error,stack::get<std::string>(L,index));}public:load_result()=default;load_result(lua_State*Ls,intstackindex=-1,intretnum=0,intpopnum=0,load_statuslerr=load_status::ok)noexcept:L(Ls),index(stackindex),returncount(retnum),popcount(popnum),err(lerr){}load_result(constload_result&)=default;load_result&operator=(constload_result&)=default;load_result(load_result&&o)noexcept:L(o.L),index(o.index),returncount(o.returncount),popcount(o.popcount),err(o.err){// Must be manual, otherwise destructor will screw us// return count being 0 is enough to keep things clean// but we will be thorougho.L=nullptr;o.index=0;o.returncount=0;o.popcount=0;o.err=load_status::syntax;}load_result&operator=(load_result&&o)noexcept{L=o.L;index=o.index;returncount=o.returncount;popcount=o.popcount;err=o.err;// Must be manual, otherwise destructor will screw us// return count being 0 is enough to keep things clean// but we will be thorougho.L=nullptr;o.index=0;o.returncount=0;o.popcount=0;o.err=load_status::syntax;return*this;}load_statusstatus()constnoexcept{returnerr;}boolvalid()constnoexcept{returnstatus()==load_status::ok;}template<typenameT>Tget()const{returntagged_get(types<meta::unqualified_t<T>>());}template<typename...Ret,typename...Args>decltype(auto)call(Args&&...args){returnget<protected_function>().templatecall<Ret...>(std::forward<Args>(args)...);}template<typename...Args>decltype(auto)operator()(Args&&...args){returncall<>(std::forward<Args>(args)...);}lua_State*lua_state()constnoexcept{returnL;};intstack_index()constnoexcept{returnindex;};~load_result(){stack::remove(L,index,popcount);}};}// sol// end of sol/load_result.hppnamespacesol{enumclasslib:char{base,package,coroutine,string,os,math,table,debug,bit32,io,ffi,jit,utf8,count};inlinestd::size_ttotal_memory_used(lua_State*L){std::size_tkb=lua_gc(L,LUA_GCCOUNT,0);kb*=1024;kb+=lua_gc(L,LUA_GCCOUNTB,0);returnkb;}classstate_view{private:lua_State*L;tablereg;global_tableglobal;optional<object>is_loaded_package(conststd::string&key){autoloaded=reg.traverse_get<optional<object>>("_LOADED",key);boolis53mod=loaded&&!(loaded->is<bool>()&&!loaded->as<bool>());if(is53mod)returnloaded;#if SOL_LUA_VERSION <= 501autoloaded51=global.traverse_get<optional<object>>("package","loaded",key);boolis51mod=loaded51&&!(loaded51->is<bool>()&&!loaded51->as<bool>());if(is51mod)returnloaded51;#endifreturnnullopt;}template<typenameT>voidensure_package(conststd::string&key,T&&sr){#if SOL_LUA_VERSION <= 501autopkg=global["package"];if(!pkg.valid()){pkg=create_table_with("loaded",create_table_with(key,sr));}else{autold=pkg["loaded"];if(!ld.valid()){ld=create_table_with(key,sr);}else{ld[key]=sr;}}#endifautoloaded=reg["_LOADED"];if(!loaded.valid()){loaded=create_table_with(key,sr);}else{loaded[key]=sr;}}template<typenameFx>objectrequire_core(conststd::string&key,Fx&&action,boolcreate_global=true){optional<object>loaded=is_loaded_package(key);if(loaded&&loaded->valid())returnstd::move(*loaded);action();autosr=stack::get<stack_reference>(L);if(create_global)set(key,sr);ensure_package(key,sr);returnstack::pop<object>(L);}public:typedefglobal_table::iteratoriterator;typedefglobal_table::const_iteratorconst_iterator;state_view(lua_State*Ls):L(Ls),reg(Ls,LUA_REGISTRYINDEX),global(Ls,detail::global_){}state_view(this_stateLs):state_view(Ls.L){}lua_State*lua_state()const{returnL;}template<typename...Args>voidopen_libraries(Args&&...args){static_assert(meta::all_same<lib,Args...>::value,"all types must be libraries");if(sizeof...(args)==0){luaL_openlibs(L);return;}liblibraries[1+sizeof...(args)]={lib::count,std::forward<Args>(args)...};for(auto&&library:libraries){switch(library){#if SOL_LUA_VERSION <= 501 && defined(SOL_LUAJIT)caselib::coroutine:#endif // luajit opens coroutine base stuffcaselib::base:luaL_requiref(L,"base",luaopen_base,1);lua_pop(L,1);break;caselib::package:luaL_requiref(L,"package",luaopen_package,1);lua_pop(L,1);break;#if !defined(SOL_LUAJIT)caselib::coroutine:#if SOL_LUA_VERSION > 501luaL_requiref(L,"coroutine",luaopen_coroutine,1);lua_pop(L,1);#endif // Lua 5.2+ onlybreak;#endif // Not LuaJIT - comes builtincaselib::string:luaL_requiref(L,"string",luaopen_string,1);lua_pop(L,1);break;caselib::table:luaL_requiref(L,"table",luaopen_table,1);lua_pop(L,1);break;caselib::math:luaL_requiref(L,"math",luaopen_math,1);lua_pop(L,1);break;caselib::bit32:#ifdef SOL_LUAJITluaL_requiref(L,"bit32",luaopen_bit,1);lua_pop(L,1);#elif (SOL_LUA_VERSION == 502) || defined(LUA_COMPAT_BITLIB) || defined(LUA_COMPAT_5_2)luaL_requiref(L,"bit32",luaopen_bit32,1);lua_pop(L,1);#else#endif // Lua 5.2 only (deprecated in 5.3 (503)) (Can be turned on with Compat flags)break;caselib::io:luaL_requiref(L,"io",luaopen_io,1);lua_pop(L,1);break;caselib::os:luaL_requiref(L,"os",luaopen_os,1);lua_pop(L,1);break;caselib::debug:luaL_requiref(L,"debug",luaopen_debug,1);lua_pop(L,1);break;caselib::utf8:#if SOL_LUA_VERSION > 502 && !defined(SOL_LUAJIT)luaL_requiref(L,"utf8",luaopen_utf8,1);lua_pop(L,1);#endif // Lua 5.3+ onlybreak;caselib::ffi:#ifdef SOL_LUAJITluaL_requiref(L,"ffi",luaopen_ffi,1);lua_pop(L,1);#endif // LuaJIT onlybreak;caselib::jit:#ifdef SOL_LUAJITluaL_requiref(L,"jit",luaopen_jit,1);lua_pop(L,1);#endif // LuaJIT Onlybreak;caselib::count:default:break;}}}objectrequire(conststd::string&key,lua_CFunctionopen_function,boolcreate_global=true){luaL_requiref(L,key.c_str(),open_function,create_global?1:0);returnstack::pop<object>(L);}objectrequire_script(conststd::string&key,conststd::string&code,boolcreate_global=true){returnrequire_core(key,[this,&code](){stack::script(L,code);},create_global);}objectrequire_file(conststd::string&key,conststd::string&filename,boolcreate_global=true){returnrequire_core(key,[this,&filename](){stack::script_file(L,filename);},create_global);}protected_function_resultdo_string(conststd::string&code){sol::protected_functionpf=load(code);returnpf();}protected_function_resultdo_file(conststd::string&filename){sol::protected_functionpf=load_file(filename);returnpf();}function_resultscript(conststd::string&code){intindex=lua_gettop(L);stack::script(L,code);intpostindex=lua_gettop(L);intreturns=postindex-index;returnfunction_result(L,(std::max)(postindex-(returns-1),1),returns);}function_resultscript_file(conststd::string&filename){intindex=lua_gettop(L);stack::script_file(L,filename);intpostindex=lua_gettop(L);intreturns=postindex-index;returnfunction_result(L,(std::max)(postindex-(returns-1),1),returns);}load_resultload(conststd::string&code){load_statusx=static_cast<load_status>(luaL_loadstring(L,code.c_str()));returnload_result(L,lua_absindex(L,-1),1,1,x);}load_resultload_file(conststd::string&filename){load_statusx=static_cast<load_status>(luaL_loadfile(L,filename.c_str()));returnload_result(L,lua_absindex(L,-1),1,1,x);}load_resultload_buffer(constchar*buff,size_tsize,constchar*name,constchar*mode=nullptr){load_statusx=static_cast<load_status>(luaL_loadbufferx(L,buff,size,name,mode));returnload_result(L,lua_absindex(L,-1),1,1,x);}iteratorbegin()const{returnglobal.begin();}iteratorend()const{returnglobal.end();}const_iteratorcbegin()const{returnglobal.cbegin();}const_iteratorcend()const{returnglobal.cend();}global_tableglobals()const{returnglobal;}tableregistry()const{returnreg;}std::size_tmemory_used()const{returntotal_memory_used(lua_state());}voidcollect_garbage(){lua_gc(lua_state(),LUA_GCCOLLECT,0);}operatorlua_State*()const{returnlua_state();}voidset_panic(lua_CFunctionpanic){lua_atpanic(L,panic);}template<typename...Args,typename...Keys>decltype(auto)get(Keys&&...keys)const{returnglobal.get<Args...>(std::forward<Keys>(keys)...);}template<typenameT,typenameKey>decltype(auto)get_or(Key&&key,T&&otherwise)const{returnglobal.get_or(std::forward<Key>(key),std::forward<T>(otherwise));}template<typenameT,typenameKey,typenameD>decltype(auto)get_or(Key&&key,D&&otherwise)const{returnglobal.get_or<T>(std::forward<Key>(key),std::forward<D>(otherwise));}template<typename...Args>state_view&set(Args&&...args){global.set(std::forward<Args>(args)...);return*this;}template<typenameT,typename...Keys>decltype(auto)traverse_get(Keys&&...keys)const{returnglobal.traverse_get<T>(std::forward<Keys>(keys)...);}template<typename...Args>state_view&traverse_set(Args&&...args){global.traverse_set(std::forward<Args>(args)...);return*this;}template<typenameT>state_view&set_usertype(usertype<T>&user){returnset_usertype(usertype_traits<T>::name(),user);}template<typenameKey,typenameT>state_view&set_usertype(Key&&key,usertype<T>&user){global.set_usertype(std::forward<Key>(key),user);return*this;}template<typenameClass,typename...Args>state_view&new_usertype(conststd::string&name,Args&&...args){global.new_usertype<Class>(name,std::forward<Args>(args)...);return*this;}template<typenameClass,typenameCTor0,typename...CTor,typename...Args>state_view&new_usertype(conststd::string&name,Args&&...args){global.new_usertype<Class,CTor0,CTor...>(name,std::forward<Args>(args)...);return*this;}template<typenameClass,typename...CArgs,typename...Args>state_view&new_usertype(conststd::string&name,constructors<CArgs...>ctor,Args&&...args){global.new_usertype<Class>(name,ctor,std::forward<Args>(args)...);return*this;}template<typenameClass,typename...Args>state_view&new_simple_usertype(conststd::string&name,Args&&...args){global.new_simple_usertype<Class>(name,std::forward<Args>(args)...);return*this;}template<typenameClass,typenameCTor0,typename...CTor,typename...Args>state_view&new_simple_usertype(conststd::string&name,Args&&...args){global.new_simple_usertype<Class,CTor0,CTor...>(name,std::forward<Args>(args)...);return*this;}template<typenameClass,typename...CArgs,typename...Args>state_view&new_simple_usertype(conststd::string&name,constructors<CArgs...>ctor,Args&&...args){global.new_simple_usertype<Class>(name,ctor,std::forward<Args>(args)...);return*this;}template<typenameClass,typename...Args>simple_usertype<Class>create_simple_usertype(Args&&...args){returnglobal.create_simple_usertype<Class>(std::forward<Args>(args)...);}template<typenameClass,typenameCTor0,typename...CTor,typename...Args>simple_usertype<Class>create_simple_usertype(Args&&...args){returnglobal.create_simple_usertype<Class,CTor0,CTor...>(std::forward<Args>(args)...);}template<typenameClass,typename...CArgs,typename...Args>simple_usertype<Class>create_simple_usertype(constructors<CArgs...>ctor,Args&&...args){returnglobal.create_simple_usertype<Class>(ctor,std::forward<Args>(args)...);}template<boolread_only=true,typename...Args>state_view&new_enum(conststd::string&name,Args&&...args){global.new_enum<read_only>(name,std::forward<Args>(args)...);return*this;}template<typenameFx>voidfor_each(Fx&&fx){global.for_each(std::forward<Fx>(fx));}template<typenameT>proxy<global_table&,T>operator[](T&&key){returnglobal[std::forward<T>(key)];}template<typenameT>proxy<constglobal_table&,T>operator[](T&&key)const{returnglobal[std::forward<T>(key)];}template<typenameSig,typename...Args,typenameKey>state_view&set_function(Key&&key,Args&&...args){global.set_function<Sig>(std::forward<Key>(key),std::forward<Args>(args)...);return*this;}template<typename...Args,typenameKey>state_view&set_function(Key&&key,Args&&...args){global.set_function(std::forward<Key>(key),std::forward<Args>(args)...);return*this;}template<typenameName>tablecreate_table(Name&&name,intnarr=0,intnrec=0){returnglobal.create(std::forward<Name>(name),narr,nrec);}template<typenameName,typenameKey,typenameValue,typename...Args>tablecreate_table(Name&&name,intnarr,intnrec,Key&&key,Value&&value,Args&&...args){returnglobal.create(std::forward<Name>(name),narr,nrec,std::forward<Key>(key),std::forward<Value>(value),std::forward<Args>(args)...);}template<typenameName,typename...Args>tablecreate_named_table(Name&&name,Args&&...args){tablex=global.create_with(std::forward<Args>(args)...);global.set(std::forward<Name>(name),x);returnx;}tablecreate_table(intnarr=0,intnrec=0){returncreate_table(lua_state(),narr,nrec);}template<typenameKey,typenameValue,typename...Args>tablecreate_table(intnarr,intnrec,Key&&key,Value&&value,Args&&...args){returncreate_table(lua_state(),narr,nrec,std::forward<Key>(key),std::forward<Value>(value),std::forward<Args>(args)...);}template<typename...Args>tablecreate_table_with(Args&&...args){returncreate_table_with(lua_state(),std::forward<Args>(args)...);}staticinlinetablecreate_table(lua_State*L,intnarr=0,intnrec=0){returnglobal_table::create(L,narr,nrec);}template<typenameKey,typenameValue,typename...Args>staticinlinetablecreate_table(lua_State*L,intnarr,intnrec,Key&&key,Value&&value,Args&&...args){returnglobal_table::create(L,narr,nrec,std::forward<Key>(key),std::forward<Value>(value),std::forward<Args>(args)...);}template<typename...Args>staticinlinetablecreate_table_with(lua_State*L,Args&&...args){returnglobal_table::create_with(L,std::forward<Args>(args)...);}};}// sol// end of sol/state_view.hppnamespacesol{inlineintdefault_at_panic(lua_State*L){#ifdef SOL_NO_EXCEPTIONS(void)L;return-1;#elseconstchar*message=lua_tostring(L,-1);if(message){std::stringerr=message;lua_pop(L,1);throwerror(err);}throwerror(std::string("An unexpected error occurred and forced the lua state to call atpanic"));#endif}inlineintdefault_error_handler(lua_State*L){usingnamespacesol;std::stringmsg="An unknown error has triggered the default error handler";optional<string_detail::string_shim>maybetopmsg=stack::check_get<string_detail::string_shim>(L,1);if(maybetopmsg){conststring_detail::string_shim&topmsg=maybetopmsg.value();msg.assign(topmsg.c_str(),topmsg.size());}luaL_traceback(L,L,msg.c_str(),1);optional<string_detail::string_shim>maybetraceback=stack::check_get<string_detail::string_shim>(L,-1);if(maybetraceback){conststring_detail::string_shim&traceback=maybetraceback.value();msg.assign(traceback.c_str(),traceback.size());}returnstack::push(L,msg);}classstate:privatestd::unique_ptr<lua_State,void(*)(lua_State*)>,publicstate_view{private:typedefstd::unique_ptr<lua_State,void(*)(lua_State*)>unique_base;public:state(lua_CFunctionpanic=default_at_panic):unique_base(luaL_newstate(),lua_close),state_view(unique_base::get()){set_panic(panic);stack::luajit_exception_handler(unique_base::get());}state(lua_CFunctionpanic,lua_Allocalfunc,void*alpointer=nullptr):unique_base(lua_newstate(alfunc,alpointer),lua_close),state_view(unique_base::get()){set_panic(panic);sol::protected_function::set_default_handler(sol::object(lua_state(),in_place,default_error_handler));stack::luajit_exception_handler(unique_base::get());}state(conststate&)=delete;state(state&&)=default;state&operator=(conststate&)=delete;state&operator=(state&&)=default;usingstate_view::get;~state(){auto&handler=protected_function::get_default_handler();if(handler.lua_state()==this->lua_state()){protected_function::set_default_handler(reference());}}};}// sol// end of sol/state.hpp// beginning of sol/coroutine.hpp// beginning of sol/thread.hppnamespacesol{structlua_thread_state{lua_State*L;operatorlua_State*()const{returnL;}lua_State*operator->()const{returnL;}};namespacestack{template<>structpusher<lua_thread_state>{intpush(lua_State*,lua_thread_statelts){lua_pushthread(lts.L);return1;}};template<>structgetter<lua_thread_state>{lua_thread_stateget(lua_State*L,intindex,record&tracking){tracking.use(1);lua_thread_statelts{lua_tothread(L,index)};returnlts;}};template<>structcheck_getter<lua_thread_state>{template<typenameHandler>optional<lua_thread_state>get(lua_State*L,intindex,Handler&&handler,record&tracking){lua_thread_statelts{lua_tothread(L,index)};if(lts.L==nullptr){handler(L,index,type::thread,type_of(L,index));returnnullopt;}tracking.use(1);returnlts;}};}#if SOL_LUA_VERSION < 502inlinelua_State*main_thread(lua_State*,lua_State*backup_if_unsupported=nullptr){returnbackup_if_unsupported;}#elseinlinelua_State*main_thread(lua_State*L,lua_State*=nullptr){lua_rawgeti(L,LUA_REGISTRYINDEX,LUA_RIDX_MAINTHREAD);lua_thread_states=stack::pop<lua_thread_state>(L);returns.L;}#endif // Lua 5.2+ has the main thread getterclassthread:publicreference{public:thread()noexcept=default;thread(constthread&)=default;thread(thread&&)=default;template<typenameT,meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>,thread>>,std::is_base_of<reference,meta::unqualified_t<T>>>=meta::enabler>thread(T&&r):reference(std::forward<T>(r)){}thread(conststack_reference&r):thread(r.lua_state(),r.stack_index()){};thread(stack_reference&&r):thread(r.lua_state(),r.stack_index()){};thread&operator=(constthread&)=default;thread&operator=(thread&&)=default;template<typenameT,meta::enable<meta::neg<std::is_integral<meta::unqualified_t<T>>>,meta::neg<std::is_same<T,ref_index>>>=meta::enabler>thread(lua_State*L,T&&r):thread(L,sol::ref_index(r.registry_index())){}thread(lua_State*L,intindex=-1):reference(L,index){#ifdef SOL_CHECK_ARGUMENTStype_assert(L,index,type::thread);#endif // Safety}thread(lua_State*L,ref_indexindex):reference(L,index){#ifdef SOL_CHECK_ARGUMENTSautopp=stack::push_pop(*this);type_assert(L,-1,type::thread);#endif // Safety}thread(lua_State*L,lua_State*actualthread):thread(L,lua_thread_state{actualthread}){}thread(lua_State*L,sol::this_stateactualthread):thread(L,lua_thread_state{actualthread.L}){}thread(lua_State*L,lua_thread_stateactualthread):reference(L,-stack::push(L,actualthread)){#ifdef SOL_CHECK_ARGUMENTStype_assert(L,-1,type::thread);#endif // Safetylua_pop(L,1);}state_viewstate()const{returnstate_view(this->thread_state());}boolis_main_thread()const{intismainthread=lua_pushthread(this->thread_state());lua_pop(this->thread_state(),1);returnismainthread==1;}lua_State*thread_state()const{autopp=stack::push_pop(*this);lua_State*lthread=lua_tothread(lua_state(),-1);returnlthread;}thread_statusstatus()const{lua_State*lthread=thread_state();thread_statuslstat=static_cast<thread_status>(lua_status(lthread));if(lstat!=thread_status::ok&&lua_gettop(lthread)==0){// No thing on the thread's stack means its deadreturnthread_status::dead;}returnlstat;}threadcreate(){returncreate(lua_state());}staticthreadcreate(lua_State*L){lua_newthread(L);threadresult(L);lua_pop(L,1);returnresult;}};}// sol// end of sol/thread.hppnamespacesol{classcoroutine:publicreference{private:call_statusstats=call_status::yielded;voidluacall(std::ptrdiff_targcount,std::ptrdiff_t){#if SOL_LUA_VERSION < 502stats=static_cast<call_status>(lua_resume(lua_state(),static_cast<int>(argcount)));#elsestats=static_cast<call_status>(lua_resume(lua_state(),nullptr,static_cast<int>(argcount)));#endif // Lua 5.1 compat}template<std::size_t...I,typename...Ret>autoinvoke(types<Ret...>,std::index_sequence<I...>,std::ptrdiff_tn){luacall(n,sizeof...(Ret));returnstack::pop<std::tuple<Ret...>>(lua_state());}template<std::size_tI,typenameRet>Retinvoke(types<Ret>,std::index_sequence<I>,std::ptrdiff_tn){luacall(n,1);returnstack::pop<Ret>(lua_state());}template<std::size_tI>voidinvoke(types<void>,std::index_sequence<I>,std::ptrdiff_tn){luacall(n,0);}protected_function_resultinvoke(types<>,std::index_sequence<>,std::ptrdiff_tn){intstacksize=lua_gettop(lua_state());intfirstreturn=(std::max)(1,stacksize-static_cast<int>(n));luacall(n,LUA_MULTRET);intpoststacksize=lua_gettop(lua_state());intreturncount=poststacksize-(firstreturn-1);if(error()){returnprotected_function_result(lua_state(),lua_absindex(lua_state(),-1),1,returncount,status());}returnprotected_function_result(lua_state(),firstreturn,returncount,returncount,status());}public:coroutine()noexcept=default;coroutine(constcoroutine&)noexcept=default;coroutine(coroutine&&)noexcept=default;coroutine&operator=(constcoroutine&)noexcept=default;coroutine&operator=(coroutine&&)noexcept=default;template<typenameT,meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>,coroutine>>,std::is_base_of<reference,meta::unqualified_t<T>>>=meta::enabler>coroutine(T&&r):reference(std::forward<T>(r)){}coroutine(lua_nil_tr):reference(r){}coroutine(conststack_reference&r)noexcept:coroutine(r.lua_state(),r.stack_index()){}coroutine(stack_reference&&r)noexcept:coroutine(r.lua_state(),r.stack_index()){}template<typenameT,meta::enable<meta::neg<std::is_integral<meta::unqualified_t<T>>>,meta::neg<std::is_same<T,ref_index>>>=meta::enabler>coroutine(lua_State*L,T&&r):coroutine(L,sol::ref_index(r.registry_index())){}coroutine(lua_State*L,intindex=-1):reference(L,index){#ifdef SOL_CHECK_ARGUMENTSstack::check<coroutine>(L,index,type_panic);#endif // Safety}coroutine(lua_State*L,ref_indexindex):reference(L,index){#ifdef SOL_CHECK_ARGUMENTSautopp=stack::push_pop(*this);stack::check<coroutine>(L,-1,type_panic);#endif // Safety}call_statusstatus()constnoexcept{returnstats;}boolerror()constnoexcept{call_statuscs=status();returncs!=call_status::ok&&cs!=call_status::yielded;}boolrunnable()constnoexcept{returnvalid()&&(status()==call_status::yielded);}explicitoperatorbool()constnoexcept{returnrunnable();}template<typename...Args>protected_function_resultoperator()(Args&&...args){returncall<>(std::forward<Args>(args)...);}template<typename...Ret,typename...Args>decltype(auto)operator()(types<Ret...>,Args&&...args){returncall<Ret...>(std::forward<Args>(args)...);}template<typename...Ret,typename...Args>decltype(auto)call(Args&&...args){push();intpushcount=stack::multi_push(lua_state(),std::forward<Args>(args)...);returninvoke(types<Ret...>(),std::make_index_sequence<sizeof...(Ret)>(),pushcount);}};}// sol// end of sol/coroutine.hpp#ifdef __GNUC__#pragma GCC diagnostic pop#elif defined _MSC_VER#pragma warning( push )#endif // g++#ifdef SOL_INSIDE_UNREAL#ifdef SOL_INSIDE_UNREAL_REMOVED_CHECK#define check(expr) { if(UNLIKELY(!(expr))) { FDebug::LogAssertFailedMessage( #expr, __FILE__, __LINE__ ); _DebugBreakAndPromptForRemote(); FDebug::AssertFailed( #expr, __FILE__, __LINE__ ); CA_ASSUME(false); } }}#endif #endif // Unreal Engine 4 Bullshit#endif // SOL_HPP// end of sol.hpp#endif // SOL_SINGLE_INCLUDE_HPP