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