Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
sol Namespace Reference

Namespaces

 adl_barrier_detail
 
 call_detail
 
 container_detail
 
 d
 
 detail
 
 
 function_detail
 
 meta
 
 policy_detail
 
 stack
 
 u_detail
 
 unicode
 

Classes

struct  absolute_index
 
struct  argument_handler
 
struct  argument_handler< types< R, Args... > >
 
struct  as_args_t
 
struct  as_container_t
 
struct  as_returns_t
 
struct  as_table_t
 
struct  automagic_enrollments
 
class  bad_optional_access
 An exception for when an optional is accessed through specific methods while it is not engaged. More...
 
struct  base
 
struct  base_list
 
class  basic_bytecode
 
class  basic_coroutine
 
struct  basic_environment
 
class  basic_function
 
class  basic_lightuserdata
 
struct  basic_lua_table
 
class  basic_metatable
 
class  basic_object
 
class  basic_object_base
 
class  basic_packaged_coroutine
 
class  basic_pairs_range
 
class  basic_protected_function
 
class  basic_reference
 
class  basic_table_core
 
class  basic_table_iterator
 
class  basic_thread
 
class  basic_userdata
 
class  basic_usertype
 
struct  basic_variadic_results
 
struct  call_construction
 
struct  closure
 
struct  closure<>
 
struct  constant_automagic_enrollments
 
struct  constructor_handler
 
struct  constructor_list
 
struct  constructor_wrapper
 
struct  create_if_nil_t
 
struct  derive
 
struct  destructor_wrapper
 
struct  destructor_wrapper< void >
 
class  dump_error
 
struct  env_key_t
 
class  error
 
struct  factory_wrapper
 
struct  forward_as_value_t
 
struct  function_arguments
 
struct  function_sig
 
struct  global_tag_t
 
struct  is_automagical
 
struct  is_callable
 
struct  is_container
 
struct  is_container< basic_variadic_results< Al > >
 
struct  is_container< variadic_results >
 
struct  is_function
 
struct  is_function< basic_function< T, aligned > >
 
struct  is_function< basic_protected_function< T, aligned, Handler > >
 
struct  is_function_binding
 
struct  is_global_table
 
struct  is_global_table< basic_table_core< true, T > >
 
struct  is_lua_index
 
struct  is_lua_index< absolute_index >
 
struct  is_lua_index< raw_index >
 
struct  is_lua_index< ref_index >
 
struct  is_lua_index< upvalue_index >
 
struct  is_lua_primitive
 
struct  is_lua_primitive< as_table_t< T > >
 
struct  is_lua_primitive< light< T > >
 
struct  is_lua_primitive< lightuserdata_value >
 
struct  is_lua_primitive< nested< T > >
 
struct  is_lua_primitive< non_null< T > >
 
struct  is_lua_primitive< optional< T > >
 
struct  is_lua_primitive< protected_function_result >
 
struct  is_lua_primitive< stack_proxy >
 
struct  is_lua_primitive< stack_proxy_base >
 
struct  is_lua_primitive< std::optional< T > >
 
struct  is_lua_primitive< std::reference_wrapper< T > >
 
struct  is_lua_primitive< T * >
 
struct  is_lua_primitive< unsafe_function_result >
 
struct  is_lua_primitive< user< T > >
 
struct  is_lua_primitive< userdata_value >
 
struct  is_lua_reference
 
struct  is_lua_reference_or_proxy
 
struct  is_main_threaded
 
struct  is_proxy_primitive
 
struct  is_stack_based
 
struct  is_stack_based< protected_function_result >
 
struct  is_stack_based< stack_count >
 
struct  is_stack_based< stack_proxy >
 
struct  is_stack_based< stack_proxy_base >
 
struct  is_stack_based< unsafe_function_result >
 
struct  is_stack_based< variadic_args >
 
struct  is_stack_table
 
struct  is_stack_table< basic_lua_table< T > >
 
struct  is_stack_table< basic_table_core< x, T > >
 
struct  is_stateless_lua_reference
 
struct  is_table
 
struct  is_table< basic_lua_table< T > >
 
struct  is_table< basic_table_core< x, T > >
 
struct  is_tieable
 
struct  is_to_stringable
 
struct  is_to_stringable< base_list< Args... > >
 
struct  is_transparent_argument
 
struct  is_unique_usertype
 
struct  is_value_semantic_for_function
 
struct  is_variable_binding
 
struct  is_variadic_arguments
 
struct  light
 
struct  lightuserdata_value
 
struct  load_result
 
struct  lua_bind_traits
 
struct  lua_nil_t
 
struct  lua_size
 
struct  lua_size< std::pair< A, B > >
 
struct  lua_size< std::tuple< Args... > >
 
struct  lua_thread_state
 
struct  lua_type_of
 
struct  lua_value
 
struct  member_function_wrapper
 
struct  metatable_key_t
 
struct  metatable_registry_key
 
class  monostate
 Used to represent an optional with no data; essentially a bool. More...
 
struct  nested
 
struct  nested_tag_t
 
struct  new_table
 
struct  no_construction
 
struct  no_metatable_t
 
struct  non_null
 
class  optional
 
class  optional< T & >
 
struct  overload_set
 
struct  override_value_t
 
class  pairs_iterator
 
struct  pairs_sentinel
 
struct  policy_wrapper
 
struct  property_wrapper
 
struct  protect_t
 
struct  protected_function_result
 
struct  proxy_base
 
struct  proxy_base_tag
 
struct  push_invoke_t
 
struct  raw_index
 
struct  readonly_wrapper
 
struct  ref_index
 
struct  reference_equals
 
struct  reference_hash
 
struct  returns_self_with
 
struct  stack_count
 
struct  stack_dependencies
 
struct  stack_guard
 
struct  stack_iterator
 
struct  stack_proxy
 
struct  stack_proxy_base
 
class  stack_reference
 
struct  stack_reference_equals
 
struct  stack_reference_hash
 
class  state
 
class  state_view
 
class  stateless_reference
 
struct  stateless_reference_equals
 
struct  stateless_reference_hash
 
class  stateless_stack_reference
 
struct  stateless_stack_reference_equals
 
struct  stateless_stack_reference_hash
 
struct  static_stack_dependencies
 
struct  table_proxy
 
struct  this_environment
 
struct  this_main_state
 
struct  this_state
 
struct  tie_size
 
struct  tie_size< protected_function_result >
 
struct  tie_size< tie_t< Tn... > >
 
struct  tie_size< unsafe_function_result >
 
struct  tie_t
 
struct  type_panic_t
 
struct  types
 
struct  unique_usertype_traits
 
struct  unsafe_function_result
 
struct  update_if_empty_t
 
struct  upvalue_index
 
struct  user
 
struct  userdata_value
 
struct  usertype_container
 
struct  usertype_proxy
 
struct  usertype_traits
 
struct  var_wrapper
 
struct  variadic_args
 
struct  variadic_results
 
struct  weak_derive
 
struct  wrap
 
struct  wrapper
 
struct  wrapper< F, std::enable_if_t< std::is_function< std::remove_pointer_t< meta::unqualified_t< F > > >::value > >
 
struct  wrapper< F, std::enable_if_t< std::is_member_object_pointer< meta::unqualified_t< F > >::value > >
 
struct  wrapper< R(O::*)(Args...) && >
 
struct  wrapper< R(O::*)(Args...) const & >
 
struct  wrapper< R(O::*)(Args...) const && >
 
struct  wrapper< R(O::*)(Args...) const &&noexcept >
 
struct  wrapper< R(O::*)(Args...) const &noexcept >
 
struct  wrapper< R(O::*)(Args...) const >
 
struct  wrapper< R(O::*)(Args...) const noexcept >
 
struct  wrapper< R(O::*)(Args...) const volatile & >
 
struct  wrapper< R(O::*)(Args...) const volatile && >
 
struct  wrapper< R(O::*)(Args...) const volatile &&noexcept >
 
struct  wrapper< R(O::*)(Args...) const volatile &noexcept >
 
struct  wrapper< R(O::*)(Args...) const volatile >
 
struct  wrapper< R(O::*)(Args...) const volatile noexcept >
 
struct  wrapper< R(O::*)(Args...) noexcept >
 
struct  wrapper< R(O::*)(Args...)& >
 
struct  wrapper< R(O::*)(Args...)&&noexcept >
 
struct  wrapper< R(O::*)(Args...)&noexcept >
 
struct  wrapper< R(O::*)(Args...)>
 
struct  wrapper< R(O::*)(Args...,...) && >
 
struct  wrapper< R(O::*)(Args...,...) const & >
 
struct  wrapper< R(O::*)(Args...,...) const && >
 
struct  wrapper< R(O::*)(Args...,...) const &&noexcept >
 
struct  wrapper< R(O::*)(Args...,...) const &noexcept >
 
struct  wrapper< R(O::*)(Args...,...) const volatile & >
 
struct  wrapper< R(O::*)(Args...,...) const volatile && >
 
struct  wrapper< R(O::*)(Args...,...) const volatile &&noexcept >
 
struct  wrapper< R(O::*)(Args...,...) const volatile &noexcept >
 
struct  wrapper< R(O::*)(Args...,...)& >
 
struct  wrapper< R(O::*)(Args...,...)&&noexcept >
 
struct  wrapper< R(O::*)(Args...,...)&noexcept >
 
struct  yielding_t
 

Typedefs

using array_value = typename lua_value::arr
 
typedef bases base_classes_tag
 
template<typename... Args>
using bases = base_list< Args... >
 
template<typename C , typename T = std::char_traits<C>>
using basic_string_view = std::basic_string_view< C, T >
 
template<typename base_type >
using basic_table = basic_table_core< false, base_type >
 
using bytecode = basic_bytecode<>
 
typedef closure c_closure
 
using check_handler_type = int(lua_State *, int, type, type, const char *)
 
template<typename... Args>
using constructors = constructor_list< Args... >
 
using coroutine = basic_coroutine< reference >
 
using environment = basic_environment< reference >
 
using exception_handler_function = int(*)(lua_State *, optional< const std::exception & >, string_view)
 
using function = unsafe_function
 
using function_result = unsafe_function_result
 
using global_table = table_core< true >
 
template<size_t I>
using in_place_index_t = std::in_place_index_t< I >
 
using in_place_t = std::in_place_t
 
template<typename T >
using in_place_type_t = std::in_place_type_t< T >
 
template<typename T , typename Element = void>
using is_actual_type_rebindable_for = typename meta::meta_detail::is_actual_type_rebindable_for_test< unique_usertype_traits< T >, Element >::type
 
template<typename T >
using 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 is_lightuserdata = meta::is_specialization_of< T, basic_lightuserdata >
 
template<typename T >
using 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 is_table_like = std::integral_constant< bool, is_table_v< T >||is_environment_v< T >||is_userdata_v< T > >
 
template<typename T >
using is_userdata = meta::is_specialization_of< T, basic_userdata >
 
template<typename T >
using is_var_wrapper = meta::is_specialization_of< T, var_wrapper >
 
using lightuserdata = basic_lightuserdata< reference >
 
typedef std::remove_pointer_t< lua_CFunction > lua_CFunction_ref
 
using lua_table = basic_lua_table< reference >
 
using main_coroutine = basic_coroutine< main_reference >
 
using main_environment = basic_environment< main_reference >
 
using main_function = main_unsafe_function
 
using main_global_table = main_table_core< true >
 
using main_lightuserdata = basic_lightuserdata< main_reference >
 
using main_object = basic_object< main_reference >
 
using main_protected_function = main_safe_function
 
using main_reference = basic_reference< true >
 
using main_safe_function = basic_protected_function< main_reference, false, reference >
 
using main_table = main_table_core< false >
 
template<bool b>
using main_table_core = basic_table_core< b, main_reference >
 
using main_unsafe_function = basic_function< main_reference, false >
 
using main_userdata = basic_userdata< main_reference >
 
typedef meta_function meta_method
 
using metatable = basic_metatable< reference >
 
using nil_t = lua_nil_t
 
using nullopt_t = std::nullopt_t
 A tag type to represent an empty optional. More...
 
using object = basic_object< reference >
 
using packaged_coroutine = basic_packaged_coroutine< reference >
 
using protected_function = safe_function
 
using reference = basic_reference< false >
 
typedef returns_self_with returns_self
 
using safe_function = basic_protected_function< reference, false, reference >
 
using safe_function_result = protected_function_result
 
typedef static_stack_dependencies<-1, 1 > self_dependency
 
using stack_aligned_function = stack_aligned_unsafe_function
 
using stack_aligned_protected_function = stack_aligned_safe_function
 
using stack_aligned_safe_function = basic_protected_function< stack_reference, true, reference >
 
using stack_aligned_stack_handler_function = basic_protected_function< stack_reference, true, stack_reference >
 
using stack_aligned_unsafe_function = basic_function< stack_reference, true >
 
using stack_coroutine = basic_coroutine< stack_reference >
 
using stack_environment = basic_environment< stack_reference >
 
using stack_function = stack_unsafe_function
 
using stack_global_table = stack_table_core< true >
 
using stack_lightuserdata = basic_lightuserdata< stack_reference >
 
using stack_lua_table = basic_lua_table< stack_reference >
 
using stack_metatable = basic_metatable< stack_reference >
 
using stack_object = basic_object< stack_reference >
 
using stack_protected_function = stack_safe_function
 
using stack_safe_function = basic_protected_function< stack_reference, false, reference >
 
using stack_table = stack_table_core< false >
 
template<bool b>
using stack_table_core = basic_table_core< b, stack_reference >
 
using stack_thread = basic_thread< stack_reference >
 
using stack_unsafe_function = basic_function< stack_reference, false >
 
using stack_userdata = basic_userdata< stack_reference >
 
template<typename T >
using stack_usertype = basic_usertype< T, stack_reference >
 
typedef std::string_view string_view
 
typedef std::hash< std::string_view > string_view_hash
 
using table = table_core< false >
 
template<bool b>
using table_core = basic_table_core< b, reference >
 
using thread = basic_thread< reference >
 
typedef std::u16string_view u16string_view
 
typedef std::u32string_view u32string_view
 
template<typename T >
using unique_usertype_actual_t = typename meta::meta_detail::unique_actual_type< unique_usertype_traits< T > >::type
 
template<typename T >
using unique_usertype_element_t = typename meta::meta_detail::unique_element_type< unique_usertype_traits< T > >::type
 
template<typename T , typename Element = void>
using unique_usertype_rebind_actual_t = typename unique_usertype_traits< T >::template rebind_actual_type< Element >
 
using unsafe_function = basic_function< reference, false >
 
using userdata = basic_userdata< reference >
 
template<typename T >
using usertype = basic_usertype< T, reference >
 
typedef std::wstring_view wstring_view
 

Enumerations

enum  automagic_flags : unsigned {
  automagic_flags::none = 0x000u, automagic_flags::default_constructor = 0x001, automagic_flags::destructor = 0x002u, automagic_flags::pairs_operator = 0x004u,
  automagic_flags::to_string_operator = 0x008u, automagic_flags::call_operator = 0x010u, automagic_flags::less_than_operator = 0x020u, automagic_flags::less_than_or_equal_to_operator = 0x040u,
  automagic_flags::length_operator = 0x080u, automagic_flags::equal_to_operator = 0x100u, automagic_flags::all
}
 
enum  call_status : int {
  call_status::ok = LUA_OK, call_status::yielded = LUA_YIELD, call_status::runtime = LUA_ERRRUN, call_status::memory = LUA_ERRMEM,
  call_status::handler = LUA_ERRERR, call_status::gc = LUA_ERRGCMM, call_status::syntax = LUA_ERRSYNTAX, call_status::file = LUA_ERRFILE
}
 
enum  call_syntax { call_syntax::dot = 0, call_syntax::colon = 1 }
 
enum  gc_mode : int { gc_mode::incremental = 0, gc_mode::generational = 1, gc_mode::default_value = incremental }
 
enum  lib : unsigned char {
  lib::base, lib::package, lib::coroutine, lib::string,
  lib::os, lib::math, lib::table, lib::debug,
  lib::bit32, lib::io, lib::ffi, lib::jit,
  lib::utf8, lib::count
}
 
enum  load_mode { load_mode::any = 0, load_mode::text = 1, load_mode::binary = 2 }
 
enum  load_status : int {
  load_status::ok = LUA_OK, load_status::syntax = LUA_ERRSYNTAX, load_status::memory = LUA_ERRMEM, load_status::gc = LUA_ERRGCMM,
  load_status::file = LUA_ERRFILE
}
 
enum  meta_function : unsigned {
  meta_function::construct, meta_function::index, meta_function::new_index, meta_function::mode,
  meta_function::call, meta_function::call_function = call, meta_function::metatable, meta_function::to_string,
  meta_function::length, meta_function::unary_minus, meta_function::addition, meta_function::subtraction,
  meta_function::multiplication, meta_function::division, meta_function::modulus, meta_function::power_of,
  meta_function::involution = power_of, meta_function::concatenation, meta_function::equal_to, meta_function::less_than,
  meta_function::less_than_or_equal_to, meta_function::garbage_collect, meta_function::floor_division, meta_function::bitwise_left_shift,
  meta_function::bitwise_right_shift, meta_function::bitwise_not, meta_function::bitwise_and, meta_function::bitwise_or,
  meta_function::bitwise_xor, meta_function::pairs, meta_function::ipairs, meta_function::next,
  meta_function::type, meta_function::type_info, meta_function::call_construct, meta_function::storage,
  meta_function::gc_names, meta_function::static_index, meta_function::static_new_index
}
 
enum  thread_status : int {
  thread_status::ok = LUA_OK, thread_status::yielded = LUA_YIELD, thread_status::runtime = LUA_ERRRUN, thread_status::memory = LUA_ERRMEM,
  thread_status::gc = LUA_ERRGCMM, thread_status::handler = LUA_ERRERR, thread_status::dead = -1
}
 
enum  type : int {
  type::none = LUA_TNONE, type::lua_nil = LUA_TNIL, type::nil = lua_nil, type::string = LUA_TSTRING,
  type::number = LUA_TNUMBER, type::thread = LUA_TTHREAD, type::boolean = LUA_TBOOLEAN, type::function = LUA_TFUNCTION,
  type::userdata = LUA_TUSERDATA, type::lightuserdata = LUA_TLIGHTUSERDATA, type::table = LUA_TTABLE, type::poly = -0xFFFF
}
 

Functions

template<typename Source >
auto as_args (Source &&source)
 
template<typename T >
auto as_container (T &&value)
 
template<typename Sig = function_sig<>, typename... Args>
auto as_function (Args &&... args)
 
template<typename Sig = function_sig<>, typename... Args>
auto as_function_reference (Args &&... args)
 
template<typename T >
nested< meta::unqualified_t< T > > as_nested (T &&container)
 
template<typename T >
nested< T > as_nested_ref (T &&container)
 
template<typename Source >
auto as_returns (Source &&source)
 
template<typename T >
as_table_t< meta::unqualified_t< T > > as_table (T &&container)
 
template<typename T >
as_table_t< T > as_table_ref (T &&container)
 
std::string associated_type_name (lua_State *L, int index, type t)
 
template<typename Container >
int basic_insert_dump_writer (lua_State *, const void *memory, size_t memory_size, void *userdata_pointer)
 
template<typename F , F fx>
int c_call (lua_State *L)
 
template<typename... Fxs>
int c_call (lua_State *L)
 
template<typename Left , typename Right >
constexpr auto clear_flags (Left left, Right right) noexcept
 
int default_at_panic (lua_State *L)
 
int default_traceback_error_handler (lua_State *L)
 
template<typename Fx >
auto destructor (Fx &&fx)
 
int dump_panic_on_error (lua_State *L_, int result_code, lua_Writer writer_function, void *userdata_pointer_, bool strip)
 
int dump_pass_on_error (lua_State *L_, int result_code, lua_Writer writer_function, void *userdata_pointer_, bool strip)
 
int dump_throw_on_error (lua_State *L_, int result_code, lua_Writer writer_function, void *userdata_pointer_, bool strip)
 
template<typename... Functions>
auto factories (Functions &&... functions)
 
template<std::size_t I>
stack_proxy get (const unsafe_function_result &fr)
 
template<std::size_t I, typename... Args>
stack_proxy get (types< Args... > t, const unsafe_function_result &fr)
 
template<std::size_t I>
stack_proxy get (const protected_function_result &fr)
 
template<std::size_t I, typename... Args>
stack_proxy get (types< Args... > t, const protected_function_result &fr)
 
template<typename E = reference, typename T >
basic_environment< E > get_environment (const T &target)
 
template<typename Left , typename Right >
constexpr bool has_any_flag (Left left, Right right) noexcept
 
template<typename Left , typename Right >
constexpr bool has_flag (Left left, Right right) noexcept
 
template<typename... Functions>
auto initializers (Functions &&... functions)
 
bool is_indeterminate_call_failure (call_status c)
 
lua_State * main_thread (lua_State *L_, lua_State *backup_if_unsupported_=nullptr)
 
template<typename... Args>
closure< Args... > make_closure (lua_CFunction f, Args &&... args)
 
template<typename T >
auto make_light (T &l)
 
template<typename T >
object make_object (lua_State *L_, T &&value)
 
template<typename T , typename... Args>
object make_object (lua_State *L_, Args &&... args)
 
template<typename T >
object make_object_userdata (lua_State *L_, T &&value)
 
template<typename T , typename... Args>
object 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 > make_optional (U &&v)
 
template<class T , class... Args>
constexpr optional< T > make_optional (Args &&... args)
 
template<class T , class U , class... Args>
constexpr optional< T > make_optional (std::initializer_list< U > il, Args &&... args)
 
template<typename R = reference, bool should_pop = !is_stack_based_v<R>, typename T >
R make_reference (lua_State *L, T &&value)
 
template<typename T , typename R = reference, bool should_pop = !is_stack_based_v<R>, typename... Args>
R make_reference (lua_State *L, Args &&... args)
 
template<typename R = reference, bool should_pop = !is_stack_based_v<R>, typename T >
R 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 make_reference_userdata (lua_State *L, Args &&... args)
 
template<typename T >
auto make_user (T &&u)
 
const std::array< std::string, 37 > & meta_function_names ()
 
template<typename T >
auto meta_registry_key (T &&key)
 
int no_panic (lua_State *, int, type, type, const char *=nullptr) noexcept
 
constexpr automagic_flags operator & (automagic_flags left, automagic_flags right) noexcept
 
constexpr automagic_flags & operator &= (automagic_flags &left, automagic_flags right) noexcept
 
template<class T , class U >
constexpr bool operator!= (const optional< T > &lhs, const optional< U > &rhs)
 relop More...
 
template<class T >
constexpr bool operator!= (const optional< T > &lhs, nullopt_t) noexcept
 relop_nullopt More...
 
template<class T >
constexpr bool operator!= (nullopt_t, const optional< T > &rhs) noexcept
 relop_nullopt More...
 
template<class T , class U >
constexpr bool operator!= (const optional< T > &lhs, const U &rhs)
 relop_t More...
 
template<class T , class U >
constexpr bool operator!= (const U &lhs, const optional< T > &rhs)
 relop_t More...
 
bool operator!= (lua_nil_t, lua_nil_t)
 
bool operator!= (const stack_reference &l, const stack_reference &r)
 
bool operator!= (const stack_reference &lhs, const lua_nil_t &)
 
bool operator!= (const lua_nil_t &, const stack_reference &rhs)
 
bool operator!= (const stateless_stack_reference &l, const stateless_stack_reference &r)
 
template<bool lb, bool rb>
bool operator!= (const basic_reference< lb > &l, const basic_reference< rb > &r) noexcept
 
template<bool lb>
bool operator!= (const basic_reference< lb > &l, const stack_reference &r) noexcept
 
template<bool rb>
bool operator!= (const stack_reference &l, const basic_reference< rb > &r) noexcept
 
template<bool lb>
bool operator!= (const basic_reference< lb > &lhs, const lua_nil_t &) noexcept
 
template<bool rb>
bool operator!= (const lua_nil_t &, const basic_reference< rb > &rhs) noexcept
 
bool operator!= (const stateless_reference &l, const stateless_reference &r) noexcept
 
bool operator!= (const stateless_reference &lhs, const lua_nil_t &) noexcept
 
bool operator!= (const lua_nil_t &, const stateless_reference &rhs) noexcept
 
template<typename Table , typename Key , typename T >
bool operator!= (T &&left, const table_proxy< Table, Key > &right)
 
template<typename Table , typename Key , typename T >
bool operator!= (const table_proxy< Table, Key > &right, T &&left)
 
template<typename Table , typename Key >
bool operator!= (lua_nil_t, const table_proxy< Table, Key > &right)
 
template<typename Table , typename Key >
bool operator!= (const table_proxy< Table, Key > &right, lua_nil_t)
 
template<typename proxy_t , bool is_const>
stack_iterator< proxy_t, is_const > 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 operator< (const optional< T > &lhs, const optional< U > &rhs)
 relop More...
 
template<class T >
constexpr bool operator< (const optional< T > &, nullopt_t) noexcept
 relop_nullopt More...
 
template<class T >
constexpr bool operator< (nullopt_t, const optional< T > &rhs) noexcept
 relop_nullopt More...
 
template<class T , class U >
constexpr bool operator< (const optional< T > &lhs, const U &rhs)
 relop_t More...
 
template<class T , class U >
constexpr bool operator< (const U &lhs, const optional< T > &rhs)
 relop_t More...
 
template<class T , class U >
constexpr bool operator<= (const optional< T > &lhs, const optional< U > &rhs)
 relop More...
 
template<class T >
constexpr bool operator<= (const optional< T > &lhs, nullopt_t) noexcept
 relop_nullopt More...
 
template<class T >
constexpr bool operator<= (nullopt_t, const optional< T > &) noexcept
 relop_nullopt More...
 
template<class T , class U >
constexpr bool operator<= (const optional< T > &lhs, const U &rhs)
 relop_t More...
 
template<class T , class U >
constexpr bool operator<= (const U &lhs, const optional< T > &rhs)
 relop_t More...
 
template<class T , class U >
constexpr bool operator== (const optional< T > &lhs, const optional< U > &rhs)
 Compares two optional objects. More...
 
template<class T >
constexpr bool operator== (const optional< T > &lhs, nullopt_t) noexcept
 Compares an optional to a nullopt More...
 
template<class T >
constexpr bool operator== (nullopt_t, const optional< T > &rhs) noexcept
 relop_nullopt More...
 
template<class T , class U >
constexpr bool operator== (const optional< T > &lhs, const U &rhs)
 Compares the optional with a value. More...
 
template<class T , class U >
constexpr bool operator== (const U &lhs, const optional< T > &rhs)
 relop_t More...
 
bool operator== (lua_nil_t, lua_nil_t)
 
bool operator== (const stack_reference &l, const stack_reference &r)
 
bool operator== (const stack_reference &lhs, const lua_nil_t &)
 
bool operator== (const lua_nil_t &, const stack_reference &rhs)
 
bool operator== (const stateless_stack_reference &l, const stateless_stack_reference &r)
 
template<bool lb, bool rb>
bool operator== (const basic_reference< lb > &l, const basic_reference< rb > &r) noexcept
 
template<bool lb>
bool operator== (const basic_reference< lb > &l, const stack_reference &r) noexcept
 
template<bool rb>
bool operator== (const stack_reference &l, const basic_reference< rb > &r) noexcept
 
template<bool lb>
bool operator== (const basic_reference< lb > &lhs, const lua_nil_t &) noexcept
 
template<bool rb>
bool operator== (const lua_nil_t &, const basic_reference< rb > &rhs) noexcept
 
bool operator== (const stateless_reference &l, const stateless_reference &r) noexcept
 
bool operator== (const stateless_reference &lhs, const lua_nil_t &) noexcept
 
bool operator== (const lua_nil_t &, const stateless_reference &rhs) noexcept
 
template<typename Table , typename Key , typename T >
bool operator== (T &&left, const table_proxy< Table, Key > &right)
 
template<typename Table , typename Key , typename T >
bool operator== (const table_proxy< Table, Key > &right, T &&left)
 
template<typename Table , typename Key >
bool operator== (lua_nil_t, const table_proxy< Table, Key > &right)
 
template<typename Table , typename Key >
bool operator== (const table_proxy< Table, Key > &right, lua_nil_t)
 
template<class T , class U >
constexpr bool operator> (const optional< T > &lhs, const optional< U > &rhs)
 relop More...
 
template<class T >
constexpr bool operator> (const optional< T > &lhs, nullopt_t) noexcept
 relop_nullopt More...
 
template<class T >
constexpr bool operator> (nullopt_t, const optional< T > &) noexcept
 relop_nullopt More...
 
template<class T , class U >
constexpr bool operator> (const optional< T > &lhs, const U &rhs)
 relop_t More...
 
template<class T , class U >
constexpr bool operator> (const U &lhs, const optional< T > &rhs)
 relop_t More...
 
template<class T , class U >
constexpr bool operator>= (const optional< T > &lhs, const optional< U > &rhs)
 relop More...
 
template<class T >
constexpr bool operator>= (const optional< T > &, nullopt_t) noexcept
 relop_nullopt More...
 
template<class T >
constexpr bool operator>= (nullopt_t, const optional< T > &rhs) noexcept
 relop_nullopt More...
 
template<class T , class U >
constexpr bool operator>= (const optional< T > &lhs, const U &rhs)
 relop_t More...
 
template<class T , class U >
constexpr bool operator>= (const U &lhs, const optional< T > &rhs)
 relop_t More...
 
constexpr automagic_flags operator| (automagic_flags left, automagic_flags right) noexcept
 
constexpr automagic_flags & operator|= (automagic_flags &left, automagic_flags right) noexcept
 
template<typename... Args>
decltype(auto) overload (Args &&... args)
 
template<typename T >
auto pass_as_value (T &value_ref_)
 
template<typename F , typename... Args>
auto policies (F &&f, Args &&... args)
 
template<typename F , typename G >
decltype(auto) property (F &&f, G &&g)
 
template<typename F >
decltype(auto) property (F &&f)
 
template<typename T >
auto protect (T &&value)
 
template<typename Fx >
auto push_invoke (Fx &&fx)
 
int push_type_panic_string (lua_State *L, int index, type expected, type actual, string_view message, string_view aux_message) noexcept
 
template<typename R , typename T >
auto readonly (R T::*v)
 
template<typename F >
decltype(auto) readonly_property (F &&f)
 
void register_main_thread (lua_State *L)
 
template<typename... Args, typename R >
constexpr auto resolve (R fun_ptr(Args...)) -> R(*)(Args...)
 
template<typename Sig >
constexpr Sig * resolve (Sig *fun_ptr)
 
template<typename... Args, typename R , typename C >
constexpr auto resolve (R(C::*mem_ptr)(Args...)) -> R(C::*)(Args...)
 
template<typename Sig , typename C >
constexpr Sig C::* resolve (Sig C::*mem_ptr)
 
template<typename... Sig, typename F , meta::disable< std::is_function< meta::unqualified_t< F >>> = meta::enabler>
constexpr auto resolve (F &&f) -> decltype(detail::resolve_i(types< Sig... >(), std::forward< F >(f)))
 
protected_function_result script_default_on_error (lua_State *L, protected_function_result pfr)
 
protected_function_result script_pass_on_error (lua_State *, protected_function_result result)
 
protected_function_result script_throw_on_error (lua_State *L, protected_function_result result)
 
void set_default_exception_handler (lua_State *L, exception_handler_function exf=&detail::default_exception_handler)
 
void 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 >
bool set_environment (const basic_environment< E > &env, const T &target)
 
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 swap (optional< T > &lhs, optional< T > &rhs) noexcept(noexcept(lhs.swap(rhs)))
 template <class t>="">
void swap(optional<T> &lhs, optional<T> &rhs); More...
 
const std::string & to_string (call_status c)
 
const std::string & to_string (load_status c)
 
const std::string & to_string (load_mode c)
 
const std::string & to_string (meta_function mf)
 
std::size_t total_memory_used (lua_State *L)
 
void type_assert (lua_State *L, int index, type expected, type actual) noexcept(false)
 
void type_assert (lua_State *L, int index, type expected)
 
void type_error (lua_State *L, int expected, int actual) noexcept(false)
 
void type_error (lua_State *L, type expected, type actual) noexcept(false)
 
std::string type_name (lua_State *L, type t)
 
type type_of (lua_State *L, int index)
 
template<typename T >
type type_of ()
 
int type_panic_c_str (lua_State *L, int index, type expected, type actual, const char *message=nullptr) noexcept(false)
 
int type_panic_string (lua_State *L, int index, type expected, type actual, string_view message="") noexcept(false)
 
template<typename V >
auto var (V &&v)
 
template<typename F >
decltype(auto) writeonly_property (F &&f)
 
template<typename F >
yielding_t< std::decay_t< F > > yielding (F &&f)
 

Variables

const auto base_classes = base_classes_tag()
 
constexpr auto bytecode_dump_writer = &basic_insert_dump_writer<bytecode>
 
const auto call_constructor = call_construction {}
 
const new_table create = {}
 
constexpr create_if_nil_t create_if_nil = create_if_nil_t()
 
const auto default_constructor = constructors<types<>> {}
 
const destructor_wrapper< void > default_destructor {}
 
constexpr env_key_t env_key {}
 
struct sol::global_tag_t global_tag
 
constexpr std::in_place_t in_place {}
 
template<size_t I>
constexpr in_place_index_t< I > in_place_index {}
 
constexpr std::in_place_t in_place_of {}
 
template<typename T >
constexpr std::in_place_type_t< T > in_place_type {}
 
template<typename T , typename Element = void>
constexpr bool is_actual_type_rebindable_for_v = is_actual_type_rebindable_for<T, Element>::value
 
template<typename T >
constexpr bool is_callable_v = is_callable<T>::value
 
template<typename T >
constexpr bool is_container_v = is_container<T>::value
 
template<typename T >
constexpr bool is_environment_v = is_environment<T>::value
 
template<typename T >
constexpr bool is_global_table_v = is_global_table<T>::value
 
template<typename T >
constexpr bool is_lightuserdata_v = is_lightuserdata<T>::value
 
template<typename T >
constexpr bool is_lua_c_function_v = is_lua_c_function<T>::value
 
template<typename T >
constexpr bool is_lua_primitive_v = is_lua_primitive<T>::value
 
template<typename T >
constexpr bool is_lua_reference_or_proxy_v = is_lua_reference_or_proxy<T>::value
 
template<typename T >
constexpr bool is_lua_reference_v = is_lua_reference<T>::value
 
template<typename T >
constexpr bool is_main_threaded_v = is_main_threaded<T>::value
 
template<typename T >
constexpr bool is_stack_based_v = is_stack_based<T>::value
 
template<typename T >
constexpr bool is_stack_table_v = is_stack_table<T>::value
 
template<typename T >
constexpr bool is_stateless_lua_reference_v = is_stateless_lua_reference<T>::value
 
template<typename T >
constexpr bool is_table_like_v = is_table_like<T>::value
 
template<typename T >
constexpr bool is_table_v = is_table<T>::value
 
template<typename T >
constexpr bool is_to_stringable_v = is_to_stringable<T>::value
 
template<typename T >
constexpr bool is_transparent_argument_v = is_transparent_argument<T>::value
 
template<typename T >
constexpr bool is_unique_usertype_v = is_unique_usertype<T>::value
 
template<typename T >
constexpr bool is_userdata_v = is_userdata<T>::value
 
template<typename T >
constexpr bool is_value_semantic_for_function_v = is_value_semantic_for_function<T>::value
 
constexpr lua_nil_t lua_nil {}
 
template<typename T >
constexpr int lua_size_v = lua_size<T>::value
 
template<typename T >
constexpr type lua_type_of_v = lua_type_of<T>::value
 
constexpr metatable_key_t metatable_key {}
 
constexpr nested_tag_t nested_tag {}
 
constexpr const nil_t & nil = lua_nil
 
const auto no_constructor = no_construction {}
 
constexpr no_metatable_t no_metatable {}
 
constexpr override_value_t override_value = override_value_t()
 
const type_panic_t type_panic = {}
 
constexpr update_if_empty_t update_if_empty = update_if_empty_t()
 

Typedef Documentation

◆ array_value

using sol::array_value = typedef typename lua_value::arr

Definition at line 27045 of file sol.hpp.

◆ base_classes_tag

typedef bases sol::base_classes_tag

Definition at line 9334 of file sol.hpp.

◆ bases

template<typename... Args>
using sol::bases = typedef base_list<Args...>

Definition at line 9332 of file sol.hpp.

◆ basic_string_view

template<typename C , typename T = std::char_traits<C>>
using sol::basic_string_view = typedef std::basic_string_view<C, T>

Definition at line 2133 of file sol.hpp.

◆ basic_table

template<typename base_type >
using sol::basic_table = typedef basic_table_core<false, base_type>

Definition at line 1125 of file forward.hpp.

◆ bytecode

using sol::bytecode = typedef basic_bytecode<>

Definition at line 4524 of file sol.hpp.

◆ c_closure

typedef closure sol::c_closure

Definition at line 7549 of file sol.hpp.

◆ check_handler_type

using sol::check_handler_type = typedef int(lua_State*, int, type, type, const char*)

Definition at line 1297 of file forward.hpp.

◆ constructors

template<typename... Args>
using sol::constructors = typedef constructor_list<Args...>

Definition at line 6995 of file sol.hpp.

◆ coroutine

typedef basic_coroutine< reference > sol::coroutine

Definition at line 1213 of file forward.hpp.

◆ environment

typedef basic_environment< reference > sol::environment

Definition at line 1152 of file forward.hpp.

◆ exception_handler_function

using sol::exception_handler_function = typedef int (*)(lua_State*, optional<const std::exception&>, string_view)

Definition at line 8733 of file sol.hpp.

◆ function

typedef unsafe_function sol::function

Definition at line 1178 of file forward.hpp.

◆ function_result

typedef unsafe_function_result sol::function_result

Definition at line 1191 of file forward.hpp.

◆ global_table

typedef table_core< true > sol::global_table

Definition at line 1127 of file forward.hpp.

◆ in_place_index_t

template<size_t I>
using sol::in_place_index_t = typedef std::in_place_index_t<I>

Definition at line 4621 of file sol.hpp.

◆ in_place_t

using sol::in_place_t = typedef std::in_place_t

Definition at line 4611 of file sol.hpp.

◆ in_place_type_t

template<typename T >
using sol::in_place_type_t = typedef std::in_place_type_t<T>

Definition at line 4616 of file sol.hpp.

◆ is_actual_type_rebindable_for

template<typename T , typename Element = void>
using sol::is_actual_type_rebindable_for = typedef typename meta::meta_detail::is_actual_type_rebindable_for_test<unique_usertype_traits<T>, Element>::type

Definition at line 9319 of file sol.hpp.

◆ is_environment

template<typename T >
using sol::is_environment = typedef std::integral_constant<bool, is_userdata_v<T> || is_table_v<T> || meta::is_specialization_of_v<T, basic_environment> >

Definition at line 8573 of file sol.hpp.

◆ is_lightuserdata

template<typename T >
using sol::is_lightuserdata = typedef meta::is_specialization_of<T, basic_lightuserdata>

Definition at line 8561 of file sol.hpp.

◆ is_lua_c_function

template<typename T >
using sol::is_lua_c_function = typedef meta::any<std::is_same<lua_CFunction, T>, std::is_same<detail::lua_CFunction_noexcept, T>, std::is_same<lua_CFunction_ref, T> >

Definition at line 8648 of file sol.hpp.

◆ is_table_like

template<typename T >
using sol::is_table_like = typedef std::integral_constant<bool, is_table_v<T> || is_environment_v<T> || is_userdata_v<T> >

Definition at line 8579 of file sol.hpp.

◆ is_userdata

template<typename T >
using sol::is_userdata = typedef meta::is_specialization_of<T, basic_userdata>

Definition at line 8567 of file sol.hpp.

◆ is_var_wrapper

template<typename T >
using sol::is_var_wrapper = typedef meta::is_specialization_of<T, var_wrapper>

Definition at line 18989 of file sol.hpp.

◆ lightuserdata

typedef basic_lightuserdata< reference > sol::lightuserdata

Definition at line 1211 of file forward.hpp.

◆ lua_CFunction_ref

typedef std::remove_pointer_t<lua_CFunction> sol::lua_CFunction_ref

Definition at line 7366 of file sol.hpp.

◆ lua_table

typedef basic_lua_table< reference > sol::lua_table

Definition at line 1135 of file forward.hpp.

◆ main_coroutine

typedef basic_coroutine< main_reference > sol::main_coroutine

Definition at line 1218 of file forward.hpp.

◆ main_environment

typedef basic_environment< main_reference > sol::main_environment

Definition at line 1153 of file forward.hpp.

◆ main_function

typedef main_unsafe_function sol::main_function

Definition at line 1179 of file forward.hpp.

◆ main_global_table

typedef main_table_core< true > sol::main_global_table

Definition at line 1129 of file forward.hpp.

◆ main_lightuserdata

typedef basic_lightuserdata< main_reference > sol::main_lightuserdata

Definition at line 1217 of file forward.hpp.

◆ main_object

typedef basic_object< main_reference > sol::main_object

Definition at line 1215 of file forward.hpp.

◆ main_protected_function

typedef main_safe_function sol::main_protected_function

Definition at line 1169 of file forward.hpp.

◆ main_reference

typedef basic_reference< true > sol::main_reference

Definition at line 1101 of file forward.hpp.

◆ main_safe_function

typedef basic_protected_function< main_reference, false, reference > sol::main_safe_function

Definition at line 1163 of file forward.hpp.

◆ main_table

typedef main_table_core< false > sol::main_table

Definition at line 1128 of file forward.hpp.

◆ main_table_core

template<bool b>
using sol::main_table_core = typedef basic_table_core<b, main_reference>

Definition at line 1121 of file forward.hpp.

◆ main_unsafe_function

typedef basic_function< main_reference, false > sol::main_unsafe_function

Definition at line 1162 of file forward.hpp.

◆ main_userdata

typedef basic_userdata< main_reference > sol::main_userdata

Definition at line 1216 of file forward.hpp.

◆ meta_method

typedef meta_function sol::meta_method

Definition at line 8025 of file sol.hpp.

◆ metatable

typedef basic_metatable< reference > sol::metatable

Definition at line 1147 of file forward.hpp.

◆ nil_t

using sol::nil_t = typedef lua_nil_t

Definition at line 7322 of file sol.hpp.

◆ nullopt_t

using sol::nullopt_t = typedef std::nullopt_t

A tag type to represent an empty optional.

Definition at line 5213 of file sol.hpp.

◆ object

typedef basic_object< reference > sol::object

Definition at line 1209 of file forward.hpp.

◆ packaged_coroutine

typedef basic_packaged_coroutine< reference > sol::packaged_coroutine

Definition at line 1214 of file forward.hpp.

◆ protected_function

typedef safe_function sol::protected_function

Definition at line 1168 of file forward.hpp.

◆ reference

typedef basic_reference< false > sol::reference

Definition at line 1100 of file forward.hpp.

◆ returns_self

typedef returns_self_with sol::returns_self

Definition at line 7066 of file sol.hpp.

◆ safe_function

typedef basic_protected_function< reference, false, reference > sol::safe_function

Definition at line 1161 of file forward.hpp.

◆ safe_function_result

typedef protected_function_result sol::safe_function_result

Definition at line 1187 of file forward.hpp.

◆ self_dependency

typedef static_stack_dependencies<-1, 1> sol::self_dependency

Definition at line 7063 of file sol.hpp.

◆ stack_aligned_function

typedef stack_aligned_unsafe_function sol::stack_aligned_function

Definition at line 1181 of file forward.hpp.

◆ stack_aligned_protected_function

typedef stack_aligned_safe_function sol::stack_aligned_protected_function

Definition at line 1171 of file forward.hpp.

◆ stack_aligned_safe_function

typedef basic_protected_function< stack_reference, true, reference > sol::stack_aligned_safe_function

Definition at line 1167 of file forward.hpp.

◆ stack_aligned_stack_handler_function

typedef basic_protected_function< stack_reference, true, stack_reference > sol::stack_aligned_stack_handler_function

Definition at line 1183 of file forward.hpp.

◆ stack_aligned_unsafe_function

typedef basic_function< stack_reference, true > sol::stack_aligned_unsafe_function

Definition at line 1166 of file forward.hpp.

◆ stack_coroutine

typedef basic_coroutine< stack_reference > sol::stack_coroutine

Definition at line 1223 of file forward.hpp.

◆ stack_environment

typedef basic_environment< stack_reference > sol::stack_environment

Definition at line 1154 of file forward.hpp.

◆ stack_function

typedef stack_unsafe_function sol::stack_function

Definition at line 1180 of file forward.hpp.

◆ stack_global_table

typedef stack_table_core< true > sol::stack_global_table

Definition at line 1131 of file forward.hpp.

◆ stack_lightuserdata

typedef basic_lightuserdata< stack_reference > sol::stack_lightuserdata

Definition at line 1221 of file forward.hpp.

◆ stack_lua_table

typedef basic_lua_table< stack_reference > sol::stack_lua_table

Definition at line 1136 of file forward.hpp.

◆ stack_metatable

typedef basic_metatable< stack_reference > sol::stack_metatable

Definition at line 1148 of file forward.hpp.

◆ stack_object

typedef basic_object< stack_reference > sol::stack_object

Definition at line 1219 of file forward.hpp.

◆ stack_protected_function

typedef stack_safe_function sol::stack_protected_function

Definition at line 1170 of file forward.hpp.

◆ stack_safe_function

typedef basic_protected_function< stack_reference, false, reference > sol::stack_safe_function

Definition at line 1165 of file forward.hpp.

◆ stack_table

typedef stack_table_core< false > sol::stack_table

Definition at line 1130 of file forward.hpp.

◆ stack_table_core

template<bool b>
using sol::stack_table_core = typedef basic_table_core<b, stack_reference>

Definition at line 1123 of file forward.hpp.

◆ stack_thread

typedef basic_thread< stack_reference > sol::stack_thread

Definition at line 1222 of file forward.hpp.

◆ stack_unsafe_function

typedef basic_function< stack_reference, false > sol::stack_unsafe_function

Definition at line 1164 of file forward.hpp.

◆ stack_userdata

typedef basic_userdata< stack_reference > sol::stack_userdata

Definition at line 1220 of file forward.hpp.

◆ stack_usertype

template<typename T >
using sol::stack_usertype = typedef basic_usertype<T, stack_reference>

Definition at line 1143 of file forward.hpp.

◆ string_view

typedef std::string_view sol::string_view

Definition at line 2135 of file sol.hpp.

◆ string_view_hash

typedef std::hash<std::string_view> sol::string_view_hash

Definition at line 2139 of file sol.hpp.

◆ table

typedef table_core< false > sol::table

Definition at line 1126 of file forward.hpp.

◆ table_core

template<bool b>
using sol::table_core = typedef basic_table_core<b, reference>

Definition at line 1119 of file forward.hpp.

◆ thread

typedef basic_thread< reference > sol::thread

Definition at line 1212 of file forward.hpp.

◆ u16string_view

typedef std::u16string_view sol::u16string_view

Definition at line 2137 of file sol.hpp.

◆ u32string_view

typedef std::u32string_view sol::u32string_view

Definition at line 2138 of file sol.hpp.

◆ unique_usertype_actual_t

template<typename T >
using sol::unique_usertype_actual_t = typedef typename meta::meta_detail::unique_actual_type<unique_usertype_traits<T> >::type

Definition at line 9182 of file sol.hpp.

◆ unique_usertype_element_t

template<typename T >
using sol::unique_usertype_element_t = typedef typename meta::meta_detail::unique_element_type<unique_usertype_traits<T> >::type

Definition at line 9217 of file sol.hpp.

◆ unique_usertype_rebind_actual_t

template<typename T , typename Element = void>
using sol::unique_usertype_rebind_actual_t = typedef typename unique_usertype_traits<T>::template rebind_actual_type<Element>

Definition at line 9220 of file sol.hpp.

◆ unsafe_function

typedef basic_function< reference, false > sol::unsafe_function

Definition at line 1160 of file forward.hpp.

◆ userdata

typedef basic_userdata< reference > sol::userdata

Definition at line 1210 of file forward.hpp.

◆ usertype

template<typename T >
using sol::usertype = typedef basic_usertype<T, reference>

Definition at line 1141 of file forward.hpp.

◆ wstring_view

typedef std::wstring_view sol::wstring_view

Definition at line 2136 of file sol.hpp.

Enumeration Type Documentation

◆ automagic_flags

enum sol::automagic_flags : unsigned
strong
Enumerator
none 
default_constructor 
destructor 
pairs_operator 
to_string_operator 
call_operator 
less_than_operator 
less_than_or_equal_to_operator 
length_operator 
equal_to_operator 
all 

Definition at line 8653 of file sol.hpp.

◆ call_status

enum sol::call_status : int
strong
Enumerator
ok 
yielded 
runtime 
memory 
handler 
gc 
syntax 
file 

Definition at line 7848 of file sol.hpp.

◆ call_syntax

enum sol::call_syntax
strong
Enumerator
dot 
colon 

Definition at line 7840 of file sol.hpp.

◆ gc_mode

enum sol::gc_mode : int
strong
Enumerator
incremental 
generational 
default_value 

Definition at line 7877 of file sol.hpp.

◆ lib

enum sol::lib : unsigned char
strong
Enumerator
base 
package 
coroutine 
string 
os 
math 
table 
debug 
bit32 
io 
ffi 
jit 
utf8 
count 

Definition at line 7809 of file sol.hpp.

◆ load_mode

enum sol::load_mode
strong
Enumerator
any 
text 
binary 

Definition at line 7842 of file sol.hpp.

◆ load_status

enum sol::load_status : int
strong
Enumerator
ok 
syntax 
memory 
gc 
file 

Definition at line 7869 of file sol.hpp.

◆ meta_function

enum sol::meta_function : unsigned
strong
Enumerator
construct 
index 
new_index 
mode 
call 
call_function 
metatable 
to_string 
length 
unary_minus 
addition 
subtraction 
multiplication 
division 
modulus 
power_of 
involution 
concatenation 
equal_to 
less_than 
less_than_or_equal_to 
garbage_collect 
floor_division 
bitwise_left_shift 
bitwise_right_shift 
bitwise_not 
bitwise_and 
bitwise_or 
bitwise_xor 
pairs 
ipairs 
next 
type 
type_info 
call_construct 
storage 
gc_names 
static_index 
static_new_index 

Definition at line 7983 of file sol.hpp.

◆ thread_status

enum sol::thread_status : int
strong
Enumerator
ok 
yielded 
runtime 
memory 
gc 
handler 
dead 

Definition at line 7859 of file sol.hpp.

◆ type

enum sol::type : int
strong
Enumerator
none 
lua_nil 
nil 
string 
number 
thread 
boolean 
function 
userdata 
lightuserdata 
table 
poly 

Definition at line 7883 of file sol.hpp.

Function Documentation

◆ as_args()

template<typename Source >
auto sol::as_args ( Source &&  source)

Definition at line 28608 of file sol.hpp.

◆ as_container()

template<typename T >
auto sol::as_container ( T &&  value)

Definition at line 7689 of file sol.hpp.

◆ as_function()

template<typename Sig = function_sig<>, typename... Args>
auto sol::as_function ( Args &&...  args)

Definition at line 7565 of file sol.hpp.

◆ as_function_reference()

template<typename Sig = function_sig<>, typename... Args>
auto sol::as_function_reference ( Args &&...  args)

Definition at line 7570 of file sol.hpp.

◆ as_nested()

template<typename T >
nested<meta::unqualified_t<T> > sol::as_nested ( T &&  container)

Definition at line 7661 of file sol.hpp.

◆ as_nested_ref()

template<typename T >
nested<T> sol::as_nested_ref ( T &&  container)

Definition at line 7656 of file sol.hpp.

◆ as_returns()

template<typename Source >
auto sol::as_returns ( Source &&  source)

Definition at line 28799 of file sol.hpp.

◆ as_table()

template<typename T >
as_table_t<meta::unqualified_t<T> > sol::as_table ( T &&  container)

Definition at line 7651 of file sol.hpp.

◆ as_table_ref()

template<typename T >
as_table_t<T> sol::as_table_ref ( T &&  container)

Definition at line 7646 of file sol.hpp.

◆ associated_type_name()

std::string sol::associated_type_name ( lua_State *  L,
int  index,
type  t 
)
inline

Definition at line 9526 of file sol.hpp.

◆ basic_insert_dump_writer()

template<typename Container >
int sol::basic_insert_dump_writer ( lua_State *  ,
const void *  memory,
size_t  memory_size,
void *  userdata_pointer 
)
inline

Definition at line 4507 of file sol.hpp.

◆ c_call() [1/2]

template<typename F , F fx>
int sol::c_call ( lua_State *  L)
inline

Definition at line 19089 of file sol.hpp.

◆ c_call() [2/2]

template<typename... Fxs>
int sol::c_call ( lua_State *  L)
inline

Definition at line 19111 of file sol.hpp.

◆ clear_flags()

template<typename Left , typename Right >
constexpr auto sol::clear_flags ( Left  left,
Right  right 
)
noexcept

Definition at line 8699 of file sol.hpp.

◆ default_at_panic()

int sol::default_at_panic ( lua_State *  L)
inline

Definition at line 27089 of file sol.hpp.

◆ default_traceback_error_handler()

int sol::default_traceback_error_handler ( lua_State *  L)
inline

Definition at line 27111 of file sol.hpp.

◆ destructor()

template<typename Fx >
auto sol::destructor ( Fx &&  fx)
inline

Definition at line 7044 of file sol.hpp.

◆ dump_panic_on_error()

int sol::dump_panic_on_error ( lua_State *  L_,
int  result_code,
lua_Writer  writer_function,
void *  userdata_pointer_,
bool  strip 
)
inline

Definition at line 20564 of file sol.hpp.

◆ dump_pass_on_error()

int sol::dump_pass_on_error ( lua_State *  L_,
int  result_code,
lua_Writer  writer_function,
void *  userdata_pointer_,
bool  strip 
)
inline

Definition at line 20556 of file sol.hpp.

◆ dump_throw_on_error()

int sol::dump_throw_on_error ( lua_State *  L_,
int  result_code,
lua_Writer  writer_function,
void *  userdata_pointer_,
bool  strip 
)
inline

Definition at line 20572 of file sol.hpp.

◆ factories()

template<typename... Functions>
auto sol::factories ( Functions &&...  functions)
inline

Definition at line 7027 of file sol.hpp.

◆ get() [1/4]

template<std::size_t I>
stack_proxy sol::get ( const unsafe_function_result &  fr)

Definition at line 17614 of file sol.hpp.

◆ get() [2/4]

template<std::size_t I, typename... Args>
stack_proxy sol::get ( types< Args... >  t,
const unsafe_function_result &  fr 
)

Definition at line 17619 of file sol.hpp.

◆ get() [3/4]

template<std::size_t I>
stack_proxy sol::get ( const protected_function_result &  fr)

Definition at line 17624 of file sol.hpp.

◆ get() [4/4]

template<std::size_t I, typename... Args>
stack_proxy sol::get ( types< Args... >  t,
const protected_function_result &  fr 
)

Definition at line 17629 of file sol.hpp.

◆ get_environment()

template<typename E = reference, typename T >
basic_environment<E> sol::get_environment ( const T &  target)

Definition at line 26726 of file sol.hpp.

◆ has_any_flag()

template<typename Left , typename Right >
constexpr bool sol::has_any_flag ( Left  left,
Right  right 
)
noexcept

Definition at line 8694 of file sol.hpp.

◆ has_flag()

template<typename Left , typename Right >
constexpr bool sol::has_flag ( Left  left,
Right  right 
)
noexcept

Definition at line 8689 of file sol.hpp.

◆ initializers()

template<typename... Functions>
auto sol::initializers ( Functions &&...  functions)
inline

Definition at line 7014 of file sol.hpp.

◆ is_indeterminate_call_failure()

bool sol::is_indeterminate_call_failure ( call_status  c)
inline

Definition at line 7936 of file sol.hpp.

◆ main_thread()

lua_State* sol::main_thread ( lua_State *  L_,
lua_State *  backup_if_unsupported_ = nullptr 
)
inline

Definition at line 10124 of file sol.hpp.

◆ make_closure()

template<typename... Args>
closure<Args...> sol::make_closure ( lua_CFunction  f,
Args &&...  args 
)

Definition at line 7552 of file sol.hpp.

◆ make_light()

template<typename T >
auto sol::make_light ( T &  l)

Definition at line 7478 of file sol.hpp.

◆ make_object() [1/2]

template<typename T >
object sol::make_object ( lua_State *  L_,
T &&  value 
)

Definition at line 16916 of file sol.hpp.

◆ make_object() [2/2]

template<typename T , typename... Args>
object sol::make_object ( lua_State *  L_,
Args &&...  args 
)

Definition at line 16921 of file sol.hpp.

◆ make_object_userdata() [1/2]

template<typename T >
object sol::make_object_userdata ( lua_State *  L_,
T &&  value 
)

Definition at line 16926 of file sol.hpp.

◆ make_object_userdata() [2/2]

template<typename T , typename... Args>
object sol::make_object_userdata ( lua_State *  L_,
Args &&...  args 
)

Definition at line 16931 of file sol.hpp.

◆ make_optional() [1/3]

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)
inline

Definition at line 6183 of file sol.hpp.

◆ make_optional() [2/3]

template<class T , class... Args>
constexpr optional<T> sol::make_optional ( Args &&...  args)
inline

Definition at line 6188 of file sol.hpp.

◆ make_optional() [3/3]

template<class T , class U , class... Args>
constexpr optional<T> sol::make_optional ( std::initializer_list< U >  il,
Args &&...  args 
)
inline

Definition at line 6192 of file sol.hpp.

◆ make_reference() [1/2]

template<typename R = reference, bool should_pop = !is_stack_based_v<R>, typename T >
R sol::make_reference ( lua_State *  L,
T &&  value 
)

Definition at line 16715 of file sol.hpp.

◆ make_reference() [2/2]

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 
)

Definition at line 16725 of file sol.hpp.

◆ make_reference_userdata() [1/2]

template<typename R = reference, bool should_pop = !is_stack_based_v<R>, typename T >
R sol::make_reference_userdata ( lua_State *  L,
T &&  value 
)

Definition at line 16735 of file sol.hpp.

◆ make_reference_userdata() [2/2]

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 
)

Definition at line 16745 of file sol.hpp.

◆ make_user()

template<typename T >
auto sol::make_user ( T &&  u)

Definition at line 7511 of file sol.hpp.

◆ meta_function_names()

const std::array<std::string, 37>& sol::meta_function_names ( )
inline

Definition at line 8027 of file sol.hpp.

◆ meta_registry_key()

template<typename T >
auto sol::meta_registry_key ( T &&  key)

Definition at line 7528 of file sol.hpp.

◆ no_panic()

int sol::no_panic ( lua_State *  ,
int  ,
type  ,
type  ,
const char *  = nullptr 
)
inlinenoexcept

Definition at line 9616 of file sol.hpp.

◆ operator &()

constexpr automagic_flags sol::operator& ( automagic_flags  left,
automagic_flags  right 
)
inlinenoexcept

Definition at line 8673 of file sol.hpp.

◆ operator &=()

constexpr automagic_flags& sol::operator&= ( automagic_flags &  left,
automagic_flags  right 
)
inlinenoexcept

Definition at line 8683 of file sol.hpp.

◆ operator!=() [1/22]

template<class T , class U >
constexpr bool sol::operator!= ( const optional< T > &  lhs,
const optional< U > &  rhs 
)
inline

relop

Definition at line 6020 of file sol.hpp.

◆ operator!=() [2/22]

template<class T >
constexpr bool sol::operator!= ( const optional< T > &  lhs,
nullopt_t   
)
inlinenoexcept

relop_nullopt

Definition at line 6058 of file sol.hpp.

◆ operator!=() [3/22]

template<class T >
constexpr bool sol::operator!= ( nullopt_t  ,
const optional< T > &  rhs 
)
inlinenoexcept

relop_nullopt

Definition at line 6063 of file sol.hpp.

◆ operator!=() [4/22]

template<class T , class U >
constexpr bool sol::operator!= ( const optional< T > &  lhs,
const U &  rhs 
)
inline

relop_t

Definition at line 6123 of file sol.hpp.

◆ operator!=() [5/22]

template<class T , class U >
constexpr bool sol::operator!= ( const U &  lhs,
const optional< T > &  rhs 
)
inline

relop_t

Definition at line 6128 of file sol.hpp.

◆ operator!=() [6/22]

bool sol::operator!= ( lua_nil_t  ,
lua_nil_t   
)
inline

Definition at line 7318 of file sol.hpp.

◆ operator!=() [7/22]

bool sol::operator!= ( const stack_reference &  l,
const stack_reference &  r 
)
inline

Definition at line 9829 of file sol.hpp.

◆ operator!=() [8/22]

bool sol::operator!= ( const stack_reference &  lhs,
const lua_nil_t &   
)
inline

Definition at line 9841 of file sol.hpp.

◆ operator!=() [9/22]

bool sol::operator!= ( const lua_nil_t &  ,
const stack_reference &  rhs 
)
inline

Definition at line 9845 of file sol.hpp.

◆ operator!=() [10/22]

bool sol::operator!= ( const stateless_stack_reference &  l,
const stateless_stack_reference &  r 
)
inline

Definition at line 9853 of file sol.hpp.

◆ operator!=() [11/22]

template<bool lb, bool rb>
bool sol::operator!= ( const basic_reference< lb > &  l,
const basic_reference< rb > &  r 
)
inlinenoexcept

Definition at line 10659 of file sol.hpp.

◆ operator!=() [12/22]

template<bool lb>
bool sol::operator!= ( const basic_reference< lb > &  l,
const stack_reference &  r 
)
inlinenoexcept

Definition at line 10670 of file sol.hpp.

◆ operator!=() [13/22]

template<bool rb>
bool sol::operator!= ( const stack_reference &  l,
const basic_reference< rb > &  r 
)
inlinenoexcept

Definition at line 10681 of file sol.hpp.

◆ operator!=() [14/22]

template<bool lb>
bool sol::operator!= ( const basic_reference< lb > &  lhs,
const lua_nil_t &   
)
inlinenoexcept

Definition at line 10696 of file sol.hpp.

◆ operator!=() [15/22]

template<bool rb>
bool sol::operator!= ( const lua_nil_t &  ,
const basic_reference< rb > &  rhs 
)
inlinenoexcept

Definition at line 10701 of file sol.hpp.

◆ operator!=() [16/22]

bool sol::operator!= ( const stateless_reference &  l,
const stateless_reference &  r 
)
inlinenoexcept

Definition at line 10709 of file sol.hpp.

◆ operator!=() [17/22]

bool sol::operator!= ( const stateless_reference &  lhs,
const lua_nil_t &   
)
inlinenoexcept

Definition at line 10721 of file sol.hpp.

◆ operator!=() [18/22]

bool sol::operator!= ( const lua_nil_t &  ,
const stateless_reference &  rhs 
)
inlinenoexcept

Definition at line 10725 of file sol.hpp.

◆ operator!=() [19/22]

template<typename Table , typename Key , typename T >
bool sol::operator!= ( T &&  left,
const table_proxy< Table, Key > &  right 
)
inline

Definition at line 24972 of file sol.hpp.

◆ operator!=() [20/22]

template<typename Table , typename Key , typename T >
bool sol::operator!= ( const table_proxy< Table, Key > &  right,
T &&  left 
)
inline

Definition at line 24978 of file sol.hpp.

◆ operator!=() [21/22]

template<typename Table , typename Key >
bool sol::operator!= ( lua_nil_t  ,
const table_proxy< Table, Key > &  right 
)
inline

Definition at line 24994 of file sol.hpp.

◆ operator!=() [22/22]

template<typename Table , typename Key >
bool sol::operator!= ( const table_proxy< Table, Key > &  right,
lua_nil_t   
)
inline

Definition at line 24999 of file sol.hpp.

◆ operator+()

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 
)
inline

Definition at line 17108 of file sol.hpp.

◆ operator<() [1/5]

template<class T , class U >
constexpr bool sol::operator< ( const optional< T > &  lhs,
const optional< U > &  rhs 
)
inline

relop

Definition at line 6025 of file sol.hpp.

◆ operator<() [2/5]

template<class T >
constexpr bool sol::operator< ( const optional< T > &  ,
nullopt_t   
)
inlinenoexcept

relop_nullopt

Definition at line 6068 of file sol.hpp.

◆ operator<() [3/5]

template<class T >
constexpr bool sol::operator< ( nullopt_t  ,
const optional< T > &  rhs 
)
inlinenoexcept

relop_nullopt

Definition at line 6073 of file sol.hpp.

◆ operator<() [4/5]

template<class T , class U >
constexpr bool sol::operator< ( const optional< T > &  lhs,
const U &  rhs 
)
inline

relop_t

Definition at line 6133 of file sol.hpp.

◆ operator<() [5/5]

template<class T , class U >
constexpr bool sol::operator< ( const U &  lhs,
const optional< T > &  rhs 
)
inline

relop_t

Definition at line 6138 of file sol.hpp.

◆ operator<=() [1/5]

template<class T , class U >
constexpr bool sol::operator<= ( const optional< T > &  lhs,
const optional< U > &  rhs 
)
inline

relop

Definition at line 6035 of file sol.hpp.

◆ operator<=() [2/5]

template<class T >
constexpr bool sol::operator<= ( const optional< T > &  lhs,
nullopt_t   
)
inlinenoexcept

relop_nullopt

Definition at line 6078 of file sol.hpp.

◆ operator<=() [3/5]

template<class T >
constexpr bool sol::operator<= ( nullopt_t  ,
const optional< T > &   
)
inlinenoexcept

relop_nullopt

Definition at line 6083 of file sol.hpp.

◆ operator<=() [4/5]

template<class T , class U >
constexpr bool sol::operator<= ( const optional< T > &  lhs,
const U &  rhs 
)
inline

relop_t

Definition at line 6143 of file sol.hpp.

◆ operator<=() [5/5]

template<class T , class U >
constexpr bool sol::operator<= ( const U &  lhs,
const optional< T > &  rhs 
)
inline

relop_t

Definition at line 6148 of file sol.hpp.

◆ operator==() [1/22]

template<class T , class U >
constexpr bool sol::operator== ( const optional< T > &  lhs,
const optional< U > &  rhs 
)
inline

Compares two optional objects.

relop

If both optionals contain a value, they are compared with Ts relational operators. Otherwise lhs and rhs are equal only if they are both empty, and lhs is less than rhs only if rhs is empty and lhs is not.

Definition at line 6015 of file sol.hpp.

◆ operator==() [2/22]

template<class T >
constexpr bool sol::operator== ( const optional< T > &  lhs,
nullopt_t   
)
inlinenoexcept

Compares an optional to a nullopt

relop_nullopt

Equivalent to comparing the optional to an empty optional

Definition at line 6048 of file sol.hpp.

◆ operator==() [3/22]

template<class T >
constexpr bool sol::operator== ( nullopt_t  ,
const optional< T > &  rhs 
)
inlinenoexcept

relop_nullopt

Definition at line 6053 of file sol.hpp.

◆ operator==() [4/22]

template<class T , class U >
constexpr bool sol::operator== ( const optional< T > &  lhs,
const U &  rhs 
)
inline

Compares the optional with a value.

relop_t

If the optional has a value, it is compared with the other value using Ts relational operators. Otherwise, the optional is considered less than the value.

Definition at line 6113 of file sol.hpp.

◆ operator==() [5/22]

template<class T , class U >
constexpr bool sol::operator== ( const U &  lhs,
const optional< T > &  rhs 
)
inline

relop_t

Definition at line 6118 of file sol.hpp.

◆ operator==() [6/22]

bool sol::operator== ( lua_nil_t  ,
lua_nil_t   
)
inline

Definition at line 7315 of file sol.hpp.

◆ operator==() [7/22]

bool sol::operator== ( const stack_reference &  l,
const stack_reference &  r 
)
inline

Definition at line 9825 of file sol.hpp.

◆ operator==() [8/22]

bool sol::operator== ( const stack_reference &  lhs,
const lua_nil_t &   
)
inline

Definition at line 9833 of file sol.hpp.

◆ operator==() [9/22]

bool sol::operator== ( const lua_nil_t &  ,
const stack_reference &  rhs 
)
inline

Definition at line 9837 of file sol.hpp.

◆ operator==() [10/22]

bool sol::operator== ( const stateless_stack_reference &  l,
const stateless_stack_reference &  r 
)
inline

Definition at line 9849 of file sol.hpp.

◆ operator==() [11/22]

template<bool lb, bool rb>
bool sol::operator== ( const basic_reference< lb > &  l,
const basic_reference< rb > &  r 
)
inlinenoexcept

Definition at line 10652 of file sol.hpp.

◆ operator==() [12/22]

template<bool lb>
bool sol::operator== ( const basic_reference< lb > &  l,
const stack_reference &  r 
)
inlinenoexcept

Definition at line 10664 of file sol.hpp.

◆ operator==() [13/22]

template<bool rb>
bool sol::operator== ( const stack_reference &  l,
const basic_reference< rb > &  r 
)
inlinenoexcept

Definition at line 10675 of file sol.hpp.

◆ operator==() [14/22]

template<bool lb>
bool sol::operator== ( const basic_reference< lb > &  lhs,
const lua_nil_t &   
)
inlinenoexcept

Definition at line 10686 of file sol.hpp.

◆ operator==() [15/22]

template<bool rb>
bool sol::operator== ( const lua_nil_t &  ,
const basic_reference< rb > &  rhs 
)
inlinenoexcept

Definition at line 10691 of file sol.hpp.

◆ operator==() [16/22]

bool sol::operator== ( const stateless_reference &  l,
const stateless_reference &  r 
)
inlinenoexcept

Definition at line 10705 of file sol.hpp.

◆ operator==() [17/22]

bool sol::operator== ( const stateless_reference &  lhs,
const lua_nil_t &   
)
inlinenoexcept

Definition at line 10713 of file sol.hpp.

◆ operator==() [18/22]

bool sol::operator== ( const lua_nil_t &  ,
const stateless_reference &  rhs 
)
inlinenoexcept

Definition at line 10717 of file sol.hpp.

◆ operator==() [19/22]

template<typename Table , typename Key , typename T >
bool sol::operator== ( T &&  left,
const table_proxy< Table, Key > &  right 
)
inline

Definition at line 24960 of file sol.hpp.

◆ operator==() [20/22]

template<typename Table , typename Key , typename T >
bool sol::operator== ( const table_proxy< Table, Key > &  right,
T &&  left 
)
inline

Definition at line 24966 of file sol.hpp.

◆ operator==() [21/22]

template<typename Table , typename Key >
bool sol::operator== ( lua_nil_t  ,
const table_proxy< Table, Key > &  right 
)
inline

Definition at line 24984 of file sol.hpp.

◆ operator==() [22/22]

template<typename Table , typename Key >
bool sol::operator== ( const table_proxy< Table, Key > &  right,
lua_nil_t   
)
inline

Definition at line 24989 of file sol.hpp.

◆ operator>() [1/5]

template<class T , class U >
constexpr bool sol::operator> ( const optional< T > &  lhs,
const optional< U > &  rhs 
)
inline

relop

Definition at line 6030 of file sol.hpp.

◆ operator>() [2/5]

template<class T >
constexpr bool sol::operator> ( const optional< T > &  lhs,
nullopt_t   
)
inlinenoexcept

relop_nullopt

Definition at line 6088 of file sol.hpp.

◆ operator>() [3/5]

template<class T >
constexpr bool sol::operator> ( nullopt_t  ,
const optional< T > &   
)
inlinenoexcept

relop_nullopt

Definition at line 6093 of file sol.hpp.

◆ operator>() [4/5]

template<class T , class U >
constexpr bool sol::operator> ( const optional< T > &  lhs,
const U &  rhs 
)
inline

relop_t

Definition at line 6153 of file sol.hpp.

◆ operator>() [5/5]

template<class T , class U >
constexpr bool sol::operator> ( const U &  lhs,
const optional< T > &  rhs 
)
inline

relop_t

Definition at line 6158 of file sol.hpp.

◆ operator>=() [1/5]

template<class T , class U >
constexpr bool sol::operator>= ( const optional< T > &  lhs,
const optional< U > &  rhs 
)
inline

relop

Definition at line 6040 of file sol.hpp.

◆ operator>=() [2/5]

template<class T >
constexpr bool sol::operator>= ( const optional< T > &  ,
nullopt_t   
)
inlinenoexcept

relop_nullopt

Definition at line 6098 of file sol.hpp.

◆ operator>=() [3/5]

template<class T >
constexpr bool sol::operator>= ( nullopt_t  ,
const optional< T > &  rhs 
)
inlinenoexcept

relop_nullopt

Definition at line 6103 of file sol.hpp.

◆ operator>=() [4/5]

template<class T , class U >
constexpr bool sol::operator>= ( const optional< T > &  lhs,
const U &  rhs 
)
inline

relop_t

Definition at line 6163 of file sol.hpp.

◆ operator>=() [5/5]

template<class T , class U >
constexpr bool sol::operator>= ( const U &  lhs,
const optional< T > &  rhs 
)
inline

relop_t

Definition at line 6168 of file sol.hpp.

◆ operator|()

constexpr automagic_flags sol::operator| ( automagic_flags  left,
automagic_flags  right 
)
inlinenoexcept

Definition at line 8668 of file sol.hpp.

◆ operator|=()

constexpr automagic_flags& sol::operator|= ( automagic_flags &  left,
automagic_flags  right 
)
inlinenoexcept

Definition at line 8678 of file sol.hpp.

◆ overload()

template<typename... Args>
decltype(auto) sol::overload ( Args &&...  args)

Definition at line 13032 of file sol.hpp.

◆ pass_as_value()

template<typename T >
auto sol::pass_as_value ( T &  value_ref_)

Definition at line 7733 of file sol.hpp.

◆ policies()

template<typename F , typename... Args>
auto sol::policies ( F &&  f,
Args &&...  args 
)

Definition at line 7110 of file sol.hpp.

◆ property() [1/2]

template<typename F , typename G >
decltype(auto) sol::property ( F &&  f,
G &&  g 
)
inline

Definition at line 17956 of file sol.hpp.

◆ property() [2/2]

template<typename F >
decltype(auto) sol::property ( F &&  f)
inline

Definition at line 17968 of file sol.hpp.

◆ protect()

template<typename T >
auto sol::protect ( T &&  value)

Definition at line 18064 of file sol.hpp.

◆ push_invoke()

template<typename Fx >
auto sol::push_invoke ( Fx &&  fx)

Definition at line 7711 of file sol.hpp.

◆ push_type_panic_string()

int sol::push_type_panic_string ( lua_State *  L,
int  index,
type  expected,
type  actual,
string_view  message,
string_view  aux_message 
)
inlinenoexcept

Definition at line 9551 of file sol.hpp.

◆ readonly()

template<typename R , typename T >
auto sol::readonly ( R T::*  v)
inline

Definition at line 18006 of file sol.hpp.

◆ readonly_property()

template<typename F >
decltype(auto) sol::readonly_property ( F &&  f)
inline

Definition at line 17979 of file sol.hpp.

◆ register_main_thread()

void sol::register_main_thread ( lua_State *  L)
inline

Definition at line 27075 of file sol.hpp.

◆ resolve() [1/5]

template<typename... Args, typename R >
constexpr auto sol::resolve ( R   fun_ptrArgs...) -> R (*)(Args...)
inline

Definition at line 19701 of file sol.hpp.

◆ resolve() [2/5]

template<typename Sig >
constexpr Sig* sol::resolve ( Sig *  fun_ptr)
inline

Definition at line 19706 of file sol.hpp.

◆ resolve() [3/5]

template<typename... Args, typename R , typename C >
constexpr auto sol::resolve ( R(C::*)(Args...)  mem_ptr) -> R (C::*)(Args...)
inline

Definition at line 19711 of file sol.hpp.

◆ resolve() [4/5]

template<typename Sig , typename C >
constexpr Sig C::* sol::resolve ( Sig C::*  mem_ptr)
inline

Definition at line 19716 of file sol.hpp.

◆ resolve() [5/5]

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)))
inline

Definition at line 19721 of file sol.hpp.

◆ script_default_on_error()

protected_function_result sol::script_default_on_error ( lua_State *  L,
protected_function_result  pfr 
)
inline

Definition at line 27212 of file sol.hpp.

◆ script_pass_on_error()

protected_function_result sol::script_pass_on_error ( lua_State *  ,
protected_function_result  result 
)
inline

Definition at line 27150 of file sol.hpp.

◆ script_throw_on_error()

protected_function_result sol::script_throw_on_error ( lua_State *  L,
protected_function_result  result 
)
inline

Definition at line 27154 of file sol.hpp.

◆ set_default_exception_handler()

void sol::set_default_exception_handler ( lua_State *  L,
exception_handler_function  exf = &detail::default_exception_handler 
)
inline

Definition at line 8897 of file sol.hpp.

◆ set_default_state()

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 
)
inline

Definition at line 27132 of file sol.hpp.

◆ set_environment()

template<typename T , typename E >
bool sol::set_environment ( const basic_environment< E > &  env,
const T &  target 
)

Definition at line 26721 of file sol.hpp.

◆ swap()

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

template <class t>="">
void swap(optional<T> &lhs, optional<T> &rhs);

Definition at line 6174 of file sol.hpp.

◆ to_string() [1/4]

const std::string& sol::to_string ( call_status  c)
inline

Definition at line 7900 of file sol.hpp.

◆ to_string() [2/4]

const std::string& sol::to_string ( load_status  c)
inline

Definition at line 7951 of file sol.hpp.

◆ to_string() [3/4]

const std::string& sol::to_string ( load_mode  c)
inline

Definition at line 7974 of file sol.hpp.

◆ to_string() [4/4]

const std::string& sol::to_string ( meta_function  mf)
inline

Definition at line 8071 of file sol.hpp.

◆ total_memory_used()

std::size_t sol::total_memory_used ( lua_State *  L)
inline

Definition at line 27143 of file sol.hpp.

◆ type_assert() [1/2]

void sol::type_assert ( lua_State *  L,
int  index,
type  expected,
type  actual 
)
inlinenoexcept

Definition at line 9628 of file sol.hpp.

◆ type_assert() [2/2]

void sol::type_assert ( lua_State *  L,
int  index,
type  expected 
)
inline

Definition at line 9634 of file sol.hpp.

◆ type_error() [1/2]

void sol::type_error ( lua_State *  L,
int  expected,
int  actual 
)
inlinenoexcept

Definition at line 9620 of file sol.hpp.

◆ type_error() [2/2]

void sol::type_error ( lua_State *  L,
type  expected,
type  actual 
)
inlinenoexcept

Definition at line 9624 of file sol.hpp.

◆ type_name()

std::string sol::type_name ( lua_State *  L,
type  t 
)
inline

Definition at line 8079 of file sol.hpp.

◆ type_of() [1/2]

type sol::type_of ( lua_State *  L,
int  index 
)
inline

Definition at line 8075 of file sol.hpp.

◆ type_of() [2/2]

template<typename T >
type sol::type_of ( )
inline

Definition at line 8593 of file sol.hpp.

◆ type_panic_c_str()

int sol::type_panic_c_str ( lua_State *  L,
int  index,
type  expected,
type  actual,
const char *  message = nullptr 
)
inlinenoexcept

Definition at line 9568 of file sol.hpp.

◆ type_panic_string()

int sol::type_panic_string ( lua_State *  L,
int  index,
type  expected,
type  actual,
string_view  message = "" 
)
inlinenoexcept

Definition at line 9563 of file sol.hpp.

◆ var()

template<typename V >
auto sol::var ( V &&  v)
inline

Definition at line 18020 of file sol.hpp.

◆ writeonly_property()

template<typename F >
decltype(auto) sol::writeonly_property ( F &&  f)
inline

Definition at line 17984 of file sol.hpp.

◆ yielding()

template<typename F >
yielding_t<std::decay_t<F> > sol::yielding ( F &&  f)
inline

Definition at line 7362 of file sol.hpp.

Variable Documentation

◆ base_classes

const auto sol::base_classes = base_classes_tag()

Definition at line 9335 of file sol.hpp.

◆ bytecode_dump_writer

constexpr auto sol::bytecode_dump_writer = &basic_insert_dump_writer<bytecode>
inline

Definition at line 4526 of file sol.hpp.

◆ call_constructor

const auto sol::call_constructor = call_construction {}

Definition at line 7003 of file sol.hpp.

◆ create

const new_table sol::create = {}

Definition at line 7807 of file sol.hpp.

◆ create_if_nil

constexpr create_if_nil_t sol::create_if_nil = create_if_nil_t()
inline

Definition at line 7742 of file sol.hpp.

◆ default_constructor

const auto sol::default_constructor = constructors<types<>> {}

Definition at line 6997 of file sol.hpp.

◆ default_destructor

const destructor_wrapper<void> sol::default_destructor {}

Definition at line 7041 of file sol.hpp.

◆ env_key

constexpr env_key_t sol::env_key {}
inline

Definition at line 7337 of file sol.hpp.

◆ global_tag

struct sol::global_tag_t sol::global_tag

◆ in_place

constexpr std::in_place_t sol::in_place {}

Definition at line 4612 of file sol.hpp.

◆ in_place_index

template<size_t I>
constexpr in_place_index_t<I> sol::in_place_index {}

Definition at line 4623 of file sol.hpp.

◆ in_place_of

constexpr std::in_place_t sol::in_place_of {}

Definition at line 4613 of file sol.hpp.

◆ in_place_type

template<typename T >
constexpr std::in_place_type_t<T> sol::in_place_type {}

Definition at line 4618 of file sol.hpp.

◆ is_actual_type_rebindable_for_v

template<typename T , typename Element = void>
constexpr bool sol::is_actual_type_rebindable_for_v = is_actual_type_rebindable_for<T, Element>::value
inline

Definition at line 9322 of file sol.hpp.

◆ is_callable_v

template<typename T >
constexpr bool sol::is_callable_v = is_callable<T>::value
inline

Definition at line 8142 of file sol.hpp.

◆ is_container_v

template<typename T >
constexpr bool sol::is_container_v = is_container<T>::value
inline

Definition at line 8129 of file sol.hpp.

◆ is_environment_v

template<typename T >
constexpr bool sol::is_environment_v = is_environment<T>::value
inline

Definition at line 8576 of file sol.hpp.

◆ is_global_table_v

template<typename T >
constexpr bool sol::is_global_table_v = is_global_table<T>::value
inline

Definition at line 8541 of file sol.hpp.

◆ is_lightuserdata_v

template<typename T >
constexpr bool sol::is_lightuserdata_v = is_lightuserdata<T>::value
inline

Definition at line 8564 of file sol.hpp.

◆ is_lua_c_function_v

template<typename T >
constexpr bool sol::is_lua_c_function_v = is_lua_c_function<T>::value
inline

Definition at line 8651 of file sol.hpp.

◆ is_lua_primitive_v

template<typename T >
constexpr bool sol::is_lua_primitive_v = is_lua_primitive<T>::value
inline

Definition at line 8429 of file sol.hpp.

◆ is_lua_reference_or_proxy_v

template<typename T >
constexpr bool sol::is_lua_reference_or_proxy_v = is_lua_reference_or_proxy<T>::value
inline

Definition at line 8106 of file sol.hpp.

◆ is_lua_reference_v

template<typename T >
constexpr bool sol::is_lua_reference_v = is_lua_reference<T>::value
inline

Definition at line 8100 of file sol.hpp.

◆ is_main_threaded_v

template<typename T >
constexpr bool sol::is_main_threaded_v = is_main_threaded<T>::value
inline

Definition at line 8448 of file sol.hpp.

◆ is_stack_based_v

template<typename T >
constexpr bool sol::is_stack_based_v = is_stack_based<T>::value
inline

Definition at line 8466 of file sol.hpp.

◆ is_stack_table_v

template<typename T >
constexpr bool sol::is_stack_table_v = is_stack_table<T>::value
inline

Definition at line 8551 of file sol.hpp.

◆ is_stateless_lua_reference_v

template<typename T >
constexpr bool sol::is_stateless_lua_reference_v = is_stateless_lua_reference<T>::value
inline

Definition at line 8090 of file sol.hpp.

◆ is_table_like_v

template<typename T >
constexpr bool sol::is_table_like_v = is_table_like<T>::value
inline

Definition at line 8582 of file sol.hpp.

◆ is_table_v

template<typename T >
constexpr bool sol::is_table_v = is_table<T>::value
inline

Definition at line 8533 of file sol.hpp.

◆ is_to_stringable_v

template<typename T >
constexpr bool sol::is_to_stringable_v = is_to_stringable<T>::value
inline

Definition at line 8136 of file sol.hpp.

◆ is_transparent_argument_v

template<typename T >
constexpr bool sol::is_transparent_argument_v = is_transparent_argument<T>::value
inline

Definition at line 8116 of file sol.hpp.

◆ is_unique_usertype_v

template<typename T >
constexpr bool sol::is_unique_usertype_v = is_unique_usertype<T>::value
inline

Definition at line 9229 of file sol.hpp.

◆ is_userdata_v

template<typename T >
constexpr bool sol::is_userdata_v = is_userdata<T>::value
inline

Definition at line 8570 of file sol.hpp.

◆ is_value_semantic_for_function_v

template<typename T >
constexpr bool sol::is_value_semantic_for_function_v = is_value_semantic_for_function<T>::value
inline

Definition at line 8442 of file sol.hpp.

◆ lua_nil

constexpr lua_nil_t sol::lua_nil {}
inline

Definition at line 7314 of file sol.hpp.

◆ lua_size_v

template<typename T >
constexpr int sol::lua_size_v = lua_size<T>::value
inline

Definition at line 8405 of file sol.hpp.

◆ lua_type_of_v

template<typename T >
constexpr type sol::lua_type_of_v = lua_type_of<T>::value
inline

Definition at line 8391 of file sol.hpp.

◆ metatable_key

constexpr metatable_key_t sol::metatable_key {}
inline

Definition at line 7331 of file sol.hpp.

◆ nested_tag

constexpr nested_tag_t sol::nested_tag {}
inline

Definition at line 7643 of file sol.hpp.

◆ nil

constexpr const nil_t& sol::nil = lua_nil
inline

Definition at line 7323 of file sol.hpp.

◆ no_constructor

const auto sol::no_constructor = no_construction {}

Definition at line 7000 of file sol.hpp.

◆ no_metatable

constexpr no_metatable_t sol::no_metatable {}
inline

Definition at line 7340 of file sol.hpp.

◆ override_value

constexpr override_value_t sol::override_value = override_value_t()
inline

Definition at line 7738 of file sol.hpp.

◆ type_panic

const type_panic_t sol::type_panic = {}

Definition at line 9582 of file sol.hpp.

◆ update_if_empty

constexpr update_if_empty_t sol::update_if_empty = update_if_empty_t()
inline

Definition at line 7740 of file sol.hpp.


plotjuggler
Author(s): Davide Faconti
autogenerated on Mon Jun 19 2023 03:12:57