Classes
struct	NativeFunction

struct	NativeFunction< void >

struct	Pushable

struct	Reference

struct	StateWrapper

struct	Table

struct	Value

struct	Value< bool >

struct	Value< CFunction >

struct	Value< char[n]>

struct	Value< const char * >

struct	Value< const char[n]>

struct	Value< const T >

struct	Value< double >

struct	Value< float >

struct	Value< internal::Path< P, K > >

struct	Value< long double >

struct	Value< NativeFunction< R > >

struct	Value< Pushable >

struct	Value< Reference >

struct	Value< signedchar >

struct	Value< signedint >

struct	Value< signedlong int >

struct	Value< signedlong long int >

struct	Value< signedshort >

struct	Value< std::function< R(A...)> >

struct	Value< std::list< T > >

struct	Value< std::map< K, V > >

struct	Value< std::nullptr_t >

struct	Value< std::string >

struct	Value< std::tuple< A... > >

struct	Value< std::vector< T > >

struct	Value< Table >

struct	Value< U & >

struct	Value< U * >

struct	Value< unsigned char >

struct	Value< unsigned int >

struct	Value< unsigned long int >

struct	Value< unsigned long long int >

struct	Value< unsigned short >

struct	Value< volatile T >

Typedefs
using	MemberMap = std::map< Pushable, Pushable >

using	Integer = lua_Integer

using	Number = lua_Number

using	State = lua_State

using	CFunction = lua_CFunction

Functions
static bool	equal (State *state, int index1, int index2)

static void	setMetatable (State state, const char name)

template<typename V >
static void	setGlobal (State state, const char name, V &&value)

template<typename V >
static V	getGlobal (State state, const char name)

template<typename... R>
static void	setFields (State *state, int index, R &&...args)

static void	setFields (State *state, int index, const MemberMap &fields)

template<typename V , typename K >
static V	getField (State *state, int index, K &&key)

template<typename S , typename F , typename... X>
static internal::Layout< S >::ReturnType	direct (State *state, int pos, F &&hook, X &&...args)

template<typename S , typename F , typename... A>
static internal::Layout< S >::ReturnType	direct (State *state, F &&hook, A &&...args)

template<typename T >
static internal::CallableInfo< T >::ReturnType	apply (State *state, int pos, T &&obj)

template<typename T >
static internal::CallableInfo< T >::ReturnType	apply (State *state, T &&obj)

template<typename S , typename F , typename... A>
static size_t	map (State *state, int pos, F &&hook, A &&...args)

template<typename S , typename F , typename... A>
static size_t	map (State *state, F &&hook, A &&...args)

static Table	getGlobalsTable (State *state)

template<typename T >
static size_t	push (State *state, T &&value)

template<typename T1 , typename T2 , typename... TR>
size_t	push (State *state, T1 &&value, T2 &&head, TR &&...rest)

template<typename T >
static T	read (State *state, int index)

template<typename U , typename... A>
static internal::StripUserType< U > &	construct (State *state, A &&...args)

template<typename U >
static void	registerUserType (State *state, const MemberMap &methods=MemberMap(), const MemberMap &meta_methods=MemberMap())

template<typename S >
static void	registerUserType (State state, const char ctor_name, const MemberMap &methods=MemberMap(), const MemberMap &meta_methods=MemberMap())

Typedef Documentation

using luwra::CFunction = typedef lua_CFunction

using luwra::Integer = typedef lua_Integer

using luwra::MemberMap = typedef std::map<Pushable, Pushable>

Map of members

using luwra::Number = typedef lua_Number

using luwra::State = typedef lua_State

Function Documentation

template<typename T >

static internal::CallableInfo<T>::ReturnType luwra::apply	(	State *	state,
		int	pos,
		T &&	obj
	)

inlinestatic

A version of direct which tries to infer the stack layout from the given Callable. It allows you to omit the template parameters since the compiler is able to infer the parameter and return types.

template<typename T >

static internal::CallableInfo<T>::ReturnType luwra::apply	(	State *	state,
		T &&	obj
	)

inlinestatic

Same as apply(state, 1, obj).

template<typename U , typename... A>

static internal::StripUserType<U>& luwra::construct	(	State *	state,
		A &&...	args
	)

inlinestatic

Construct a user type value on the stack.

Note: Instances created using this specialization are allocated and constructed as full user data types in Lua. The default garbage-collecting hook will destruct the user type, once it has been marked.

Parameters

state	Lua state
args	Constructor arguments

Returns: Reference to the constructed value

template<typename S , typename F , typename... X>

static internal::Layout<S>::ReturnType luwra::direct	(	State *	state,
		int	pos,
		F &&	hook,
		X &&...	args
	)

inlinestatic

Retrieve values from the stack and invoke a Callable with them.

Template Parameters

S	Signature in the form of `R(A...)` where `A` is a sequence of types, which shall be retrieved from the stack, and `R` the return type of `hook`
F	An instance of `Callable` which accepts parameters `X..., A...` and returns `R` (this parameter should be inferable and can be omitted)
X	Extra argument types

Parameters

state	Lua state instance
pos	Index of the first value
hook	Callable value
args	Extra arguments which shall be be passed to `hook` before the stack values

Returns: Result of calling hook

template<typename S , typename F , typename... A>

static internal::Layout<S>::ReturnType luwra::direct	(	State *	state,
		F &&	hook,
		A &&...	args
	)

inlinestatic

Same as direct(state, 1, hook).

static bool luwra::equal	(	State *	state,
		int	index1,
		int	index2
	)

inlinestatic

Check if two values are equal.

Parameters

state	Lua state
index1	Index of left-hand side value
index2	Index of right-hand side value

template<typename V , typename K >

static V luwra::getField	(	State *	state,
		int	index,
		K &&	key
	)

inlinestatic

Retrieve a field from a table.

template<typename V >

static V luwra::getGlobal	(	State *	state,
		const char *	name
	)

inlinestatic

Retrieve a global value.

Parameters

state	Lua state
name	Global name

Returns: Value associated with the given name

static Table luwra::getGlobalsTable ( State * state )

inlinestatic

Retrieve the table containing all global values.

Parameters

state Lua state

Returns: Reference to the globals table.

template<typename S , typename F , typename... A>

static size_t luwra::map	(	State *	state,
		int	pos,
		F &&	hook,
		A &&...	args
	)

inlinestatic

Similiar to direct but pushes the result of the given Callable onto the stack.

Returns: Number of values pushed

template<typename S , typename F , typename... A>

static size_t luwra::map	(	State *	state,
		F &&	hook,
		A &&...	args
	)

inlinestatic

Same as map(state, 1, hook).

template<typename T >

static size_t luwra::push	(	State *	state,
		T &&	value
	)

inlinestatic

Convenient wrapped for Value<T>::push.

template<typename T1 , typename T2 , typename... TR>

size_t luwra::push	(	State *	state,
		T1 &&	value,
		T2 &&	head,
		TR &&...	rest
	)

Allows you to push multiple values at once.

template<typename T >

static T luwra::read	(	State *	state,
		int	index
	)

inlinestatic

Convenient wrapper for Value<T>::read.

template<typename U >

static void luwra::registerUserType	(	State *	state,
		const MemberMap &	methods = `MemberMap()`,
		const MemberMap &	meta_methods = `MemberMap()`
	)

inlinestatic

Register the metatable for user type T. This function allows you to register methods which are shared across all instances of this type.

By default a garbage-collector hook and string representation function are added as meta methods. Both can be overwritten.

Template Parameters

U	User type struct or class

Parameters

state	Lua state
methods	Map of methods
meta_methods	Map of meta methods

template<typename S >

static void luwra::registerUserType	(	State *	state,
		const char *	ctor_name,
		const MemberMap &	methods = `MemberMap()`,
		const MemberMap &	meta_methods = `MemberMap()`
	)

inlinestatic

Same as the other registerUserType but registers the constructor as well. The template parameter is a signature U(A...) where U is the user type and A... its constructor parameters.

template<typename... R>

static void luwra::setFields	(	State *	state,
		int	index,
		R &&...	args
	)

inlinestatic

Set multiple fields at once. Allows you to provide multiple key-value pairs.

Parameters

state	Lua state
index	Table index
args	Key-value pairs

static void luwra::setFields	(	State *	state,
		int	index,
		const MemberMap &	fields
	)

inlinestatic

Apply key-value pairs to a table.

Parameters

state	Lua state
index	Table index
fields	Table fields

template<typename V >

static void luwra::setGlobal	(	State *	state,
		const char *	name,
		V &&	value
	)

inlinestatic

Register a value as a global.

Parameters

state	Lua state
name	Global name
value	Global value

static void luwra::setMetatable	(	State *	state,
		const char *	name
	)

inlinestatic

Set a registered metatable for the value on top of the stack.

Parameters

state	Lua state
name	Metatable name

Classes

Typedefs

Functions

Typedef Documentation

Function Documentation