OpenMiner  0.0.1a
Voxel game engine
Public Member Functions | Private Member Functions | List of all members
sol::basic_function< base_t, aligned > Class Template Reference

#include <sol.hpp>

Inheritance diagram for sol::basic_function< base_t, aligned >:
base_t

Public Member Functions

 basic_function ()=default
 
template<typename T , meta::enable< meta::neg< std::is_same< meta::unqualified_t< T >, basic_function >>, meta::neg< std::is_same< base_t, stack_reference >>, meta::neg< std::is_same< lua_nil_t, meta::unqualified_t< T >>>, is_lua_reference< meta::unqualified_t< T >>> = meta::enabler>
 basic_function (T &&r) noexcept
 
 basic_function (const basic_function &)=default
 
basic_function & operator= (const basic_function &)=default
 
 basic_function (basic_function &&)=default
 
basic_function & operator= (basic_function &&)=default
 
 basic_function (const stack_reference &r)
 
 basic_function (stack_reference &&r)
 
 basic_function (lua_nil_t n)
 
template<typename T , meta::enable< is_lua_reference< meta::unqualified_t< T >>> = meta::enabler>
 basic_function (lua_State *L, T &&r)
 
 basic_function (lua_State *L, int index=-1)
 
 basic_function (lua_State *L, ref_index index)
 
template<typename... Args>
unsafe_function_result operator() (Args &&... args) const
 
template<typename... Ret, typename... Args>
decltype(auto) operator() (types< Ret... >, Args &&... args) const
 
template<typename... Ret, typename... Args>
decltype(auto) call (Args &&... args) const
 

Private Member Functions

void luacall (std::ptrdiff_t argcount, std::ptrdiff_t resultcount) const
 
template<std::size_t... I, typename... Ret>
auto invoke (types< Ret... >, std::index_sequence< I... >, std::ptrdiff_t n) const
 
template<std::size_t I, typename Ret >
Ret invoke (types< Ret >, std::index_sequence< I >, std::ptrdiff_t n) const
 
template<std::size_t I>
void invoke (types< void >, std::index_sequence< I >, std::ptrdiff_t n) const
 
unsafe_function_result invoke (types<>, std::index_sequence<>, std::ptrdiff_t n) const
 

Constructor & Destructor Documentation

§ basic_function() [1/10]

template<typename base_t, bool aligned = false>
sol::basic_function< base_t, aligned >::basic_function ( )
default

§ basic_function() [2/10]

template<typename base_t, bool aligned = false>
template<typename T , meta::enable< meta::neg< std::is_same< meta::unqualified_t< T >, basic_function >>, meta::neg< std::is_same< base_t, stack_reference >>, meta::neg< std::is_same< lua_nil_t, meta::unqualified_t< T >>>, is_lua_reference< meta::unqualified_t< T >>> = meta::enabler>
sol::basic_function< base_t, aligned >::basic_function ( T &&  r)
inlinenoexcept
14978  : base_t(std::forward<T>(r)) {
14979 #if defined(SOL_SAFE_REFERENCES) && SOL_SAFE_REFERENCES
14980  if (!is_function<meta::unqualified_t<T>>::value) {
14981  auto pp = stack::push_pop(*this);
14982  constructor_handler handler{};
14983  stack::check<basic_function>(lua_state(), -1, handler);
14984  }
14985 #endif // Safety
14986  }
base_t
sol::stack::push_pop
push_popper< top_level, T > push_pop(T &&x)
Definition: sol.hpp:6661

§ basic_function() [3/10]

template<typename base_t, bool aligned = false>
sol::basic_function< base_t, aligned >::basic_function ( const basic_function< base_t, aligned > &  )
default

§ basic_function() [4/10]

template<typename base_t, bool aligned = false>
sol::basic_function< base_t, aligned >::basic_function ( basic_function< base_t, aligned > &&  )
default

§ basic_function() [5/10]

template<typename base_t, bool aligned = false>
sol::basic_function< base_t, aligned >::basic_function ( const stack_reference &  r)
inline
14992  : basic_function(r.lua_state(), r.stack_index()) {
14993  }
sol::basic_function::basic_function
basic_function()=default

§ basic_function() [6/10]

template<typename base_t, bool aligned = false>
sol::basic_function< base_t, aligned >::basic_function ( stack_reference &&  r)
inline
14995  : basic_function(r.lua_state(), r.stack_index()) {
14996  }
sol::basic_function::basic_function
basic_function()=default

§ basic_function() [7/10]

template<typename base_t, bool aligned = false>
sol::basic_function< base_t, aligned >::basic_function ( lua_nil_t  n)
inline
14998  : base_t(n) {
14999  }
base_t

§ basic_function() [8/10]

template<typename base_t, bool aligned = false>
template<typename T , meta::enable< is_lua_reference< meta::unqualified_t< T >>> = meta::enabler>
sol::basic_function< base_t, aligned >::basic_function ( lua_State *  L,
T &&  r 
)
inline
15002  : base_t(L, std::forward<T>(r)) {
15003 #if defined(SOL_SAFE_REFERENCES) && SOL_SAFE_REFERENCES
15004  auto pp = stack::push_pop(*this);
15005  constructor_handler handler{};
15006  stack::check<basic_function>(lua_state(), -1, handler);
15007 #endif // Safety
15008  }
base_t
sol::stack::push_pop
push_popper< top_level, T > push_pop(T &&x)
Definition: sol.hpp:6661

§ basic_function() [9/10]

template<typename base_t, bool aligned = false>
sol::basic_function< base_t, aligned >::basic_function ( lua_State *  L,
int  index = -1 
)
inline
15010  : base_t(L, index) {
15011 #if defined(SOL_SAFE_REFERENCES) && SOL_SAFE_REFERENCES
15012  constructor_handler handler{};
15013  stack::check<basic_function>(L, index, handler);
15014 #endif // Safety
15015  }
base_t

§ basic_function() [10/10]

template<typename base_t, bool aligned = false>
sol::basic_function< base_t, aligned >::basic_function ( lua_State *  L,
ref_index  index 
)
inline
15017  : base_t(L, index) {
15018 #if defined(SOL_SAFE_REFERENCES) && SOL_SAFE_REFERENCES
15019  auto pp = stack::push_pop(*this);
15020  constructor_handler handler{};
15021  stack::check<basic_function>(lua_state(), -1, handler);
15022 #endif // Safety
15023  }
base_t
sol::stack::push_pop
push_popper< top_level, T > push_pop(T &&x)
Definition: sol.hpp:6661

Member Function Documentation

§ call()

template<typename base_t, bool aligned = false>
template<typename... Ret, typename... Args>
decltype(auto) sol::basic_function< base_t, aligned >::call ( Args &&...  args) const
inline
15036  {
15037  if (!aligned) {
15038  base_t::push();
15039  }
15040  int pushcount = stack::multi_push_reference(lua_state(), std::forward<Args>(args)...);
15041  return invoke(types<Ret...>(), std::make_index_sequence<sizeof...(Ret)>(), pushcount);
15042  }
sol::stack::multi_push_reference
int multi_push_reference(lua_State *)
Definition: sol.hpp:7802
sol::basic_function::invoke
auto invoke(types< Ret... >, std::index_sequence< I... >, std::ptrdiff_t n) const
Definition: sol.hpp:14947
sol::stack::push
int push(lua_State *L, Arg &&arg, Args &&... args)
Definition: sol.hpp:7776

§ invoke() [1/4]

template<typename base_t, bool aligned = false>
template<std::size_t... I, typename... Ret>
auto sol::basic_function< base_t, aligned >::invoke ( types< Ret... >  ,
std::index_sequence< I... >  ,
std::ptrdiff_t  n 
) const
inlineprivate
14947  {
14948  luacall(n, lua_size<std::tuple<Ret...>>::value);
14949  return stack::pop<std::tuple<Ret...>>(lua_state());
14950  }
sol::stack::pop
decltype(auto) pop(lua_State *L)
Definition: sol.hpp:8064
sol::basic_function::luacall
void luacall(std::ptrdiff_t argcount, std::ptrdiff_t resultcount) const
Definition: sol.hpp:14942

§ invoke() [2/4]

template<typename base_t, bool aligned = false>
template<std::size_t I, typename Ret >
Ret sol::basic_function< base_t, aligned >::invoke ( types< Ret >  ,
std::index_sequence< I >  ,
std::ptrdiff_t  n 
) const
inlineprivate
14953  {
14954  luacall(n, lua_size<Ret>::value);
14955  return stack::pop<Ret>(lua_state());
14956  }
sol::basic_function::luacall
void luacall(std::ptrdiff_t argcount, std::ptrdiff_t resultcount) const
Definition: sol.hpp:14942

§ invoke() [3/4]

template<typename base_t, bool aligned = false>
template<std::size_t I>
void sol::basic_function< base_t, aligned >::invoke ( types< void >  ,
std::index_sequence< I >  ,
std::ptrdiff_t  n 
) const
inlineprivate
14959  {
14960  luacall(n, 0);
14961  }
sol::basic_function::luacall
void luacall(std::ptrdiff_t argcount, std::ptrdiff_t resultcount) const
Definition: sol.hpp:14942

§ invoke() [4/4]

template<typename base_t, bool aligned = false>
unsafe_function_result sol::basic_function< base_t, aligned >::invoke ( types<>  ,
std::index_sequence<>  ,
std::ptrdiff_t  n 
) const
inlineprivate
14963  {
14964  int stacksize = lua_gettop(lua_state());
14965  int firstreturn = (std::max)(1, stacksize - static_cast<int>(n));
14966  luacall(n, LUA_MULTRET);
14967  int poststacksize = lua_gettop(lua_state());
14968  int returncount = poststacksize - (firstreturn - 1);
14969  return unsafe_function_result(lua_state(), firstreturn, returncount);
14970  }
sol::basic_function::luacall
void luacall(std::ptrdiff_t argcount, std::ptrdiff_t resultcount) const
Definition: sol.hpp:14942

§ luacall()

template<typename base_t, bool aligned = false>
void sol::basic_function< base_t, aligned >::luacall ( std::ptrdiff_t  argcount,
std::ptrdiff_t  resultcount 
) const
inlineprivate
14942  {
14943  lua_call(lua_state(), static_cast<int>(argcount), static_cast<int>(resultcount));
14944  }

§ operator()() [1/2]

template<typename base_t, bool aligned = false>
template<typename... Args>
unsafe_function_result sol::basic_function< base_t, aligned >::operator() ( Args &&...  args) const
inline
15026  {
15027  return call<>(std::forward<Args>(args)...);
15028  }

§ operator()() [2/2]

template<typename base_t, bool aligned = false>
template<typename... Ret, typename... Args>
decltype(auto) sol::basic_function< base_t, aligned >::operator() ( types< Ret... >  ,
Args &&...  args 
) const
inline
15031  {
15032  return call<Ret...>(std::forward<Args>(args)...);
15033  }
sol::basic_function::call
decltype(auto) call(Args &&... args) const
Definition: sol.hpp:15036

§ operator=() [1/2]

template<typename base_t, bool aligned = false>
basic_function& sol::basic_function< base_t, aligned >::operator= ( const basic_function< base_t, aligned > &  )
default

§ operator=() [2/2]

template<typename base_t, bool aligned = false>
basic_function& sol::basic_function< base_t, aligned >::operator= ( basic_function< base_t, aligned > &&  )
default
The documentation for this class was generated from the following file:
Generated by   doxygen 1.8.12