263 lines
6.7 KiB
C++
263 lines
6.7 KiB
C++
#ifndef _library__lua_params__hpp__included__
|
|
#define _library__lua_params__hpp__included__
|
|
|
|
#include "lua-base.hpp"
|
|
#include "lua-framebuffer.hpp"
|
|
#include "lua-function.hpp"
|
|
|
|
namespace lua
|
|
{
|
|
struct function_parameter_tag
|
|
{
|
|
function_parameter_tag(int& _idx) : idx(_idx) {}
|
|
int& idx;
|
|
};
|
|
|
|
struct table_parameter_tag
|
|
{
|
|
table_parameter_tag(int& _idx) : idx(_idx) {}
|
|
int& idx;
|
|
};
|
|
|
|
template<typename T, typename U> struct optional_parameter_tag
|
|
{
|
|
optional_parameter_tag(T& _target, U _dflt) : target(_target), dflt(_dflt) {}
|
|
T& target;
|
|
U dflt;
|
|
};
|
|
|
|
struct skipped_parameter_tag
|
|
{
|
|
};
|
|
|
|
template<typename T> static void arg_helper(state& L, T& x, int idx, const std::string& fname)
|
|
{
|
|
x = L.get_numeric_argument<T>(idx, fname);
|
|
}
|
|
|
|
template<> void arg_helper(state& L, bool& x, int idx, const std::string& fname)
|
|
{
|
|
x = L.get_bool(idx, fname);
|
|
}
|
|
|
|
template<> void arg_helper(state& L, std::string& x, int idx, const std::string& fname)
|
|
{
|
|
x = L.get_string(idx, fname);
|
|
}
|
|
|
|
template<typename T> void arg_helper(state& L, T*& x, int idx, const std::string& fname)
|
|
{
|
|
x = _class<T>::get(L, idx, fname);
|
|
}
|
|
|
|
template<typename T> void arg_helper(state& L, lua::objpin<T>& x, int idx, const std::string& fname)
|
|
{
|
|
x = _class<T>::pin(L, idx, fname);
|
|
}
|
|
|
|
template<> void arg_helper(state& L, framebuffer::color& x, int idx, const std::string& fname)
|
|
{
|
|
x = lua_get_fb_color(L, idx, fname);
|
|
}
|
|
|
|
template<> void arg_helper(state& L, skipped_parameter_tag& x, int idx, const std::string& fname)
|
|
{
|
|
delete &x;
|
|
}
|
|
|
|
template<> void arg_helper(state& L, function_parameter_tag& x, int idx, const std::string& fname)
|
|
{
|
|
if(L.type(idx) != LUA_TFUNCTION)
|
|
(stringfmt() << "Expected function as argument #" << idx << " to " << fname).throwex();
|
|
x.idx = idx;
|
|
delete &x;
|
|
}
|
|
|
|
template<> void arg_helper(state& L, table_parameter_tag& x, int idx, const std::string& fname)
|
|
{
|
|
if(L.type(idx) != LUA_TTABLE)
|
|
(stringfmt() << "Expected table as argument #" << idx << " to " << fname).throwex();
|
|
x.idx = idx;
|
|
delete &x;
|
|
}
|
|
|
|
template<typename T, typename U> void arg_helper(state& L, optional_parameter_tag<T, U>& x, int idx,
|
|
const std::string& fname)
|
|
{
|
|
x.target = x.dflt;
|
|
L.get_numeric_argument<T>(idx, x.target, fname);
|
|
delete &x;
|
|
}
|
|
|
|
template<typename U> void arg_helper(state& L, optional_parameter_tag<bool, U>& x, int idx, const std::string& fname)
|
|
{
|
|
x.target = (L.type(idx) == LUA_TNIL || L.type(idx) == LUA_TNONE) ? x.dflt : L.get_bool(idx, fname);
|
|
delete &x;
|
|
}
|
|
|
|
template<typename U> void arg_helper(state& L, optional_parameter_tag<std::string, U>& x, int idx,
|
|
const std::string& fname)
|
|
{
|
|
x.target = (L.type(idx) == LUA_TNIL || L.type(idx) == LUA_TNONE) ? x.dflt : L.get_string(idx, fname);
|
|
delete &x;
|
|
}
|
|
|
|
template<typename U> void arg_helper(state& L, optional_parameter_tag<framebuffer::color, U>& x, int idx,
|
|
const std::string& fname)
|
|
{
|
|
x.target = lua_get_fb_color(L, idx, fname, x.dflt);
|
|
delete &x;
|
|
}
|
|
|
|
template<typename T, typename U> void arg_helper(state& L, optional_parameter_tag<T*, U>& x, int idx,
|
|
const std::string& fname)
|
|
{
|
|
x.target = _class<T>::get(L, idx, fname, true);
|
|
delete &x;
|
|
}
|
|
|
|
/**
|
|
* Parameters for Lua function.
|
|
*/
|
|
class parameters
|
|
{
|
|
public:
|
|
/**
|
|
* Make
|
|
*/
|
|
parameters(state& _L, const std::string& _fname)
|
|
: L(_L), fname(_fname), next(1)
|
|
{
|
|
}
|
|
/**
|
|
* Read mandatory argument.
|
|
*
|
|
* Parameter i: Index to read. If 0, read next and advance pointer.
|
|
* Returns: The read value.
|
|
*
|
|
* Notes: The following types can be read:
|
|
* - Numeric types.
|
|
* - Pointers to lua classes.
|
|
* - Pins of lua classes.
|
|
*/
|
|
template<typename T> T arg(int i = 0)
|
|
{
|
|
T tmp;
|
|
arg_helper(L, tmp, i ? i : next, fname);
|
|
if(!i) next++;
|
|
return tmp;
|
|
}
|
|
/**
|
|
* Read optional argument.
|
|
*
|
|
* Parameter d: The default value.
|
|
* Parameter i: Index to read. If 0, read next and advance pointer.
|
|
* Returns: The read value.
|
|
*
|
|
* Notes: The following types can be read:
|
|
* - Numeric types.
|
|
* - Pointers to lua classes (d is ignored, assumed NULL).
|
|
*/
|
|
template<typename T> T arg_opt(T d, int i = 0)
|
|
{
|
|
T tmp;
|
|
arg_helper(L, optional<T>(tmp, d), i ? i : next, fname);
|
|
if(!i) next++;
|
|
return tmp;
|
|
}
|
|
/**
|
|
* Is of specified class?
|
|
*
|
|
* Parameter i: Index to read. If 0, read next.
|
|
* Returns: True if it is, false if is is not.
|
|
*/
|
|
template<typename T> bool is(int i = 0)
|
|
{
|
|
return _class<T>::is(L, i ? i : next);
|
|
}
|
|
/**
|
|
* Skip argument and return index.
|
|
*
|
|
* Returns: The index.
|
|
*/
|
|
int skip() { return next++; }
|
|
/**
|
|
* Reset sequence.
|
|
*/
|
|
void reset(int idx = 1) { next = idx; }
|
|
/**
|
|
* Get name.
|
|
*/
|
|
const std::string& get_fname() { return fname; }
|
|
/**
|
|
* More arguments remain?
|
|
*/
|
|
bool more() { return (L.type(next) != LUA_TNONE); }
|
|
/**
|
|
* Is of lua type?
|
|
*/
|
|
bool is_novalue(int i = 0) { int t = L.type(i ? i : next); return (t == LUA_TNONE || t == LUA_TNIL); }
|
|
bool is_none(int i = 0) { int t = L.type(i ? i : next); return (t == LUA_TNONE); }
|
|
bool is_nil(int i = 0) { int t = L.type(i ? i : next); return (t == LUA_TNIL); }
|
|
bool is_boolean(int i = 0) { int t = L.type(i ? i : next); return (t == LUA_TBOOLEAN); }
|
|
bool is_number(int i = 0) { int t = L.type(i ? i : next); return (t == LUA_TNUMBER); }
|
|
bool is_string(int i = 0) { int t = L.type(i ? i : next); return (t == LUA_TSTRING); }
|
|
bool is_thread(int i = 0) { int t = L.type(i ? i : next); return (t == LUA_TTHREAD); }
|
|
bool is_table(int i = 0) { int t = L.type(i ? i : next); return (t == LUA_TTABLE); }
|
|
bool is_function(int i = 0) { int t = L.type(i ? i : next); return (t == LUA_TFUNCTION); }
|
|
bool is_lightuserdata(int i = 0) { int t = L.type(i ? i : next); return (t == LUA_TLIGHTUSERDATA); }
|
|
bool is_userdata(int i = 0) { int t = L.type(i ? i : next); return (t == LUA_TUSERDATA); }
|
|
/**
|
|
* Throw an error.
|
|
*/
|
|
void expected(const std::string& what, int i = 0)
|
|
{
|
|
(stringfmt() << "Expected " << what << " as argument #" << (i ? i : next) << " of "
|
|
<< fname).throwex();
|
|
}
|
|
/**
|
|
* Read multiple at once.
|
|
*/
|
|
template<typename T, typename... U> void operator()(T& x, U&... args)
|
|
{
|
|
arg_helper(L, x, next, fname);
|
|
next++;
|
|
(*this)(args...);
|
|
}
|
|
void operator()()
|
|
{
|
|
}
|
|
/**
|
|
* Optional tag.
|
|
*/
|
|
template<typename T, typename U> optional_parameter_tag<T, U>& optional(T& value, U dflt)
|
|
{
|
|
return *new optional_parameter_tag<T, U>(value, dflt);
|
|
}
|
|
/**
|
|
* Optional tag, reference default value.
|
|
*/
|
|
template<typename T, typename U> optional_parameter_tag<T, const U&>& optional2(T& value, const U& dflt)
|
|
{
|
|
return *new optional_parameter_tag<T, const U&>(value, dflt);
|
|
}
|
|
/**
|
|
* Skipped tag.
|
|
*/
|
|
skipped_parameter_tag& skipped() { return *new skipped_parameter_tag(); }
|
|
/**
|
|
* Function tag.
|
|
*/
|
|
function_parameter_tag& function(int& fnidx) { return *new function_parameter_tag(fnidx); }
|
|
/**
|
|
* Table tag.
|
|
*/
|
|
table_parameter_tag& table(int& fnidx) { return *new table_parameter_tag(fnidx); }
|
|
private:
|
|
state& L;
|
|
std::string fname;
|
|
int next;
|
|
};
|
|
}
|
|
|
|
#endif
|