Fawkes API  Fawkes Development Version
fawkesutils_tolua.cpp
00001 /*
00002 ** Lua binding: fawkesutils
00003 ** Generated automatically by tolua++-1.0.92
00004 */
00005 /*  This program is free software; you can redistribute it and/or modify
00006  *  it under the terms of the GNU General Public License as published by
00007  *  the Free Software Foundation; either version 2 of the License, or
00008  *  (at your option) any later version. A runtime exception applies to
00009  *  this software (see LICENSE.GPL_WRE file mentioned below for details).
00010  *
00011  *  This program is distributed in the hope that it will be useful,
00012  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
00013  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00014  *  GNU Library General Public License for more details.
00015  *
00016  *  Read the full text in the LICENSE.GPL_WRE file in the doc directory.
00017  */
00018 
00019 #ifndef __cplusplus
00020 #include "stdlib.h"
00021 #endif
00022 #include "string.h"
00023 
00024 #include "tolua++.h"
00025 
00026 /* Exported function */
00027 TOLUA_API int  tolua_fawkesutils_open (lua_State* tolua_S);
00028 
00029 #include <utils/graph/rcsoft_map_node.h>
00030 #include <string>
00031 #include <vector>
00032 using namespace std;
00033 #include <utils/graph/rcsoft_map_node.h>
00034 #include <utils/graph/rcsoft_map_graph.h>
00035 #include <vector>
00036 #include <string>
00037 using namespace std;
00038 using namespace fawkes;
00039 #include <utils/kalman/kalman_1d.h>
00040 #include <utils/time/time.h>
00041 #include <utils/time/clock.h>
00042 
00043 /* function to release collected object via destructor */
00044 #ifdef __cplusplus
00045 
00046 static int tolua_collect_fawkes__KalmanFilter1D (lua_State* tolua_S)
00047 {
00048  fawkes::KalmanFilter1D* self = (fawkes::KalmanFilter1D*) tolua_tousertype(tolua_S,1,0);
00049         Mtolua_delete(self);
00050         return 0;
00051 }
00052 
00053 static int tolua_collect_vector_string_ (lua_State* tolua_S)
00054 {
00055  vector<string>* self = (vector<string>*) tolua_tousertype(tolua_S,1,0);
00056         Mtolua_delete(self);
00057         return 0;
00058 }
00059 
00060 static int tolua_collect_fawkes__RCSoftMapNode (lua_State* tolua_S)
00061 {
00062  fawkes::RCSoftMapNode* self = (fawkes::RCSoftMapNode*) tolua_tousertype(tolua_S,1,0);
00063         Mtolua_delete(self);
00064         return 0;
00065 }
00066 
00067 static int tolua_collect_fawkes__RCSoftMapGraph (lua_State* tolua_S)
00068 {
00069  fawkes::RCSoftMapGraph* self = (fawkes::RCSoftMapGraph*) tolua_tousertype(tolua_S,1,0);
00070         Mtolua_delete(self);
00071         return 0;
00072 }
00073 
00074 static int tolua_collect_fawkes__Time (lua_State* tolua_S)
00075 {
00076  fawkes::Time* self = (fawkes::Time*) tolua_tousertype(tolua_S,1,0);
00077         Mtolua_delete(self);
00078         return 0;
00079 }
00080 
00081 static int tolua_collect_vector_fawkes__RCSoftMapNode_ (lua_State* tolua_S)
00082 {
00083  vector<fawkes::RCSoftMapNode>* self = (vector<fawkes::RCSoftMapNode>*) tolua_tousertype(tolua_S,1,0);
00084         Mtolua_delete(self);
00085         return 0;
00086 }
00087 #endif
00088 
00089 
00090 /* function to register type */
00091 static void tolua_reg_types (lua_State* tolua_S)
00092 {
00093  tolua_usertype(tolua_S,"fawkes::KalmanFilter1D");
00094  tolua_usertype(tolua_S,"timeval");
00095  tolua_usertype(tolua_S,"vector<string>");
00096  tolua_usertype(tolua_S,"fawkes::Clock");
00097  tolua_usertype(tolua_S,"fawkes::RCSoftMapNode");
00098  tolua_usertype(tolua_S,"fawkes::RCSoftMapGraph");
00099  tolua_usertype(tolua_S,"fawkes::Time");
00100  tolua_usertype(tolua_S,"vector<fawkes::RCSoftMapNode>");
00101 }
00102 
00103 /* method: clear of class  vector<string> */
00104 #ifndef TOLUA_DISABLE_tolua_fawkesutils_vector_string__clear00
00105 static int tolua_fawkesutils_vector_string__clear00(lua_State* tolua_S)
00106 {
00107 #ifndef TOLUA_RELEASE
00108  tolua_Error tolua_err;
00109  if (
00110      !tolua_isusertype(tolua_S,1,"vector<string>",0,&tolua_err) ||
00111      !tolua_isnoobj(tolua_S,2,&tolua_err)
00112  )
00113   goto tolua_lerror;
00114  else
00115 #endif
00116  {
00117   vector<string>* self = (vector<string>*)  tolua_tousertype(tolua_S,1,0);
00118 #ifndef TOLUA_RELEASE
00119   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'clear'", NULL);
00120 #endif
00121   {
00122    self->clear();
00123   }
00124  }
00125  return 0;
00126 #ifndef TOLUA_RELEASE
00127  tolua_lerror:
00128  tolua_error(tolua_S,"#ferror in function 'clear'.",&tolua_err);
00129  return 0;
00130 #endif
00131 }
00132 #endif //#ifndef TOLUA_DISABLE
00133 
00134 /* method: size of class  vector<string> */
00135 #ifndef TOLUA_DISABLE_tolua_fawkesutils_vector_string__size00
00136 static int tolua_fawkesutils_vector_string__size00(lua_State* tolua_S)
00137 {
00138 #ifndef TOLUA_RELEASE
00139  tolua_Error tolua_err;
00140  if (
00141      !tolua_isusertype(tolua_S,1,"const vector<string>",0,&tolua_err) ||
00142      !tolua_isnoobj(tolua_S,2,&tolua_err)
00143  )
00144   goto tolua_lerror;
00145  else
00146 #endif
00147  {
00148   const vector<string>* self = (const vector<string>*)  tolua_tousertype(tolua_S,1,0);
00149 #ifndef TOLUA_RELEASE
00150   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'size'", NULL);
00151 #endif
00152   {
00153    int tolua_ret = (int)  self->size();
00154    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00155   }
00156  }
00157  return 1;
00158 #ifndef TOLUA_RELEASE
00159  tolua_lerror:
00160  tolua_error(tolua_S,"#ferror in function 'size'.",&tolua_err);
00161  return 0;
00162 #endif
00163 }
00164 #endif //#ifndef TOLUA_DISABLE
00165 
00166 /* method: operator[] of class  vector<string> */
00167 #ifndef TOLUA_DISABLE_tolua_fawkesutils_vector_string___geti00
00168 static int tolua_fawkesutils_vector_string___geti00(lua_State* tolua_S)
00169 {
00170 #ifndef TOLUA_RELEASE
00171  tolua_Error tolua_err;
00172  if (
00173      !tolua_isusertype(tolua_S,1,"const vector<string>",0,&tolua_err) ||
00174      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00175      !tolua_isnoobj(tolua_S,3,&tolua_err)
00176  )
00177   goto tolua_lerror;
00178  else
00179 #endif
00180  {
00181   const vector<string>* self = (const vector<string>*)  tolua_tousertype(tolua_S,1,0);
00182   int index = ((int)  tolua_tonumber(tolua_S,2,0));
00183 #ifndef TOLUA_RELEASE
00184   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'", NULL);
00185 #endif
00186   {
00187    const string tolua_ret = (const string)  self->operator[](index);
00188    tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
00189   }
00190  }
00191  return 1;
00192 #ifndef TOLUA_RELEASE
00193  tolua_lerror:
00194  tolua_error(tolua_S,"#ferror in function '.geti'.",&tolua_err);
00195  return 0;
00196 #endif
00197 }
00198 #endif //#ifndef TOLUA_DISABLE
00199 
00200 /* method: operator&[] of class  vector<string> */
00201 #ifndef TOLUA_DISABLE_tolua_fawkesutils_vector_string___seti00
00202 static int tolua_fawkesutils_vector_string___seti00(lua_State* tolua_S)
00203 {
00204 #ifndef TOLUA_RELEASE
00205  tolua_Error tolua_err;
00206  if (
00207      !tolua_isusertype(tolua_S,1,"vector<string>",0,&tolua_err) ||
00208      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00209      !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
00210      !tolua_isnoobj(tolua_S,4,&tolua_err)
00211  )
00212   goto tolua_lerror;
00213  else
00214 #endif
00215  {
00216   vector<string>* self = (vector<string>*)  tolua_tousertype(tolua_S,1,0);
00217   int index = ((int)  tolua_tonumber(tolua_S,2,0));
00218   string tolua_value = ((string)  tolua_tocppstring(tolua_S,3,0));
00219 #ifndef TOLUA_RELEASE
00220   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator&[]'", NULL);
00221 #endif
00222   self->operator[](index) =  tolua_value;
00223  }
00224  return 0;
00225 #ifndef TOLUA_RELEASE
00226  tolua_lerror:
00227  tolua_error(tolua_S,"#ferror in function '.seti'.",&tolua_err);
00228  return 0;
00229 #endif
00230 }
00231 #endif //#ifndef TOLUA_DISABLE
00232 
00233 /* method: operator[] of class  vector<string> */
00234 #ifndef TOLUA_DISABLE_tolua_fawkesutils_vector_string___geti01
00235 static int tolua_fawkesutils_vector_string___geti01(lua_State* tolua_S)
00236 {
00237  tolua_Error tolua_err;
00238  if (
00239      !tolua_isusertype(tolua_S,1,"vector<string>",0,&tolua_err) ||
00240      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00241      !tolua_isnoobj(tolua_S,3,&tolua_err)
00242  )
00243   goto tolua_lerror;
00244  else
00245  {
00246   vector<string>* self = (vector<string>*)  tolua_tousertype(tolua_S,1,0);
00247   int index = ((int)  tolua_tonumber(tolua_S,2,0));
00248 #ifndef TOLUA_RELEASE
00249   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'", NULL);
00250 #endif
00251   {
00252    string tolua_ret = (string)  self->operator[](index);
00253    tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
00254   }
00255  }
00256  return 1;
00257 tolua_lerror:
00258  return tolua_fawkesutils_vector_string___geti00(tolua_S);
00259 }
00260 #endif //#ifndef TOLUA_DISABLE
00261 
00262 /* method: push_back of class  vector<string> */
00263 #ifndef TOLUA_DISABLE_tolua_fawkesutils_vector_string__push_back00
00264 static int tolua_fawkesutils_vector_string__push_back00(lua_State* tolua_S)
00265 {
00266 #ifndef TOLUA_RELEASE
00267  tolua_Error tolua_err;
00268  if (
00269      !tolua_isusertype(tolua_S,1,"vector<string>",0,&tolua_err) ||
00270      !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
00271      !tolua_isnoobj(tolua_S,3,&tolua_err)
00272  )
00273   goto tolua_lerror;
00274  else
00275 #endif
00276  {
00277   vector<string>* self = (vector<string>*)  tolua_tousertype(tolua_S,1,0);
00278   string val = ((string)  tolua_tocppstring(tolua_S,2,0));
00279 #ifndef TOLUA_RELEASE
00280   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'push_back'", NULL);
00281 #endif
00282   {
00283    self->push_back(val);
00284   }
00285  }
00286  return 0;
00287 #ifndef TOLUA_RELEASE
00288  tolua_lerror:
00289  tolua_error(tolua_S,"#ferror in function 'push_back'.",&tolua_err);
00290  return 0;
00291 #endif
00292 }
00293 #endif //#ifndef TOLUA_DISABLE
00294 
00295 /* method: new of class  vector<string> */
00296 #ifndef TOLUA_DISABLE_tolua_fawkesutils_vector_string__new00
00297 static int tolua_fawkesutils_vector_string__new00(lua_State* tolua_S)
00298 {
00299 #ifndef TOLUA_RELEASE
00300  tolua_Error tolua_err;
00301  if (
00302      !tolua_isusertable(tolua_S,1,"vector<string>",0,&tolua_err) ||
00303      !tolua_isnoobj(tolua_S,2,&tolua_err)
00304  )
00305   goto tolua_lerror;
00306  else
00307 #endif
00308  {
00309   {
00310    vector<string>* tolua_ret = (vector<string>*)  Mtolua_new((vector<string>)());
00311     tolua_pushusertype(tolua_S,(void*)tolua_ret,"vector<string>");
00312   }
00313  }
00314  return 1;
00315 #ifndef TOLUA_RELEASE
00316  tolua_lerror:
00317  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00318  return 0;
00319 #endif
00320 }
00321 #endif //#ifndef TOLUA_DISABLE
00322 
00323 /* method: new_local of class  vector<string> */
00324 #ifndef TOLUA_DISABLE_tolua_fawkesutils_vector_string__new00_local
00325 static int tolua_fawkesutils_vector_string__new00_local(lua_State* tolua_S)
00326 {
00327 #ifndef TOLUA_RELEASE
00328  tolua_Error tolua_err;
00329  if (
00330      !tolua_isusertable(tolua_S,1,"vector<string>",0,&tolua_err) ||
00331      !tolua_isnoobj(tolua_S,2,&tolua_err)
00332  )
00333   goto tolua_lerror;
00334  else
00335 #endif
00336  {
00337   {
00338    vector<string>* tolua_ret = (vector<string>*)  Mtolua_new((vector<string>)());
00339     tolua_pushusertype(tolua_S,(void*)tolua_ret,"vector<string>");
00340     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00341   }
00342  }
00343  return 1;
00344 #ifndef TOLUA_RELEASE
00345  tolua_lerror:
00346  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00347  return 0;
00348 #endif
00349 }
00350 #endif //#ifndef TOLUA_DISABLE
00351 
00352 /* method: delete of class  vector<string> */
00353 #ifndef TOLUA_DISABLE_tolua_fawkesutils_vector_string__delete00
00354 static int tolua_fawkesutils_vector_string__delete00(lua_State* tolua_S)
00355 {
00356 #ifndef TOLUA_RELEASE
00357  tolua_Error tolua_err;
00358  if (
00359      !tolua_isusertype(tolua_S,1,"vector<string>",0,&tolua_err) ||
00360      !tolua_isnoobj(tolua_S,2,&tolua_err)
00361  )
00362   goto tolua_lerror;
00363  else
00364 #endif
00365  {
00366   vector<string>* self = (vector<string>*)  tolua_tousertype(tolua_S,1,0);
00367 #ifndef TOLUA_RELEASE
00368   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
00369 #endif
00370   Mtolua_delete(self);
00371  }
00372  return 0;
00373 #ifndef TOLUA_RELEASE
00374  tolua_lerror:
00375  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
00376  return 0;
00377 #endif
00378 }
00379 #endif //#ifndef TOLUA_DISABLE
00380 
00381 /* method: clear of class  vector<fawkes::RCSoftMapNode> */
00382 #ifndef TOLUA_DISABLE_tolua_fawkesutils_vector_fawkes__RCSoftMapNode__clear00
00383 static int tolua_fawkesutils_vector_fawkes__RCSoftMapNode__clear00(lua_State* tolua_S)
00384 {
00385 #ifndef TOLUA_RELEASE
00386  tolua_Error tolua_err;
00387  if (
00388      !tolua_isusertype(tolua_S,1,"vector<fawkes::RCSoftMapNode>",0,&tolua_err) ||
00389      !tolua_isnoobj(tolua_S,2,&tolua_err)
00390  )
00391   goto tolua_lerror;
00392  else
00393 #endif
00394  {
00395   vector<fawkes::RCSoftMapNode>* self = (vector<fawkes::RCSoftMapNode>*)  tolua_tousertype(tolua_S,1,0);
00396 #ifndef TOLUA_RELEASE
00397   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'clear'", NULL);
00398 #endif
00399   {
00400    self->clear();
00401   }
00402  }
00403  return 0;
00404 #ifndef TOLUA_RELEASE
00405  tolua_lerror:
00406  tolua_error(tolua_S,"#ferror in function 'clear'.",&tolua_err);
00407  return 0;
00408 #endif
00409 }
00410 #endif //#ifndef TOLUA_DISABLE
00411 
00412 /* method: size of class  vector<fawkes::RCSoftMapNode> */
00413 #ifndef TOLUA_DISABLE_tolua_fawkesutils_vector_fawkes__RCSoftMapNode__size00
00414 static int tolua_fawkesutils_vector_fawkes__RCSoftMapNode__size00(lua_State* tolua_S)
00415 {
00416 #ifndef TOLUA_RELEASE
00417  tolua_Error tolua_err;
00418  if (
00419      !tolua_isusertype(tolua_S,1,"const vector<fawkes::RCSoftMapNode>",0,&tolua_err) ||
00420      !tolua_isnoobj(tolua_S,2,&tolua_err)
00421  )
00422   goto tolua_lerror;
00423  else
00424 #endif
00425  {
00426   const vector<fawkes::RCSoftMapNode>* self = (const vector<fawkes::RCSoftMapNode>*)  tolua_tousertype(tolua_S,1,0);
00427 #ifndef TOLUA_RELEASE
00428   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'size'", NULL);
00429 #endif
00430   {
00431    int tolua_ret = (int)  self->size();
00432    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00433   }
00434  }
00435  return 1;
00436 #ifndef TOLUA_RELEASE
00437  tolua_lerror:
00438  tolua_error(tolua_S,"#ferror in function 'size'.",&tolua_err);
00439  return 0;
00440 #endif
00441 }
00442 #endif //#ifndef TOLUA_DISABLE
00443 
00444 /* method: operator[] of class  vector<fawkes::RCSoftMapNode> */
00445 #ifndef TOLUA_DISABLE_tolua_fawkesutils_vector_fawkes__RCSoftMapNode___geti00
00446 static int tolua_fawkesutils_vector_fawkes__RCSoftMapNode___geti00(lua_State* tolua_S)
00447 {
00448 #ifndef TOLUA_RELEASE
00449  tolua_Error tolua_err;
00450  if (
00451      !tolua_isusertype(tolua_S,1,"const vector<fawkes::RCSoftMapNode>",0,&tolua_err) ||
00452      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00453      !tolua_isnoobj(tolua_S,3,&tolua_err)
00454  )
00455   goto tolua_lerror;
00456  else
00457 #endif
00458  {
00459   const vector<fawkes::RCSoftMapNode>* self = (const vector<fawkes::RCSoftMapNode>*)  tolua_tousertype(tolua_S,1,0);
00460   int index = ((int)  tolua_tonumber(tolua_S,2,0));
00461 #ifndef TOLUA_RELEASE
00462   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'", NULL);
00463 #endif
00464   {
00465    const fawkes::RCSoftMapNode tolua_ret = (const fawkes::RCSoftMapNode)  self->operator[](index);
00466    {
00467 #ifdef __cplusplus
00468     void* tolua_obj = Mtolua_new((fawkes::RCSoftMapNode)(tolua_ret));
00469      tolua_pushusertype(tolua_S,tolua_obj,"const fawkes::RCSoftMapNode");
00470     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00471 #else
00472     void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(const fawkes::RCSoftMapNode));
00473      tolua_pushusertype(tolua_S,tolua_obj,"const fawkes::RCSoftMapNode");
00474     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00475 #endif
00476    }
00477   }
00478  }
00479  return 1;
00480 #ifndef TOLUA_RELEASE
00481  tolua_lerror:
00482  tolua_error(tolua_S,"#ferror in function '.geti'.",&tolua_err);
00483  return 0;
00484 #endif
00485 }
00486 #endif //#ifndef TOLUA_DISABLE
00487 
00488 /* method: operator&[] of class  vector<fawkes::RCSoftMapNode> */
00489 #ifndef TOLUA_DISABLE_tolua_fawkesutils_vector_fawkes__RCSoftMapNode___seti00
00490 static int tolua_fawkesutils_vector_fawkes__RCSoftMapNode___seti00(lua_State* tolua_S)
00491 {
00492 #ifndef TOLUA_RELEASE
00493  tolua_Error tolua_err;
00494  if (
00495      !tolua_isusertype(tolua_S,1,"vector<fawkes::RCSoftMapNode>",0,&tolua_err) ||
00496      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00497      (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"fawkes::RCSoftMapNode",0,&tolua_err)) ||
00498      !tolua_isnoobj(tolua_S,4,&tolua_err)
00499  )
00500   goto tolua_lerror;
00501  else
00502 #endif
00503  {
00504   vector<fawkes::RCSoftMapNode>* self = (vector<fawkes::RCSoftMapNode>*)  tolua_tousertype(tolua_S,1,0);
00505   int index = ((int)  tolua_tonumber(tolua_S,2,0));
00506   fawkes::RCSoftMapNode tolua_value = *((fawkes::RCSoftMapNode*)  tolua_tousertype(tolua_S,3,0));
00507 #ifndef TOLUA_RELEASE
00508   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator&[]'", NULL);
00509 #endif
00510   self->operator[](index) =  tolua_value;
00511  }
00512  return 0;
00513 #ifndef TOLUA_RELEASE
00514  tolua_lerror:
00515  tolua_error(tolua_S,"#ferror in function '.seti'.",&tolua_err);
00516  return 0;
00517 #endif
00518 }
00519 #endif //#ifndef TOLUA_DISABLE
00520 
00521 /* method: operator[] of class  vector<fawkes::RCSoftMapNode> */
00522 #ifndef TOLUA_DISABLE_tolua_fawkesutils_vector_fawkes__RCSoftMapNode___geti01
00523 static int tolua_fawkesutils_vector_fawkes__RCSoftMapNode___geti01(lua_State* tolua_S)
00524 {
00525  tolua_Error tolua_err;
00526  if (
00527      !tolua_isusertype(tolua_S,1,"vector<fawkes::RCSoftMapNode>",0,&tolua_err) ||
00528      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00529      !tolua_isnoobj(tolua_S,3,&tolua_err)
00530  )
00531   goto tolua_lerror;
00532  else
00533  {
00534   vector<fawkes::RCSoftMapNode>* self = (vector<fawkes::RCSoftMapNode>*)  tolua_tousertype(tolua_S,1,0);
00535   int index = ((int)  tolua_tonumber(tolua_S,2,0));
00536 #ifndef TOLUA_RELEASE
00537   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'", NULL);
00538 #endif
00539   {
00540    fawkes::RCSoftMapNode tolua_ret = (fawkes::RCSoftMapNode)  self->operator[](index);
00541    {
00542 #ifdef __cplusplus
00543     void* tolua_obj = Mtolua_new((fawkes::RCSoftMapNode)(tolua_ret));
00544      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::RCSoftMapNode");
00545     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00546 #else
00547     void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::RCSoftMapNode));
00548      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::RCSoftMapNode");
00549     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00550 #endif
00551    }
00552   }
00553  }
00554  return 1;
00555 tolua_lerror:
00556  return tolua_fawkesutils_vector_fawkes__RCSoftMapNode___geti00(tolua_S);
00557 }
00558 #endif //#ifndef TOLUA_DISABLE
00559 
00560 /* method: push_back of class  vector<fawkes::RCSoftMapNode> */
00561 #ifndef TOLUA_DISABLE_tolua_fawkesutils_vector_fawkes__RCSoftMapNode__push_back00
00562 static int tolua_fawkesutils_vector_fawkes__RCSoftMapNode__push_back00(lua_State* tolua_S)
00563 {
00564 #ifndef TOLUA_RELEASE
00565  tolua_Error tolua_err;
00566  if (
00567      !tolua_isusertype(tolua_S,1,"vector<fawkes::RCSoftMapNode>",0,&tolua_err) ||
00568      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"fawkes::RCSoftMapNode",0,&tolua_err)) ||
00569      !tolua_isnoobj(tolua_S,3,&tolua_err)
00570  )
00571   goto tolua_lerror;
00572  else
00573 #endif
00574  {
00575   vector<fawkes::RCSoftMapNode>* self = (vector<fawkes::RCSoftMapNode>*)  tolua_tousertype(tolua_S,1,0);
00576   fawkes::RCSoftMapNode val = *((fawkes::RCSoftMapNode*)  tolua_tousertype(tolua_S,2,0));
00577 #ifndef TOLUA_RELEASE
00578   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'push_back'", NULL);
00579 #endif
00580   {
00581    self->push_back(val);
00582   }
00583  }
00584  return 0;
00585 #ifndef TOLUA_RELEASE
00586  tolua_lerror:
00587  tolua_error(tolua_S,"#ferror in function 'push_back'.",&tolua_err);
00588  return 0;
00589 #endif
00590 }
00591 #endif //#ifndef TOLUA_DISABLE
00592 
00593 /* method: new of class  vector<fawkes::RCSoftMapNode> */
00594 #ifndef TOLUA_DISABLE_tolua_fawkesutils_vector_fawkes__RCSoftMapNode__new00
00595 static int tolua_fawkesutils_vector_fawkes__RCSoftMapNode__new00(lua_State* tolua_S)
00596 {
00597 #ifndef TOLUA_RELEASE
00598  tolua_Error tolua_err;
00599  if (
00600      !tolua_isusertable(tolua_S,1,"vector<fawkes::RCSoftMapNode>",0,&tolua_err) ||
00601      !tolua_isnoobj(tolua_S,2,&tolua_err)
00602  )
00603   goto tolua_lerror;
00604  else
00605 #endif
00606  {
00607   {
00608    vector<fawkes::RCSoftMapNode>* tolua_ret = (vector<fawkes::RCSoftMapNode>*)  Mtolua_new((vector<fawkes::RCSoftMapNode>)());
00609     tolua_pushusertype(tolua_S,(void*)tolua_ret,"vector<fawkes::RCSoftMapNode>");
00610   }
00611  }
00612  return 1;
00613 #ifndef TOLUA_RELEASE
00614  tolua_lerror:
00615  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00616  return 0;
00617 #endif
00618 }
00619 #endif //#ifndef TOLUA_DISABLE
00620 
00621 /* method: new_local of class  vector<fawkes::RCSoftMapNode> */
00622 #ifndef TOLUA_DISABLE_tolua_fawkesutils_vector_fawkes__RCSoftMapNode__new00_local
00623 static int tolua_fawkesutils_vector_fawkes__RCSoftMapNode__new00_local(lua_State* tolua_S)
00624 {
00625 #ifndef TOLUA_RELEASE
00626  tolua_Error tolua_err;
00627  if (
00628      !tolua_isusertable(tolua_S,1,"vector<fawkes::RCSoftMapNode>",0,&tolua_err) ||
00629      !tolua_isnoobj(tolua_S,2,&tolua_err)
00630  )
00631   goto tolua_lerror;
00632  else
00633 #endif
00634  {
00635   {
00636    vector<fawkes::RCSoftMapNode>* tolua_ret = (vector<fawkes::RCSoftMapNode>*)  Mtolua_new((vector<fawkes::RCSoftMapNode>)());
00637     tolua_pushusertype(tolua_S,(void*)tolua_ret,"vector<fawkes::RCSoftMapNode>");
00638     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00639   }
00640  }
00641  return 1;
00642 #ifndef TOLUA_RELEASE
00643  tolua_lerror:
00644  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00645  return 0;
00646 #endif
00647 }
00648 #endif //#ifndef TOLUA_DISABLE
00649 
00650 /* method: delete of class  vector<fawkes::RCSoftMapNode> */
00651 #ifndef TOLUA_DISABLE_tolua_fawkesutils_vector_fawkes__RCSoftMapNode__delete00
00652 static int tolua_fawkesutils_vector_fawkes__RCSoftMapNode__delete00(lua_State* tolua_S)
00653 {
00654 #ifndef TOLUA_RELEASE
00655  tolua_Error tolua_err;
00656  if (
00657      !tolua_isusertype(tolua_S,1,"vector<fawkes::RCSoftMapNode>",0,&tolua_err) ||
00658      !tolua_isnoobj(tolua_S,2,&tolua_err)
00659  )
00660   goto tolua_lerror;
00661  else
00662 #endif
00663  {
00664   vector<fawkes::RCSoftMapNode>* self = (vector<fawkes::RCSoftMapNode>*)  tolua_tousertype(tolua_S,1,0);
00665 #ifndef TOLUA_RELEASE
00666   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
00667 #endif
00668   Mtolua_delete(self);
00669  }
00670  return 0;
00671 #ifndef TOLUA_RELEASE
00672  tolua_lerror:
00673  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
00674  return 0;
00675 #endif
00676 }
00677 #endif //#ifndef TOLUA_DISABLE
00678 
00679 /* method: new of class  fawkes::RCSoftMapNode */
00680 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_RCSoftMapNode_new00
00681 static int tolua_fawkesutils_fawkes_RCSoftMapNode_new00(lua_State* tolua_S)
00682 {
00683 #ifndef TOLUA_RELEASE
00684  tolua_Error tolua_err;
00685  if (
00686      !tolua_isusertable(tolua_S,1,"fawkes::RCSoftMapNode",0,&tolua_err) ||
00687      !tolua_isnoobj(tolua_S,2,&tolua_err)
00688  )
00689   goto tolua_lerror;
00690  else
00691 #endif
00692  {
00693   {
00694    fawkes::RCSoftMapNode* tolua_ret = (fawkes::RCSoftMapNode*)  Mtolua_new((fawkes::RCSoftMapNode)());
00695     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::RCSoftMapNode");
00696   }
00697  }
00698  return 1;
00699 #ifndef TOLUA_RELEASE
00700  tolua_lerror:
00701  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00702  return 0;
00703 #endif
00704 }
00705 #endif //#ifndef TOLUA_DISABLE
00706 
00707 /* method: new_local of class  fawkes::RCSoftMapNode */
00708 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_RCSoftMapNode_new00_local
00709 static int tolua_fawkesutils_fawkes_RCSoftMapNode_new00_local(lua_State* tolua_S)
00710 {
00711 #ifndef TOLUA_RELEASE
00712  tolua_Error tolua_err;
00713  if (
00714      !tolua_isusertable(tolua_S,1,"fawkes::RCSoftMapNode",0,&tolua_err) ||
00715      !tolua_isnoobj(tolua_S,2,&tolua_err)
00716  )
00717   goto tolua_lerror;
00718  else
00719 #endif
00720  {
00721   {
00722    fawkes::RCSoftMapNode* tolua_ret = (fawkes::RCSoftMapNode*)  Mtolua_new((fawkes::RCSoftMapNode)());
00723     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::RCSoftMapNode");
00724     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00725   }
00726  }
00727  return 1;
00728 #ifndef TOLUA_RELEASE
00729  tolua_lerror:
00730  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00731  return 0;
00732 #endif
00733 }
00734 #endif //#ifndef TOLUA_DISABLE
00735 
00736 /* method: new of class  fawkes::RCSoftMapNode */
00737 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_RCSoftMapNode_new01
00738 static int tolua_fawkesutils_fawkes_RCSoftMapNode_new01(lua_State* tolua_S)
00739 {
00740  tolua_Error tolua_err;
00741  if (
00742      !tolua_isusertable(tolua_S,1,"fawkes::RCSoftMapNode",0,&tolua_err) ||
00743      !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
00744      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
00745      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
00746      (tolua_isvaluenil(tolua_S,5,&tolua_err) || !tolua_isusertype(tolua_S,5,"vector<string>",0,&tolua_err)) ||
00747      (tolua_isvaluenil(tolua_S,6,&tolua_err) || !tolua_isusertype(tolua_S,6,"vector<string>",0,&tolua_err)) ||
00748      (tolua_isvaluenil(tolua_S,7,&tolua_err) || !tolua_isusertype(tolua_S,7,"vector<string>",0,&tolua_err)) ||
00749      !tolua_isnoobj(tolua_S,8,&tolua_err)
00750  )
00751   goto tolua_lerror;
00752  else
00753  {
00754   string name = ((string)  tolua_tocppstring(tolua_S,2,0));
00755   double x = ((double)  tolua_tonumber(tolua_S,3,0));
00756   double y = ((double)  tolua_tonumber(tolua_S,4,0));
00757   vector<string> children = *((vector<string>*)  tolua_tousertype(tolua_S,5,0));
00758   vector<string> properties = *((vector<string>*)  tolua_tousertype(tolua_S,6,0));
00759   vector<string> aliases = *((vector<string>*)  tolua_tousertype(tolua_S,7,0));
00760   {
00761    fawkes::RCSoftMapNode* tolua_ret = (fawkes::RCSoftMapNode*)  Mtolua_new((fawkes::RCSoftMapNode)(name,x,y,children,properties,aliases));
00762     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::RCSoftMapNode");
00763   }
00764  }
00765  return 1;
00766 tolua_lerror:
00767  return tolua_fawkesutils_fawkes_RCSoftMapNode_new00(tolua_S);
00768 }
00769 #endif //#ifndef TOLUA_DISABLE
00770 
00771 /* method: new_local of class  fawkes::RCSoftMapNode */
00772 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_RCSoftMapNode_new01_local
00773 static int tolua_fawkesutils_fawkes_RCSoftMapNode_new01_local(lua_State* tolua_S)
00774 {
00775  tolua_Error tolua_err;
00776  if (
00777      !tolua_isusertable(tolua_S,1,"fawkes::RCSoftMapNode",0,&tolua_err) ||
00778      !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
00779      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
00780      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
00781      (tolua_isvaluenil(tolua_S,5,&tolua_err) || !tolua_isusertype(tolua_S,5,"vector<string>",0,&tolua_err)) ||
00782      (tolua_isvaluenil(tolua_S,6,&tolua_err) || !tolua_isusertype(tolua_S,6,"vector<string>",0,&tolua_err)) ||
00783      (tolua_isvaluenil(tolua_S,7,&tolua_err) || !tolua_isusertype(tolua_S,7,"vector<string>",0,&tolua_err)) ||
00784      !tolua_isnoobj(tolua_S,8,&tolua_err)
00785  )
00786   goto tolua_lerror;
00787  else
00788  {
00789   string name = ((string)  tolua_tocppstring(tolua_S,2,0));
00790   double x = ((double)  tolua_tonumber(tolua_S,3,0));
00791   double y = ((double)  tolua_tonumber(tolua_S,4,0));
00792   vector<string> children = *((vector<string>*)  tolua_tousertype(tolua_S,5,0));
00793   vector<string> properties = *((vector<string>*)  tolua_tousertype(tolua_S,6,0));
00794   vector<string> aliases = *((vector<string>*)  tolua_tousertype(tolua_S,7,0));
00795   {
00796    fawkes::RCSoftMapNode* tolua_ret = (fawkes::RCSoftMapNode*)  Mtolua_new((fawkes::RCSoftMapNode)(name,x,y,children,properties,aliases));
00797     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::RCSoftMapNode");
00798     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00799   }
00800  }
00801  return 1;
00802 tolua_lerror:
00803  return tolua_fawkesutils_fawkes_RCSoftMapNode_new00_local(tolua_S);
00804 }
00805 #endif //#ifndef TOLUA_DISABLE
00806 
00807 /* method: name of class  fawkes::RCSoftMapNode */
00808 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_RCSoftMapNode_name00
00809 static int tolua_fawkesutils_fawkes_RCSoftMapNode_name00(lua_State* tolua_S)
00810 {
00811 #ifndef TOLUA_RELEASE
00812  tolua_Error tolua_err;
00813  if (
00814      !tolua_isusertype(tolua_S,1,"const fawkes::RCSoftMapNode",0,&tolua_err) ||
00815      !tolua_isnoobj(tolua_S,2,&tolua_err)
00816  )
00817   goto tolua_lerror;
00818  else
00819 #endif
00820  {
00821   const fawkes::RCSoftMapNode* self = (const fawkes::RCSoftMapNode*)  tolua_tousertype(tolua_S,1,0);
00822 #ifndef TOLUA_RELEASE
00823   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'name'", NULL);
00824 #endif
00825   {
00826    string tolua_ret = (string)  self->name();
00827    tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
00828   }
00829  }
00830  return 1;
00831 #ifndef TOLUA_RELEASE
00832  tolua_lerror:
00833  tolua_error(tolua_S,"#ferror in function 'name'.",&tolua_err);
00834  return 0;
00835 #endif
00836 }
00837 #endif //#ifndef TOLUA_DISABLE
00838 
00839 /* method: x of class  fawkes::RCSoftMapNode */
00840 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_RCSoftMapNode_x00
00841 static int tolua_fawkesutils_fawkes_RCSoftMapNode_x00(lua_State* tolua_S)
00842 {
00843 #ifndef TOLUA_RELEASE
00844  tolua_Error tolua_err;
00845  if (
00846      !tolua_isusertype(tolua_S,1,"const fawkes::RCSoftMapNode",0,&tolua_err) ||
00847      !tolua_isnoobj(tolua_S,2,&tolua_err)
00848  )
00849   goto tolua_lerror;
00850  else
00851 #endif
00852  {
00853   const fawkes::RCSoftMapNode* self = (const fawkes::RCSoftMapNode*)  tolua_tousertype(tolua_S,1,0);
00854 #ifndef TOLUA_RELEASE
00855   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'x'", NULL);
00856 #endif
00857   {
00858    float tolua_ret = (float)  self->x();
00859    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00860   }
00861  }
00862  return 1;
00863 #ifndef TOLUA_RELEASE
00864  tolua_lerror:
00865  tolua_error(tolua_S,"#ferror in function 'x'.",&tolua_err);
00866  return 0;
00867 #endif
00868 }
00869 #endif //#ifndef TOLUA_DISABLE
00870 
00871 /* method: y of class  fawkes::RCSoftMapNode */
00872 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_RCSoftMapNode_y00
00873 static int tolua_fawkesutils_fawkes_RCSoftMapNode_y00(lua_State* tolua_S)
00874 {
00875 #ifndef TOLUA_RELEASE
00876  tolua_Error tolua_err;
00877  if (
00878      !tolua_isusertype(tolua_S,1,"const fawkes::RCSoftMapNode",0,&tolua_err) ||
00879      !tolua_isnoobj(tolua_S,2,&tolua_err)
00880  )
00881   goto tolua_lerror;
00882  else
00883 #endif
00884  {
00885   const fawkes::RCSoftMapNode* self = (const fawkes::RCSoftMapNode*)  tolua_tousertype(tolua_S,1,0);
00886 #ifndef TOLUA_RELEASE
00887   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'y'", NULL);
00888 #endif
00889   {
00890    float tolua_ret = (float)  self->y();
00891    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00892   }
00893  }
00894  return 1;
00895 #ifndef TOLUA_RELEASE
00896  tolua_lerror:
00897  tolua_error(tolua_S,"#ferror in function 'y'.",&tolua_err);
00898  return 0;
00899 #endif
00900 }
00901 #endif //#ifndef TOLUA_DISABLE
00902 
00903 /* method: properties of class  fawkes::RCSoftMapNode */
00904 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_RCSoftMapNode_properties00
00905 static int tolua_fawkesutils_fawkes_RCSoftMapNode_properties00(lua_State* tolua_S)
00906 {
00907 #ifndef TOLUA_RELEASE
00908  tolua_Error tolua_err;
00909  if (
00910      !tolua_isusertype(tolua_S,1,"fawkes::RCSoftMapNode",0,&tolua_err) ||
00911      !tolua_isnoobj(tolua_S,2,&tolua_err)
00912  )
00913   goto tolua_lerror;
00914  else
00915 #endif
00916  {
00917   fawkes::RCSoftMapNode* self = (fawkes::RCSoftMapNode*)  tolua_tousertype(tolua_S,1,0);
00918 #ifndef TOLUA_RELEASE
00919   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'properties'", NULL);
00920 #endif
00921   {
00922    vector<string>& tolua_ret = (vector<string>&)  self->properties();
00923     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"vector<string>");
00924   }
00925  }
00926  return 1;
00927 #ifndef TOLUA_RELEASE
00928  tolua_lerror:
00929  tolua_error(tolua_S,"#ferror in function 'properties'.",&tolua_err);
00930  return 0;
00931 #endif
00932 }
00933 #endif //#ifndef TOLUA_DISABLE
00934 
00935 /* method: aliases of class  fawkes::RCSoftMapNode */
00936 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_RCSoftMapNode_aliases00
00937 static int tolua_fawkesutils_fawkes_RCSoftMapNode_aliases00(lua_State* tolua_S)
00938 {
00939 #ifndef TOLUA_RELEASE
00940  tolua_Error tolua_err;
00941  if (
00942      !tolua_isusertype(tolua_S,1,"fawkes::RCSoftMapNode",0,&tolua_err) ||
00943      !tolua_isnoobj(tolua_S,2,&tolua_err)
00944  )
00945   goto tolua_lerror;
00946  else
00947 #endif
00948  {
00949   fawkes::RCSoftMapNode* self = (fawkes::RCSoftMapNode*)  tolua_tousertype(tolua_S,1,0);
00950 #ifndef TOLUA_RELEASE
00951   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'aliases'", NULL);
00952 #endif
00953   {
00954    vector<string>& tolua_ret = (vector<string>&)  self->aliases();
00955     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"vector<string>");
00956   }
00957  }
00958  return 1;
00959 #ifndef TOLUA_RELEASE
00960  tolua_lerror:
00961  tolua_error(tolua_S,"#ferror in function 'aliases'.",&tolua_err);
00962  return 0;
00963 #endif
00964 }
00965 #endif //#ifndef TOLUA_DISABLE
00966 
00967 /* method: children of class  fawkes::RCSoftMapNode */
00968 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_RCSoftMapNode_children00
00969 static int tolua_fawkesutils_fawkes_RCSoftMapNode_children00(lua_State* tolua_S)
00970 {
00971 #ifndef TOLUA_RELEASE
00972  tolua_Error tolua_err;
00973  if (
00974      !tolua_isusertype(tolua_S,1,"fawkes::RCSoftMapNode",0,&tolua_err) ||
00975      !tolua_isnoobj(tolua_S,2,&tolua_err)
00976  )
00977   goto tolua_lerror;
00978  else
00979 #endif
00980  {
00981   fawkes::RCSoftMapNode* self = (fawkes::RCSoftMapNode*)  tolua_tousertype(tolua_S,1,0);
00982 #ifndef TOLUA_RELEASE
00983   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'children'", NULL);
00984 #endif
00985   {
00986    vector<string>& tolua_ret = (vector<string>&)  self->children();
00987     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"vector<string>");
00988   }
00989  }
00990  return 1;
00991 #ifndef TOLUA_RELEASE
00992  tolua_lerror:
00993  tolua_error(tolua_S,"#ferror in function 'children'.",&tolua_err);
00994  return 0;
00995 #endif
00996 }
00997 #endif //#ifndef TOLUA_DISABLE
00998 
00999 /* method: has_property of class  fawkes::RCSoftMapNode */
01000 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_RCSoftMapNode_has_property00
01001 static int tolua_fawkesutils_fawkes_RCSoftMapNode_has_property00(lua_State* tolua_S)
01002 {
01003 #ifndef TOLUA_RELEASE
01004  tolua_Error tolua_err;
01005  if (
01006      !tolua_isusertype(tolua_S,1,"fawkes::RCSoftMapNode",0,&tolua_err) ||
01007      !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
01008      !tolua_isnoobj(tolua_S,3,&tolua_err)
01009  )
01010   goto tolua_lerror;
01011  else
01012 #endif
01013  {
01014   fawkes::RCSoftMapNode* self = (fawkes::RCSoftMapNode*)  tolua_tousertype(tolua_S,1,0);
01015   string property = ((string)  tolua_tocppstring(tolua_S,2,0));
01016 #ifndef TOLUA_RELEASE
01017   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'has_property'", NULL);
01018 #endif
01019   {
01020    bool tolua_ret = (bool)  self->has_property(property);
01021    tolua_pushboolean(tolua_S,(bool)tolua_ret);
01022   }
01023  }
01024  return 1;
01025 #ifndef TOLUA_RELEASE
01026  tolua_lerror:
01027  tolua_error(tolua_S,"#ferror in function 'has_property'.",&tolua_err);
01028  return 0;
01029 #endif
01030 }
01031 #endif //#ifndef TOLUA_DISABLE
01032 
01033 /* method: has_alias of class  fawkes::RCSoftMapNode */
01034 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_RCSoftMapNode_has_alias00
01035 static int tolua_fawkesutils_fawkes_RCSoftMapNode_has_alias00(lua_State* tolua_S)
01036 {
01037 #ifndef TOLUA_RELEASE
01038  tolua_Error tolua_err;
01039  if (
01040      !tolua_isusertype(tolua_S,1,"fawkes::RCSoftMapNode",0,&tolua_err) ||
01041      !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
01042      !tolua_isnoobj(tolua_S,3,&tolua_err)
01043  )
01044   goto tolua_lerror;
01045  else
01046 #endif
01047  {
01048   fawkes::RCSoftMapNode* self = (fawkes::RCSoftMapNode*)  tolua_tousertype(tolua_S,1,0);
01049   string property = ((string)  tolua_tocppstring(tolua_S,2,0));
01050 #ifndef TOLUA_RELEASE
01051   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'has_alias'", NULL);
01052 #endif
01053   {
01054    bool tolua_ret = (bool)  self->has_alias(property);
01055    tolua_pushboolean(tolua_S,(bool)tolua_ret);
01056   }
01057  }
01058  return 1;
01059 #ifndef TOLUA_RELEASE
01060  tolua_lerror:
01061  tolua_error(tolua_S,"#ferror in function 'has_alias'.",&tolua_err);
01062  return 0;
01063 #endif
01064 }
01065 #endif //#ifndef TOLUA_DISABLE
01066 
01067 /* method: new of class  fawkes::RCSoftMapGraph */
01068 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_RCSoftMapGraph_new00
01069 static int tolua_fawkesutils_fawkes_RCSoftMapGraph_new00(lua_State* tolua_S)
01070 {
01071 #ifndef TOLUA_RELEASE
01072  tolua_Error tolua_err;
01073  if (
01074      !tolua_isusertable(tolua_S,1,"fawkes::RCSoftMapGraph",0,&tolua_err) ||
01075      !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
01076      !tolua_isnoobj(tolua_S,3,&tolua_err)
01077  )
01078   goto tolua_lerror;
01079  else
01080 #endif
01081  {
01082   string filename = ((string)  tolua_tocppstring(tolua_S,2,0));
01083   {
01084    fawkes::RCSoftMapGraph* tolua_ret = (fawkes::RCSoftMapGraph*)  Mtolua_new((fawkes::RCSoftMapGraph)(filename));
01085     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::RCSoftMapGraph");
01086   }
01087  }
01088  return 1;
01089 #ifndef TOLUA_RELEASE
01090  tolua_lerror:
01091  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
01092  return 0;
01093 #endif
01094 }
01095 #endif //#ifndef TOLUA_DISABLE
01096 
01097 /* method: new_local of class  fawkes::RCSoftMapGraph */
01098 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_RCSoftMapGraph_new00_local
01099 static int tolua_fawkesutils_fawkes_RCSoftMapGraph_new00_local(lua_State* tolua_S)
01100 {
01101 #ifndef TOLUA_RELEASE
01102  tolua_Error tolua_err;
01103  if (
01104      !tolua_isusertable(tolua_S,1,"fawkes::RCSoftMapGraph",0,&tolua_err) ||
01105      !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
01106      !tolua_isnoobj(tolua_S,3,&tolua_err)
01107  )
01108   goto tolua_lerror;
01109  else
01110 #endif
01111  {
01112   string filename = ((string)  tolua_tocppstring(tolua_S,2,0));
01113   {
01114    fawkes::RCSoftMapGraph* tolua_ret = (fawkes::RCSoftMapGraph*)  Mtolua_new((fawkes::RCSoftMapGraph)(filename));
01115     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::RCSoftMapGraph");
01116     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01117   }
01118  }
01119  return 1;
01120 #ifndef TOLUA_RELEASE
01121  tolua_lerror:
01122  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
01123  return 0;
01124 #endif
01125 }
01126 #endif //#ifndef TOLUA_DISABLE
01127 
01128 /* method: delete of class  fawkes::RCSoftMapGraph */
01129 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_RCSoftMapGraph_delete00
01130 static int tolua_fawkesutils_fawkes_RCSoftMapGraph_delete00(lua_State* tolua_S)
01131 {
01132 #ifndef TOLUA_RELEASE
01133  tolua_Error tolua_err;
01134  if (
01135      !tolua_isusertype(tolua_S,1,"fawkes::RCSoftMapGraph",0,&tolua_err) ||
01136      !tolua_isnoobj(tolua_S,2,&tolua_err)
01137  )
01138   goto tolua_lerror;
01139  else
01140 #endif
01141  {
01142   fawkes::RCSoftMapGraph* self = (fawkes::RCSoftMapGraph*)  tolua_tousertype(tolua_S,1,0);
01143 #ifndef TOLUA_RELEASE
01144   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
01145 #endif
01146   Mtolua_delete(self);
01147  }
01148  return 0;
01149 #ifndef TOLUA_RELEASE
01150  tolua_lerror:
01151  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
01152  return 0;
01153 #endif
01154 }
01155 #endif //#ifndef TOLUA_DISABLE
01156 
01157 /* method: graph_name of class  fawkes::RCSoftMapGraph */
01158 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_RCSoftMapGraph_graph_name00
01159 static int tolua_fawkesutils_fawkes_RCSoftMapGraph_graph_name00(lua_State* tolua_S)
01160 {
01161 #ifndef TOLUA_RELEASE
01162  tolua_Error tolua_err;
01163  if (
01164      !tolua_isusertype(tolua_S,1,"fawkes::RCSoftMapGraph",0,&tolua_err) ||
01165      !tolua_isnoobj(tolua_S,2,&tolua_err)
01166  )
01167   goto tolua_lerror;
01168  else
01169 #endif
01170  {
01171   fawkes::RCSoftMapGraph* self = (fawkes::RCSoftMapGraph*)  tolua_tousertype(tolua_S,1,0);
01172 #ifndef TOLUA_RELEASE
01173   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'graph_name'", NULL);
01174 #endif
01175   {
01176    string tolua_ret = (string)  self->graph_name();
01177    tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
01178   }
01179  }
01180  return 1;
01181 #ifndef TOLUA_RELEASE
01182  tolua_lerror:
01183  tolua_error(tolua_S,"#ferror in function 'graph_name'.",&tolua_err);
01184  return 0;
01185 #endif
01186 }
01187 #endif //#ifndef TOLUA_DISABLE
01188 
01189 /* method: nodes of class  fawkes::RCSoftMapGraph */
01190 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_RCSoftMapGraph_nodes00
01191 static int tolua_fawkesutils_fawkes_RCSoftMapGraph_nodes00(lua_State* tolua_S)
01192 {
01193 #ifndef TOLUA_RELEASE
01194  tolua_Error tolua_err;
01195  if (
01196      !tolua_isusertype(tolua_S,1,"fawkes::RCSoftMapGraph",0,&tolua_err) ||
01197      !tolua_isnoobj(tolua_S,2,&tolua_err)
01198  )
01199   goto tolua_lerror;
01200  else
01201 #endif
01202  {
01203   fawkes::RCSoftMapGraph* self = (fawkes::RCSoftMapGraph*)  tolua_tousertype(tolua_S,1,0);
01204 #ifndef TOLUA_RELEASE
01205   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'nodes'", NULL);
01206 #endif
01207   {
01208    vector<fawkes::RCSoftMapNode> tolua_ret = (vector<fawkes::RCSoftMapNode>)  self->nodes();
01209    {
01210 #ifdef __cplusplus
01211     void* tolua_obj = Mtolua_new((vector<fawkes::RCSoftMapNode>)(tolua_ret));
01212      tolua_pushusertype(tolua_S,tolua_obj,"vector<fawkes::RCSoftMapNode>");
01213     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01214 #else
01215     void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(vector<fawkes::RCSoftMapNode>));
01216      tolua_pushusertype(tolua_S,tolua_obj,"vector<fawkes::RCSoftMapNode>");
01217     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01218 #endif
01219    }
01220   }
01221  }
01222  return 1;
01223 #ifndef TOLUA_RELEASE
01224  tolua_lerror:
01225  tolua_error(tolua_S,"#ferror in function 'nodes'.",&tolua_err);
01226  return 0;
01227 #endif
01228 }
01229 #endif //#ifndef TOLUA_DISABLE
01230 
01231 /* method: node of class  fawkes::RCSoftMapGraph */
01232 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_RCSoftMapGraph_node00
01233 static int tolua_fawkesutils_fawkes_RCSoftMapGraph_node00(lua_State* tolua_S)
01234 {
01235 #ifndef TOLUA_RELEASE
01236  tolua_Error tolua_err;
01237  if (
01238      !tolua_isusertype(tolua_S,1,"fawkes::RCSoftMapGraph",0,&tolua_err) ||
01239      !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
01240      !tolua_isnoobj(tolua_S,3,&tolua_err)
01241  )
01242   goto tolua_lerror;
01243  else
01244 #endif
01245  {
01246   fawkes::RCSoftMapGraph* self = (fawkes::RCSoftMapGraph*)  tolua_tousertype(tolua_S,1,0);
01247   string name_or_alias = ((string)  tolua_tocppstring(tolua_S,2,0));
01248 #ifndef TOLUA_RELEASE
01249   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'node'", NULL);
01250 #endif
01251   {
01252    fawkes::RCSoftMapNode tolua_ret = (fawkes::RCSoftMapNode)  self->node(name_or_alias);
01253    {
01254 #ifdef __cplusplus
01255     void* tolua_obj = Mtolua_new((fawkes::RCSoftMapNode)(tolua_ret));
01256      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::RCSoftMapNode");
01257     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01258 #else
01259     void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::RCSoftMapNode));
01260      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::RCSoftMapNode");
01261     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01262 #endif
01263    }
01264   }
01265  }
01266  return 1;
01267 #ifndef TOLUA_RELEASE
01268  tolua_lerror:
01269  tolua_error(tolua_S,"#ferror in function 'node'.",&tolua_err);
01270  return 0;
01271 #endif
01272 }
01273 #endif //#ifndef TOLUA_DISABLE
01274 
01275 /* method: root_node of class  fawkes::RCSoftMapGraph */
01276 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_RCSoftMapGraph_root_node00
01277 static int tolua_fawkesutils_fawkes_RCSoftMapGraph_root_node00(lua_State* tolua_S)
01278 {
01279 #ifndef TOLUA_RELEASE
01280  tolua_Error tolua_err;
01281  if (
01282      !tolua_isusertype(tolua_S,1,"fawkes::RCSoftMapGraph",0,&tolua_err) ||
01283      !tolua_isnoobj(tolua_S,2,&tolua_err)
01284  )
01285   goto tolua_lerror;
01286  else
01287 #endif
01288  {
01289   fawkes::RCSoftMapGraph* self = (fawkes::RCSoftMapGraph*)  tolua_tousertype(tolua_S,1,0);
01290 #ifndef TOLUA_RELEASE
01291   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'root_node'", NULL);
01292 #endif
01293   {
01294    fawkes::RCSoftMapNode tolua_ret = (fawkes::RCSoftMapNode)  self->root_node();
01295    {
01296 #ifdef __cplusplus
01297     void* tolua_obj = Mtolua_new((fawkes::RCSoftMapNode)(tolua_ret));
01298      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::RCSoftMapNode");
01299     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01300 #else
01301     void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::RCSoftMapNode));
01302      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::RCSoftMapNode");
01303     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01304 #endif
01305    }
01306   }
01307  }
01308  return 1;
01309 #ifndef TOLUA_RELEASE
01310  tolua_lerror:
01311  tolua_error(tolua_S,"#ferror in function 'root_node'.",&tolua_err);
01312  return 0;
01313 #endif
01314 }
01315 #endif //#ifndef TOLUA_DISABLE
01316 
01317 /* method: closest_node of class  fawkes::RCSoftMapGraph */
01318 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_RCSoftMapGraph_closest_node00
01319 static int tolua_fawkesutils_fawkes_RCSoftMapGraph_closest_node00(lua_State* tolua_S)
01320 {
01321 #ifndef TOLUA_RELEASE
01322  tolua_Error tolua_err;
01323  if (
01324      !tolua_isusertype(tolua_S,1,"fawkes::RCSoftMapGraph",0,&tolua_err) ||
01325      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01326      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
01327      !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
01328      !tolua_isnoobj(tolua_S,5,&tolua_err)
01329  )
01330   goto tolua_lerror;
01331  else
01332 #endif
01333  {
01334   fawkes::RCSoftMapGraph* self = (fawkes::RCSoftMapGraph*)  tolua_tousertype(tolua_S,1,0);
01335   float pos_x = ((float)  tolua_tonumber(tolua_S,2,0));
01336   float pos_y = ((float)  tolua_tonumber(tolua_S,3,0));
01337   string property = ((string)  tolua_tocppstring(tolua_S,4,0));
01338 #ifndef TOLUA_RELEASE
01339   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'closest_node'", NULL);
01340 #endif
01341   {
01342    fawkes::RCSoftMapNode tolua_ret = (fawkes::RCSoftMapNode)  self->closest_node(pos_x,pos_y,property);
01343    {
01344 #ifdef __cplusplus
01345     void* tolua_obj = Mtolua_new((fawkes::RCSoftMapNode)(tolua_ret));
01346      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::RCSoftMapNode");
01347     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01348 #else
01349     void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::RCSoftMapNode));
01350      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::RCSoftMapNode");
01351     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01352 #endif
01353    }
01354   }
01355  }
01356  return 1;
01357 #ifndef TOLUA_RELEASE
01358  tolua_lerror:
01359  tolua_error(tolua_S,"#ferror in function 'closest_node'.",&tolua_err);
01360  return 0;
01361 #endif
01362 }
01363 #endif //#ifndef TOLUA_DISABLE
01364 
01365 /* method: search_nodes of class  fawkes::RCSoftMapGraph */
01366 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_RCSoftMapGraph_search_nodes00
01367 static int tolua_fawkesutils_fawkes_RCSoftMapGraph_search_nodes00(lua_State* tolua_S)
01368 {
01369 #ifndef TOLUA_RELEASE
01370  tolua_Error tolua_err;
01371  if (
01372      !tolua_isusertype(tolua_S,1,"fawkes::RCSoftMapGraph",0,&tolua_err) ||
01373      !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
01374      !tolua_isnoobj(tolua_S,3,&tolua_err)
01375  )
01376   goto tolua_lerror;
01377  else
01378 #endif
01379  {
01380   fawkes::RCSoftMapGraph* self = (fawkes::RCSoftMapGraph*)  tolua_tousertype(tolua_S,1,0);
01381   string property = ((string)  tolua_tocppstring(tolua_S,2,0));
01382 #ifndef TOLUA_RELEASE
01383   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'search_nodes'", NULL);
01384 #endif
01385   {
01386    vector<fawkes::RCSoftMapNode> tolua_ret = (vector<fawkes::RCSoftMapNode>)  self->search_nodes(property);
01387    {
01388 #ifdef __cplusplus
01389     void* tolua_obj = Mtolua_new((vector<fawkes::RCSoftMapNode>)(tolua_ret));
01390      tolua_pushusertype(tolua_S,tolua_obj,"vector<fawkes::RCSoftMapNode>");
01391     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01392 #else
01393     void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(vector<fawkes::RCSoftMapNode>));
01394      tolua_pushusertype(tolua_S,tolua_obj,"vector<fawkes::RCSoftMapNode>");
01395     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01396 #endif
01397    }
01398   }
01399  }
01400  return 1;
01401 #ifndef TOLUA_RELEASE
01402  tolua_lerror:
01403  tolua_error(tolua_S,"#ferror in function 'search_nodes'.",&tolua_err);
01404  return 0;
01405 #endif
01406 }
01407 #endif //#ifndef TOLUA_DISABLE
01408 
01409 /* method: new of class  fawkes::KalmanFilter1D */
01410 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_KalmanFilter1D_new00
01411 static int tolua_fawkesutils_fawkes_KalmanFilter1D_new00(lua_State* tolua_S)
01412 {
01413 #ifndef TOLUA_RELEASE
01414  tolua_Error tolua_err;
01415  if (
01416      !tolua_isusertable(tolua_S,1,"fawkes::KalmanFilter1D",0,&tolua_err) ||
01417      !tolua_isnumber(tolua_S,2,1,&tolua_err) ||
01418      !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
01419      !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
01420      !tolua_isnumber(tolua_S,5,1,&tolua_err) ||
01421      !tolua_isnoobj(tolua_S,6,&tolua_err)
01422  )
01423   goto tolua_lerror;
01424  else
01425 #endif
01426  {
01427   float noise_x = ((float)  tolua_tonumber(tolua_S,2,1.0));
01428   float noise_z = ((float)  tolua_tonumber(tolua_S,3,1.0));
01429   float mu = ((float)  tolua_tonumber(tolua_S,4,0.0));
01430   float sig = ((float)  tolua_tonumber(tolua_S,5,1.0));
01431   {
01432    fawkes::KalmanFilter1D* tolua_ret = (fawkes::KalmanFilter1D*)  Mtolua_new((fawkes::KalmanFilter1D)(noise_x,noise_z,mu,sig));
01433     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::KalmanFilter1D");
01434   }
01435  }
01436  return 1;
01437 #ifndef TOLUA_RELEASE
01438  tolua_lerror:
01439  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
01440  return 0;
01441 #endif
01442 }
01443 #endif //#ifndef TOLUA_DISABLE
01444 
01445 /* method: new_local of class  fawkes::KalmanFilter1D */
01446 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_KalmanFilter1D_new00_local
01447 static int tolua_fawkesutils_fawkes_KalmanFilter1D_new00_local(lua_State* tolua_S)
01448 {
01449 #ifndef TOLUA_RELEASE
01450  tolua_Error tolua_err;
01451  if (
01452      !tolua_isusertable(tolua_S,1,"fawkes::KalmanFilter1D",0,&tolua_err) ||
01453      !tolua_isnumber(tolua_S,2,1,&tolua_err) ||
01454      !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
01455      !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
01456      !tolua_isnumber(tolua_S,5,1,&tolua_err) ||
01457      !tolua_isnoobj(tolua_S,6,&tolua_err)
01458  )
01459   goto tolua_lerror;
01460  else
01461 #endif
01462  {
01463   float noise_x = ((float)  tolua_tonumber(tolua_S,2,1.0));
01464   float noise_z = ((float)  tolua_tonumber(tolua_S,3,1.0));
01465   float mu = ((float)  tolua_tonumber(tolua_S,4,0.0));
01466   float sig = ((float)  tolua_tonumber(tolua_S,5,1.0));
01467   {
01468    fawkes::KalmanFilter1D* tolua_ret = (fawkes::KalmanFilter1D*)  Mtolua_new((fawkes::KalmanFilter1D)(noise_x,noise_z,mu,sig));
01469     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::KalmanFilter1D");
01470     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01471   }
01472  }
01473  return 1;
01474 #ifndef TOLUA_RELEASE
01475  tolua_lerror:
01476  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
01477  return 0;
01478 #endif
01479 }
01480 #endif //#ifndef TOLUA_DISABLE
01481 
01482 /* method: delete of class  fawkes::KalmanFilter1D */
01483 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_KalmanFilter1D_delete00
01484 static int tolua_fawkesutils_fawkes_KalmanFilter1D_delete00(lua_State* tolua_S)
01485 {
01486 #ifndef TOLUA_RELEASE
01487  tolua_Error tolua_err;
01488  if (
01489      !tolua_isusertype(tolua_S,1,"fawkes::KalmanFilter1D",0,&tolua_err) ||
01490      !tolua_isnoobj(tolua_S,2,&tolua_err)
01491  )
01492   goto tolua_lerror;
01493  else
01494 #endif
01495  {
01496   fawkes::KalmanFilter1D* self = (fawkes::KalmanFilter1D*)  tolua_tousertype(tolua_S,1,0);
01497 #ifndef TOLUA_RELEASE
01498   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
01499 #endif
01500   Mtolua_delete(self);
01501  }
01502  return 0;
01503 #ifndef TOLUA_RELEASE
01504  tolua_lerror:
01505  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
01506  return 0;
01507 #endif
01508 }
01509 #endif //#ifndef TOLUA_DISABLE
01510 
01511 /* method: filter of class  fawkes::KalmanFilter1D */
01512 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_KalmanFilter1D_filter00
01513 static int tolua_fawkesutils_fawkes_KalmanFilter1D_filter00(lua_State* tolua_S)
01514 {
01515 #ifndef TOLUA_RELEASE
01516  tolua_Error tolua_err;
01517  if (
01518      !tolua_isusertype(tolua_S,1,"fawkes::KalmanFilter1D",0,&tolua_err) ||
01519      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01520      !tolua_isnoobj(tolua_S,3,&tolua_err)
01521  )
01522   goto tolua_lerror;
01523  else
01524 #endif
01525  {
01526   fawkes::KalmanFilter1D* self = (fawkes::KalmanFilter1D*)  tolua_tousertype(tolua_S,1,0);
01527   float observe = ((float)  tolua_tonumber(tolua_S,2,0));
01528 #ifndef TOLUA_RELEASE
01529   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'filter'", NULL);
01530 #endif
01531   {
01532    self->filter(observe);
01533   }
01534  }
01535  return 0;
01536 #ifndef TOLUA_RELEASE
01537  tolua_lerror:
01538  tolua_error(tolua_S,"#ferror in function 'filter'.",&tolua_err);
01539  return 0;
01540 #endif
01541 }
01542 #endif //#ifndef TOLUA_DISABLE
01543 
01544 /* method: filter of class  fawkes::KalmanFilter1D */
01545 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_KalmanFilter1D_filter01
01546 static int tolua_fawkesutils_fawkes_KalmanFilter1D_filter01(lua_State* tolua_S)
01547 {
01548  tolua_Error tolua_err;
01549  if (
01550      !tolua_isusertype(tolua_S,1,"fawkes::KalmanFilter1D",0,&tolua_err) ||
01551      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01552      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
01553      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
01554      !tolua_isnoobj(tolua_S,5,&tolua_err)
01555  )
01556   goto tolua_lerror;
01557  else
01558  {
01559   fawkes::KalmanFilter1D* self = (fawkes::KalmanFilter1D*)  tolua_tousertype(tolua_S,1,0);
01560   float observe = ((float)  tolua_tonumber(tolua_S,2,0));
01561   float mu = ((float)  tolua_tonumber(tolua_S,3,0));
01562   float sig = ((float)  tolua_tonumber(tolua_S,4,0));
01563 #ifndef TOLUA_RELEASE
01564   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'filter'", NULL);
01565 #endif
01566   {
01567    self->filter(observe,mu,sig);
01568    tolua_pushnumber(tolua_S,(lua_Number)mu);
01569    tolua_pushnumber(tolua_S,(lua_Number)sig);
01570   }
01571  }
01572  return 2;
01573 tolua_lerror:
01574  return tolua_fawkesutils_fawkes_KalmanFilter1D_filter00(tolua_S);
01575 }
01576 #endif //#ifndef TOLUA_DISABLE
01577 
01578 /* method: predict of class  fawkes::KalmanFilter1D */
01579 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_KalmanFilter1D_predict00
01580 static int tolua_fawkesutils_fawkes_KalmanFilter1D_predict00(lua_State* tolua_S)
01581 {
01582 #ifndef TOLUA_RELEASE
01583  tolua_Error tolua_err;
01584  if (
01585      !tolua_isusertype(tolua_S,1,"const fawkes::KalmanFilter1D",0,&tolua_err) ||
01586      !tolua_isnoobj(tolua_S,2,&tolua_err)
01587  )
01588   goto tolua_lerror;
01589  else
01590 #endif
01591  {
01592   const fawkes::KalmanFilter1D* self = (const fawkes::KalmanFilter1D*)  tolua_tousertype(tolua_S,1,0);
01593 #ifndef TOLUA_RELEASE
01594   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'predict'", NULL);
01595 #endif
01596   {
01597    float tolua_ret = (float)  self->predict();
01598    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01599   }
01600  }
01601  return 1;
01602 #ifndef TOLUA_RELEASE
01603  tolua_lerror:
01604  tolua_error(tolua_S,"#ferror in function 'predict'.",&tolua_err);
01605  return 0;
01606 #endif
01607 }
01608 #endif //#ifndef TOLUA_DISABLE
01609 
01610 /* method: predict of class  fawkes::KalmanFilter1D */
01611 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_KalmanFilter1D_predict01
01612 static int tolua_fawkesutils_fawkes_KalmanFilter1D_predict01(lua_State* tolua_S)
01613 {
01614  tolua_Error tolua_err;
01615  if (
01616      !tolua_isusertype(tolua_S,1,"const fawkes::KalmanFilter1D",0,&tolua_err) ||
01617      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01618      !tolua_isnoobj(tolua_S,3,&tolua_err)
01619  )
01620   goto tolua_lerror;
01621  else
01622  {
01623   const fawkes::KalmanFilter1D* self = (const fawkes::KalmanFilter1D*)  tolua_tousertype(tolua_S,1,0);
01624   float vel = ((float)  tolua_tonumber(tolua_S,2,0));
01625 #ifndef TOLUA_RELEASE
01626   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'predict'", NULL);
01627 #endif
01628   {
01629    float tolua_ret = (float)  self->predict(vel);
01630    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01631   }
01632  }
01633  return 1;
01634 tolua_lerror:
01635  return tolua_fawkesutils_fawkes_KalmanFilter1D_predict00(tolua_S);
01636 }
01637 #endif //#ifndef TOLUA_DISABLE
01638 
01639 /* method: predict of class  fawkes::KalmanFilter1D */
01640 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_KalmanFilter1D_predict02
01641 static int tolua_fawkesutils_fawkes_KalmanFilter1D_predict02(lua_State* tolua_S)
01642 {
01643  tolua_Error tolua_err;
01644  if (
01645      !tolua_isusertype(tolua_S,1,"const fawkes::KalmanFilter1D",0,&tolua_err) ||
01646      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01647      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
01648      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
01649      !tolua_isnoobj(tolua_S,5,&tolua_err)
01650  )
01651   goto tolua_lerror;
01652  else
01653  {
01654   const fawkes::KalmanFilter1D* self = (const fawkes::KalmanFilter1D*)  tolua_tousertype(tolua_S,1,0);
01655   float vel = ((float)  tolua_tonumber(tolua_S,2,0));
01656   int steps = ((int)  tolua_tonumber(tolua_S,3,0));
01657   float noise_z = ((float)  tolua_tonumber(tolua_S,4,0));
01658 #ifndef TOLUA_RELEASE
01659   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'predict'", NULL);
01660 #endif
01661   {
01662    float tolua_ret = (float)  self->predict(vel,steps,noise_z);
01663    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01664   }
01665  }
01666  return 1;
01667 tolua_lerror:
01668  return tolua_fawkesutils_fawkes_KalmanFilter1D_predict01(tolua_S);
01669 }
01670 #endif //#ifndef TOLUA_DISABLE
01671 
01672 /* method: predict of class  fawkes::KalmanFilter1D */
01673 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_KalmanFilter1D_predict03
01674 static int tolua_fawkesutils_fawkes_KalmanFilter1D_predict03(lua_State* tolua_S)
01675 {
01676  tolua_Error tolua_err;
01677  if (
01678      !tolua_isusertype(tolua_S,1,"const fawkes::KalmanFilter1D",0,&tolua_err) ||
01679      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01680      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
01681      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
01682      !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
01683      !tolua_isnoobj(tolua_S,6,&tolua_err)
01684  )
01685   goto tolua_lerror;
01686  else
01687  {
01688   const fawkes::KalmanFilter1D* self = (const fawkes::KalmanFilter1D*)  tolua_tousertype(tolua_S,1,0);
01689   float mu = ((float)  tolua_tonumber(tolua_S,2,0));
01690   float vel = ((float)  tolua_tonumber(tolua_S,3,0));
01691   int steps = ((int)  tolua_tonumber(tolua_S,4,0));
01692   float noise_z = ((float)  tolua_tonumber(tolua_S,5,0));
01693 #ifndef TOLUA_RELEASE
01694   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'predict'", NULL);
01695 #endif
01696   {
01697    float tolua_ret = (float)  self->predict(mu,vel,steps,noise_z);
01698    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01699   }
01700  }
01701  return 1;
01702 tolua_lerror:
01703  return tolua_fawkesutils_fawkes_KalmanFilter1D_predict02(tolua_S);
01704 }
01705 #endif //#ifndef TOLUA_DISABLE
01706 
01707 /* get function: tv_sec of class  timeval */
01708 #ifndef TOLUA_DISABLE_tolua_get_timeval_tv_sec
01709 static int tolua_get_timeval_tv_sec(lua_State* tolua_S)
01710 {
01711   timeval* self = (timeval*)  tolua_tousertype(tolua_S,1,0);
01712 #ifndef TOLUA_RELEASE
01713   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'tv_sec'",NULL);
01714 #endif
01715   tolua_pushnumber(tolua_S,(lua_Number)self->tv_sec);
01716  return 1;
01717 }
01718 #endif //#ifndef TOLUA_DISABLE
01719 
01720 /* set function: tv_sec of class  timeval */
01721 #ifndef TOLUA_DISABLE_tolua_set_timeval_tv_sec
01722 static int tolua_set_timeval_tv_sec(lua_State* tolua_S)
01723 {
01724   timeval* self = (timeval*)  tolua_tousertype(tolua_S,1,0);
01725 #ifndef TOLUA_RELEASE
01726   tolua_Error tolua_err;
01727   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'tv_sec'",NULL);
01728   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
01729    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
01730 #endif
01731   self->tv_sec = ((long int)  tolua_tonumber(tolua_S,2,0))
01732 ;
01733  return 0;
01734 }
01735 #endif //#ifndef TOLUA_DISABLE
01736 
01737 /* get function: tv_usec of class  timeval */
01738 #ifndef TOLUA_DISABLE_tolua_get_timeval_tv_usec
01739 static int tolua_get_timeval_tv_usec(lua_State* tolua_S)
01740 {
01741   timeval* self = (timeval*)  tolua_tousertype(tolua_S,1,0);
01742 #ifndef TOLUA_RELEASE
01743   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'tv_usec'",NULL);
01744 #endif
01745   tolua_pushnumber(tolua_S,(lua_Number)self->tv_usec);
01746  return 1;
01747 }
01748 #endif //#ifndef TOLUA_DISABLE
01749 
01750 /* set function: tv_usec of class  timeval */
01751 #ifndef TOLUA_DISABLE_tolua_set_timeval_tv_usec
01752 static int tolua_set_timeval_tv_usec(lua_State* tolua_S)
01753 {
01754   timeval* self = (timeval*)  tolua_tousertype(tolua_S,1,0);
01755 #ifndef TOLUA_RELEASE
01756   tolua_Error tolua_err;
01757   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'tv_usec'",NULL);
01758   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
01759    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
01760 #endif
01761   self->tv_usec = ((long int)  tolua_tonumber(tolua_S,2,0))
01762 ;
01763  return 0;
01764 }
01765 #endif //#ifndef TOLUA_DISABLE
01766 
01767 /* method: new of class  fawkes::Time */
01768 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new00
01769 static int tolua_fawkesutils_fawkes_Time_new00(lua_State* tolua_S)
01770 {
01771 #ifndef TOLUA_RELEASE
01772  tolua_Error tolua_err;
01773  if (
01774      !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
01775      !tolua_isnoobj(tolua_S,2,&tolua_err)
01776  )
01777   goto tolua_lerror;
01778  else
01779 #endif
01780  {
01781   {
01782    fawkes::Time* tolua_ret = (fawkes::Time*)  Mtolua_new((fawkes::Time)());
01783     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
01784   }
01785  }
01786  return 1;
01787 #ifndef TOLUA_RELEASE
01788  tolua_lerror:
01789  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
01790  return 0;
01791 #endif
01792 }
01793 #endif //#ifndef TOLUA_DISABLE
01794 
01795 /* method: new_local of class  fawkes::Time */
01796 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new00_local
01797 static int tolua_fawkesutils_fawkes_Time_new00_local(lua_State* tolua_S)
01798 {
01799 #ifndef TOLUA_RELEASE
01800  tolua_Error tolua_err;
01801  if (
01802      !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
01803      !tolua_isnoobj(tolua_S,2,&tolua_err)
01804  )
01805   goto tolua_lerror;
01806  else
01807 #endif
01808  {
01809   {
01810    fawkes::Time* tolua_ret = (fawkes::Time*)  Mtolua_new((fawkes::Time)());
01811     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
01812     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01813   }
01814  }
01815  return 1;
01816 #ifndef TOLUA_RELEASE
01817  tolua_lerror:
01818  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
01819  return 0;
01820 #endif
01821 }
01822 #endif //#ifndef TOLUA_DISABLE
01823 
01824 /* method: new of class  fawkes::Time */
01825 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new01
01826 static int tolua_fawkesutils_fawkes_Time_new01(lua_State* tolua_S)
01827 {
01828  tolua_Error tolua_err;
01829  if (
01830      !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
01831      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01832      !tolua_isnoobj(tolua_S,3,&tolua_err)
01833  )
01834   goto tolua_lerror;
01835  else
01836  {
01837   long ms = ((long)  tolua_tonumber(tolua_S,2,0));
01838   {
01839    fawkes::Time* tolua_ret = (fawkes::Time*)  Mtolua_new((fawkes::Time)(ms));
01840     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
01841   }
01842  }
01843  return 1;
01844 tolua_lerror:
01845  return tolua_fawkesutils_fawkes_Time_new00(tolua_S);
01846 }
01847 #endif //#ifndef TOLUA_DISABLE
01848 
01849 /* method: new_local of class  fawkes::Time */
01850 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new01_local
01851 static int tolua_fawkesutils_fawkes_Time_new01_local(lua_State* tolua_S)
01852 {
01853  tolua_Error tolua_err;
01854  if (
01855      !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
01856      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01857      !tolua_isnoobj(tolua_S,3,&tolua_err)
01858  )
01859   goto tolua_lerror;
01860  else
01861  {
01862   long ms = ((long)  tolua_tonumber(tolua_S,2,0));
01863   {
01864    fawkes::Time* tolua_ret = (fawkes::Time*)  Mtolua_new((fawkes::Time)(ms));
01865     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
01866     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01867   }
01868  }
01869  return 1;
01870 tolua_lerror:
01871  return tolua_fawkesutils_fawkes_Time_new00_local(tolua_S);
01872 }
01873 #endif //#ifndef TOLUA_DISABLE
01874 
01875 /* method: new of class  fawkes::Time */
01876 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new02
01877 static int tolua_fawkesutils_fawkes_Time_new02(lua_State* tolua_S)
01878 {
01879  tolua_Error tolua_err;
01880  if (
01881      !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
01882      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01883      !tolua_isnoobj(tolua_S,3,&tolua_err)
01884  )
01885   goto tolua_lerror;
01886  else
01887  {
01888   float sec = ((float)  tolua_tonumber(tolua_S,2,0));
01889   {
01890    fawkes::Time* tolua_ret = (fawkes::Time*)  Mtolua_new((fawkes::Time)(sec));
01891     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
01892   }
01893  }
01894  return 1;
01895 tolua_lerror:
01896  return tolua_fawkesutils_fawkes_Time_new01(tolua_S);
01897 }
01898 #endif //#ifndef TOLUA_DISABLE
01899 
01900 /* method: new_local of class  fawkes::Time */
01901 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new02_local
01902 static int tolua_fawkesutils_fawkes_Time_new02_local(lua_State* tolua_S)
01903 {
01904  tolua_Error tolua_err;
01905  if (
01906      !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
01907      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01908      !tolua_isnoobj(tolua_S,3,&tolua_err)
01909  )
01910   goto tolua_lerror;
01911  else
01912  {
01913   float sec = ((float)  tolua_tonumber(tolua_S,2,0));
01914   {
01915    fawkes::Time* tolua_ret = (fawkes::Time*)  Mtolua_new((fawkes::Time)(sec));
01916     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
01917     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01918   }
01919  }
01920  return 1;
01921 tolua_lerror:
01922  return tolua_fawkesutils_fawkes_Time_new01_local(tolua_S);
01923 }
01924 #endif //#ifndef TOLUA_DISABLE
01925 
01926 /* method: new of class  fawkes::Time */
01927 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new03
01928 static int tolua_fawkesutils_fawkes_Time_new03(lua_State* tolua_S)
01929 {
01930  tolua_Error tolua_err;
01931  if (
01932      !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
01933      !tolua_isusertype(tolua_S,2,"fawkes::Clock",0,&tolua_err) ||
01934      !tolua_isnoobj(tolua_S,3,&tolua_err)
01935  )
01936   goto tolua_lerror;
01937  else
01938  {
01939   fawkes::Clock* clock = ((fawkes::Clock*)  tolua_tousertype(tolua_S,2,0));
01940   {
01941    fawkes::Time* tolua_ret = (fawkes::Time*)  Mtolua_new((fawkes::Time)(clock));
01942     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
01943   }
01944  }
01945  return 1;
01946 tolua_lerror:
01947  return tolua_fawkesutils_fawkes_Time_new02(tolua_S);
01948 }
01949 #endif //#ifndef TOLUA_DISABLE
01950 
01951 /* method: new_local of class  fawkes::Time */
01952 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new03_local
01953 static int tolua_fawkesutils_fawkes_Time_new03_local(lua_State* tolua_S)
01954 {
01955  tolua_Error tolua_err;
01956  if (
01957      !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
01958      !tolua_isusertype(tolua_S,2,"fawkes::Clock",0,&tolua_err) ||
01959      !tolua_isnoobj(tolua_S,3,&tolua_err)
01960  )
01961   goto tolua_lerror;
01962  else
01963  {
01964   fawkes::Clock* clock = ((fawkes::Clock*)  tolua_tousertype(tolua_S,2,0));
01965   {
01966    fawkes::Time* tolua_ret = (fawkes::Time*)  Mtolua_new((fawkes::Time)(clock));
01967     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
01968     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01969   }
01970  }
01971  return 1;
01972 tolua_lerror:
01973  return tolua_fawkesutils_fawkes_Time_new02_local(tolua_S);
01974 }
01975 #endif //#ifndef TOLUA_DISABLE
01976 
01977 /* method: new of class  fawkes::Time */
01978 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new04
01979 static int tolua_fawkesutils_fawkes_Time_new04(lua_State* tolua_S)
01980 {
01981  tolua_Error tolua_err;
01982  if (
01983      !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
01984      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::Time",0,&tolua_err)) ||
01985      !tolua_isnoobj(tolua_S,3,&tolua_err)
01986  )
01987   goto tolua_lerror;
01988  else
01989  {
01990   const fawkes::Time* t = ((const fawkes::Time*)  tolua_tousertype(tolua_S,2,0));
01991   {
01992    fawkes::Time* tolua_ret = (fawkes::Time*)  Mtolua_new((fawkes::Time)(*t));
01993     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
01994   }
01995  }
01996  return 1;
01997 tolua_lerror:
01998  return tolua_fawkesutils_fawkes_Time_new03(tolua_S);
01999 }
02000 #endif //#ifndef TOLUA_DISABLE
02001 
02002 /* method: new_local of class  fawkes::Time */
02003 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new04_local
02004 static int tolua_fawkesutils_fawkes_Time_new04_local(lua_State* tolua_S)
02005 {
02006  tolua_Error tolua_err;
02007  if (
02008      !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
02009      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::Time",0,&tolua_err)) ||
02010      !tolua_isnoobj(tolua_S,3,&tolua_err)
02011  )
02012   goto tolua_lerror;
02013  else
02014  {
02015   const fawkes::Time* t = ((const fawkes::Time*)  tolua_tousertype(tolua_S,2,0));
02016   {
02017    fawkes::Time* tolua_ret = (fawkes::Time*)  Mtolua_new((fawkes::Time)(*t));
02018     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
02019     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
02020   }
02021  }
02022  return 1;
02023 tolua_lerror:
02024  return tolua_fawkesutils_fawkes_Time_new03_local(tolua_S);
02025 }
02026 #endif //#ifndef TOLUA_DISABLE
02027 
02028 /* method: new of class  fawkes::Time */
02029 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new05
02030 static int tolua_fawkesutils_fawkes_Time_new05(lua_State* tolua_S)
02031 {
02032  tolua_Error tolua_err;
02033  if (
02034      !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
02035      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02036      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
02037      !tolua_isnoobj(tolua_S,4,&tolua_err)
02038  )
02039   goto tolua_lerror;
02040  else
02041  {
02042   long sec = ((long)  tolua_tonumber(tolua_S,2,0));
02043   long usec = ((long)  tolua_tonumber(tolua_S,3,0));
02044   {
02045    fawkes::Time* tolua_ret = (fawkes::Time*)  Mtolua_new((fawkes::Time)(sec,usec));
02046     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
02047   }
02048  }
02049  return 1;
02050 tolua_lerror:
02051  return tolua_fawkesutils_fawkes_Time_new04(tolua_S);
02052 }
02053 #endif //#ifndef TOLUA_DISABLE
02054 
02055 /* method: new_local of class  fawkes::Time */
02056 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new05_local
02057 static int tolua_fawkesutils_fawkes_Time_new05_local(lua_State* tolua_S)
02058 {
02059  tolua_Error tolua_err;
02060  if (
02061      !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
02062      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02063      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
02064      !tolua_isnoobj(tolua_S,4,&tolua_err)
02065  )
02066   goto tolua_lerror;
02067  else
02068  {
02069   long sec = ((long)  tolua_tonumber(tolua_S,2,0));
02070   long usec = ((long)  tolua_tonumber(tolua_S,3,0));
02071   {
02072    fawkes::Time* tolua_ret = (fawkes::Time*)  Mtolua_new((fawkes::Time)(sec,usec));
02073     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
02074     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
02075   }
02076  }
02077  return 1;
02078 tolua_lerror:
02079  return tolua_fawkesutils_fawkes_Time_new04_local(tolua_S);
02080 }
02081 #endif //#ifndef TOLUA_DISABLE
02082 
02083 /* method: new of class  fawkes::Time */
02084 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new06
02085 static int tolua_fawkesutils_fawkes_Time_new06(lua_State* tolua_S)
02086 {
02087  tolua_Error tolua_err;
02088  if (
02089      !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
02090      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02091      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
02092      !tolua_isusertype(tolua_S,4,"fawkes::Clock",0,&tolua_err) ||
02093      !tolua_isnoobj(tolua_S,5,&tolua_err)
02094  )
02095   goto tolua_lerror;
02096  else
02097  {
02098   long sec = ((long)  tolua_tonumber(tolua_S,2,0));
02099   long usec = ((long)  tolua_tonumber(tolua_S,3,0));
02100   fawkes::Clock* clock = ((fawkes::Clock*)  tolua_tousertype(tolua_S,4,0));
02101   {
02102    fawkes::Time* tolua_ret = (fawkes::Time*)  Mtolua_new((fawkes::Time)(sec,usec,clock));
02103     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
02104   }
02105  }
02106  return 1;
02107 tolua_lerror:
02108  return tolua_fawkesutils_fawkes_Time_new05(tolua_S);
02109 }
02110 #endif //#ifndef TOLUA_DISABLE
02111 
02112 /* method: new_local of class  fawkes::Time */
02113 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new06_local
02114 static int tolua_fawkesutils_fawkes_Time_new06_local(lua_State* tolua_S)
02115 {
02116  tolua_Error tolua_err;
02117  if (
02118      !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
02119      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02120      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
02121      !tolua_isusertype(tolua_S,4,"fawkes::Clock",0,&tolua_err) ||
02122      !tolua_isnoobj(tolua_S,5,&tolua_err)
02123  )
02124   goto tolua_lerror;
02125  else
02126  {
02127   long sec = ((long)  tolua_tonumber(tolua_S,2,0));
02128   long usec = ((long)  tolua_tonumber(tolua_S,3,0));
02129   fawkes::Clock* clock = ((fawkes::Clock*)  tolua_tousertype(tolua_S,4,0));
02130   {
02131    fawkes::Time* tolua_ret = (fawkes::Time*)  Mtolua_new((fawkes::Time)(sec,usec,clock));
02132     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
02133     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
02134   }
02135  }
02136  return 1;
02137 tolua_lerror:
02138  return tolua_fawkesutils_fawkes_Time_new05_local(tolua_S);
02139 }
02140 #endif //#ifndef TOLUA_DISABLE
02141 
02142 /* method: delete of class  fawkes::Time */
02143 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_delete00
02144 static int tolua_fawkesutils_fawkes_Time_delete00(lua_State* tolua_S)
02145 {
02146 #ifndef TOLUA_RELEASE
02147  tolua_Error tolua_err;
02148  if (
02149      !tolua_isusertype(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
02150      !tolua_isnoobj(tolua_S,2,&tolua_err)
02151  )
02152   goto tolua_lerror;
02153  else
02154 #endif
02155  {
02156   fawkes::Time* self = (fawkes::Time*)  tolua_tousertype(tolua_S,1,0);
02157 #ifndef TOLUA_RELEASE
02158   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
02159 #endif
02160   Mtolua_delete(self);
02161  }
02162  return 0;
02163 #ifndef TOLUA_RELEASE
02164  tolua_lerror:
02165  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
02166  return 0;
02167 #endif
02168 }
02169 #endif //#ifndef TOLUA_DISABLE
02170 
02171 /* method: in_sec of class  fawkes::Time */
02172 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_in_sec00
02173 static int tolua_fawkesutils_fawkes_Time_in_sec00(lua_State* tolua_S)
02174 {
02175 #ifndef TOLUA_RELEASE
02176  tolua_Error tolua_err;
02177  if (
02178      !tolua_isusertype(tolua_S,1,"const fawkes::Time",0,&tolua_err) ||
02179      !tolua_isnoobj(tolua_S,2,&tolua_err)
02180  )
02181   goto tolua_lerror;
02182  else
02183 #endif
02184  {
02185   const fawkes::Time* self = (const fawkes::Time*)  tolua_tousertype(tolua_S,1,0);
02186 #ifndef TOLUA_RELEASE
02187   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'in_sec'", NULL);
02188 #endif
02189   {
02190    float tolua_ret = (float)  self->in_sec();
02191    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02192   }
02193  }
02194  return 1;
02195 #ifndef TOLUA_RELEASE
02196  tolua_lerror:
02197  tolua_error(tolua_S,"#ferror in function 'in_sec'.",&tolua_err);
02198  return 0;
02199 #endif
02200 }
02201 #endif //#ifndef TOLUA_DISABLE
02202 
02203 /* method: in_msec of class  fawkes::Time */
02204 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_in_msec00
02205 static int tolua_fawkesutils_fawkes_Time_in_msec00(lua_State* tolua_S)
02206 {
02207 #ifndef TOLUA_RELEASE
02208  tolua_Error tolua_err;
02209  if (
02210      !tolua_isusertype(tolua_S,1,"const fawkes::Time",0,&tolua_err) ||
02211      !tolua_isnoobj(tolua_S,2,&tolua_err)
02212  )
02213   goto tolua_lerror;
02214  else
02215 #endif
02216  {
02217   const fawkes::Time* self = (const fawkes::Time*)  tolua_tousertype(tolua_S,1,0);
02218 #ifndef TOLUA_RELEASE
02219   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'in_msec'", NULL);
02220 #endif
02221   {
02222    long tolua_ret = (long)  self->in_msec();
02223    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02224   }
02225  }
02226  return 1;
02227 #ifndef TOLUA_RELEASE
02228  tolua_lerror:
02229  tolua_error(tolua_S,"#ferror in function 'in_msec'.",&tolua_err);
02230  return 0;
02231 #endif
02232 }
02233 #endif //#ifndef TOLUA_DISABLE
02234 
02235 /* method: in_usec of class  fawkes::Time */
02236 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_in_usec00
02237 static int tolua_fawkesutils_fawkes_Time_in_usec00(lua_State* tolua_S)
02238 {
02239 #ifndef TOLUA_RELEASE
02240  tolua_Error tolua_err;
02241  if (
02242      !tolua_isusertype(tolua_S,1,"const fawkes::Time",0,&tolua_err) ||
02243      !tolua_isnoobj(tolua_S,2,&tolua_err)
02244  )
02245   goto tolua_lerror;
02246  else
02247 #endif
02248  {
02249   const fawkes::Time* self = (const fawkes::Time*)  tolua_tousertype(tolua_S,1,0);
02250 #ifndef TOLUA_RELEASE
02251   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'in_usec'", NULL);
02252 #endif
02253   {
02254    long tolua_ret = (long)  self->in_usec();
02255    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02256   }
02257  }
02258  return 1;
02259 #ifndef TOLUA_RELEASE
02260  tolua_lerror:
02261  tolua_error(tolua_S,"#ferror in function 'in_usec'.",&tolua_err);
02262  return 0;
02263 #endif
02264 }
02265 #endif //#ifndef TOLUA_DISABLE
02266 
02267 /* method: get_timeval of class  fawkes::Time */
02268 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_get_timeval00
02269 static int tolua_fawkesutils_fawkes_Time_get_timeval00(lua_State* tolua_S)
02270 {
02271 #ifndef TOLUA_RELEASE
02272  tolua_Error tolua_err;
02273  if (
02274      !tolua_isusertype(tolua_S,1,"const fawkes::Time",0,&tolua_err) ||
02275      !tolua_isnoobj(tolua_S,2,&tolua_err)
02276  )
02277   goto tolua_lerror;
02278  else
02279 #endif
02280  {
02281   const fawkes::Time* self = (const fawkes::Time*)  tolua_tousertype(tolua_S,1,0);
02282 #ifndef TOLUA_RELEASE
02283   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_timeval'", NULL);
02284 #endif
02285   {
02286    const timeval* tolua_ret = (const timeval*)  self->get_timeval();
02287     tolua_pushusertype(tolua_S,(void*)tolua_ret,"const timeval");
02288   }
02289  }
02290  return 1;
02291 #ifndef TOLUA_RELEASE
02292  tolua_lerror:
02293  tolua_error(tolua_S,"#ferror in function 'get_timeval'.",&tolua_err);
02294  return 0;
02295 #endif
02296 }
02297 #endif //#ifndef TOLUA_DISABLE
02298 
02299 /* method: set_time of class  fawkes::Time */
02300 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_set_time00
02301 static int tolua_fawkesutils_fawkes_Time_set_time00(lua_State* tolua_S)
02302 {
02303 #ifndef TOLUA_RELEASE
02304  tolua_Error tolua_err;
02305  if (
02306      !tolua_isusertype(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
02307      !tolua_isusertype(tolua_S,2,"const timeval",0,&tolua_err) ||
02308      !tolua_isnoobj(tolua_S,3,&tolua_err)
02309  )
02310   goto tolua_lerror;
02311  else
02312 #endif
02313  {
02314   fawkes::Time* self = (fawkes::Time*)  tolua_tousertype(tolua_S,1,0);
02315   const timeval* tv = ((const timeval*)  tolua_tousertype(tolua_S,2,0));
02316 #ifndef TOLUA_RELEASE
02317   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_time'", NULL);
02318 #endif
02319   {
02320    self->set_time(tv);
02321   }
02322  }
02323  return 0;
02324 #ifndef TOLUA_RELEASE
02325  tolua_lerror:
02326  tolua_error(tolua_S,"#ferror in function 'set_time'.",&tolua_err);
02327  return 0;
02328 #endif
02329 }
02330 #endif //#ifndef TOLUA_DISABLE
02331 
02332 /* method: set_time of class  fawkes::Time */
02333 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_set_time01
02334 static int tolua_fawkesutils_fawkes_Time_set_time01(lua_State* tolua_S)
02335 {
02336  tolua_Error tolua_err;
02337  if (
02338      !tolua_isusertype(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
02339      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02340      !tolua_isnoobj(tolua_S,3,&tolua_err)
02341  )
02342   goto tolua_lerror;
02343  else
02344  {
02345   fawkes::Time* self = (fawkes::Time*)  tolua_tousertype(tolua_S,1,0);
02346   long ms = ((long)  tolua_tonumber(tolua_S,2,0));
02347 #ifndef TOLUA_RELEASE
02348   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_time'", NULL);
02349 #endif
02350   {
02351    self->set_time(ms);
02352   }
02353  }
02354  return 0;
02355 tolua_lerror:
02356  return tolua_fawkesutils_fawkes_Time_set_time00(tolua_S);
02357 }
02358 #endif //#ifndef TOLUA_DISABLE
02359 
02360 /* method: set_time of class  fawkes::Time */
02361 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_set_time02
02362 static int tolua_fawkesutils_fawkes_Time_set_time02(lua_State* tolua_S)
02363 {
02364  tolua_Error tolua_err;
02365  if (
02366      !tolua_isusertype(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
02367      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02368      !tolua_isnoobj(tolua_S,3,&tolua_err)
02369  )
02370   goto tolua_lerror;
02371  else
02372  {
02373   fawkes::Time* self = (fawkes::Time*)  tolua_tousertype(tolua_S,1,0);
02374   float sec = ((float)  tolua_tonumber(tolua_S,2,0));
02375 #ifndef TOLUA_RELEASE
02376   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_time'", NULL);
02377 #endif
02378   {
02379    self->set_time(sec);
02380   }
02381  }
02382  return 0;
02383 tolua_lerror:
02384  return tolua_fawkesutils_fawkes_Time_set_time01(tolua_S);
02385 }
02386 #endif //#ifndef TOLUA_DISABLE
02387 
02388 /* method: set_time of class  fawkes::Time */
02389 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_set_time03
02390 static int tolua_fawkesutils_fawkes_Time_set_time03(lua_State* tolua_S)
02391 {
02392  tolua_Error tolua_err;
02393  if (
02394      !tolua_isusertype(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
02395      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::Time",0,&tolua_err)) ||
02396      !tolua_isnoobj(tolua_S,3,&tolua_err)
02397  )
02398   goto tolua_lerror;
02399  else
02400  {
02401   fawkes::Time* self = (fawkes::Time*)  tolua_tousertype(tolua_S,1,0);
02402   const fawkes::Time* t = ((const fawkes::Time*)  tolua_tousertype(tolua_S,2,0));
02403 #ifndef TOLUA_RELEASE
02404   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_time'", NULL);
02405 #endif
02406   {
02407    self->set_time(*t);
02408   }
02409  }
02410  return 0;
02411 tolua_lerror:
02412  return tolua_fawkesutils_fawkes_Time_set_time02(tolua_S);
02413 }
02414 #endif //#ifndef TOLUA_DISABLE
02415 
02416 /* method: add of class  fawkes::Time */
02417 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_add00
02418 static int tolua_fawkesutils_fawkes_Time_add00(lua_State* tolua_S)
02419 {
02420 #ifndef TOLUA_RELEASE
02421  tolua_Error tolua_err;
02422  if (
02423      !tolua_isusertype(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
02424      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02425      !tolua_isnoobj(tolua_S,3,&tolua_err)
02426  )
02427   goto tolua_lerror;
02428  else
02429 #endif
02430  {
02431   fawkes::Time* self = (fawkes::Time*)  tolua_tousertype(tolua_S,1,0);
02432   float seconds = ((float)  tolua_tonumber(tolua_S,2,0));
02433 #ifndef TOLUA_RELEASE
02434   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'add'", NULL);
02435 #endif
02436   {
02437    self->add(seconds);
02438   }
02439  }
02440  return 0;
02441 #ifndef TOLUA_RELEASE
02442  tolua_lerror:
02443  tolua_error(tolua_S,"#ferror in function 'add'.",&tolua_err);
02444  return 0;
02445 #endif
02446 }
02447 #endif //#ifndef TOLUA_DISABLE
02448 
02449 /* method: stamp of class  fawkes::Time */
02450 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_stamp00
02451 static int tolua_fawkesutils_fawkes_Time_stamp00(lua_State* tolua_S)
02452 {
02453 #ifndef TOLUA_RELEASE
02454  tolua_Error tolua_err;
02455  if (
02456      !tolua_isusertype(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
02457      !tolua_isnoobj(tolua_S,2,&tolua_err)
02458  )
02459   goto tolua_lerror;
02460  else
02461 #endif
02462  {
02463   fawkes::Time* self = (fawkes::Time*)  tolua_tousertype(tolua_S,1,0);
02464 #ifndef TOLUA_RELEASE
02465   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'stamp'", NULL);
02466 #endif
02467   {
02468    fawkes::Time& tolua_ret = (fawkes::Time&)  self->stamp();
02469     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"fawkes::Time");
02470   }
02471  }
02472  return 1;
02473 #ifndef TOLUA_RELEASE
02474  tolua_lerror:
02475  tolua_error(tolua_S,"#ferror in function 'stamp'.",&tolua_err);
02476  return 0;
02477 #endif
02478 }
02479 #endif //#ifndef TOLUA_DISABLE
02480 
02481 /* method: operator+ of class  fawkes::Time */
02482 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time__add00
02483 static int tolua_fawkesutils_fawkes_Time__add00(lua_State* tolua_S)
02484 {
02485 #ifndef TOLUA_RELEASE
02486  tolua_Error tolua_err;
02487  if (
02488      !tolua_isusertype(tolua_S,1,"const fawkes::Time",0,&tolua_err) ||
02489      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::Time",0,&tolua_err)) ||
02490      !tolua_isnoobj(tolua_S,3,&tolua_err)
02491  )
02492   goto tolua_lerror;
02493  else
02494 #endif
02495  {
02496   const fawkes::Time* self = (const fawkes::Time*)  tolua_tousertype(tolua_S,1,0);
02497   const fawkes::Time* t = ((const fawkes::Time*)  tolua_tousertype(tolua_S,2,0));
02498 #ifndef TOLUA_RELEASE
02499   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator+'", NULL);
02500 #endif
02501   {
02502    fawkes::Time tolua_ret = (fawkes::Time)  self->operator+(*t);
02503    {
02504 #ifdef __cplusplus
02505     void* tolua_obj = Mtolua_new((fawkes::Time)(tolua_ret));
02506      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::Time");
02507     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
02508 #else
02509     void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::Time));
02510      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::Time");
02511     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
02512 #endif
02513    }
02514   }
02515  }
02516  return 1;
02517 #ifndef TOLUA_RELEASE
02518  tolua_lerror:
02519  tolua_error(tolua_S,"#ferror in function '.add'.",&tolua_err);
02520  return 0;
02521 #endif
02522 }
02523 #endif //#ifndef TOLUA_DISABLE
02524 
02525 /* method: operator- of class  fawkes::Time */
02526 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time__sub00
02527 static int tolua_fawkesutils_fawkes_Time__sub00(lua_State* tolua_S)
02528 {
02529 #ifndef TOLUA_RELEASE
02530  tolua_Error tolua_err;
02531  if (
02532      !tolua_isusertype(tolua_S,1,"const fawkes::Time",0,&tolua_err) ||
02533      !tolua_isusertype(tolua_S,2,"const fawkes::Time",0,&tolua_err) ||
02534      !tolua_isnoobj(tolua_S,3,&tolua_err)
02535  )
02536   goto tolua_lerror;
02537  else
02538 #endif
02539  {
02540   const fawkes::Time* self = (const fawkes::Time*)  tolua_tousertype(tolua_S,1,0);
02541   const fawkes::Time* t = ((const fawkes::Time*)  tolua_tousertype(tolua_S,2,0));
02542 #ifndef TOLUA_RELEASE
02543   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator-'", NULL);
02544 #endif
02545   {
02546    float tolua_ret = (float)  self->operator-(t);
02547    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02548   }
02549  }
02550  return 1;
02551 #ifndef TOLUA_RELEASE
02552  tolua_lerror:
02553  tolua_error(tolua_S,"#ferror in function '.sub'.",&tolua_err);
02554  return 0;
02555 #endif
02556 }
02557 #endif //#ifndef TOLUA_DISABLE
02558 
02559 /* method: str of class  fawkes::Time */
02560 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_str00
02561 static int tolua_fawkesutils_fawkes_Time_str00(lua_State* tolua_S)
02562 {
02563 #ifndef TOLUA_RELEASE
02564  tolua_Error tolua_err;
02565  if (
02566      !tolua_isusertype(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
02567      !tolua_isnoobj(tolua_S,2,&tolua_err)
02568  )
02569   goto tolua_lerror;
02570  else
02571 #endif
02572  {
02573   fawkes::Time* self = (fawkes::Time*)  tolua_tousertype(tolua_S,1,0);
02574 #ifndef TOLUA_RELEASE
02575   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'str'", NULL);
02576 #endif
02577   {
02578    const char* tolua_ret = (const char*)  self->str();
02579    tolua_pushstring(tolua_S,(const char*)tolua_ret);
02580   }
02581  }
02582  return 1;
02583 #ifndef TOLUA_RELEASE
02584  tolua_lerror:
02585  tolua_error(tolua_S,"#ferror in function 'str'.",&tolua_err);
02586  return 0;
02587 #endif
02588 }
02589 #endif //#ifndef TOLUA_DISABLE
02590 
02591 /* method: str_r of class  fawkes::Time */
02592 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_str_r00
02593 static int tolua_fawkesutils_fawkes_Time_str_r00(lua_State* tolua_S)
02594 {
02595 #ifndef TOLUA_RELEASE
02596  tolua_Error tolua_err;
02597  if (
02598      !tolua_isusertype(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
02599      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
02600      !tolua_isnoobj(tolua_S,3,&tolua_err)
02601  )
02602   goto tolua_lerror;
02603  else
02604 #endif
02605  {
02606   fawkes::Time* self = (fawkes::Time*)  tolua_tousertype(tolua_S,1,0);
02607   char* s = ((char*)  tolua_tostring(tolua_S,2,0));
02608 #ifndef TOLUA_RELEASE
02609   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'str_r'", NULL);
02610 #endif
02611   {
02612    self->str_r(s);
02613   }
02614  }
02615  return 0;
02616 #ifndef TOLUA_RELEASE
02617  tolua_lerror:
02618  tolua_error(tolua_S,"#ferror in function 'str_r'.",&tolua_err);
02619  return 0;
02620 #endif
02621 }
02622 #endif //#ifndef TOLUA_DISABLE
02623 
02624 /* method: instance of class  fawkes::Clock */
02625 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_instance00
02626 static int tolua_fawkesutils_fawkes_Clock_instance00(lua_State* tolua_S)
02627 {
02628 #ifndef TOLUA_RELEASE
02629  tolua_Error tolua_err;
02630  if (
02631      !tolua_isusertable(tolua_S,1,"fawkes::Clock",0,&tolua_err) ||
02632      !tolua_isnoobj(tolua_S,2,&tolua_err)
02633  )
02634   goto tolua_lerror;
02635  else
02636 #endif
02637  {
02638   {
02639    fawkes::Clock* tolua_ret = (fawkes::Clock*)  fawkes::Clock::instance();
02640     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Clock");
02641   }
02642  }
02643  return 1;
02644 #ifndef TOLUA_RELEASE
02645  tolua_lerror:
02646  tolua_error(tolua_S,"#ferror in function 'instance'.",&tolua_err);
02647  return 0;
02648 #endif
02649 }
02650 #endif //#ifndef TOLUA_DISABLE
02651 
02652 /* method: finalize of class  fawkes::Clock */
02653 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_finalize00
02654 static int tolua_fawkesutils_fawkes_Clock_finalize00(lua_State* tolua_S)
02655 {
02656 #ifndef TOLUA_RELEASE
02657  tolua_Error tolua_err;
02658  if (
02659      !tolua_isusertable(tolua_S,1,"fawkes::Clock",0,&tolua_err) ||
02660      !tolua_isnoobj(tolua_S,2,&tolua_err)
02661  )
02662   goto tolua_lerror;
02663  else
02664 #endif
02665  {
02666   {
02667    fawkes::Clock::finalize();
02668   }
02669  }
02670  return 0;
02671 #ifndef TOLUA_RELEASE
02672  tolua_lerror:
02673  tolua_error(tolua_S,"#ferror in function 'finalize'.",&tolua_err);
02674  return 0;
02675 #endif
02676 }
02677 #endif //#ifndef TOLUA_DISABLE
02678 
02679 /* method: is_ext_default_timesource of class  fawkes::Clock */
02680 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_is_ext_default_timesource00
02681 static int tolua_fawkesutils_fawkes_Clock_is_ext_default_timesource00(lua_State* tolua_S)
02682 {
02683 #ifndef TOLUA_RELEASE
02684  tolua_Error tolua_err;
02685  if (
02686      !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
02687      !tolua_isnoobj(tolua_S,2,&tolua_err)
02688  )
02689   goto tolua_lerror;
02690  else
02691 #endif
02692  {
02693   const fawkes::Clock* self = (const fawkes::Clock*)  tolua_tousertype(tolua_S,1,0);
02694 #ifndef TOLUA_RELEASE
02695   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_ext_default_timesource'", NULL);
02696 #endif
02697   {
02698    bool tolua_ret = (bool)  self->is_ext_default_timesource();
02699    tolua_pushboolean(tolua_S,(bool)tolua_ret);
02700   }
02701  }
02702  return 1;
02703 #ifndef TOLUA_RELEASE
02704  tolua_lerror:
02705  tolua_error(tolua_S,"#ferror in function 'is_ext_default_timesource'.",&tolua_err);
02706  return 0;
02707 #endif
02708 }
02709 #endif //#ifndef TOLUA_DISABLE
02710 
02711 /* method: has_ext_timesource of class  fawkes::Clock */
02712 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_has_ext_timesource00
02713 static int tolua_fawkesutils_fawkes_Clock_has_ext_timesource00(lua_State* tolua_S)
02714 {
02715 #ifndef TOLUA_RELEASE
02716  tolua_Error tolua_err;
02717  if (
02718      !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
02719      !tolua_isnoobj(tolua_S,2,&tolua_err)
02720  )
02721   goto tolua_lerror;
02722  else
02723 #endif
02724  {
02725   const fawkes::Clock* self = (const fawkes::Clock*)  tolua_tousertype(tolua_S,1,0);
02726 #ifndef TOLUA_RELEASE
02727   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'has_ext_timesource'", NULL);
02728 #endif
02729   {
02730    bool tolua_ret = (bool)  self->has_ext_timesource();
02731    tolua_pushboolean(tolua_S,(bool)tolua_ret);
02732   }
02733  }
02734  return 1;
02735 #ifndef TOLUA_RELEASE
02736  tolua_lerror:
02737  tolua_error(tolua_S,"#ferror in function 'has_ext_timesource'.",&tolua_err);
02738  return 0;
02739 #endif
02740 }
02741 #endif //#ifndef TOLUA_DISABLE
02742 
02743 /* method: ext_to_realtime of class  fawkes::Clock */
02744 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_ext_to_realtime00
02745 static int tolua_fawkesutils_fawkes_Clock_ext_to_realtime00(lua_State* tolua_S)
02746 {
02747 #ifndef TOLUA_RELEASE
02748  tolua_Error tolua_err;
02749  if (
02750      !tolua_isusertype(tolua_S,1,"fawkes::Clock",0,&tolua_err) ||
02751      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::Time",0,&tolua_err)) ||
02752      !tolua_isnoobj(tolua_S,3,&tolua_err)
02753  )
02754   goto tolua_lerror;
02755  else
02756 #endif
02757  {
02758   fawkes::Clock* self = (fawkes::Clock*)  tolua_tousertype(tolua_S,1,0);
02759   const fawkes::Time* t = ((const fawkes::Time*)  tolua_tousertype(tolua_S,2,0));
02760 #ifndef TOLUA_RELEASE
02761   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ext_to_realtime'", NULL);
02762 #endif
02763   {
02764    fawkes::Time tolua_ret = (fawkes::Time)  self->ext_to_realtime(*t);
02765    {
02766 #ifdef __cplusplus
02767     void* tolua_obj = Mtolua_new((fawkes::Time)(tolua_ret));
02768      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::Time");
02769     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
02770 #else
02771     void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::Time));
02772      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::Time");
02773     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
02774 #endif
02775    }
02776   }
02777  }
02778  return 1;
02779 #ifndef TOLUA_RELEASE
02780  tolua_lerror:
02781  tolua_error(tolua_S,"#ferror in function 'ext_to_realtime'.",&tolua_err);
02782  return 0;
02783 #endif
02784 }
02785 #endif //#ifndef TOLUA_DISABLE
02786 
02787 /* method: get_time of class  fawkes::Clock */
02788 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_get_time00
02789 static int tolua_fawkesutils_fawkes_Clock_get_time00(lua_State* tolua_S)
02790 {
02791 #ifndef TOLUA_RELEASE
02792  tolua_Error tolua_err;
02793  if (
02794      !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
02795      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"fawkes::Time",0,&tolua_err)) ||
02796      !tolua_isnoobj(tolua_S,3,&tolua_err)
02797  )
02798   goto tolua_lerror;
02799  else
02800 #endif
02801  {
02802   const fawkes::Clock* self = (const fawkes::Clock*)  tolua_tousertype(tolua_S,1,0);
02803   fawkes::Time* time = ((fawkes::Time*)  tolua_tousertype(tolua_S,2,0));
02804 #ifndef TOLUA_RELEASE
02805   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_time'", NULL);
02806 #endif
02807   {
02808    self->get_time(*time);
02809   }
02810  }
02811  return 0;
02812 #ifndef TOLUA_RELEASE
02813  tolua_lerror:
02814  tolua_error(tolua_S,"#ferror in function 'get_time'.",&tolua_err);
02815  return 0;
02816 #endif
02817 }
02818 #endif //#ifndef TOLUA_DISABLE
02819 
02820 /* method: get_time of class  fawkes::Clock */
02821 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_get_time01
02822 static int tolua_fawkesutils_fawkes_Clock_get_time01(lua_State* tolua_S)
02823 {
02824  tolua_Error tolua_err;
02825  if (
02826      !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
02827      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"fawkes::Time",0,&tolua_err)) ||
02828      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
02829      !tolua_isnoobj(tolua_S,4,&tolua_err)
02830  )
02831   goto tolua_lerror;
02832  else
02833  {
02834   const fawkes::Clock* self = (const fawkes::Clock*)  tolua_tousertype(tolua_S,1,0);
02835   fawkes::Time* time = ((fawkes::Time*)  tolua_tousertype(tolua_S,2,0));
02836   fawkes::Clock::TimesourceSelector sel = ((fawkes::Clock::TimesourceSelector) (int)  tolua_tonumber(tolua_S,3,0));
02837 #ifndef TOLUA_RELEASE
02838   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_time'", NULL);
02839 #endif
02840   {
02841    self->get_time(*time,sel);
02842   }
02843  }
02844  return 0;
02845 tolua_lerror:
02846  return tolua_fawkesutils_fawkes_Clock_get_time00(tolua_S);
02847 }
02848 #endif //#ifndef TOLUA_DISABLE
02849 
02850 /* method: get_time of class  fawkes::Clock */
02851 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_get_time02
02852 static int tolua_fawkesutils_fawkes_Clock_get_time02(lua_State* tolua_S)
02853 {
02854  tolua_Error tolua_err;
02855  if (
02856      !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
02857      !tolua_isusertype(tolua_S,2,"fawkes::Time",0,&tolua_err) ||
02858      !tolua_isnoobj(tolua_S,3,&tolua_err)
02859  )
02860   goto tolua_lerror;
02861  else
02862  {
02863   const fawkes::Clock* self = (const fawkes::Clock*)  tolua_tousertype(tolua_S,1,0);
02864   fawkes::Time* time = ((fawkes::Time*)  tolua_tousertype(tolua_S,2,0));
02865 #ifndef TOLUA_RELEASE
02866   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_time'", NULL);
02867 #endif
02868   {
02869    self->get_time(time);
02870   }
02871  }
02872  return 0;
02873 tolua_lerror:
02874  return tolua_fawkesutils_fawkes_Clock_get_time01(tolua_S);
02875 }
02876 #endif //#ifndef TOLUA_DISABLE
02877 
02878 /* method: get_time of class  fawkes::Clock */
02879 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_get_time03
02880 static int tolua_fawkesutils_fawkes_Clock_get_time03(lua_State* tolua_S)
02881 {
02882  tolua_Error tolua_err;
02883  if (
02884      !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
02885      !tolua_isusertype(tolua_S,2,"fawkes::Time",0,&tolua_err) ||
02886      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
02887      !tolua_isnoobj(tolua_S,4,&tolua_err)
02888  )
02889   goto tolua_lerror;
02890  else
02891  {
02892   const fawkes::Clock* self = (const fawkes::Clock*)  tolua_tousertype(tolua_S,1,0);
02893   fawkes::Time* time = ((fawkes::Time*)  tolua_tousertype(tolua_S,2,0));
02894   fawkes::Clock::TimesourceSelector sel = ((fawkes::Clock::TimesourceSelector) (int)  tolua_tonumber(tolua_S,3,0));
02895 #ifndef TOLUA_RELEASE
02896   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_time'", NULL);
02897 #endif
02898   {
02899    self->get_time(time,sel);
02900   }
02901  }
02902  return 0;
02903 tolua_lerror:
02904  return tolua_fawkesutils_fawkes_Clock_get_time02(tolua_S);
02905 }
02906 #endif //#ifndef TOLUA_DISABLE
02907 
02908 /* method: get_time of class  fawkes::Clock */
02909 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_get_time04
02910 static int tolua_fawkesutils_fawkes_Clock_get_time04(lua_State* tolua_S)
02911 {
02912  tolua_Error tolua_err;
02913  if (
02914      !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
02915      !tolua_isusertype(tolua_S,2,"timeval",0,&tolua_err) ||
02916      !tolua_isnoobj(tolua_S,3,&tolua_err)
02917  )
02918   goto tolua_lerror;
02919  else
02920  {
02921   const fawkes::Clock* self = (const fawkes::Clock*)  tolua_tousertype(tolua_S,1,0);
02922   struct timeval* tv = ((struct timeval*)  tolua_tousertype(tolua_S,2,0));
02923 #ifndef TOLUA_RELEASE
02924   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_time'", NULL);
02925 #endif
02926   {
02927    self->get_time(tv);
02928   }
02929  }
02930  return 0;
02931 tolua_lerror:
02932  return tolua_fawkesutils_fawkes_Clock_get_time03(tolua_S);
02933 }
02934 #endif //#ifndef TOLUA_DISABLE
02935 
02936 /* method: get_time of class  fawkes::Clock */
02937 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_get_time05
02938 static int tolua_fawkesutils_fawkes_Clock_get_time05(lua_State* tolua_S)
02939 {
02940  tolua_Error tolua_err;
02941  if (
02942      !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
02943      !tolua_isusertype(tolua_S,2,"timeval",0,&tolua_err) ||
02944      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
02945      !tolua_isnoobj(tolua_S,4,&tolua_err)
02946  )
02947   goto tolua_lerror;
02948  else
02949  {
02950   const fawkes::Clock* self = (const fawkes::Clock*)  tolua_tousertype(tolua_S,1,0);
02951   struct timeval* tv = ((struct timeval*)  tolua_tousertype(tolua_S,2,0));
02952   fawkes::Clock::TimesourceSelector sel = ((fawkes::Clock::TimesourceSelector) (int)  tolua_tonumber(tolua_S,3,0));
02953 #ifndef TOLUA_RELEASE
02954   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_time'", NULL);
02955 #endif
02956   {
02957    self->get_time(tv,sel);
02958   }
02959  }
02960  return 0;
02961 tolua_lerror:
02962  return tolua_fawkesutils_fawkes_Clock_get_time04(tolua_S);
02963 }
02964 #endif //#ifndef TOLUA_DISABLE
02965 
02966 /* method: get_systime of class  fawkes::Clock */
02967 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_get_systime00
02968 static int tolua_fawkesutils_fawkes_Clock_get_systime00(lua_State* tolua_S)
02969 {
02970 #ifndef TOLUA_RELEASE
02971  tolua_Error tolua_err;
02972  if (
02973      !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
02974      !tolua_isusertype(tolua_S,2,"timeval",0,&tolua_err) ||
02975      !tolua_isnoobj(tolua_S,3,&tolua_err)
02976  )
02977   goto tolua_lerror;
02978  else
02979 #endif
02980  {
02981   const fawkes::Clock* self = (const fawkes::Clock*)  tolua_tousertype(tolua_S,1,0);
02982   struct timeval* tv = ((struct timeval*)  tolua_tousertype(tolua_S,2,0));
02983 #ifndef TOLUA_RELEASE
02984   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_systime'", NULL);
02985 #endif
02986   {
02987    self->get_systime(tv);
02988   }
02989  }
02990  return 0;
02991 #ifndef TOLUA_RELEASE
02992  tolua_lerror:
02993  tolua_error(tolua_S,"#ferror in function 'get_systime'.",&tolua_err);
02994  return 0;
02995 #endif
02996 }
02997 #endif //#ifndef TOLUA_DISABLE
02998 
02999 /* method: get_systime of class  fawkes::Clock */
03000 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_get_systime01
03001 static int tolua_fawkesutils_fawkes_Clock_get_systime01(lua_State* tolua_S)
03002 {
03003  tolua_Error tolua_err;
03004  if (
03005      !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
03006      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"fawkes::Time",0,&tolua_err)) ||
03007      !tolua_isnoobj(tolua_S,3,&tolua_err)
03008  )
03009   goto tolua_lerror;
03010  else
03011  {
03012   const fawkes::Clock* self = (const fawkes::Clock*)  tolua_tousertype(tolua_S,1,0);
03013   fawkes::Time* time = ((fawkes::Time*)  tolua_tousertype(tolua_S,2,0));
03014 #ifndef TOLUA_RELEASE
03015   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_systime'", NULL);
03016 #endif
03017   {
03018    self->get_systime(*time);
03019   }
03020  }
03021  return 0;
03022 tolua_lerror:
03023  return tolua_fawkesutils_fawkes_Clock_get_systime00(tolua_S);
03024 }
03025 #endif //#ifndef TOLUA_DISABLE
03026 
03027 /* method: get_systime of class  fawkes::Clock */
03028 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_get_systime02
03029 static int tolua_fawkesutils_fawkes_Clock_get_systime02(lua_State* tolua_S)
03030 {
03031  tolua_Error tolua_err;
03032  if (
03033      !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
03034      !tolua_isusertype(tolua_S,2,"fawkes::Time",0,&tolua_err) ||
03035      !tolua_isnoobj(tolua_S,3,&tolua_err)
03036  )
03037   goto tolua_lerror;
03038  else
03039  {
03040   const fawkes::Clock* self = (const fawkes::Clock*)  tolua_tousertype(tolua_S,1,0);
03041   fawkes::Time* time = ((fawkes::Time*)  tolua_tousertype(tolua_S,2,0));
03042 #ifndef TOLUA_RELEASE
03043   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_systime'", NULL);
03044 #endif
03045   {
03046    self->get_systime(time);
03047   }
03048  }
03049  return 0;
03050 tolua_lerror:
03051  return tolua_fawkesutils_fawkes_Clock_get_systime01(tolua_S);
03052 }
03053 #endif //#ifndef TOLUA_DISABLE
03054 
03055 /* method: now of class  fawkes::Clock */
03056 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_now00
03057 static int tolua_fawkesutils_fawkes_Clock_now00(lua_State* tolua_S)
03058 {
03059 #ifndef TOLUA_RELEASE
03060  tolua_Error tolua_err;
03061  if (
03062      !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
03063      !tolua_isnoobj(tolua_S,2,&tolua_err)
03064  )
03065   goto tolua_lerror;
03066  else
03067 #endif
03068  {
03069   const fawkes::Clock* self = (const fawkes::Clock*)  tolua_tousertype(tolua_S,1,0);
03070 #ifndef TOLUA_RELEASE
03071   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'now'", NULL);
03072 #endif
03073   {
03074    fawkes::Time tolua_ret = (fawkes::Time)  self->now();
03075    {
03076 #ifdef __cplusplus
03077     void* tolua_obj = Mtolua_new((fawkes::Time)(tolua_ret));
03078      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::Time");
03079     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
03080 #else
03081     void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::Time));
03082      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::Time");
03083     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
03084 #endif
03085    }
03086   }
03087  }
03088  return 1;
03089 #ifndef TOLUA_RELEASE
03090  tolua_lerror:
03091  tolua_error(tolua_S,"#ferror in function 'now'.",&tolua_err);
03092  return 0;
03093 #endif
03094 }
03095 #endif //#ifndef TOLUA_DISABLE
03096 
03097 /* method: elapsed of class  fawkes::Clock */
03098 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_elapsed00
03099 static int tolua_fawkesutils_fawkes_Clock_elapsed00(lua_State* tolua_S)
03100 {
03101 #ifndef TOLUA_RELEASE
03102  tolua_Error tolua_err;
03103  if (
03104      !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
03105      !tolua_isusertype(tolua_S,2,"fawkes::Time",0,&tolua_err) ||
03106      !tolua_isnoobj(tolua_S,3,&tolua_err)
03107  )
03108   goto tolua_lerror;
03109  else
03110 #endif
03111  {
03112   const fawkes::Clock* self = (const fawkes::Clock*)  tolua_tousertype(tolua_S,1,0);
03113   fawkes::Time* t = ((fawkes::Time*)  tolua_tousertype(tolua_S,2,0));
03114 #ifndef TOLUA_RELEASE
03115   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'elapsed'", NULL);
03116 #endif
03117   {
03118    float tolua_ret = (float)  self->elapsed(t);
03119    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03120   }
03121  }
03122  return 1;
03123 #ifndef TOLUA_RELEASE
03124  tolua_lerror:
03125  tolua_error(tolua_S,"#ferror in function 'elapsed'.",&tolua_err);
03126  return 0;
03127 #endif
03128 }
03129 #endif //#ifndef TOLUA_DISABLE
03130 
03131 /* method: sys_elapsed of class  fawkes::Clock */
03132 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_sys_elapsed00
03133 static int tolua_fawkesutils_fawkes_Clock_sys_elapsed00(lua_State* tolua_S)
03134 {
03135 #ifndef TOLUA_RELEASE
03136  tolua_Error tolua_err;
03137  if (
03138      !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
03139      !tolua_isusertype(tolua_S,2,"fawkes::Time",0,&tolua_err) ||
03140      !tolua_isnoobj(tolua_S,3,&tolua_err)
03141  )
03142   goto tolua_lerror;
03143  else
03144 #endif
03145  {
03146   const fawkes::Clock* self = (const fawkes::Clock*)  tolua_tousertype(tolua_S,1,0);
03147   fawkes::Time* t = ((fawkes::Time*)  tolua_tousertype(tolua_S,2,0));
03148 #ifndef TOLUA_RELEASE
03149   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'sys_elapsed'", NULL);
03150 #endif
03151   {
03152    float tolua_ret = (float)  self->sys_elapsed(t);
03153    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03154   }
03155  }
03156  return 1;
03157 #ifndef TOLUA_RELEASE
03158  tolua_lerror:
03159  tolua_error(tolua_S,"#ferror in function 'sys_elapsed'.",&tolua_err);
03160  return 0;
03161 #endif
03162 }
03163 #endif //#ifndef TOLUA_DISABLE
03164 
03165 /* Open function */
03166 TOLUA_API int tolua_fawkesutils_open (lua_State* tolua_S)
03167 {
03168  tolua_open(tolua_S);
03169  tolua_reg_types(tolua_S);
03170  tolua_module(tolua_S,NULL,0);
03171  tolua_beginmodule(tolua_S,NULL);
03172   #ifdef __cplusplus
03173   tolua_cclass(tolua_S,"vector_string_","vector<string>","",tolua_collect_vector_string_);
03174   #else
03175   tolua_cclass(tolua_S,"vector_string_","vector<string>","",NULL);
03176   #endif
03177   tolua_beginmodule(tolua_S,"vector_string_");
03178    tolua_function(tolua_S,"clear",tolua_fawkesutils_vector_string__clear00);
03179    tolua_function(tolua_S,"size",tolua_fawkesutils_vector_string__size00);
03180    tolua_function(tolua_S,".geti",tolua_fawkesutils_vector_string___geti00);
03181    tolua_function(tolua_S,".seti",tolua_fawkesutils_vector_string___seti00);
03182    tolua_function(tolua_S,".geti",tolua_fawkesutils_vector_string___geti01);
03183    tolua_function(tolua_S,"push_back",tolua_fawkesutils_vector_string__push_back00);
03184    tolua_function(tolua_S,"new",tolua_fawkesutils_vector_string__new00);
03185    tolua_function(tolua_S,"new_local",tolua_fawkesutils_vector_string__new00_local);
03186    tolua_function(tolua_S,".call",tolua_fawkesutils_vector_string__new00_local);
03187    tolua_function(tolua_S,"delete",tolua_fawkesutils_vector_string__delete00);
03188   tolua_endmodule(tolua_S);
03189   #ifdef __cplusplus
03190   tolua_cclass(tolua_S,"vector_fawkes__RCSoftMapNode_","vector<fawkes::RCSoftMapNode>","",tolua_collect_vector_fawkes__RCSoftMapNode_);
03191   #else
03192   tolua_cclass(tolua_S,"vector_fawkes__RCSoftMapNode_","vector<fawkes::RCSoftMapNode>","",NULL);
03193   #endif
03194   tolua_beginmodule(tolua_S,"vector_fawkes__RCSoftMapNode_");
03195    tolua_function(tolua_S,"clear",tolua_fawkesutils_vector_fawkes__RCSoftMapNode__clear00);
03196    tolua_function(tolua_S,"size",tolua_fawkesutils_vector_fawkes__RCSoftMapNode__size00);
03197    tolua_function(tolua_S,".geti",tolua_fawkesutils_vector_fawkes__RCSoftMapNode___geti00);
03198    tolua_function(tolua_S,".seti",tolua_fawkesutils_vector_fawkes__RCSoftMapNode___seti00);
03199    tolua_function(tolua_S,".geti",tolua_fawkesutils_vector_fawkes__RCSoftMapNode___geti01);
03200    tolua_function(tolua_S,"push_back",tolua_fawkesutils_vector_fawkes__RCSoftMapNode__push_back00);
03201    tolua_function(tolua_S,"new",tolua_fawkesutils_vector_fawkes__RCSoftMapNode__new00);
03202    tolua_function(tolua_S,"new_local",tolua_fawkesutils_vector_fawkes__RCSoftMapNode__new00_local);
03203    tolua_function(tolua_S,".call",tolua_fawkesutils_vector_fawkes__RCSoftMapNode__new00_local);
03204    tolua_function(tolua_S,"delete",tolua_fawkesutils_vector_fawkes__RCSoftMapNode__delete00);
03205   tolua_endmodule(tolua_S);
03206   tolua_module(tolua_S,"fawkes",0);
03207   tolua_beginmodule(tolua_S,"fawkes");
03208    #ifdef __cplusplus
03209    tolua_cclass(tolua_S,"RCSoftMapNode","fawkes::RCSoftMapNode","",tolua_collect_fawkes__RCSoftMapNode);
03210    #else
03211    tolua_cclass(tolua_S,"RCSoftMapNode","fawkes::RCSoftMapNode","",NULL);
03212    #endif
03213    tolua_beginmodule(tolua_S,"RCSoftMapNode");
03214     tolua_function(tolua_S,"new",tolua_fawkesutils_fawkes_RCSoftMapNode_new00);
03215     tolua_function(tolua_S,"new_local",tolua_fawkesutils_fawkes_RCSoftMapNode_new00_local);
03216     tolua_function(tolua_S,".call",tolua_fawkesutils_fawkes_RCSoftMapNode_new00_local);
03217     tolua_function(tolua_S,"new",tolua_fawkesutils_fawkes_RCSoftMapNode_new01);
03218     tolua_function(tolua_S,"new_local",tolua_fawkesutils_fawkes_RCSoftMapNode_new01_local);
03219     tolua_function(tolua_S,".call",tolua_fawkesutils_fawkes_RCSoftMapNode_new01_local);
03220     tolua_function(tolua_S,"name",tolua_fawkesutils_fawkes_RCSoftMapNode_name00);
03221     tolua_function(tolua_S,"x",tolua_fawkesutils_fawkes_RCSoftMapNode_x00);
03222     tolua_function(tolua_S,"y",tolua_fawkesutils_fawkes_RCSoftMapNode_y00);
03223     tolua_function(tolua_S,"properties",tolua_fawkesutils_fawkes_RCSoftMapNode_properties00);
03224     tolua_function(tolua_S,"aliases",tolua_fawkesutils_fawkes_RCSoftMapNode_aliases00);
03225     tolua_function(tolua_S,"children",tolua_fawkesutils_fawkes_RCSoftMapNode_children00);
03226     tolua_function(tolua_S,"has_property",tolua_fawkesutils_fawkes_RCSoftMapNode_has_property00);
03227     tolua_function(tolua_S,"has_alias",tolua_fawkesutils_fawkes_RCSoftMapNode_has_alias00);
03228    tolua_endmodule(tolua_S);
03229   tolua_endmodule(tolua_S);
03230   tolua_module(tolua_S,"fawkes",0);
03231   tolua_beginmodule(tolua_S,"fawkes");
03232    #ifdef __cplusplus
03233    tolua_cclass(tolua_S,"RCSoftMapGraph","fawkes::RCSoftMapGraph","",tolua_collect_fawkes__RCSoftMapGraph);
03234    #else
03235    tolua_cclass(tolua_S,"RCSoftMapGraph","fawkes::RCSoftMapGraph","",NULL);
03236    #endif
03237    tolua_beginmodule(tolua_S,"RCSoftMapGraph");
03238     tolua_function(tolua_S,"new",tolua_fawkesutils_fawkes_RCSoftMapGraph_new00);
03239     tolua_function(tolua_S,"new_local",tolua_fawkesutils_fawkes_RCSoftMapGraph_new00_local);
03240     tolua_function(tolua_S,".call",tolua_fawkesutils_fawkes_RCSoftMapGraph_new00_local);
03241     tolua_function(tolua_S,"delete",tolua_fawkesutils_fawkes_RCSoftMapGraph_delete00);
03242     tolua_function(tolua_S,"graph_name",tolua_fawkesutils_fawkes_RCSoftMapGraph_graph_name00);
03243     tolua_function(tolua_S,"nodes",tolua_fawkesutils_fawkes_RCSoftMapGraph_nodes00);
03244     tolua_function(tolua_S,"node",tolua_fawkesutils_fawkes_RCSoftMapGraph_node00);
03245     tolua_function(tolua_S,"root_node",tolua_fawkesutils_fawkes_RCSoftMapGraph_root_node00);
03246     tolua_function(tolua_S,"closest_node",tolua_fawkesutils_fawkes_RCSoftMapGraph_closest_node00);
03247     tolua_function(tolua_S,"search_nodes",tolua_fawkesutils_fawkes_RCSoftMapGraph_search_nodes00);
03248    tolua_endmodule(tolua_S);
03249   tolua_endmodule(tolua_S);
03250   tolua_module(tolua_S,"fawkes",0);
03251   tolua_beginmodule(tolua_S,"fawkes");
03252    #ifdef __cplusplus
03253    tolua_cclass(tolua_S,"KalmanFilter1D","fawkes::KalmanFilter1D","",tolua_collect_fawkes__KalmanFilter1D);
03254    #else
03255    tolua_cclass(tolua_S,"KalmanFilter1D","fawkes::KalmanFilter1D","",NULL);
03256    #endif
03257    tolua_beginmodule(tolua_S,"KalmanFilter1D");
03258     tolua_function(tolua_S,"new",tolua_fawkesutils_fawkes_KalmanFilter1D_new00);
03259     tolua_function(tolua_S,"new_local",tolua_fawkesutils_fawkes_KalmanFilter1D_new00_local);
03260     tolua_function(tolua_S,".call",tolua_fawkesutils_fawkes_KalmanFilter1D_new00_local);
03261     tolua_function(tolua_S,"delete",tolua_fawkesutils_fawkes_KalmanFilter1D_delete00);
03262     tolua_function(tolua_S,"filter",tolua_fawkesutils_fawkes_KalmanFilter1D_filter00);
03263     tolua_function(tolua_S,"filter",tolua_fawkesutils_fawkes_KalmanFilter1D_filter01);
03264     tolua_function(tolua_S,"predict",tolua_fawkesutils_fawkes_KalmanFilter1D_predict00);
03265     tolua_function(tolua_S,"predict",tolua_fawkesutils_fawkes_KalmanFilter1D_predict01);
03266     tolua_function(tolua_S,"predict",tolua_fawkesutils_fawkes_KalmanFilter1D_predict02);
03267     tolua_function(tolua_S,"predict",tolua_fawkesutils_fawkes_KalmanFilter1D_predict03);
03268    tolua_endmodule(tolua_S);
03269   tolua_endmodule(tolua_S);
03270   tolua_cclass(tolua_S,"timeval","timeval","",NULL);
03271   tolua_beginmodule(tolua_S,"timeval");
03272    tolua_variable(tolua_S,"tv_sec",tolua_get_timeval_tv_sec,tolua_set_timeval_tv_sec);
03273    tolua_variable(tolua_S,"tv_usec",tolua_get_timeval_tv_usec,tolua_set_timeval_tv_usec);
03274   tolua_endmodule(tolua_S);
03275   tolua_module(tolua_S,"fawkes",0);
03276   tolua_beginmodule(tolua_S,"fawkes");
03277    #ifdef __cplusplus
03278    tolua_cclass(tolua_S,"Time","fawkes::Time","",tolua_collect_fawkes__Time);
03279    #else
03280    tolua_cclass(tolua_S,"Time","fawkes::Time","",NULL);
03281    #endif
03282    tolua_beginmodule(tolua_S,"Time");
03283     tolua_function(tolua_S,"new",tolua_fawkesutils_fawkes_Time_new00);
03284     tolua_function(tolua_S,"new_local",tolua_fawkesutils_fawkes_Time_new00_local);
03285     tolua_function(tolua_S,".call",tolua_fawkesutils_fawkes_Time_new00_local);
03286     tolua_function(tolua_S,"new",tolua_fawkesutils_fawkes_Time_new01);
03287     tolua_function(tolua_S,"new_local",tolua_fawkesutils_fawkes_Time_new01_local);
03288     tolua_function(tolua_S,".call",tolua_fawkesutils_fawkes_Time_new01_local);
03289     tolua_function(tolua_S,"new",tolua_fawkesutils_fawkes_Time_new02);
03290     tolua_function(tolua_S,"new_local",tolua_fawkesutils_fawkes_Time_new02_local);
03291     tolua_function(tolua_S,".call",tolua_fawkesutils_fawkes_Time_new02_local);
03292     tolua_function(tolua_S,"new",tolua_fawkesutils_fawkes_Time_new03);
03293     tolua_function(tolua_S,"new_local",tolua_fawkesutils_fawkes_Time_new03_local);
03294     tolua_function(tolua_S,".call",tolua_fawkesutils_fawkes_Time_new03_local);
03295     tolua_function(tolua_S,"new",tolua_fawkesutils_fawkes_Time_new04);
03296     tolua_function(tolua_S,"new_local",tolua_fawkesutils_fawkes_Time_new04_local);
03297     tolua_function(tolua_S,".call",tolua_fawkesutils_fawkes_Time_new04_local);
03298     tolua_function(tolua_S,"new",tolua_fawkesutils_fawkes_Time_new05);
03299     tolua_function(tolua_S,"new_local",tolua_fawkesutils_fawkes_Time_new05_local);
03300     tolua_function(tolua_S,".call",tolua_fawkesutils_fawkes_Time_new05_local);
03301     tolua_function(tolua_S,"new",tolua_fawkesutils_fawkes_Time_new06);
03302     tolua_function(tolua_S,"new_local",tolua_fawkesutils_fawkes_Time_new06_local);
03303     tolua_function(tolua_S,".call",tolua_fawkesutils_fawkes_Time_new06_local);
03304     tolua_function(tolua_S,"delete",tolua_fawkesutils_fawkes_Time_delete00);
03305     tolua_function(tolua_S,"in_sec",tolua_fawkesutils_fawkes_Time_in_sec00);
03306     tolua_function(tolua_S,"in_msec",tolua_fawkesutils_fawkes_Time_in_msec00);
03307     tolua_function(tolua_S,"in_usec",tolua_fawkesutils_fawkes_Time_in_usec00);
03308     tolua_function(tolua_S,"get_timeval",tolua_fawkesutils_fawkes_Time_get_timeval00);
03309     tolua_function(tolua_S,"set_time",tolua_fawkesutils_fawkes_Time_set_time00);
03310     tolua_function(tolua_S,"set_time",tolua_fawkesutils_fawkes_Time_set_time01);
03311     tolua_function(tolua_S,"set_time",tolua_fawkesutils_fawkes_Time_set_time02);
03312     tolua_function(tolua_S,"set_time",tolua_fawkesutils_fawkes_Time_set_time03);
03313     tolua_function(tolua_S,"add",tolua_fawkesutils_fawkes_Time_add00);
03314     tolua_function(tolua_S,"stamp",tolua_fawkesutils_fawkes_Time_stamp00);
03315     tolua_function(tolua_S,".add",tolua_fawkesutils_fawkes_Time__add00);
03316     tolua_function(tolua_S,".sub",tolua_fawkesutils_fawkes_Time__sub00);
03317     tolua_function(tolua_S,"str",tolua_fawkesutils_fawkes_Time_str00);
03318     tolua_function(tolua_S,"str_r",tolua_fawkesutils_fawkes_Time_str_r00);
03319    tolua_endmodule(tolua_S);
03320   tolua_endmodule(tolua_S);
03321   tolua_module(tolua_S,"fawkes",0);
03322   tolua_beginmodule(tolua_S,"fawkes");
03323    tolua_cclass(tolua_S,"Clock","fawkes::Clock","",NULL);
03324    tolua_beginmodule(tolua_S,"Clock");
03325     tolua_constant(tolua_S,"DEFAULT",fawkes::Clock::DEFAULT);
03326     tolua_constant(tolua_S,"REALTIME",fawkes::Clock::REALTIME);
03327     tolua_constant(tolua_S,"EXTERNAL",fawkes::Clock::EXTERNAL);
03328     tolua_function(tolua_S,"instance",tolua_fawkesutils_fawkes_Clock_instance00);
03329     tolua_function(tolua_S,"finalize",tolua_fawkesutils_fawkes_Clock_finalize00);
03330     tolua_function(tolua_S,"is_ext_default_timesource",tolua_fawkesutils_fawkes_Clock_is_ext_default_timesource00);
03331     tolua_function(tolua_S,"has_ext_timesource",tolua_fawkesutils_fawkes_Clock_has_ext_timesource00);
03332     tolua_function(tolua_S,"ext_to_realtime",tolua_fawkesutils_fawkes_Clock_ext_to_realtime00);
03333     tolua_function(tolua_S,"get_time",tolua_fawkesutils_fawkes_Clock_get_time00);
03334     tolua_function(tolua_S,"get_time",tolua_fawkesutils_fawkes_Clock_get_time01);
03335     tolua_function(tolua_S,"get_time",tolua_fawkesutils_fawkes_Clock_get_time02);
03336     tolua_function(tolua_S,"get_time",tolua_fawkesutils_fawkes_Clock_get_time03);
03337     tolua_function(tolua_S,"get_time",tolua_fawkesutils_fawkes_Clock_get_time04);
03338     tolua_function(tolua_S,"get_time",tolua_fawkesutils_fawkes_Clock_get_time05);
03339     tolua_function(tolua_S,"get_systime",tolua_fawkesutils_fawkes_Clock_get_systime00);
03340     tolua_function(tolua_S,"get_systime",tolua_fawkesutils_fawkes_Clock_get_systime01);
03341     tolua_function(tolua_S,"get_systime",tolua_fawkesutils_fawkes_Clock_get_systime02);
03342     tolua_function(tolua_S,"now",tolua_fawkesutils_fawkes_Clock_now00);
03343     tolua_function(tolua_S,"elapsed",tolua_fawkesutils_fawkes_Clock_elapsed00);
03344     tolua_function(tolua_S,"sys_elapsed",tolua_fawkesutils_fawkes_Clock_sys_elapsed00);
03345    tolua_endmodule(tolua_S);
03346   tolua_endmodule(tolua_S);
03347  tolua_endmodule(tolua_S);
03348  return 1;
03349 }
03350 
03351 
03352 extern "C" {
03353 #if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501
03354  TOLUA_API int luaopen_fawkesutils (lua_State* tolua_S) {
03355  return tolua_fawkesutils_open(tolua_S);
03356 };
03357 #endif
03358 }
03359 
03360