Fawkes API
Fawkes Development Version
|
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