Fawkes API Fawkes Development Version
|
00001 /* 00002 ** Lua binding: interfaces_TestInterface 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_interfaces_TestInterface_open (lua_State* tolua_S); 00028 00029 #include <interfaces/TestInterface.h> 00030 using namespace fawkes; 00031 00032 /* function to release collected object via destructor */ 00033 #ifdef __cplusplus 00034 00035 static int tolua_collect_fawkes__TestInterface__SetTestIntMessage (lua_State* tolua_S) 00036 { 00037 fawkes::TestInterface::SetTestIntMessage* self = (fawkes::TestInterface::SetTestIntMessage*) tolua_tousertype(tolua_S,1,0); 00038 Mtolua_delete(self); 00039 return 0; 00040 } 00041 00042 static int tolua_collect_fawkes__TestInterface__CalculateMessage (lua_State* tolua_S) 00043 { 00044 fawkes::TestInterface::CalculateMessage* self = (fawkes::TestInterface::CalculateMessage*) tolua_tousertype(tolua_S,1,0); 00045 Mtolua_delete(self); 00046 return 0; 00047 } 00048 00049 static int tolua_collect_fawkes__TestInterface__SetTestStringMessage (lua_State* tolua_S) 00050 { 00051 fawkes::TestInterface::SetTestStringMessage* self = (fawkes::TestInterface::SetTestStringMessage*) tolua_tousertype(tolua_S,1,0); 00052 Mtolua_delete(self); 00053 return 0; 00054 } 00055 #endif 00056 00057 00058 /* function to register type */ 00059 static void tolua_reg_types (lua_State* tolua_S) 00060 { 00061 tolua_usertype(tolua_S,"Message"); 00062 tolua_usertype(tolua_S,"fawkes::TestInterface::SetTestIntMessage"); 00063 tolua_usertype(tolua_S,"fawkes::TestInterface"); 00064 tolua_usertype(tolua_S,"fawkes::TestInterface::CalculateMessage"); 00065 tolua_usertype(tolua_S,"fawkes::TestInterface::SetTestStringMessage"); 00066 tolua_usertype(tolua_S,"Interface"); 00067 } 00068 00069 /* get function: TEST_CONSTANT of class fawkes::TestInterface */ 00070 #ifndef TOLUA_DISABLE_tolua_get_fawkes__TestInterface_TEST_CONSTANT 00071 static int tolua_get_fawkes__TestInterface_TEST_CONSTANT(lua_State* tolua_S) 00072 { 00073 tolua_pushnumber(tolua_S,(lua_Number)fawkes::TestInterface::TEST_CONSTANT); 00074 return 1; 00075 } 00076 #endif //#ifndef TOLUA_DISABLE 00077 00078 /* get function: TEST_FLOAT_CONSTANT of class fawkes::TestInterface */ 00079 #ifndef TOLUA_DISABLE_tolua_get_fawkes__TestInterface_TEST_FLOAT_CONSTANT 00080 static int tolua_get_fawkes__TestInterface_TEST_FLOAT_CONSTANT(lua_State* tolua_S) 00081 { 00082 tolua_pushnumber(tolua_S,(lua_Number)fawkes::TestInterface::TEST_FLOAT_CONSTANT); 00083 return 1; 00084 } 00085 #endif //#ifndef TOLUA_DISABLE 00086 00087 /* method: new of class SetTestIntMessage */ 00088 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_new00 00089 static int tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_new00(lua_State* tolua_S) 00090 { 00091 #ifndef TOLUA_RELEASE 00092 tolua_Error tolua_err; 00093 if ( 00094 !tolua_isusertable(tolua_S,1,"fawkes::TestInterface::SetTestIntMessage",0,&tolua_err) || 00095 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 00096 !tolua_isnoobj(tolua_S,3,&tolua_err) 00097 ) 00098 goto tolua_lerror; 00099 else 00100 #endif 00101 { 00102 int ini_test_int = ((int) tolua_tonumber(tolua_S,2,0)); 00103 { 00104 fawkes::TestInterface::SetTestIntMessage* tolua_ret = (fawkes::TestInterface::SetTestIntMessage*) Mtolua_new((fawkes::TestInterface::SetTestIntMessage)(ini_test_int)); 00105 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::TestInterface::SetTestIntMessage"); 00106 } 00107 } 00108 return 1; 00109 #ifndef TOLUA_RELEASE 00110 tolua_lerror: 00111 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 00112 return 0; 00113 #endif 00114 } 00115 #endif //#ifndef TOLUA_DISABLE 00116 00117 /* method: new_local of class SetTestIntMessage */ 00118 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_new00_local 00119 static int tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_new00_local(lua_State* tolua_S) 00120 { 00121 #ifndef TOLUA_RELEASE 00122 tolua_Error tolua_err; 00123 if ( 00124 !tolua_isusertable(tolua_S,1,"fawkes::TestInterface::SetTestIntMessage",0,&tolua_err) || 00125 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 00126 !tolua_isnoobj(tolua_S,3,&tolua_err) 00127 ) 00128 goto tolua_lerror; 00129 else 00130 #endif 00131 { 00132 int ini_test_int = ((int) tolua_tonumber(tolua_S,2,0)); 00133 { 00134 fawkes::TestInterface::SetTestIntMessage* tolua_ret = (fawkes::TestInterface::SetTestIntMessage*) Mtolua_new((fawkes::TestInterface::SetTestIntMessage)(ini_test_int)); 00135 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::TestInterface::SetTestIntMessage"); 00136 tolua_register_gc(tolua_S,lua_gettop(tolua_S)); 00137 } 00138 } 00139 return 1; 00140 #ifndef TOLUA_RELEASE 00141 tolua_lerror: 00142 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 00143 return 0; 00144 #endif 00145 } 00146 #endif //#ifndef TOLUA_DISABLE 00147 00148 /* method: new of class SetTestIntMessage */ 00149 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_new01 00150 static int tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_new01(lua_State* tolua_S) 00151 { 00152 tolua_Error tolua_err; 00153 if ( 00154 !tolua_isusertable(tolua_S,1,"fawkes::TestInterface::SetTestIntMessage",0,&tolua_err) || 00155 !tolua_isnoobj(tolua_S,2,&tolua_err) 00156 ) 00157 goto tolua_lerror; 00158 else 00159 { 00160 { 00161 fawkes::TestInterface::SetTestIntMessage* tolua_ret = (fawkes::TestInterface::SetTestIntMessage*) Mtolua_new((fawkes::TestInterface::SetTestIntMessage)()); 00162 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::TestInterface::SetTestIntMessage"); 00163 } 00164 } 00165 return 1; 00166 tolua_lerror: 00167 return tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_new00(tolua_S); 00168 } 00169 #endif //#ifndef TOLUA_DISABLE 00170 00171 /* method: new_local of class SetTestIntMessage */ 00172 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_new01_local 00173 static int tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_new01_local(lua_State* tolua_S) 00174 { 00175 tolua_Error tolua_err; 00176 if ( 00177 !tolua_isusertable(tolua_S,1,"fawkes::TestInterface::SetTestIntMessage",0,&tolua_err) || 00178 !tolua_isnoobj(tolua_S,2,&tolua_err) 00179 ) 00180 goto tolua_lerror; 00181 else 00182 { 00183 { 00184 fawkes::TestInterface::SetTestIntMessage* tolua_ret = (fawkes::TestInterface::SetTestIntMessage*) Mtolua_new((fawkes::TestInterface::SetTestIntMessage)()); 00185 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::TestInterface::SetTestIntMessage"); 00186 tolua_register_gc(tolua_S,lua_gettop(tolua_S)); 00187 } 00188 } 00189 return 1; 00190 tolua_lerror: 00191 return tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_new00_local(tolua_S); 00192 } 00193 #endif //#ifndef TOLUA_DISABLE 00194 00195 /* method: delete of class SetTestIntMessage */ 00196 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_delete00 00197 static int tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_delete00(lua_State* tolua_S) 00198 { 00199 #ifndef TOLUA_RELEASE 00200 tolua_Error tolua_err; 00201 if ( 00202 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface::SetTestIntMessage",0,&tolua_err) || 00203 !tolua_isnoobj(tolua_S,2,&tolua_err) 00204 ) 00205 goto tolua_lerror; 00206 else 00207 #endif 00208 { 00209 fawkes::TestInterface::SetTestIntMessage* self = (fawkes::TestInterface::SetTestIntMessage*) tolua_tousertype(tolua_S,1,0); 00210 #ifndef TOLUA_RELEASE 00211 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL); 00212 #endif 00213 Mtolua_delete(self); 00214 } 00215 return 0; 00216 #ifndef TOLUA_RELEASE 00217 tolua_lerror: 00218 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err); 00219 return 0; 00220 #endif 00221 } 00222 #endif //#ifndef TOLUA_DISABLE 00223 00224 /* method: test_int of class SetTestIntMessage */ 00225 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_test_int00 00226 static int tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_test_int00(lua_State* tolua_S) 00227 { 00228 #ifndef TOLUA_RELEASE 00229 tolua_Error tolua_err; 00230 if ( 00231 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface::SetTestIntMessage",0,&tolua_err) || 00232 !tolua_isnoobj(tolua_S,2,&tolua_err) 00233 ) 00234 goto tolua_lerror; 00235 else 00236 #endif 00237 { 00238 fawkes::TestInterface::SetTestIntMessage* self = (fawkes::TestInterface::SetTestIntMessage*) tolua_tousertype(tolua_S,1,0); 00239 #ifndef TOLUA_RELEASE 00240 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'test_int'", NULL); 00241 #endif 00242 { 00243 int tolua_ret = (int) self->test_int(); 00244 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00245 } 00246 } 00247 return 1; 00248 #ifndef TOLUA_RELEASE 00249 tolua_lerror: 00250 tolua_error(tolua_S,"#ferror in function 'test_int'.",&tolua_err); 00251 return 0; 00252 #endif 00253 } 00254 #endif //#ifndef TOLUA_DISABLE 00255 00256 /* method: set_test_int of class SetTestIntMessage */ 00257 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_set_test_int00 00258 static int tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_set_test_int00(lua_State* tolua_S) 00259 { 00260 #ifndef TOLUA_RELEASE 00261 tolua_Error tolua_err; 00262 if ( 00263 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface::SetTestIntMessage",0,&tolua_err) || 00264 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 00265 !tolua_isnoobj(tolua_S,3,&tolua_err) 00266 ) 00267 goto tolua_lerror; 00268 else 00269 #endif 00270 { 00271 fawkes::TestInterface::SetTestIntMessage* self = (fawkes::TestInterface::SetTestIntMessage*) tolua_tousertype(tolua_S,1,0); 00272 const int new_test_int = ((const int) tolua_tonumber(tolua_S,2,0)); 00273 #ifndef TOLUA_RELEASE 00274 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_test_int'", NULL); 00275 #endif 00276 { 00277 self->set_test_int(new_test_int); 00278 } 00279 } 00280 return 0; 00281 #ifndef TOLUA_RELEASE 00282 tolua_lerror: 00283 tolua_error(tolua_S,"#ferror in function 'set_test_int'.",&tolua_err); 00284 return 0; 00285 #endif 00286 } 00287 #endif //#ifndef TOLUA_DISABLE 00288 00289 /* method: maxlenof_test_int of class SetTestIntMessage */ 00290 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_maxlenof_test_int00 00291 static int tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_maxlenof_test_int00(lua_State* tolua_S) 00292 { 00293 #ifndef TOLUA_RELEASE 00294 tolua_Error tolua_err; 00295 if ( 00296 !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface::SetTestIntMessage",0,&tolua_err) || 00297 !tolua_isnoobj(tolua_S,2,&tolua_err) 00298 ) 00299 goto tolua_lerror; 00300 else 00301 #endif 00302 { 00303 const fawkes::TestInterface::SetTestIntMessage* self = (const fawkes::TestInterface::SetTestIntMessage*) tolua_tousertype(tolua_S,1,0); 00304 #ifndef TOLUA_RELEASE 00305 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_test_int'", NULL); 00306 #endif 00307 { 00308 int tolua_ret = (int) self->maxlenof_test_int(); 00309 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00310 } 00311 } 00312 return 1; 00313 #ifndef TOLUA_RELEASE 00314 tolua_lerror: 00315 tolua_error(tolua_S,"#ferror in function 'maxlenof_test_int'.",&tolua_err); 00316 return 0; 00317 #endif 00318 } 00319 #endif //#ifndef TOLUA_DISABLE 00320 00321 /* method: new of class SetTestStringMessage */ 00322 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_new00 00323 static int tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_new00(lua_State* tolua_S) 00324 { 00325 #ifndef TOLUA_RELEASE 00326 tolua_Error tolua_err; 00327 if ( 00328 !tolua_isusertable(tolua_S,1,"fawkes::TestInterface::SetTestStringMessage",0,&tolua_err) || 00329 !tolua_isstring(tolua_S,2,0,&tolua_err) || 00330 !tolua_isnoobj(tolua_S,3,&tolua_err) 00331 ) 00332 goto tolua_lerror; 00333 else 00334 #endif 00335 { 00336 char* ini_test_string = ((char*) tolua_tostring(tolua_S,2,0)); 00337 { 00338 fawkes::TestInterface::SetTestStringMessage* tolua_ret = (fawkes::TestInterface::SetTestStringMessage*) Mtolua_new((fawkes::TestInterface::SetTestStringMessage)(ini_test_string)); 00339 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::TestInterface::SetTestStringMessage"); 00340 } 00341 } 00342 return 1; 00343 #ifndef TOLUA_RELEASE 00344 tolua_lerror: 00345 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 00346 return 0; 00347 #endif 00348 } 00349 #endif //#ifndef TOLUA_DISABLE 00350 00351 /* method: new_local of class SetTestStringMessage */ 00352 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_new00_local 00353 static int tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_new00_local(lua_State* tolua_S) 00354 { 00355 #ifndef TOLUA_RELEASE 00356 tolua_Error tolua_err; 00357 if ( 00358 !tolua_isusertable(tolua_S,1,"fawkes::TestInterface::SetTestStringMessage",0,&tolua_err) || 00359 !tolua_isstring(tolua_S,2,0,&tolua_err) || 00360 !tolua_isnoobj(tolua_S,3,&tolua_err) 00361 ) 00362 goto tolua_lerror; 00363 else 00364 #endif 00365 { 00366 char* ini_test_string = ((char*) tolua_tostring(tolua_S,2,0)); 00367 { 00368 fawkes::TestInterface::SetTestStringMessage* tolua_ret = (fawkes::TestInterface::SetTestStringMessage*) Mtolua_new((fawkes::TestInterface::SetTestStringMessage)(ini_test_string)); 00369 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::TestInterface::SetTestStringMessage"); 00370 tolua_register_gc(tolua_S,lua_gettop(tolua_S)); 00371 } 00372 } 00373 return 1; 00374 #ifndef TOLUA_RELEASE 00375 tolua_lerror: 00376 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 00377 return 0; 00378 #endif 00379 } 00380 #endif //#ifndef TOLUA_DISABLE 00381 00382 /* method: new of class SetTestStringMessage */ 00383 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_new01 00384 static int tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_new01(lua_State* tolua_S) 00385 { 00386 tolua_Error tolua_err; 00387 if ( 00388 !tolua_isusertable(tolua_S,1,"fawkes::TestInterface::SetTestStringMessage",0,&tolua_err) || 00389 !tolua_isnoobj(tolua_S,2,&tolua_err) 00390 ) 00391 goto tolua_lerror; 00392 else 00393 { 00394 { 00395 fawkes::TestInterface::SetTestStringMessage* tolua_ret = (fawkes::TestInterface::SetTestStringMessage*) Mtolua_new((fawkes::TestInterface::SetTestStringMessage)()); 00396 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::TestInterface::SetTestStringMessage"); 00397 } 00398 } 00399 return 1; 00400 tolua_lerror: 00401 return tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_new00(tolua_S); 00402 } 00403 #endif //#ifndef TOLUA_DISABLE 00404 00405 /* method: new_local of class SetTestStringMessage */ 00406 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_new01_local 00407 static int tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_new01_local(lua_State* tolua_S) 00408 { 00409 tolua_Error tolua_err; 00410 if ( 00411 !tolua_isusertable(tolua_S,1,"fawkes::TestInterface::SetTestStringMessage",0,&tolua_err) || 00412 !tolua_isnoobj(tolua_S,2,&tolua_err) 00413 ) 00414 goto tolua_lerror; 00415 else 00416 { 00417 { 00418 fawkes::TestInterface::SetTestStringMessage* tolua_ret = (fawkes::TestInterface::SetTestStringMessage*) Mtolua_new((fawkes::TestInterface::SetTestStringMessage)()); 00419 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::TestInterface::SetTestStringMessage"); 00420 tolua_register_gc(tolua_S,lua_gettop(tolua_S)); 00421 } 00422 } 00423 return 1; 00424 tolua_lerror: 00425 return tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_new00_local(tolua_S); 00426 } 00427 #endif //#ifndef TOLUA_DISABLE 00428 00429 /* method: delete of class SetTestStringMessage */ 00430 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_delete00 00431 static int tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_delete00(lua_State* tolua_S) 00432 { 00433 #ifndef TOLUA_RELEASE 00434 tolua_Error tolua_err; 00435 if ( 00436 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface::SetTestStringMessage",0,&tolua_err) || 00437 !tolua_isnoobj(tolua_S,2,&tolua_err) 00438 ) 00439 goto tolua_lerror; 00440 else 00441 #endif 00442 { 00443 fawkes::TestInterface::SetTestStringMessage* self = (fawkes::TestInterface::SetTestStringMessage*) tolua_tousertype(tolua_S,1,0); 00444 #ifndef TOLUA_RELEASE 00445 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL); 00446 #endif 00447 Mtolua_delete(self); 00448 } 00449 return 0; 00450 #ifndef TOLUA_RELEASE 00451 tolua_lerror: 00452 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err); 00453 return 0; 00454 #endif 00455 } 00456 #endif //#ifndef TOLUA_DISABLE 00457 00458 /* method: test_string of class SetTestStringMessage */ 00459 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_test_string00 00460 static int tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_test_string00(lua_State* tolua_S) 00461 { 00462 #ifndef TOLUA_RELEASE 00463 tolua_Error tolua_err; 00464 if ( 00465 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface::SetTestStringMessage",0,&tolua_err) || 00466 !tolua_isnoobj(tolua_S,2,&tolua_err) 00467 ) 00468 goto tolua_lerror; 00469 else 00470 #endif 00471 { 00472 fawkes::TestInterface::SetTestStringMessage* self = (fawkes::TestInterface::SetTestStringMessage*) tolua_tousertype(tolua_S,1,0); 00473 #ifndef TOLUA_RELEASE 00474 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'test_string'", NULL); 00475 #endif 00476 { 00477 char* tolua_ret = (char*) self->test_string(); 00478 tolua_pushstring(tolua_S,(const char*)tolua_ret); 00479 } 00480 } 00481 return 1; 00482 #ifndef TOLUA_RELEASE 00483 tolua_lerror: 00484 tolua_error(tolua_S,"#ferror in function 'test_string'.",&tolua_err); 00485 return 0; 00486 #endif 00487 } 00488 #endif //#ifndef TOLUA_DISABLE 00489 00490 /* method: set_test_string of class SetTestStringMessage */ 00491 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_set_test_string00 00492 static int tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_set_test_string00(lua_State* tolua_S) 00493 { 00494 #ifndef TOLUA_RELEASE 00495 tolua_Error tolua_err; 00496 if ( 00497 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface::SetTestStringMessage",0,&tolua_err) || 00498 !tolua_isstring(tolua_S,2,0,&tolua_err) || 00499 !tolua_isnoobj(tolua_S,3,&tolua_err) 00500 ) 00501 goto tolua_lerror; 00502 else 00503 #endif 00504 { 00505 fawkes::TestInterface::SetTestStringMessage* self = (fawkes::TestInterface::SetTestStringMessage*) tolua_tousertype(tolua_S,1,0); 00506 const char* new_test_string = ((const char*) tolua_tostring(tolua_S,2,0)); 00507 #ifndef TOLUA_RELEASE 00508 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_test_string'", NULL); 00509 #endif 00510 { 00511 self->set_test_string(new_test_string); 00512 } 00513 } 00514 return 0; 00515 #ifndef TOLUA_RELEASE 00516 tolua_lerror: 00517 tolua_error(tolua_S,"#ferror in function 'set_test_string'.",&tolua_err); 00518 return 0; 00519 #endif 00520 } 00521 #endif //#ifndef TOLUA_DISABLE 00522 00523 /* method: maxlenof_test_string of class SetTestStringMessage */ 00524 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_maxlenof_test_string00 00525 static int tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_maxlenof_test_string00(lua_State* tolua_S) 00526 { 00527 #ifndef TOLUA_RELEASE 00528 tolua_Error tolua_err; 00529 if ( 00530 !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface::SetTestStringMessage",0,&tolua_err) || 00531 !tolua_isnoobj(tolua_S,2,&tolua_err) 00532 ) 00533 goto tolua_lerror; 00534 else 00535 #endif 00536 { 00537 const fawkes::TestInterface::SetTestStringMessage* self = (const fawkes::TestInterface::SetTestStringMessage*) tolua_tousertype(tolua_S,1,0); 00538 #ifndef TOLUA_RELEASE 00539 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_test_string'", NULL); 00540 #endif 00541 { 00542 int tolua_ret = (int) self->maxlenof_test_string(); 00543 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00544 } 00545 } 00546 return 1; 00547 #ifndef TOLUA_RELEASE 00548 tolua_lerror: 00549 tolua_error(tolua_S,"#ferror in function 'maxlenof_test_string'.",&tolua_err); 00550 return 0; 00551 #endif 00552 } 00553 #endif //#ifndef TOLUA_DISABLE 00554 00555 /* method: new of class CalculateMessage */ 00556 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_new00 00557 static int tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_new00(lua_State* tolua_S) 00558 { 00559 #ifndef TOLUA_RELEASE 00560 tolua_Error tolua_err; 00561 if ( 00562 !tolua_isusertable(tolua_S,1,"fawkes::TestInterface::CalculateMessage",0,&tolua_err) || 00563 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 00564 !tolua_isnumber(tolua_S,3,0,&tolua_err) || 00565 !tolua_isnoobj(tolua_S,4,&tolua_err) 00566 ) 00567 goto tolua_lerror; 00568 else 00569 #endif 00570 { 00571 int ini_summand = ((int) tolua_tonumber(tolua_S,2,0)); 00572 int ini_addend = ((int) tolua_tonumber(tolua_S,3,0)); 00573 { 00574 fawkes::TestInterface::CalculateMessage* tolua_ret = (fawkes::TestInterface::CalculateMessage*) Mtolua_new((fawkes::TestInterface::CalculateMessage)(ini_summand,ini_addend)); 00575 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::TestInterface::CalculateMessage"); 00576 } 00577 } 00578 return 1; 00579 #ifndef TOLUA_RELEASE 00580 tolua_lerror: 00581 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 00582 return 0; 00583 #endif 00584 } 00585 #endif //#ifndef TOLUA_DISABLE 00586 00587 /* method: new_local of class CalculateMessage */ 00588 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_new00_local 00589 static int tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_new00_local(lua_State* tolua_S) 00590 { 00591 #ifndef TOLUA_RELEASE 00592 tolua_Error tolua_err; 00593 if ( 00594 !tolua_isusertable(tolua_S,1,"fawkes::TestInterface::CalculateMessage",0,&tolua_err) || 00595 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 00596 !tolua_isnumber(tolua_S,3,0,&tolua_err) || 00597 !tolua_isnoobj(tolua_S,4,&tolua_err) 00598 ) 00599 goto tolua_lerror; 00600 else 00601 #endif 00602 { 00603 int ini_summand = ((int) tolua_tonumber(tolua_S,2,0)); 00604 int ini_addend = ((int) tolua_tonumber(tolua_S,3,0)); 00605 { 00606 fawkes::TestInterface::CalculateMessage* tolua_ret = (fawkes::TestInterface::CalculateMessage*) Mtolua_new((fawkes::TestInterface::CalculateMessage)(ini_summand,ini_addend)); 00607 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::TestInterface::CalculateMessage"); 00608 tolua_register_gc(tolua_S,lua_gettop(tolua_S)); 00609 } 00610 } 00611 return 1; 00612 #ifndef TOLUA_RELEASE 00613 tolua_lerror: 00614 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 00615 return 0; 00616 #endif 00617 } 00618 #endif //#ifndef TOLUA_DISABLE 00619 00620 /* method: new of class CalculateMessage */ 00621 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_new01 00622 static int tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_new01(lua_State* tolua_S) 00623 { 00624 tolua_Error tolua_err; 00625 if ( 00626 !tolua_isusertable(tolua_S,1,"fawkes::TestInterface::CalculateMessage",0,&tolua_err) || 00627 !tolua_isnoobj(tolua_S,2,&tolua_err) 00628 ) 00629 goto tolua_lerror; 00630 else 00631 { 00632 { 00633 fawkes::TestInterface::CalculateMessage* tolua_ret = (fawkes::TestInterface::CalculateMessage*) Mtolua_new((fawkes::TestInterface::CalculateMessage)()); 00634 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::TestInterface::CalculateMessage"); 00635 } 00636 } 00637 return 1; 00638 tolua_lerror: 00639 return tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_new00(tolua_S); 00640 } 00641 #endif //#ifndef TOLUA_DISABLE 00642 00643 /* method: new_local of class CalculateMessage */ 00644 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_new01_local 00645 static int tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_new01_local(lua_State* tolua_S) 00646 { 00647 tolua_Error tolua_err; 00648 if ( 00649 !tolua_isusertable(tolua_S,1,"fawkes::TestInterface::CalculateMessage",0,&tolua_err) || 00650 !tolua_isnoobj(tolua_S,2,&tolua_err) 00651 ) 00652 goto tolua_lerror; 00653 else 00654 { 00655 { 00656 fawkes::TestInterface::CalculateMessage* tolua_ret = (fawkes::TestInterface::CalculateMessage*) Mtolua_new((fawkes::TestInterface::CalculateMessage)()); 00657 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::TestInterface::CalculateMessage"); 00658 tolua_register_gc(tolua_S,lua_gettop(tolua_S)); 00659 } 00660 } 00661 return 1; 00662 tolua_lerror: 00663 return tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_new00_local(tolua_S); 00664 } 00665 #endif //#ifndef TOLUA_DISABLE 00666 00667 /* method: delete of class CalculateMessage */ 00668 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_delete00 00669 static int tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_delete00(lua_State* tolua_S) 00670 { 00671 #ifndef TOLUA_RELEASE 00672 tolua_Error tolua_err; 00673 if ( 00674 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface::CalculateMessage",0,&tolua_err) || 00675 !tolua_isnoobj(tolua_S,2,&tolua_err) 00676 ) 00677 goto tolua_lerror; 00678 else 00679 #endif 00680 { 00681 fawkes::TestInterface::CalculateMessage* self = (fawkes::TestInterface::CalculateMessage*) tolua_tousertype(tolua_S,1,0); 00682 #ifndef TOLUA_RELEASE 00683 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL); 00684 #endif 00685 Mtolua_delete(self); 00686 } 00687 return 0; 00688 #ifndef TOLUA_RELEASE 00689 tolua_lerror: 00690 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err); 00691 return 0; 00692 #endif 00693 } 00694 #endif //#ifndef TOLUA_DISABLE 00695 00696 /* method: summand of class CalculateMessage */ 00697 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_summand00 00698 static int tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_summand00(lua_State* tolua_S) 00699 { 00700 #ifndef TOLUA_RELEASE 00701 tolua_Error tolua_err; 00702 if ( 00703 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface::CalculateMessage",0,&tolua_err) || 00704 !tolua_isnoobj(tolua_S,2,&tolua_err) 00705 ) 00706 goto tolua_lerror; 00707 else 00708 #endif 00709 { 00710 fawkes::TestInterface::CalculateMessage* self = (fawkes::TestInterface::CalculateMessage*) tolua_tousertype(tolua_S,1,0); 00711 #ifndef TOLUA_RELEASE 00712 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'summand'", NULL); 00713 #endif 00714 { 00715 int tolua_ret = (int) self->summand(); 00716 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00717 } 00718 } 00719 return 1; 00720 #ifndef TOLUA_RELEASE 00721 tolua_lerror: 00722 tolua_error(tolua_S,"#ferror in function 'summand'.",&tolua_err); 00723 return 0; 00724 #endif 00725 } 00726 #endif //#ifndef TOLUA_DISABLE 00727 00728 /* method: set_summand of class CalculateMessage */ 00729 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_set_summand00 00730 static int tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_set_summand00(lua_State* tolua_S) 00731 { 00732 #ifndef TOLUA_RELEASE 00733 tolua_Error tolua_err; 00734 if ( 00735 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface::CalculateMessage",0,&tolua_err) || 00736 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 00737 !tolua_isnoobj(tolua_S,3,&tolua_err) 00738 ) 00739 goto tolua_lerror; 00740 else 00741 #endif 00742 { 00743 fawkes::TestInterface::CalculateMessage* self = (fawkes::TestInterface::CalculateMessage*) tolua_tousertype(tolua_S,1,0); 00744 const int new_summand = ((const int) tolua_tonumber(tolua_S,2,0)); 00745 #ifndef TOLUA_RELEASE 00746 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_summand'", NULL); 00747 #endif 00748 { 00749 self->set_summand(new_summand); 00750 } 00751 } 00752 return 0; 00753 #ifndef TOLUA_RELEASE 00754 tolua_lerror: 00755 tolua_error(tolua_S,"#ferror in function 'set_summand'.",&tolua_err); 00756 return 0; 00757 #endif 00758 } 00759 #endif //#ifndef TOLUA_DISABLE 00760 00761 /* method: maxlenof_summand of class CalculateMessage */ 00762 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_maxlenof_summand00 00763 static int tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_maxlenof_summand00(lua_State* tolua_S) 00764 { 00765 #ifndef TOLUA_RELEASE 00766 tolua_Error tolua_err; 00767 if ( 00768 !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface::CalculateMessage",0,&tolua_err) || 00769 !tolua_isnoobj(tolua_S,2,&tolua_err) 00770 ) 00771 goto tolua_lerror; 00772 else 00773 #endif 00774 { 00775 const fawkes::TestInterface::CalculateMessage* self = (const fawkes::TestInterface::CalculateMessage*) tolua_tousertype(tolua_S,1,0); 00776 #ifndef TOLUA_RELEASE 00777 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_summand'", NULL); 00778 #endif 00779 { 00780 int tolua_ret = (int) self->maxlenof_summand(); 00781 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00782 } 00783 } 00784 return 1; 00785 #ifndef TOLUA_RELEASE 00786 tolua_lerror: 00787 tolua_error(tolua_S,"#ferror in function 'maxlenof_summand'.",&tolua_err); 00788 return 0; 00789 #endif 00790 } 00791 #endif //#ifndef TOLUA_DISABLE 00792 00793 /* method: addend of class CalculateMessage */ 00794 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_addend00 00795 static int tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_addend00(lua_State* tolua_S) 00796 { 00797 #ifndef TOLUA_RELEASE 00798 tolua_Error tolua_err; 00799 if ( 00800 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface::CalculateMessage",0,&tolua_err) || 00801 !tolua_isnoobj(tolua_S,2,&tolua_err) 00802 ) 00803 goto tolua_lerror; 00804 else 00805 #endif 00806 { 00807 fawkes::TestInterface::CalculateMessage* self = (fawkes::TestInterface::CalculateMessage*) tolua_tousertype(tolua_S,1,0); 00808 #ifndef TOLUA_RELEASE 00809 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addend'", NULL); 00810 #endif 00811 { 00812 int tolua_ret = (int) self->addend(); 00813 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00814 } 00815 } 00816 return 1; 00817 #ifndef TOLUA_RELEASE 00818 tolua_lerror: 00819 tolua_error(tolua_S,"#ferror in function 'addend'.",&tolua_err); 00820 return 0; 00821 #endif 00822 } 00823 #endif //#ifndef TOLUA_DISABLE 00824 00825 /* method: set_addend of class CalculateMessage */ 00826 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_set_addend00 00827 static int tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_set_addend00(lua_State* tolua_S) 00828 { 00829 #ifndef TOLUA_RELEASE 00830 tolua_Error tolua_err; 00831 if ( 00832 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface::CalculateMessage",0,&tolua_err) || 00833 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 00834 !tolua_isnoobj(tolua_S,3,&tolua_err) 00835 ) 00836 goto tolua_lerror; 00837 else 00838 #endif 00839 { 00840 fawkes::TestInterface::CalculateMessage* self = (fawkes::TestInterface::CalculateMessage*) tolua_tousertype(tolua_S,1,0); 00841 const int new_addend = ((const int) tolua_tonumber(tolua_S,2,0)); 00842 #ifndef TOLUA_RELEASE 00843 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_addend'", NULL); 00844 #endif 00845 { 00846 self->set_addend(new_addend); 00847 } 00848 } 00849 return 0; 00850 #ifndef TOLUA_RELEASE 00851 tolua_lerror: 00852 tolua_error(tolua_S,"#ferror in function 'set_addend'.",&tolua_err); 00853 return 0; 00854 #endif 00855 } 00856 #endif //#ifndef TOLUA_DISABLE 00857 00858 /* method: maxlenof_addend of class CalculateMessage */ 00859 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_maxlenof_addend00 00860 static int tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_maxlenof_addend00(lua_State* tolua_S) 00861 { 00862 #ifndef TOLUA_RELEASE 00863 tolua_Error tolua_err; 00864 if ( 00865 !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface::CalculateMessage",0,&tolua_err) || 00866 !tolua_isnoobj(tolua_S,2,&tolua_err) 00867 ) 00868 goto tolua_lerror; 00869 else 00870 #endif 00871 { 00872 const fawkes::TestInterface::CalculateMessage* self = (const fawkes::TestInterface::CalculateMessage*) tolua_tousertype(tolua_S,1,0); 00873 #ifndef TOLUA_RELEASE 00874 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_addend'", NULL); 00875 #endif 00876 { 00877 int tolua_ret = (int) self->maxlenof_addend(); 00878 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00879 } 00880 } 00881 return 1; 00882 #ifndef TOLUA_RELEASE 00883 tolua_lerror: 00884 tolua_error(tolua_S,"#ferror in function 'maxlenof_addend'.",&tolua_err); 00885 return 0; 00886 #endif 00887 } 00888 #endif //#ifndef TOLUA_DISABLE 00889 00890 /* method: is_test_bool of class fawkes::TestInterface */ 00891 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_is_test_bool00 00892 static int tolua_interfaces_TestInterface_fawkes_TestInterface_is_test_bool00(lua_State* tolua_S) 00893 { 00894 #ifndef TOLUA_RELEASE 00895 tolua_Error tolua_err; 00896 if ( 00897 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) || 00898 !tolua_isnoobj(tolua_S,2,&tolua_err) 00899 ) 00900 goto tolua_lerror; 00901 else 00902 #endif 00903 { 00904 fawkes::TestInterface* self = (fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 00905 #ifndef TOLUA_RELEASE 00906 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_test_bool'", NULL); 00907 #endif 00908 { 00909 bool tolua_ret = (bool) self->is_test_bool(); 00910 tolua_pushboolean(tolua_S,(bool)tolua_ret); 00911 } 00912 } 00913 return 1; 00914 #ifndef TOLUA_RELEASE 00915 tolua_lerror: 00916 tolua_error(tolua_S,"#ferror in function 'is_test_bool'.",&tolua_err); 00917 return 0; 00918 #endif 00919 } 00920 #endif //#ifndef TOLUA_DISABLE 00921 00922 /* method: set_test_bool of class fawkes::TestInterface */ 00923 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_bool00 00924 static int tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_bool00(lua_State* tolua_S) 00925 { 00926 #ifndef TOLUA_RELEASE 00927 tolua_Error tolua_err; 00928 if ( 00929 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) || 00930 !tolua_isboolean(tolua_S,2,0,&tolua_err) || 00931 !tolua_isnoobj(tolua_S,3,&tolua_err) 00932 ) 00933 goto tolua_lerror; 00934 else 00935 #endif 00936 { 00937 fawkes::TestInterface* self = (fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 00938 const bool new_test_bool = ((const bool) tolua_toboolean(tolua_S,2,0)); 00939 #ifndef TOLUA_RELEASE 00940 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_test_bool'", NULL); 00941 #endif 00942 { 00943 self->set_test_bool(new_test_bool); 00944 } 00945 } 00946 return 0; 00947 #ifndef TOLUA_RELEASE 00948 tolua_lerror: 00949 tolua_error(tolua_S,"#ferror in function 'set_test_bool'.",&tolua_err); 00950 return 0; 00951 #endif 00952 } 00953 #endif //#ifndef TOLUA_DISABLE 00954 00955 /* method: maxlenof_test_bool of class fawkes::TestInterface */ 00956 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_bool00 00957 static int tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_bool00(lua_State* tolua_S) 00958 { 00959 #ifndef TOLUA_RELEASE 00960 tolua_Error tolua_err; 00961 if ( 00962 !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) || 00963 !tolua_isnoobj(tolua_S,2,&tolua_err) 00964 ) 00965 goto tolua_lerror; 00966 else 00967 #endif 00968 { 00969 const fawkes::TestInterface* self = (const fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 00970 #ifndef TOLUA_RELEASE 00971 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_test_bool'", NULL); 00972 #endif 00973 { 00974 int tolua_ret = (int) self->maxlenof_test_bool(); 00975 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00976 } 00977 } 00978 return 1; 00979 #ifndef TOLUA_RELEASE 00980 tolua_lerror: 00981 tolua_error(tolua_S,"#ferror in function 'maxlenof_test_bool'.",&tolua_err); 00982 return 0; 00983 #endif 00984 } 00985 #endif //#ifndef TOLUA_DISABLE 00986 00987 /* method: test_int of class fawkes::TestInterface */ 00988 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_test_int00 00989 static int tolua_interfaces_TestInterface_fawkes_TestInterface_test_int00(lua_State* tolua_S) 00990 { 00991 #ifndef TOLUA_RELEASE 00992 tolua_Error tolua_err; 00993 if ( 00994 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) || 00995 !tolua_isnoobj(tolua_S,2,&tolua_err) 00996 ) 00997 goto tolua_lerror; 00998 else 00999 #endif 01000 { 01001 fawkes::TestInterface* self = (fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 01002 #ifndef TOLUA_RELEASE 01003 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'test_int'", NULL); 01004 #endif 01005 { 01006 int tolua_ret = (int) self->test_int(); 01007 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01008 } 01009 } 01010 return 1; 01011 #ifndef TOLUA_RELEASE 01012 tolua_lerror: 01013 tolua_error(tolua_S,"#ferror in function 'test_int'.",&tolua_err); 01014 return 0; 01015 #endif 01016 } 01017 #endif //#ifndef TOLUA_DISABLE 01018 01019 /* method: set_test_int of class fawkes::TestInterface */ 01020 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_int00 01021 static int tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_int00(lua_State* tolua_S) 01022 { 01023 #ifndef TOLUA_RELEASE 01024 tolua_Error tolua_err; 01025 if ( 01026 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) || 01027 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 01028 !tolua_isnoobj(tolua_S,3,&tolua_err) 01029 ) 01030 goto tolua_lerror; 01031 else 01032 #endif 01033 { 01034 fawkes::TestInterface* self = (fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 01035 const int new_test_int = ((const int) tolua_tonumber(tolua_S,2,0)); 01036 #ifndef TOLUA_RELEASE 01037 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_test_int'", NULL); 01038 #endif 01039 { 01040 self->set_test_int(new_test_int); 01041 } 01042 } 01043 return 0; 01044 #ifndef TOLUA_RELEASE 01045 tolua_lerror: 01046 tolua_error(tolua_S,"#ferror in function 'set_test_int'.",&tolua_err); 01047 return 0; 01048 #endif 01049 } 01050 #endif //#ifndef TOLUA_DISABLE 01051 01052 /* method: maxlenof_test_int of class fawkes::TestInterface */ 01053 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_int00 01054 static int tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_int00(lua_State* tolua_S) 01055 { 01056 #ifndef TOLUA_RELEASE 01057 tolua_Error tolua_err; 01058 if ( 01059 !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) || 01060 !tolua_isnoobj(tolua_S,2,&tolua_err) 01061 ) 01062 goto tolua_lerror; 01063 else 01064 #endif 01065 { 01066 const fawkes::TestInterface* self = (const fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 01067 #ifndef TOLUA_RELEASE 01068 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_test_int'", NULL); 01069 #endif 01070 { 01071 int tolua_ret = (int) self->maxlenof_test_int(); 01072 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01073 } 01074 } 01075 return 1; 01076 #ifndef TOLUA_RELEASE 01077 tolua_lerror: 01078 tolua_error(tolua_S,"#ferror in function 'maxlenof_test_int'.",&tolua_err); 01079 return 0; 01080 #endif 01081 } 01082 #endif //#ifndef TOLUA_DISABLE 01083 01084 /* method: flags of class fawkes::TestInterface */ 01085 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_flags00 01086 static int tolua_interfaces_TestInterface_fawkes_TestInterface_flags00(lua_State* tolua_S) 01087 { 01088 #ifndef TOLUA_RELEASE 01089 tolua_Error tolua_err; 01090 if ( 01091 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) || 01092 !tolua_isnoobj(tolua_S,2,&tolua_err) 01093 ) 01094 goto tolua_lerror; 01095 else 01096 #endif 01097 { 01098 fawkes::TestInterface* self = (fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 01099 #ifndef TOLUA_RELEASE 01100 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'flags'", NULL); 01101 #endif 01102 { 01103 unsigned char tolua_ret = (unsigned char) self->flags(); 01104 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01105 } 01106 } 01107 return 1; 01108 #ifndef TOLUA_RELEASE 01109 tolua_lerror: 01110 tolua_error(tolua_S,"#ferror in function 'flags'.",&tolua_err); 01111 return 0; 01112 #endif 01113 } 01114 #endif //#ifndef TOLUA_DISABLE 01115 01116 /* method: set_flags of class fawkes::TestInterface */ 01117 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_set_flags00 01118 static int tolua_interfaces_TestInterface_fawkes_TestInterface_set_flags00(lua_State* tolua_S) 01119 { 01120 #ifndef TOLUA_RELEASE 01121 tolua_Error tolua_err; 01122 if ( 01123 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) || 01124 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 01125 !tolua_isnoobj(tolua_S,3,&tolua_err) 01126 ) 01127 goto tolua_lerror; 01128 else 01129 #endif 01130 { 01131 fawkes::TestInterface* self = (fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 01132 unsigned const char new_flags = ((unsigned const char) tolua_tonumber(tolua_S,2,0)); 01133 #ifndef TOLUA_RELEASE 01134 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_flags'", NULL); 01135 #endif 01136 { 01137 self->set_flags(new_flags); 01138 } 01139 } 01140 return 0; 01141 #ifndef TOLUA_RELEASE 01142 tolua_lerror: 01143 tolua_error(tolua_S,"#ferror in function 'set_flags'.",&tolua_err); 01144 return 0; 01145 #endif 01146 } 01147 #endif //#ifndef TOLUA_DISABLE 01148 01149 /* method: maxlenof_flags of class fawkes::TestInterface */ 01150 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_flags00 01151 static int tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_flags00(lua_State* tolua_S) 01152 { 01153 #ifndef TOLUA_RELEASE 01154 tolua_Error tolua_err; 01155 if ( 01156 !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) || 01157 !tolua_isnoobj(tolua_S,2,&tolua_err) 01158 ) 01159 goto tolua_lerror; 01160 else 01161 #endif 01162 { 01163 const fawkes::TestInterface* self = (const fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 01164 #ifndef TOLUA_RELEASE 01165 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_flags'", NULL); 01166 #endif 01167 { 01168 int tolua_ret = (int) self->maxlenof_flags(); 01169 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01170 } 01171 } 01172 return 1; 01173 #ifndef TOLUA_RELEASE 01174 tolua_lerror: 01175 tolua_error(tolua_S,"#ferror in function 'maxlenof_flags'.",&tolua_err); 01176 return 0; 01177 #endif 01178 } 01179 #endif //#ifndef TOLUA_DISABLE 01180 01181 /* method: test_string of class fawkes::TestInterface */ 01182 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_test_string00 01183 static int tolua_interfaces_TestInterface_fawkes_TestInterface_test_string00(lua_State* tolua_S) 01184 { 01185 #ifndef TOLUA_RELEASE 01186 tolua_Error tolua_err; 01187 if ( 01188 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) || 01189 !tolua_isnoobj(tolua_S,2,&tolua_err) 01190 ) 01191 goto tolua_lerror; 01192 else 01193 #endif 01194 { 01195 fawkes::TestInterface* self = (fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 01196 #ifndef TOLUA_RELEASE 01197 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'test_string'", NULL); 01198 #endif 01199 { 01200 char* tolua_ret = (char*) self->test_string(); 01201 tolua_pushstring(tolua_S,(const char*)tolua_ret); 01202 } 01203 } 01204 return 1; 01205 #ifndef TOLUA_RELEASE 01206 tolua_lerror: 01207 tolua_error(tolua_S,"#ferror in function 'test_string'.",&tolua_err); 01208 return 0; 01209 #endif 01210 } 01211 #endif //#ifndef TOLUA_DISABLE 01212 01213 /* method: set_test_string of class fawkes::TestInterface */ 01214 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_string00 01215 static int tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_string00(lua_State* tolua_S) 01216 { 01217 #ifndef TOLUA_RELEASE 01218 tolua_Error tolua_err; 01219 if ( 01220 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) || 01221 !tolua_isstring(tolua_S,2,0,&tolua_err) || 01222 !tolua_isnoobj(tolua_S,3,&tolua_err) 01223 ) 01224 goto tolua_lerror; 01225 else 01226 #endif 01227 { 01228 fawkes::TestInterface* self = (fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 01229 const char* new_test_string = ((const char*) tolua_tostring(tolua_S,2,0)); 01230 #ifndef TOLUA_RELEASE 01231 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_test_string'", NULL); 01232 #endif 01233 { 01234 self->set_test_string(new_test_string); 01235 } 01236 } 01237 return 0; 01238 #ifndef TOLUA_RELEASE 01239 tolua_lerror: 01240 tolua_error(tolua_S,"#ferror in function 'set_test_string'.",&tolua_err); 01241 return 0; 01242 #endif 01243 } 01244 #endif //#ifndef TOLUA_DISABLE 01245 01246 /* method: maxlenof_test_string of class fawkes::TestInterface */ 01247 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_string00 01248 static int tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_string00(lua_State* tolua_S) 01249 { 01250 #ifndef TOLUA_RELEASE 01251 tolua_Error tolua_err; 01252 if ( 01253 !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) || 01254 !tolua_isnoobj(tolua_S,2,&tolua_err) 01255 ) 01256 goto tolua_lerror; 01257 else 01258 #endif 01259 { 01260 const fawkes::TestInterface* self = (const fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 01261 #ifndef TOLUA_RELEASE 01262 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_test_string'", NULL); 01263 #endif 01264 { 01265 int tolua_ret = (int) self->maxlenof_test_string(); 01266 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01267 } 01268 } 01269 return 1; 01270 #ifndef TOLUA_RELEASE 01271 tolua_lerror: 01272 tolua_error(tolua_S,"#ferror in function 'maxlenof_test_string'.",&tolua_err); 01273 return 0; 01274 #endif 01275 } 01276 #endif //#ifndef TOLUA_DISABLE 01277 01278 /* method: result of class fawkes::TestInterface */ 01279 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_result00 01280 static int tolua_interfaces_TestInterface_fawkes_TestInterface_result00(lua_State* tolua_S) 01281 { 01282 #ifndef TOLUA_RELEASE 01283 tolua_Error tolua_err; 01284 if ( 01285 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) || 01286 !tolua_isnoobj(tolua_S,2,&tolua_err) 01287 ) 01288 goto tolua_lerror; 01289 else 01290 #endif 01291 { 01292 fawkes::TestInterface* self = (fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 01293 #ifndef TOLUA_RELEASE 01294 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'result'", NULL); 01295 #endif 01296 { 01297 int tolua_ret = (int) self->result(); 01298 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01299 } 01300 } 01301 return 1; 01302 #ifndef TOLUA_RELEASE 01303 tolua_lerror: 01304 tolua_error(tolua_S,"#ferror in function 'result'.",&tolua_err); 01305 return 0; 01306 #endif 01307 } 01308 #endif //#ifndef TOLUA_DISABLE 01309 01310 /* method: set_result of class fawkes::TestInterface */ 01311 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_set_result00 01312 static int tolua_interfaces_TestInterface_fawkes_TestInterface_set_result00(lua_State* tolua_S) 01313 { 01314 #ifndef TOLUA_RELEASE 01315 tolua_Error tolua_err; 01316 if ( 01317 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) || 01318 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 01319 !tolua_isnoobj(tolua_S,3,&tolua_err) 01320 ) 01321 goto tolua_lerror; 01322 else 01323 #endif 01324 { 01325 fawkes::TestInterface* self = (fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 01326 const int new_result = ((const int) tolua_tonumber(tolua_S,2,0)); 01327 #ifndef TOLUA_RELEASE 01328 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_result'", NULL); 01329 #endif 01330 { 01331 self->set_result(new_result); 01332 } 01333 } 01334 return 0; 01335 #ifndef TOLUA_RELEASE 01336 tolua_lerror: 01337 tolua_error(tolua_S,"#ferror in function 'set_result'.",&tolua_err); 01338 return 0; 01339 #endif 01340 } 01341 #endif //#ifndef TOLUA_DISABLE 01342 01343 /* method: maxlenof_result of class fawkes::TestInterface */ 01344 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_result00 01345 static int tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_result00(lua_State* tolua_S) 01346 { 01347 #ifndef TOLUA_RELEASE 01348 tolua_Error tolua_err; 01349 if ( 01350 !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) || 01351 !tolua_isnoobj(tolua_S,2,&tolua_err) 01352 ) 01353 goto tolua_lerror; 01354 else 01355 #endif 01356 { 01357 const fawkes::TestInterface* self = (const fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 01358 #ifndef TOLUA_RELEASE 01359 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_result'", NULL); 01360 #endif 01361 { 01362 int tolua_ret = (int) self->maxlenof_result(); 01363 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01364 } 01365 } 01366 return 1; 01367 #ifndef TOLUA_RELEASE 01368 tolua_lerror: 01369 tolua_error(tolua_S,"#ferror in function 'maxlenof_result'.",&tolua_err); 01370 return 0; 01371 #endif 01372 } 01373 #endif //#ifndef TOLUA_DISABLE 01374 01375 /* method: test_uint of class fawkes::TestInterface */ 01376 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_test_uint00 01377 static int tolua_interfaces_TestInterface_fawkes_TestInterface_test_uint00(lua_State* tolua_S) 01378 { 01379 #ifndef TOLUA_RELEASE 01380 tolua_Error tolua_err; 01381 if ( 01382 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) || 01383 !tolua_isnoobj(tolua_S,2,&tolua_err) 01384 ) 01385 goto tolua_lerror; 01386 else 01387 #endif 01388 { 01389 fawkes::TestInterface* self = (fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 01390 #ifndef TOLUA_RELEASE 01391 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'test_uint'", NULL); 01392 #endif 01393 { 01394 unsigned int tolua_ret = (unsigned int) self->test_uint(); 01395 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01396 } 01397 } 01398 return 1; 01399 #ifndef TOLUA_RELEASE 01400 tolua_lerror: 01401 tolua_error(tolua_S,"#ferror in function 'test_uint'.",&tolua_err); 01402 return 0; 01403 #endif 01404 } 01405 #endif //#ifndef TOLUA_DISABLE 01406 01407 /* method: set_test_uint of class fawkes::TestInterface */ 01408 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_uint00 01409 static int tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_uint00(lua_State* tolua_S) 01410 { 01411 #ifndef TOLUA_RELEASE 01412 tolua_Error tolua_err; 01413 if ( 01414 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) || 01415 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 01416 !tolua_isnoobj(tolua_S,3,&tolua_err) 01417 ) 01418 goto tolua_lerror; 01419 else 01420 #endif 01421 { 01422 fawkes::TestInterface* self = (fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 01423 unsigned const int new_test_uint = ((unsigned const int) tolua_tonumber(tolua_S,2,0)); 01424 #ifndef TOLUA_RELEASE 01425 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_test_uint'", NULL); 01426 #endif 01427 { 01428 self->set_test_uint(new_test_uint); 01429 } 01430 } 01431 return 0; 01432 #ifndef TOLUA_RELEASE 01433 tolua_lerror: 01434 tolua_error(tolua_S,"#ferror in function 'set_test_uint'.",&tolua_err); 01435 return 0; 01436 #endif 01437 } 01438 #endif //#ifndef TOLUA_DISABLE 01439 01440 /* method: maxlenof_test_uint of class fawkes::TestInterface */ 01441 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_uint00 01442 static int tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_uint00(lua_State* tolua_S) 01443 { 01444 #ifndef TOLUA_RELEASE 01445 tolua_Error tolua_err; 01446 if ( 01447 !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) || 01448 !tolua_isnoobj(tolua_S,2,&tolua_err) 01449 ) 01450 goto tolua_lerror; 01451 else 01452 #endif 01453 { 01454 const fawkes::TestInterface* self = (const fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 01455 #ifndef TOLUA_RELEASE 01456 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_test_uint'", NULL); 01457 #endif 01458 { 01459 int tolua_ret = (int) self->maxlenof_test_uint(); 01460 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01461 } 01462 } 01463 return 1; 01464 #ifndef TOLUA_RELEASE 01465 tolua_lerror: 01466 tolua_error(tolua_S,"#ferror in function 'maxlenof_test_uint'.",&tolua_err); 01467 return 0; 01468 #endif 01469 } 01470 #endif //#ifndef TOLUA_DISABLE 01471 01472 /* method: test_ulint of class fawkes::TestInterface */ 01473 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_test_ulint00 01474 static int tolua_interfaces_TestInterface_fawkes_TestInterface_test_ulint00(lua_State* tolua_S) 01475 { 01476 #ifndef TOLUA_RELEASE 01477 tolua_Error tolua_err; 01478 if ( 01479 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) || 01480 !tolua_isnoobj(tolua_S,2,&tolua_err) 01481 ) 01482 goto tolua_lerror; 01483 else 01484 #endif 01485 { 01486 fawkes::TestInterface* self = (fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 01487 #ifndef TOLUA_RELEASE 01488 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'test_ulint'", NULL); 01489 #endif 01490 { 01491 unsigned long tolua_ret = (unsigned long) self->test_ulint(); 01492 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01493 } 01494 } 01495 return 1; 01496 #ifndef TOLUA_RELEASE 01497 tolua_lerror: 01498 tolua_error(tolua_S,"#ferror in function 'test_ulint'.",&tolua_err); 01499 return 0; 01500 #endif 01501 } 01502 #endif //#ifndef TOLUA_DISABLE 01503 01504 /* method: set_test_ulint of class fawkes::TestInterface */ 01505 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_ulint00 01506 static int tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_ulint00(lua_State* tolua_S) 01507 { 01508 #ifndef TOLUA_RELEASE 01509 tolua_Error tolua_err; 01510 if ( 01511 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) || 01512 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 01513 !tolua_isnoobj(tolua_S,3,&tolua_err) 01514 ) 01515 goto tolua_lerror; 01516 else 01517 #endif 01518 { 01519 fawkes::TestInterface* self = (fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 01520 unsigned const long new_test_ulint = ((unsigned const long) tolua_tonumber(tolua_S,2,0)); 01521 #ifndef TOLUA_RELEASE 01522 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_test_ulint'", NULL); 01523 #endif 01524 { 01525 self->set_test_ulint(new_test_ulint); 01526 } 01527 } 01528 return 0; 01529 #ifndef TOLUA_RELEASE 01530 tolua_lerror: 01531 tolua_error(tolua_S,"#ferror in function 'set_test_ulint'.",&tolua_err); 01532 return 0; 01533 #endif 01534 } 01535 #endif //#ifndef TOLUA_DISABLE 01536 01537 /* method: maxlenof_test_ulint of class fawkes::TestInterface */ 01538 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_ulint00 01539 static int tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_ulint00(lua_State* tolua_S) 01540 { 01541 #ifndef TOLUA_RELEASE 01542 tolua_Error tolua_err; 01543 if ( 01544 !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) || 01545 !tolua_isnoobj(tolua_S,2,&tolua_err) 01546 ) 01547 goto tolua_lerror; 01548 else 01549 #endif 01550 { 01551 const fawkes::TestInterface* self = (const fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 01552 #ifndef TOLUA_RELEASE 01553 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_test_ulint'", NULL); 01554 #endif 01555 { 01556 int tolua_ret = (int) self->maxlenof_test_ulint(); 01557 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01558 } 01559 } 01560 return 1; 01561 #ifndef TOLUA_RELEASE 01562 tolua_lerror: 01563 tolua_error(tolua_S,"#ferror in function 'maxlenof_test_ulint'.",&tolua_err); 01564 return 0; 01565 #endif 01566 } 01567 #endif //#ifndef TOLUA_DISABLE 01568 01569 /* method: test_lint of class fawkes::TestInterface */ 01570 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_test_lint00 01571 static int tolua_interfaces_TestInterface_fawkes_TestInterface_test_lint00(lua_State* tolua_S) 01572 { 01573 #ifndef TOLUA_RELEASE 01574 tolua_Error tolua_err; 01575 if ( 01576 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) || 01577 !tolua_isnoobj(tolua_S,2,&tolua_err) 01578 ) 01579 goto tolua_lerror; 01580 else 01581 #endif 01582 { 01583 fawkes::TestInterface* self = (fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 01584 #ifndef TOLUA_RELEASE 01585 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'test_lint'", NULL); 01586 #endif 01587 { 01588 long tolua_ret = (long) self->test_lint(); 01589 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01590 } 01591 } 01592 return 1; 01593 #ifndef TOLUA_RELEASE 01594 tolua_lerror: 01595 tolua_error(tolua_S,"#ferror in function 'test_lint'.",&tolua_err); 01596 return 0; 01597 #endif 01598 } 01599 #endif //#ifndef TOLUA_DISABLE 01600 01601 /* method: set_test_lint of class fawkes::TestInterface */ 01602 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_lint00 01603 static int tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_lint00(lua_State* tolua_S) 01604 { 01605 #ifndef TOLUA_RELEASE 01606 tolua_Error tolua_err; 01607 if ( 01608 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) || 01609 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 01610 !tolua_isnoobj(tolua_S,3,&tolua_err) 01611 ) 01612 goto tolua_lerror; 01613 else 01614 #endif 01615 { 01616 fawkes::TestInterface* self = (fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 01617 const long new_test_lint = ((const long) tolua_tonumber(tolua_S,2,0)); 01618 #ifndef TOLUA_RELEASE 01619 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_test_lint'", NULL); 01620 #endif 01621 { 01622 self->set_test_lint(new_test_lint); 01623 } 01624 } 01625 return 0; 01626 #ifndef TOLUA_RELEASE 01627 tolua_lerror: 01628 tolua_error(tolua_S,"#ferror in function 'set_test_lint'.",&tolua_err); 01629 return 0; 01630 #endif 01631 } 01632 #endif //#ifndef TOLUA_DISABLE 01633 01634 /* method: maxlenof_test_lint of class fawkes::TestInterface */ 01635 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_lint00 01636 static int tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_lint00(lua_State* tolua_S) 01637 { 01638 #ifndef TOLUA_RELEASE 01639 tolua_Error tolua_err; 01640 if ( 01641 !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) || 01642 !tolua_isnoobj(tolua_S,2,&tolua_err) 01643 ) 01644 goto tolua_lerror; 01645 else 01646 #endif 01647 { 01648 const fawkes::TestInterface* self = (const fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 01649 #ifndef TOLUA_RELEASE 01650 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_test_lint'", NULL); 01651 #endif 01652 { 01653 int tolua_ret = (int) self->maxlenof_test_lint(); 01654 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01655 } 01656 } 01657 return 1; 01658 #ifndef TOLUA_RELEASE 01659 tolua_lerror: 01660 tolua_error(tolua_S,"#ferror in function 'maxlenof_test_lint'.",&tolua_err); 01661 return 0; 01662 #endif 01663 } 01664 #endif //#ifndef TOLUA_DISABLE 01665 01666 /* method: oftype of class fawkes::TestInterface */ 01667 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_oftype00 01668 static int tolua_interfaces_TestInterface_fawkes_TestInterface_oftype00(lua_State* tolua_S) 01669 { 01670 #ifndef TOLUA_RELEASE 01671 tolua_Error tolua_err; 01672 if ( 01673 !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) || 01674 !tolua_isstring(tolua_S,2,0,&tolua_err) || 01675 !tolua_isnoobj(tolua_S,3,&tolua_err) 01676 ) 01677 goto tolua_lerror; 01678 else 01679 #endif 01680 { 01681 const fawkes::TestInterface* self = (const fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 01682 const char* interface_type = ((const char*) tolua_tostring(tolua_S,2,0)); 01683 #ifndef TOLUA_RELEASE 01684 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'oftype'", NULL); 01685 #endif 01686 { 01687 bool tolua_ret = (bool) self->oftype(interface_type); 01688 tolua_pushboolean(tolua_S,(bool)tolua_ret); 01689 } 01690 } 01691 return 1; 01692 #ifndef TOLUA_RELEASE 01693 tolua_lerror: 01694 tolua_error(tolua_S,"#ferror in function 'oftype'.",&tolua_err); 01695 return 0; 01696 #endif 01697 } 01698 #endif //#ifndef TOLUA_DISABLE 01699 01700 /* method: datachunk of class fawkes::TestInterface */ 01701 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_datachunk00 01702 static int tolua_interfaces_TestInterface_fawkes_TestInterface_datachunk00(lua_State* tolua_S) 01703 { 01704 #ifndef TOLUA_RELEASE 01705 tolua_Error tolua_err; 01706 if ( 01707 !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) || 01708 !tolua_isnoobj(tolua_S,2,&tolua_err) 01709 ) 01710 goto tolua_lerror; 01711 else 01712 #endif 01713 { 01714 const fawkes::TestInterface* self = (const fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 01715 #ifndef TOLUA_RELEASE 01716 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datachunk'", NULL); 01717 #endif 01718 { 01719 const void* tolua_ret = (const void*) self->datachunk(); 01720 tolua_pushuserdata(tolua_S,(void*)tolua_ret); 01721 } 01722 } 01723 return 1; 01724 #ifndef TOLUA_RELEASE 01725 tolua_lerror: 01726 tolua_error(tolua_S,"#ferror in function 'datachunk'.",&tolua_err); 01727 return 0; 01728 #endif 01729 } 01730 #endif //#ifndef TOLUA_DISABLE 01731 01732 /* method: datasize of class fawkes::TestInterface */ 01733 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_datasize00 01734 static int tolua_interfaces_TestInterface_fawkes_TestInterface_datasize00(lua_State* tolua_S) 01735 { 01736 #ifndef TOLUA_RELEASE 01737 tolua_Error tolua_err; 01738 if ( 01739 !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) || 01740 !tolua_isnoobj(tolua_S,2,&tolua_err) 01741 ) 01742 goto tolua_lerror; 01743 else 01744 #endif 01745 { 01746 const fawkes::TestInterface* self = (const fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 01747 #ifndef TOLUA_RELEASE 01748 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datasize'", NULL); 01749 #endif 01750 { 01751 unsigned int tolua_ret = (unsigned int) self->datasize(); 01752 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01753 } 01754 } 01755 return 1; 01756 #ifndef TOLUA_RELEASE 01757 tolua_lerror: 01758 tolua_error(tolua_S,"#ferror in function 'datasize'.",&tolua_err); 01759 return 0; 01760 #endif 01761 } 01762 #endif //#ifndef TOLUA_DISABLE 01763 01764 /* method: type of class fawkes::TestInterface */ 01765 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_type00 01766 static int tolua_interfaces_TestInterface_fawkes_TestInterface_type00(lua_State* tolua_S) 01767 { 01768 #ifndef TOLUA_RELEASE 01769 tolua_Error tolua_err; 01770 if ( 01771 !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) || 01772 !tolua_isnoobj(tolua_S,2,&tolua_err) 01773 ) 01774 goto tolua_lerror; 01775 else 01776 #endif 01777 { 01778 const fawkes::TestInterface* self = (const fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 01779 #ifndef TOLUA_RELEASE 01780 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'type'", NULL); 01781 #endif 01782 { 01783 const char* tolua_ret = (const char*) self->type(); 01784 tolua_pushstring(tolua_S,(const char*)tolua_ret); 01785 } 01786 } 01787 return 1; 01788 #ifndef TOLUA_RELEASE 01789 tolua_lerror: 01790 tolua_error(tolua_S,"#ferror in function 'type'.",&tolua_err); 01791 return 0; 01792 #endif 01793 } 01794 #endif //#ifndef TOLUA_DISABLE 01795 01796 /* method: id of class fawkes::TestInterface */ 01797 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_id00 01798 static int tolua_interfaces_TestInterface_fawkes_TestInterface_id00(lua_State* tolua_S) 01799 { 01800 #ifndef TOLUA_RELEASE 01801 tolua_Error tolua_err; 01802 if ( 01803 !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) || 01804 !tolua_isnoobj(tolua_S,2,&tolua_err) 01805 ) 01806 goto tolua_lerror; 01807 else 01808 #endif 01809 { 01810 const fawkes::TestInterface* self = (const fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 01811 #ifndef TOLUA_RELEASE 01812 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'id'", NULL); 01813 #endif 01814 { 01815 const char* tolua_ret = (const char*) self->id(); 01816 tolua_pushstring(tolua_S,(const char*)tolua_ret); 01817 } 01818 } 01819 return 1; 01820 #ifndef TOLUA_RELEASE 01821 tolua_lerror: 01822 tolua_error(tolua_S,"#ferror in function 'id'.",&tolua_err); 01823 return 0; 01824 #endif 01825 } 01826 #endif //#ifndef TOLUA_DISABLE 01827 01828 /* method: uid of class fawkes::TestInterface */ 01829 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_uid00 01830 static int tolua_interfaces_TestInterface_fawkes_TestInterface_uid00(lua_State* tolua_S) 01831 { 01832 #ifndef TOLUA_RELEASE 01833 tolua_Error tolua_err; 01834 if ( 01835 !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) || 01836 !tolua_isnoobj(tolua_S,2,&tolua_err) 01837 ) 01838 goto tolua_lerror; 01839 else 01840 #endif 01841 { 01842 const fawkes::TestInterface* self = (const fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 01843 #ifndef TOLUA_RELEASE 01844 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'uid'", NULL); 01845 #endif 01846 { 01847 const char* tolua_ret = (const char*) self->uid(); 01848 tolua_pushstring(tolua_S,(const char*)tolua_ret); 01849 } 01850 } 01851 return 1; 01852 #ifndef TOLUA_RELEASE 01853 tolua_lerror: 01854 tolua_error(tolua_S,"#ferror in function 'uid'.",&tolua_err); 01855 return 0; 01856 #endif 01857 } 01858 #endif //#ifndef TOLUA_DISABLE 01859 01860 /* method: serial of class fawkes::TestInterface */ 01861 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_serial00 01862 static int tolua_interfaces_TestInterface_fawkes_TestInterface_serial00(lua_State* tolua_S) 01863 { 01864 #ifndef TOLUA_RELEASE 01865 tolua_Error tolua_err; 01866 if ( 01867 !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) || 01868 !tolua_isnoobj(tolua_S,2,&tolua_err) 01869 ) 01870 goto tolua_lerror; 01871 else 01872 #endif 01873 { 01874 const fawkes::TestInterface* self = (const fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 01875 #ifndef TOLUA_RELEASE 01876 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'serial'", NULL); 01877 #endif 01878 { 01879 unsigned int tolua_ret = (unsigned int) self->serial(); 01880 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01881 } 01882 } 01883 return 1; 01884 #ifndef TOLUA_RELEASE 01885 tolua_lerror: 01886 tolua_error(tolua_S,"#ferror in function 'serial'.",&tolua_err); 01887 return 0; 01888 #endif 01889 } 01890 #endif //#ifndef TOLUA_DISABLE 01891 01892 /* method: mem_serial of class fawkes::TestInterface */ 01893 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_mem_serial00 01894 static int tolua_interfaces_TestInterface_fawkes_TestInterface_mem_serial00(lua_State* tolua_S) 01895 { 01896 #ifndef TOLUA_RELEASE 01897 tolua_Error tolua_err; 01898 if ( 01899 !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) || 01900 !tolua_isnoobj(tolua_S,2,&tolua_err) 01901 ) 01902 goto tolua_lerror; 01903 else 01904 #endif 01905 { 01906 const fawkes::TestInterface* self = (const fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 01907 #ifndef TOLUA_RELEASE 01908 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'mem_serial'", NULL); 01909 #endif 01910 { 01911 unsigned int tolua_ret = (unsigned int) self->mem_serial(); 01912 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01913 } 01914 } 01915 return 1; 01916 #ifndef TOLUA_RELEASE 01917 tolua_lerror: 01918 tolua_error(tolua_S,"#ferror in function 'mem_serial'.",&tolua_err); 01919 return 0; 01920 #endif 01921 } 01922 #endif //#ifndef TOLUA_DISABLE 01923 01924 /* method: operator== of class fawkes::TestInterface */ 01925 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface__eq00 01926 static int tolua_interfaces_TestInterface_fawkes_TestInterface__eq00(lua_State* tolua_S) 01927 { 01928 #ifndef TOLUA_RELEASE 01929 tolua_Error tolua_err; 01930 if ( 01931 !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) || 01932 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Interface",0,&tolua_err)) || 01933 !tolua_isnoobj(tolua_S,3,&tolua_err) 01934 ) 01935 goto tolua_lerror; 01936 else 01937 #endif 01938 { 01939 const fawkes::TestInterface* self = (const fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 01940 Interface* comp = ((Interface*) tolua_tousertype(tolua_S,2,0)); 01941 #ifndef TOLUA_RELEASE 01942 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='", NULL); 01943 #endif 01944 { 01945 bool tolua_ret = (bool) self->operator==(*comp); 01946 tolua_pushboolean(tolua_S,(bool)tolua_ret); 01947 } 01948 } 01949 return 1; 01950 #ifndef TOLUA_RELEASE 01951 tolua_lerror: 01952 tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err); 01953 return 0; 01954 #endif 01955 } 01956 #endif //#ifndef TOLUA_DISABLE 01957 01958 /* method: hash of class fawkes::TestInterface */ 01959 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_hash00 01960 static int tolua_interfaces_TestInterface_fawkes_TestInterface_hash00(lua_State* tolua_S) 01961 { 01962 #ifndef TOLUA_RELEASE 01963 tolua_Error tolua_err; 01964 if ( 01965 !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) || 01966 !tolua_isnoobj(tolua_S,2,&tolua_err) 01967 ) 01968 goto tolua_lerror; 01969 else 01970 #endif 01971 { 01972 const fawkes::TestInterface* self = (const fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 01973 #ifndef TOLUA_RELEASE 01974 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash'", NULL); 01975 #endif 01976 { 01977 unsigned const char* tolua_ret = ( unsigned const char*) self->hash(); 01978 tolua_pushstring(tolua_S,(const char*)tolua_ret); 01979 } 01980 } 01981 return 1; 01982 #ifndef TOLUA_RELEASE 01983 tolua_lerror: 01984 tolua_error(tolua_S,"#ferror in function 'hash'.",&tolua_err); 01985 return 0; 01986 #endif 01987 } 01988 #endif //#ifndef TOLUA_DISABLE 01989 01990 /* method: hash_size of class fawkes::TestInterface */ 01991 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_hash_size00 01992 static int tolua_interfaces_TestInterface_fawkes_TestInterface_hash_size00(lua_State* tolua_S) 01993 { 01994 #ifndef TOLUA_RELEASE 01995 tolua_Error tolua_err; 01996 if ( 01997 !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) || 01998 !tolua_isnoobj(tolua_S,2,&tolua_err) 01999 ) 02000 goto tolua_lerror; 02001 else 02002 #endif 02003 { 02004 const fawkes::TestInterface* self = (const fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 02005 #ifndef TOLUA_RELEASE 02006 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash_size'", NULL); 02007 #endif 02008 { 02009 int tolua_ret = (int) self->hash_size(); 02010 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 02011 } 02012 } 02013 return 1; 02014 #ifndef TOLUA_RELEASE 02015 tolua_lerror: 02016 tolua_error(tolua_S,"#ferror in function 'hash_size'.",&tolua_err); 02017 return 0; 02018 #endif 02019 } 02020 #endif //#ifndef TOLUA_DISABLE 02021 02022 /* method: hash_printable of class fawkes::TestInterface */ 02023 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_hash_printable00 02024 static int tolua_interfaces_TestInterface_fawkes_TestInterface_hash_printable00(lua_State* tolua_S) 02025 { 02026 #ifndef TOLUA_RELEASE 02027 tolua_Error tolua_err; 02028 if ( 02029 !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) || 02030 !tolua_isnoobj(tolua_S,2,&tolua_err) 02031 ) 02032 goto tolua_lerror; 02033 else 02034 #endif 02035 { 02036 const fawkes::TestInterface* self = (const fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 02037 #ifndef TOLUA_RELEASE 02038 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash_printable'", NULL); 02039 #endif 02040 { 02041 const char* tolua_ret = (const char*) self->hash_printable(); 02042 tolua_pushstring(tolua_S,(const char*)tolua_ret); 02043 } 02044 } 02045 return 1; 02046 #ifndef TOLUA_RELEASE 02047 tolua_lerror: 02048 tolua_error(tolua_S,"#ferror in function 'hash_printable'.",&tolua_err); 02049 return 0; 02050 #endif 02051 } 02052 #endif //#ifndef TOLUA_DISABLE 02053 02054 /* method: is_writer of class fawkes::TestInterface */ 02055 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_is_writer00 02056 static int tolua_interfaces_TestInterface_fawkes_TestInterface_is_writer00(lua_State* tolua_S) 02057 { 02058 #ifndef TOLUA_RELEASE 02059 tolua_Error tolua_err; 02060 if ( 02061 !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) || 02062 !tolua_isnoobj(tolua_S,2,&tolua_err) 02063 ) 02064 goto tolua_lerror; 02065 else 02066 #endif 02067 { 02068 const fawkes::TestInterface* self = (const fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 02069 #ifndef TOLUA_RELEASE 02070 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_writer'", NULL); 02071 #endif 02072 { 02073 bool tolua_ret = (bool) self->is_writer(); 02074 tolua_pushboolean(tolua_S,(bool)tolua_ret); 02075 } 02076 } 02077 return 1; 02078 #ifndef TOLUA_RELEASE 02079 tolua_lerror: 02080 tolua_error(tolua_S,"#ferror in function 'is_writer'.",&tolua_err); 02081 return 0; 02082 #endif 02083 } 02084 #endif //#ifndef TOLUA_DISABLE 02085 02086 /* method: set_from_chunk of class fawkes::TestInterface */ 02087 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_set_from_chunk00 02088 static int tolua_interfaces_TestInterface_fawkes_TestInterface_set_from_chunk00(lua_State* tolua_S) 02089 { 02090 #ifndef TOLUA_RELEASE 02091 tolua_Error tolua_err; 02092 if ( 02093 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) || 02094 !tolua_isuserdata(tolua_S,2,0,&tolua_err) || 02095 !tolua_isnoobj(tolua_S,3,&tolua_err) 02096 ) 02097 goto tolua_lerror; 02098 else 02099 #endif 02100 { 02101 fawkes::TestInterface* self = (fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 02102 void* chunk = ((void*) tolua_touserdata(tolua_S,2,0)); 02103 #ifndef TOLUA_RELEASE 02104 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_from_chunk'", NULL); 02105 #endif 02106 { 02107 self->set_from_chunk(chunk); 02108 } 02109 } 02110 return 0; 02111 #ifndef TOLUA_RELEASE 02112 tolua_lerror: 02113 tolua_error(tolua_S,"#ferror in function 'set_from_chunk'.",&tolua_err); 02114 return 0; 02115 #endif 02116 } 02117 #endif //#ifndef TOLUA_DISABLE 02118 02119 /* method: create_message of class fawkes::TestInterface */ 02120 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_create_message00 02121 static int tolua_interfaces_TestInterface_fawkes_TestInterface_create_message00(lua_State* tolua_S) 02122 { 02123 #ifndef TOLUA_RELEASE 02124 tolua_Error tolua_err; 02125 if ( 02126 !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) || 02127 !tolua_isstring(tolua_S,2,0,&tolua_err) || 02128 !tolua_isnoobj(tolua_S,3,&tolua_err) 02129 ) 02130 goto tolua_lerror; 02131 else 02132 #endif 02133 { 02134 const fawkes::TestInterface* self = (const fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 02135 const char* type = ((const char*) tolua_tostring(tolua_S,2,0)); 02136 #ifndef TOLUA_RELEASE 02137 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'create_message'", NULL); 02138 #endif 02139 { 02140 Message* tolua_ret = (Message*) self->create_message(type); 02141 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Message"); 02142 } 02143 } 02144 return 1; 02145 #ifndef TOLUA_RELEASE 02146 tolua_lerror: 02147 tolua_error(tolua_S,"#ferror in function 'create_message'.",&tolua_err); 02148 return 0; 02149 #endif 02150 } 02151 #endif //#ifndef TOLUA_DISABLE 02152 02153 /* method: read of class fawkes::TestInterface */ 02154 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_read00 02155 static int tolua_interfaces_TestInterface_fawkes_TestInterface_read00(lua_State* tolua_S) 02156 { 02157 #ifndef TOLUA_RELEASE 02158 tolua_Error tolua_err; 02159 if ( 02160 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) || 02161 !tolua_isnoobj(tolua_S,2,&tolua_err) 02162 ) 02163 goto tolua_lerror; 02164 else 02165 #endif 02166 { 02167 fawkes::TestInterface* self = (fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 02168 #ifndef TOLUA_RELEASE 02169 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'read'", NULL); 02170 #endif 02171 { 02172 self->read(); 02173 } 02174 } 02175 return 0; 02176 #ifndef TOLUA_RELEASE 02177 tolua_lerror: 02178 tolua_error(tolua_S,"#ferror in function 'read'.",&tolua_err); 02179 return 0; 02180 #endif 02181 } 02182 #endif //#ifndef TOLUA_DISABLE 02183 02184 /* method: write of class fawkes::TestInterface */ 02185 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_write00 02186 static int tolua_interfaces_TestInterface_fawkes_TestInterface_write00(lua_State* tolua_S) 02187 { 02188 #ifndef TOLUA_RELEASE 02189 tolua_Error tolua_err; 02190 if ( 02191 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) || 02192 !tolua_isnoobj(tolua_S,2,&tolua_err) 02193 ) 02194 goto tolua_lerror; 02195 else 02196 #endif 02197 { 02198 fawkes::TestInterface* self = (fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 02199 #ifndef TOLUA_RELEASE 02200 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'write'", NULL); 02201 #endif 02202 { 02203 self->write(); 02204 } 02205 } 02206 return 0; 02207 #ifndef TOLUA_RELEASE 02208 tolua_lerror: 02209 tolua_error(tolua_S,"#ferror in function 'write'.",&tolua_err); 02210 return 0; 02211 #endif 02212 } 02213 #endif //#ifndef TOLUA_DISABLE 02214 02215 /* method: has_writer of class fawkes::TestInterface */ 02216 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_has_writer00 02217 static int tolua_interfaces_TestInterface_fawkes_TestInterface_has_writer00(lua_State* tolua_S) 02218 { 02219 #ifndef TOLUA_RELEASE 02220 tolua_Error tolua_err; 02221 if ( 02222 !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) || 02223 !tolua_isnoobj(tolua_S,2,&tolua_err) 02224 ) 02225 goto tolua_lerror; 02226 else 02227 #endif 02228 { 02229 const fawkes::TestInterface* self = (const fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 02230 #ifndef TOLUA_RELEASE 02231 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'has_writer'", NULL); 02232 #endif 02233 { 02234 bool tolua_ret = (bool) self->has_writer(); 02235 tolua_pushboolean(tolua_S,(bool)tolua_ret); 02236 } 02237 } 02238 return 1; 02239 #ifndef TOLUA_RELEASE 02240 tolua_lerror: 02241 tolua_error(tolua_S,"#ferror in function 'has_writer'.",&tolua_err); 02242 return 0; 02243 #endif 02244 } 02245 #endif //#ifndef TOLUA_DISABLE 02246 02247 /* method: num_readers of class fawkes::TestInterface */ 02248 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_num_readers00 02249 static int tolua_interfaces_TestInterface_fawkes_TestInterface_num_readers00(lua_State* tolua_S) 02250 { 02251 #ifndef TOLUA_RELEASE 02252 tolua_Error tolua_err; 02253 if ( 02254 !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) || 02255 !tolua_isnoobj(tolua_S,2,&tolua_err) 02256 ) 02257 goto tolua_lerror; 02258 else 02259 #endif 02260 { 02261 const fawkes::TestInterface* self = (const fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 02262 #ifndef TOLUA_RELEASE 02263 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'num_readers'", NULL); 02264 #endif 02265 { 02266 unsigned int tolua_ret = (unsigned int) self->num_readers(); 02267 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 02268 } 02269 } 02270 return 1; 02271 #ifndef TOLUA_RELEASE 02272 tolua_lerror: 02273 tolua_error(tolua_S,"#ferror in function 'num_readers'.",&tolua_err); 02274 return 0; 02275 #endif 02276 } 02277 #endif //#ifndef TOLUA_DISABLE 02278 02279 /* method: msgq_enqueue_copy of class fawkes::TestInterface */ 02280 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_enqueue_copy00 02281 static int tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_enqueue_copy00(lua_State* tolua_S) 02282 { 02283 #ifndef TOLUA_RELEASE 02284 tolua_Error tolua_err; 02285 if ( 02286 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) || 02287 !tolua_isusertype(tolua_S,2,"Message",0,&tolua_err) || 02288 !tolua_isnoobj(tolua_S,3,&tolua_err) 02289 ) 02290 goto tolua_lerror; 02291 else 02292 #endif 02293 { 02294 fawkes::TestInterface* self = (fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 02295 Message* message = ((Message*) tolua_tousertype(tolua_S,2,0)); 02296 #ifndef TOLUA_RELEASE 02297 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_enqueue_copy'", NULL); 02298 #endif 02299 { 02300 unsigned int tolua_ret = (unsigned int) self->msgq_enqueue_copy(message); 02301 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 02302 } 02303 } 02304 return 1; 02305 #ifndef TOLUA_RELEASE 02306 tolua_lerror: 02307 tolua_error(tolua_S,"#ferror in function 'msgq_enqueue_copy'.",&tolua_err); 02308 return 0; 02309 #endif 02310 } 02311 #endif //#ifndef TOLUA_DISABLE 02312 02313 /* method: msgq_remove of class fawkes::TestInterface */ 02314 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_remove00 02315 static int tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_remove00(lua_State* tolua_S) 02316 { 02317 #ifndef TOLUA_RELEASE 02318 tolua_Error tolua_err; 02319 if ( 02320 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) || 02321 !tolua_isusertype(tolua_S,2,"Message",0,&tolua_err) || 02322 !tolua_isnoobj(tolua_S,3,&tolua_err) 02323 ) 02324 goto tolua_lerror; 02325 else 02326 #endif 02327 { 02328 fawkes::TestInterface* self = (fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 02329 Message* message = ((Message*) tolua_tousertype(tolua_S,2,0)); 02330 #ifndef TOLUA_RELEASE 02331 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_remove'", NULL); 02332 #endif 02333 { 02334 self->msgq_remove(message); 02335 } 02336 } 02337 return 0; 02338 #ifndef TOLUA_RELEASE 02339 tolua_lerror: 02340 tolua_error(tolua_S,"#ferror in function 'msgq_remove'.",&tolua_err); 02341 return 0; 02342 #endif 02343 } 02344 #endif //#ifndef TOLUA_DISABLE 02345 02346 /* method: msgq_remove of class fawkes::TestInterface */ 02347 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_remove01 02348 static int tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_remove01(lua_State* tolua_S) 02349 { 02350 tolua_Error tolua_err; 02351 if ( 02352 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) || 02353 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 02354 !tolua_isnoobj(tolua_S,3,&tolua_err) 02355 ) 02356 goto tolua_lerror; 02357 else 02358 { 02359 fawkes::TestInterface* self = (fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 02360 unsigned int message_id = ((unsigned int) tolua_tonumber(tolua_S,2,0)); 02361 #ifndef TOLUA_RELEASE 02362 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_remove'", NULL); 02363 #endif 02364 { 02365 self->msgq_remove(message_id); 02366 } 02367 } 02368 return 0; 02369 tolua_lerror: 02370 return tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_remove00(tolua_S); 02371 } 02372 #endif //#ifndef TOLUA_DISABLE 02373 02374 /* method: msgq_size of class fawkes::TestInterface */ 02375 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_size00 02376 static int tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_size00(lua_State* tolua_S) 02377 { 02378 #ifndef TOLUA_RELEASE 02379 tolua_Error tolua_err; 02380 if ( 02381 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) || 02382 !tolua_isnoobj(tolua_S,2,&tolua_err) 02383 ) 02384 goto tolua_lerror; 02385 else 02386 #endif 02387 { 02388 fawkes::TestInterface* self = (fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 02389 #ifndef TOLUA_RELEASE 02390 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_size'", NULL); 02391 #endif 02392 { 02393 unsigned int tolua_ret = (unsigned int) self->msgq_size(); 02394 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 02395 } 02396 } 02397 return 1; 02398 #ifndef TOLUA_RELEASE 02399 tolua_lerror: 02400 tolua_error(tolua_S,"#ferror in function 'msgq_size'.",&tolua_err); 02401 return 0; 02402 #endif 02403 } 02404 #endif //#ifndef TOLUA_DISABLE 02405 02406 /* method: msgq_flush of class fawkes::TestInterface */ 02407 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_flush00 02408 static int tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_flush00(lua_State* tolua_S) 02409 { 02410 #ifndef TOLUA_RELEASE 02411 tolua_Error tolua_err; 02412 if ( 02413 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) || 02414 !tolua_isnoobj(tolua_S,2,&tolua_err) 02415 ) 02416 goto tolua_lerror; 02417 else 02418 #endif 02419 { 02420 fawkes::TestInterface* self = (fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 02421 #ifndef TOLUA_RELEASE 02422 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_flush'", NULL); 02423 #endif 02424 { 02425 self->msgq_flush(); 02426 } 02427 } 02428 return 0; 02429 #ifndef TOLUA_RELEASE 02430 tolua_lerror: 02431 tolua_error(tolua_S,"#ferror in function 'msgq_flush'.",&tolua_err); 02432 return 0; 02433 #endif 02434 } 02435 #endif //#ifndef TOLUA_DISABLE 02436 02437 /* method: msgq_lock of class fawkes::TestInterface */ 02438 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_lock00 02439 static int tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_lock00(lua_State* tolua_S) 02440 { 02441 #ifndef TOLUA_RELEASE 02442 tolua_Error tolua_err; 02443 if ( 02444 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) || 02445 !tolua_isnoobj(tolua_S,2,&tolua_err) 02446 ) 02447 goto tolua_lerror; 02448 else 02449 #endif 02450 { 02451 fawkes::TestInterface* self = (fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 02452 #ifndef TOLUA_RELEASE 02453 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_lock'", NULL); 02454 #endif 02455 { 02456 self->msgq_lock(); 02457 } 02458 } 02459 return 0; 02460 #ifndef TOLUA_RELEASE 02461 tolua_lerror: 02462 tolua_error(tolua_S,"#ferror in function 'msgq_lock'.",&tolua_err); 02463 return 0; 02464 #endif 02465 } 02466 #endif //#ifndef TOLUA_DISABLE 02467 02468 /* method: msgq_try_lock of class fawkes::TestInterface */ 02469 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_try_lock00 02470 static int tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_try_lock00(lua_State* tolua_S) 02471 { 02472 #ifndef TOLUA_RELEASE 02473 tolua_Error tolua_err; 02474 if ( 02475 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) || 02476 !tolua_isnoobj(tolua_S,2,&tolua_err) 02477 ) 02478 goto tolua_lerror; 02479 else 02480 #endif 02481 { 02482 fawkes::TestInterface* self = (fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 02483 #ifndef TOLUA_RELEASE 02484 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_try_lock'", NULL); 02485 #endif 02486 { 02487 bool tolua_ret = (bool) self->msgq_try_lock(); 02488 tolua_pushboolean(tolua_S,(bool)tolua_ret); 02489 } 02490 } 02491 return 1; 02492 #ifndef TOLUA_RELEASE 02493 tolua_lerror: 02494 tolua_error(tolua_S,"#ferror in function 'msgq_try_lock'.",&tolua_err); 02495 return 0; 02496 #endif 02497 } 02498 #endif //#ifndef TOLUA_DISABLE 02499 02500 /* method: msgq_unlock of class fawkes::TestInterface */ 02501 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_unlock00 02502 static int tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_unlock00(lua_State* tolua_S) 02503 { 02504 #ifndef TOLUA_RELEASE 02505 tolua_Error tolua_err; 02506 if ( 02507 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) || 02508 !tolua_isnoobj(tolua_S,2,&tolua_err) 02509 ) 02510 goto tolua_lerror; 02511 else 02512 #endif 02513 { 02514 fawkes::TestInterface* self = (fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 02515 #ifndef TOLUA_RELEASE 02516 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_unlock'", NULL); 02517 #endif 02518 { 02519 self->msgq_unlock(); 02520 } 02521 } 02522 return 0; 02523 #ifndef TOLUA_RELEASE 02524 tolua_lerror: 02525 tolua_error(tolua_S,"#ferror in function 'msgq_unlock'.",&tolua_err); 02526 return 0; 02527 #endif 02528 } 02529 #endif //#ifndef TOLUA_DISABLE 02530 02531 /* method: msgq_pop of class fawkes::TestInterface */ 02532 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_pop00 02533 static int tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_pop00(lua_State* tolua_S) 02534 { 02535 #ifndef TOLUA_RELEASE 02536 tolua_Error tolua_err; 02537 if ( 02538 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) || 02539 !tolua_isnoobj(tolua_S,2,&tolua_err) 02540 ) 02541 goto tolua_lerror; 02542 else 02543 #endif 02544 { 02545 fawkes::TestInterface* self = (fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 02546 #ifndef TOLUA_RELEASE 02547 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_pop'", NULL); 02548 #endif 02549 { 02550 self->msgq_pop(); 02551 } 02552 } 02553 return 0; 02554 #ifndef TOLUA_RELEASE 02555 tolua_lerror: 02556 tolua_error(tolua_S,"#ferror in function 'msgq_pop'.",&tolua_err); 02557 return 0; 02558 #endif 02559 } 02560 #endif //#ifndef TOLUA_DISABLE 02561 02562 /* method: msgq_first of class fawkes::TestInterface */ 02563 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_first00 02564 static int tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_first00(lua_State* tolua_S) 02565 { 02566 #ifndef TOLUA_RELEASE 02567 tolua_Error tolua_err; 02568 if ( 02569 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) || 02570 !tolua_isnoobj(tolua_S,2,&tolua_err) 02571 ) 02572 goto tolua_lerror; 02573 else 02574 #endif 02575 { 02576 fawkes::TestInterface* self = (fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 02577 #ifndef TOLUA_RELEASE 02578 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_first'", NULL); 02579 #endif 02580 { 02581 Message* tolua_ret = (Message*) self->msgq_first(); 02582 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Message"); 02583 } 02584 } 02585 return 1; 02586 #ifndef TOLUA_RELEASE 02587 tolua_lerror: 02588 tolua_error(tolua_S,"#ferror in function 'msgq_first'.",&tolua_err); 02589 return 0; 02590 #endif 02591 } 02592 #endif //#ifndef TOLUA_DISABLE 02593 02594 /* method: msgq_empty of class fawkes::TestInterface */ 02595 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_empty00 02596 static int tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_empty00(lua_State* tolua_S) 02597 { 02598 #ifndef TOLUA_RELEASE 02599 tolua_Error tolua_err; 02600 if ( 02601 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) || 02602 !tolua_isnoobj(tolua_S,2,&tolua_err) 02603 ) 02604 goto tolua_lerror; 02605 else 02606 #endif 02607 { 02608 fawkes::TestInterface* self = (fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 02609 #ifndef TOLUA_RELEASE 02610 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_empty'", NULL); 02611 #endif 02612 { 02613 bool tolua_ret = (bool) self->msgq_empty(); 02614 tolua_pushboolean(tolua_S,(bool)tolua_ret); 02615 } 02616 } 02617 return 1; 02618 #ifndef TOLUA_RELEASE 02619 tolua_lerror: 02620 tolua_error(tolua_S,"#ferror in function 'msgq_empty'.",&tolua_err); 02621 return 0; 02622 #endif 02623 } 02624 #endif //#ifndef TOLUA_DISABLE 02625 02626 /* Open function */ 02627 TOLUA_API int tolua_interfaces_TestInterface_open (lua_State* tolua_S) 02628 { 02629 tolua_open(tolua_S); 02630 tolua_reg_types(tolua_S); 02631 tolua_module(tolua_S,NULL,0); 02632 tolua_beginmodule(tolua_S,NULL); 02633 tolua_module(tolua_S,"fawkes",0); 02634 tolua_beginmodule(tolua_S,"fawkes"); 02635 tolua_cclass(tolua_S,"TestInterface","fawkes::TestInterface","Interface",NULL); 02636 tolua_beginmodule(tolua_S,"TestInterface"); 02637 tolua_variable(tolua_S,"TEST_CONSTANT",tolua_get_fawkes__TestInterface_TEST_CONSTANT,NULL); 02638 tolua_variable(tolua_S,"TEST_FLOAT_CONSTANT",tolua_get_fawkes__TestInterface_TEST_FLOAT_CONSTANT,NULL); 02639 tolua_constant(tolua_S,"TEST_ENUM_1",fawkes::TestInterface::TEST_ENUM_1); 02640 tolua_constant(tolua_S,"TEST_ENUM_2",fawkes::TestInterface::TEST_ENUM_2); 02641 #ifdef __cplusplus 02642 tolua_cclass(tolua_S,"SetTestIntMessage","fawkes::TestInterface::SetTestIntMessage","Message",tolua_collect_fawkes__TestInterface__SetTestIntMessage); 02643 #else 02644 tolua_cclass(tolua_S,"SetTestIntMessage","fawkes::TestInterface::SetTestIntMessage","Message",NULL); 02645 #endif 02646 tolua_beginmodule(tolua_S,"SetTestIntMessage"); 02647 tolua_function(tolua_S,"new",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_new00); 02648 tolua_function(tolua_S,"new_local",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_new00_local); 02649 tolua_function(tolua_S,".call",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_new00_local); 02650 tolua_function(tolua_S,"new",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_new01); 02651 tolua_function(tolua_S,"new_local",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_new01_local); 02652 tolua_function(tolua_S,".call",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_new01_local); 02653 tolua_function(tolua_S,"delete",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_delete00); 02654 tolua_function(tolua_S,"test_int",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_test_int00); 02655 tolua_function(tolua_S,"set_test_int",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_set_test_int00); 02656 tolua_function(tolua_S,"maxlenof_test_int",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_maxlenof_test_int00); 02657 tolua_endmodule(tolua_S); 02658 #ifdef __cplusplus 02659 tolua_cclass(tolua_S,"SetTestStringMessage","fawkes::TestInterface::SetTestStringMessage","Message",tolua_collect_fawkes__TestInterface__SetTestStringMessage); 02660 #else 02661 tolua_cclass(tolua_S,"SetTestStringMessage","fawkes::TestInterface::SetTestStringMessage","Message",NULL); 02662 #endif 02663 tolua_beginmodule(tolua_S,"SetTestStringMessage"); 02664 tolua_function(tolua_S,"new",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_new00); 02665 tolua_function(tolua_S,"new_local",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_new00_local); 02666 tolua_function(tolua_S,".call",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_new00_local); 02667 tolua_function(tolua_S,"new",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_new01); 02668 tolua_function(tolua_S,"new_local",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_new01_local); 02669 tolua_function(tolua_S,".call",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_new01_local); 02670 tolua_function(tolua_S,"delete",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_delete00); 02671 tolua_function(tolua_S,"test_string",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_test_string00); 02672 tolua_function(tolua_S,"set_test_string",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_set_test_string00); 02673 tolua_function(tolua_S,"maxlenof_test_string",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_maxlenof_test_string00); 02674 tolua_endmodule(tolua_S); 02675 #ifdef __cplusplus 02676 tolua_cclass(tolua_S,"CalculateMessage","fawkes::TestInterface::CalculateMessage","Message",tolua_collect_fawkes__TestInterface__CalculateMessage); 02677 #else 02678 tolua_cclass(tolua_S,"CalculateMessage","fawkes::TestInterface::CalculateMessage","Message",NULL); 02679 #endif 02680 tolua_beginmodule(tolua_S,"CalculateMessage"); 02681 tolua_function(tolua_S,"new",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_new00); 02682 tolua_function(tolua_S,"new_local",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_new00_local); 02683 tolua_function(tolua_S,".call",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_new00_local); 02684 tolua_function(tolua_S,"new",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_new01); 02685 tolua_function(tolua_S,"new_local",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_new01_local); 02686 tolua_function(tolua_S,".call",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_new01_local); 02687 tolua_function(tolua_S,"delete",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_delete00); 02688 tolua_function(tolua_S,"summand",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_summand00); 02689 tolua_function(tolua_S,"set_summand",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_set_summand00); 02690 tolua_function(tolua_S,"maxlenof_summand",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_maxlenof_summand00); 02691 tolua_function(tolua_S,"addend",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_addend00); 02692 tolua_function(tolua_S,"set_addend",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_set_addend00); 02693 tolua_function(tolua_S,"maxlenof_addend",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_maxlenof_addend00); 02694 tolua_endmodule(tolua_S); 02695 tolua_function(tolua_S,"is_test_bool",tolua_interfaces_TestInterface_fawkes_TestInterface_is_test_bool00); 02696 tolua_function(tolua_S,"set_test_bool",tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_bool00); 02697 tolua_function(tolua_S,"maxlenof_test_bool",tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_bool00); 02698 tolua_function(tolua_S,"test_int",tolua_interfaces_TestInterface_fawkes_TestInterface_test_int00); 02699 tolua_function(tolua_S,"set_test_int",tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_int00); 02700 tolua_function(tolua_S,"maxlenof_test_int",tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_int00); 02701 tolua_function(tolua_S,"flags",tolua_interfaces_TestInterface_fawkes_TestInterface_flags00); 02702 tolua_function(tolua_S,"set_flags",tolua_interfaces_TestInterface_fawkes_TestInterface_set_flags00); 02703 tolua_function(tolua_S,"maxlenof_flags",tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_flags00); 02704 tolua_function(tolua_S,"test_string",tolua_interfaces_TestInterface_fawkes_TestInterface_test_string00); 02705 tolua_function(tolua_S,"set_test_string",tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_string00); 02706 tolua_function(tolua_S,"maxlenof_test_string",tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_string00); 02707 tolua_function(tolua_S,"result",tolua_interfaces_TestInterface_fawkes_TestInterface_result00); 02708 tolua_function(tolua_S,"set_result",tolua_interfaces_TestInterface_fawkes_TestInterface_set_result00); 02709 tolua_function(tolua_S,"maxlenof_result",tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_result00); 02710 tolua_function(tolua_S,"test_uint",tolua_interfaces_TestInterface_fawkes_TestInterface_test_uint00); 02711 tolua_function(tolua_S,"set_test_uint",tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_uint00); 02712 tolua_function(tolua_S,"maxlenof_test_uint",tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_uint00); 02713 tolua_function(tolua_S,"test_ulint",tolua_interfaces_TestInterface_fawkes_TestInterface_test_ulint00); 02714 tolua_function(tolua_S,"set_test_ulint",tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_ulint00); 02715 tolua_function(tolua_S,"maxlenof_test_ulint",tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_ulint00); 02716 tolua_function(tolua_S,"test_lint",tolua_interfaces_TestInterface_fawkes_TestInterface_test_lint00); 02717 tolua_function(tolua_S,"set_test_lint",tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_lint00); 02718 tolua_function(tolua_S,"maxlenof_test_lint",tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_lint00); 02719 tolua_function(tolua_S,"oftype",tolua_interfaces_TestInterface_fawkes_TestInterface_oftype00); 02720 tolua_function(tolua_S,"datachunk",tolua_interfaces_TestInterface_fawkes_TestInterface_datachunk00); 02721 tolua_function(tolua_S,"datasize",tolua_interfaces_TestInterface_fawkes_TestInterface_datasize00); 02722 tolua_function(tolua_S,"type",tolua_interfaces_TestInterface_fawkes_TestInterface_type00); 02723 tolua_function(tolua_S,"id",tolua_interfaces_TestInterface_fawkes_TestInterface_id00); 02724 tolua_function(tolua_S,"uid",tolua_interfaces_TestInterface_fawkes_TestInterface_uid00); 02725 tolua_function(tolua_S,"serial",tolua_interfaces_TestInterface_fawkes_TestInterface_serial00); 02726 tolua_function(tolua_S,"mem_serial",tolua_interfaces_TestInterface_fawkes_TestInterface_mem_serial00); 02727 tolua_function(tolua_S,".eq",tolua_interfaces_TestInterface_fawkes_TestInterface__eq00); 02728 tolua_function(tolua_S,"hash",tolua_interfaces_TestInterface_fawkes_TestInterface_hash00); 02729 tolua_function(tolua_S,"hash_size",tolua_interfaces_TestInterface_fawkes_TestInterface_hash_size00); 02730 tolua_function(tolua_S,"hash_printable",tolua_interfaces_TestInterface_fawkes_TestInterface_hash_printable00); 02731 tolua_function(tolua_S,"is_writer",tolua_interfaces_TestInterface_fawkes_TestInterface_is_writer00); 02732 tolua_function(tolua_S,"set_from_chunk",tolua_interfaces_TestInterface_fawkes_TestInterface_set_from_chunk00); 02733 tolua_function(tolua_S,"create_message",tolua_interfaces_TestInterface_fawkes_TestInterface_create_message00); 02734 tolua_function(tolua_S,"read",tolua_interfaces_TestInterface_fawkes_TestInterface_read00); 02735 tolua_function(tolua_S,"write",tolua_interfaces_TestInterface_fawkes_TestInterface_write00); 02736 tolua_function(tolua_S,"has_writer",tolua_interfaces_TestInterface_fawkes_TestInterface_has_writer00); 02737 tolua_function(tolua_S,"num_readers",tolua_interfaces_TestInterface_fawkes_TestInterface_num_readers00); 02738 tolua_function(tolua_S,"msgq_enqueue_copy",tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_enqueue_copy00); 02739 tolua_function(tolua_S,"msgq_remove",tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_remove00); 02740 tolua_function(tolua_S,"msgq_remove",tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_remove01); 02741 tolua_function(tolua_S,"msgq_size",tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_size00); 02742 tolua_function(tolua_S,"msgq_flush",tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_flush00); 02743 tolua_function(tolua_S,"msgq_lock",tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_lock00); 02744 tolua_function(tolua_S,"msgq_try_lock",tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_try_lock00); 02745 tolua_function(tolua_S,"msgq_unlock",tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_unlock00); 02746 tolua_function(tolua_S,"msgq_pop",tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_pop00); 02747 tolua_function(tolua_S,"msgq_first",tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_first00); 02748 tolua_function(tolua_S,"msgq_empty",tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_empty00); 02749 tolua_endmodule(tolua_S); 02750 tolua_endmodule(tolua_S); 02751 tolua_endmodule(tolua_S); 02752 return 1; 02753 } 02754 02755 02756 extern "C" { 02757 #if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501 02758 TOLUA_API int luaopen_interfaces_TestInterface (lua_State* tolua_S) { 02759 return tolua_interfaces_TestInterface_open(tolua_S); 02760 }; 02761 #endif 02762 } 02763 02764