sol.hpp File Reference

#include <sol/config.hpp>
#include <cstdint>
#include <utility>
#include <type_traits>
#include <string_view>
#include <tuple>
#include <cstddef>
#include <string>
#include <functional>
#include <memory>
#include <array>
#include <iterator>
#include <iosfwd>
#include <variant>
#include <lua.hpp>
#include <stddef.h>
#include <limits.h>
#include <string.h>
#include <lua.h>
#include <lauxlib.h>
#include <lualib.h>
#include <stdlib.h>
#include <ctype.h>
#include <errno.h>
#include <stdio.h>
#include <vector>
#include <stdexcept>
#include <exception>
#include <new>
#include <cstdlib>
#include <optional>
#include <initializer_list>
#include <cstring>
#include <cctype>
#include <locale>
#include <cstdio>
#include <bitset>
#include <forward_list>
#include <algorithm>
#include <sstream>
#include <cmath>
#include <cassert>
#include <limits>
#include <unordered_map>

Include dependency graph for sol.hpp:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	sol::absolute_index
struct	sol::detail::accumulate< C, v, V, Args >
struct	sol::detail::accumulate< C, v, V, T, Args... >
struct	sol::detail::accumulate_list< C, v, V, List >
struct	sol::detail::accumulate_list< C, v, V, types< Args... > >
struct	sol::call_detail::agnostic_lua_call_wrapper< F, is_index, is_variable, checked, boost, clean_stack, typename >
struct	sol::call_detail::agnostic_lua_call_wrapper< bases< Args... >, is_index, is_variable, checked, boost, clean_stack, C >
struct	sol::call_detail::agnostic_lua_call_wrapper< detail::lua_CFunction_noexcept, is_index, is_variable, checked, boost, clean_stack, C >
struct	sol::call_detail::agnostic_lua_call_wrapper< detail::no_prop, is_index, is_variable, checked, boost, clean_stack, C >
struct	sol::call_detail::agnostic_lua_call_wrapper< lua_CFunction, is_index, is_variable, checked, boost, clean_stack, C >
struct	sol::call_detail::agnostic_lua_call_wrapper< lua_CFunction_ref, is_index, is_variable, checked, boost, clean_stack, C >
struct	sol::call_detail::agnostic_lua_call_wrapper< no_construction, is_index, is_variable, checked, boost, clean_stack, C >
struct	sol::call_detail::agnostic_lua_call_wrapper< std::reference_wrapper< T >, is_index, is_variable, checked, boost, clean_stack, C >
struct	sol::call_detail::agnostic_lua_call_wrapper< var_wrapper< T >, is_index, is_variable, checked, boost, clean_stack, C >
struct	sol::meta::all< Args >
struct	sol::meta::all< T, Args... >
struct	sol::meta::all_same< T,... >
struct	sol::meta::all_same< T, U, Args... >
struct	sol::meta::meta_detail::always_true< typename >
struct	sol::meta::any< Args >
struct	sol::meta::any< T, Args... >
struct	sol::meta::any_same< T,... >
struct	sol::meta::any_same< T, U, Args... >
struct	sol::argument_handler< F >
struct	sol::argument_handler< types< R, Args... > >
struct	sol::lua_value::arr
struct	sol::as_args_t< T >
struct	sol::as_args_t< T >
struct	sol::as_container_t< T >
struct	sol::as_container_t< T >
struct	sol::as_container_t< T & >
struct	sol::detail::as_pointer_tag< T >
struct	sol::detail::as_reference_tag
struct	sol::as_returns_t< T >
struct	sol::as_table_t< T >
struct	sol::as_table_t< T >
struct	sol::detail::as_table_tag< T >
struct	sol::detail::as_unique_tag< T >
struct	sol::detail::as_value_tag< T >
struct	sol::detail::associated_nullopt< T >
struct	sol::meta::at_in_pack< I, Args >
struct	sol::meta::at_in_pack< 0, Arg, Args... >
struct	sol::meta::at_in_pack< I, Arg, Args... >
struct	sol::automagic_enrollments
class	sol::bad_optional_access
struct	sol::base< T >
struct	sol::base_list< Args >
class	sol::basic_bytecode< Allocator >
class	sol::basic_bytecode< Allocator >
struct	sol::stack::stack_detail::basic_check< expected, check_func >
class	sol::basic_coroutine< ref_t >
class	sol::basic_coroutine< ref_t >
struct	sol::basic_environment< base_type >
struct	sol::basic_environment< base_type >
class	sol::basic_function< ref_t, aligned >
class	sol::basic_function< ref_t, aligned >
class	sol::basic_lightuserdata< base_type >
class	sol::basic_lightuserdata< base_type >
struct	sol::basic_lua_table< ref_t >
struct	sol::basic_lua_table< ref_t >
class	sol::basic_metatable< base_type >
class	sol::basic_metatable< base_type >
class	sol::basic_object< base_type >
class	sol::basic_object< base_type >
class	sol::basic_object_base< ref_t >
class	sol::basic_object_base< ref_t >
class	sol::basic_protected_function< ref_t, aligned, handler_t >
class	sol::basic_protected_function< ref_t, aligned, handler_t >
class	sol::basic_reference< main_only >
class	sol::basic_reference< main_only >
class	sol::basic_table_core< top_level, ref_t >
class	sol::basic_table_core< top_level, ref_t >
class	sol::basic_table_iterator< reference_type >
class	sol::basic_thread< ref_t >
class	sol::basic_thread< ref_t >
struct	sol::meta::meta_detail::basic_traits< it_is_noexcept, has_c_variadic, T, R, Args >
class	sol::basic_userdata< base_type >
class	sol::basic_userdata< base_type >
class	sol::basic_usertype< T, base_type >
class	sol::basic_usertype< T, base_type >
struct	sol::basic_variadic_results< Al >
struct	sol::meta::bind_traits< Signature >
struct	sol::u_detail::binding< K, Fq, T >
struct	sol::u_detail::binding_base
struct	sol::u_detail::binding_data_equals
struct	sol::function_detail::c_call_matcher< Fxs >
struct	sol::function_detail::c_function_invocation
struct	sol::call_construction
struct	sol::function_detail::call_indicator
struct	sol::meta::meta_detail::callable_traits< Signature, b >
struct	sol::meta::meta_detail::callable_traits< R(T::*), true >
struct	sol::member_function_wrapper< F, R, O, FArgs >::caller
struct	sol::wrapper< F, std::enable_if_t< std::is_member_object_pointer< meta::unqualified_t< F > >::value > >::caller
struct	sol::wrapper< F, std::enable_if_t< std::is_function< std::remove_pointer_t< meta::unqualified_t< F > > >::value > >::caller
struct	sol::wrapper< F, typename >::caller
struct	sol::meta::meta_detail::is_callable< T, std::enable_if_t<!std::is_final< unqualified_t< T > >::value &&std::is_class< unqualified_t< T > >::value &&!std::is_destructible< unqualified_t< T > >::value > >::Check< U, U >
struct	sol::meta::meta_detail::is_callable< T, std::enable_if_t<!std::is_final< unqualified_t< T > >::value &&std::is_class< unqualified_t< T > >::value &&std::is_destructible< unqualified_t< T > >::value > >::Check< U, U >
struct	sol::meta::meta_detail::check_deducible_signature< F >
struct	sol::function_detail::class_indicator< T >
struct	sol::detail::clean< n >
struct	sol::closure< Upvalues >
struct	sol::closure<>
struct	sol::meta::conditional< bool >
struct	sol::meta::conditional< false >
struct	sol::detail::conjunction<... >
struct	sol::detail::conjunction< B >
struct	sol::detail::conjunction< B, Bs... >
struct	sol::constructor_handler
struct	sol::constructor_list< Args >
struct	sol::call_detail::constructor_match< T, checked, clean_stack >
struct	sol::constructor_wrapper< Functions >
struct	sol::container_detail::container_decay< T >
struct	sol::container_detail::container_decay< as_container_t< T > >
struct	sol::stack::stack_detail::copy_code_units_utf< Ch, ErCh >
struct	sol::stack::stack_detail::count_code_units_utf< Ch >
struct	sol::meta::count_for< Pred, List >
struct	sol::meta::count_for< Pred, types< Args... > >
struct	sol::meta::count_for_pack< Pred, Ts >
struct	sol::meta::count_for_to_pack< Limit, Pred, Ts >
struct	sol::meta::meta_detail::count_when_for_pack< When, Limit, I, Pred, Ts >
struct	sol::meta::count_when_for_to_pack< When, Limit, Pred, Ts >
struct	sol::create_if_nil_t
struct	sol::unicode::decoded_result< It >
struct	sol::detail::default_construct
struct	sol::detail::default_destruct
struct	sol::detail::deleter
struct	sol::detail::deprecate_type< T >
struct	sol::derive< T >
struct	sol::meta::meta_detail::is_callable< T, std::enable_if_t<!std::is_final< unqualified_t< T > >::value &&std::is_class< unqualified_t< T > >::value &&!std::is_destructible< unqualified_t< T > >::value > >::Derived
struct	sol::meta::meta_detail::is_callable< T, std::enable_if_t<!std::is_final< unqualified_t< T > >::value &&std::is_class< unqualified_t< T > >::value &&std::is_destructible< unqualified_t< T > >::value > >::Derived
struct	sol::destructor_wrapper< Function >
struct	sol::destructor_wrapper< void >
struct	sol::detail::direct_error_tag
struct	sol::detail::optional_storage_base< T, true >::dummy
struct	sol::detail::optional_storage_base< T, bool >::dummy
class	sol::dump_error
struct	sol::detail::ebco< T, tag, typename >
struct	sol::detail::ebco< T &&, tag >
struct	sol::detail::ebco< T &, tag >
struct	sol::detail::ebco< T, tag, std::enable_if_t<!std::is_reference_v< T > &&std::is_class_v< T > &&!std::is_final_v< T > > >
struct	sol::unicode::encoded_result< C >
struct	sol::env_key_t
class	sol::error
struct	sol::detail::error_result
struct	sol::meta::meta_detail::is_callable< T, std::enable_if_t<!std::is_final< unqualified_t< T > >::value &&std::is_class< unqualified_t< T > >::value &&!std::is_destructible< unqualified_t< T > >::value > >::F
struct	sol::meta::meta_detail::is_callable< T, std::enable_if_t<!std::is_final< unqualified_t< T > >::value &&std::is_class< unqualified_t< T > >::value &&std::is_destructible< unqualified_t< T > >::value > >::F
struct	sol::factory_wrapper< Functions >
struct	sol::stack::field_getter< T, global, raw, typename >
struct	sol::stack::field_getter< T, global, raw, typename >
struct	sol::stack::field_getter< std::pair< A, B >, b, raw, C >
struct	sol::stack::field_getter< std::tuple< Args... >, b, raw, C >
struct	sol::stack::field_setter< T, global, raw, typename >
struct	sol::stack::field_setter< T, global, raw, typename >
struct	sol::stack::field_setter< std::pair< A, B >, b, raw, C >
struct	sol::stack::field_setter< std::tuple< Args... >, b, raw, C >
struct	sol::meta::find_in_pack_v< V, Vs >
struct	sol::meta::find_in_pack_v< V, Vs1, Vs... >
struct	sol::function_arguments< Sig, Ps >
struct	sol::function_sig< Args >
struct	sol::function_detail::functor_function< Func, is_yielding, no_trampoline >
struct	sol::meta::meta_detail::fx_traits< Signature, b >
struct	sol::meta::meta_detail::fx_traits< R(*)(Args...) noexcept, false >
struct	sol::meta::meta_detail::fx_traits< R(*)(Args...), false >
struct	sol::meta::meta_detail::fx_traits< R(*)(Args...,...) noexcept, false >
struct	sol::meta::meta_detail::fx_traits< R(*)(Args...,...), false >
struct	sol::meta::meta_detail::fx_traits< R(Args...) noexcept, false >
struct	sol::meta::meta_detail::fx_traits< R(Args...), false >
struct	sol::meta::meta_detail::fx_traits< R(Args...,...) noexcept, false >
struct	sol::meta::meta_detail::fx_traits< R(Args...,...), false >
struct	sol::meta::meta_detail::fx_traits< R(T::*)(Args...) const &&, false >
struct	sol::meta::meta_detail::fx_traits< R(T::*)(Args...) const &&noexcept, false >
struct	sol::meta::meta_detail::fx_traits< R(T::*)(Args...) const &, false >
struct	sol::meta::meta_detail::fx_traits< R(T::*)(Args...) const &noexcept, false >
struct	sol::meta::meta_detail::fx_traits< R(T::*)(Args...) const noexcept, false >
struct	sol::meta::meta_detail::fx_traits< R(T::*)(Args...) const volatile &&, false >
struct	sol::meta::meta_detail::fx_traits< R(T::*)(Args...) const volatile &&noexcept, false >
struct	sol::meta::meta_detail::fx_traits< R(T::*)(Args...) const volatile &, false >
struct	sol::meta::meta_detail::fx_traits< R(T::*)(Args...) const volatile &noexcept, false >
struct	sol::meta::meta_detail::fx_traits< R(T::*)(Args...) const volatile noexcept, false >
struct	sol::meta::meta_detail::fx_traits< R(T::*)(Args...) const volatile, false >
struct	sol::meta::meta_detail::fx_traits< R(T::*)(Args...) const, false >
struct	sol::meta::meta_detail::fx_traits< R(T::*)(Args...) noexcept, false >
struct	sol::meta::meta_detail::fx_traits< R(T::*)(Args...)&&, false >
struct	sol::meta::meta_detail::fx_traits< R(T::*)(Args...)&&noexcept, false >
struct	sol::meta::meta_detail::fx_traits< R(T::*)(Args...)&, false >
struct	sol::meta::meta_detail::fx_traits< R(T::*)(Args...)&noexcept, false >
struct	sol::meta::meta_detail::fx_traits< R(T::*)(Args...), false >
struct	sol::meta::meta_detail::fx_traits< R(T::*)(Args...,...) const &&, false >
struct	sol::meta::meta_detail::fx_traits< R(T::*)(Args...,...) const &&noexcept, false >
struct	sol::meta::meta_detail::fx_traits< R(T::*)(Args...,...) const &, false >
struct	sol::meta::meta_detail::fx_traits< R(T::*)(Args...,...) const &noexcept, false >
struct	sol::meta::meta_detail::fx_traits< R(T::*)(Args...,...) const noexcept, false >
struct	sol::meta::meta_detail::fx_traits< R(T::*)(Args...,...) const volatile &&, false >
struct	sol::meta::meta_detail::fx_traits< R(T::*)(Args...,...) const volatile &&noexcept, false >
struct	sol::meta::meta_detail::fx_traits< R(T::*)(Args...,...) const volatile &, false >
struct	sol::meta::meta_detail::fx_traits< R(T::*)(Args...,...) const volatile &noexcept, false >
struct	sol::meta::meta_detail::fx_traits< R(T::*)(Args...,...) const volatile noexcept, false >
struct	sol::meta::meta_detail::fx_traits< R(T::*)(Args...,...) const volatile, false >
struct	sol::meta::meta_detail::fx_traits< R(T::*)(Args...,...) const, false >
struct	sol::meta::meta_detail::fx_traits< R(T::*)(Args...,...) noexcept, false >
struct	sol::meta::meta_detail::fx_traits< R(T::*)(Args...,...)&&, false >
struct	sol::meta::meta_detail::fx_traits< R(T::*)(Args...,...)&&noexcept, false >
struct	sol::meta::meta_detail::fx_traits< R(T::*)(Args...,...)&, false >
struct	sol::meta::meta_detail::fx_traits< R(T::*)(Args...,...)&noexcept, false >
struct	sol::meta::meta_detail::fx_traits< R(T::*)(Args...,...), false >
struct	sol::meta::meta_detail::fx_traits< Signature, true >
struct	sol::detail::get_is_primitive< T, bool, bool >
struct	sol::detail::get_is_primitive< T, false, true >
struct	sol::detail::get_is_primitive< T, true, false >
struct	sol::detail::get_is_primitive< T, true, true >
struct	sol::detail::global_tag
struct	sol::meta::has_begin_end< T >
struct	sol::meta::meta_detail::has_begin_end_impl
struct	sol::container_detail::has_clear_test< T >
struct	sol::meta::has_deducible_signature< F >
struct	sol::container_detail::has_empty_test< T >
struct	sol::container_detail::has_erase_after_test< T >
struct	sol::container_detail::has_erase_key_test< T >
struct	sol::container_detail::has_erase_test< T >
struct	sol::container_detail::has_find_test< T, typename >
struct	sol::container_detail::has_find_test< T, std::enable_if_t< meta::is_lookup< T >::value > >
struct	sol::meta::meta_detail::has_insert_after_test< T >
struct	sol::meta::meta_detail::has_insert_test< T >
struct	sol::detail::has_internal_marker_impl< T, typename >
struct	sol::detail::has_internal_marker_impl< T, typename void_< typename T::SOL_INTERNAL_UNSPECIALIZED_MARKER_ >::type >
struct	sol::meta::has_iterator< T >
struct	sol::meta::meta_detail::has_iterator_impl
struct	sol::meta::has_key_comp< T >
struct	sol::meta::meta_detail::has_key_comp_impl
struct	sol::meta::has_key_type< T >
struct	sol::meta::meta_detail::has_key_type_impl
struct	sol::meta::has_key_value_pair< T >
struct	sol::meta::meta_detail::has_key_value_pair_impl
struct	sol::meta::has_load_factor< T >
struct	sol::meta::meta_detail::has_load_factor_impl
struct	sol::meta::has_mapped_type< T >
struct	sol::meta::meta_detail::has_mapped_type_impl
struct	sol::meta::meta_detail::has_max_size_test< T >
struct	sol::meta::meta_detail::has_push_back_test< T >
struct	sol::meta::meta_detail::has_size_test< T >
struct	sol::meta::meta_detail::has_to_string_test< T >
struct	sol::container_detail::has_traits_add_test< T >
struct	sol::container_detail::has_traits_at_test< T >
struct	sol::container_detail::has_traits_erase_test< T >
struct	sol::container_detail::has_traits_find_test< T >
struct	sol::container_detail::has_traits_get_test< T >
struct	sol::container_detail::has_traits_index_get_test< T >
struct	sol::container_detail::has_traits_index_of_test< T >
struct	sol::container_detail::has_traits_index_set_test< T >
struct	sol::container_detail::has_traits_insert_test< T >
struct	sol::container_detail::has_traits_ipairs_test< T >
struct	sol::container_detail::has_traits_next_test< T >
struct	sol::container_detail::has_traits_pairs_test< T >
struct	sol::container_detail::has_traits_set_test< T >
struct	sol::container_detail::has_traits_size_test< T >
struct	sol::meta::has_value_type< T >
struct	sol::meta::meta_detail::has_value_type_impl
struct	std::hash<::sol::optional< T > >
struct	sol::detail::i_am_secret
struct	sol::meta::identity< T >
struct	sol::detail::implicit_wrapper< T >
struct	sol::u_detail::index_call_storage
struct	sol::meta::index_in< T, List >
struct	sol::meta::index_in< T, types< Args... > >
struct	sol::meta::index_in_pack< T, Args >
struct	sol::meta::meta_detail::index_in_pack< I, T, Args >
struct	sol::meta::meta_detail::index_in_pack< I, T, T1, Args... >
struct	sol::detail::indexed_insert
struct	sol::detail::inheritance< T >
struct	sol::detail::invoke_result_impl< F, class, Us >
struct	sol::member_function_wrapper< F, R, O, FArgs >::invoker< fx >
struct	sol::wrapper< F, std::enable_if_t< std::is_member_object_pointer< meta::unqualified_t< F > >::value > >::invoker< fx >
struct	sol::wrapper< F, std::enable_if_t< std::is_function< std::remove_pointer_t< meta::unqualified_t< F > > >::value > >::invoker< fx >
struct	sol::detail::swap_adl_tests::is_adl_swap_noexcept< T, U >
struct	sol::is_automagical< T >
struct	sol::detail::is_base_rebindable_non_void_sfinae< T, typename >
struct	sol::detail::is_base_rebindable_non_void_sfinae< T, std::enable_if_t< is_base_rebindable_v< T > > >
struct	sol::meta::meta_detail::is_callable< T, typename >
struct	sol::meta::meta_detail::is_callable< T, std::enable_if_t< std::is_final< unqualified_t< T > >::value &&std::is_class< unqualified_t< T > >::value &&std::is_same< decltype(void(&T::operator())), void >::value > >
struct	sol::meta::meta_detail::is_callable< T, std::enable_if_t<!std::is_final< unqualified_t< T > >::value &&std::is_class< unqualified_t< T > >::value &&!std::is_destructible< unqualified_t< T > >::value > >
struct	sol::meta::meta_detail::is_callable< T, std::enable_if_t<!std::is_final< unqualified_t< T > >::value &&std::is_class< unqualified_t< T > >::value &&std::is_destructible< unqualified_t< T > >::value > >
struct	sol::detail::is_constructor< T >
struct	sol::detail::is_constructor< factory_wrapper< Args... > >
struct	sol::detail::is_constructor< policy_wrapper< F, Policies... > >
struct	sol::detail::is_constructor< protect_t< T > >
struct	sol::is_container< T >
struct	sol::is_container< basic_variadic_results< Al > >
struct	sol::is_container< variadic_results >
struct	sol::detail::is_destructor< T >
struct	sol::detail::is_destructor< destructor_wrapper< Fx > >
struct	sol::meta::meta_detail::is_detected< Test, class, Args >
struct	sol::meta::meta_detail::is_detected< Test, void_t< Test< Args... > >, Args... >
struct	sol::container_detail::is_forced_container< T >
struct	sol::container_detail::is_forced_container< as_container_t< T > >
struct	sol::is_function< T >
struct	sol::is_function< basic_function< T, aligned > >
struct	sol::is_function< basic_protected_function< T, aligned, Handler > >
struct	sol::is_function_binding< T >
struct	sol::meta::is_invokable< T >
struct	sol::meta::is_invokable< Fun(Args...)>
struct	sol::meta::meta_detail::is_invokable_tester
struct	sol::is_lua_index< T >
struct	sol::is_lua_index< absolute_index >
struct	sol::is_lua_index< raw_index >
struct	sol::is_lua_index< ref_index >
struct	sol::is_lua_index< upvalue_index >
struct	sol::is_lua_primitive< T >
struct	sol::is_lua_primitive< as_table_t< T > >
struct	sol::is_lua_primitive< light< T > >
struct	sol::is_lua_primitive< lightuserdata_value >
struct	sol::is_lua_primitive< nested< T > >
struct	sol::is_lua_primitive< non_null< T > >
struct	sol::is_lua_primitive< optional< T > >
struct	sol::is_lua_primitive< protected_function_result >
struct	sol::is_lua_primitive< stack_proxy >
struct	sol::is_lua_primitive< stack_proxy_base >
struct	sol::is_lua_primitive< std::optional< T > >
struct	sol::is_lua_primitive< std::reference_wrapper< T > >
struct	sol::is_lua_primitive< T * >
struct	sol::is_lua_primitive< unsafe_function_result >
struct	sol::is_lua_primitive< user< T > >
struct	sol::is_lua_primitive< userdata_value >
struct	sol::is_lua_reference< T >
struct	sol::is_lua_reference_or_proxy< T >
struct	sol::is_main_threaded< T >
struct	sol::meta::meta_detail::is_matched_lookup_impl< T, b >
struct	sol::meta::meta_detail::is_matched_lookup_impl< T, true >
struct	sol::meta::is_member_object< T >
struct	sol::meta::is_member_object< readonly_wrapper< T > >
struct	sol::meta::is_move_only< T >
struct	sol::detail::is_non_factory_constructor< T >
struct	sol::detail::is_non_factory_constructor< constructor_wrapper< Args... > >
struct	sol::detail::is_non_factory_constructor< constructors< Args... > >
struct	sol::detail::is_non_factory_constructor< no_construction >
struct	sol::detail::is_nothrow_swappable< T, U >
struct	sol::detail::is_optional_impl< T >
struct	sol::detail::is_optional_impl< optional< T > >
struct	sol::meta::is_pair< T >
struct	sol::meta::is_pair< std::pair< T1, T2 > >
struct	sol::is_proxy_primitive< T >
struct	sol::meta::meta_detail::is_specialization_of< T, Templ >
struct	sol::meta::meta_detail::is_specialization_of< Templ< T... >, Templ >
struct	sol::detail::is_speshul< T >
struct	sol::detail::is_speshul< protected_function_result >
struct	sol::detail::is_speshul< unsafe_function_result >
struct	sol::is_stack_based< T >
struct	sol::is_stack_based< protected_function_result >
struct	sol::is_stack_based< stack_count >
struct	sol::is_stack_based< stack_proxy >
struct	sol::is_stack_based< stack_proxy_base >
struct	sol::is_stack_based< unsafe_function_result >
struct	sol::is_stack_based< variadic_args >
struct	sol::is_stack_table< T >
struct	sol::is_stack_table< basic_lua_table< T > >
struct	sol::is_stack_table< basic_table_core< x, T > >
struct	sol::detail::swap_adl_tests::is_std_swap_noexcept< T >
struct	sol::detail::swap_adl_tests::is_std_swap_noexcept< T[N]>
struct	sol::meta::is_string_of< T, CharT >
struct	sol::meta::is_string_of< std::basic_string< CharT, TraitsT, AllocT >, CharTargetT >
struct	sol::meta::is_string_view_of< T, CharT >
struct	sol::meta::is_string_view_of< std::basic_string_view< CharT, TraitsT >, CharTargetT >
struct	sol::detail::is_swappable< T, U >
struct	sol::detail::is_swappable< T[N], T[N]>
struct	sol::is_table< T >
struct	sol::is_table< basic_lua_table< T > >
struct	sol::is_table< basic_table_core< x, T > >
struct	sol::is_tieable< T >
struct	sol::is_to_stringable< T >
struct	sol::is_to_stringable< base_list< Args... > >
struct	sol::is_transparent_argument< T >
struct	sol::is_transparent_argument< this_environment >
struct	sol::is_transparent_argument< this_main_state >
struct	sol::is_transparent_argument< this_state >
struct	sol::is_transparent_argument< variadic_args >
struct	sol::is_unique_usertype< T >
struct	sol::call_detail::is_var_bind< T, typename >
struct	sol::call_detail::is_var_bind< detail::no_prop >
struct	sol::call_detail::is_var_bind< policy_wrapper< F, Policies... > >
struct	sol::call_detail::is_var_bind< property_wrapper< R, W > >
struct	sol::call_detail::is_var_bind< readonly_wrapper< T > >
struct	sol::call_detail::is_var_bind< T, std::enable_if_t< is_lua_reference_or_proxy< T >::value > >
struct	sol::call_detail::is_var_bind< T, std::enable_if_t< std::is_member_object_pointer< T >::value > >
struct	sol::call_detail::is_var_bind< var_wrapper< T > >
struct	sol::is_variable_binding< T >
struct	sol::is_variadic_arguments< T >
struct	sol::container_detail::usertype_container_default< X, std::enable_if_t< std::is_array< std::remove_pointer_t< meta::unwrap_unqualified_t< X > > >::value > >::iter
struct	sol::container_detail::usertype_container_default< X, std::enable_if_t< meta::all< is_forced_container< meta::unqualified_t< X > >, meta::has_value_type< meta::unqualified_t< container_decay_t< X > > >, meta::has_iterator< meta::unqualified_t< container_decay_t< X > > > >::value > >::iter
struct	sol::meta::iterator_tag< T, typename >
struct	sol::meta::iterator_tag< T, conditional_t< false, typename std::iterator_traits< T >::iterator_category, void > >
struct	sol::light< L >
struct	sol::light< L >
struct	sol::lightuserdata_value
struct	sol::load_result
struct	sol::lua_bind_traits< Signature >
struct	sol::call_detail::lua_call_wrapper< T, F, is_index, is_variable, checked, boost, clean_stack, typename >
struct	sol::call_detail::lua_call_wrapper< T, constructor_list< Args... >, is_index, is_variable, checked, boost, clean_stack, C >
struct	sol::call_detail::lua_call_wrapper< T, constructor_wrapper< Cxs... >, is_index, is_variable, checked, boost, clean_stack, C >
struct	sol::call_detail::lua_call_wrapper< T, destructor_wrapper< Fx >, is_index, is_variable, checked, boost, clean_stack, C >
struct	sol::call_detail::lua_call_wrapper< T, factory_wrapper< Fs... >, is_index, is_variable, checked, boost, clean_stack, C >
struct	sol::call_detail::lua_call_wrapper< T, function_arguments< Sig, P >, is_index, is_variable, checked, boost, clean_stack, C >
struct	sol::call_detail::lua_call_wrapper< T, overload_set< Fs... >, is_index, is_variable, checked, boost, clean_stack, C >
struct	sol::call_detail::lua_call_wrapper< T, policy_wrapper< F, Policies... >, is_index, is_variable, checked, boost, clean_stack, C >
struct	sol::call_detail::lua_call_wrapper< T, property_wrapper< R, W >, is_index, is_variable, checked, boost, clean_stack, C >
struct	sol::call_detail::lua_call_wrapper< T, protect_t< V >, is_index, is_variable, checked, boost, clean_stack, C >
struct	sol::call_detail::lua_call_wrapper< T, readonly_wrapper< F >, is_index, is_variable, checked, boost, clean_stack, C >
struct	sol::call_detail::lua_call_wrapper< T, yielding_t< Y >, is_index, is_variable, checked, boost, clean_stack, C >
struct	sol::lua_nil_t
struct	sol::u_detail::lua_reference_func
struct	sol::lua_size< T >
struct	sol::lua_size< std::pair< A, B > >
struct	sol::lua_size< std::tuple< Args... > >
struct	sol::lua_thread_state
struct	sol::lua_type_of< T >
struct	sol::detail::lua_type_of< T, typename >
struct	sol::detail::lua_type_of< as_table_t< T > >
struct	sol::detail::lua_type_of< basic_coroutine< Base > >
struct	sol::detail::lua_type_of< basic_environment< B > >
struct	sol::detail::lua_type_of< basic_function< Base, aligned > >
struct	sol::detail::lua_type_of< basic_lightuserdata< Base > >
struct	sol::detail::lua_type_of< basic_lua_table< Base > >
struct	sol::detail::lua_type_of< basic_metatable< Base > >
struct	sol::detail::lua_type_of< basic_object< Base > >
struct	sol::detail::lua_type_of< basic_protected_function< Base, aligned, Handler > >
struct	sol::detail::lua_type_of< basic_reference< b > >
struct	sol::detail::lua_type_of< basic_string_view< C, T > >
struct	sol::detail::lua_type_of< basic_table_core< b, Base > >
struct	sol::detail::lua_type_of< basic_thread< Base > >
struct	sol::detail::lua_type_of< basic_userdata< Base > >
struct	sol::detail::lua_type_of< basic_usertype< T, Base > >
struct	sol::detail::lua_type_of< bool >
struct	sol::detail::lua_type_of< char >
struct	sol::detail::lua_type_of< char16_t >
struct	sol::detail::lua_type_of< char16_t[N]>
struct	sol::detail::lua_type_of< char32_t >
struct	sol::detail::lua_type_of< char32_t[N]>
struct	sol::detail::lua_type_of< char[N]>
struct	sol::detail::lua_type_of< const char * >
struct	sol::detail::lua_type_of< const char16_t * >
struct	sol::detail::lua_type_of< const char32_t * >
struct	sol::detail::lua_type_of< const void * >
struct	sol::detail::lua_type_of< detail::non_lua_nil_t >
struct	sol::detail::lua_type_of< env_key_t >
struct	sol::detail::lua_type_of< error >
struct	sol::detail::lua_type_of< light< T > >
struct	sol::detail::lua_type_of< lightuserdata_value >
struct	sol::detail::lua_type_of< lua_CFunction >
struct	sol::detail::lua_type_of< lua_nil_t >
struct	sol::detail::lua_type_of< lua_value >
struct	sol::detail::lua_type_of< meta_function >
struct	sol::detail::lua_type_of< metatable_key_t >
struct	sol::detail::lua_type_of< nested< T > >
struct	sol::detail::lua_type_of< new_table >
struct	sol::detail::lua_type_of< nullopt_t >
struct	sol::detail::lua_type_of< optional< T > >
struct	sol::detail::lua_type_of< stack_count >
struct	sol::detail::lua_type_of< stack_reference >
struct	sol::detail::lua_type_of< std::basic_string< C, T, A > >
struct	sol::detail::lua_type_of< std::function< Signature > >
struct	sol::detail::lua_type_of< std::initializer_list< T > >
struct	sol::detail::lua_type_of< std::nullptr_t >
struct	sol::detail::lua_type_of< std::optional< T > >
struct	sol::detail::lua_type_of< std::pair< A, B > >
struct	sol::detail::lua_type_of< std::remove_pointer_t< lua_CFunction > >
struct	sol::detail::lua_type_of< std::tuple< Args... > >
struct	sol::detail::lua_type_of< std::variant< Tn... > >
struct	sol::detail::lua_type_of< T * >
struct	sol::detail::lua_type_of< T, std::enable_if_t< std::is_arithmetic_v< T >||std::is_same_v< T, lua_Number >||std::is_same_v< T, lua_Integer > > >
struct	sol::detail::lua_type_of< T, std::enable_if_t< std::is_enum_v< T > > >
struct	sol::detail::lua_type_of< T, std::enable_if_t< std::is_function_v< T > > >
struct	sol::detail::lua_type_of< this_environment >
struct	sol::detail::lua_type_of< this_main_state >
struct	sol::detail::lua_type_of< this_state >
struct	sol::detail::lua_type_of< type >
struct	sol::detail::lua_type_of< user< T > >
struct	sol::detail::lua_type_of< userdata_value >
struct	sol::detail::lua_type_of< variadic_args >
struct	sol::detail::lua_type_of< variadic_results >
struct	sol::detail::lua_type_of< void * >
struct	sol::detail::lua_type_of< wchar_t >
struct	sol::detail::lua_type_of< wchar_t[N]>
struct	sol::lua_value
struct	sol::function_detail::member_function< T, Function, is_yielding >
struct	sol::member_function_wrapper< F, R, O, FArgs >
struct	sol::function_detail::member_variable< T, Function, is_yielding >
struct	sol::metatable_key_t
struct	sol::metatable_registry_key< T >
struct	sol::stack::stack_detail::metatable_setup< T, is_shim >
class	sol::monostate
	Used to represent an optional with no data; essentially a bool. More...
struct	sol::meta::meta_detail::check_deducible_signature< F >::nat
struct	sol::nested< T >
struct	sol::nested< T >
struct	sol::nested_tag_t
struct	sol::u_detail::new_index_call_storage
struct	sol::new_table
struct	sol::detail::no_comp
struct	sol::no_construction
struct	sol::no_metatable_t
struct	sol::detail::no_prop
struct	sol::detail::no_safety_tag
struct	sol::detail::non_lua_nil_t
struct	sol::non_null< T >
struct	sol::call_detail::lua_call_wrapper< T, factory_wrapper< Fs... >, is_index, is_variable, checked, boost, clean_stack, C >::on_match
struct	sol::call_detail::lua_call_wrapper< T, overload_set< Fs... >, is_index, is_variable, checked, boost, clean_stack, C >::on_match
struct	sol::call_detail::lua_call_wrapper< T, constructor_wrapper< Cxs... >, is_index, is_variable, checked, boost, clean_stack, C >::onmatch
class	sol::optional< T >
class	sol::optional< T >
class	sol::optional< T >
class	sol::optional< T & >
struct	sol::detail::optional_copy_assign_base< T, bool >
struct	sol::detail::optional_copy_assign_base< T, false >
struct	sol::detail::optional_copy_base< T, bool >
struct	sol::detail::optional_copy_base< T, false >
struct	sol::detail::optional_delete_assign_base< T, EnableCopy, EnableMove >
struct	sol::detail::optional_delete_assign_base< T, false, false >
struct	sol::detail::optional_delete_assign_base< T, false, true >
struct	sol::detail::optional_delete_assign_base< T, true, false >
struct	sol::detail::optional_delete_ctor_base< T, EnableCopy, EnableMove >
struct	sol::detail::optional_delete_ctor_base< T, false, false >
struct	sol::detail::optional_delete_ctor_base< T, false, true >
struct	sol::detail::optional_delete_ctor_base< T, true, false >
struct	sol::detail::optional_move_assign_base< T, bool >
struct	sol::detail::optional_move_assign_base< T, false >
struct	sol::detail::optional_move_base< T, bool >
struct	sol::detail::optional_move_base< T, false >
struct	sol::detail::optional_operations_base< T >
struct	sol::detail::optional_storage_base< T, bool >
struct	sol::detail::optional_storage_base< T, true >
struct	sol::overload_set< Functions >
struct	sol::function_detail::overloaded_function< start_skew, Functions >
struct	sol::override_value_t
struct	sol::detail::policy_base_tag
struct	sol::policy_wrapper< F, Policies >
struct	sol::policy_wrapper< F, Policies >
struct	sol::meta::pop_front_type< Arg >
struct	sol::meta::pop_front_type< types< Arg, Args... > >
struct	sol::meta::pop_front_type< types< Args... > >
struct	sol::stack::popper< T, typename >
struct	sol::stack::popper< T, typename >
struct	sol::stack::probe
struct	sol::stack::probe_field_getter< T, P, b, raw, typename >
struct	sol::stack::probe_field_getter< T, P, b, raw, typename >
struct	sol::stack::probe_field_getter< std::pair< A, B >, P, b, raw, C >
struct	sol::stack::probe_field_getter< std::tuple< Args... >, P, b, raw, C >
struct	sol::detail::properties_enrollment_allowed
struct	sol::property_wrapper< R, W >
struct	sol::protect_t< T >
struct	sol::protect_t< T >
struct	sol::protected_function_result
struct	sol::detail::protected_handler< b, target_t >
struct	sol::proxy_base< Super >
struct	sol::proxy_base< Super >
struct	sol::proxy_base_tag
struct	sol::stack::stack_detail::push_function
struct	sol::push_invoke_t< T >
struct	sol::push_invoke_t< T & >
struct	sol::stack::push_popper< bool, T, typename >
struct	sol::stack::push_popper< false, T, std::enable_if_t< is_stack_based_v< meta::unqualified_t< T > > > >
struct	sol::stack::push_popper< true, T, C >
struct	sol::stack::push_popper_at
struct	sol::stack::push_popper_n< top_level >
struct	sol::stack::push_popper_n< true >
struct	sol::stack::qualified_check_getter< T, C >
struct	sol::stack::qualified_check_getter< T, C >
struct	sol::stack::qualified_checker< X, expected, typename >
struct	sol::stack::qualified_checker< X, expected, typename >
struct	sol::stack::qualified_getter< X, typename >
struct	sol::stack::qualified_getter< X, typename >
struct	sol::stack::qualified_getter< T, std::enable_if_t< meta::is_optional_v< T > > >
struct	sol::stack::qualified_interop_checker< T, typename >
struct	sol::stack::qualified_interop_getter< T, typename >
struct	sol::raw_index
struct	sol::readonly_wrapper< T >
struct	sol::stack::record
struct	sol::detail::ref_clean
struct	sol::ref_index
struct	sol::reference_equals
struct	sol::reference_hash
struct	sol::meta::remove_member_pointer< T >
struct	sol::meta::remove_member_pointer< R T::* >
struct	sol::meta::remove_member_pointer< R T::*const >
struct	sol::meta::return_type< Args >
struct	sol::meta::return_type< T >
struct	sol::meta::return_type<>
struct	sol::returns_self_with< In >
struct	sol::detail::returns_void_impl< F, class, U >
struct	sol::detail::returns_void_impl< F, void_t< invoke_result_t< F, U... > >, U... >
struct	sol::stack_count
struct	sol::stack_dependencies
struct	sol::stack_guard
struct	sol::stack_iterator< proxy_t, is_const >
struct	sol::stack_proxy
struct	sol::stack_proxy_base
class	sol::stack_reference
struct	sol::stack_reference_equals
struct	sol::stack_reference_hash
class	sol::state
struct	sol::detail::state_deleter
class	sol::state_view
class	sol::stateless_reference
class	sol::stateless_stack_reference
struct	sol::static_stack_dependencies< Target, In >
struct	sol::detail::std_shim< R >
struct	sol::detail::std_shim< void >
struct	sol::u_detail::string_for_each_metatable_func
struct	sol::stack::stack_detail::strip< T >
struct	sol::stack::stack_detail::strip< non_null< T > >
struct	sol::stack::stack_detail::strip< std::reference_wrapper< T > >
struct	sol::stack::stack_detail::strip< user< T > >
class	sol::meta::supports_adl_to_string< T >
class	sol::meta::meta_detail::supports_adl_to_string_test< T, U >
class	sol::meta::meta_detail::supports_adl_to_string_test< T, void_t< decltype(to_string(std::declval< const T & >()))>
class	sol::meta::supports_op_equal< T, U >
class	sol::meta::meta_detail::supports_op_equal_test< T, U, typename >
class	sol::meta::supports_op_left_shift< T, U >
class	sol::meta::meta_detail::supports_op_left_shift_test< T, U, typename >
class	sol::meta::supports_op_less< T, U >
class	sol::meta::supports_op_less_equal< T, U >
class	sol::meta::meta_detail::supports_op_less_equal_test< T, U, typename >
class	sol::meta::meta_detail::supports_op_less_test< T, U, typename >
class	sol::meta::supports_to_string_member< T >
struct	sol::table_proxy< Table, Key >
struct	sol::table_proxy< Table, Key >
struct	sol::detail::swap_adl_tests::tag
struct	sol::detail::tagged< Tag, T >
struct	sol::this_environment
struct	sol::this_main_state
struct	sol::this_state
struct	sol::tie_size< T >
struct	sol::tie_size< protected_function_result >
struct	sol::tie_size< tie_t< Tn... > >
struct	sol::tie_size< unsafe_function_result >
struct	sol::tie_t< Tn >
struct	sol::meta::detail::tuple_types_< Args >
struct	sol::meta::detail::tuple_types_< std::tuple< Args... > >
struct	sol::type_panic_t
struct	sol::types< Args >
struct	sol::container_detail::u_c_launch< X >
struct	sol::detail::unchecked_t
struct	sol::stack::stack_detail::undefined_metatable
struct	sol::unicode::unicode_detail
struct	sol::detail::unique_usertype< T >
struct	sol::unique_usertype_traits< T >
struct	sol::unique_usertype_traits< T >
struct	sol::unique_usertype_traits< std::shared_ptr< T > >
struct	sol::unique_usertype_traits< std::unique_ptr< T, D > >
struct	sol::stack::unqualified_check_getter< T, typename >
struct	sol::stack::unqualified_check_getter< T, typename >
struct	sol::stack::unqualified_check_getter< lua_thread_state >
struct	sol::stack::unqualified_check_getter< std::variant< Tn... >, C >
struct	sol::stack::unqualified_checker< T, expected, typename >
struct	sol::stack::unqualified_checker< T, expected, typename >
struct	sol::stack::unqualified_checker< detail::as_pointer_tag< T >, type::userdata >
struct	sol::stack::unqualified_checker< detail::as_value_tag< T >, type::userdata >
struct	sol::stack::unqualified_checker< non_null< T >, type::userdata >
struct	sol::stack::unqualified_checker< std::pair< A, B >, type::poly >
struct	sol::stack::unqualified_checker< std::tuple< Args... >, type::poly >
struct	sol::stack::unqualified_checker< std::variant< Tn... >, type::poly >
struct	sol::stack::unqualified_getter< T, typename >
struct	sol::stack::unqualified_getter< T, typename >
struct	sol::stack::unqualified_getter< as_container_t< T > * >
struct	sol::stack::unqualified_getter< as_container_t< T > >
struct	sol::stack::unqualified_getter< as_table_t< std::forward_list< T, Al > > >
struct	sol::stack::unqualified_getter< as_table_t< T > >
struct	sol::stack::unqualified_getter< basic_bytecode< Allocator > >
struct	sol::stack::unqualified_getter< basic_string_view< char, Traits > >
struct	sol::stack::unqualified_getter< c_closure >
struct	sol::stack::unqualified_getter< char >
struct	sol::stack::unqualified_getter< char16_t >
struct	sol::stack::unqualified_getter< char32_t >
struct	sol::stack::unqualified_getter< const char * >
struct	sol::stack::unqualified_getter< const void * >
struct	sol::stack::unqualified_getter< detail::as_pointer_tag< T > >
struct	sol::stack::unqualified_getter< detail::as_value_tag< T > >
struct	sol::stack::unqualified_getter< env_key_t >
struct	sol::stack::unqualified_getter< error >
struct	sol::stack::unqualified_getter< light< T > >
struct	sol::stack::unqualified_getter< lightuserdata_value >
struct	sol::stack::unqualified_getter< lua_CFunction >
struct	sol::stack::unqualified_getter< lua_nil_t >
struct	sol::stack::unqualified_getter< lua_thread_state >
struct	sol::stack::unqualified_getter< lua_value >
struct	sol::stack::unqualified_getter< meta_function >
struct	sol::stack::unqualified_getter< metatable_key_t >
struct	sol::stack::unqualified_getter< nested< T > >
struct	sol::stack::unqualified_getter< non_null< T * > >
struct	sol::stack::unqualified_getter< nullopt_t >
struct	sol::stack::unqualified_getter< stack_proxy >
struct	sol::stack::unqualified_getter< stack_proxy_base >
struct	sol::stack::unqualified_getter< std::basic_string< char16_t, Traits, Al > >
struct	sol::stack::unqualified_getter< std::basic_string< char32_t, Traits, Al > >
struct	sol::stack::unqualified_getter< std::basic_string< wchar_t, Traits, Al > >
struct	sol::stack::unqualified_getter< std::function< Signature > >
struct	sol::stack::unqualified_getter< std::nullptr_t >
struct	sol::stack::unqualified_getter< std::pair< A, B > >
struct	sol::stack::unqualified_getter< std::reference_wrapper< T > >
struct	sol::stack::unqualified_getter< std::string >
struct	sol::stack::unqualified_getter< std::tuple< Tn... > >
struct	sol::stack::unqualified_getter< std::variant< Tn... > >
struct	sol::stack::unqualified_getter< T & >
struct	sol::stack::unqualified_getter< T * >
struct	sol::stack::unqualified_getter< this_environment >
struct	sol::stack::unqualified_getter< this_main_state >
struct	sol::stack::unqualified_getter< this_state >
struct	sol::stack::unqualified_getter< type >
struct	sol::stack::unqualified_getter< user< T * > >
struct	sol::stack::unqualified_getter< user< T > >
struct	sol::stack::unqualified_getter< userdata_value >
struct	sol::stack::unqualified_getter< variadic_args >
struct	sol::stack::unqualified_getter< void * >
struct	sol::stack::unqualified_getter< wchar_t >
struct	sol::stack::unqualified_interop_checker< T, typename >
struct	sol::stack::unqualified_interop_getter< T, typename >
struct	sol::meta::meta_detail::unqualified_non_alias< T >
struct	sol::stack::unqualified_pusher< T, typename >
struct	sol::stack::unqualified_pusher< T, typename >
struct	sol::stack::unqualified_pusher< absolute_index >
struct	sol::stack::unqualified_pusher< as_args_t< T > >
struct	sol::stack::unqualified_pusher< as_container_t< T * > >
struct	sol::stack::unqualified_pusher< as_container_t< T > >
struct	sol::stack::unqualified_pusher< as_returns_t< T > >
struct	sol::stack::unqualified_pusher< as_table_t< T > >
struct	sol::stack::unqualified_pusher< basic_bytecode< Allocator > >
struct	sol::stack::unqualified_pusher< basic_string_view< Ch, Traits > >
struct	sol::stack::unqualified_pusher< basic_variadic_results< Al > >
struct	sol::stack::unqualified_pusher< c_closure >
struct	sol::stack::unqualified_pusher< char * >
struct	sol::stack::unqualified_pusher< char >
struct	sol::stack::unqualified_pusher< char16_t * >
struct	sol::stack::unqualified_pusher< char16_t >
struct	sol::stack::unqualified_pusher< char16_t[N]>
struct	sol::stack::unqualified_pusher< char32_t * >
struct	sol::stack::unqualified_pusher< char32_t >
struct	sol::stack::unqualified_pusher< char32_t[N]>
struct	sol::stack::unqualified_pusher< char[N]>
struct	sol::stack::unqualified_pusher< closure< Arg, Args... > >
struct	sol::stack::unqualified_pusher< const char * >
struct	sol::stack::unqualified_pusher< const char16_t * >
struct	sol::stack::unqualified_pusher< const char32_t * >
struct	sol::stack::unqualified_pusher< const void * >
struct	sol::stack::unqualified_pusher< const wchar_t * >
struct	sol::stack::unqualified_pusher< constructor_list< L0, Lists... > >
struct	sol::stack::unqualified_pusher< constructor_wrapper< F, Fxs... > >
struct	sol::stack::unqualified_pusher< destructor_wrapper< Fx > >
struct	sol::stack::unqualified_pusher< detail::as_pointer_tag< T > >
struct	sol::stack::unqualified_pusher< detail::as_reference_tag >
struct	sol::stack::unqualified_pusher< detail::as_table_tag< T > >
struct	sol::stack::unqualified_pusher< detail::as_unique_tag< T > >
struct	sol::stack::unqualified_pusher< detail::as_value_tag< T > >
struct	sol::stack::unqualified_pusher< detail::lua_CFunction_noexcept >
struct	sol::stack::unqualified_pusher< detail::tagged< T, constructor_list< Lists... > > >
struct	sol::stack::unqualified_pusher< detail::tagged< T, constructor_wrapper< Fxs... > > >
struct	sol::stack::unqualified_pusher< detail::tagged< T, destructor_wrapper< Fx > > >
struct	sol::stack::unqualified_pusher< detail::tagged< T, destructor_wrapper< void > > >
struct	sol::stack::unqualified_pusher< detail::tagged< T, no_construction > >
struct	sol::stack::unqualified_pusher< detail::tagged< T, policy_wrapper< F, Policies... > > >
struct	sol::stack::unqualified_pusher< factory_wrapper< Functions... > >
struct	sol::stack::unqualified_pusher< function_arguments< T, Args... > >
struct	sol::stack::unqualified_pusher< function_sig< Sigs... > >
struct	sol::stack::unqualified_pusher< light< T > >
struct	sol::stack::unqualified_pusher< lightuserdata_value >
struct	sol::stack::unqualified_pusher< lua_CFunction >
struct	sol::stack::unqualified_pusher< lua_nil_t >
struct	sol::stack::unqualified_pusher< lua_thread_state >
struct	sol::stack::unqualified_pusher< lua_value >
struct	sol::stack::unqualified_pusher< meta_function >
struct	sol::stack::unqualified_pusher< metatable_key_t >
struct	sol::stack::unqualified_pusher< nested< T > >
struct	sol::stack::unqualified_pusher< new_table >
struct	sol::stack::unqualified_pusher< no_construction >
struct	sol::stack::unqualified_pusher< nullopt_t >
struct	sol::stack::unqualified_pusher< overload_set< Functions... > >
struct	sol::stack::unqualified_pusher< policy_wrapper< F, Policies... > >
struct	sol::stack::unqualified_pusher< property_wrapper< F, G > >
struct	sol::stack::unqualified_pusher< protect_t< T > >
struct	sol::stack::unqualified_pusher< protected_function_result >
struct	sol::stack::unqualified_pusher< push_invoke_t< T > >
struct	sol::stack::unqualified_pusher< raw_index >
struct	sol::stack::unqualified_pusher< ref_index >
struct	sol::stack::unqualified_pusher< Signature, std::enable_if_t< meta::all< std::is_function< std::remove_pointer_t< Signature > >, meta::neg< std::is_same< Signature, lua_CFunction > >, meta::neg< std::is_same< Signature, std::remove_pointer_t< lua_CFunction > > >, meta::neg< std::is_same< Signature, detail::lua_CFunction_noexcept > >, meta::neg< std::is_same< Signature, std::remove_pointer_t< detail::lua_CFunction_noexcept > > > >::value > >
struct	sol::stack::unqualified_pusher< Signature, std::enable_if_t< std::is_member_pointer< Signature >::value > >
struct	sol::stack::unqualified_pusher< stack_count >
struct	sol::stack::unqualified_pusher< stack_proxy >
struct	sol::stack::unqualified_pusher< stack_proxy_base >
struct	sol::stack::unqualified_pusher< std::basic_string< Ch, Traits, Al > >
struct	sol::stack::unqualified_pusher< std::function< Signature > >
struct	sol::stack::unqualified_pusher< std::initializer_list< T > >
struct	sol::stack::unqualified_pusher< std::nullptr_t >
struct	sol::stack::unqualified_pusher< std::pair< A, B > >
struct	sol::stack::unqualified_pusher< std::reference_wrapper< T > >
struct	sol::stack::unqualified_pusher< std::remove_pointer_t< detail::lua_CFunction_noexcept > >
struct	sol::stack::unqualified_pusher< std::remove_pointer_t< lua_CFunction > >
struct	sol::stack::unqualified_pusher< std::tuple< Args... > >
struct	sol::stack::unqualified_pusher< std::variant< Tn... > >
struct	sol::stack::unqualified_pusher< T *, std::enable_if_t< is_container_v< T > > >
struct	sol::stack::unqualified_pusher< T, std::enable_if_t< is_container_v< T > > >
struct	sol::stack::unqualified_pusher< T, std::enable_if_t< meta::is_optional_v< T > > >
struct	sol::stack::unqualified_pusher< table_proxy< Table, Key > >
struct	sol::stack::unqualified_pusher< this_main_state >
struct	sol::stack::unqualified_pusher< this_state >
struct	sol::stack::unqualified_pusher< unsafe_function_result >
struct	sol::stack::unqualified_pusher< user< T > >
struct	sol::stack::unqualified_pusher< userdata_value >
struct	sol::stack::unqualified_pusher< var_wrapper< T > >
struct	sol::stack::unqualified_pusher< variadic_args >
struct	sol::stack::unqualified_pusher< variadic_results >
struct	sol::stack::unqualified_pusher< void * >
struct	sol::stack::unqualified_pusher< wchar_t * >
struct	sol::stack::unqualified_pusher< wchar_t >
struct	sol::stack::unqualified_pusher< wchar_t[N]>
struct	sol::stack::unqualified_pusher< yielding_t< T > >
struct	sol::unsafe_function_result
struct	sol::meta::unwrap_unqualified< T >
struct	sol::meta::unwrapped< T >
struct	sol::meta::unwrapped< std::reference_wrapper< T > >
struct	sol::u_detail::update_bases_func
struct	sol::update_if_empty_t
struct	sol::function_detail::upvalue_free_function< Function, is_yielding >
struct	sol::upvalue_index
struct	sol::function_detail::upvalue_member_function< T, Function, is_yielding >
struct	sol::function_detail::upvalue_member_variable< T, Function, is_yielding >
struct	sol::function_detail::upvalue_member_variable< T, readonly_wrapper< Function >, is_yielding >
struct	sol::function_detail::upvalue_this_member_function< T, Function, is_yielding >
struct	sol::function_detail::upvalue_this_member_variable< T, Function, is_yielding >
struct	sol::function_detail::upvalue_this_member_variable< T, readonly_wrapper< Function >, is_yielding >
struct	sol::user< U >
struct	sol::user< U >
struct	sol::userdata_value
struct	sol::usertype_container< T >
struct	sol::usertype_container< T >
struct	sol::container_detail::usertype_container_default< X, typename >
struct	sol::container_detail::usertype_container_default< usertype_container< X > >
struct	sol::container_detail::usertype_container_default< X, std::enable_if_t< meta::all< is_forced_container< meta::unqualified_t< X > >, meta::has_value_type< meta::unqualified_t< container_decay_t< X > > >, meta::has_iterator< meta::unqualified_t< container_decay_t< X > > > >::value > >
struct	sol::container_detail::usertype_container_default< X, std::enable_if_t< std::is_array< std::remove_pointer_t< meta::unwrap_unqualified_t< X > > >::value > >
struct	sol::usertype_proxy< Table, Key >
struct	sol::u_detail::usertype_storage< T >
struct	sol::u_detail::usertype_storage< T >
struct	sol::u_detail::usertype_storage_base
struct	sol::usertype_traits< T >
struct	sol::usertype_traits< T >
struct	sol::stack::stack_detail::uu_pusher< T >
struct	sol::var_wrapper< T >
struct	sol::variadic_args
struct	sol::variadic_results
struct	sol::detail::void_<... >
struct	sol::call_detail::void_call< T, List >
struct	sol::call_detail::void_call< T, types< Args... > >
struct	sol::meta::meta_detail::void_tuple_element< I, T >
struct	sol::meta::meta_detail::void_tuple_element< I, std::tuple<> >
struct	sol::detail::voider<... >
struct	sol::weak_derive< T >
struct	sol::detail::with_function_tag
struct	sol::wrap< F, f >
struct	sol::wrapper< F, typename >
struct	sol::wrapper< F, std::enable_if_t< std::is_function< std::remove_pointer_t< meta::unqualified_t< F > > >::value > >
struct	sol::wrapper< F, std::enable_if_t< std::is_member_object_pointer< meta::unqualified_t< F > >::value > >
struct	sol::wrapper< R(O::*)(Args...) const >
struct	sol::wrapper< R(O::*)(Args...) const & >
struct	sol::wrapper< R(O::*)(Args...) const && >
struct	sol::wrapper< R(O::*)(Args...) const &&noexcept >
struct	sol::wrapper< R(O::*)(Args...) const &noexcept >
struct	sol::wrapper< R(O::*)(Args...) const noexcept >
struct	sol::wrapper< R(O::*)(Args...) const volatile & >
struct	sol::wrapper< R(O::*)(Args...) const volatile && >
struct	sol::wrapper< R(O::*)(Args...) const volatile &&noexcept >
struct	sol::wrapper< R(O::*)(Args...) const volatile &noexcept >
struct	sol::wrapper< R(O::*)(Args...) const volatile >
struct	sol::wrapper< R(O::*)(Args...) const volatile noexcept >
struct	sol::wrapper< R(O::*)(Args...) noexcept >
struct	sol::wrapper< R(O::*)(Args...)& >
struct	sol::wrapper< R(O::*)(Args...)&& >
struct	sol::wrapper< R(O::*)(Args...)&&noexcept >
struct	sol::wrapper< R(O::*)(Args...)&noexcept >
struct	sol::wrapper< R(O::*)(Args...)>
struct	sol::wrapper< R(O::*)(Args...,...) const & >
struct	sol::wrapper< R(O::*)(Args...,...) const && >
struct	sol::wrapper< R(O::*)(Args...,...) const &&noexcept >
struct	sol::wrapper< R(O::*)(Args...,...) const &noexcept >
struct	sol::wrapper< R(O::*)(Args...,...) const volatile & >
struct	sol::wrapper< R(O::*)(Args...,...) const volatile && >
struct	sol::wrapper< R(O::*)(Args...,...) const volatile &&noexcept >
struct	sol::wrapper< R(O::*)(Args...,...) const volatile &noexcept >
struct	sol::wrapper< R(O::*)(Args...,...)& >
struct	sol::wrapper< R(O::*)(Args...,...)&& >
struct	sol::wrapper< R(O::*)(Args...,...)&&noexcept >
struct	sol::wrapper< R(O::*)(Args...,...)&noexcept >
struct	sol::detail::yield_tag_t
struct	sol::yielding_t< T >

Namespaces
	sol
	sol::adl_barrier_detail
	sol::call_detail
	sol::call_detail::overload_detail
	sol::container_detail
	sol::detail
	sol::detail::swap_adl_tests
	sol::function_detail
	sol::meta
	sol::meta::detail
	sol::meta::meta_detail
	sol::policy_detail
	sol::stack
	sol::stack::stack_detail
	sol::u_detail
	sol::unicode
	std

Macros
#define	COMPAT53_API   static inline
#define	COMPAT53_CONCAT(a, b)   COMPAT53_CONCAT_HELPER(a, b)
#define	COMPAT53_CONCAT_HELPER(a, b)   a##b
#define	COMPAT53_INCLUDE_SOURCE   1
#define	COMPAT53_PREFIX   kp_compat53
#define	KEPLER_PROJECT_COMPAT53_C_
#define	KEPLER_PROJECT_COMPAT53_H_
#define	LUA_KFUNCTION(_name)   static int (_name)(lua_State *L, int status, lua_KContext ctx)
#define	NOT_KEPLER_PROJECT_COMPAT54_H_
#define	SOL_ALIGN_MEMORY_I_   SOL_DEFAULT_ON
#define	SOL_ALL_SAFETIES_ON_I_   SOL_DEFAULT_OFF
#define	SOL_BASE_CLASSES(T, ...)
#define	SOL_COMPILER_CLANG_I_   SOL_OFF
#define	SOL_COMPILER_EDG_I_   SOL_OFF
#define	SOL_COMPILER_FRONTEND_MINGW_I_   SOL_OFF
#define	SOL_COMPILER_GCC_I_   SOL_OFF
#define	SOL_COMPILER_VCXX_I_   SOL_OFF
#define	SOL_CONTAINER_START_INDEX_I_   1
#define	SOL_DEBUG_BUILD_I_   SOL_OFF
#define	SOL_DEFAULT_AUTOMAGICAL_USERTYPES_I_   SOL_DEFAULT_ON
#define	SOL_DEFAULT_OFF   -
#define	SOL_DEFAULT_ON   +
#define	SOL_DEFAULT_PASS_ON_ERROR_I_   SOL_OFF
#define	SOL_DEPRECATED   [[deprecated]]
#define	SOL_DERIVED_CLASSES(T, ...)
#define	SOL_EXCEPTIONS_I_   SOL_DEFAULT_ON
#define	SOL_FILE_ID_SIZE_I_   2048
#define	SOL_FORWARD_DETAIL_HPP
#define	SOL_FORWARD_HPP
#define	SOL_GET_FUNCTION_POINTER_UNSAFE_I_   SOL_DEFAULT_OFF
#define	SOL_HPP
#define	SOL_ID_SIZE_I_   512
#define	SOL_INSIDE_UNREAL_ENGINE_I_   SOL_DEFAULT_OFF
#define	SOL_IS_DEFAULT_OFF(OP_SYMBOL)   ((3 OP_SYMBOL 3 OP_SYMBOL 3) < 0)
#define	SOL_IS_DEFAULT_ON(OP_SYMBOL)   ((3 OP_SYMBOL 3) > 3)
#define	SOL_IS_OFF(OP_SYMBOL)   ((3 OP_SYMBOL 3) == 0)
#define	SOL_IS_ON(OP_SYMBOL)   ((3 OP_SYMBOL 3) != 0)
#define	SOL_LUA_VERSION   500
#define	SOL_LUA_VESION_I_   SOL_LUA_VERSION
#define	SOL_LUAJIT_VERSION_I_   0
#define	SOL_LUAL_STREAM_USE_CLOSE_FUNCTION_I_   SOL_DEFAULT_OFF
#define	SOL_MINGW_CCTYPE_IS_POISONED_I_   SOL_DEFAULT_OFF
#define	SOL_NIL_I_   SOL_DEFAULT_ON
#define	SOL_NUMBER_PRECISION_CHECKS_I_   SOL_DEFAULT_OFF
#define	SOL_OFF   ^
#define	SOL_ON   |
#define	SOL_OPTIMIZATION_STRING_CONVERSION_STACK_SIZE_I_   1024
#define	SOL_PLATFORM_APPLE_I_   SOL_OFF
#define	SOL_PLATFORM_APPLE_IPHONE_I_   SOL_OFF
#define	SOL_PLATFORM_ARM32_I_   SOL_OFF
#define	SOL_PLATFORM_ARM64_I_   SOL_OFF
#define	SOL_PLATFORM_BSDLIKE_I_   SOL_OFF
#define	SOL_PLATFORM_LINUXLIKE_I_   SOL_OFF
#define	SOL_PLATFORM_UNIXLIKE_I_   SOL_OFF
#define	SOL_PLATFORM_WINDOWS_I_   SOL_OFF
#define	SOL_PLATFORM_X16_I_   SOL_ON
#define	SOL_PLATFORM_X64_I_   SOL_OFF
#define	SOL_PLATFORM_X86_I_   SOL_OFF
#define	SOL_PRINT_ERRORS_I_   SOL_OFF
#define	SOL_PROPAGATE_EXCEPTIONS_I_   SOL_DEFAULT_OFF
#define	SOL_RTTI_I_   SOL_DEFAULT_ON
#define	SOL_SAFE_FUNCTION_CALLS_I_   SOL_DEFAULT_OFF
#define	SOL_SAFE_FUNCTION_OBJECTS_I_   SOL_DEFAULT_OFF
#define	SOL_SAFE_GETTER_I_   SOL_DEFAULT_OFF
#define	SOL_SAFE_NUMERICS_I_   SOL_DEFAULT_OFF
#define	SOL_SAFE_PROXIES_I_   SOL_DEFAULT_OFF
#define	SOL_SAFE_REFERENCES_I_   SOL_DEFAULT_OFF
#define	SOL_SAFE_STACK_CHECK_I_   SOL_DEFAULT_OFF
#define	SOL_SAFE_USERTYPE_I_   SOL_DEFAULT_OFF
#define	SOL_STD_VARIANT_I_   SOL_DEFAULT_ON
#define	SOL_STRINGS_ARE_NUMBERS_I_   SOL_DEFAULT_OFF
#define	SOL_TL_MONOSTATE_INPLACE_MUTEX
#define	SOL_TL_OPTIONAL_11_CONSTEXPR   constexpr
#define	SOL_TL_OPTIONAL_IS_TRIVIALLY_COPY_ASSIGNABLE(T)   std::is_trivially_copy_assignable<T>::value
#define	SOL_TL_OPTIONAL_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T)   std::is_trivially_copy_constructible<T>::value
#define	SOL_TL_OPTIONAL_IS_TRIVIALLY_DESTRUCTIBLE(T)   std::is_trivially_destructible<T>::value
#define	SOL_TL_OPTIONAL_VERSION_MAJOR   0
#define	SOL_TL_OPTIONAL_VERSION_MINOR   5
#define	SOL_TL_TRAITS_MUTEX
#define	SOL_USE_BOOST_I_   SOL_OFF
#define	SOL_USE_COMPATIBILITY_LAYER_I_   SOL_DEFAULT_ON
#define	SOL_USE_CXX_LUA_I_   SOL_OFF
#define	SOL_USE_CXX_LUAJIT_I_   SOL_OFF
#define	SOL_USE_INTEROP_I_   SOL_DEFAULT_OFF
#define	SOL_USE_LUA_HPP_I_   SOL_DEFAULT_ON
#define	SOL_USE_LUAJIT_EXCEPTION_TRAMPOLINE_I_   SOL_DEFAULT_OFF
#define	SOL_USE_LUAJIT_I_   SOL_DEFAULT_OFF
#define	SOL_USE_MOONJIT_I_   SOL_OFF
#define	SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_   SOL_DEFAULT_ON
#define	SOL_USE_THREAD_LOCAL_I_   SOL_DEFAULT_ON
#define	SOL_USE_UNSAFE_BASE_LOOKUP_I_   SOL_OFF
#define	SOL_USERTYPE_TYPE_BINDING_INFO_I_   SOL_DEFAULT_ON
#define	SOL_VERSION   ((SOL_VERSION_MAJOR * 100000) + (SOL_VERSION_MINOR * 100) + (SOL_VERSION_PATCH))
#define	SOL_VERSION_MAJOR   3
#define	SOL_VERSION_MINOR   5
#define	SOL_VERSION_PATCH   0
#define	SOL_VERSION_STRING   "3.5.0"

Typedefs
template<typename T >
using	sol::meta::meta_detail::adl_sol_lua_check_get_test_t = decltype(sol_lua_check_get(types< T >(), static_cast< lua_State * >(nullptr),-1, no_panic, std::declval< stack::record & >()))
template<typename T >
using	sol::meta::meta_detail::adl_sol_lua_check_test_t = decltype(sol_lua_check(types< T >(), static_cast< lua_State * >(nullptr),-1, no_panic, std::declval< stack::record & >()))
template<typename T >
using	sol::meta::meta_detail::adl_sol_lua_get_test_t = decltype(sol_lua_get(types< T >(), static_cast< lua_State * >(nullptr),-1, std::declval< stack::record & >()))
template<typename T >
using	sol::meta::meta_detail::adl_sol_lua_interop_check_test_t = decltype(sol_lua_interop_check(types< T >(), static_cast< lua_State * >(nullptr),-1, type::none, no_panic, std::declval< stack::record & >()))
template<typename T >
using	sol::meta::meta_detail::adl_sol_lua_interop_get_test_t = decltype(sol_lua_interop_get(types< T >(), static_cast< lua_State * >(nullptr),-1, static_cast< void * >(nullptr), std::declval< stack::record & >()))
template<typename T , typename... Args>
using	sol::meta::meta_detail::adl_sol_lua_push_exact_test_t = decltype(sol_lua_push(types< T >(), static_cast< lua_State * >(nullptr), std::declval< Args >()...))
template<typename... Args>
using	sol::meta::meta_detail::adl_sol_lua_push_test_t = decltype(sol_lua_push(static_cast< lua_State * >(nullptr), std::declval< Args >()...))
template<typename... Args>
using	sol::detail::any_is_constructor = meta::any< is_constructor< meta::unqualified_t< Args >>... >
template<typename... Args>
using	sol::detail::any_is_destructor = meta::any< is_destructor< meta::unqualified_t< Args >>... >
template<typename T >
using	sol::detail::array_return_type = meta::conditional_t< std::is_array< T >::value, std::add_lvalue_reference_t< T >, T >
using	sol::array_value = typename lua_value::arr
template<std::size_t I, typename... Args>
using	sol::meta::at_in_pack_t = typename at_in_pack< I, Args... >::type
typedef bases	sol::base_classes_tag
template<typename... Args>
using	sol::bases = base_list< Args... >
template<typename C , typename T = std::char_traits<C>>
using	sol::basic_string_view = std::basic_string_view< C, T >
template<bool B>
using	sol::meta::boolean = std::integral_constant< bool, B >
using	sol::bytecode = basic_bytecode<>
typedef closure	sol::c_closure
using	sol::u_detail::change_indexing_mem_func = void(usertype_storage_base::*)(lua_State *, submetatable_type, void *, stack_reference &, lua_CFunction, lua_CFunction, lua_CFunction, lua_CFunction)
template<bool B, typename T , typename U >
using	sol::meta::conditional_t = typename conditional< B >::template type< T, U >
template<bool B, class T , class F >
using	sol::detail::conditional_t = typename std::conditional< B, T, F >::type
template<typename... Args>
using	sol::constructors = constructor_list< Args... >
template<typename T >
using	sol::container_detail::container_decay_t = typename container_decay< meta::unqualified_t< T >>::type
template<template< typename... > class Pred, typename... Ts>
using	sol::meta::count_even_for_pack = count_when_for_to_pack< meta_detail::on_even, sizeof...(Ts), Pred, Ts... >
template<template< typename... > class Pred, typename... Ts>
using	sol::meta::count_odd_for_pack = count_when_for_to_pack< meta_detail::on_odd, sizeof...(Ts), Pred, Ts... >
template<class T >
using	sol::detail::decay_t = typename std::decay< T >::type
template<typename... Args>
using	sol::meta::disable = std::enable_if_t< neg< all< Args... >>::value, enable_t >
template<typename... Args>
using	sol::meta::disable_any = std::enable_if_t< neg< any< Args... >>::value, enable_t >
template<class T , class... U>
using	sol::detail::disable_if_ret_void = enable_if_t<!returns_void< T &&, U... >::value >
template<bool value, typename T = void>
using	sol::meta::disable_if_t = std::enable_if_t<!value, T >
template<typename... Args>
using	sol::meta::enable = std::enable_if_t< all< Args... >::value, enable_t >
template<typename... Args>
using	sol::meta::enable_any = std::enable_if_t< any< Args... >::value, enable_t >
template<class T , class U >
using	sol::detail::enable_assign_forward = detail::enable_if_t<!std::is_same< optional< T >, detail::decay_t< U >>::value &&!detail::conjunction< std::is_scalar< T >, std::is_same< T, detail::decay_t< U >>>::value &&std::is_constructible< T, U >::value &&std::is_assignable< T &, U >::value >
template<class T , class U , class Other >
using	sol::detail::enable_assign_from_other = detail::enable_if_t< std::is_constructible< T, Other >::value &&std::is_assignable< T &, Other >::value &&!std::is_constructible< T, optional< U > & >::value &&!std::is_constructible< T, optional< U > && >::value &&!std::is_constructible< T, const optional< U > & >::value &&!std::is_constructible< T, const optional< U > && >::value &&!std::is_convertible< optional< U > &, T >::value &&!std::is_convertible< optional< U > &&, T >::value &&!std::is_convertible< const optional< U > &, T >::value &&!std::is_convertible< const optional< U > &&, T >::value &&!std::is_assignable< T &, optional< U > & >::value &&!std::is_assignable< T &, optional< U > && >::value &&!std::is_assignable< T &, const optional< U > & >::value &&!std::is_assignable< T &, const optional< U > && >::value >
template<class T , class U >
using	sol::detail::enable_forward_value = detail::enable_if_t< std::is_constructible< T, U && >::value &&!std::is_same< detail::decay_t< U >, in_place_t >::value &&!std::is_same< optional< T >, detail::decay_t< U >>::value >
template<class T , class U , class Other >
using	sol::detail::enable_from_other = detail::enable_if_t< std::is_constructible< T, Other >::value &&!std::is_constructible< T, optional< U > & >::value &&!std::is_constructible< T, optional< U > && >::value &&!std::is_constructible< T, const optional< U > & >::value &&!std::is_constructible< T, const optional< U > && >::value &&!std::is_convertible< optional< U > &, T >::value &&!std::is_convertible< optional< U > &&, T >::value &&!std::is_convertible< const optional< U > &, T >::value &&!std::is_convertible< const optional< U > &&, T >::value >
template<class T , class... U>
using	sol::detail::enable_if_ret_void = enable_if_t< returns_void< T &&, U... >::value >
template<bool E, class T = void>
using	sol::detail::enable_if_t = typename std::enable_if< E, T >::type
using	sol::exception_handler_function = int(*)(lua_State *, optional< const std::exception & >, string_view)
template<class U >
using	sol::detail::fixup_void = conditional_t< std::is_void< U >::value, monostate, U >
template<typename Signature >
using	sol::meta::function_args_t = typename bind_traits< Signature >::args_list
template<typename Signature >
using	sol::meta::function_return_t = typename bind_traits< Signature >::return_type
template<typename Signature >
using	sol::meta::function_signature_t = typename bind_traits< Signature >::signature_type
template<class F , class U , class = invoke_result_t<F, U>>
using	sol::detail::get_map_return = optional< fixup_void< invoke_result_t< F, U >>>
template<typename T >
using	sol::container_detail::has_clear = meta::boolean< has_clear_test< T >::value >
template<typename T >
using	sol::container_detail::has_empty = meta::boolean< has_empty_test< T >::value >
template<typename T >
using	sol::container_detail::has_erase = meta::boolean< has_erase_test< T >::value >
template<typename T >
using	sol::container_detail::has_erase_after = meta::boolean< has_erase_after_test< T >::value >
template<typename T >
using	sol::container_detail::has_erase_key = meta::boolean< has_erase_key_test< T >::value >
template<typename T >
using	sol::container_detail::has_find = meta::boolean< has_find_test< T >::value >
template<typename T >
using	sol::meta::has_insert = meta::boolean< meta_detail::has_insert_test< T >::value >
template<typename T >
using	sol::meta::has_insert_after = meta::boolean< meta_detail::has_insert_after_test< T >::value >
template<typename T >
using	sol::detail::has_internal_marker = has_internal_marker_impl< T >
template<typename T >
using	sol::meta::has_max_size = meta::boolean< meta_detail::has_max_size_test< T >::value >
template<typename T >
using	sol::meta::has_push_back = meta::boolean< meta_detail::has_push_back_test< T >::value >
template<typename T >
using	sol::meta::has_size = meta::boolean< meta_detail::has_size_test< T >::value >
template<typename T >
using	sol::container_detail::has_traits_add = meta::boolean< has_traits_add_test< T >::value >
template<typename T >
using	sol::container_detail::has_traits_at = meta::boolean< has_traits_at_test< T >::value >
template<typename T >
using	sol::container_detail::has_traits_clear = has_clear< T >
template<typename T >
using	sol::container_detail::has_traits_empty = has_empty< T >
template<typename T >
using	sol::container_detail::has_traits_erase = meta::boolean< has_traits_erase_test< T >::value >
template<typename T >
using	sol::container_detail::has_traits_find = meta::boolean< has_traits_find_test< T >::value >
template<typename T >
using	sol::container_detail::has_traits_get = meta::boolean< has_traits_get_test< T >::value >
template<typename T >
using	sol::container_detail::has_traits_index_get = meta::boolean< has_traits_index_get_test< T >::value >
template<typename T >
using	sol::container_detail::has_traits_index_of = meta::boolean< has_traits_index_of_test< T >::value >
template<typename T >
using	sol::container_detail::has_traits_index_set = meta::boolean< has_traits_index_set_test< T >::value >
template<typename T >
using	sol::container_detail::has_traits_insert = meta::boolean< has_traits_insert_test< T >::value >
template<typename T >
using	sol::container_detail::has_traits_ipairs = meta::boolean< has_traits_ipairs_test< T >::value >
template<typename T >
using	sol::container_detail::has_traits_next = meta::boolean< has_traits_next_test< T >::value >
template<typename T >
using	sol::container_detail::has_traits_pairs = meta::boolean< has_traits_pairs_test< T >::value >
template<typename T >
using	sol::container_detail::has_traits_set = meta::boolean< has_traits_set_test< T >::value >
template<typename T >
using	sol::container_detail::has_traits_size = meta::boolean< has_traits_size_test< T >::value >
template<typename T >
using	sol::meta::identity_t = typename identity< T >::type
template<size_t I>
using	sol::in_place_index_t = std::in_place_index_t< I >
using	sol::in_place_t = std::in_place_t
template<typename T >
using	sol::in_place_type_t = std::in_place_type_t< T >
using	sol::u_detail::index_call_function = int(lua_State *, void *)
template<std::size_t I>
using	sol::meta::index_value = std::integral_constant< std::size_t, I >
using	sol::detail::inheritance_cast_function = decltype(&inheritance< void >::type_cast)
using	sol::detail::inheritance_check_function = decltype(&inheritance< void >::type_check)
using	sol::detail::inheritance_unique_cast_function = decltype(&inheritance< void >::type_unique_cast< void >)
template<class F , class... Us>
using	sol::detail::invoke_result = invoke_result_impl< F, void, Us... >
template<class F , class... Us>
using	sol::detail::invoke_result_t = typename invoke_result< F, Us... >::type
template<typename T >
using	sol::meta::is_associative = meta::all< has_key_type< T >, has_key_value_pair< T >, has_mapped_type< T >>
template<typename T >
using	sol::is_base_rebindable = meta::is_detected< detail::is_base_rebindable_test, T >
template<typename T >
using	sol::is_base_rebindable_non_void = meta::is_detected< detail::is_base_rebindable_test, T >
template<typename T , typename Rebind = void>
using	sol::detail::is_base_rebindable_test = typename T::template rebind_base< Rebind >
template<typename T >
using	sol::meta::is_builtin_type = std::integral_constant< bool, std::is_arithmetic< T >::value||std::is_pointer< T >::value||std::is_array< T >::value >
template<typename T >
using	sol::meta::is_c_str = is_c_str_of< T, char >
template<typename T , typename Char >
using	sol::meta::is_c_str_of = any< std::is_same< T, const Char * >, std::is_same< T, Char const *const >, std::is_same< T, Char * >, is_string_of< T, Char >, is_string_literal_array_of< T, Char >>
template<typename T >
using	sol::meta::is_callable = boolean< meta_detail::is_callable< T >::value >
template<typename T >
using	sol::meta::meta_detail::is_dereferenceable_test = decltype(*std::declval< T >())
template<template< class... > class Trait, class... Args>
using	sol::meta::is_detected = typename meta_detail::is_detected< Trait, void, Args... >::type
template<typename T >
using	sol::is_environment = std::integral_constant< bool, is_userdata_v< T >||is_table_v< T >||meta::is_specialization_of_v< T, basic_environment >>
template<typename T >
using	sol::meta::meta_detail::is_explicitly_dereferenceable_test = decltype(std::declval< T >().operator*())
template<typename T >
using	sol::meta::is_initializer_list = meta::is_specialization_of< T, std::initializer_list >
template<typename T , typename... >
using	sol::detail::is_insert_mode = std::integral_constant< bool, std::is_same_v< T, override_value_t >||std::is_same_v< T, update_if_empty_t >||std::is_same_v< T, create_if_nil_t >>
template<typename T >
using	sol::is_lightuserdata = meta::is_specialization_of< T, basic_lightuserdata >
template<typename T >
using	sol::meta::is_lookup = meta::all< has_key_type< T >, has_value_type< T >>
template<typename T >
using	sol::is_lua_c_function = meta::any< std::is_same< lua_CFunction, T >, std::is_same< detail::lua_CFunction_noexcept, T >, std::is_same< lua_CFunction_ref, T >>
template<typename T >
using	sol::meta::is_matched_lookup = meta_detail::is_matched_lookup_impl< T, is_lookup< T >::value >
template<typename T , typename... >
using	sol::detail::is_not_insert_mode = meta::neg< is_insert_mode< T >>
template<typename T >
using	sol::meta::is_not_move_only = neg< is_move_only< T >>
template<class T >
using	sol::detail::is_optional = is_optional_impl< decay_t< T >>
template<typename T >
using	sol::meta::is_optional = any< is_specialization_of< T, optional >, is_specialization_of< T, std::optional >>
template<typename T >
using	sol::meta::is_ordered = meta::all< has_key_comp< T >, meta::neg< has_load_factor< T >>>
template<typename T >
using	sol::meta::is_pointer_like = std::integral_constant< bool,!std::is_array_v< T > &&(std::is_pointer_v< T >||is_detected_v< meta_detail::is_explicitly_dereferenceable_test, T >)>
template<typename T >
using	sol::detail::is_policy = meta::is_specialization_of< T, policy_wrapper >
template<typename T , template< typename... > class Templ>
using	sol::meta::is_specialization_of = meta_detail::is_specialization_of< std::remove_cv_t< T >, Templ >
template<typename T , typename CharT = char>
using	sol::meta::is_string_constructible = meta::boolean< is_string_literal_array_of_v< T, CharT >||std::is_same_v< T, const CharT * >||std::is_same_v< T, CharT >||is_string_of_v< T, CharT >||std::is_same_v< T, std::initializer_list< CharT >>||is_string_view_of_v< T, CharT >>
template<typename T >
using	sol::meta::is_string_like = meta::boolean< is_specialization_of_v< T, std::basic_string >||is_specialization_of_v< T, std::basic_string_view >||is_string_literal_array_v< T >>
template<typename T >
using	sol::meta::is_string_like_or_constructible = meta::boolean< is_string_like_v< T >||is_string_constructible_v< T >>
template<typename T >
using	sol::meta::is_string_literal_array = boolean< std::is_array_v< T > &&any_same_v< std::remove_all_extents_t< T >, char, char16_t, char32_t, wchar_t >>
template<typename T , typename CharT = char>
using	sol::meta::is_string_literal_array_of = boolean< std::is_array_v< T > &&std::is_same_v< std::remove_all_extents_t< T >, CharT >>
template<typename T >
using	sol::is_table_like = std::integral_constant< bool, is_table_v< T >||is_environment_v< T >||is_userdata_v< T >>
template<typename T >
using	sol::meta::is_tuple = is_specialization_of< T, std::tuple >
template<typename T >
using	sol::is_userdata = meta::is_specialization_of< T, basic_userdata >
template<typename T >
using	sol::is_var_wrapper = meta::is_specialization_of< T, var_wrapper >
typedef int(*	sol::detail::lua_CFunction_noexcept) (lua_State *L) noexcept
typedef std::remove_pointer_t< lua_CFunction >	sol::lua_CFunction_ref
using	sol::detail::lua_reg_table = luaL_Reg[64]
typedef meta_function	sol::meta_method
template<typename T >
using	sol::meta::neg = boolean<!T::value >
using	sol::nil_t = lua_nil_t
template<typename T >
using	sol::meta::meta_detail::non_void_t = meta::conditional_t< std::is_void_v< T >,::sol::detail::unchecked_t, T >
using	sol::nullopt_t = std::nullopt_t
	A tag type to represent an empty optional. More...
template<typename , typename >
using	sol::meta::meta_detail::on_always = std::true_type
template<typename , typename TI >
using	sol::meta::meta_detail::on_even = meta::boolean<(TI::value%2)==0 >
template<typename , typename TI >
using	sol::meta::meta_detail::on_odd = meta::boolean<(TI::value%2)==1 >
template<typename Arg >
using	sol::meta::pop_front_type_t = typename pop_front_type< Arg >::type
template<typename T >
using	sol::detail::proxy_key_t = meta::conditional_t< meta::is_specialization_of_v< meta::unqualified_t< T >, std::tuple >, T, std::tuple< meta::conditional_t< std::is_array_v< meta::unqualified_t< T >>, std::remove_reference_t< T > &, meta::unqualified_t< T >>>>
template<class T >
using	sol::detail::remove_const_t = typename std::remove_const< T >::type
template<typename T >
using	sol::meta::remove_member_pointer_t = remove_member_pointer< T >
template<class T >
using	sol::detail::remove_reference_t = typename std::remove_reference< T >::type
template<typename... Args>
using	sol::meta::return_type_t = typename return_type< Args... >::type
typedef returns_self_with	sol::returns_self
template<class F , class... U>
using	sol::detail::returns_void = returns_void_impl< F, void, U... >
typedef static_stack_dependencies<-1, 1 >	sol::self_dependency
using	sol::meta::sfinae_no_t = std::false_type
using	sol::meta::sfinae_yes_t = std::true_type
typedef std::string_view	sol::string_view
typedef std::hash< std::string_view >	sol::string_view_hash
template<typename T >
using	sol::stack::stack_detail::strip_t = typename strip< T >::type
using	sol::detail::swallow = std::initializer_list< int >
template<std::size_t N, typename Tuple >
using	sol::meta::tuple_element = std::tuple_element< N, std::remove_reference_t< Tuple >>
template<std::size_t N, typename Tuple >
using	sol::meta::tuple_element_t = std::tuple_element_t< N, std::remove_reference_t< Tuple >>
template<typename... Args>
using	sol::meta::tuple_types = typename detail::tuple_types_< Args... >::type
using	sol::detail::typical_chunk_name_t = char[SOL_ID_SIZE_I_]
using	sol::detail::typical_file_chunk_name_t = char[SOL_FILE_ID_SIZE_I_]
typedef std::u16string_view	sol::u16string_view
typedef std::u32string_view	sol::u32string_view
using	sol::stack::stack_detail::undefined_method_func = void(*)(stack_reference)
using	sol::detail::unique_destructor = void(*)(void *)
using	sol::detail::unique_tag = detail::inheritance_unique_cast_function
template<typename T >
using	sol::meta::unqualified = std::remove_cv< std::remove_reference_t< T >>
template<typename T >
using	sol::meta::unqualified_t = typename unqualified< T >::type
template<std::size_t N, typename Tuple >
using	sol::meta::unqualified_tuple_element = unqualified< tuple_element_t< N, Tuple >>
template<std::size_t N, typename Tuple >
using	sol::meta::unqualified_tuple_element_t = unqualified_t< tuple_element_t< N, Tuple >>
template<typename T >
using	sol::meta::unwrap_unqualified_t = typename unwrap_unqualified< T >::type
template<typename T >
using	sol::meta::unwrapped_t = typename unwrapped< T >::type
template<typename T >
using	sol::meta::void_t = void
template<class... Ts>
using	sol::detail::void_t = typename voider< Ts... >::type
template<std::size_t I, typename T >
using	sol::meta::meta_detail::void_tuple_element_t = typename void_tuple_element< I, T >::type
typedef std::wstring_view	sol::wstring_view

Enumerations
enum	sol::call_status : int {   sol::call_status::ok = LUA_OK, sol::call_status::yielded = LUA_YIELD, sol::call_status::runtime = LUA_ERRRUN, sol::call_status::memory = LUA_ERRMEM,   sol::call_status::handler = LUA_ERRERR, sol::call_status::gc = LUA_ERRGCMM, sol::call_status::syntax = LUA_ERRSYNTAX, sol::call_status::file = LUA_ERRFILE }
enum	sol::call_syntax { sol::call_syntax::dot = 0, sol::call_syntax::colon = 1 }
enum	sol::meta::enable_t { sol::meta::enable_t::_ }
enum	sol::unicode::error_code {   sol::unicode::error_code::ok = 0, sol::unicode::error_code::invalid_code_point, sol::unicode::error_code::invalid_code_unit, sol::unicode::error_code::invalid_leading_surrogate,   sol::unicode::error_code::invalid_trailing_surrogate, sol::unicode::error_code::sequence_too_short, sol::unicode::error_code::overlong_sequence }
enum	sol::gc_mode : int { sol::gc_mode::incremental = 0, sol::gc_mode::generational = 1, sol::gc_mode::default_value = incremental }
enum	sol::detail::insert_mode { sol::detail::none = 0x0, sol::detail::update_if_empty = 0x01, sol::detail::override_value = 0x02, sol::detail::create_if_nil = 0x04 }
enum	sol::lib : char {   sol::lib::base, sol::lib::package, sol::lib::coroutine, sol::lib::string,   sol::lib::os, sol::lib::math, sol::lib::table, sol::lib::debug,   sol::lib::bit32, sol::lib::io, sol::lib::ffi, sol::lib::jit,   sol::lib::utf8, sol::lib::count }
enum	sol::load_mode { sol::load_mode::any = 0, sol::load_mode::text = 1, sol::load_mode::binary = 2 }
enum	sol::load_status : int {   sol::load_status::ok = LUA_OK, sol::load_status::syntax = LUA_ERRSYNTAX, sol::load_status::memory = LUA_ERRMEM, sol::load_status::gc = LUA_ERRGCMM,   sol::load_status::file = LUA_ERRFILE }
enum	sol::meta_function {   sol::meta_function::construct, sol::meta_function::index, sol::meta_function::new_index, sol::meta_function::mode,   sol::meta_function::call, sol::meta_function::call_function = call, sol::meta_function::metatable, sol::meta_function::to_string,   sol::meta_function::length, sol::meta_function::unary_minus, sol::meta_function::addition, sol::meta_function::subtraction,   sol::meta_function::multiplication, sol::meta_function::division, sol::meta_function::modulus, sol::meta_function::power_of,   sol::meta_function::involution = power_of, sol::meta_function::concatenation, sol::meta_function::equal_to, sol::meta_function::less_than,   sol::meta_function::less_than_or_equal_to, sol::meta_function::garbage_collect, sol::meta_function::floor_division, sol::meta_function::bitwise_left_shift,   sol::meta_function::bitwise_right_shift, sol::meta_function::bitwise_not, sol::meta_function::bitwise_and, sol::meta_function::bitwise_or,   sol::meta_function::bitwise_xor, sol::meta_function::pairs, sol::meta_function::ipairs, sol::meta_function::next,   sol::meta_function::type, sol::meta_function::type_info, sol::meta_function::call_construct, sol::meta_function::storage,   sol::meta_function::gc_names, sol::meta_function::static_index, sol::meta_function::static_new_index }
enum	sol::u_detail::submetatable_type {   sol::u_detail::submetatable_type::value, sol::u_detail::submetatable_type::reference, sol::u_detail::submetatable_type::unique, sol::u_detail::submetatable_type::const_reference,   sol::u_detail::submetatable_type::const_value, sol::u_detail::submetatable_type::named }
enum	sol::thread_status : int {   sol::thread_status::ok = LUA_OK, sol::thread_status::yielded = LUA_YIELD, sol::thread_status::runtime = LUA_ERRRUN, sol::thread_status::memory = LUA_ERRMEM,   sol::thread_status::gc = LUA_ERRGCMM, sol::thread_status::handler = LUA_ERRERR, sol::thread_status::dead = -1 }
enum	sol::type : int {   sol::type::none = LUA_TNONE, sol::type::lua_nil = LUA_TNIL, sol::type::nil = lua_nil, sol::type::string = LUA_TSTRING,   sol::type::number = LUA_TNUMBER, sol::type::thread = LUA_TTHREAD, sol::type::boolean = LUA_TBOOLEAN, sol::type::function = LUA_TFUNCTION,   sol::type::userdata = LUA_TUSERDATA, sol::type::lightuserdata = LUA_TLIGHTUSERDATA, sol::type::table = LUA_TTABLE, sol::type::poly = -0xFFFF }

Functions
void	sol::detail::accumulate_and_mark (const std::string &n, std::string &aux_message, int &marker)
template<typename T >
int	sol::detail::adl_default_to_string (std::true_type, lua_State *L)
template<typename T >
int	sol::detail::adl_default_to_string (std::false_type, lua_State *L)
void *	sol::detail::align (std::size_t alignment, std::size_t size, void *&ptr, std::size_t &space, std::size_t &required_space)
void *	sol::detail::align (std::size_t alignment, std::size_t size, void *&ptr, std::size_t &space)
void	sol::detail::align_one (std::size_t a, std::size_t s, void *&target_alignment)
template<typename T >
void *	sol::detail::align_user (void *ptr)
void *	sol::detail::align_usertype_pointer (void *ptr)
template<typename T , bool pre_aligned = false, bool pre_shifted = false>
void *	sol::detail::align_usertype_unique (void *ptr)
template<bool pre_aligned = false, bool pre_shifted = false>
void *	sol::detail::align_usertype_unique_destructor (void *ptr)
template<bool pre_aligned = false, bool pre_shifted = false>
void *	sol::detail::align_usertype_unique_tag (void *ptr)
template<typename... Args>
std::size_t	sol::detail::aligned_space_for (void *alignment=nullptr)
template<typename Source >
auto	sol::as_args (Source &&source)
template<typename T >
auto	sol::as_container (T &&value)
template<typename Sig = function_sig<>, typename... Args>
auto	sol::as_function (Args &&...args)
template<typename Sig = function_sig<>, typename... Args>
auto	sol::as_function_reference (Args &&...args)
template<typename T >
nested< meta::unqualified_t< T > >	sol::as_nested (T &&container)
template<typename T >
nested< T >	sol::as_nested_ref (T &&container)
template<typename Source >
auto	sol::as_returns (Source &&source)
template<typename T >
as_table_t< meta::unqualified_t< T > >	sol::as_table (T &&container)
template<typename T >
as_table_t< T >	sol::as_table_ref (T &&container)
std::string	sol::associated_type_name (lua_State *L, int index, type t)
bool	sol::detail::attempt_alloc (lua_State *L, std::size_t ptr_align, std::size_t ptr_size, std::size_t value_align, std::size_t value_size, std::size_t allocated_size, void *&pointer_adjusted, void *&data_adjusted)
bool	sol::detail::attempt_alloc_unique (lua_State *L, std::size_t ptr_align, std::size_t ptr_size, std::size_t real_align, std::size_t real_size, std::size_t allocated_size, void *&pointer_adjusted, void *&dx_adjusted, void *&id_adjusted, void *&data_adjusted)
decltype(auto)	sol::detail::base_class_cast_key ()
decltype(auto)	sol::detail::base_class_check_key ()
decltype(auto)	sol::detail::base_class_index_propogation_key ()
decltype(auto)	sol::detail::base_class_new_index_propogation_key ()
template<typename Container >
int	sol::basic_insert_dump_writer (lua_State *, const void *memory, size_t memory_size, void *userdata)
template<typename F , F fx>
int	sol::c_call (lua_State *L)
template<typename... Fxs>
int	sol::c_call (lua_State *L)
template<typename F , F fx>
int	sol::function_detail::c_call_raw (std::true_type, lua_State *L)
template<typename F , F fx>
int	sol::function_detail::c_call_raw (std::false_type, lua_State *L)
int	sol::detail::c_trampoline (lua_State *L, lua_CFunction f)
template<bool checkargs = detail::default_safe_function_calls, std::size_t... I, typename R , typename... Args, typename Fx , typename... FxArgs>
decltype(auto)	sol::stack::stack_detail::call (types< R >, types< Args... > ta, std::index_sequence< I... > tai, lua_State *L, int start, Fx &&fx, FxArgs &&...args)
template<bool check_args = detail::default_safe_function_calls, typename R , typename... Args, typename Fx , typename... FxArgs>
decltype(auto)	sol::stack::call (types< R > tr, types< Args... > ta, lua_State *L, int start, Fx &&fx, FxArgs &&...args)
template<bool check_args = detail::default_safe_function_calls, typename R , typename... Args, typename Fx , typename... FxArgs>
decltype(auto)	sol::stack::call (types< R > tr, types< Args... > ta, lua_State *L, Fx &&fx, FxArgs &&...args)
template<typename Fx , int start = 1, bool is_yielding = false>
int	sol::function_detail::call (lua_State *L)
int	sol::detail::call_exception_handler (lua_State *L, optional< const std::exception & > maybe_ex, string_view what)
template<bool check_args = detail::default_safe_function_calls, typename R , typename... Args, typename Fx , typename... FxArgs>
decltype(auto)	sol::stack::call_from_top (types< R > tr, types< Args... > ta, lua_State *L, Fx &&fx, FxArgs &&...args)
template<bool check_args = detail::default_safe_function_calls, bool clean_stack = true, typename Ret0 , typename... Ret, typename... Args, typename Fx , typename... FxArgs>
int	sol::stack::call_into_lua (types< Ret0, Ret... > tr, types< Args... > ta, lua_State *L, int start, Fx &&fx, FxArgs &&...fxargs)
template<bool check_args = detail::default_safe_function_calls, bool clean_stack = true, typename Fx , typename... FxArgs>
int	sol::stack::call_lua (lua_State *L, int start, Fx &&fx, FxArgs &&...fxargs)
template<typename R , typename V , V , typename T >
int	sol::function_detail::call_set_assignable (std::false_type, T &&, lua_State *L)
template<typename R , typename V , V variable, typename T >
int	sol::function_detail::call_set_assignable (std::true_type, lua_State *L, T &&mem)
template<typename R , typename V , V , typename T >
int	sol::function_detail::call_set_variable (std::false_type, lua_State *L, T &&)
template<typename R , typename V , V variable, typename T >
int	sol::function_detail::call_set_variable (std::true_type, lua_State *L, T &&mem)
template<typename T , bool is_index, bool is_variable, typename F , int start = 1, bool checked = detail::default_safe_function_calls, bool clean_stack = true>
int	sol::call_detail::call_user (lua_State *L)
template<typename T , bool is_index, bool is_variable, int boost = 0, bool checked = detail::default_safe_function_calls, bool clean_stack = true, typename Fx , typename... Args>
int	sol::call_detail::call_wrapped (lua_State *L, Fx &&fx, Args &&...args)
template<typename F , F fx>
int	sol::function_detail::call_wrapper_entry (lua_State *L) noexcept(meta::bind_traits< F >::is_noexcept)
template<typename F , F fx>
int	sol::function_detail::call_wrapper_function (std::false_type, lua_State *L)
template<typename F , F fx>
int	sol::function_detail::call_wrapper_function (std::true_type, lua_State *L)
template<typename F , F fx>
int	sol::function_detail::call_wrapper_variable (std::false_type, lua_State *L)
template<typename V , V variable>
int	sol::function_detail::call_wrapper_variable (std::true_type, lua_State *L)
template<class , class >
std::false_type	sol::detail::swap_adl_tests::can_swap (...) noexcept(false)
template<class T , class U , class = decltype(swap(std::declval<T&>(), std::declval<U&>()))>
std::true_type	sol::detail::swap_adl_tests::can_swap (int) noexcept(noexcept(swap(std::declval< T & >(), std::declval< U & >())))
template<typename T >
int	sol::detail::cannot_destruct (lua_State *L)
template<typename T , typename Handler >
bool	sol::stack::check (lua_State *L, int index, Handler &&handler, record &tracking)
template<typename T , typename Handler >
bool	sol::stack::check (lua_State *L, int index, Handler &&handler)
template<typename T >
bool	sol::stack::check (lua_State *L, int index=-lua_size< meta::unqualified_t< T >>::value)
template<typename Function , typename Handler >
bool	sol::stack::stack_detail::check_function_pointer (lua_State *L, int index, Handler &&handler, record &tracking) noexcept
template<typename T , typename Handler >
decltype(auto)	sol::stack::check_get (lua_State *L, int index, Handler &&handler, record &tracking)
template<typename T , typename Handler >
decltype(auto)	sol::stack::check_get (lua_State *L, int index, Handler &&handler)
template<typename T >
decltype(auto)	sol::stack::check_get (lua_State *L, int index=-lua_size< meta::unqualified_t< T >>::value)
template<typename T , bool poptable = true>
bool	sol::stack::stack_detail::check_metatable (lua_State *L, int index=-2)
template<typename Handler >
bool	sol::stack::stack_detail::check_types (lua_State *, int, Handler &&, record &)
template<typename T , typename... Args, typename Handler >
bool	sol::stack::stack_detail::check_types (lua_State *L, int firstargument, Handler &&handler, record &tracking)
template<typename... Args, typename Handler >
bool	sol::stack::stack_detail::check_types (types< Args... >, lua_State *L, int index, Handler &&handler, record &tracking)
template<typename T , typename Handler >
bool	sol::stack::check_usertype (lua_State *L, int index, type, Handler &&handler, record &tracking)
template<typename T , typename Handler >
bool	sol::stack::check_usertype (lua_State *L, int index, Handler &&handler, record &tracking)
template<typename T , typename Handler >
bool	sol::stack::check_usertype (lua_State *L, int index, Handler &&handler)
template<typename T >
bool	sol::stack::check_usertype (lua_State *L, int index=-lua_size< meta::unqualified_t< T >>::value)
void	sol::stack::clear (lua_State *L, int table_index)
void	sol::stack::clear (reference &r)
void	sol::stack::clear (stack_reference &r)
void	sol::detail::clear_entries (stack_reference r)
void	sol::detail::clear_entries (const reference &registry_reference)
encoded_result< char16_t >	sol::unicode::code_point_to_utf16 (char32_t codepoint)
encoded_result< char32_t >	sol::unicode::code_point_to_utf32 (char32_t codepoint)
encoded_result< char >	sol::unicode::code_point_to_utf8 (char32_t codepoint)
template<typename T , typename Op >
int	sol::detail::comparsion_operator_wrap (lua_State *L)
template<typename T , bool checked, bool clean_stack, typename... TypeLists>
int	sol::call_detail::construct (lua_State *L)
template<typename T , typename... TypeLists, typename Match , typename... Args>
int	sol::call_detail::construct_match (Match &&matchfx, lua_State *L, int fxarity, int start, Args &&...args)
template<typename T , bool checked, bool clean_stack, typename... TypeLists>
int	sol::call_detail::construct_trampolined (lua_State *L)
template<typename Ch , typename F >
void	sol::stack::stack_detail::convert (const char *strb, const char *stre, F &&f)
void	sol::stack::coroutine_create_guard (lua_State *L)
template<typename T >
usertype_storage< T > &	sol::u_detail::create_usertype_storage (lua_State *L)
int	sol::default_at_panic (lua_State *L)
const std::string &	sol::detail::default_chunk_name ()
int	sol::detail::default_exception_handler (lua_State *L, optional< const std::exception & >, string_view what)
const char(&	sol::detail::default_exception_handler_name ())[11]
const char(&	sol::detail::default_handler_name ())[9]
const char(&	sol::detail::default_main_thread_name ())[9]
template<typename T >
int	sol::detail::default_size (lua_State *L)
template<typename T >
int	sol::detail::default_to_string (lua_State *L)
int	sol::default_traceback_error_handler (lua_State *L)
template<typename T >
void	sol::u_detail::delete_usertype_storage (lua_State *L)
template<typename T >
const std::string &	sol::detail::demangle ()
template<typename T >
std::string	sol::detail::demangle_once ()
template<typename T >
decltype(auto)	sol::detail::deref (T &&item)
template<typename T >
decltype(auto)	sol::detail::deref_move_only (T &&item)
template<typename T >
int	sol::u_detail::destruct_usertype_storage (lua_State *L)
template<typename Fx >
auto	sol::destructor (Fx &&fx)
int	sol::dump_panic_on_error (lua_State *L, int result_code, lua_Writer writer_function, void *userdata, bool strip)
int	sol::dump_pass_on_error (lua_State *L, int result_code, lua_Writer writer_function, void *userdata, bool strip)
int	sol::dump_throw_on_error (lua_State *L, int result_code, lua_Writer writer_function, void *userdata, bool strip)
template<typename Fx , typename... Args>
static decltype(auto)	sol::stack::stack_detail::eval (types<>, std::index_sequence<>, lua_State *, int, record &, Fx &&fx, Args &&...args)
template<typename Fx , typename Arg , typename... Args, std::size_t I, std::size_t... Is, typename... FxArgs>
static decltype(auto)	sol::stack::stack_detail::eval (types< Arg, Args... >, std::index_sequence< I, Is... >, lua_State *L, int start, record &tracking, Fx &&fx, FxArgs &&...fxargs)
template<typename... Functions>
auto	sol::factories (Functions &&...functions)
int	sol::detail::fail_on_newindex (lua_State *L)
template<typename base_t , typename T >
basic_function< base_t >	sol::detail::force_cast (T &p)
template<typename T >
decltype(auto)	sol::meta::meta_detail::force_tuple (T &&x)
template<typename T >
auto	sol::stack::get (lua_State *L, int index, record &tracking) -> decltype(stack_detail::unchecked_get< T >(L, index, tracking))
template<typename T >
decltype(auto)	sol::stack::get (lua_State *L, int index=-lua_size< meta::unqualified_t< T >>::value)
template<std::size_t I, typename... Args, typename T >
stack_proxy	sol::detail::get (types< Args... >, meta::index_value< 0 >, meta::index_value< I >, const T &fr)
template<std::size_t I, std::size_t N, typename Arg , typename... Args, typename T , meta::enable< meta::boolean<(N > 0)> >
stack_proxy	sol::detail::get (types< Arg, Args... >, meta::index_value< N >, meta::index_value< I >, const T &fr)
template<std::size_t I>
stack_proxy	sol::get (const unsafe_function_result &fr)
template<std::size_t I, typename... Args>
stack_proxy	sol::get (types< Args... > t, const unsafe_function_result &fr)
template<std::size_t I>
stack_proxy	sol::get (const protected_function_result &fr)
template<std::size_t I, typename... Args>
stack_proxy	sol::get (types< Args... > t, const protected_function_result &fr)
template<typename T >
std::pair< T, int >	sol::stack::stack_detail::get_as_upvalues (lua_State *L, int index=2)
template<typename T >
std::pair< T, int >	sol::stack::stack_detail::get_as_upvalues_using_function (lua_State *L, int function_index=-1)
call_syntax	sol::stack::get_call_syntax (lua_State *L, const string_view &key, int index)
template<typename Reference , bool is_main_ref = false>
static Reference	sol::detail::get_default_handler (lua_State *L)
template<typename E = reference, typename T >
basic_environment< E >	sol::get_environment (const T &target)
template<bool global = false, bool raw = false, typename Key >
void	sol::stack::get_field (lua_State *L, Key &&key)
template<bool global = false, bool raw = false, typename Key >
void	sol::stack::get_field (lua_State *L, Key &&key, int tableindex)
template<typename Function >
Function *	sol::stack::stack_detail::get_function_pointer (lua_State *, int, record &) noexcept
template<typename BaseCh , typename S >
S	sol::stack::stack_detail::get_into (lua_State *L, int index, record &tracking)
template<typename T >
decltype(auto)	sol::container_detail::get_key (std::false_type, T &&t)
template<typename T >
decltype(auto)	sol::container_detail::get_key (std::true_type, T &&t)
template<typename C >
static int	sol::stack::stack_detail::get_size_hint (C &c)
template<typename V , typename Al >
static int	sol::stack::stack_detail::get_size_hint (const std::forward_list< V, Al > &)
error	sol::stack::get_traceback_or_errors (lua_State *L)
template<typename T >
decltype(auto)	sol::stack::get_usertype (lua_State *L, int index, record &tracking)
template<typename T >
decltype(auto)	sol::stack::get_usertype (lua_State *L, int index=-lua_size< meta::unqualified_t< T >>::value)
template<typename T >
usertype_storage< T > &	sol::u_detail::get_usertype_storage (lua_State *L)
usertype_storage_base &	sol::u_detail::get_usertype_storage_base (lua_State *L, const char *gcmetakey)
template<typename T >
decltype(auto)	sol::container_detail::get_value (std::false_type, T &&t)
template<typename T >
decltype(auto)	sol::container_detail::get_value (std::true_type, T &&t)
int	sol::detail::handle_errors (lua_State *L, const error_result &er)
template<int I, int... In>
void	sol::policy_detail::handle_policy (static_stack_dependencies< I, In... >, lua_State *L, int &)
template<int... In>
void	sol::policy_detail::handle_policy (returns_self_with< In... >, lua_State *L, int &pushed)
void	sol::policy_detail::handle_policy (const stack_dependencies &sdeps, lua_State *L, int &)
template<typename P , meta::disable< std::is_base_of< detail::policy_base_tag, meta::unqualified_t< P >>> = meta::enabler>
void	sol::policy_detail::handle_policy (P &&p, lua_State *L, int &pushed)
template<bool b, typename handler_t >
void	sol::detail::handle_protected_exception (lua_State *L, optional< const std::exception & > maybe_ex, const char *error, detail::protected_handler< b, handler_t > &h)
bool	sol::stack::stack_detail::impl_check_metatable (lua_State *L, int index, const std::string &metakey, bool poptable)
int	sol::u_detail::index_fail (lua_State *L)
int	sol::u_detail::index_target_fail (lua_State *L, void *)
template<typename... Functions>
auto	sol::initializers (Functions &&...functions)
template<typename T , typename IFx , typename Fx >
void	sol::detail::insert_default_registrations (IFx &&ifx, Fx &&fx)
template<typename T >
bool	sol::stack::stack_detail::integer_value_fits (const T &value)
template<typename T , typename Handler >
bool	sol::stack::stack_detail::interop_check (lua_State *L, int index, type index_type, Handler &&handler, record &tracking)
template<typename T >
decltype(auto)	sol::stack::stack_detail::interop_get (lua_State *L, int index, void *unadjusted_pointer, record &tracking)
template<typename Fn , typename... Args, typename = enable_if_t<std::is_member_pointer<decay_t<Fn>>::value>, int = 0>
constexpr auto	sol::detail::invoke (Fn &&f, Args &&...args) noexcept(noexcept(std::mem_fn(f)(std::forward< Args >(args)...))) -> decltype(std::mem_fn(f)(std::forward< Args >(args)...))
template<typename Fn , typename... Args, typename = enable_if_t<!std::is_member_pointer<decay_t<Fn>>::value>>
constexpr auto	sol::detail::invoke (Fn &&f, Args &&...args) noexcept(noexcept(std::forward< Fn >(f)(std::forward< Args >(args)...))) -> decltype(std::forward< Fn >(f)(std::forward< Args >(args)...))
template<class F , class... Us>
struct	sol::detail::invoke_result_impl< F, decltype(detail::invoke(std::declval< F > ()
template<typename T >
int	sol::detail::is_check (lua_State *L)
bool	sol::is_indeterminate_call_failure (call_status c)
int	sol::u_detail::is_indexer (string_view s)
int	sol::u_detail::is_indexer (meta_function mf)
int	sol::u_detail::is_indexer (call_construction)
bool	sol::stack::is_main_thread (lua_State *L)
template<bool yielding>
int	sol::function_detail::lua_c_noexcept_wrapper (lua_State *L) noexcept
template<bool yielding>
int	sol::function_detail::lua_c_wrapper (lua_State *L)
int	sol::detail::lua_cfunction_trampoline (lua_State *L, lua_CFunction f)
void	sol::stack::luajit_exception_handler (lua_State *L, int(*handler)(lua_State *, lua_CFunction)=detail::c_trampoline)
void	sol::stack::luajit_exception_off (lua_State *L)
lua_State *	sol::main_thread (lua_State *L, lua_State *backup_if_unsupported=nullptr)
template<std::size_t N>
const char *	sol::detail::make_chunk_name (const string_view &code, const std::string &chunkname, char(&basechunkname)[N])
template<typename... Args>
closure< Args... >	sol::make_closure (lua_CFunction f, Args &&...args)
template<typename T >
lua_CFunction	sol::detail::make_destructor (std::true_type)
template<typename T >
lua_CFunction	sol::detail::make_destructor (std::false_type)
template<typename T >
lua_CFunction	sol::detail::make_destructor ()
template<typename T >
auto	sol::make_light (T &l)
template<typename T >
object	sol::make_object (lua_State *L, T &&value)
template<typename T , typename... Args>
object	sol::make_object (lua_State *L, Args &&...args)
template<typename T >
object	sol::make_object_userdata (lua_State *L, T &&value)
template<typename T , typename... Args>
object	sol::make_object_userdata (lua_State *L, Args &&...args)
template<class T = detail::i_am_secret, class U , class Ret = detail::conditional_t<std::is_same<T, detail::i_am_secret>::value, detail::decay_t<U>, T>>
constexpr optional< Ret >	sol::make_optional (U &&v)
template<class T , class... Args>
constexpr optional< T >	sol::make_optional (Args &&...args)
template<class T , class U , class... Args>
constexpr optional< T >	sol::make_optional (std::initializer_list< U > il, Args &&...args)
template<typename R = reference, bool should_pop = !is_stack_based_v<R>, typename T >
R	sol::make_reference (lua_State *L, T &&value)
template<typename T , typename R = reference, bool should_pop = !is_stack_based_v<R>, typename... Args>
R	sol::make_reference (lua_State *L, Args &&...args)
template<typename R = reference, bool should_pop = !is_stack_based_v<R>, typename T >
R	sol::make_reference_userdata (lua_State *L, T &&value)
template<typename T , typename R = reference, bool should_pop = !is_stack_based_v<R>, typename... Args>
R	sol::make_reference_userdata (lua_State *L, Args &&...args)
template<typename Arg >
std::string	sol::u_detail::make_string (Arg &&arg)
auto	sol::u_detail::make_string_view (string_view s)
auto	sol::u_detail::make_string_view (call_construction)
auto	sol::u_detail::make_string_view (meta_function mf)
auto	sol::u_detail::make_string_view (base_classes_tag)
template<typename T , typename Dx , typename... Args>
std::unique_ptr< T, Dx >	sol::detail::make_unique_deleter (Args &&...args)
template<typename T >
auto	sol::make_user (T &&u)
template<typename T >
optional< usertype_storage< T > & >	sol::u_detail::maybe_get_usertype_storage (lua_State *L)
optional< usertype_storage_base & >	sol::u_detail::maybe_get_usertype_storage_base (lua_State *L, int index)
optional< usertype_storage_base & >	sol::u_detail::maybe_get_usertype_storage_base (lua_State *L, const char *gcmetakey)
bool	sol::stack::maybe_indexable (lua_State *L, int index=-1)
template<typename T >
int	sol::detail::member_default_to_string (std::true_type, lua_State *L)
template<typename T >
int	sol::detail::member_default_to_string (std::false_type, lua_State *L)
const std::array< std::string, 37 > &	sol::meta_function_names ()
template<typename T >
auto	sol::meta_registry_key (T &&key)
template<typename F >
void	sol::stack::modify_unique_usertype (const stack_reference &obj, F &&f)
template<typename T , typename F >
void	sol::stack::modify_unique_usertype_as (const stack_reference &obj, F &&f)
template<typename T >
int	sol::stack::stack_detail::msvc_is_ass_with_if_constexpr_push_enum (std::true_type, lua_State *L, const T &value)
template<typename T >
int	sol::stack::stack_detail::msvc_is_ass_with_if_constexpr_push_enum (std::false_type, lua_State *, const T &)
template<typename... Args, typename Handler >
bool	sol::stack::multi_check (lua_State *L, int index, Handler &&handler, record &tracking)
template<typename... Args, typename Handler >
bool	sol::stack::multi_check (lua_State *L, int index, Handler &&handler)
template<typename... Args>
bool	sol::stack::multi_check (lua_State *L, int index)
int	sol::stack::multi_push (lua_State *)
template<typename T , typename... Args>
int	sol::stack::multi_push (lua_State *L, T &&t, Args &&...args)
int	sol::stack::multi_push_reference (lua_State *)
template<typename T , typename... Args>
int	sol::stack::multi_push_reference (lua_State *L, T &&t, Args &&...args)
int	sol::u_detail::new_index_fail (lua_State *L)
int	sol::u_detail::new_index_target_fail (lua_State *L, void *)
int	sol::function_detail::no_construction_error (lua_State *L)
int	sol::no_panic (lua_State *, int, type, type, const char *=nullptr) noexcept
template<class T , class U >
constexpr bool	sol::operator!= (const optional< T > &lhs, const optional< U > &rhs)
	relop More...
template<class T >
constexpr bool	sol::operator!= (const optional< T > &lhs, nullopt_t) noexcept
	relop_nullopt More...
template<class T >
constexpr bool	sol::operator!= (nullopt_t, const optional< T > &rhs) noexcept
	relop_nullopt More...
template<class T , class U >
constexpr bool	sol::operator!= (const optional< T > &lhs, const U &rhs)
	relop_t More...
template<class T , class U >
constexpr bool	sol::operator!= (const U &lhs, const optional< T > &rhs)
	relop_t More...
bool	sol::operator!= (lua_nil_t, lua_nil_t)
bool	sol::operator!= (const stack_reference &l, const stack_reference &r)
bool	sol::operator!= (const stack_reference &lhs, const lua_nil_t &)
bool	sol::operator!= (const lua_nil_t &, const stack_reference &rhs)
template<bool lb, bool rb>
bool	sol::operator!= (const basic_reference< lb > &l, const basic_reference< rb > &r)
template<bool lb>
bool	sol::operator!= (const basic_reference< lb > &l, const stack_reference &r)
template<bool rb>
bool	sol::operator!= (const stack_reference &l, const basic_reference< rb > &r)
template<bool lb>
bool	sol::operator!= (const basic_reference< lb > &lhs, const lua_nil_t &)
template<bool rb>
bool	sol::operator!= (const lua_nil_t &, const basic_reference< rb > &rhs)
template<typename Table , typename Key , typename T >
bool	sol::operator!= (T &&left, const table_proxy< Table, Key > &right)
template<typename Table , typename Key , typename T >
bool	sol::operator!= (const table_proxy< Table, Key > &right, T &&left)
template<typename Table , typename Key >
bool	sol::operator!= (lua_nil_t, const table_proxy< Table, Key > &right)
template<typename Table , typename Key >
bool	sol::operator!= (const table_proxy< Table, Key > &right, lua_nil_t)
template<typename proxy_t , bool is_const>
stack_iterator< proxy_t, is_const >	sol::operator+ (typename stack_iterator< proxy_t, is_const >::difference_type n, const stack_iterator< proxy_t, is_const > &r)
template<class T , class U >
constexpr bool	sol::operator< (const optional< T > &lhs, const optional< U > &rhs)
	relop More...
template<class T >
constexpr bool	sol::operator< (const optional< T > &, nullopt_t) noexcept
	relop_nullopt More...
template<class T >
constexpr bool	sol::operator< (nullopt_t, const optional< T > &rhs) noexcept
	relop_nullopt More...
template<class T , class U >
constexpr bool	sol::operator< (const optional< T > &lhs, const U &rhs)
	relop_t More...
template<class T , class U >
constexpr bool	sol::operator< (const U &lhs, const optional< T > &rhs)
	relop_t More...
template<class T , class U >
constexpr bool	sol::operator<= (const optional< T > &lhs, const optional< U > &rhs)
	relop More...
template<class T >
constexpr bool	sol::operator<= (const optional< T > &lhs, nullopt_t) noexcept
	relop_nullopt More...
template<class T >
constexpr bool	sol::operator<= (nullopt_t, const optional< T > &) noexcept
	relop_nullopt More...
template<class T , class U >
constexpr bool	sol::operator<= (const optional< T > &lhs, const U &rhs)
	relop_t More...
template<class T , class U >
constexpr bool	sol::operator<= (const U &lhs, const optional< T > &rhs)
	relop_t More...
template<class T , class U >
constexpr bool	sol::operator== (const optional< T > &lhs, const optional< U > &rhs)
	Compares two optional objects. More...
template<class T >
constexpr bool	sol::operator== (const optional< T > &lhs, nullopt_t) noexcept
	Compares an optional to a nullopt More...
template<class T >
constexpr bool	sol::operator== (nullopt_t, const optional< T > &rhs) noexcept
	relop_nullopt More...
template<class T , class U >
constexpr bool	sol::operator== (const optional< T > &lhs, const U &rhs)
	Compares the optional with a value. More...
template<class T , class U >
constexpr bool	sol::operator== (const U &lhs, const optional< T > &rhs)
	relop_t More...
bool	sol::operator== (lua_nil_t, lua_nil_t)
bool	sol::operator== (const stack_reference &l, const stack_reference &r)
bool	sol::operator== (const stack_reference &lhs, const lua_nil_t &)
bool	sol::operator== (const lua_nil_t &, const stack_reference &rhs)
template<bool lb, bool rb>
bool	sol::operator== (const basic_reference< lb > &l, const basic_reference< rb > &r)
template<bool lb>
bool	sol::operator== (const basic_reference< lb > &l, const stack_reference &r)
template<bool rb>
bool	sol::operator== (const stack_reference &l, const basic_reference< rb > &r)
template<bool lb>
bool	sol::operator== (const basic_reference< lb > &lhs, const lua_nil_t &)
template<bool rb>
bool	sol::operator== (const lua_nil_t &, const basic_reference< rb > &rhs)
template<typename Table , typename Key , typename T >
bool	sol::operator== (T &&left, const table_proxy< Table, Key > &right)
template<typename Table , typename Key , typename T >
bool	sol::operator== (const table_proxy< Table, Key > &right, T &&left)
template<typename Table , typename Key >
bool	sol::operator== (lua_nil_t, const table_proxy< Table, Key > &right)
template<typename Table , typename Key >
bool	sol::operator== (const table_proxy< Table, Key > &right, lua_nil_t)
template<class T , class U >
constexpr bool	sol::operator> (const optional< T > &lhs, const optional< U > &rhs)
	relop More...
template<class T >
constexpr bool	sol::operator> (const optional< T > &lhs, nullopt_t) noexcept
	relop_nullopt More...
template<class T >
constexpr bool	sol::operator> (nullopt_t, const optional< T > &) noexcept
	relop_nullopt More...
template<class T , class U >
constexpr bool	sol::operator> (const optional< T > &lhs, const U &rhs)
	relop_t More...
template<class T , class U >
constexpr bool	sol::operator> (const U &lhs, const optional< T > &rhs)
	relop_t More...
template<class T , class U >
constexpr bool	sol::operator>= (const optional< T > &lhs, const optional< U > &rhs)
	relop More...
template<class T >
constexpr bool	sol::operator>= (const optional< T > &, nullopt_t) noexcept
	relop_nullopt More...
template<class T >
constexpr bool	sol::operator>= (nullopt_t, const optional< T > &rhs) noexcept
	relop_nullopt More...
template<class T , class U >
constexpr bool	sol::operator>= (const optional< T > &lhs, const U &rhs)
	relop_t More...
template<class T , class U >
constexpr bool	sol::operator>= (const U &lhs, const optional< T > &rhs)
	relop_t More...
template<class Opt , class F , class Ret = decltype(detail::invoke(std::declval<F>(), *std::declval<Opt>())), detail::enable_if_t<!std::is_void< Ret >::value > * = nullptr>
constexpr auto	sol::detail::optional_map_impl (Opt &&opt, F &&f) -> optional< Ret >
template<class Opt , class F , class Ret = decltype(detail::invoke(std::declval<F>(), *std::declval<Opt>())), detail::enable_if_t< std::is_void< Ret >::value > * = nullptr>
auto	sol::detail::optional_map_impl (Opt &&opt, F &&f) -> optional< monostate >
template<typename T >
int	sol::detail::oss_default_to_string (std::true_type, lua_State *L)
template<typename T >
int	sol::detail::oss_default_to_string (std::false_type, lua_State *L)
template<typename... Args>
decltype(auto)	sol::overload (Args &&...args)
template<typename... Functions, typename Match , typename... Args>
int	sol::call_detail::overload_match (Match &&matchfx, lua_State *L, int start, Args &&...args)
template<std::size_t... M, typename Match , typename... Args>
int	sol::call_detail::overload_detail::overload_match_arity (types<>, std::index_sequence<>, std::index_sequence< M... >, Match &&, lua_State *L, int, int, Args &&...)
template<typename Fx , typename... Fxs, std::size_t I, std::size_t... In, std::size_t... M, typename Match , typename... Args>
int	sol::call_detail::overload_detail::overload_match_arity (types< Fx, Fxs... >, std::index_sequence< I, In... >, std::index_sequence< M... >, Match &&matchfx, lua_State *L, int fxarity, int start, Args &&...args)
template<typename... Functions, typename Match , typename... Args>
int	sol::call_detail::overload_match_arity (Match &&matchfx, lua_State *L, int fxarity, int start, Args &&...args)
template<std::size_t... M, typename Match , typename... Args>
int	sol::call_detail::overload_detail::overload_match_arity_single (types<>, std::index_sequence<>, std::index_sequence< M... >, Match &&matchfx, lua_State *L, int fxarity, int start, Args &&...args)
template<typename Fx , std::size_t I, std::size_t... M, typename Match , typename... Args>
int	sol::call_detail::overload_detail::overload_match_arity_single (types< Fx >, std::index_sequence< I >, std::index_sequence< M... >, Match &&matchfx, lua_State *L, int fxarity, int start, Args &&...args)
template<typename Fx , typename Fx1 , typename... Fxs, std::size_t I, std::size_t I1, std::size_t... In, std::size_t... M, typename Match , typename... Args>
int	sol::call_detail::overload_detail::overload_match_arity_single (types< Fx, Fx1, Fxs... >, std::index_sequence< I, I1, In... >, std::index_sequence< M... >, Match &&matchfx, lua_State *L, int fxarity, int start, Args &&...args)
template<typename R , typename W >
auto &	sol::call_detail::pick (std::true_type, property_wrapper< R, W > &f)
template<typename R , typename W >
auto &	sol::call_detail::pick (std::false_type, property_wrapper< R, W > &f)
template<bool b>
lua_State *	sol::detail::pick_main_thread (lua_State *L, lua_State *backup_if_unsupported=nullptr)
template<typename F , typename... Args>
auto	sol::policies (F &&f, Args &&...args)
template<typename T >
decltype(auto)	sol::stack::pop (lua_State *L)
template<bool top_level = false>
push_popper_n< top_level >	sol::stack::pop_n (lua_State *L, int x)
template<bool global = false, bool raw = false, typename C = detail::non_lua_nil_t, typename Key >
probe	sol::stack::probe_get_field (lua_State *L, Key &&key)
template<bool global = false, bool raw = false, typename C = detail::non_lua_nil_t, typename Key >
probe	sol::stack::probe_get_field (lua_State *L, Key &&key, int tableindex)
template<bool global = false, typename C = detail::non_lua_nil_t, typename Key >
probe	sol::stack::probe_raw_get_field (lua_State *L, Key &&key)
template<bool global = false, typename C = detail::non_lua_nil_t, typename Key >
probe	sol::stack::probe_raw_get_field (lua_State *L, Key &&key, int tableindex)
template<typename F , typename G >
decltype(auto)	sol::property (F &&f, G &&g)
template<typename F >
decltype(auto)	sol::property (F &&f)
bool	sol::detail::property_always_true (meta_function)
template<typename T >
auto	sol::protect (T &&value)
template<typename T >
T *	sol::detail::ptr (T &val)
template<typename T >
T *	sol::detail::ptr (std::reference_wrapper< T > val)
template<typename T >
T *	sol::detail::ptr (T *val)
template<typename T , typename... Args>
int	sol::stack::push (lua_State *L, T &&t, Args &&...args)
template<typename T , typename Arg , typename... Args, typename = std::enable_if_t<!std::is_same<T, Arg>::value>>
int	sol::stack::push (lua_State *L, Arg &&arg, Args &&...args)
template<typename T >
int	sol::stack::stack_detail::push_as_upvalues (lua_State *L, T &item)
int	sol::stack::push_environment_of (lua_State *L, int index=-1)
template<typename T >
int	sol::stack::push_environment_of (const T &target)
template<typename Fx >
auto	sol::push_invoke (Fx &&fx)
template<bool top_level = false, typename T >
push_popper< top_level, T >	sol::stack::push_pop (T &&x)
template<typename T >
push_popper_at	sol::stack::push_pop_at (T &&x)
template<typename T , typename Arg , typename... Args>
int	sol::stack::stack_detail::push_reference (lua_State *L, Arg &&arg, Args &&...args)
template<typename T , typename... Args>
int	sol::stack::push_reference (lua_State *L, T &&t, Args &&...args)
template<typename T , typename Arg , typename... Args>
int	sol::stack::push_reference (lua_State *L, Arg &&arg, Args &&...args)
int	sol::push_type_panic_string (lua_State *L, int index, type expected, type actual, string_view message, string_view aux_message) noexcept
template<typename T , typename... Args>
int	sol::stack::push_userdata (lua_State *L, T &&t, Args &&...args)
template<typename T , typename Arg , typename... Args>
int	sol::stack::push_userdata (lua_State *L, Arg &&arg, Args &&...args)
template<bool global = false, typename Key >
void	sol::stack::raw_get_field (lua_State *L, Key &&key)
template<bool global = false, typename Key >
void	sol::stack::raw_get_field (lua_State *L, Key &&key, int tableindex)
template<bool global = false, typename Key , typename Value >
void	sol::stack::raw_set_field (lua_State *L, Key &&key, Value &&value)
template<bool global = false, typename Key , typename Value >
void	sol::stack::raw_set_field (lua_State *L, Key &&key, Value &&value, int tableindex)
template<typename R , typename T >
auto	sol::readonly (R T::*v)
template<typename F >
decltype(auto)	sol::readonly_property (F &&f)
void	sol::register_main_thread (lua_State *L)
template<typename T >
int	sol::u_detail::register_usertype (lua_State *L, automagic_enrollments enrollments={})
void	sol::stack::remove (lua_State *L, int rawindex, int count)
template<typename T >
void	sol::detail::reserve (T &, std::size_t)
template<typename T , typename Al >
void	sol::detail::reserve (std::vector< T, Al > &vec, std::size_t hint)
template<typename T , typename Tr , typename Al >
void	sol::detail::reserve (std::basic_string< T, Tr, Al > &str, std::size_t hint)
template<typename... Args, typename R >
constexpr auto	sol::resolve (R fun_ptr(Args...)) -> R(*)(Args...)
template<typename Sig >
constexpr Sig *	sol::resolve (Sig *fun_ptr)
template<typename... Args, typename R , typename C >
constexpr auto	sol::resolve (R(C::*mem_ptr)(Args...)) -> R(C::*)(Args...)
template<typename Sig , typename C >
constexpr Sig C::*	sol::resolve (Sig C::*mem_ptr)
template<typename... Sig, typename F , meta::disable< std::is_function< meta::unqualified_t< F >>> = meta::enabler>
constexpr auto	sol::resolve (F &&f) -> decltype(detail::resolve_i(types< Sig... >(), std::forward< F >(f)))
template<typename F , typename U = meta::unqualified_t<F>>
constexpr auto	sol::detail::resolve_f (std::true_type, F &&f) -> decltype(resolve_i(types< meta::function_signature_t< decltype(&U::operator())>>(), std::forward< F >(f)))
template<typename F >
constexpr void	sol::detail::resolve_f (std::false_type, F &&)
template<typename R , typename... Args, typename F , typename = std::invoke_result_t<meta::unqualified_t<F>, Args...>>
constexpr auto	sol::detail::resolve_i (types< R(Args...)>, F &&) -> R(meta::unqualified_t< F >::*)(Args...)
template<typename F , typename U = meta::unqualified_t<F>>
constexpr auto	sol::detail::resolve_i (types<>, F &&f) -> decltype(resolve_f(meta::has_deducible_signature< U >(), std::forward< F >(f)))
template<typename... Args, typename F , typename R = std::invoke_result_t<F&, Args...>>
constexpr auto	sol::detail::resolve_i (types< Args... >, F &&f) -> decltype(resolve_i(types< R(Args...)>(), std::forward< F >(f)))
template<typename Sig , typename C >
constexpr Sig C::*	sol::detail::resolve_v (std::false_type, Sig C::*mem_func_ptr)
template<typename Sig , typename C >
constexpr Sig C::*	sol::detail::resolve_v (std::true_type, Sig C::*mem_variable_ptr)
void	sol::stack::script (lua_State *L, lua_Reader reader, void *data, const std::string &chunkname=detail::default_chunk_name(), load_mode mode=load_mode::any)
void	sol::stack::script (lua_State *L, const string_view &code, const std::string &chunkname=detail::default_chunk_name(), load_mode mode=load_mode::any)
protected_function_result	sol::script_default_on_error (lua_State *L, protected_function_result pfr)
void	sol::stack::script_file (lua_State *L, const std::string &filename, load_mode mode=load_mode::any)
protected_function_result	sol::script_pass_on_error (lua_State *, protected_function_result result)
protected_function_result	sol::script_throw_on_error (lua_State *L, protected_function_result result)
template<bool is_yielding, typename Fx , typename... Args>
void	sol::function_detail::select (lua_State *L, Fx &&fx, Args &&...args)
template<bool is_yielding, typename R , typename... A, typename Fx , typename... Args>
void	sol::function_detail::select_convertible (types< R(A...)>, lua_State *L, Fx &&fx, Args &&...args)
template<bool is_yielding, typename Fx , typename... Args>
void	sol::function_detail::select_convertible (types<>, lua_State *L, Fx &&fx, Args &&...args)
template<bool is_yielding, typename Fx , typename... Args>
void	sol::function_detail::select_member_function (lua_State *L, Fx &&fx, Args &&...args)
template<bool is_yielding, typename Fx , typename T , typename... Args>
void	sol::function_detail::select_member_function_with (lua_State *L, Fx &&fx, T &&obj, Args &&...args)
template<bool is_yielding, typename Fx , typename... Args>
void	sol::function_detail::select_member_variable (lua_State *L, Fx &&fx, Args &&...args)
template<bool is_yielding, bool no_trampoline, typename Fx , typename... Args>
void	sol::function_detail::select_set_fx (lua_State *L, Args &&...args)
void	sol::set_default_exception_handler (lua_State *L, exception_handler_function exf=&detail::default_exception_handler)
template<typename T >
static void	sol::detail::set_default_handler (lua_State *L, const T &ref)
void	sol::set_default_state (lua_State *L, lua_CFunction panic_function=&default_at_panic, lua_CFunction traceback_function=c_call< decltype(&default_traceback_error_handler),&default_traceback_error_handler >, exception_handler_function exf=detail::default_exception_handler)
template<typename T , typename E >
void	sol::set_environment (const basic_environment< E > &env, const T &target)
template<bool global = false, bool raw = false, typename Key , typename Value >
void	sol::stack::set_field (lua_State *L, Key &&key, Value &&value)
template<bool global = false, bool raw = false, typename Key , typename Value >
void	sol::stack::set_field (lua_State *L, Key &&key, Value &&value, int tableindex)
template<typename T >
int	sol::stack::set_ref (lua_State *L, T &&arg, int tableindex=-2)
template<typename T >
void	sol::stack::stack_detail::set_undefined_methods_on (stack_reference)
template<typename T >
const std::string &	sol::detail::short_demangle ()
std::string	sol::detail::short_demangle_from_type_name (std::string realname)
template<typename T >
std::string	sol::detail::short_demangle_once ()
void	sol::detail::stack_fail (int, int)
template<lua_CFunction f>
int	sol::detail::static_trampoline (lua_State *L)
template<lua_CFunction_noexcept f>
int	sol::detail::static_trampoline_noexcept (lua_State *L) noexcept
template<class T >
tag	sol::detail::swap_adl_tests::swap (T &, T &)
template<class T , std::size_t N>
tag	sol::detail::swap_adl_tests::swap (T(&a)[N], T(&b)[N])
template<class T , detail::enable_if_t< std::is_move_constructible< T >::value > * = nullptr, detail::enable_if_t< detail::is_swappable< T >::value > * = nullptr>
void	sol::swap (optional< T > &lhs, optional< T > &rhs) noexcept(noexcept(lhs.swap(rhs)))
	template <class t>=""> swap(optional<T> &lhs, optional<T> &rhs); More...
template<typename... Tn>
tie_t< std::remove_reference_t< Tn >... >	sol::adl_barrier_detail::tie (Tn &&...argn)
const std::string &	sol::to_string (call_status c)
const std::string &	sol::to_string (load_status c)
const std::string &	sol::to_string (load_mode c)
const std::string &	sol::to_string (meta_function mf)
const string_view &	sol::unicode::to_string (error_code ec)
int	sol::stack::top (lua_State *L)
std::size_t	sol::total_memory_used (lua_State *L)
template<typename Fx , typename... Args>
int	sol::detail::trampoline (lua_State *L, Fx &&f, Args &&...args)
template<typename... X>
decltype(auto)	sol::meta::tuplefy (X &&...x)
void	sol::type_assert (lua_State *L, int index, type expected, type actual) noexcept(false)
void	sol::type_assert (lua_State *L, int index, type expected)
void	sol::type_error (lua_State *L, int expected, int actual) noexcept(false)
void	sol::type_error (lua_State *L, type expected, type actual) noexcept(false)
std::string	sol::type_name (lua_State *L, type t)
type	sol::type_of (lua_State *L, int index)
template<typename T >
type	sol::type_of ()
int	sol::type_panic_c_str (lua_State *L, int index, type expected, type actual, const char *message=nullptr) noexcept(false)
int	sol::type_panic_string (lua_State *L, int index, type expected, type actual, string_view message="") noexcept(false)
template<typename F , F fx>
int	sol::detail::typed_static_trampoline (lua_State *L)
template<typename T >
decltype(auto)	sol::stack::stack_detail::unchecked_get (lua_State *L, int index, record &tracking)
template<typename T >
decltype(auto)	sol::stack::stack_detail::unchecked_unqualified_get (lua_State *L, int index, record &tracking)
template<typename T >
int	sol::detail::unique_destruct (lua_State *L)
template<typename T , typename Handler >
bool	sol::stack::unqualified_check (lua_State *L, int index, Handler &&handler, record &tracking)
template<typename T , typename Handler >
bool	sol::stack::unqualified_check (lua_State *L, int index, Handler &&handler)
template<typename T >
bool	sol::stack::unqualified_check (lua_State *L, int index=-lua_size< meta::unqualified_t< T >>::value)
template<typename T , typename Handler >
decltype(auto)	sol::stack::unqualified_check_get (lua_State *L, int index, Handler &&handler, record &tracking)
template<typename T , typename Handler >
decltype(auto)	sol::stack::unqualified_check_get (lua_State *L, int index, Handler &&handler)
template<typename T >
decltype(auto)	sol::stack::unqualified_check_get (lua_State *L, int index=-lua_size< meta::unqualified_t< T >>::value)
template<typename T >
auto	sol::stack::unqualified_get (lua_State *L, int index, record &tracking) -> decltype(stack_detail::unchecked_unqualified_get< T >(L, index, tracking))
template<typename T >
decltype(auto)	sol::stack::unqualified_get (lua_State *L, int index=-lua_size< meta::unqualified_t< T >>::value)
template<typename T , typename Handler >
bool	sol::stack::stack_detail::unqualified_interop_check (lua_State *L, int index, type index_type, Handler &&handler, record &tracking)
template<typename T >
decltype(auto)	sol::stack::stack_detail::unqualified_interop_get (lua_State *L, int index, void *unadjusted_pointer, record &tracking)
template<typename T >
auto	sol::detail::unwrap (T &&item) -> decltype(std::forward< T >(item))
template<typename T >
T &	sol::detail::unwrap (std::reference_wrapper< T > arg)
template<typename T >
int	sol::detail::user_alloc_destruct (lua_State *L)
template<typename T >
T *	sol::detail::user_allocate (lua_State *L)
template<typename T >
int	sol::detail::usertype_alloc_destruct (lua_State *L)
template<typename T >
T *	sol::detail::usertype_allocate (lua_State *L)
template<typename T >
T **	sol::detail::usertype_allocate_pointer (lua_State *L)
template<typename T , typename Real >
void	sol::detail::usertype_unique_alloc_destroy (void *memory)
template<typename T , typename Real >
Real *	sol::detail::usertype_unique_allocate (lua_State *L, T **&pref, unique_destructor *&dx, unique_tag *&id)
template<class , class >
std::false_type	sol::detail::swap_adl_tests::uses_std (...)
template<typename It >
decoded_result< It >	sol::unicode::utf16_to_code_point (It it, It last)
template<typename It >
decoded_result< It >	sol::unicode::utf32_to_code_point (It it, It last)
template<typename It >
decoded_result< It >	sol::unicode::utf8_to_code_point (It it, It last)
template<typename V >
auto	sol::var (V &&v)
struct	sol::detail::void ())
template<typename F >
decltype(auto)	sol::writeonly_property (F &&f)
bool	sol::detail::xmovable (lua_State *leftL, lua_State *rightL)
template<typename F >
yielding_t< std::decay_t< F > >	sol::yielding (F &&f)

Variables
template<typename T , typename... Args>
constexpr bool	sol::meta::all_v = all<T, Args...>::value
template<typename... Args>
constexpr bool	sol::detail::any_is_constructor_v = any_is_constructor<Args...>::value
template<typename... Args>
constexpr bool	sol::detail::any_is_destructor_v = any_is_destructor<Args...>::value
template<typename T , typename... Args>
constexpr bool	sol::meta::any_same_v = any_same<T, Args...>::value
template<typename T , typename... Args>
constexpr bool	sol::meta::any_v = any<T, Args...>::value
template<typename T >
constexpr auto	sol::detail::associated_nullopt_v = associated_nullopt<T>::value
const auto	sol::base_classes = base_classes_tag()
constexpr const int	sol::u_detail::base_walking_failed_index = -32467
template<bool B>
constexpr bool	sol::meta::boolean_v = boolean<B>::value
constexpr auto	sol::bytecode_dump_writer = &basic_insert_dump_writer<bytecode>
const auto	sol::call_constructor = call_construction{}
template<template< typename... > class Pred, typename... Ts>
constexpr std::size_t	sol::meta::count_even_for_pack_v = count_even_for_pack<Pred, Ts...>::value
template<template< typename... > class Pred, typename... Ts>
constexpr std::size_t	sol::meta::count_for_pack_v = count_for_pack<Pred, Ts...>::value
template<std::size_t Limit, template< typename... > class Pred, typename... Ts>
constexpr std::size_t	sol::meta::count_for_to_pack_v = count_for_to_pack<Limit, Pred, Ts...>::value
template<template< typename... > class Pred, typename... Ts>
constexpr std::size_t	sol::meta::count_odd_for_pack_v = count_odd_for_pack<Pred, Ts...>::value
template<template< typename... > class When, std::size_t Limit, template< typename... > class Pred, typename... Ts>
constexpr std::size_t	sol::meta::count_when_for_to_pack_v = count_when_for_to_pack<When, Limit, Pred, Ts...>::value
const new_table	sol::create = {}
constexpr create_if_nil_t	sol::create_if_nil = create_if_nil_t()
const auto	sol::default_constructor = constructors<types<>>{}
const destructor_wrapper< void >	sol::default_destructor {}
const bool	sol::detail::default_safe_function_calls
const auto	sol::detail::direct_error = direct_error_tag{}
constexpr const auto	sol::meta::enabler = enable_t::_
const env_key_t	sol::env_key = {}
constexpr const int	sol::u_detail::environment_index = 1
constexpr const int	sol::u_detail::exact_function_index = 4
struct sol::detail::global_tag	sol::detail::global_
template<typename T >
constexpr bool	sol::meta::has_begin_end_v = has_begin_end<T>::value
template<typename T >
constexpr bool	sol::detail::has_internal_marker_v = has_internal_marker<T>::value
constexpr std::in_place_t	sol::in_place {}
template<size_t I>
constexpr in_place_index_t< I >	sol::in_place_index {}
constexpr std::in_place_t	sol::in_place_of {}
template<typename T >
constexpr std::in_place_type_t< T >	sol::in_place_type {}
constexpr const int	sol::u_detail::index_function_index = 3
template<typename T >
constexpr bool	sol::meta::meta_detail::is_adl_sol_lua_check_get_v = meta::is_detected_v<adl_sol_lua_check_get_test_t, T>
template<typename T >
constexpr bool	sol::meta::meta_detail::is_adl_sol_lua_check_v = meta::is_detected_v<adl_sol_lua_check_test_t, T>
template<typename T >
constexpr bool	sol::meta::meta_detail::is_adl_sol_lua_get_v = meta::is_detected_v<adl_sol_lua_get_test_t, T>
template<typename T >
constexpr bool	sol::meta::meta_detail::is_adl_sol_lua_interop_check_v = meta::is_detected_v<adl_sol_lua_interop_check_test_t, T>
template<typename T >
constexpr bool	sol::meta::meta_detail::is_adl_sol_lua_interop_get_v = meta::is_detected_v<adl_sol_lua_interop_get_test_t, T>
template<typename T , typename... Args>
constexpr bool	sol::meta::meta_detail::is_adl_sol_lua_push_exact_v = meta::is_detected_v<adl_sol_lua_push_exact_test_t, T, Args...>
template<typename... Args>
constexpr bool	sol::meta::meta_detail::is_adl_sol_lua_push_v = meta::is_detected_v<adl_sol_lua_push_test_t, Args...>
template<typename T >
constexpr bool	sol::is_base_rebindable_non_void_v = is_base_rebindable_non_void<T>::value
template<typename T >
constexpr bool	sol::is_base_rebindable_v = is_base_rebindable<T>::value
template<typename T , typename Char >
constexpr bool	sol::meta::is_c_str_of_v = is_c_str_of<T, Char>::value
template<typename T >
constexpr bool	sol::meta::is_c_str_v = is_c_str<T>::value
template<typename T >
constexpr bool	sol::meta::is_callable_v = is_callable<T>::value
template<typename T >
constexpr bool	sol::detail::is_constructor_v = is_constructor<T>::value
template<typename T >
constexpr bool	sol::is_container_v = is_container<T>::value
template<template< class... > class Trait, class... Args>
constexpr bool	sol::meta::is_detected_v = is_detected<Trait, Args...>::value
template<typename T >
constexpr bool	sol::is_environment_v = is_environment<T>::value
template<typename T >
constexpr bool	sol::meta::is_initializer_list_v = is_initializer_list<T>::value
template<typename T >
constexpr bool	sol::is_lightuserdata_v = is_lightuserdata<T>::value
template<typename T >
constexpr bool	sol::is_lua_c_function_v = is_lua_c_function<T>::value
template<typename T >
constexpr bool	sol::is_lua_primitive_v = is_lua_primitive<T>::value
template<typename T >
constexpr bool	sol::is_lua_reference_or_proxy_v = is_lua_reference_or_proxy<T>::value
template<typename T >
constexpr bool	sol::is_lua_reference_v = is_lua_reference<T>::value
template<typename T >
constexpr bool	sol::meta::is_member_object_v = is_member_object<T>::value
template<typename T >
constexpr bool	sol::detail::is_non_factory_constructor_v = is_non_factory_constructor<T>::value
template<typename T >
constexpr bool	sol::meta::is_optional_v = is_optional<T>::value
template<typename T >
constexpr bool	sol::meta::is_pointer_like_v = is_pointer_like<T>::value
template<typename T >
constexpr bool	sol::detail::is_policy_v = is_policy<T>::value
template<typename T , template< typename... > class Templ>
constexpr bool	sol::meta::is_specialization_of_v = is_specialization_of<std::remove_cv_t<T>, Templ>::value
template<typename T >
constexpr bool	sol::is_stack_based_v = is_stack_based<T>::value
template<typename T >
constexpr bool	sol::is_stack_table_v = is_stack_table<T>::value
template<typename T , typename CharT = char>
constexpr bool	sol::meta::is_string_constructible_v = is_string_constructible<T, CharT>::value
template<typename T >
constexpr bool	sol::meta::is_string_like_v = is_string_like<T>::value
template<typename T , typename CharT = char>
constexpr bool	sol::meta::is_string_literal_array_of_v = is_string_literal_array_of<T, CharT>::value
template<typename T >
constexpr bool	sol::meta::is_string_literal_array_v = is_string_literal_array<T>::value
template<typename T , typename CharT >
constexpr bool	sol::meta::is_string_of_v = is_string_of<T, CharT>::value
template<typename T , typename CharT >
constexpr bool	sol::meta::is_string_view_of_v = is_string_view_of<T, CharT>::value
template<typename T >
constexpr bool	sol::is_table_like_v = is_table_like<T>::value
template<typename T >
constexpr bool	sol::is_table_v = is_table<T>::value
template<typename T >
constexpr bool	sol::is_transparent_argument_v = is_transparent_argument<T>::value
template<typename T >
constexpr bool	sol::meta::is_tuple_v = is_tuple<T>::value
template<typename T >
constexpr bool	sol::is_unique_usertype_v = is_unique_usertype<T>::value
template<typename T >
constexpr bool	sol::is_userdata_v = is_userdata<T>::value
constexpr const int	sol::u_detail::lookup_failed_index = -42469
constexpr lua_nil_t	sol::lua_nil {}
template<typename T >
constexpr int	sol::lua_size_v = lua_size<T>::value
template<typename T >
constexpr type	sol::lua_type_of_v = lua_type_of<T>::value
constexpr const int	sol::u_detail::magic_index = 5
const metatable_key_t	sol::metatable_key = {}
template<typename T >
constexpr bool	sol::meta::neg_v = neg<T>::value
constexpr nested_tag_t	sol::nested_tag {}
constexpr const int	sol::u_detail::new_index_function_index = 4
constexpr const nil_t &	sol::nil = lua_nil
const auto	sol::no_constructor = no_construction{}
const no_metatable_t	sol::no_metatable = {}
struct sol::detail::no_safety_tag	sol::detail::no_safety
constexpr const char *	sol::detail::not_a_number = "not a numeric type"
constexpr const char *	sol::detail::not_a_number_integral = "not a numeric type that fits exactly an integer (number maybe has significant decimals)"
constexpr const char *	sol::detail::not_a_number_or_number_string = "not a numeric type or numeric string"
constexpr const char *	sol::detail::not_a_number_or_number_string_integral = "not a numeric type or a numeric string that fits exactly an integer (e.g. number maybe has significant decimals)"
constexpr const char *	sol::detail::not_enough_stack_space = "not enough space left on Lua stack"
constexpr const char *	sol::stack::stack_detail::not_enough_stack_space = "not enough space left on Lua stack"
constexpr const char *	sol::detail::not_enough_stack_space_environment = "not enough space left on Lua stack to retrieve environment"
constexpr const char *	sol::stack::stack_detail::not_enough_stack_space_environment = "not enough space left on Lua stack to retrieve environment"
constexpr const char *	sol::detail::not_enough_stack_space_floating = "not enough space left on Lua stack for a floating point number"
constexpr const char *	sol::stack::stack_detail::not_enough_stack_space_floating = "not enough space left on Lua stack for a floating point number"
constexpr const char *	sol::detail::not_enough_stack_space_generic = "not enough space left on Lua stack to push valuees"
constexpr const char *	sol::stack::stack_detail::not_enough_stack_space_generic = "not enough space left on Lua stack to push valuees"
constexpr const char *	sol::detail::not_enough_stack_space_integral = "not enough space left on Lua stack for an integral number"
constexpr const char *	sol::stack::stack_detail::not_enough_stack_space_integral = "not enough space left on Lua stack for an integral number"
constexpr const char *	sol::detail::not_enough_stack_space_meta_function_name = "not enough space left on Lua stack for the name of a meta_function"
constexpr const char *	sol::stack::stack_detail::not_enough_stack_space_meta_function_name = "not enough space left on Lua stack for the name of a meta_function"
constexpr const char *	sol::detail::not_enough_stack_space_string = "not enough space left on Lua stack for a string"
constexpr const char *	sol::stack::stack_detail::not_enough_stack_space_string = "not enough space left on Lua stack for a string"
constexpr const char *	sol::detail::not_enough_stack_space_userdata = "not enough space left on Lua stack to create a sol3 userdata"
constexpr const char *	sol::stack::stack_detail::not_enough_stack_space_userdata = "not enough space left on Lua stack to create a sol3 userdata"
constexpr override_value_t	sol::override_value = override_value_t()
constexpr const char *	sol::detail::protected_function_error = "caught (...) unknown error during protected_function call"
constexpr std::array< string_view, 9 >	sol::detail::removals
constexpr const int	sol::u_detail::simple_usertype_storage_index = 2
constexpr const lua_Integer	sol::u_detail::toplevel_magic = static_cast<lua_Integer>(0xCCC2CCC1)
const type_panic_t	sol::type_panic = {}
const unchecked_t	sol::detail::unchecked = unchecked_t{}
constexpr update_if_empty_t	sol::update_if_empty = update_if_empty_t()
constexpr const int	sol::u_detail::usertype_storage_base_index = 3
constexpr const int	sol::u_detail::usertype_storage_index = 2
template<class T , class U >
std::is_same< decltype(swap(std::declval< T & >), std::declval< U & >))), tag >	sol::detail::swap_adl_tests::uses_std (int)
const yield_tag_t	sol::detail::yield_tag = yield_tag_t {}

Macro Definition Documentation

#define COMPAT53_API   static inline

Definition at line 2486 of file sol.hpp.

#define COMPAT53_CONCAT	(		a,
			b
	)		COMPAT53_CONCAT_HELPER(a, b)

Definition at line 2495 of file sol.hpp.

#define COMPAT53_CONCAT_HELPER	(		a,
			b
	)		a##b

Definition at line 2494 of file sol.hpp.

#define COMPAT53_INCLUDE_SOURCE   1

Definition at line 2452 of file sol.hpp.

#define COMPAT53_PREFIX   kp_compat53

Definition at line 2478 of file sol.hpp.

#define KEPLER_PROJECT_COMPAT53_C_

Definition at line 2874 of file sol.hpp.

#define KEPLER_PROJECT_COMPAT53_H_

Definition at line 2458 of file sol.hpp.

#define LUA_KFUNCTION

(

_name

)

static int (_name)(lua_State *L, int status, lua_KContext ctx)

Definition at line 2858 of file sol.hpp.

#define NOT_KEPLER_PROJECT_COMPAT54_H_

Definition at line 3717 of file sol.hpp.

#define SOL_ALIGN_MEMORY_I_   SOL_DEFAULT_ON

Definition at line 525 of file sol.hpp.

#define SOL_ALL_SAFETIES_ON_I_   SOL_DEFAULT_OFF

Definition at line 197 of file sol.hpp.

#define SOL_BASE_CLASSES	(		T,
			...
	)

Value:

namespace sol {                                   \
                template <>                                  \
                struct base<T> : std::true_type {            \
                        typedef ::sol::types<__VA_ARGS__> type; \
                };                                           \
        }                                                 \
	void a_sol3_detail_function_decl_please_no_collide()

Definition at line 833 of file sol.hpp.

#define SOL_COMPILER_CLANG_I_   SOL_OFF

Definition at line 73 of file sol.hpp.

#define SOL_COMPILER_EDG_I_   SOL_OFF

Definition at line 75 of file sol.hpp.

#define SOL_COMPILER_FRONTEND_MINGW_I_   SOL_OFF

Definition at line 82 of file sol.hpp.

#define SOL_COMPILER_GCC_I_   SOL_OFF

Definition at line 74 of file sol.hpp.

#define SOL_COMPILER_VCXX_I_   SOL_OFF

Definition at line 76 of file sol.hpp.

#define SOL_CONTAINER_START_INDEX_I_   1

Definition at line 515 of file sol.hpp.

#define SOL_DEBUG_BUILD_I_   SOL_OFF

Definition at line 138 of file sol.hpp.

#define SOL_DEFAULT_AUTOMAGICAL_USERTYPES_I_   SOL_DEFAULT_ON

Definition at line 364 of file sol.hpp.

#define SOL_DEFAULT_OFF   -

Definition at line 55 of file sol.hpp.

#define SOL_DEFAULT_ON   +

Definition at line 54 of file sol.hpp.

#define SOL_DEFAULT_PASS_ON_ERROR_I_   SOL_OFF

Definition at line 454 of file sol.hpp.

#define SOL_DEPRECATED   [[deprecated]]

Definition at line 19612 of file sol.hpp.

#define SOL_DERIVED_CLASSES	(		T,
			...
	)

Value:

namespace sol {                                   \
                template <>                                  \
                struct derive<T> : std::true_type {          \
                        typedef ::sol::types<__VA_ARGS__> type; \
                };                                           \
        }                                                 \
	void a_sol3_detail_function_decl_please_no_collide()

Definition at line 841 of file sol.hpp.

#define SOL_EXCEPTIONS_I_   SOL_DEFAULT_ON

Definition at line 163 of file sol.hpp.

#define SOL_FILE_ID_SIZE_I_   2048

Definition at line 427 of file sol.hpp.

#define SOL_FORWARD_DETAIL_HPP

Definition at line 856 of file sol.hpp.

#define SOL_FORWARD_HPP

Definition at line 614 of file sol.hpp.

#define SOL_GET_FUNCTION_POINTER_UNSAFE_I_   SOL_DEFAULT_OFF

Definition at line 579 of file sol.hpp.

#define SOL_HPP

Definition at line 33 of file sol.hpp.

#define SOL_ID_SIZE_I_   512

Definition at line 419 of file sol.hpp.

#define SOL_INSIDE_UNREAL_ENGINE_I_   SOL_DEFAULT_OFF

Definition at line 558 of file sol.hpp.

#define SOL_IS_DEFAULT_OFF

(

OP_SYMBOL

)

((3 OP_SYMBOL 3 OP_SYMBOL 3) < 0)

Definition at line 50 of file sol.hpp.

#define SOL_IS_DEFAULT_ON

(

OP_SYMBOL

)

((3 OP_SYMBOL 3) > 3)

Definition at line 49 of file sol.hpp.

#define SOL_IS_OFF

(

OP_SYMBOL

)

((3 OP_SYMBOL 3) == 0)

Definition at line 48 of file sol.hpp.

#define SOL_IS_ON

(

OP_SYMBOL

)

((3 OP_SYMBOL 3) != 0)

Definition at line 47 of file sol.hpp.

#define SOL_LUA_VERSION   500

Definition at line 2372 of file sol.hpp.

#define SOL_LUA_VESION_I_   SOL_LUA_VERSION

Definition at line 2380 of file sol.hpp.

#define SOL_LUAJIT_VERSION_I_   0

Definition at line 2356 of file sol.hpp.

#define SOL_LUAL_STREAM_USE_CLOSE_FUNCTION_I_   SOL_DEFAULT_OFF

Definition at line 2438 of file sol.hpp.

#define SOL_MINGW_CCTYPE_IS_POISONED_I_   SOL_DEFAULT_OFF

Definition at line 586 of file sol.hpp.

#define SOL_NIL_I_   SOL_DEFAULT_ON

Definition at line 338 of file sol.hpp.

#define SOL_NUMBER_PRECISION_CHECKS_I_   SOL_DEFAULT_OFF

Definition at line 308 of file sol.hpp.

#define SOL_OFF   ^

Definition at line 53 of file sol.hpp.

#define SOL_ON   |

Definition at line 52 of file sol.hpp.

#define SOL_OPTIMIZATION_STRING_CONVERSION_STACK_SIZE_I_   1024

Definition at line 413 of file sol.hpp.

#define SOL_PLATFORM_APPLE_I_   SOL_OFF

Definition at line 110 of file sol.hpp.

#define SOL_PLATFORM_APPLE_IPHONE_I_   SOL_OFF

Definition at line 123 of file sol.hpp.

#define SOL_PLATFORM_ARM32_I_   SOL_OFF

Definition at line 99 of file sol.hpp.

#define SOL_PLATFORM_ARM64_I_   SOL_OFF

Definition at line 100 of file sol.hpp.

#define SOL_PLATFORM_BSDLIKE_I_   SOL_OFF

Definition at line 124 of file sol.hpp.

#define SOL_PLATFORM_LINUXLIKE_I_   SOL_OFF

Definition at line 120 of file sol.hpp.

#define SOL_PLATFORM_UNIXLIKE_I_   SOL_OFF

Definition at line 115 of file sol.hpp.

#define SOL_PLATFORM_WINDOWS_I_   SOL_OFF

Definition at line 105 of file sol.hpp.

#define SOL_PLATFORM_X16_I_   SOL_ON

Definition at line 86 of file sol.hpp.

#define SOL_PLATFORM_X64_I_   SOL_OFF

Definition at line 88 of file sol.hpp.

#define SOL_PLATFORM_X86_I_   SOL_OFF

Definition at line 87 of file sol.hpp.

#define SOL_PRINT_ERRORS_I_   SOL_OFF

Definition at line 442 of file sol.hpp.

#define SOL_PROPAGATE_EXCEPTIONS_I_   SOL_DEFAULT_OFF

Definition at line 2411 of file sol.hpp.

#define SOL_RTTI_I_   SOL_DEFAULT_ON

Definition at line 185 of file sol.hpp.

#define SOL_SAFE_FUNCTION_CALLS_I_   SOL_DEFAULT_OFF

Definition at line 257 of file sol.hpp.

#define SOL_SAFE_FUNCTION_OBJECTS_I_   SOL_DEFAULT_OFF

Definition at line 245 of file sol.hpp.

#define SOL_SAFE_GETTER_I_   SOL_DEFAULT_OFF

Definition at line 208 of file sol.hpp.

#define SOL_SAFE_NUMERICS_I_   SOL_DEFAULT_OFF

Definition at line 281 of file sol.hpp.

#define SOL_SAFE_PROXIES_I_   SOL_DEFAULT_OFF

Definition at line 269 of file sol.hpp.

#define SOL_SAFE_REFERENCES_I_   SOL_DEFAULT_OFF

Definition at line 232 of file sol.hpp.

#define SOL_SAFE_STACK_CHECK_I_   SOL_DEFAULT_OFF

Definition at line 293 of file sol.hpp.

#define SOL_SAFE_USERTYPE_I_   SOL_DEFAULT_OFF

Definition at line 220 of file sol.hpp.

#define SOL_STD_VARIANT_I_   SOL_DEFAULT_ON

Definition at line 385 of file sol.hpp.

#define SOL_STRINGS_ARE_NUMBERS_I_   SOL_DEFAULT_OFF

Definition at line 319 of file sol.hpp.

#define SOL_TL_MONOSTATE_INPLACE_MUTEX

Definition at line 4011 of file sol.hpp.

#define SOL_TL_OPTIONAL_11_CONSTEXPR   constexpr

Definition at line 4006 of file sol.hpp.

#define SOL_TL_OPTIONAL_IS_TRIVIALLY_COPY_ASSIGNABLE

(

T

)

std::is_trivially_copy_assignable<T>::value

Definition at line 3994 of file sol.hpp.

#define SOL_TL_OPTIONAL_IS_TRIVIALLY_COPY_CONSTRUCTIBLE

(

T

)

std::is_trivially_copy_constructible<T>::value

Definition at line 3993 of file sol.hpp.

#define SOL_TL_OPTIONAL_IS_TRIVIALLY_DESTRUCTIBLE

(

T

)

std::is_trivially_destructible<T>::value

Definition at line 3995 of file sol.hpp.

#define SOL_TL_OPTIONAL_VERSION_MAJOR   0

Definition at line 3941 of file sol.hpp.

#define SOL_TL_OPTIONAL_VERSION_MINOR   5

Definition at line 3942 of file sol.hpp.

#define SOL_TL_TRAITS_MUTEX

Definition at line 4022 of file sol.hpp.

#define SOL_USE_BOOST_I_   SOL_OFF

Definition at line 535 of file sol.hpp.

#define SOL_USE_COMPATIBILITY_LAYER_I_   SOL_DEFAULT_ON

Definition at line 569 of file sol.hpp.

#define SOL_USE_CXX_LUA_I_   SOL_OFF

Definition at line 471 of file sol.hpp.

#define SOL_USE_CXX_LUAJIT_I_   SOL_OFF

Definition at line 487 of file sol.hpp.

#define SOL_USE_INTEROP_I_   SOL_DEFAULT_OFF

Definition at line 326 of file sol.hpp.

#define SOL_USE_LUA_HPP_I_   SOL_DEFAULT_ON

Definition at line 505 of file sol.hpp.

#define SOL_USE_LUAJIT_EXCEPTION_TRAMPOLINE_I_   SOL_DEFAULT_OFF

Definition at line 2424 of file sol.hpp.

#define SOL_USE_LUAJIT_I_   SOL_DEFAULT_OFF

Definition at line 2340 of file sol.hpp.

#define SOL_USE_MOONJIT_I_   SOL_OFF

Definition at line 2362 of file sol.hpp.

#define SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_   SOL_DEFAULT_ON

Definition at line 406 of file sol.hpp.

#define SOL_USE_THREAD_LOCAL_I_   SOL_DEFAULT_ON

Definition at line 191 of file sol.hpp.

#define SOL_USE_UNSAFE_BASE_LOOKUP_I_   SOL_OFF

Definition at line 545 of file sol.hpp.

#define SOL_USERTYPE_TYPE_BINDING_INFO_I_   SOL_DEFAULT_ON

Definition at line 348 of file sol.hpp.

#define SOL_VERSION   ((SOL_VERSION_MAJOR * 100000) + (SOL_VERSION_MINOR * 100) + (SOL_VERSION_PATCH))

Definition at line 45 of file sol.hpp.

#define SOL_VERSION_MAJOR   3

Definition at line 41 of file sol.hpp.

#define SOL_VERSION_MINOR   5

Definition at line 42 of file sol.hpp.

#define SOL_VERSION_PATCH   0

Definition at line 43 of file sol.hpp.

#define SOL_VERSION_STRING   "3.5.0"

Definition at line 44 of file sol.hpp.