include/library/lua-params.hpp

   1 #ifndef _library__lua_params__hpp__included__
   2 #define _library__lua_params__hpp__included__
   3
   4 #include "lua-base.hpp"
   5 #include "lua-framebuffer.hpp"
   6 #include "lua-class.hpp"
   7
   8 namespace lua
   9 {
  10 struct function_parameter_tag
  11 {
  12         function_parameter_tag(int& _idx) : idx(_idx) {}
  13         int& idx;
  14 };
  15
  16 struct table_parameter_tag
  17 {
  18         table_parameter_tag(int& _idx) : idx(_idx) {}
  19         int& idx;
  20 };
  21
  22 template<typename T, typename U> struct optional_parameter_tag
  23 {
  24         optional_parameter_tag(T& _target, U _dflt) : target(_target), dflt(_dflt) {}
  25         T& target;
  26         U dflt;
  27 };
  28
  29 struct skipped_parameter_tag
  30 {
  31 };
  32
  33 template<typename T> static void arg_helper(state& L, T& x, int idx, const std::string& fname)
  34 {
  35         x = L.get_numeric_argument<T>(idx, fname);
  36 }
  37
  38 template<> void arg_helper(state& L, bool& x, int idx, const std::string& fname)
  39 {
  40         x = L.get_bool(idx, fname);
  41 }
  42
  43 template<> void arg_helper(state& L, std::string& x, int idx, const std::string& fname)
  44 {
  45         x = L.get_string(idx, fname);
  46 }
  47
  48 template<typename T> void arg_helper(state& L, T*& x, int idx, const std::string& fname)
  49 {
  50         x = _class<T>::get(L, idx, fname);
  51 }
  52
  53 template<typename T> void arg_helper(state& L, lua::objpin<T>& x, int idx, const std::string& fname)
  54 {
  55         x = _class<T>::pin(L, idx, fname);
  56 }
  57
  58 template<> void arg_helper(state& L, framebuffer::color& x, int idx, const std::string& fname)
  59 {
  60         x = get_fb_color(L, idx, fname);
  61 }
  62
  63 template<> void arg_helper(state& L, skipped_parameter_tag& x, int idx, const std::string& fname)
  64 {
  65         delete &x;
  66 }
  67
  68 template<> void arg_helper(state& L, function_parameter_tag& x, int idx, const std::string& fname)
  69 {
  70         if(L.type(idx) != LUA_TFUNCTION)
  71                 (stringfmt() << "Expected function as argument #" << idx << " to " << fname).throwex();
  72         x.idx = idx;
  73         delete &x;
  74 }
  75
  76 template<> void arg_helper(state& L, table_parameter_tag& x, int idx, const std::string& fname)
  77 {
  78         if(L.type(idx) != LUA_TTABLE)
  79                 (stringfmt() << "Expected table as argument #" << idx << " to " << fname).throwex();
  80         x.idx = idx;
  81         delete &x;
  82 }
  83
  84 template<typename T, typename U> void arg_helper(state& L, optional_parameter_tag<T, U>& x, int idx,
  85         const std::string& fname)
  86 {
  87         x.target = x.dflt;
  88         L.get_numeric_argument<T>(idx, x.target, fname);
  89         delete &x;
  90 }
  91
  92 template<typename U> void arg_helper(state& L, optional_parameter_tag<bool, U>& x, int idx, const std::string& fname)
  93 {
  94         x.target = (L.type(idx) == LUA_TNIL || L.type(idx) == LUA_TNONE) ? x.dflt : L.get_bool(idx, fname);
  95         delete &x;
  96 }
  97
  98 template<typename U> void arg_helper(state& L, optional_parameter_tag<std::string, U>& x, int idx,
  99         const std::string& fname)
 100 {
 101         x.target = (L.type(idx) == LUA_TNIL || L.type(idx) == LUA_TNONE) ? x.dflt : L.get_string(idx, fname);
 102         delete &x;
 103 }
 104
 105 template<typename U> void arg_helper(state& L, optional_parameter_tag<framebuffer::color, U>& x, int idx,
 106         const std::string& fname)
 107 {
 108         x.target = get_fb_color(L, idx, fname, x.dflt);
 109         delete &x;
 110 }
 111
 112 template<typename T, typename U> void arg_helper(state& L, optional_parameter_tag<T*, U>& x, int idx,
 113         const std::string& fname)
 114 {
 115         x.target = _class<T>::get(L, idx, fname, true);
 116         delete &x;
 117 }
 118
 119 /**
 120  * Parameters for Lua function.
 121  */
 122 class parameters
 123 {
 124 public:
 125 /**
 126  * Make
 127  */
 128         parameters(state& _L, const std::string& _fname)
 129                 : L(_L), fname(_fname), next(1)
 130         {
 131         }
 132 /**
 133  * Read mandatory argument.
 134  *
 135  * Parameter i: Index to read. If 0, read next and advance pointer.
 136  * Returns: The read value.
 137  *
 138  * Notes: The following types can be read:
 139  * - Numeric types.
 140  * - Pointers to lua classes.
 141  * - Pins of lua classes.
 142  */
 143         template<typename T> T arg(int i = 0)
 144         {
 145                 T tmp;
 146                 arg_helper(L, tmp, i ? i : next, fname);
 147                 if(!i) next++;
 148                 return tmp;
 149         }
 150 /**
 151  * Read optional argument.
 152  *
 153  * Parameter d: The default value.
 154  * Parameter i: Index to read. If 0, read next and advance pointer.
 155  * Returns: The read value.
 156  *
 157  * Notes: The following types can be read:
 158  * - Numeric types.
 159  * - Pointers to lua classes (d is ignored, assumed NULL).
 160  */
 161         template<typename T> T arg_opt(T d, int i = 0)
 162         {
 163                 T tmp;
 164                 arg_helper(L, optional<T>(tmp, d), i ? i : next, fname);
 165                 if(!i) next++;
 166                 return tmp;
 167         }
 168 /**
 169  * Is of specified class?
 170  *
 171  * Parameter i: Index to read. If 0, read next.
 172  * Returns: True if it is, false if is is not.
 173  */
 174         template<typename T> bool is(int i = 0)
 175         {
 176                 return _class<T>::is(L, i ? i : next);
 177         }
 178 /**
 179  * Skip argument and return index.
 180  *
 181  * Returns: The index.
 182  */
 183         int skip() { return next++; }
 184 /**
 185  * Reset sequence.
 186  */
 187         void reset(int idx = 1) { next = idx; }
 188 /**
 189  * Get name.
 190  */
 191         const std::string& get_fname() { return fname; }
 192 /**
 193  * More arguments remain?
 194  */
 195         bool more() { return (L.type(next) != LUA_TNONE); }
 196 /**
 197  * Is of lua type?
 198  */
 199         bool is_novalue(int i = 0) { int t = L.type(i ? i : next); return (t == LUA_TNONE || t == LUA_TNIL); }
 200         bool is_none(int i = 0) { int t = L.type(i ? i : next); return (t == LUA_TNONE); }
 201         bool is_nil(int i = 0) { int t = L.type(i ? i : next); return (t == LUA_TNIL); }
 202         bool is_boolean(int i = 0) { int t = L.type(i ? i : next); return (t == LUA_TBOOLEAN); }
 203         bool is_number(int i = 0) { int t = L.type(i ? i : next); return (t == LUA_TNUMBER); }
 204         bool is_string(int i = 0) { int t = L.type(i ? i : next); return (t == LUA_TSTRING); }
 205         bool is_thread(int i = 0) { int t = L.type(i ? i : next); return (t == LUA_TTHREAD); }
 206         bool is_table(int i = 0) { int t = L.type(i ? i : next); return (t == LUA_TTABLE); }
 207         bool is_function(int i = 0) { int t = L.type(i ? i : next); return (t == LUA_TFUNCTION); }
 208         bool is_lightuserdata(int i = 0) { int t = L.type(i ? i : next); return (t == LUA_TLIGHTUSERDATA); }
 209         bool is_userdata(int i = 0) { int t = L.type(i ? i : next); return (t == LUA_TUSERDATA); }
 210 /**
 211  * Throw an error.
 212  */
 213         void expected(const std::string& what, int i = 0)
 214         {
 215                 (stringfmt() << "Expected " << what << " as argument #" << (i ? i : next) << " of "
 216                         << fname).throwex();
 217         }
 218 /**
 219  * Read multiple at once.
 220  */
 221         template<typename T, typename... U> void operator()(T& x, U&... args)
 222         {
 223                 arg_helper(L, x, next, fname);
 224                 next++;
 225                 (*this)(args...);
 226         }
 227         void operator()()
 228         {
 229         }
 230 /**
 231  * Optional tag.
 232  */
 233         template<typename T, typename U> optional_parameter_tag<T, U>& optional(T& value, U dflt)
 234         {
 235                 return *new optional_parameter_tag<T, U>(value, dflt);
 236         }
 237 /**
 238  * Optional tag, reference default value.
 239  */
 240         template<typename T, typename U> optional_parameter_tag<T, const U&>& optional2(T& value, const U& dflt)
 241         {
 242                 return *new optional_parameter_tag<T, const U&>(value, dflt);
 243         }
 244 /**
 245  * Skipped tag.
 246  */
 247         skipped_parameter_tag& skipped() { return *new skipped_parameter_tag(); }
 248 /**
 249  * Function tag.
 250  */
 251         function_parameter_tag& function(int& fnidx) { return *new function_parameter_tag(fnidx); }
 252 /**
 253  * Table tag.
 254  */
 255         table_parameter_tag& table(int& fnidx) { return *new table_parameter_tag(fnidx); }
 256 /**
 257  * Get Lua state.
 258  */
 259         state& get_state() { return L; }
 260 private:
 261         state& L;
 262         std::string fname;
 263         int next;
 264 };
 265 }
 266
 267 #endif