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/kalman/kalman_1d.h>
00030 #include <utils/logging/component.h>
00031 #include <utils/time/clock.h>
00032 #include <utils/time/time.h>
00033 
00034 /* function to release collected object via destructor */
00035 #ifdef __cplusplus
00036 
00037 static int tolua_collect_fawkes__KalmanFilter1D (lua_State* tolua_S)
00038 {
00039  fawkes::KalmanFilter1D* self = (fawkes::KalmanFilter1D*) tolua_tousertype(tolua_S,1,0);
00040         Mtolua_delete(self);
00041         return 0;
00042 }
00043 
00044 static int tolua_collect_fawkes__Time (lua_State* tolua_S)
00045 {
00046  fawkes::Time* self = (fawkes::Time*) tolua_tousertype(tolua_S,1,0);
00047         Mtolua_delete(self);
00048         return 0;
00049 }
00050 #endif
00051 
00052 
00053 /* function to register type */
00054 static void tolua_reg_types (lua_State* tolua_S)
00055 {
00056  tolua_usertype(tolua_S,"fawkes::KalmanFilter1D");
00057  tolua_usertype(tolua_S,"timeval");
00058  tolua_usertype(tolua_S,"fawkes::Clock");
00059  tolua_usertype(tolua_S,"fawkes::ComponentLogger");
00060  tolua_usertype(tolua_S,"fawkes::Time");
00061 }
00062 
00063 /* method: new of class  fawkes::KalmanFilter1D */
00064 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_KalmanFilter1D_new00
00065 static int tolua_fawkesutils_fawkes_KalmanFilter1D_new00(lua_State* tolua_S)
00066 {
00067 #ifndef TOLUA_RELEASE
00068  tolua_Error tolua_err;
00069  if (
00070      !tolua_isusertable(tolua_S,1,"fawkes::KalmanFilter1D",0,&tolua_err) ||
00071      !tolua_isnumber(tolua_S,2,1,&tolua_err) ||
00072      !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
00073      !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
00074      !tolua_isnumber(tolua_S,5,1,&tolua_err) ||
00075      !tolua_isnoobj(tolua_S,6,&tolua_err)
00076  )
00077   goto tolua_lerror;
00078  else
00079 #endif
00080  {
00081   float noise_x = ((float)  tolua_tonumber(tolua_S,2,1.0));
00082   float noise_z = ((float)  tolua_tonumber(tolua_S,3,1.0));
00083   float mu = ((float)  tolua_tonumber(tolua_S,4,0.0));
00084   float sig = ((float)  tolua_tonumber(tolua_S,5,1.0));
00085   {
00086    fawkes::KalmanFilter1D* tolua_ret = (fawkes::KalmanFilter1D*)  Mtolua_new((fawkes::KalmanFilter1D)(noise_x,noise_z,mu,sig));
00087     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::KalmanFilter1D");
00088   }
00089  }
00090  return 1;
00091 #ifndef TOLUA_RELEASE
00092  tolua_lerror:
00093  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00094  return 0;
00095 #endif
00096 }
00097 #endif //#ifndef TOLUA_DISABLE
00098 
00099 /* method: new_local of class  fawkes::KalmanFilter1D */
00100 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_KalmanFilter1D_new00_local
00101 static int tolua_fawkesutils_fawkes_KalmanFilter1D_new00_local(lua_State* tolua_S)
00102 {
00103 #ifndef TOLUA_RELEASE
00104  tolua_Error tolua_err;
00105  if (
00106      !tolua_isusertable(tolua_S,1,"fawkes::KalmanFilter1D",0,&tolua_err) ||
00107      !tolua_isnumber(tolua_S,2,1,&tolua_err) ||
00108      !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
00109      !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
00110      !tolua_isnumber(tolua_S,5,1,&tolua_err) ||
00111      !tolua_isnoobj(tolua_S,6,&tolua_err)
00112  )
00113   goto tolua_lerror;
00114  else
00115 #endif
00116  {
00117   float noise_x = ((float)  tolua_tonumber(tolua_S,2,1.0));
00118   float noise_z = ((float)  tolua_tonumber(tolua_S,3,1.0));
00119   float mu = ((float)  tolua_tonumber(tolua_S,4,0.0));
00120   float sig = ((float)  tolua_tonumber(tolua_S,5,1.0));
00121   {
00122    fawkes::KalmanFilter1D* tolua_ret = (fawkes::KalmanFilter1D*)  Mtolua_new((fawkes::KalmanFilter1D)(noise_x,noise_z,mu,sig));
00123     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::KalmanFilter1D");
00124     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00125   }
00126  }
00127  return 1;
00128 #ifndef TOLUA_RELEASE
00129  tolua_lerror:
00130  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00131  return 0;
00132 #endif
00133 }
00134 #endif //#ifndef TOLUA_DISABLE
00135 
00136 /* method: delete of class  fawkes::KalmanFilter1D */
00137 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_KalmanFilter1D_delete00
00138 static int tolua_fawkesutils_fawkes_KalmanFilter1D_delete00(lua_State* tolua_S)
00139 {
00140 #ifndef TOLUA_RELEASE
00141  tolua_Error tolua_err;
00142  if (
00143      !tolua_isusertype(tolua_S,1,"fawkes::KalmanFilter1D",0,&tolua_err) ||
00144      !tolua_isnoobj(tolua_S,2,&tolua_err)
00145  )
00146   goto tolua_lerror;
00147  else
00148 #endif
00149  {
00150   fawkes::KalmanFilter1D* self = (fawkes::KalmanFilter1D*)  tolua_tousertype(tolua_S,1,0);
00151 #ifndef TOLUA_RELEASE
00152   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
00153 #endif
00154   Mtolua_delete(self);
00155  }
00156  return 0;
00157 #ifndef TOLUA_RELEASE
00158  tolua_lerror:
00159  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
00160  return 0;
00161 #endif
00162 }
00163 #endif //#ifndef TOLUA_DISABLE
00164 
00165 /* method: filter of class  fawkes::KalmanFilter1D */
00166 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_KalmanFilter1D_filter00
00167 static int tolua_fawkesutils_fawkes_KalmanFilter1D_filter00(lua_State* tolua_S)
00168 {
00169 #ifndef TOLUA_RELEASE
00170  tolua_Error tolua_err;
00171  if (
00172      !tolua_isusertype(tolua_S,1,"fawkes::KalmanFilter1D",0,&tolua_err) ||
00173      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00174      !tolua_isnoobj(tolua_S,3,&tolua_err)
00175  )
00176   goto tolua_lerror;
00177  else
00178 #endif
00179  {
00180   fawkes::KalmanFilter1D* self = (fawkes::KalmanFilter1D*)  tolua_tousertype(tolua_S,1,0);
00181   float observe = ((float)  tolua_tonumber(tolua_S,2,0));
00182 #ifndef TOLUA_RELEASE
00183   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'filter'", NULL);
00184 #endif
00185   {
00186    self->filter(observe);
00187   }
00188  }
00189  return 0;
00190 #ifndef TOLUA_RELEASE
00191  tolua_lerror:
00192  tolua_error(tolua_S,"#ferror in function 'filter'.",&tolua_err);
00193  return 0;
00194 #endif
00195 }
00196 #endif //#ifndef TOLUA_DISABLE
00197 
00198 /* method: filter of class  fawkes::KalmanFilter1D */
00199 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_KalmanFilter1D_filter01
00200 static int tolua_fawkesutils_fawkes_KalmanFilter1D_filter01(lua_State* tolua_S)
00201 {
00202  tolua_Error tolua_err;
00203  if (
00204      !tolua_isusertype(tolua_S,1,"fawkes::KalmanFilter1D",0,&tolua_err) ||
00205      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00206      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
00207      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
00208      !tolua_isnoobj(tolua_S,5,&tolua_err)
00209  )
00210   goto tolua_lerror;
00211  else
00212  {
00213   fawkes::KalmanFilter1D* self = (fawkes::KalmanFilter1D*)  tolua_tousertype(tolua_S,1,0);
00214   float observe = ((float)  tolua_tonumber(tolua_S,2,0));
00215   float mu = ((float)  tolua_tonumber(tolua_S,3,0));
00216   float sig = ((float)  tolua_tonumber(tolua_S,4,0));
00217 #ifndef TOLUA_RELEASE
00218   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'filter'", NULL);
00219 #endif
00220   {
00221    self->filter(observe,mu,sig);
00222    tolua_pushnumber(tolua_S,(lua_Number)mu);
00223    tolua_pushnumber(tolua_S,(lua_Number)sig);
00224   }
00225  }
00226  return 2;
00227 tolua_lerror:
00228  return tolua_fawkesutils_fawkes_KalmanFilter1D_filter00(tolua_S);
00229 }
00230 #endif //#ifndef TOLUA_DISABLE
00231 
00232 /* method: predict of class  fawkes::KalmanFilter1D */
00233 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_KalmanFilter1D_predict00
00234 static int tolua_fawkesutils_fawkes_KalmanFilter1D_predict00(lua_State* tolua_S)
00235 {
00236 #ifndef TOLUA_RELEASE
00237  tolua_Error tolua_err;
00238  if (
00239      !tolua_isusertype(tolua_S,1,"const fawkes::KalmanFilter1D",0,&tolua_err) ||
00240      !tolua_isnoobj(tolua_S,2,&tolua_err)
00241  )
00242   goto tolua_lerror;
00243  else
00244 #endif
00245  {
00246   const fawkes::KalmanFilter1D* self = (const fawkes::KalmanFilter1D*)  tolua_tousertype(tolua_S,1,0);
00247 #ifndef TOLUA_RELEASE
00248   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'predict'", NULL);
00249 #endif
00250   {
00251    float tolua_ret = (float)  self->predict();
00252    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00253   }
00254  }
00255  return 1;
00256 #ifndef TOLUA_RELEASE
00257  tolua_lerror:
00258  tolua_error(tolua_S,"#ferror in function 'predict'.",&tolua_err);
00259  return 0;
00260 #endif
00261 }
00262 #endif //#ifndef TOLUA_DISABLE
00263 
00264 /* method: predict of class  fawkes::KalmanFilter1D */
00265 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_KalmanFilter1D_predict01
00266 static int tolua_fawkesutils_fawkes_KalmanFilter1D_predict01(lua_State* tolua_S)
00267 {
00268  tolua_Error tolua_err;
00269  if (
00270      !tolua_isusertype(tolua_S,1,"const fawkes::KalmanFilter1D",0,&tolua_err) ||
00271      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00272      !tolua_isnoobj(tolua_S,3,&tolua_err)
00273  )
00274   goto tolua_lerror;
00275  else
00276  {
00277   const fawkes::KalmanFilter1D* self = (const fawkes::KalmanFilter1D*)  tolua_tousertype(tolua_S,1,0);
00278   float vel = ((float)  tolua_tonumber(tolua_S,2,0));
00279 #ifndef TOLUA_RELEASE
00280   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'predict'", NULL);
00281 #endif
00282   {
00283    float tolua_ret = (float)  self->predict(vel);
00284    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00285   }
00286  }
00287  return 1;
00288 tolua_lerror:
00289  return tolua_fawkesutils_fawkes_KalmanFilter1D_predict00(tolua_S);
00290 }
00291 #endif //#ifndef TOLUA_DISABLE
00292 
00293 /* method: predict of class  fawkes::KalmanFilter1D */
00294 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_KalmanFilter1D_predict02
00295 static int tolua_fawkesutils_fawkes_KalmanFilter1D_predict02(lua_State* tolua_S)
00296 {
00297  tolua_Error tolua_err;
00298  if (
00299      !tolua_isusertype(tolua_S,1,"const fawkes::KalmanFilter1D",0,&tolua_err) ||
00300      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00301      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
00302      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
00303      !tolua_isnoobj(tolua_S,5,&tolua_err)
00304  )
00305   goto tolua_lerror;
00306  else
00307  {
00308   const fawkes::KalmanFilter1D* self = (const fawkes::KalmanFilter1D*)  tolua_tousertype(tolua_S,1,0);
00309   float vel = ((float)  tolua_tonumber(tolua_S,2,0));
00310   int steps = ((int)  tolua_tonumber(tolua_S,3,0));
00311   float noise_z = ((float)  tolua_tonumber(tolua_S,4,0));
00312 #ifndef TOLUA_RELEASE
00313   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'predict'", NULL);
00314 #endif
00315   {
00316    float tolua_ret = (float)  self->predict(vel,steps,noise_z);
00317    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00318   }
00319  }
00320  return 1;
00321 tolua_lerror:
00322  return tolua_fawkesutils_fawkes_KalmanFilter1D_predict01(tolua_S);
00323 }
00324 #endif //#ifndef TOLUA_DISABLE
00325 
00326 /* method: predict of class  fawkes::KalmanFilter1D */
00327 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_KalmanFilter1D_predict03
00328 static int tolua_fawkesutils_fawkes_KalmanFilter1D_predict03(lua_State* tolua_S)
00329 {
00330  tolua_Error tolua_err;
00331  if (
00332      !tolua_isusertype(tolua_S,1,"const fawkes::KalmanFilter1D",0,&tolua_err) ||
00333      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00334      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
00335      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
00336      !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
00337      !tolua_isnoobj(tolua_S,6,&tolua_err)
00338  )
00339   goto tolua_lerror;
00340  else
00341  {
00342   const fawkes::KalmanFilter1D* self = (const fawkes::KalmanFilter1D*)  tolua_tousertype(tolua_S,1,0);
00343   float mu = ((float)  tolua_tonumber(tolua_S,2,0));
00344   float vel = ((float)  tolua_tonumber(tolua_S,3,0));
00345   int steps = ((int)  tolua_tonumber(tolua_S,4,0));
00346   float noise_z = ((float)  tolua_tonumber(tolua_S,5,0));
00347 #ifndef TOLUA_RELEASE
00348   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'predict'", NULL);
00349 #endif
00350   {
00351    float tolua_ret = (float)  self->predict(mu,vel,steps,noise_z);
00352    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00353   }
00354  }
00355  return 1;
00356 tolua_lerror:
00357  return tolua_fawkesutils_fawkes_KalmanFilter1D_predict02(tolua_S);
00358 }
00359 #endif //#ifndef TOLUA_DISABLE
00360 
00361 /* method: log_debug of class  fawkes::ComponentLogger */
00362 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_ComponentLogger_log_debug00
00363 static int tolua_fawkesutils_fawkes_ComponentLogger_log_debug00(lua_State* tolua_S)
00364 {
00365 #ifndef TOLUA_RELEASE
00366  tolua_Error tolua_err;
00367  if (
00368      !tolua_isusertype(tolua_S,1,"fawkes::ComponentLogger",0,&tolua_err) ||
00369      !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
00370      !tolua_isnoobj(tolua_S,3,&tolua_err)
00371  )
00372   goto tolua_lerror;
00373  else
00374 #endif
00375  {
00376   fawkes::ComponentLogger* self = (fawkes::ComponentLogger*)  tolua_tousertype(tolua_S,1,0);
00377   std::string message = ((std::string)  tolua_tocppstring(tolua_S,2,0));
00378 #ifndef TOLUA_RELEASE
00379   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'log_debug'", NULL);
00380 #endif
00381   {
00382    self->log_debug(message);
00383   }
00384  }
00385  return 0;
00386 #ifndef TOLUA_RELEASE
00387  tolua_lerror:
00388  tolua_error(tolua_S,"#ferror in function 'log_debug'.",&tolua_err);
00389  return 0;
00390 #endif
00391 }
00392 #endif //#ifndef TOLUA_DISABLE
00393 
00394 /* method: log_info of class  fawkes::ComponentLogger */
00395 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_ComponentLogger_log_info00
00396 static int tolua_fawkesutils_fawkes_ComponentLogger_log_info00(lua_State* tolua_S)
00397 {
00398 #ifndef TOLUA_RELEASE
00399  tolua_Error tolua_err;
00400  if (
00401      !tolua_isusertype(tolua_S,1,"fawkes::ComponentLogger",0,&tolua_err) ||
00402      !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
00403      !tolua_isnoobj(tolua_S,3,&tolua_err)
00404  )
00405   goto tolua_lerror;
00406  else
00407 #endif
00408  {
00409   fawkes::ComponentLogger* self = (fawkes::ComponentLogger*)  tolua_tousertype(tolua_S,1,0);
00410   std::string message = ((std::string)  tolua_tocppstring(tolua_S,2,0));
00411 #ifndef TOLUA_RELEASE
00412   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'log_info'", NULL);
00413 #endif
00414   {
00415    self->log_info(message);
00416   }
00417  }
00418  return 0;
00419 #ifndef TOLUA_RELEASE
00420  tolua_lerror:
00421  tolua_error(tolua_S,"#ferror in function 'log_info'.",&tolua_err);
00422  return 0;
00423 #endif
00424 }
00425 #endif //#ifndef TOLUA_DISABLE
00426 
00427 /* method: log_warn of class  fawkes::ComponentLogger */
00428 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_ComponentLogger_log_warn00
00429 static int tolua_fawkesutils_fawkes_ComponentLogger_log_warn00(lua_State* tolua_S)
00430 {
00431 #ifndef TOLUA_RELEASE
00432  tolua_Error tolua_err;
00433  if (
00434      !tolua_isusertype(tolua_S,1,"fawkes::ComponentLogger",0,&tolua_err) ||
00435      !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
00436      !tolua_isnoobj(tolua_S,3,&tolua_err)
00437  )
00438   goto tolua_lerror;
00439  else
00440 #endif
00441  {
00442   fawkes::ComponentLogger* self = (fawkes::ComponentLogger*)  tolua_tousertype(tolua_S,1,0);
00443   std::string message = ((std::string)  tolua_tocppstring(tolua_S,2,0));
00444 #ifndef TOLUA_RELEASE
00445   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'log_warn'", NULL);
00446 #endif
00447   {
00448    self->log_warn(message);
00449   }
00450  }
00451  return 0;
00452 #ifndef TOLUA_RELEASE
00453  tolua_lerror:
00454  tolua_error(tolua_S,"#ferror in function 'log_warn'.",&tolua_err);
00455  return 0;
00456 #endif
00457 }
00458 #endif //#ifndef TOLUA_DISABLE
00459 
00460 /* method: log_error of class  fawkes::ComponentLogger */
00461 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_ComponentLogger_log_error00
00462 static int tolua_fawkesutils_fawkes_ComponentLogger_log_error00(lua_State* tolua_S)
00463 {
00464 #ifndef TOLUA_RELEASE
00465  tolua_Error tolua_err;
00466  if (
00467      !tolua_isusertype(tolua_S,1,"fawkes::ComponentLogger",0,&tolua_err) ||
00468      !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
00469      !tolua_isnoobj(tolua_S,3,&tolua_err)
00470  )
00471   goto tolua_lerror;
00472  else
00473 #endif
00474  {
00475   fawkes::ComponentLogger* self = (fawkes::ComponentLogger*)  tolua_tousertype(tolua_S,1,0);
00476   std::string message = ((std::string)  tolua_tocppstring(tolua_S,2,0));
00477 #ifndef TOLUA_RELEASE
00478   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'log_error'", NULL);
00479 #endif
00480   {
00481    self->log_error(message);
00482   }
00483  }
00484  return 0;
00485 #ifndef TOLUA_RELEASE
00486  tolua_lerror:
00487  tolua_error(tolua_S,"#ferror in function 'log_error'.",&tolua_err);
00488  return 0;
00489 #endif
00490 }
00491 #endif //#ifndef TOLUA_DISABLE
00492 
00493 /* method: instance of class  fawkes::Clock */
00494 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_instance00
00495 static int tolua_fawkesutils_fawkes_Clock_instance00(lua_State* tolua_S)
00496 {
00497 #ifndef TOLUA_RELEASE
00498  tolua_Error tolua_err;
00499  if (
00500      !tolua_isusertable(tolua_S,1,"fawkes::Clock",0,&tolua_err) ||
00501      !tolua_isnoobj(tolua_S,2,&tolua_err)
00502  )
00503   goto tolua_lerror;
00504  else
00505 #endif
00506  {
00507   {
00508    fawkes::Clock* tolua_ret = (fawkes::Clock*)  fawkes::Clock::instance();
00509     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Clock");
00510   }
00511  }
00512  return 1;
00513 #ifndef TOLUA_RELEASE
00514  tolua_lerror:
00515  tolua_error(tolua_S,"#ferror in function 'instance'.",&tolua_err);
00516  return 0;
00517 #endif
00518 }
00519 #endif //#ifndef TOLUA_DISABLE
00520 
00521 /* method: finalize of class  fawkes::Clock */
00522 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_finalize00
00523 static int tolua_fawkesutils_fawkes_Clock_finalize00(lua_State* tolua_S)
00524 {
00525 #ifndef TOLUA_RELEASE
00526  tolua_Error tolua_err;
00527  if (
00528      !tolua_isusertable(tolua_S,1,"fawkes::Clock",0,&tolua_err) ||
00529      !tolua_isnoobj(tolua_S,2,&tolua_err)
00530  )
00531   goto tolua_lerror;
00532  else
00533 #endif
00534  {
00535   {
00536    fawkes::Clock::finalize();
00537   }
00538  }
00539  return 0;
00540 #ifndef TOLUA_RELEASE
00541  tolua_lerror:
00542  tolua_error(tolua_S,"#ferror in function 'finalize'.",&tolua_err);
00543  return 0;
00544 #endif
00545 }
00546 #endif //#ifndef TOLUA_DISABLE
00547 
00548 /* method: is_ext_default_timesource of class  fawkes::Clock */
00549 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_is_ext_default_timesource00
00550 static int tolua_fawkesutils_fawkes_Clock_is_ext_default_timesource00(lua_State* tolua_S)
00551 {
00552 #ifndef TOLUA_RELEASE
00553  tolua_Error tolua_err;
00554  if (
00555      !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
00556      !tolua_isnoobj(tolua_S,2,&tolua_err)
00557  )
00558   goto tolua_lerror;
00559  else
00560 #endif
00561  {
00562   const fawkes::Clock* self = (const fawkes::Clock*)  tolua_tousertype(tolua_S,1,0);
00563 #ifndef TOLUA_RELEASE
00564   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_ext_default_timesource'", NULL);
00565 #endif
00566   {
00567    bool tolua_ret = (bool)  self->is_ext_default_timesource();
00568    tolua_pushboolean(tolua_S,(bool)tolua_ret);
00569   }
00570  }
00571  return 1;
00572 #ifndef TOLUA_RELEASE
00573  tolua_lerror:
00574  tolua_error(tolua_S,"#ferror in function 'is_ext_default_timesource'.",&tolua_err);
00575  return 0;
00576 #endif
00577 }
00578 #endif //#ifndef TOLUA_DISABLE
00579 
00580 /* method: has_ext_timesource of class  fawkes::Clock */
00581 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_has_ext_timesource00
00582 static int tolua_fawkesutils_fawkes_Clock_has_ext_timesource00(lua_State* tolua_S)
00583 {
00584 #ifndef TOLUA_RELEASE
00585  tolua_Error tolua_err;
00586  if (
00587      !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
00588      !tolua_isnoobj(tolua_S,2,&tolua_err)
00589  )
00590   goto tolua_lerror;
00591  else
00592 #endif
00593  {
00594   const fawkes::Clock* self = (const fawkes::Clock*)  tolua_tousertype(tolua_S,1,0);
00595 #ifndef TOLUA_RELEASE
00596   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'has_ext_timesource'", NULL);
00597 #endif
00598   {
00599    bool tolua_ret = (bool)  self->has_ext_timesource();
00600    tolua_pushboolean(tolua_S,(bool)tolua_ret);
00601   }
00602  }
00603  return 1;
00604 #ifndef TOLUA_RELEASE
00605  tolua_lerror:
00606  tolua_error(tolua_S,"#ferror in function 'has_ext_timesource'.",&tolua_err);
00607  return 0;
00608 #endif
00609 }
00610 #endif //#ifndef TOLUA_DISABLE
00611 
00612 /* method: ext_to_realtime of class  fawkes::Clock */
00613 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_ext_to_realtime00
00614 static int tolua_fawkesutils_fawkes_Clock_ext_to_realtime00(lua_State* tolua_S)
00615 {
00616 #ifndef TOLUA_RELEASE
00617  tolua_Error tolua_err;
00618  if (
00619      !tolua_isusertype(tolua_S,1,"fawkes::Clock",0,&tolua_err) ||
00620      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::Time",0,&tolua_err)) ||
00621      !tolua_isnoobj(tolua_S,3,&tolua_err)
00622  )
00623   goto tolua_lerror;
00624  else
00625 #endif
00626  {
00627   fawkes::Clock* self = (fawkes::Clock*)  tolua_tousertype(tolua_S,1,0);
00628   const fawkes::Time* t = ((const fawkes::Time*)  tolua_tousertype(tolua_S,2,0));
00629 #ifndef TOLUA_RELEASE
00630   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ext_to_realtime'", NULL);
00631 #endif
00632   {
00633    fawkes::Time tolua_ret = (fawkes::Time)  self->ext_to_realtime(*t);
00634    {
00635 #ifdef __cplusplus
00636     void* tolua_obj = Mtolua_new((fawkes::Time)(tolua_ret));
00637      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::Time");
00638     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00639 #else
00640     void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::Time));
00641      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::Time");
00642     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00643 #endif
00644    }
00645   }
00646  }
00647  return 1;
00648 #ifndef TOLUA_RELEASE
00649  tolua_lerror:
00650  tolua_error(tolua_S,"#ferror in function 'ext_to_realtime'.",&tolua_err);
00651  return 0;
00652 #endif
00653 }
00654 #endif //#ifndef TOLUA_DISABLE
00655 
00656 /* method: get_time of class  fawkes::Clock */
00657 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_get_time00
00658 static int tolua_fawkesutils_fawkes_Clock_get_time00(lua_State* tolua_S)
00659 {
00660 #ifndef TOLUA_RELEASE
00661  tolua_Error tolua_err;
00662  if (
00663      !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
00664      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"fawkes::Time",0,&tolua_err)) ||
00665      !tolua_isnoobj(tolua_S,3,&tolua_err)
00666  )
00667   goto tolua_lerror;
00668  else
00669 #endif
00670  {
00671   const fawkes::Clock* self = (const fawkes::Clock*)  tolua_tousertype(tolua_S,1,0);
00672   fawkes::Time* time = ((fawkes::Time*)  tolua_tousertype(tolua_S,2,0));
00673 #ifndef TOLUA_RELEASE
00674   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_time'", NULL);
00675 #endif
00676   {
00677    self->get_time(*time);
00678   }
00679  }
00680  return 0;
00681 #ifndef TOLUA_RELEASE
00682  tolua_lerror:
00683  tolua_error(tolua_S,"#ferror in function 'get_time'.",&tolua_err);
00684  return 0;
00685 #endif
00686 }
00687 #endif //#ifndef TOLUA_DISABLE
00688 
00689 /* method: get_time of class  fawkes::Clock */
00690 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_get_time01
00691 static int tolua_fawkesutils_fawkes_Clock_get_time01(lua_State* tolua_S)
00692 {
00693  tolua_Error tolua_err;
00694  if (
00695      !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
00696      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"fawkes::Time",0,&tolua_err)) ||
00697      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
00698      !tolua_isnoobj(tolua_S,4,&tolua_err)
00699  )
00700   goto tolua_lerror;
00701  else
00702  {
00703   const fawkes::Clock* self = (const fawkes::Clock*)  tolua_tousertype(tolua_S,1,0);
00704   fawkes::Time* time = ((fawkes::Time*)  tolua_tousertype(tolua_S,2,0));
00705   fawkes::Clock::TimesourceSelector sel = ((fawkes::Clock::TimesourceSelector) (int)  tolua_tonumber(tolua_S,3,0));
00706 #ifndef TOLUA_RELEASE
00707   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_time'", NULL);
00708 #endif
00709   {
00710    self->get_time(*time,sel);
00711   }
00712  }
00713  return 0;
00714 tolua_lerror:
00715  return tolua_fawkesutils_fawkes_Clock_get_time00(tolua_S);
00716 }
00717 #endif //#ifndef TOLUA_DISABLE
00718 
00719 /* method: get_time of class  fawkes::Clock */
00720 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_get_time02
00721 static int tolua_fawkesutils_fawkes_Clock_get_time02(lua_State* tolua_S)
00722 {
00723  tolua_Error tolua_err;
00724  if (
00725      !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
00726      !tolua_isusertype(tolua_S,2,"fawkes::Time",0,&tolua_err) ||
00727      !tolua_isnoobj(tolua_S,3,&tolua_err)
00728  )
00729   goto tolua_lerror;
00730  else
00731  {
00732   const fawkes::Clock* self = (const fawkes::Clock*)  tolua_tousertype(tolua_S,1,0);
00733   fawkes::Time* time = ((fawkes::Time*)  tolua_tousertype(tolua_S,2,0));
00734 #ifndef TOLUA_RELEASE
00735   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_time'", NULL);
00736 #endif
00737   {
00738    self->get_time(time);
00739   }
00740  }
00741  return 0;
00742 tolua_lerror:
00743  return tolua_fawkesutils_fawkes_Clock_get_time01(tolua_S);
00744 }
00745 #endif //#ifndef TOLUA_DISABLE
00746 
00747 /* method: get_time of class  fawkes::Clock */
00748 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_get_time03
00749 static int tolua_fawkesutils_fawkes_Clock_get_time03(lua_State* tolua_S)
00750 {
00751  tolua_Error tolua_err;
00752  if (
00753      !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
00754      !tolua_isusertype(tolua_S,2,"fawkes::Time",0,&tolua_err) ||
00755      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
00756      !tolua_isnoobj(tolua_S,4,&tolua_err)
00757  )
00758   goto tolua_lerror;
00759  else
00760  {
00761   const fawkes::Clock* self = (const fawkes::Clock*)  tolua_tousertype(tolua_S,1,0);
00762   fawkes::Time* time = ((fawkes::Time*)  tolua_tousertype(tolua_S,2,0));
00763   fawkes::Clock::TimesourceSelector sel = ((fawkes::Clock::TimesourceSelector) (int)  tolua_tonumber(tolua_S,3,0));
00764 #ifndef TOLUA_RELEASE
00765   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_time'", NULL);
00766 #endif
00767   {
00768    self->get_time(time,sel);
00769   }
00770  }
00771  return 0;
00772 tolua_lerror:
00773  return tolua_fawkesutils_fawkes_Clock_get_time02(tolua_S);
00774 }
00775 #endif //#ifndef TOLUA_DISABLE
00776 
00777 /* method: get_time of class  fawkes::Clock */
00778 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_get_time04
00779 static int tolua_fawkesutils_fawkes_Clock_get_time04(lua_State* tolua_S)
00780 {
00781  tolua_Error tolua_err;
00782  if (
00783      !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
00784      !tolua_isusertype(tolua_S,2,"timeval",0,&tolua_err) ||
00785      !tolua_isnoobj(tolua_S,3,&tolua_err)
00786  )
00787   goto tolua_lerror;
00788  else
00789  {
00790   const fawkes::Clock* self = (const fawkes::Clock*)  tolua_tousertype(tolua_S,1,0);
00791   struct timeval* tv = ((struct timeval*)  tolua_tousertype(tolua_S,2,0));
00792 #ifndef TOLUA_RELEASE
00793   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_time'", NULL);
00794 #endif
00795   {
00796    self->get_time(tv);
00797   }
00798  }
00799  return 0;
00800 tolua_lerror:
00801  return tolua_fawkesutils_fawkes_Clock_get_time03(tolua_S);
00802 }
00803 #endif //#ifndef TOLUA_DISABLE
00804 
00805 /* method: get_time of class  fawkes::Clock */
00806 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_get_time05
00807 static int tolua_fawkesutils_fawkes_Clock_get_time05(lua_State* tolua_S)
00808 {
00809  tolua_Error tolua_err;
00810  if (
00811      !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
00812      !tolua_isusertype(tolua_S,2,"timeval",0,&tolua_err) ||
00813      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
00814      !tolua_isnoobj(tolua_S,4,&tolua_err)
00815  )
00816   goto tolua_lerror;
00817  else
00818  {
00819   const fawkes::Clock* self = (const fawkes::Clock*)  tolua_tousertype(tolua_S,1,0);
00820   struct timeval* tv = ((struct timeval*)  tolua_tousertype(tolua_S,2,0));
00821   fawkes::Clock::TimesourceSelector sel = ((fawkes::Clock::TimesourceSelector) (int)  tolua_tonumber(tolua_S,3,0));
00822 #ifndef TOLUA_RELEASE
00823   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_time'", NULL);
00824 #endif
00825   {
00826    self->get_time(tv,sel);
00827   }
00828  }
00829  return 0;
00830 tolua_lerror:
00831  return tolua_fawkesutils_fawkes_Clock_get_time04(tolua_S);
00832 }
00833 #endif //#ifndef TOLUA_DISABLE
00834 
00835 /* method: get_systime of class  fawkes::Clock */
00836 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_get_systime00
00837 static int tolua_fawkesutils_fawkes_Clock_get_systime00(lua_State* tolua_S)
00838 {
00839 #ifndef TOLUA_RELEASE
00840  tolua_Error tolua_err;
00841  if (
00842      !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
00843      !tolua_isusertype(tolua_S,2,"timeval",0,&tolua_err) ||
00844      !tolua_isnoobj(tolua_S,3,&tolua_err)
00845  )
00846   goto tolua_lerror;
00847  else
00848 #endif
00849  {
00850   const fawkes::Clock* self = (const fawkes::Clock*)  tolua_tousertype(tolua_S,1,0);
00851   struct timeval* tv = ((struct timeval*)  tolua_tousertype(tolua_S,2,0));
00852 #ifndef TOLUA_RELEASE
00853   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_systime'", NULL);
00854 #endif
00855   {
00856    self->get_systime(tv);
00857   }
00858  }
00859  return 0;
00860 #ifndef TOLUA_RELEASE
00861  tolua_lerror:
00862  tolua_error(tolua_S,"#ferror in function 'get_systime'.",&tolua_err);
00863  return 0;
00864 #endif
00865 }
00866 #endif //#ifndef TOLUA_DISABLE
00867 
00868 /* method: get_systime of class  fawkes::Clock */
00869 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_get_systime01
00870 static int tolua_fawkesutils_fawkes_Clock_get_systime01(lua_State* tolua_S)
00871 {
00872  tolua_Error tolua_err;
00873  if (
00874      !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
00875      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"fawkes::Time",0,&tolua_err)) ||
00876      !tolua_isnoobj(tolua_S,3,&tolua_err)
00877  )
00878   goto tolua_lerror;
00879  else
00880  {
00881   const fawkes::Clock* self = (const fawkes::Clock*)  tolua_tousertype(tolua_S,1,0);
00882   fawkes::Time* time = ((fawkes::Time*)  tolua_tousertype(tolua_S,2,0));
00883 #ifndef TOLUA_RELEASE
00884   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_systime'", NULL);
00885 #endif
00886   {
00887    self->get_systime(*time);
00888   }
00889  }
00890  return 0;
00891 tolua_lerror:
00892  return tolua_fawkesutils_fawkes_Clock_get_systime00(tolua_S);
00893 }
00894 #endif //#ifndef TOLUA_DISABLE
00895 
00896 /* method: get_systime of class  fawkes::Clock */
00897 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_get_systime02
00898 static int tolua_fawkesutils_fawkes_Clock_get_systime02(lua_State* tolua_S)
00899 {
00900  tolua_Error tolua_err;
00901  if (
00902      !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
00903      !tolua_isusertype(tolua_S,2,"fawkes::Time",0,&tolua_err) ||
00904      !tolua_isnoobj(tolua_S,3,&tolua_err)
00905  )
00906   goto tolua_lerror;
00907  else
00908  {
00909   const fawkes::Clock* self = (const fawkes::Clock*)  tolua_tousertype(tolua_S,1,0);
00910   fawkes::Time* time = ((fawkes::Time*)  tolua_tousertype(tolua_S,2,0));
00911 #ifndef TOLUA_RELEASE
00912   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_systime'", NULL);
00913 #endif
00914   {
00915    self->get_systime(time);
00916   }
00917  }
00918  return 0;
00919 tolua_lerror:
00920  return tolua_fawkesutils_fawkes_Clock_get_systime01(tolua_S);
00921 }
00922 #endif //#ifndef TOLUA_DISABLE
00923 
00924 /* method: now of class  fawkes::Clock */
00925 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_now00
00926 static int tolua_fawkesutils_fawkes_Clock_now00(lua_State* tolua_S)
00927 {
00928 #ifndef TOLUA_RELEASE
00929  tolua_Error tolua_err;
00930  if (
00931      !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
00932      !tolua_isnoobj(tolua_S,2,&tolua_err)
00933  )
00934   goto tolua_lerror;
00935  else
00936 #endif
00937  {
00938   const fawkes::Clock* self = (const fawkes::Clock*)  tolua_tousertype(tolua_S,1,0);
00939 #ifndef TOLUA_RELEASE
00940   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'now'", NULL);
00941 #endif
00942   {
00943    fawkes::Time tolua_ret = (fawkes::Time)  self->now();
00944    {
00945 #ifdef __cplusplus
00946     void* tolua_obj = Mtolua_new((fawkes::Time)(tolua_ret));
00947      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::Time");
00948     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00949 #else
00950     void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::Time));
00951      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::Time");
00952     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00953 #endif
00954    }
00955   }
00956  }
00957  return 1;
00958 #ifndef TOLUA_RELEASE
00959  tolua_lerror:
00960  tolua_error(tolua_S,"#ferror in function 'now'.",&tolua_err);
00961  return 0;
00962 #endif
00963 }
00964 #endif //#ifndef TOLUA_DISABLE
00965 
00966 /* method: elapsed of class  fawkes::Clock */
00967 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_elapsed00
00968 static int tolua_fawkesutils_fawkes_Clock_elapsed00(lua_State* tolua_S)
00969 {
00970 #ifndef TOLUA_RELEASE
00971  tolua_Error tolua_err;
00972  if (
00973      !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
00974      !tolua_isusertype(tolua_S,2,"fawkes::Time",0,&tolua_err) ||
00975      !tolua_isnoobj(tolua_S,3,&tolua_err)
00976  )
00977   goto tolua_lerror;
00978  else
00979 #endif
00980  {
00981   const fawkes::Clock* self = (const fawkes::Clock*)  tolua_tousertype(tolua_S,1,0);
00982   fawkes::Time* t = ((fawkes::Time*)  tolua_tousertype(tolua_S,2,0));
00983 #ifndef TOLUA_RELEASE
00984   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'elapsed'", NULL);
00985 #endif
00986   {
00987    float tolua_ret = (float)  self->elapsed(t);
00988    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00989   }
00990  }
00991  return 1;
00992 #ifndef TOLUA_RELEASE
00993  tolua_lerror:
00994  tolua_error(tolua_S,"#ferror in function 'elapsed'.",&tolua_err);
00995  return 0;
00996 #endif
00997 }
00998 #endif //#ifndef TOLUA_DISABLE
00999 
01000 /* method: sys_elapsed of class  fawkes::Clock */
01001 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_sys_elapsed00
01002 static int tolua_fawkesutils_fawkes_Clock_sys_elapsed00(lua_State* tolua_S)
01003 {
01004 #ifndef TOLUA_RELEASE
01005  tolua_Error tolua_err;
01006  if (
01007      !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
01008      !tolua_isusertype(tolua_S,2,"fawkes::Time",0,&tolua_err) ||
01009      !tolua_isnoobj(tolua_S,3,&tolua_err)
01010  )
01011   goto tolua_lerror;
01012  else
01013 #endif
01014  {
01015   const fawkes::Clock* self = (const fawkes::Clock*)  tolua_tousertype(tolua_S,1,0);
01016   fawkes::Time* t = ((fawkes::Time*)  tolua_tousertype(tolua_S,2,0));
01017 #ifndef TOLUA_RELEASE
01018   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'sys_elapsed'", NULL);
01019 #endif
01020   {
01021    float tolua_ret = (float)  self->sys_elapsed(t);
01022    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01023   }
01024  }
01025  return 1;
01026 #ifndef TOLUA_RELEASE
01027  tolua_lerror:
01028  tolua_error(tolua_S,"#ferror in function 'sys_elapsed'.",&tolua_err);
01029  return 0;
01030 #endif
01031 }
01032 #endif //#ifndef TOLUA_DISABLE
01033 
01034 /* get function: tv_sec of class  timeval */
01035 #ifndef TOLUA_DISABLE_tolua_get_timeval_tv_sec
01036 static int tolua_get_timeval_tv_sec(lua_State* tolua_S)
01037 {
01038   timeval* self = (timeval*)  tolua_tousertype(tolua_S,1,0);
01039 #ifndef TOLUA_RELEASE
01040   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'tv_sec'",NULL);
01041 #endif
01042   tolua_pushnumber(tolua_S,(lua_Number)self->tv_sec);
01043  return 1;
01044 }
01045 #endif //#ifndef TOLUA_DISABLE
01046 
01047 /* set function: tv_sec of class  timeval */
01048 #ifndef TOLUA_DISABLE_tolua_set_timeval_tv_sec
01049 static int tolua_set_timeval_tv_sec(lua_State* tolua_S)
01050 {
01051   timeval* self = (timeval*)  tolua_tousertype(tolua_S,1,0);
01052 #ifndef TOLUA_RELEASE
01053   tolua_Error tolua_err;
01054   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'tv_sec'",NULL);
01055   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
01056    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
01057 #endif
01058   self->tv_sec = ((long int)  tolua_tonumber(tolua_S,2,0))
01059 ;
01060  return 0;
01061 }
01062 #endif //#ifndef TOLUA_DISABLE
01063 
01064 /* get function: tv_usec of class  timeval */
01065 #ifndef TOLUA_DISABLE_tolua_get_timeval_tv_usec
01066 static int tolua_get_timeval_tv_usec(lua_State* tolua_S)
01067 {
01068   timeval* self = (timeval*)  tolua_tousertype(tolua_S,1,0);
01069 #ifndef TOLUA_RELEASE
01070   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'tv_usec'",NULL);
01071 #endif
01072   tolua_pushnumber(tolua_S,(lua_Number)self->tv_usec);
01073  return 1;
01074 }
01075 #endif //#ifndef TOLUA_DISABLE
01076 
01077 /* set function: tv_usec of class  timeval */
01078 #ifndef TOLUA_DISABLE_tolua_set_timeval_tv_usec
01079 static int tolua_set_timeval_tv_usec(lua_State* tolua_S)
01080 {
01081   timeval* self = (timeval*)  tolua_tousertype(tolua_S,1,0);
01082 #ifndef TOLUA_RELEASE
01083   tolua_Error tolua_err;
01084   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'tv_usec'",NULL);
01085   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
01086    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
01087 #endif
01088   self->tv_usec = ((long int)  tolua_tonumber(tolua_S,2,0))
01089 ;
01090  return 0;
01091 }
01092 #endif //#ifndef TOLUA_DISABLE
01093 
01094 /* method: new of class  fawkes::Time */
01095 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new00
01096 static int tolua_fawkesutils_fawkes_Time_new00(lua_State* tolua_S)
01097 {
01098 #ifndef TOLUA_RELEASE
01099  tolua_Error tolua_err;
01100  if (
01101      !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
01102      !tolua_isnoobj(tolua_S,2,&tolua_err)
01103  )
01104   goto tolua_lerror;
01105  else
01106 #endif
01107  {
01108   {
01109    fawkes::Time* tolua_ret = (fawkes::Time*)  Mtolua_new((fawkes::Time)());
01110     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
01111   }
01112  }
01113  return 1;
01114 #ifndef TOLUA_RELEASE
01115  tolua_lerror:
01116  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
01117  return 0;
01118 #endif
01119 }
01120 #endif //#ifndef TOLUA_DISABLE
01121 
01122 /* method: new_local of class  fawkes::Time */
01123 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new00_local
01124 static int tolua_fawkesutils_fawkes_Time_new00_local(lua_State* tolua_S)
01125 {
01126 #ifndef TOLUA_RELEASE
01127  tolua_Error tolua_err;
01128  if (
01129      !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
01130      !tolua_isnoobj(tolua_S,2,&tolua_err)
01131  )
01132   goto tolua_lerror;
01133  else
01134 #endif
01135  {
01136   {
01137    fawkes::Time* tolua_ret = (fawkes::Time*)  Mtolua_new((fawkes::Time)());
01138     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
01139     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01140   }
01141  }
01142  return 1;
01143 #ifndef TOLUA_RELEASE
01144  tolua_lerror:
01145  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
01146  return 0;
01147 #endif
01148 }
01149 #endif //#ifndef TOLUA_DISABLE
01150 
01151 /* method: new of class  fawkes::Time */
01152 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new01
01153 static int tolua_fawkesutils_fawkes_Time_new01(lua_State* tolua_S)
01154 {
01155  tolua_Error tolua_err;
01156  if (
01157      !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
01158      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01159      !tolua_isnoobj(tolua_S,3,&tolua_err)
01160  )
01161   goto tolua_lerror;
01162  else
01163  {
01164   long ms = ((long)  tolua_tonumber(tolua_S,2,0));
01165   {
01166    fawkes::Time* tolua_ret = (fawkes::Time*)  Mtolua_new((fawkes::Time)(ms));
01167     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
01168   }
01169  }
01170  return 1;
01171 tolua_lerror:
01172  return tolua_fawkesutils_fawkes_Time_new00(tolua_S);
01173 }
01174 #endif //#ifndef TOLUA_DISABLE
01175 
01176 /* method: new_local of class  fawkes::Time */
01177 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new01_local
01178 static int tolua_fawkesutils_fawkes_Time_new01_local(lua_State* tolua_S)
01179 {
01180  tolua_Error tolua_err;
01181  if (
01182      !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
01183      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01184      !tolua_isnoobj(tolua_S,3,&tolua_err)
01185  )
01186   goto tolua_lerror;
01187  else
01188  {
01189   long ms = ((long)  tolua_tonumber(tolua_S,2,0));
01190   {
01191    fawkes::Time* tolua_ret = (fawkes::Time*)  Mtolua_new((fawkes::Time)(ms));
01192     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
01193     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01194   }
01195  }
01196  return 1;
01197 tolua_lerror:
01198  return tolua_fawkesutils_fawkes_Time_new00_local(tolua_S);
01199 }
01200 #endif //#ifndef TOLUA_DISABLE
01201 
01202 /* method: new of class  fawkes::Time */
01203 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new02
01204 static int tolua_fawkesutils_fawkes_Time_new02(lua_State* tolua_S)
01205 {
01206  tolua_Error tolua_err;
01207  if (
01208      !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
01209      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01210      !tolua_isnoobj(tolua_S,3,&tolua_err)
01211  )
01212   goto tolua_lerror;
01213  else
01214  {
01215   float sec = ((float)  tolua_tonumber(tolua_S,2,0));
01216   {
01217    fawkes::Time* tolua_ret = (fawkes::Time*)  Mtolua_new((fawkes::Time)(sec));
01218     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
01219   }
01220  }
01221  return 1;
01222 tolua_lerror:
01223  return tolua_fawkesutils_fawkes_Time_new01(tolua_S);
01224 }
01225 #endif //#ifndef TOLUA_DISABLE
01226 
01227 /* method: new_local of class  fawkes::Time */
01228 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new02_local
01229 static int tolua_fawkesutils_fawkes_Time_new02_local(lua_State* tolua_S)
01230 {
01231  tolua_Error tolua_err;
01232  if (
01233      !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
01234      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01235      !tolua_isnoobj(tolua_S,3,&tolua_err)
01236  )
01237   goto tolua_lerror;
01238  else
01239  {
01240   float sec = ((float)  tolua_tonumber(tolua_S,2,0));
01241   {
01242    fawkes::Time* tolua_ret = (fawkes::Time*)  Mtolua_new((fawkes::Time)(sec));
01243     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
01244     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01245   }
01246  }
01247  return 1;
01248 tolua_lerror:
01249  return tolua_fawkesutils_fawkes_Time_new01_local(tolua_S);
01250 }
01251 #endif //#ifndef TOLUA_DISABLE
01252 
01253 /* method: new of class  fawkes::Time */
01254 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new03
01255 static int tolua_fawkesutils_fawkes_Time_new03(lua_State* tolua_S)
01256 {
01257  tolua_Error tolua_err;
01258  if (
01259      !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
01260      !tolua_isusertype(tolua_S,2,"fawkes::Clock",0,&tolua_err) ||
01261      !tolua_isnoobj(tolua_S,3,&tolua_err)
01262  )
01263   goto tolua_lerror;
01264  else
01265  {
01266   fawkes::Clock* clock = ((fawkes::Clock*)  tolua_tousertype(tolua_S,2,0));
01267   {
01268    fawkes::Time* tolua_ret = (fawkes::Time*)  Mtolua_new((fawkes::Time)(clock));
01269     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
01270   }
01271  }
01272  return 1;
01273 tolua_lerror:
01274  return tolua_fawkesutils_fawkes_Time_new02(tolua_S);
01275 }
01276 #endif //#ifndef TOLUA_DISABLE
01277 
01278 /* method: new_local of class  fawkes::Time */
01279 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new03_local
01280 static int tolua_fawkesutils_fawkes_Time_new03_local(lua_State* tolua_S)
01281 {
01282  tolua_Error tolua_err;
01283  if (
01284      !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
01285      !tolua_isusertype(tolua_S,2,"fawkes::Clock",0,&tolua_err) ||
01286      !tolua_isnoobj(tolua_S,3,&tolua_err)
01287  )
01288   goto tolua_lerror;
01289  else
01290  {
01291   fawkes::Clock* clock = ((fawkes::Clock*)  tolua_tousertype(tolua_S,2,0));
01292   {
01293    fawkes::Time* tolua_ret = (fawkes::Time*)  Mtolua_new((fawkes::Time)(clock));
01294     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
01295     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01296   }
01297  }
01298  return 1;
01299 tolua_lerror:
01300  return tolua_fawkesutils_fawkes_Time_new02_local(tolua_S);
01301 }
01302 #endif //#ifndef TOLUA_DISABLE
01303 
01304 /* method: new of class  fawkes::Time */
01305 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new04
01306 static int tolua_fawkesutils_fawkes_Time_new04(lua_State* tolua_S)
01307 {
01308  tolua_Error tolua_err;
01309  if (
01310      !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
01311      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::Time",0,&tolua_err)) ||
01312      !tolua_isnoobj(tolua_S,3,&tolua_err)
01313  )
01314   goto tolua_lerror;
01315  else
01316  {
01317   const fawkes::Time* t = ((const fawkes::Time*)  tolua_tousertype(tolua_S,2,0));
01318   {
01319    fawkes::Time* tolua_ret = (fawkes::Time*)  Mtolua_new((fawkes::Time)(*t));
01320     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
01321   }
01322  }
01323  return 1;
01324 tolua_lerror:
01325  return tolua_fawkesutils_fawkes_Time_new03(tolua_S);
01326 }
01327 #endif //#ifndef TOLUA_DISABLE
01328 
01329 /* method: new_local of class  fawkes::Time */
01330 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new04_local
01331 static int tolua_fawkesutils_fawkes_Time_new04_local(lua_State* tolua_S)
01332 {
01333  tolua_Error tolua_err;
01334  if (
01335      !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
01336      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::Time",0,&tolua_err)) ||
01337      !tolua_isnoobj(tolua_S,3,&tolua_err)
01338  )
01339   goto tolua_lerror;
01340  else
01341  {
01342   const fawkes::Time* t = ((const fawkes::Time*)  tolua_tousertype(tolua_S,2,0));
01343   {
01344    fawkes::Time* tolua_ret = (fawkes::Time*)  Mtolua_new((fawkes::Time)(*t));
01345     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
01346     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01347   }
01348  }
01349  return 1;
01350 tolua_lerror:
01351  return tolua_fawkesutils_fawkes_Time_new03_local(tolua_S);
01352 }
01353 #endif //#ifndef TOLUA_DISABLE
01354 
01355 /* method: delete of class  fawkes::Time */
01356 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_delete00
01357 static int tolua_fawkesutils_fawkes_Time_delete00(lua_State* tolua_S)
01358 {
01359 #ifndef TOLUA_RELEASE
01360  tolua_Error tolua_err;
01361  if (
01362      !tolua_isusertype(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
01363      !tolua_isnoobj(tolua_S,2,&tolua_err)
01364  )
01365   goto tolua_lerror;
01366  else
01367 #endif
01368  {
01369   fawkes::Time* self = (fawkes::Time*)  tolua_tousertype(tolua_S,1,0);
01370 #ifndef TOLUA_RELEASE
01371   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
01372 #endif
01373   Mtolua_delete(self);
01374  }
01375  return 0;
01376 #ifndef TOLUA_RELEASE
01377  tolua_lerror:
01378  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
01379  return 0;
01380 #endif
01381 }
01382 #endif //#ifndef TOLUA_DISABLE
01383 
01384 /* method: in_sec of class  fawkes::Time */
01385 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_in_sec00
01386 static int tolua_fawkesutils_fawkes_Time_in_sec00(lua_State* tolua_S)
01387 {
01388 #ifndef TOLUA_RELEASE
01389  tolua_Error tolua_err;
01390  if (
01391      !tolua_isusertype(tolua_S,1,"const fawkes::Time",0,&tolua_err) ||
01392      !tolua_isnoobj(tolua_S,2,&tolua_err)
01393  )
01394   goto tolua_lerror;
01395  else
01396 #endif
01397  {
01398   const fawkes::Time* self = (const fawkes::Time*)  tolua_tousertype(tolua_S,1,0);
01399 #ifndef TOLUA_RELEASE
01400   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'in_sec'", NULL);
01401 #endif
01402   {
01403    float tolua_ret = (float)  self->in_sec();
01404    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01405   }
01406  }
01407  return 1;
01408 #ifndef TOLUA_RELEASE
01409  tolua_lerror:
01410  tolua_error(tolua_S,"#ferror in function 'in_sec'.",&tolua_err);
01411  return 0;
01412 #endif
01413 }
01414 #endif //#ifndef TOLUA_DISABLE
01415 
01416 /* method: in_msec of class  fawkes::Time */
01417 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_in_msec00
01418 static int tolua_fawkesutils_fawkes_Time_in_msec00(lua_State* tolua_S)
01419 {
01420 #ifndef TOLUA_RELEASE
01421  tolua_Error tolua_err;
01422  if (
01423      !tolua_isusertype(tolua_S,1,"const fawkes::Time",0,&tolua_err) ||
01424      !tolua_isnoobj(tolua_S,2,&tolua_err)
01425  )
01426   goto tolua_lerror;
01427  else
01428 #endif
01429  {
01430   const fawkes::Time* self = (const fawkes::Time*)  tolua_tousertype(tolua_S,1,0);
01431 #ifndef TOLUA_RELEASE
01432   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'in_msec'", NULL);
01433 #endif
01434   {
01435    long tolua_ret = (long)  self->in_msec();
01436    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01437   }
01438  }
01439  return 1;
01440 #ifndef TOLUA_RELEASE
01441  tolua_lerror:
01442  tolua_error(tolua_S,"#ferror in function 'in_msec'.",&tolua_err);
01443  return 0;
01444 #endif
01445 }
01446 #endif //#ifndef TOLUA_DISABLE
01447 
01448 /* method: in_usec of class  fawkes::Time */
01449 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_in_usec00
01450 static int tolua_fawkesutils_fawkes_Time_in_usec00(lua_State* tolua_S)
01451 {
01452 #ifndef TOLUA_RELEASE
01453  tolua_Error tolua_err;
01454  if (
01455      !tolua_isusertype(tolua_S,1,"const fawkes::Time",0,&tolua_err) ||
01456      !tolua_isnoobj(tolua_S,2,&tolua_err)
01457  )
01458   goto tolua_lerror;
01459  else
01460 #endif
01461  {
01462   const fawkes::Time* self = (const fawkes::Time*)  tolua_tousertype(tolua_S,1,0);
01463 #ifndef TOLUA_RELEASE
01464   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'in_usec'", NULL);
01465 #endif
01466   {
01467    long tolua_ret = (long)  self->in_usec();
01468    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01469   }
01470  }
01471  return 1;
01472 #ifndef TOLUA_RELEASE
01473  tolua_lerror:
01474  tolua_error(tolua_S,"#ferror in function 'in_usec'.",&tolua_err);
01475  return 0;
01476 #endif
01477 }
01478 #endif //#ifndef TOLUA_DISABLE
01479 
01480 /* method: get_timeval of class  fawkes::Time */
01481 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_get_timeval00
01482 static int tolua_fawkesutils_fawkes_Time_get_timeval00(lua_State* tolua_S)
01483 {
01484 #ifndef TOLUA_RELEASE
01485  tolua_Error tolua_err;
01486  if (
01487      !tolua_isusertype(tolua_S,1,"const fawkes::Time",0,&tolua_err) ||
01488      !tolua_isnoobj(tolua_S,2,&tolua_err)
01489  )
01490   goto tolua_lerror;
01491  else
01492 #endif
01493  {
01494   const fawkes::Time* self = (const fawkes::Time*)  tolua_tousertype(tolua_S,1,0);
01495 #ifndef TOLUA_RELEASE
01496   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_timeval'", NULL);
01497 #endif
01498   {
01499    const timeval* tolua_ret = (const timeval*)  self->get_timeval();
01500     tolua_pushusertype(tolua_S,(void*)tolua_ret,"const timeval");
01501   }
01502  }
01503  return 1;
01504 #ifndef TOLUA_RELEASE
01505  tolua_lerror:
01506  tolua_error(tolua_S,"#ferror in function 'get_timeval'.",&tolua_err);
01507  return 0;
01508 #endif
01509 }
01510 #endif //#ifndef TOLUA_DISABLE
01511 
01512 /* method: set_time of class  fawkes::Time */
01513 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_set_time00
01514 static int tolua_fawkesutils_fawkes_Time_set_time00(lua_State* tolua_S)
01515 {
01516 #ifndef TOLUA_RELEASE
01517  tolua_Error tolua_err;
01518  if (
01519      !tolua_isusertype(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
01520      !tolua_isusertype(tolua_S,2,"const timeval",0,&tolua_err) ||
01521      !tolua_isnoobj(tolua_S,3,&tolua_err)
01522  )
01523   goto tolua_lerror;
01524  else
01525 #endif
01526  {
01527   fawkes::Time* self = (fawkes::Time*)  tolua_tousertype(tolua_S,1,0);
01528   const timeval* tv = ((const timeval*)  tolua_tousertype(tolua_S,2,0));
01529 #ifndef TOLUA_RELEASE
01530   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_time'", NULL);
01531 #endif
01532   {
01533    self->set_time(tv);
01534   }
01535  }
01536  return 0;
01537 #ifndef TOLUA_RELEASE
01538  tolua_lerror:
01539  tolua_error(tolua_S,"#ferror in function 'set_time'.",&tolua_err);
01540  return 0;
01541 #endif
01542 }
01543 #endif //#ifndef TOLUA_DISABLE
01544 
01545 /* method: set_time of class  fawkes::Time */
01546 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_set_time01
01547 static int tolua_fawkesutils_fawkes_Time_set_time01(lua_State* tolua_S)
01548 {
01549  tolua_Error tolua_err;
01550  if (
01551      !tolua_isusertype(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
01552      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01553      !tolua_isnoobj(tolua_S,3,&tolua_err)
01554  )
01555   goto tolua_lerror;
01556  else
01557  {
01558   fawkes::Time* self = (fawkes::Time*)  tolua_tousertype(tolua_S,1,0);
01559   long ms = ((long)  tolua_tonumber(tolua_S,2,0));
01560 #ifndef TOLUA_RELEASE
01561   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_time'", NULL);
01562 #endif
01563   {
01564    self->set_time(ms);
01565   }
01566  }
01567  return 0;
01568 tolua_lerror:
01569  return tolua_fawkesutils_fawkes_Time_set_time00(tolua_S);
01570 }
01571 #endif //#ifndef TOLUA_DISABLE
01572 
01573 /* method: set_time of class  fawkes::Time */
01574 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_set_time02
01575 static int tolua_fawkesutils_fawkes_Time_set_time02(lua_State* tolua_S)
01576 {
01577  tolua_Error tolua_err;
01578  if (
01579      !tolua_isusertype(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
01580      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01581      !tolua_isnoobj(tolua_S,3,&tolua_err)
01582  )
01583   goto tolua_lerror;
01584  else
01585  {
01586   fawkes::Time* self = (fawkes::Time*)  tolua_tousertype(tolua_S,1,0);
01587   float sec = ((float)  tolua_tonumber(tolua_S,2,0));
01588 #ifndef TOLUA_RELEASE
01589   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_time'", NULL);
01590 #endif
01591   {
01592    self->set_time(sec);
01593   }
01594  }
01595  return 0;
01596 tolua_lerror:
01597  return tolua_fawkesutils_fawkes_Time_set_time01(tolua_S);
01598 }
01599 #endif //#ifndef TOLUA_DISABLE
01600 
01601 /* method: set_time of class  fawkes::Time */
01602 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_set_time03
01603 static int tolua_fawkesutils_fawkes_Time_set_time03(lua_State* tolua_S)
01604 {
01605  tolua_Error tolua_err;
01606  if (
01607      !tolua_isusertype(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
01608      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::Time",0,&tolua_err)) ||
01609      !tolua_isnoobj(tolua_S,3,&tolua_err)
01610  )
01611   goto tolua_lerror;
01612  else
01613  {
01614   fawkes::Time* self = (fawkes::Time*)  tolua_tousertype(tolua_S,1,0);
01615   const fawkes::Time* t = ((const fawkes::Time*)  tolua_tousertype(tolua_S,2,0));
01616 #ifndef TOLUA_RELEASE
01617   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_time'", NULL);
01618 #endif
01619   {
01620    self->set_time(*t);
01621   }
01622  }
01623  return 0;
01624 tolua_lerror:
01625  return tolua_fawkesutils_fawkes_Time_set_time02(tolua_S);
01626 }
01627 #endif //#ifndef TOLUA_DISABLE
01628 
01629 /* method: add of class  fawkes::Time */
01630 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_add00
01631 static int tolua_fawkesutils_fawkes_Time_add00(lua_State* tolua_S)
01632 {
01633 #ifndef TOLUA_RELEASE
01634  tolua_Error tolua_err;
01635  if (
01636      !tolua_isusertype(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
01637      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01638      !tolua_isnoobj(tolua_S,3,&tolua_err)
01639  )
01640   goto tolua_lerror;
01641  else
01642 #endif
01643  {
01644   fawkes::Time* self = (fawkes::Time*)  tolua_tousertype(tolua_S,1,0);
01645   float seconds = ((float)  tolua_tonumber(tolua_S,2,0));
01646 #ifndef TOLUA_RELEASE
01647   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'add'", NULL);
01648 #endif
01649   {
01650    self->add(seconds);
01651   }
01652  }
01653  return 0;
01654 #ifndef TOLUA_RELEASE
01655  tolua_lerror:
01656  tolua_error(tolua_S,"#ferror in function 'add'.",&tolua_err);
01657  return 0;
01658 #endif
01659 }
01660 #endif //#ifndef TOLUA_DISABLE
01661 
01662 /* method: stamp of class  fawkes::Time */
01663 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_stamp00
01664 static int tolua_fawkesutils_fawkes_Time_stamp00(lua_State* tolua_S)
01665 {
01666 #ifndef TOLUA_RELEASE
01667  tolua_Error tolua_err;
01668  if (
01669      !tolua_isusertype(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
01670      !tolua_isnoobj(tolua_S,2,&tolua_err)
01671  )
01672   goto tolua_lerror;
01673  else
01674 #endif
01675  {
01676   fawkes::Time* self = (fawkes::Time*)  tolua_tousertype(tolua_S,1,0);
01677 #ifndef TOLUA_RELEASE
01678   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'stamp'", NULL);
01679 #endif
01680   {
01681    fawkes::Time& tolua_ret = (fawkes::Time&)  self->stamp();
01682     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"fawkes::Time");
01683   }
01684  }
01685  return 1;
01686 #ifndef TOLUA_RELEASE
01687  tolua_lerror:
01688  tolua_error(tolua_S,"#ferror in function 'stamp'.",&tolua_err);
01689  return 0;
01690 #endif
01691 }
01692 #endif //#ifndef TOLUA_DISABLE
01693 
01694 /* method: operator+ of class  fawkes::Time */
01695 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time__add00
01696 static int tolua_fawkesutils_fawkes_Time__add00(lua_State* tolua_S)
01697 {
01698 #ifndef TOLUA_RELEASE
01699  tolua_Error tolua_err;
01700  if (
01701      !tolua_isusertype(tolua_S,1,"const fawkes::Time",0,&tolua_err) ||
01702      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::Time",0,&tolua_err)) ||
01703      !tolua_isnoobj(tolua_S,3,&tolua_err)
01704  )
01705   goto tolua_lerror;
01706  else
01707 #endif
01708  {
01709   const fawkes::Time* self = (const fawkes::Time*)  tolua_tousertype(tolua_S,1,0);
01710   const fawkes::Time* t = ((const fawkes::Time*)  tolua_tousertype(tolua_S,2,0));
01711 #ifndef TOLUA_RELEASE
01712   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator+'", NULL);
01713 #endif
01714   {
01715    fawkes::Time tolua_ret = (fawkes::Time)  self->operator+(*t);
01716    {
01717 #ifdef __cplusplus
01718     void* tolua_obj = Mtolua_new((fawkes::Time)(tolua_ret));
01719      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::Time");
01720     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01721 #else
01722     void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::Time));
01723      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::Time");
01724     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01725 #endif
01726    }
01727   }
01728  }
01729  return 1;
01730 #ifndef TOLUA_RELEASE
01731  tolua_lerror:
01732  tolua_error(tolua_S,"#ferror in function '.add'.",&tolua_err);
01733  return 0;
01734 #endif
01735 }
01736 #endif //#ifndef TOLUA_DISABLE
01737 
01738 /* method: operator- of class  fawkes::Time */
01739 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time__sub00
01740 static int tolua_fawkesutils_fawkes_Time__sub00(lua_State* tolua_S)
01741 {
01742 #ifndef TOLUA_RELEASE
01743  tolua_Error tolua_err;
01744  if (
01745      !tolua_isusertype(tolua_S,1,"const fawkes::Time",0,&tolua_err) ||
01746      !tolua_isusertype(tolua_S,2,"const fawkes::Time",0,&tolua_err) ||
01747      !tolua_isnoobj(tolua_S,3,&tolua_err)
01748  )
01749   goto tolua_lerror;
01750  else
01751 #endif
01752  {
01753   const fawkes::Time* self = (const fawkes::Time*)  tolua_tousertype(tolua_S,1,0);
01754   const fawkes::Time* t = ((const fawkes::Time*)  tolua_tousertype(tolua_S,2,0));
01755 #ifndef TOLUA_RELEASE
01756   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator-'", NULL);
01757 #endif
01758   {
01759    float tolua_ret = (float)  self->operator-(t);
01760    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01761   }
01762  }
01763  return 1;
01764 #ifndef TOLUA_RELEASE
01765  tolua_lerror:
01766  tolua_error(tolua_S,"#ferror in function '.sub'.",&tolua_err);
01767  return 0;
01768 #endif
01769 }
01770 #endif //#ifndef TOLUA_DISABLE
01771 
01772 /* method: str of class  fawkes::Time */
01773 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_str00
01774 static int tolua_fawkesutils_fawkes_Time_str00(lua_State* tolua_S)
01775 {
01776 #ifndef TOLUA_RELEASE
01777  tolua_Error tolua_err;
01778  if (
01779      !tolua_isusertype(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
01780      !tolua_isnoobj(tolua_S,2,&tolua_err)
01781  )
01782   goto tolua_lerror;
01783  else
01784 #endif
01785  {
01786   fawkes::Time* self = (fawkes::Time*)  tolua_tousertype(tolua_S,1,0);
01787 #ifndef TOLUA_RELEASE
01788   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'str'", NULL);
01789 #endif
01790   {
01791    const char* tolua_ret = (const char*)  self->str();
01792    tolua_pushstring(tolua_S,(const char*)tolua_ret);
01793   }
01794  }
01795  return 1;
01796 #ifndef TOLUA_RELEASE
01797  tolua_lerror:
01798  tolua_error(tolua_S,"#ferror in function 'str'.",&tolua_err);
01799  return 0;
01800 #endif
01801 }
01802 #endif //#ifndef TOLUA_DISABLE
01803 
01804 /* method: str_r of class  fawkes::Time */
01805 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_str_r00
01806 static int tolua_fawkesutils_fawkes_Time_str_r00(lua_State* tolua_S)
01807 {
01808 #ifndef TOLUA_RELEASE
01809  tolua_Error tolua_err;
01810  if (
01811      !tolua_isusertype(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
01812      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
01813      !tolua_isnoobj(tolua_S,3,&tolua_err)
01814  )
01815   goto tolua_lerror;
01816  else
01817 #endif
01818  {
01819   fawkes::Time* self = (fawkes::Time*)  tolua_tousertype(tolua_S,1,0);
01820   char* s = ((char*)  tolua_tostring(tolua_S,2,0));
01821 #ifndef TOLUA_RELEASE
01822   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'str_r'", NULL);
01823 #endif
01824   {
01825    self->str_r(s);
01826   }
01827  }
01828  return 0;
01829 #ifndef TOLUA_RELEASE
01830  tolua_lerror:
01831  tolua_error(tolua_S,"#ferror in function 'str_r'.",&tolua_err);
01832  return 0;
01833 #endif
01834 }
01835 #endif //#ifndef TOLUA_DISABLE
01836 
01837 /* Open function */
01838 TOLUA_API int tolua_fawkesutils_open (lua_State* tolua_S)
01839 {
01840  tolua_open(tolua_S);
01841  tolua_reg_types(tolua_S);
01842  tolua_module(tolua_S,NULL,0);
01843  tolua_beginmodule(tolua_S,NULL);
01844   tolua_module(tolua_S,"fawkes",0);
01845   tolua_beginmodule(tolua_S,"fawkes");
01846    #ifdef __cplusplus
01847    tolua_cclass(tolua_S,"KalmanFilter1D","fawkes::KalmanFilter1D","",tolua_collect_fawkes__KalmanFilter1D);
01848    #else
01849    tolua_cclass(tolua_S,"KalmanFilter1D","fawkes::KalmanFilter1D","",NULL);
01850    #endif
01851    tolua_beginmodule(tolua_S,"KalmanFilter1D");
01852     tolua_function(tolua_S,"new",tolua_fawkesutils_fawkes_KalmanFilter1D_new00);
01853     tolua_function(tolua_S,"new_local",tolua_fawkesutils_fawkes_KalmanFilter1D_new00_local);
01854     tolua_function(tolua_S,".call",tolua_fawkesutils_fawkes_KalmanFilter1D_new00_local);
01855     tolua_function(tolua_S,"delete",tolua_fawkesutils_fawkes_KalmanFilter1D_delete00);
01856     tolua_function(tolua_S,"filter",tolua_fawkesutils_fawkes_KalmanFilter1D_filter00);
01857     tolua_function(tolua_S,"filter",tolua_fawkesutils_fawkes_KalmanFilter1D_filter01);
01858     tolua_function(tolua_S,"predict",tolua_fawkesutils_fawkes_KalmanFilter1D_predict00);
01859     tolua_function(tolua_S,"predict",tolua_fawkesutils_fawkes_KalmanFilter1D_predict01);
01860     tolua_function(tolua_S,"predict",tolua_fawkesutils_fawkes_KalmanFilter1D_predict02);
01861     tolua_function(tolua_S,"predict",tolua_fawkesutils_fawkes_KalmanFilter1D_predict03);
01862    tolua_endmodule(tolua_S);
01863   tolua_endmodule(tolua_S);
01864   tolua_module(tolua_S,"fawkes",0);
01865   tolua_beginmodule(tolua_S,"fawkes");
01866    tolua_cclass(tolua_S,"ComponentLogger","fawkes::ComponentLogger","",NULL);
01867    tolua_beginmodule(tolua_S,"ComponentLogger");
01868     tolua_function(tolua_S,"log_debug",tolua_fawkesutils_fawkes_ComponentLogger_log_debug00);
01869     tolua_function(tolua_S,"log_info",tolua_fawkesutils_fawkes_ComponentLogger_log_info00);
01870     tolua_function(tolua_S,"log_warn",tolua_fawkesutils_fawkes_ComponentLogger_log_warn00);
01871     tolua_function(tolua_S,"log_error",tolua_fawkesutils_fawkes_ComponentLogger_log_error00);
01872    tolua_endmodule(tolua_S);
01873   tolua_endmodule(tolua_S);
01874   tolua_module(tolua_S,"fawkes",0);
01875   tolua_beginmodule(tolua_S,"fawkes");
01876    tolua_cclass(tolua_S,"Clock","fawkes::Clock","",NULL);
01877    tolua_beginmodule(tolua_S,"Clock");
01878     tolua_constant(tolua_S,"DEFAULT",fawkes::Clock::DEFAULT);
01879     tolua_constant(tolua_S,"REALTIME",fawkes::Clock::REALTIME);
01880     tolua_constant(tolua_S,"EXTERNAL",fawkes::Clock::EXTERNAL);
01881     tolua_function(tolua_S,"instance",tolua_fawkesutils_fawkes_Clock_instance00);
01882     tolua_function(tolua_S,"finalize",tolua_fawkesutils_fawkes_Clock_finalize00);
01883     tolua_function(tolua_S,"is_ext_default_timesource",tolua_fawkesutils_fawkes_Clock_is_ext_default_timesource00);
01884     tolua_function(tolua_S,"has_ext_timesource",tolua_fawkesutils_fawkes_Clock_has_ext_timesource00);
01885     tolua_function(tolua_S,"ext_to_realtime",tolua_fawkesutils_fawkes_Clock_ext_to_realtime00);
01886     tolua_function(tolua_S,"get_time",tolua_fawkesutils_fawkes_Clock_get_time00);
01887     tolua_function(tolua_S,"get_time",tolua_fawkesutils_fawkes_Clock_get_time01);
01888     tolua_function(tolua_S,"get_time",tolua_fawkesutils_fawkes_Clock_get_time02);
01889     tolua_function(tolua_S,"get_time",tolua_fawkesutils_fawkes_Clock_get_time03);
01890     tolua_function(tolua_S,"get_time",tolua_fawkesutils_fawkes_Clock_get_time04);
01891     tolua_function(tolua_S,"get_time",tolua_fawkesutils_fawkes_Clock_get_time05);
01892     tolua_function(tolua_S,"get_systime",tolua_fawkesutils_fawkes_Clock_get_systime00);
01893     tolua_function(tolua_S,"get_systime",tolua_fawkesutils_fawkes_Clock_get_systime01);
01894     tolua_function(tolua_S,"get_systime",tolua_fawkesutils_fawkes_Clock_get_systime02);
01895     tolua_function(tolua_S,"now",tolua_fawkesutils_fawkes_Clock_now00);
01896     tolua_function(tolua_S,"elapsed",tolua_fawkesutils_fawkes_Clock_elapsed00);
01897     tolua_function(tolua_S,"sys_elapsed",tolua_fawkesutils_fawkes_Clock_sys_elapsed00);
01898    tolua_endmodule(tolua_S);
01899   tolua_endmodule(tolua_S);
01900   tolua_cclass(tolua_S,"timeval","timeval","",NULL);
01901   tolua_beginmodule(tolua_S,"timeval");
01902    tolua_variable(tolua_S,"tv_sec",tolua_get_timeval_tv_sec,tolua_set_timeval_tv_sec);
01903    tolua_variable(tolua_S,"tv_usec",tolua_get_timeval_tv_usec,tolua_set_timeval_tv_usec);
01904   tolua_endmodule(tolua_S);
01905   tolua_module(tolua_S,"fawkes",0);
01906   tolua_beginmodule(tolua_S,"fawkes");
01907    #ifdef __cplusplus
01908    tolua_cclass(tolua_S,"Time","fawkes::Time","",tolua_collect_fawkes__Time);
01909    #else
01910    tolua_cclass(tolua_S,"Time","fawkes::Time","",NULL);
01911    #endif
01912    tolua_beginmodule(tolua_S,"Time");
01913     tolua_function(tolua_S,"new",tolua_fawkesutils_fawkes_Time_new00);
01914     tolua_function(tolua_S,"new_local",tolua_fawkesutils_fawkes_Time_new00_local);
01915     tolua_function(tolua_S,".call",tolua_fawkesutils_fawkes_Time_new00_local);
01916     tolua_function(tolua_S,"new",tolua_fawkesutils_fawkes_Time_new01);
01917     tolua_function(tolua_S,"new_local",tolua_fawkesutils_fawkes_Time_new01_local);
01918     tolua_function(tolua_S,".call",tolua_fawkesutils_fawkes_Time_new01_local);
01919     tolua_function(tolua_S,"new",tolua_fawkesutils_fawkes_Time_new02);
01920     tolua_function(tolua_S,"new_local",tolua_fawkesutils_fawkes_Time_new02_local);
01921     tolua_function(tolua_S,".call",tolua_fawkesutils_fawkes_Time_new02_local);
01922     tolua_function(tolua_S,"new",tolua_fawkesutils_fawkes_Time_new03);
01923     tolua_function(tolua_S,"new_local",tolua_fawkesutils_fawkes_Time_new03_local);
01924     tolua_function(tolua_S,".call",tolua_fawkesutils_fawkes_Time_new03_local);
01925     tolua_function(tolua_S,"new",tolua_fawkesutils_fawkes_Time_new04);
01926     tolua_function(tolua_S,"new_local",tolua_fawkesutils_fawkes_Time_new04_local);
01927     tolua_function(tolua_S,".call",tolua_fawkesutils_fawkes_Time_new04_local);
01928     tolua_function(tolua_S,"delete",tolua_fawkesutils_fawkes_Time_delete00);
01929     tolua_function(tolua_S,"in_sec",tolua_fawkesutils_fawkes_Time_in_sec00);
01930     tolua_function(tolua_S,"in_msec",tolua_fawkesutils_fawkes_Time_in_msec00);
01931     tolua_function(tolua_S,"in_usec",tolua_fawkesutils_fawkes_Time_in_usec00);
01932     tolua_function(tolua_S,"get_timeval",tolua_fawkesutils_fawkes_Time_get_timeval00);
01933     tolua_function(tolua_S,"set_time",tolua_fawkesutils_fawkes_Time_set_time00);
01934     tolua_function(tolua_S,"set_time",tolua_fawkesutils_fawkes_Time_set_time01);
01935     tolua_function(tolua_S,"set_time",tolua_fawkesutils_fawkes_Time_set_time02);
01936     tolua_function(tolua_S,"set_time",tolua_fawkesutils_fawkes_Time_set_time03);
01937     tolua_function(tolua_S,"add",tolua_fawkesutils_fawkes_Time_add00);
01938     tolua_function(tolua_S,"stamp",tolua_fawkesutils_fawkes_Time_stamp00);
01939     tolua_function(tolua_S,".add",tolua_fawkesutils_fawkes_Time__add00);
01940     tolua_function(tolua_S,".sub",tolua_fawkesutils_fawkes_Time__sub00);
01941     tolua_function(tolua_S,"str",tolua_fawkesutils_fawkes_Time_str00);
01942     tolua_function(tolua_S,"str_r",tolua_fawkesutils_fawkes_Time_str_r00);
01943    tolua_endmodule(tolua_S);
01944   tolua_endmodule(tolua_S);
01945  tolua_endmodule(tolua_S);
01946  return 1;
01947 }
01948 
01949 
01950 extern "C" {
01951 #if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501
01952  TOLUA_API int luaopen_fawkesutils (lua_State* tolua_S) {
01953  return tolua_fawkesutils_open(tolua_S);
01954 };
01955 #endif
01956 }
01957 
01958