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