sol::detail Namespace Reference

Classes
struct	accumulate
struct	accumulate< C, v, V, T, Args... >
struct	accumulate_list
struct	accumulate_list< C, v, V, types< Args... > >
struct	as_pointer_tag
struct	as_reference_tag
struct	as_table_tag
struct	as_unique_tag
struct	as_value_tag
struct	associated_nullopt
struct	clean
struct	conjunction
struct	conjunction< B >
struct	conjunction< B, Bs... >
struct	default_construct
struct	default_destroy
struct	deleter
struct	deprecate_type
struct	direct_error_tag
struct	ebco
struct	ebco< T &&, tag >
struct	ebco< T &, tag >
struct	ebco< T, tag, std::enable_if_t<!std::is_reference_v< T > &&std::is_class_v< T > &&!std::is_final_v< T > > >
struct	error_result
struct	get_is_primitive
struct	get_is_primitive< T, false, true >
struct	get_is_primitive< T, true, false >
struct	get_is_primitive< T, true, true >
struct	i_am_secret
struct	implicit_wrapper
struct	indexed_insert
struct	inheritance
struct	invoke_result_impl
struct	invoke_result_impl< F, decltype(detail::invoke(std::declval< F >(), std::declval< Us >()...), void()), Us... >
struct	is_constructor
struct	is_constructor< factory_wrapper< Args... > >
struct	is_constructor< policy_wrapper< F, Policies... > >
struct	is_constructor< protect_t< T > >
struct	is_destructor
struct	is_destructor< destructor_wrapper< Fx > >
struct	is_non_factory_constructor
struct	is_non_factory_constructor< constructor_wrapper< Args... > >
struct	is_non_factory_constructor< constructors< Args... > >
struct	is_non_factory_constructor< no_construction >
struct	is_nothrow_swappable
struct	is_optional_impl
struct	is_optional_impl< optional< T > >
struct	is_speshul
struct	is_speshul< protected_function_result >
struct	is_speshul< unsafe_function_result >
struct	is_swappable
struct	is_swappable< T[N], T[N]>
struct	lua_type_of
struct	lua_type_of< as_table_t< T > >
struct	lua_type_of< basic_coroutine< Base > >
struct	lua_type_of< basic_environment< B > >
struct	lua_type_of< basic_function< Base, aligned > >
struct	lua_type_of< basic_lightuserdata< Base > >
struct	lua_type_of< basic_lua_table< Base > >
struct	lua_type_of< basic_metatable< Base > >
struct	lua_type_of< basic_object< Base > >
struct	lua_type_of< basic_protected_function< Base, aligned, Handler > >
struct	lua_type_of< basic_reference< b > >
struct	lua_type_of< basic_string_view< C, T > >
struct	lua_type_of< basic_table_core< b, Base > >
struct	lua_type_of< basic_thread< Base > >
struct	lua_type_of< basic_userdata< Base > >
struct	lua_type_of< basic_usertype< T, Base > >
struct	lua_type_of< bool >
struct	lua_type_of< char >
struct	lua_type_of< char16_t >
struct	lua_type_of< char16_t[N]>
struct	lua_type_of< char32_t >
struct	lua_type_of< char32_t[N]>
struct	lua_type_of< char[N]>
struct	lua_type_of< const char * >
struct	lua_type_of< const char16_t * >
struct	lua_type_of< const char32_t * >
struct	lua_type_of< const void * >
struct	lua_type_of< const wchar_t * >
struct	lua_type_of< detail::non_lua_nil_t >
struct	lua_type_of< env_key_t >
struct	lua_type_of< error >
struct	lua_type_of< light< T > >
struct	lua_type_of< lightuserdata_value >
struct	lua_type_of< lua_CFunction >
struct	lua_type_of< lua_nil_t >
struct	lua_type_of< lua_value >
struct	lua_type_of< meta_function >
struct	lua_type_of< metatable_key_t >
struct	lua_type_of< nested< T > >
struct	lua_type_of< new_table >
struct	lua_type_of< nullopt_t >
struct	lua_type_of< optional< T > >
struct	lua_type_of< stack_count >
struct	lua_type_of< stack_reference >
struct	lua_type_of< std::basic_string< C, T, A > >
struct	lua_type_of< std::function< Signature > >
struct	lua_type_of< std::initializer_list< T > >
struct	lua_type_of< std::nullptr_t >
struct	lua_type_of< std::optional< T > >
struct	lua_type_of< std::pair< A, B > >
struct	lua_type_of< std::remove_pointer_t< lua_CFunction > >
struct	lua_type_of< std::tuple< Args... > >
struct	lua_type_of< std::variant< Tn... > >
struct	lua_type_of< T * >
struct	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	lua_type_of< T, std::enable_if_t< std::is_enum_v< T > > >
struct	lua_type_of< T, std::enable_if_t< std::is_function_v< T > > >
struct	lua_type_of< this_environment >
struct	lua_type_of< this_main_state >
struct	lua_type_of< this_state >
struct	lua_type_of< type >
struct	lua_type_of< user< T > >
struct	lua_type_of< userdata_value >
struct	lua_type_of< variadic_args >
struct	lua_type_of< variadic_results >
struct	lua_type_of< void * >
struct	lua_type_of< wchar_t >
struct	lua_type_of< wchar_t[N]>
struct	no_comp
struct	no_prop
struct	no_safety_tag
struct	non_lua_nil_t
struct	optional_copy_assign_base
struct	optional_copy_assign_base< T, false >
struct	optional_copy_base
struct	optional_copy_base< T, false >
struct	optional_delete_assign_base
struct	optional_delete_assign_base< T, false, false >
struct	optional_delete_assign_base< T, false, true >
struct	optional_delete_assign_base< T, true, false >
struct	optional_delete_ctor_base
struct	optional_delete_ctor_base< T, false, false >
struct	optional_delete_ctor_base< T, false, true >
struct	optional_delete_ctor_base< T, true, false >
struct	optional_move_assign_base
struct	optional_move_assign_base< T, false >
struct	optional_move_base
struct	optional_move_base< T, false >
struct	optional_operations_base
struct	optional_storage_base
struct	optional_storage_base< T, true >
struct	policy_base_tag
struct	properties_enrollment_allowed
struct	protected_handler
struct	ref_clean
struct	returns_void_impl
struct	returns_void_impl< F, void_t< invoke_result_t< F, U... > >, U... >
struct	state_deleter
struct	std_shim
struct	std_shim< void >
struct	tagged
struct	unchecked_t
struct	unique_fallback
struct	unique_fallback< std::shared_ptr< T > >
struct	unique_fallback< std::unique_ptr< T, D > >
struct	voider
struct	with_function_tag
struct	yield_tag_t

Typedefs
using	swallow = std::initializer_list< int >
template<class T >
using	remove_const_t = typename std::remove_const< T >::type
template<class T >
using	remove_reference_t = typename std::remove_reference< T >::type
template<class T >
using	decay_t = typename std::decay< T >::type
template<bool E, class T = void>
using	enable_if_t = typename std::enable_if< E, T >::type
template<bool B, class T , class F >
using	conditional_t = typename std::conditional< B, T, F >::type
template<class F , class... Us>
using	invoke_result = invoke_result_impl< F, void, Us... >
template<class F , class... Us>
using	invoke_result_t = typename invoke_result< F, Us... >::type
template<class... Ts>
using	void_t = typename voider< Ts... >::type
template<class T >
using	is_optional = is_optional_impl< decay_t< T > >
template<class U >
using	fixup_void = conditional_t< std::is_void< U >::value, monostate, U >
template<class F , class U , class = invoke_result_t<F, U>>
using	get_map_return = optional< fixup_void< invoke_result_t< F, U > >>
template<class F , class... U>
using	returns_void = returns_void_impl< F, void, U... >
template<class T , class... U>
using	enable_if_ret_void = enable_if_t< returns_void< T &&, U... >::value >
template<class T , class... U>
using	disable_if_ret_void = enable_if_t<!returns_void< T &&, U... >::value >
template<class T , class U >
using	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	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	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	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<typename T >
using	is_policy = meta::is_specialization_of< T, policy_wrapper >
typedef int(*	lua_CFunction_noexcept) (lua_State *L) noexcept
template<typename T , typename... >
using	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 , typename... >
using	is_not_insert_mode = meta::neg< is_insert_mode< T > >
template<typename T >
using	is_msvc_callable_rigged = meta::any< meta::is_specialization_of< T, push_invoke_t >, meta::is_specialization_of< T, as_table_t >, meta::is_specialization_of< T, forward_as_value_t >, meta::is_specialization_of< T, as_container_t >, meta::is_specialization_of< T, nested >, meta::is_specialization_of< T, yielding_t > >
template<typename... Args>
using	any_is_constructor = meta::any< is_constructor< meta::unqualified_t< Args > >... >
template<typename... Args>
using	any_is_destructor = meta::any< is_destructor< meta::unqualified_t< Args > >... >
using	inheritance_check_function = decltype(&inheritance< void >::type_check)
using	inheritance_cast_function = decltype(&inheritance< void >::type_cast)
using	inheritance_unique_cast_function = decltype(&inheritance< void >::type_unique_cast< void >)
using	lua_reg_table = luaL_Reg[64]
using	unique_destructor = void(*)(void *)
using	unique_tag = detail::inheritance_unique_cast_function
using	typical_chunk_name_t = char[SOL_ID_SIZE_I_]
using	typical_file_chunk_name_t = char[SOL_FILE_ID_SIZE_I_]
template<typename T >
using	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<typename T >
using	array_return_type = meta::conditional_t< std::is_array< T >::value, std::add_lvalue_reference_t< T >, T >

Enumerations
enum	insert_mode { none = 0x0, update_if_empty = 0x01, override_value = 0x02, create_if_nil = 0x04 }

Functions
template<typename T >
auto	unwrap (T &&item) -> decltype(std::forward< T >(item))
template<typename T >
T &	unwrap (std::reference_wrapper< T > arg)
template<typename T >
decltype(auto)	deref (T &&item)
template<typename T >
decltype(auto)	deref_move_only (T &&item)
template<typename T >
T *	ptr (T &val)
template<typename T >
T *	ptr (std::reference_wrapper< T > val)
template<typename T >
T *	ptr (T *val)
int	handle_errors (lua_State *L, const error_result &er)
template<typename Fn , typename... Args, typename = enable_if_t<std::is_member_pointer<decay_t<Fn>>::value>, int = 0>
constexpr auto	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	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 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	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	optional_map_impl (Opt &&opt, F &&f) -> optional< monostate >
template<typename T , typename Dx , typename... Args>
std::unique_ptr< T, Dx >	make_unique_deleter (Args &&... args)
const char(&	default_exception_handler_name ())[11]
int	default_exception_handler (lua_State *L, optional< const std::exception &>, string_view what)
int	call_exception_handler (lua_State *L, optional< const std::exception &> maybe_ex, string_view what)
int	lua_cfunction_trampoline (lua_State *L, lua_CFunction f)
template<lua_CFunction f>
int	static_trampoline (lua_State *L)
template<lua_CFunction_noexcept f>
int	static_trampoline_noexcept (lua_State *L) noexcept
template<typename Fx , typename... Args>
int	trampoline (lua_State *L, Fx &&f, Args &&... args)
int	c_trampoline (lua_State *L, lua_CFunction f)
template<typename F , F fx>
int	typed_static_trampoline (lua_State *L)
template<typename T >
std::string	demangle_once ()
std::string	short_demangle_from_type_name (std::string realname)
template<typename T >
std::string	short_demangle_once ()
template<typename T >
const std::string &	demangle ()
template<typename T >
const std::string &	short_demangle ()
template<typename T >
constexpr bool	unique_is_null_noexcept () noexcept
template<typename T >
bool	unique_is_null (lua_State *L_, T &value_) noexcept(unique_is_null_noexcept< std::remove_cv_t< T >>())
template<typename T >
constexpr bool	unique_get_noexcept () noexcept
template<typename T >
auto	unique_get (lua_State *L_, T &value_) noexcept(unique_get_noexcept< std::remove_cv_t< T >>())
decltype(auto)	base_class_check_key ()
decltype(auto)	base_class_cast_key ()
decltype(auto)	base_class_index_propogation_key ()
decltype(auto)	base_class_new_index_propogation_key ()
void	accumulate_and_mark (const std::string &n, std::string &aux_message, int &marker)
bool	xmovable (lua_State *leftL, lua_State *rightL)
const char(&	default_main_thread_name ())[9]
template<bool b>
lua_State *	pick_main_thread (lua_State *L_, lua_State *backup_if_unsupported=nullptr)
void	stack_fail (int, int)
void *	alloc_newuserdata (lua_State *L, std::size_t bytesize)
constexpr std::uintptr_t	align (std::size_t alignment, std::uintptr_t ptr, std::size_t &space)
void *	align (std::size_t alignment, void *ptr, std::size_t &space)
constexpr std::uintptr_t	align_one (std::size_t alignment, std::size_t size, std::uintptr_t ptr)
template<typename... Args>
constexpr std::size_t	aligned_space_for (std::uintptr_t ptr)
template<typename... Args>
constexpr std::size_t	aligned_space_for ()
void *	align_usertype_pointer (void *ptr)
template<bool pre_aligned = false, bool pre_shifted = false>
void *	align_usertype_unique_destructor (void *ptr)
template<bool pre_aligned = false, bool pre_shifted = false>
void *	align_usertype_unique_tag (void *ptr)
template<typename T , bool pre_aligned = false, bool pre_shifted = false>
void *	align_usertype_unique (void *ptr)
template<typename T >
void *	align_user (void *ptr)
template<typename T >
T **	usertype_allocate_pointer (lua_State *L)
bool	attempt_alloc (lua_State *L, std::size_t ptr_align, std::size_t ptr_size, std::size_t value_align, std::size_t allocated_size, void *&pointer_adjusted, void *&data_adjusted)
bool	attempt_alloc_unique (lua_State *L, std::size_t ptr_align, std::size_t ptr_size, std::size_t real_align, std::size_t allocated_size, void *&pointer_adjusted, void *&dx_adjusted, void *&id_adjusted, void *&data_adjusted)
template<typename T >
T *	usertype_allocate (lua_State *L)
template<typename T , typename Real >
Real *	usertype_unique_allocate (lua_State *L, T **&pref, unique_destructor *&dx, unique_tag *&id)
template<typename T >
T *	user_allocate (lua_State *L)
template<typename T >
int	usertype_alloc_destroy (lua_State *L) noexcept
template<typename T >
int	unique_destroy (lua_State *L) noexcept
template<typename T >
int	user_alloc_destroy (lua_State *L) noexcept
template<typename T , typename Real >
void	usertype_unique_alloc_destroy (void *memory)
template<typename T >
int	cannot_destroy (lua_State *L)
template<typename T >
void	reserve (T &, std::size_t)
template<typename T , typename Al >
void	reserve (std::vector< T, Al > &vec, std::size_t hint)
template<typename T , typename Tr , typename Al >
void	reserve (std::basic_string< T, Tr, Al > &str, std::size_t hint)
bool	property_always_true (meta_function)
template<typename T >
lua_CFunction	make_destructor (std::true_type)
template<typename T >
lua_CFunction	make_destructor (std::false_type)
template<typename T >
lua_CFunction	make_destructor ()
template<typename T >
int	is_check (lua_State *L)
template<typename T >
int	member_default_to_string (std::true_type, lua_State *L)
template<typename T >
int	member_default_to_string (std::false_type, lua_State *L)
template<typename T >
int	adl_default_to_string (std::true_type, lua_State *L)
template<typename T >
int	adl_default_to_string (std::false_type, lua_State *L)
template<typename T >
int	oss_default_to_string (std::true_type, lua_State *L)
template<typename T >
int	oss_default_to_string (std::false_type, lua_State *L)
template<typename T >
int	default_to_string (lua_State *L)
template<typename T >
int	default_size (lua_State *L)
template<typename T , typename Op >
int	comparsion_operator_wrap (lua_State *L)
template<typename T , typename IFx , typename Fx >
void	insert_default_registrations (IFx &&ifx, Fx &&fx)
const std::string &	default_chunk_name ()
template<std::size_t N>
const char *	make_chunk_name (const string_view &code, const std::string &chunkname, char(&basechunkname)[N])
void	clear_entries (stack_reference r)
void	clear_entries (const reference &registry_reference)
template<std::size_t I, typename... Args, typename T >
stack_proxy	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	get (types< Arg, Args... >, meta::index_value< N >, meta::index_value< I >, const T &fr)
template<typename R , typename... Args, typename F , typename = std::invoke_result_t<meta::unqualified_t<F>, Args...>>
constexpr auto	resolve_i (types< R(Args...)>, F &&) -> R(meta::unqualified_t< F >::*)(Args...)
template<typename F , typename U = meta::unqualified_t<F>>
constexpr auto	resolve_f (std::true_type, F &&f) -> decltype(resolve_i(types< meta::function_signature_t< decltype(&U::operator())>>(), std::forward< F >(f)))
template<typename F >
constexpr void	resolve_f (std::false_type, F &&)
template<typename F , typename U = meta::unqualified_t<F>>
constexpr auto	resolve_i (types<>, F &&f) -> decltype(resolve_f(meta::call_operator_deducible< U >(), std::forward< F >(f)))
template<typename... Args, typename F , typename R = std::invoke_result_t<F&, Args...>>
constexpr auto	resolve_i (types< Args... >, F &&f) -> decltype(resolve_i(types< R(Args...)>(), std::forward< F >(f)))
template<typename Sig , typename C >
constexpr Sig C::*	resolve_v (std::false_type, Sig C::*mem_func_ptr)
template<typename Sig , typename C >
constexpr Sig C::*	resolve_v (std::true_type, Sig C::*mem_variable_ptr)
const char(&	default_handler_name ())[9]
template<typename Base , typename T >
basic_function< Base >	force_cast (T &p)
template<typename Reference , bool IsMainReference = false>
Reference	get_default_handler (lua_State *L_)
template<typename T >
void	set_default_handler (lua_State *L, const T &ref)
template<bool ShouldPush_, typename Handler_ >
void	handle_protected_exception (lua_State *L_, optional< const std::exception &> maybe_ex, const char *error, detail::protected_handler< ShouldPush_, Handler_ > &handler_)
int	fail_on_newindex (lua_State *L_)

Variables
const unchecked_t	unchecked = unchecked_t {}
const bool	default_safe_function_calls
const auto	direct_error = direct_error_tag {}
template<typename T >
constexpr auto	associated_nullopt_v = associated_nullopt<T>::value
template<typename T >
constexpr bool	is_policy_v = is_policy<T>::value
constexpr yield_tag_t	yield_tag {}
template<typename T >
constexpr bool	is_msvc_callable_rigged_v = is_msvc_callable_rigged<T>::value
template<typename T >
constexpr bool	is_non_factory_constructor_v = is_non_factory_constructor<T>::value
template<typename T >
constexpr bool	is_constructor_v = is_constructor<T>::value
template<typename... Args>
constexpr bool	any_is_constructor_v = any_is_constructor<Args...>::value
template<typename... Args>
constexpr bool	any_is_destructor_v = any_is_destructor<Args...>::value
constexpr std::array< string_view, 9 >	removals
constexpr const char *	not_a_number = "not a numeric type"
constexpr const char *	not_a_number_or_number_string = "not a numeric type or numeric string"
constexpr const char *	not_a_number_integral = "not a numeric type that fits exactly an integer (number maybe has significant decimals)"
constexpr const char *	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 *	not_enough_stack_space = "not enough space left on Lua stack"
constexpr const char *	not_enough_stack_space_floating = "not enough space left on Lua stack for a floating point number"
constexpr const char *	not_enough_stack_space_integral = "not enough space left on Lua stack for an integral number"
constexpr const char *	not_enough_stack_space_string = "not enough space left on Lua stack for a string"
constexpr const char *	not_enough_stack_space_meta_function_name = "not enough space left on Lua stack for the name of a meta_function"
constexpr const char *	not_enough_stack_space_userdata = "not enough space left on Lua stack to create a sol2 userdata"
constexpr const char *	not_enough_stack_space_generic = "not enough space left on Lua stack to push valuees"
constexpr const char *	not_enough_stack_space_environment = "not enough space left on Lua stack to retrieve environment"
constexpr const char *	protected_function_error = "caught (...) unknown error during protected_function call"
struct sol::detail::no_safety_tag	no_safety
template<typename Tag >
constexpr bool	is_tagged_v

Detailed Description

Variable Documentation

default_safe_function_calls

const bool sol::detail::default_safe_function_calls

Initial value:

=



             false

is_tagged_v

template<typename Tag >

constexpr bool sol::detail::is_tagged_v

inline

Initial value:

= meta::is_specialization_of_v<Tag,
                    detail::
                         as_pointer_tag> || meta::is_specialization_of_v<Tag, as_value_tag> || meta::is_specialization_of_v<Tag, as_unique_tag> || meta::is_specialization_of_v<Tag, as_table_tag> || std::is_same_v<Tag, as_reference_tag> || std::is_same_v<Tag, with_function_tag>

removals

constexpr std::array<string_view, 9> sol::detail::removals

inline

Initial value:

{ { "{anonymous}",
        "(anonymous namespace)",
        "public:",
        "private:",
        "protected:",
        "struct ",
        "class ",
        "`anonymous-namespace'",
        "`anonymous namespace'" } }