summaryrefslogtreecommitdiffstatshomepage
path: root/3rdparty/sol2/sol/types.hpp
diff options
context:
space:
mode:
Diffstat (limited to '3rdparty/sol2/sol/types.hpp')
-rw-r--r--3rdparty/sol2/sol/types.hpp806
1 files changed, 0 insertions, 806 deletions
diff --git a/3rdparty/sol2/sol/types.hpp b/3rdparty/sol2/sol/types.hpp
deleted file mode 100644
index ca349a56d19..00000000000
--- a/3rdparty/sol2/sol/types.hpp
+++ /dev/null
@@ -1,806 +0,0 @@
-// 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.
-
-#ifndef SOL_TYPES_HPP
-#define SOL_TYPES_HPP
-
-#include "optional.hpp"
-#include "compatibility.hpp"
-#include "traits.hpp"
-#include "string_shim.hpp"
-#include <array>
-#include <string>
-
-namespace sol {
- namespace detail {
-#ifdef SOL_NO_EXCEPTIONS
- template <lua_CFunction f>
- int static_trampoline(lua_State* L) {
- return f(L);
- }
-
- template <typename Fx, typename... Args>
- int trampoline(lua_State* L, Fx&& f, Args&&... args) {
- return f(L, std::forward<Args>(args)...);
- }
-
- inline int c_trampoline(lua_State* L, lua_CFunction f) {
- return trampoline(L, f);
- }
-#else
- template <lua_CFunction f>
- int static_trampoline(lua_State* L) {
- try {
- return f(L);
- }
- catch (const char *s) {
- lua_pushstring(L, s);
- }
- catch (const std::exception& e) {
- lua_pushstring(L, e.what());
- }
-#if !defined(SOL_EXCEPTIONS_SAFE_PROPAGATION)
- catch (...) {
- lua_pushstring(L, "caught (...) exception");
- }
-#endif
- return lua_error(L);
- }
-
- template <typename Fx, typename... Args>
- int trampoline(lua_State* L, Fx&& f, Args&&... args) {
- try {
- return f(L, std::forward<Args>(args)...);
- }
- catch (const char *s) {
- lua_pushstring(L, s);
- }
- catch (const std::exception& e) {
- lua_pushstring(L, e.what());
- }
-#if !defined(SOL_EXCEPTIONS_SAFE_PROPAGATION)
- catch (...) {
- lua_pushstring(L, "caught (...) exception");
- }
-#endif
- return lua_error(L);
- }
-
- inline int c_trampoline(lua_State* L, lua_CFunction f) {
- return trampoline(L, f);
- }
-#endif // Exceptions vs. No Exceptions
-
- template <typename T>
- struct unique_usertype {};
-
- template <typename T>
- struct implicit_wrapper {
- T& item;
- implicit_wrapper(T* item) : item(*item) {}
- implicit_wrapper(T& item) : item(item) {}
- operator T& () {
- return item;
- }
- operator T* () {
- return std::addressof(item);
- }
- };
- } // detail
-
- struct lua_nil_t {};
- const lua_nil_t lua_nil{};
- inline bool operator==(lua_nil_t, lua_nil_t) { return true; }
- inline bool operator!=(lua_nil_t, lua_nil_t) { return false; }
-#ifndef __OBJC__
- typedef lua_nil_t nil_t;
- const nil_t nil{};
-#endif
-
- struct metatable_key_t {};
- const metatable_key_t metatable_key = {};
-
- struct no_metatable_t {};
- const no_metatable_t no_metatable = {};
-
- typedef std::remove_pointer_t<lua_CFunction> lua_r_CFunction;
-
- template <typename T>
- struct unique_usertype_traits {
- typedef T type;
- typedef T actual_type;
- static const bool value = false;
-
- template <typename U>
- static bool is_null(U&&) {
- return false;
- }
-
- template <typename U>
- static auto get(U&& value) {
- return std::addressof(detail::deref(value));
- }
- };
-
- template <typename T>
- struct unique_usertype_traits<std::shared_ptr<T>> {
- typedef T type;
- typedef std::shared_ptr<T> actual_type;
- static const bool value = true;
-
- static bool is_null(const actual_type& p) {
- return p == nullptr;
- }
-
- static type* get(const actual_type& p) {
- return p.get();
- }
- };
-
- template <typename T, typename D>
- struct unique_usertype_traits<std::unique_ptr<T, D>> {
- typedef T type;
- typedef std::unique_ptr<T, D> actual_type;
- static const bool value = true;
-
- static bool is_null(const actual_type& p) {
- return p == nullptr;
- }
-
- static type* get(const actual_type& p) {
- return p.get();
- }
- };
-
- template <typename T>
- struct non_null {};
-
- template <typename... Args>
- struct function_sig {};
-
- struct upvalue_index {
- int index;
- upvalue_index(int idx) : index(lua_upvalueindex(idx)) {}
- operator int() const { return index; }
- };
-
- struct raw_index {
- int index;
- raw_index(int i) : index(i) {}
- operator int() const { return index; }
- };
-
- struct absolute_index {
- int index;
- absolute_index(lua_State* L, int idx) : index(lua_absindex(L, idx)) {}
- operator int() const { return index; }
- };
-
- struct ref_index {
- int index;
- ref_index(int idx) : index(idx) {}
- operator int() const { return index; }
- };
-
- struct lightuserdata_value {
- void* value;
- lightuserdata_value(void* data) : value(data) {}
- operator void*() const { return value; }
- };
-
- struct userdata_value {
- void* value;
- userdata_value(void* data) : value(data) {}
- operator void*() const { return value; }
- };
-
- template <typename L>
- struct light {
- L* value;
-
- light(L& x) : value(std::addressof(x)) {}
- light(L* x) : value(x) {}
- light(void* x) : value(static_cast<L*>(x)) {}
- operator L* () const { return value; }
- operator L& () const { return *value; }
- };
-
- template <typename T>
- auto make_light(T& l) {
- typedef meta::unwrapped_t<std::remove_pointer_t<std::remove_pointer_t<T>>> L;
- return light<L>(l);
- }
-
- template <typename U>
- struct user {
- U value;
-
- user(U x) : value(std::move(x)) {}
- operator U* () { return std::addressof(value); }
- operator U& () { return value; }
- operator const U& () const { return value; }
- };
-
- template <typename T>
- auto make_user(T&& u) {
- typedef meta::unwrapped_t<meta::unqualified_t<T>> U;
- return user<U>(std::forward<T>(u));
- }
-
- template <typename T>
- struct metatable_registry_key {
- T key;
-
- metatable_registry_key(T key) : key(std::forward<T>(key)) {}
- };
-
- template <typename T>
- auto meta_registry_key(T&& key) {
- typedef meta::unqualified_t<T> K;
- return metatable_registry_key<K>(std::forward<T>(key));
- }
-
- template <typename... Upvalues>
- struct closure {
- lua_CFunction c_function;
- std::tuple<Upvalues...> upvalues;
- closure(lua_CFunction f, Upvalues... targetupvalues) : c_function(f), upvalues(std::forward<Upvalues>(targetupvalues)...) {}
- };
-
- template <>
- struct closure<> {
- lua_CFunction c_function;
- int upvalues;
- closure(lua_CFunction f, int upvalue_count = 0) : c_function(f), upvalues(upvalue_count) {}
- };
-
- typedef closure<> c_closure;
-
- template <typename... Args>
- closure<Args...> make_closure(lua_CFunction f, Args&&... args) {
- return closure<Args...>(f, std::forward<Args>(args)...);
- }
-
- template <typename Sig, typename... Ps>
- struct function_arguments {
- std::tuple<Ps...> arguments;
- template <typename Arg, 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 <typename Sig = function_sig<>, typename... Args>
- auto as_function(Args&&... args) {
- return function_arguments<Sig, std::decay_t<Args>...>(std::forward<Args>(args)...);
- }
-
- template <typename Sig = function_sig<>, typename... Args>
- auto as_function_reference(Args&&... args) {
- return function_arguments<Sig, Args...>(std::forward<Args>(args)...);
- }
-
- template <typename T>
- struct as_table_t {
- T source;
- template <typename... Args>
- as_table_t(Args&&... args) : source(std::forward<Args>(args)...) {}
-
- operator std::add_lvalue_reference_t<T> () {
- return source;
- }
- };
-
- template <typename T>
- as_table_t<T> as_table(T&& container) {
- return as_table_t<T>(std::forward<T>(container));
- }
-
- struct this_state {
- lua_State* L;
- operator lua_State* () const {
- return L;
- }
- lua_State* operator-> () const {
- return L;
- }
- };
-
- enum class call_syntax {
- dot = 0,
- colon = 1
- };
-
- enum class call_status : int {
- ok = LUA_OK,
- yielded = LUA_YIELD,
- runtime = LUA_ERRRUN,
- memory = LUA_ERRMEM,
- handler = LUA_ERRERR,
- gc = LUA_ERRGCMM
- };
-
- enum class thread_status : int {
- ok = LUA_OK,
- yielded = LUA_YIELD,
- runtime = LUA_ERRRUN,
- memory = LUA_ERRMEM,
- gc = LUA_ERRGCMM,
- handler = LUA_ERRERR,
- dead = -1,
- };
-
- enum class load_status : int {
- ok = LUA_OK,
- syntax = LUA_ERRSYNTAX,
- memory = LUA_ERRMEM,
- gc = LUA_ERRGCMM,
- file = LUA_ERRFILE,
- };
-
- enum class type : int {
- none = LUA_TNONE,
- lua_nil = LUA_TNIL,
-#ifndef __OBJC__
- nil = lua_nil,
-#endif // Objective C++ Keyword
- string = 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
- };
-
- enum class meta_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
- };
-
- typedef meta_function meta_method;
-
- const std::array<std::string, 2> meta_variable_names = { {
- "__index",
- "__newindex",
- } };
-
- const std::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"
- } };
-
- inline const std::string& name_of(meta_function mf) {
- return meta_function_names[static_cast<int>(mf)];
- }
-
- inline type type_of(lua_State* L, int index) {
- return static_cast<type>(lua_type(L, index));
- }
-
- inline int type_panic(lua_State* L, int index, type expected, type actual) {
- return luaL_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 wrong
- inline int no_panic(lua_State*, int, type, type) noexcept {
- return 0;
- }
-
- inline void type_error(lua_State* L, int expected, int actual) {
- luaL_error(L, "expected %s, received %s", lua_typename(L, expected), lua_typename(L, actual));
- }
-
- inline void type_error(lua_State* L, type expected, type actual) {
- type_error(L, static_cast<int>(expected), static_cast<int>(actual));
- }
-
- inline void type_assert(lua_State* L, int index, type expected, type actual) {
- if (expected != type::poly && expected != actual) {
- type_panic(L, index, expected, actual);
- }
- }
-
- inline void type_assert(lua_State* L, int index, type expected) {
- type actual = type_of(L, index);
- type_assert(L, index, expected, actual);
- }
-
- inline std::string type_name(lua_State* L, type t) {
- return lua_typename(L, static_cast<int>(t));
- }
-
- class reference;
- class stack_reference;
- template <typename Table, typename Key>
- struct proxy;
- template<typename T>
- class usertype;
- template <bool, typename T>
- class basic_table_core;
- template <bool b>
- using table_core = basic_table_core<b, reference>;
- template <bool b>
- using stack_table_core = basic_table_core<b, stack_reference>;
- typedef table_core<false> table;
- typedef table_core<true> global_table;
- typedef stack_table_core<false> stack_table;
- typedef stack_table_core<true> stack_global_table;
- template <typename T>
- class basic_function;
- template <typename T>
- class basic_protected_function;
- using function = basic_function<reference>;
- using protected_function = basic_protected_function<reference>;
- using stack_function = basic_function<stack_reference>;
- using stack_protected_function = basic_protected_function<stack_reference>;
- template <typename base_t>
- class basic_object;
- template <typename base_t>
- class basic_userdata;
- template <typename base_t>
- class basic_lightuserdata;
- struct variadic_args;
- using object = basic_object<reference>;
- using stack_object = basic_object<stack_reference>;
- using userdata = basic_userdata<reference>;
- using stack_userdata = basic_userdata<stack_reference>;
- using lightuserdata = basic_lightuserdata<reference>;
- using stack_lightuserdata = basic_lightuserdata<stack_reference>;
- class coroutine;
- class thread;
- struct variadic_args;
- struct this_state;
-
- namespace detail {
- template <typename T, typename = void>
- struct lua_type_of : std::integral_constant<type, type::userdata> {};
-
- template <>
- struct lua_type_of<std::string> : std::integral_constant<type, type::string> {};
-
- template <>
- struct lua_type_of<std::wstring> : std::integral_constant<type, type::string> {};
-
- template <>
- struct lua_type_of<std::u16string> : std::integral_constant<type, type::string> {};
-
- template <>
- struct lua_type_of<std::u32string> : std::integral_constant<type, type::string> {};
-
- template <std::size_t N>
- struct lua_type_of<char[N]> : std::integral_constant<type, type::string> {};
-
- template <std::size_t N>
- struct lua_type_of<wchar_t[N]> : std::integral_constant<type, type::string> {};
-
- template <std::size_t N>
- struct lua_type_of<char16_t[N]> : std::integral_constant<type, type::string> {};
-
- template <std::size_t N>
- struct lua_type_of<char32_t[N]> : std::integral_constant<type, type::string> {};
-
- template <>
- struct lua_type_of<char> : std::integral_constant<type, type::string> {};
-
- template <>
- struct lua_type_of<wchar_t> : std::integral_constant<type, type::string> {};
-
- template <>
- struct lua_type_of<char16_t> : std::integral_constant<type, type::string> {};
-
- template <>
- struct lua_type_of<char32_t> : std::integral_constant<type, type::string> {};
-
- template <>
- struct lua_type_of<const char*> : std::integral_constant<type, type::string> {};
-
- template <>
- struct lua_type_of<const char16_t*> : std::integral_constant<type, type::string> {};
-
- template <>
- struct lua_type_of<const char32_t*> : std::integral_constant<type, type::string> {};
-
- template <>
- struct lua_type_of<string_detail::string_shim> : std::integral_constant<type, type::string> {};
-
- template <>
- struct lua_type_of<bool> : std::integral_constant<type, type::boolean> {};
-
- template <>
- struct lua_type_of<lua_nil_t> : std::integral_constant<type, type::lua_nil> { };
-
- template <>
- struct lua_type_of<nullopt_t> : std::integral_constant<type, type::lua_nil> { };
-
- template <>
- struct lua_type_of<std::nullptr_t> : std::integral_constant<type, type::lua_nil> { };
-
- template <>
- struct lua_type_of<sol::error> : std::integral_constant<type, type::string> { };
-
- template <bool b, typename Base>
- struct lua_type_of<basic_table_core<b, Base>> : std::integral_constant<type, type::table> { };
-
- template <>
- struct lua_type_of<reference> : std::integral_constant<type, type::poly> {};
-
- template <>
- struct lua_type_of<stack_reference> : std::integral_constant<type, type::poly> {};
-
- template <typename Base>
- struct lua_type_of<basic_object<Base>> : std::integral_constant<type, type::poly> {};
-
- template <typename... Args>
- struct lua_type_of<std::tuple<Args...>> : std::integral_constant<type, type::poly> {};
-
- template <typename A, typename B>
- struct lua_type_of<std::pair<A, B>> : std::integral_constant<type, type::poly> {};
-
- template <>
- struct lua_type_of<void*> : std::integral_constant<type, type::lightuserdata> {};
-
- template <>
- struct lua_type_of<lightuserdata_value> : std::integral_constant<type, type::lightuserdata> {};
-
- template <>
- struct lua_type_of<userdata_value> : std::integral_constant<type, type::userdata> {};
-
- template <typename T>
- struct lua_type_of<light<T>> : std::integral_constant<type, type::lightuserdata> {};
-
- template <typename T>
- struct lua_type_of<user<T>> : std::integral_constant<type, type::userdata> {};
-
- template <typename Base>
- struct lua_type_of<basic_lightuserdata<Base>> : std::integral_constant<type, type::lightuserdata> {};
-
- template <typename Base>
- struct lua_type_of<basic_userdata<Base>> : std::integral_constant<type, type::userdata> {};
-
- template <>
- struct lua_type_of<lua_CFunction> : std::integral_constant<type, type::function> {};
-
- template <>
- struct lua_type_of<std::remove_pointer_t<lua_CFunction>> : std::integral_constant<type, type::function> {};
-
- template <typename Base>
- struct lua_type_of<basic_function<Base>> : std::integral_constant<type, type::function> {};
-
- template <typename Base>
- struct lua_type_of<basic_protected_function<Base>> : std::integral_constant<type, type::function> {};
-
- template <>
- struct lua_type_of<coroutine> : std::integral_constant<type, type::function> {};
-
- template <>
- struct lua_type_of<thread> : std::integral_constant<type, type::thread> {};
-
- template <typename Signature>
- struct lua_type_of<std::function<Signature>> : std::integral_constant<type, type::function> {};
-
- template <typename T>
- struct lua_type_of<optional<T>> : std::integral_constant<type, type::poly> {};
-
- template <>
- struct lua_type_of<variadic_args> : std::integral_constant<type, type::poly> {};
-
- template <>
- struct lua_type_of<this_state> : std::integral_constant<type, type::poly> {};
-
- template <>
- struct lua_type_of<type> : std::integral_constant<type, type::poly> {};
-
- template <typename T>
- struct lua_type_of<T*> : std::integral_constant<type, type::userdata> {};
-
- template <typename T>
- struct lua_type_of<T, std::enable_if_t<std::is_arithmetic<T>::value>> : std::integral_constant<type, type::number> {};
-
- template <typename T>
- struct lua_type_of<T, std::enable_if_t<std::is_enum<T>::value>> : std::integral_constant<type, type::number> {};
-
- template <typename T, typename C = void>
- struct is_container : std::false_type {};
-
- template <typename T>
- struct is_container<T, std::enable_if_t<meta::has_begin_end<meta::unqualified_t<T>>::value>> : std::true_type {};
-
- template <>
- struct lua_type_of<meta_function> : std::integral_constant<type, type::string> {};
-
- template <typename C, C v, template <typename...> class V, typename... Args>
- struct accumulate : std::integral_constant<C, v> {};
-
- template <typename C, C v, template <typename...> class V, typename T, typename... Args>
- struct accumulate<C, v, V, T, Args...> : accumulate<C, v + V<T>::value, V, Args...> {};
- } // detail
-
- template <typename T>
- struct is_unique_usertype : std::integral_constant<bool, unique_usertype_traits<T>::value> {};
-
- template <typename T>
- struct lua_type_of : detail::lua_type_of<T> {};
-
- template <typename T>
- struct lua_size : std::integral_constant<int, 1> { };
-
- template <typename A, typename B>
- struct lua_size<std::pair<A, B>> : std::integral_constant<int, lua_size<A>::value + lua_size<B>::value> { };
-
- template <typename... Args>
- struct lua_size<std::tuple<Args...>> : std::integral_constant<int, detail::accumulate<int, 0, lua_size, Args...>::value> { };
-
- template <typename T>
- struct is_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 <typename T>
- struct is_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 <typename T>
- struct is_lua_primitive<T*> : std::true_type {};
- template <typename T>
- struct is_lua_primitive<std::reference_wrapper<T>> : std::true_type { };
- template <typename T>
- struct is_lua_primitive<user<T>> : std::true_type { };
- template <typename T>
- struct is_lua_primitive<light<T>> : is_lua_primitive<T*> { };
- template <typename T>
- struct is_lua_primitive<optional<T>> : std::true_type {};
- template <>
- struct is_lua_primitive<userdata_value> : std::true_type {};
- template <>
- struct is_lua_primitive<lightuserdata_value> : std::true_type {};
- template <typename T>
- struct is_lua_primitive<non_null<T>> : is_lua_primitive<T*> {};
-
- template <typename T>
- struct is_proxy_primitive : is_lua_primitive<T> { };
-
- template <typename T>
- struct is_transparent_argument : std::false_type {};
-
- template <>
- struct is_transparent_argument<this_state> : std::true_type {};
-
- template <>
- struct is_transparent_argument<variadic_args> : std::true_type {};
-
- template <typename T>
- struct is_variadic_arguments : std::is_same<T, variadic_args> {};
-
- template <typename Signature>
- struct lua_bind_traits : meta::bind_traits<Signature> {
- private:
- typedef meta::bind_traits<Signature> base_t;
- public:
- typedef std::integral_constant<bool, meta::count_for<is_transparent_argument, typename base_t::args_list>::value != 0> runtime_variadics_t;
- static const std::size_t true_arity = base_t::arity;
- static const std::size_t arity = base_t::arity - meta::count_for<is_transparent_argument, typename base_t::args_list>::value;
- static const std::size_t true_free_arity = base_t::free_arity;
- static const std::size_t free_arity = base_t::free_arity - meta::count_for<is_transparent_argument, typename base_t::args_list>::value;
- };
-
- template <typename T>
- struct is_table : std::false_type {};
- template <bool x, typename T>
- struct is_table<basic_table_core<x, T>> : std::true_type {};
-
- template <typename T>
- struct is_function : std::false_type {};
- template <typename T>
- struct is_function<basic_function<T>> : std::true_type {};
- template <typename T>
- struct is_function<basic_protected_function<T>> : std::true_type {};
-
- template <typename T>
- struct is_lightuserdata : std::false_type {};
- template <typename T>
- struct is_lightuserdata<basic_lightuserdata<T>> : std::true_type {};
-
- template <typename T>
- struct is_userdata : std::false_type {};
- template <typename T>
- struct is_userdata<basic_userdata<T>> : std::true_type {};
-
- template <typename T>
- struct is_container : detail::is_container<T>{};
-
- template<typename T>
- inline type type_of() {
- return lua_type_of<meta::unqualified_t<T>>::value;
- }
-} // sol
-
-#endif // SOL_TYPES_HPP