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: oftype of class fawkes::TestInterface */ 01473 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_oftype00 01474 static int tolua_interfaces_TestInterface_fawkes_TestInterface_oftype00(lua_State* tolua_S) 01475 { 01476 #ifndef TOLUA_RELEASE 01477 tolua_Error tolua_err; 01478 if ( 01479 !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) || 01480 !tolua_isstring(tolua_S,2,0,&tolua_err) || 01481 !tolua_isnoobj(tolua_S,3,&tolua_err) 01482 ) 01483 goto tolua_lerror; 01484 else 01485 #endif 01486 { 01487 const fawkes::TestInterface* self = (const fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 01488 const char* interface_type = ((const char*) tolua_tostring(tolua_S,2,0)); 01489 #ifndef TOLUA_RELEASE 01490 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'oftype'", NULL); 01491 #endif 01492 { 01493 bool tolua_ret = (bool) self->oftype(interface_type); 01494 tolua_pushboolean(tolua_S,(bool)tolua_ret); 01495 } 01496 } 01497 return 1; 01498 #ifndef TOLUA_RELEASE 01499 tolua_lerror: 01500 tolua_error(tolua_S,"#ferror in function 'oftype'.",&tolua_err); 01501 return 0; 01502 #endif 01503 } 01504 #endif //#ifndef TOLUA_DISABLE 01505 01506 /* method: datachunk of class fawkes::TestInterface */ 01507 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_datachunk00 01508 static int tolua_interfaces_TestInterface_fawkes_TestInterface_datachunk00(lua_State* tolua_S) 01509 { 01510 #ifndef TOLUA_RELEASE 01511 tolua_Error tolua_err; 01512 if ( 01513 !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) || 01514 !tolua_isnoobj(tolua_S,2,&tolua_err) 01515 ) 01516 goto tolua_lerror; 01517 else 01518 #endif 01519 { 01520 const fawkes::TestInterface* self = (const fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 01521 #ifndef TOLUA_RELEASE 01522 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datachunk'", NULL); 01523 #endif 01524 { 01525 const void* tolua_ret = (const void*) self->datachunk(); 01526 tolua_pushuserdata(tolua_S,(void*)tolua_ret); 01527 } 01528 } 01529 return 1; 01530 #ifndef TOLUA_RELEASE 01531 tolua_lerror: 01532 tolua_error(tolua_S,"#ferror in function 'datachunk'.",&tolua_err); 01533 return 0; 01534 #endif 01535 } 01536 #endif //#ifndef TOLUA_DISABLE 01537 01538 /* method: datasize of class fawkes::TestInterface */ 01539 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_datasize00 01540 static int tolua_interfaces_TestInterface_fawkes_TestInterface_datasize00(lua_State* tolua_S) 01541 { 01542 #ifndef TOLUA_RELEASE 01543 tolua_Error tolua_err; 01544 if ( 01545 !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) || 01546 !tolua_isnoobj(tolua_S,2,&tolua_err) 01547 ) 01548 goto tolua_lerror; 01549 else 01550 #endif 01551 { 01552 const fawkes::TestInterface* self = (const fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 01553 #ifndef TOLUA_RELEASE 01554 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datasize'", NULL); 01555 #endif 01556 { 01557 unsigned int tolua_ret = (unsigned int) self->datasize(); 01558 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01559 } 01560 } 01561 return 1; 01562 #ifndef TOLUA_RELEASE 01563 tolua_lerror: 01564 tolua_error(tolua_S,"#ferror in function 'datasize'.",&tolua_err); 01565 return 0; 01566 #endif 01567 } 01568 #endif //#ifndef TOLUA_DISABLE 01569 01570 /* method: type of class fawkes::TestInterface */ 01571 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_type00 01572 static int tolua_interfaces_TestInterface_fawkes_TestInterface_type00(lua_State* tolua_S) 01573 { 01574 #ifndef TOLUA_RELEASE 01575 tolua_Error tolua_err; 01576 if ( 01577 !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) || 01578 !tolua_isnoobj(tolua_S,2,&tolua_err) 01579 ) 01580 goto tolua_lerror; 01581 else 01582 #endif 01583 { 01584 const fawkes::TestInterface* self = (const fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 01585 #ifndef TOLUA_RELEASE 01586 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'type'", NULL); 01587 #endif 01588 { 01589 const char* tolua_ret = (const char*) self->type(); 01590 tolua_pushstring(tolua_S,(const char*)tolua_ret); 01591 } 01592 } 01593 return 1; 01594 #ifndef TOLUA_RELEASE 01595 tolua_lerror: 01596 tolua_error(tolua_S,"#ferror in function 'type'.",&tolua_err); 01597 return 0; 01598 #endif 01599 } 01600 #endif //#ifndef TOLUA_DISABLE 01601 01602 /* method: id of class fawkes::TestInterface */ 01603 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_id00 01604 static int tolua_interfaces_TestInterface_fawkes_TestInterface_id00(lua_State* tolua_S) 01605 { 01606 #ifndef TOLUA_RELEASE 01607 tolua_Error tolua_err; 01608 if ( 01609 !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) || 01610 !tolua_isnoobj(tolua_S,2,&tolua_err) 01611 ) 01612 goto tolua_lerror; 01613 else 01614 #endif 01615 { 01616 const fawkes::TestInterface* self = (const fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 01617 #ifndef TOLUA_RELEASE 01618 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'id'", NULL); 01619 #endif 01620 { 01621 const char* tolua_ret = (const char*) self->id(); 01622 tolua_pushstring(tolua_S,(const char*)tolua_ret); 01623 } 01624 } 01625 return 1; 01626 #ifndef TOLUA_RELEASE 01627 tolua_lerror: 01628 tolua_error(tolua_S,"#ferror in function 'id'.",&tolua_err); 01629 return 0; 01630 #endif 01631 } 01632 #endif //#ifndef TOLUA_DISABLE 01633 01634 /* method: uid of class fawkes::TestInterface */ 01635 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_uid00 01636 static int tolua_interfaces_TestInterface_fawkes_TestInterface_uid00(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 'uid'", NULL); 01651 #endif 01652 { 01653 const char* tolua_ret = (const char*) self->uid(); 01654 tolua_pushstring(tolua_S,(const char*)tolua_ret); 01655 } 01656 } 01657 return 1; 01658 #ifndef TOLUA_RELEASE 01659 tolua_lerror: 01660 tolua_error(tolua_S,"#ferror in function 'uid'.",&tolua_err); 01661 return 0; 01662 #endif 01663 } 01664 #endif //#ifndef TOLUA_DISABLE 01665 01666 /* method: serial of class fawkes::TestInterface */ 01667 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_serial00 01668 static int tolua_interfaces_TestInterface_fawkes_TestInterface_serial00(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_isnoobj(tolua_S,2,&tolua_err) 01675 ) 01676 goto tolua_lerror; 01677 else 01678 #endif 01679 { 01680 const fawkes::TestInterface* self = (const fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 01681 #ifndef TOLUA_RELEASE 01682 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'serial'", NULL); 01683 #endif 01684 { 01685 unsigned int tolua_ret = (unsigned int) self->serial(); 01686 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01687 } 01688 } 01689 return 1; 01690 #ifndef TOLUA_RELEASE 01691 tolua_lerror: 01692 tolua_error(tolua_S,"#ferror in function 'serial'.",&tolua_err); 01693 return 0; 01694 #endif 01695 } 01696 #endif //#ifndef TOLUA_DISABLE 01697 01698 /* method: mem_serial of class fawkes::TestInterface */ 01699 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_mem_serial00 01700 static int tolua_interfaces_TestInterface_fawkes_TestInterface_mem_serial00(lua_State* tolua_S) 01701 { 01702 #ifndef TOLUA_RELEASE 01703 tolua_Error tolua_err; 01704 if ( 01705 !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) || 01706 !tolua_isnoobj(tolua_S,2,&tolua_err) 01707 ) 01708 goto tolua_lerror; 01709 else 01710 #endif 01711 { 01712 const fawkes::TestInterface* self = (const fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 01713 #ifndef TOLUA_RELEASE 01714 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'mem_serial'", NULL); 01715 #endif 01716 { 01717 unsigned int tolua_ret = (unsigned int) self->mem_serial(); 01718 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01719 } 01720 } 01721 return 1; 01722 #ifndef TOLUA_RELEASE 01723 tolua_lerror: 01724 tolua_error(tolua_S,"#ferror in function 'mem_serial'.",&tolua_err); 01725 return 0; 01726 #endif 01727 } 01728 #endif //#ifndef TOLUA_DISABLE 01729 01730 /* method: operator== of class fawkes::TestInterface */ 01731 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface__eq00 01732 static int tolua_interfaces_TestInterface_fawkes_TestInterface__eq00(lua_State* tolua_S) 01733 { 01734 #ifndef TOLUA_RELEASE 01735 tolua_Error tolua_err; 01736 if ( 01737 !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) || 01738 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Interface",0,&tolua_err)) || 01739 !tolua_isnoobj(tolua_S,3,&tolua_err) 01740 ) 01741 goto tolua_lerror; 01742 else 01743 #endif 01744 { 01745 const fawkes::TestInterface* self = (const fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 01746 Interface* comp = ((Interface*) tolua_tousertype(tolua_S,2,0)); 01747 #ifndef TOLUA_RELEASE 01748 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='", NULL); 01749 #endif 01750 { 01751 bool tolua_ret = (bool) self->operator==(*comp); 01752 tolua_pushboolean(tolua_S,(bool)tolua_ret); 01753 } 01754 } 01755 return 1; 01756 #ifndef TOLUA_RELEASE 01757 tolua_lerror: 01758 tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err); 01759 return 0; 01760 #endif 01761 } 01762 #endif //#ifndef TOLUA_DISABLE 01763 01764 /* method: hash of class fawkes::TestInterface */ 01765 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_hash00 01766 static int tolua_interfaces_TestInterface_fawkes_TestInterface_hash00(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 'hash'", NULL); 01781 #endif 01782 { 01783 unsigned const char* tolua_ret = ( unsigned const char*) self->hash(); 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 'hash'.",&tolua_err); 01791 return 0; 01792 #endif 01793 } 01794 #endif //#ifndef TOLUA_DISABLE 01795 01796 /* method: hash_size of class fawkes::TestInterface */ 01797 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_hash_size00 01798 static int tolua_interfaces_TestInterface_fawkes_TestInterface_hash_size00(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 'hash_size'", NULL); 01813 #endif 01814 { 01815 int tolua_ret = (int) self->hash_size(); 01816 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01817 } 01818 } 01819 return 1; 01820 #ifndef TOLUA_RELEASE 01821 tolua_lerror: 01822 tolua_error(tolua_S,"#ferror in function 'hash_size'.",&tolua_err); 01823 return 0; 01824 #endif 01825 } 01826 #endif //#ifndef TOLUA_DISABLE 01827 01828 /* method: hash_printable of class fawkes::TestInterface */ 01829 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_hash_printable00 01830 static int tolua_interfaces_TestInterface_fawkes_TestInterface_hash_printable00(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 'hash_printable'", NULL); 01845 #endif 01846 { 01847 const char* tolua_ret = (const char*) self->hash_printable(); 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 'hash_printable'.",&tolua_err); 01855 return 0; 01856 #endif 01857 } 01858 #endif //#ifndef TOLUA_DISABLE 01859 01860 /* method: is_writer of class fawkes::TestInterface */ 01861 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_is_writer00 01862 static int tolua_interfaces_TestInterface_fawkes_TestInterface_is_writer00(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 'is_writer'", NULL); 01877 #endif 01878 { 01879 bool tolua_ret = (bool) self->is_writer(); 01880 tolua_pushboolean(tolua_S,(bool)tolua_ret); 01881 } 01882 } 01883 return 1; 01884 #ifndef TOLUA_RELEASE 01885 tolua_lerror: 01886 tolua_error(tolua_S,"#ferror in function 'is_writer'.",&tolua_err); 01887 return 0; 01888 #endif 01889 } 01890 #endif //#ifndef TOLUA_DISABLE 01891 01892 /* method: set_from_chunk of class fawkes::TestInterface */ 01893 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_set_from_chunk00 01894 static int tolua_interfaces_TestInterface_fawkes_TestInterface_set_from_chunk00(lua_State* tolua_S) 01895 { 01896 #ifndef TOLUA_RELEASE 01897 tolua_Error tolua_err; 01898 if ( 01899 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) || 01900 !tolua_isuserdata(tolua_S,2,0,&tolua_err) || 01901 !tolua_isnoobj(tolua_S,3,&tolua_err) 01902 ) 01903 goto tolua_lerror; 01904 else 01905 #endif 01906 { 01907 fawkes::TestInterface* self = (fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 01908 void* chunk = ((void*) tolua_touserdata(tolua_S,2,0)); 01909 #ifndef TOLUA_RELEASE 01910 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_from_chunk'", NULL); 01911 #endif 01912 { 01913 self->set_from_chunk(chunk); 01914 } 01915 } 01916 return 0; 01917 #ifndef TOLUA_RELEASE 01918 tolua_lerror: 01919 tolua_error(tolua_S,"#ferror in function 'set_from_chunk'.",&tolua_err); 01920 return 0; 01921 #endif 01922 } 01923 #endif //#ifndef TOLUA_DISABLE 01924 01925 /* method: create_message of class fawkes::TestInterface */ 01926 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_create_message00 01927 static int tolua_interfaces_TestInterface_fawkes_TestInterface_create_message00(lua_State* tolua_S) 01928 { 01929 #ifndef TOLUA_RELEASE 01930 tolua_Error tolua_err; 01931 if ( 01932 !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) || 01933 !tolua_isstring(tolua_S,2,0,&tolua_err) || 01934 !tolua_isnoobj(tolua_S,3,&tolua_err) 01935 ) 01936 goto tolua_lerror; 01937 else 01938 #endif 01939 { 01940 const fawkes::TestInterface* self = (const fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 01941 const char* type = ((const char*) tolua_tostring(tolua_S,2,0)); 01942 #ifndef TOLUA_RELEASE 01943 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'create_message'", NULL); 01944 #endif 01945 { 01946 Message* tolua_ret = (Message*) self->create_message(type); 01947 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Message"); 01948 } 01949 } 01950 return 1; 01951 #ifndef TOLUA_RELEASE 01952 tolua_lerror: 01953 tolua_error(tolua_S,"#ferror in function 'create_message'.",&tolua_err); 01954 return 0; 01955 #endif 01956 } 01957 #endif //#ifndef TOLUA_DISABLE 01958 01959 /* method: read of class fawkes::TestInterface */ 01960 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_read00 01961 static int tolua_interfaces_TestInterface_fawkes_TestInterface_read00(lua_State* tolua_S) 01962 { 01963 #ifndef TOLUA_RELEASE 01964 tolua_Error tolua_err; 01965 if ( 01966 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) || 01967 !tolua_isnoobj(tolua_S,2,&tolua_err) 01968 ) 01969 goto tolua_lerror; 01970 else 01971 #endif 01972 { 01973 fawkes::TestInterface* self = (fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 01974 #ifndef TOLUA_RELEASE 01975 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'read'", NULL); 01976 #endif 01977 { 01978 self->read(); 01979 } 01980 } 01981 return 0; 01982 #ifndef TOLUA_RELEASE 01983 tolua_lerror: 01984 tolua_error(tolua_S,"#ferror in function 'read'.",&tolua_err); 01985 return 0; 01986 #endif 01987 } 01988 #endif //#ifndef TOLUA_DISABLE 01989 01990 /* method: write of class fawkes::TestInterface */ 01991 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_write00 01992 static int tolua_interfaces_TestInterface_fawkes_TestInterface_write00(lua_State* tolua_S) 01993 { 01994 #ifndef TOLUA_RELEASE 01995 tolua_Error tolua_err; 01996 if ( 01997 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) || 01998 !tolua_isnoobj(tolua_S,2,&tolua_err) 01999 ) 02000 goto tolua_lerror; 02001 else 02002 #endif 02003 { 02004 fawkes::TestInterface* self = (fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 02005 #ifndef TOLUA_RELEASE 02006 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'write'", NULL); 02007 #endif 02008 { 02009 self->write(); 02010 } 02011 } 02012 return 0; 02013 #ifndef TOLUA_RELEASE 02014 tolua_lerror: 02015 tolua_error(tolua_S,"#ferror in function 'write'.",&tolua_err); 02016 return 0; 02017 #endif 02018 } 02019 #endif //#ifndef TOLUA_DISABLE 02020 02021 /* method: has_writer of class fawkes::TestInterface */ 02022 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_has_writer00 02023 static int tolua_interfaces_TestInterface_fawkes_TestInterface_has_writer00(lua_State* tolua_S) 02024 { 02025 #ifndef TOLUA_RELEASE 02026 tolua_Error tolua_err; 02027 if ( 02028 !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) || 02029 !tolua_isnoobj(tolua_S,2,&tolua_err) 02030 ) 02031 goto tolua_lerror; 02032 else 02033 #endif 02034 { 02035 const fawkes::TestInterface* self = (const fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 02036 #ifndef TOLUA_RELEASE 02037 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'has_writer'", NULL); 02038 #endif 02039 { 02040 bool tolua_ret = (bool) self->has_writer(); 02041 tolua_pushboolean(tolua_S,(bool)tolua_ret); 02042 } 02043 } 02044 return 1; 02045 #ifndef TOLUA_RELEASE 02046 tolua_lerror: 02047 tolua_error(tolua_S,"#ferror in function 'has_writer'.",&tolua_err); 02048 return 0; 02049 #endif 02050 } 02051 #endif //#ifndef TOLUA_DISABLE 02052 02053 /* method: num_readers of class fawkes::TestInterface */ 02054 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_num_readers00 02055 static int tolua_interfaces_TestInterface_fawkes_TestInterface_num_readers00(lua_State* tolua_S) 02056 { 02057 #ifndef TOLUA_RELEASE 02058 tolua_Error tolua_err; 02059 if ( 02060 !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) || 02061 !tolua_isnoobj(tolua_S,2,&tolua_err) 02062 ) 02063 goto tolua_lerror; 02064 else 02065 #endif 02066 { 02067 const fawkes::TestInterface* self = (const fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 02068 #ifndef TOLUA_RELEASE 02069 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'num_readers'", NULL); 02070 #endif 02071 { 02072 unsigned int tolua_ret = (unsigned int) self->num_readers(); 02073 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 02074 } 02075 } 02076 return 1; 02077 #ifndef TOLUA_RELEASE 02078 tolua_lerror: 02079 tolua_error(tolua_S,"#ferror in function 'num_readers'.",&tolua_err); 02080 return 0; 02081 #endif 02082 } 02083 #endif //#ifndef TOLUA_DISABLE 02084 02085 /* method: msgq_enqueue_copy of class fawkes::TestInterface */ 02086 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_enqueue_copy00 02087 static int tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_enqueue_copy00(lua_State* tolua_S) 02088 { 02089 #ifndef TOLUA_RELEASE 02090 tolua_Error tolua_err; 02091 if ( 02092 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) || 02093 !tolua_isusertype(tolua_S,2,"Message",0,&tolua_err) || 02094 !tolua_isnoobj(tolua_S,3,&tolua_err) 02095 ) 02096 goto tolua_lerror; 02097 else 02098 #endif 02099 { 02100 fawkes::TestInterface* self = (fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 02101 Message* message = ((Message*) tolua_tousertype(tolua_S,2,0)); 02102 #ifndef TOLUA_RELEASE 02103 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_enqueue_copy'", NULL); 02104 #endif 02105 { 02106 unsigned int tolua_ret = (unsigned int) self->msgq_enqueue_copy(message); 02107 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 02108 } 02109 } 02110 return 1; 02111 #ifndef TOLUA_RELEASE 02112 tolua_lerror: 02113 tolua_error(tolua_S,"#ferror in function 'msgq_enqueue_copy'.",&tolua_err); 02114 return 0; 02115 #endif 02116 } 02117 #endif //#ifndef TOLUA_DISABLE 02118 02119 /* method: msgq_remove of class fawkes::TestInterface */ 02120 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_remove00 02121 static int tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_remove00(lua_State* tolua_S) 02122 { 02123 #ifndef TOLUA_RELEASE 02124 tolua_Error tolua_err; 02125 if ( 02126 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) || 02127 !tolua_isusertype(tolua_S,2,"Message",0,&tolua_err) || 02128 !tolua_isnoobj(tolua_S,3,&tolua_err) 02129 ) 02130 goto tolua_lerror; 02131 else 02132 #endif 02133 { 02134 fawkes::TestInterface* self = (fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 02135 Message* message = ((Message*) tolua_tousertype(tolua_S,2,0)); 02136 #ifndef TOLUA_RELEASE 02137 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_remove'", NULL); 02138 #endif 02139 { 02140 self->msgq_remove(message); 02141 } 02142 } 02143 return 0; 02144 #ifndef TOLUA_RELEASE 02145 tolua_lerror: 02146 tolua_error(tolua_S,"#ferror in function 'msgq_remove'.",&tolua_err); 02147 return 0; 02148 #endif 02149 } 02150 #endif //#ifndef TOLUA_DISABLE 02151 02152 /* method: msgq_remove of class fawkes::TestInterface */ 02153 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_remove01 02154 static int tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_remove01(lua_State* tolua_S) 02155 { 02156 tolua_Error tolua_err; 02157 if ( 02158 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) || 02159 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 02160 !tolua_isnoobj(tolua_S,3,&tolua_err) 02161 ) 02162 goto tolua_lerror; 02163 else 02164 { 02165 fawkes::TestInterface* self = (fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 02166 unsigned int message_id = ((unsigned int) tolua_tonumber(tolua_S,2,0)); 02167 #ifndef TOLUA_RELEASE 02168 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_remove'", NULL); 02169 #endif 02170 { 02171 self->msgq_remove(message_id); 02172 } 02173 } 02174 return 0; 02175 tolua_lerror: 02176 return tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_remove00(tolua_S); 02177 } 02178 #endif //#ifndef TOLUA_DISABLE 02179 02180 /* method: msgq_size of class fawkes::TestInterface */ 02181 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_size00 02182 static int tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_size00(lua_State* tolua_S) 02183 { 02184 #ifndef TOLUA_RELEASE 02185 tolua_Error tolua_err; 02186 if ( 02187 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) || 02188 !tolua_isnoobj(tolua_S,2,&tolua_err) 02189 ) 02190 goto tolua_lerror; 02191 else 02192 #endif 02193 { 02194 fawkes::TestInterface* self = (fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 02195 #ifndef TOLUA_RELEASE 02196 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_size'", NULL); 02197 #endif 02198 { 02199 unsigned int tolua_ret = (unsigned int) self->msgq_size(); 02200 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 02201 } 02202 } 02203 return 1; 02204 #ifndef TOLUA_RELEASE 02205 tolua_lerror: 02206 tolua_error(tolua_S,"#ferror in function 'msgq_size'.",&tolua_err); 02207 return 0; 02208 #endif 02209 } 02210 #endif //#ifndef TOLUA_DISABLE 02211 02212 /* method: msgq_flush of class fawkes::TestInterface */ 02213 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_flush00 02214 static int tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_flush00(lua_State* tolua_S) 02215 { 02216 #ifndef TOLUA_RELEASE 02217 tolua_Error tolua_err; 02218 if ( 02219 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) || 02220 !tolua_isnoobj(tolua_S,2,&tolua_err) 02221 ) 02222 goto tolua_lerror; 02223 else 02224 #endif 02225 { 02226 fawkes::TestInterface* self = (fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 02227 #ifndef TOLUA_RELEASE 02228 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_flush'", NULL); 02229 #endif 02230 { 02231 self->msgq_flush(); 02232 } 02233 } 02234 return 0; 02235 #ifndef TOLUA_RELEASE 02236 tolua_lerror: 02237 tolua_error(tolua_S,"#ferror in function 'msgq_flush'.",&tolua_err); 02238 return 0; 02239 #endif 02240 } 02241 #endif //#ifndef TOLUA_DISABLE 02242 02243 /* method: msgq_lock of class fawkes::TestInterface */ 02244 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_lock00 02245 static int tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_lock00(lua_State* tolua_S) 02246 { 02247 #ifndef TOLUA_RELEASE 02248 tolua_Error tolua_err; 02249 if ( 02250 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) || 02251 !tolua_isnoobj(tolua_S,2,&tolua_err) 02252 ) 02253 goto tolua_lerror; 02254 else 02255 #endif 02256 { 02257 fawkes::TestInterface* self = (fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 02258 #ifndef TOLUA_RELEASE 02259 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_lock'", NULL); 02260 #endif 02261 { 02262 self->msgq_lock(); 02263 } 02264 } 02265 return 0; 02266 #ifndef TOLUA_RELEASE 02267 tolua_lerror: 02268 tolua_error(tolua_S,"#ferror in function 'msgq_lock'.",&tolua_err); 02269 return 0; 02270 #endif 02271 } 02272 #endif //#ifndef TOLUA_DISABLE 02273 02274 /* method: msgq_try_lock of class fawkes::TestInterface */ 02275 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_try_lock00 02276 static int tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_try_lock00(lua_State* tolua_S) 02277 { 02278 #ifndef TOLUA_RELEASE 02279 tolua_Error tolua_err; 02280 if ( 02281 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) || 02282 !tolua_isnoobj(tolua_S,2,&tolua_err) 02283 ) 02284 goto tolua_lerror; 02285 else 02286 #endif 02287 { 02288 fawkes::TestInterface* self = (fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 02289 #ifndef TOLUA_RELEASE 02290 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_try_lock'", NULL); 02291 #endif 02292 { 02293 bool tolua_ret = (bool) self->msgq_try_lock(); 02294 tolua_pushboolean(tolua_S,(bool)tolua_ret); 02295 } 02296 } 02297 return 1; 02298 #ifndef TOLUA_RELEASE 02299 tolua_lerror: 02300 tolua_error(tolua_S,"#ferror in function 'msgq_try_lock'.",&tolua_err); 02301 return 0; 02302 #endif 02303 } 02304 #endif //#ifndef TOLUA_DISABLE 02305 02306 /* method: msgq_unlock of class fawkes::TestInterface */ 02307 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_unlock00 02308 static int tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_unlock00(lua_State* tolua_S) 02309 { 02310 #ifndef TOLUA_RELEASE 02311 tolua_Error tolua_err; 02312 if ( 02313 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) || 02314 !tolua_isnoobj(tolua_S,2,&tolua_err) 02315 ) 02316 goto tolua_lerror; 02317 else 02318 #endif 02319 { 02320 fawkes::TestInterface* self = (fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 02321 #ifndef TOLUA_RELEASE 02322 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_unlock'", NULL); 02323 #endif 02324 { 02325 self->msgq_unlock(); 02326 } 02327 } 02328 return 0; 02329 #ifndef TOLUA_RELEASE 02330 tolua_lerror: 02331 tolua_error(tolua_S,"#ferror in function 'msgq_unlock'.",&tolua_err); 02332 return 0; 02333 #endif 02334 } 02335 #endif //#ifndef TOLUA_DISABLE 02336 02337 /* method: msgq_pop of class fawkes::TestInterface */ 02338 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_pop00 02339 static int tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_pop00(lua_State* tolua_S) 02340 { 02341 #ifndef TOLUA_RELEASE 02342 tolua_Error tolua_err; 02343 if ( 02344 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) || 02345 !tolua_isnoobj(tolua_S,2,&tolua_err) 02346 ) 02347 goto tolua_lerror; 02348 else 02349 #endif 02350 { 02351 fawkes::TestInterface* self = (fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 02352 #ifndef TOLUA_RELEASE 02353 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_pop'", NULL); 02354 #endif 02355 { 02356 self->msgq_pop(); 02357 } 02358 } 02359 return 0; 02360 #ifndef TOLUA_RELEASE 02361 tolua_lerror: 02362 tolua_error(tolua_S,"#ferror in function 'msgq_pop'.",&tolua_err); 02363 return 0; 02364 #endif 02365 } 02366 #endif //#ifndef TOLUA_DISABLE 02367 02368 /* method: msgq_first of class fawkes::TestInterface */ 02369 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_first00 02370 static int tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_first00(lua_State* tolua_S) 02371 { 02372 #ifndef TOLUA_RELEASE 02373 tolua_Error tolua_err; 02374 if ( 02375 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) || 02376 !tolua_isnoobj(tolua_S,2,&tolua_err) 02377 ) 02378 goto tolua_lerror; 02379 else 02380 #endif 02381 { 02382 fawkes::TestInterface* self = (fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 02383 #ifndef TOLUA_RELEASE 02384 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_first'", NULL); 02385 #endif 02386 { 02387 Message* tolua_ret = (Message*) self->msgq_first(); 02388 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Message"); 02389 } 02390 } 02391 return 1; 02392 #ifndef TOLUA_RELEASE 02393 tolua_lerror: 02394 tolua_error(tolua_S,"#ferror in function 'msgq_first'.",&tolua_err); 02395 return 0; 02396 #endif 02397 } 02398 #endif //#ifndef TOLUA_DISABLE 02399 02400 /* method: msgq_empty of class fawkes::TestInterface */ 02401 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_empty00 02402 static int tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_empty00(lua_State* tolua_S) 02403 { 02404 #ifndef TOLUA_RELEASE 02405 tolua_Error tolua_err; 02406 if ( 02407 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) || 02408 !tolua_isnoobj(tolua_S,2,&tolua_err) 02409 ) 02410 goto tolua_lerror; 02411 else 02412 #endif 02413 { 02414 fawkes::TestInterface* self = (fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0); 02415 #ifndef TOLUA_RELEASE 02416 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_empty'", NULL); 02417 #endif 02418 { 02419 bool tolua_ret = (bool) self->msgq_empty(); 02420 tolua_pushboolean(tolua_S,(bool)tolua_ret); 02421 } 02422 } 02423 return 1; 02424 #ifndef TOLUA_RELEASE 02425 tolua_lerror: 02426 tolua_error(tolua_S,"#ferror in function 'msgq_empty'.",&tolua_err); 02427 return 0; 02428 #endif 02429 } 02430 #endif //#ifndef TOLUA_DISABLE 02431 02432 /* Open function */ 02433 TOLUA_API int tolua_interfaces_TestInterface_open (lua_State* tolua_S) 02434 { 02435 tolua_open(tolua_S); 02436 tolua_reg_types(tolua_S); 02437 tolua_module(tolua_S,NULL,0); 02438 tolua_beginmodule(tolua_S,NULL); 02439 tolua_module(tolua_S,"fawkes",0); 02440 tolua_beginmodule(tolua_S,"fawkes"); 02441 tolua_cclass(tolua_S,"TestInterface","fawkes::TestInterface","Interface",NULL); 02442 tolua_beginmodule(tolua_S,"TestInterface"); 02443 tolua_variable(tolua_S,"TEST_CONSTANT",tolua_get_fawkes__TestInterface_TEST_CONSTANT,NULL); 02444 tolua_variable(tolua_S,"TEST_FLOAT_CONSTANT",tolua_get_fawkes__TestInterface_TEST_FLOAT_CONSTANT,NULL); 02445 tolua_constant(tolua_S,"TEST_ENUM_1",fawkes::TestInterface::TEST_ENUM_1); 02446 tolua_constant(tolua_S,"TEST_ENUM_2",fawkes::TestInterface::TEST_ENUM_2); 02447 #ifdef __cplusplus 02448 tolua_cclass(tolua_S,"SetTestIntMessage","fawkes::TestInterface::SetTestIntMessage","Message",tolua_collect_fawkes__TestInterface__SetTestIntMessage); 02449 #else 02450 tolua_cclass(tolua_S,"SetTestIntMessage","fawkes::TestInterface::SetTestIntMessage","Message",NULL); 02451 #endif 02452 tolua_beginmodule(tolua_S,"SetTestIntMessage"); 02453 tolua_function(tolua_S,"new",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_new00); 02454 tolua_function(tolua_S,"new_local",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_new00_local); 02455 tolua_function(tolua_S,".call",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_new00_local); 02456 tolua_function(tolua_S,"new",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_new01); 02457 tolua_function(tolua_S,"new_local",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_new01_local); 02458 tolua_function(tolua_S,".call",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_new01_local); 02459 tolua_function(tolua_S,"delete",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_delete00); 02460 tolua_function(tolua_S,"test_int",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_test_int00); 02461 tolua_function(tolua_S,"set_test_int",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_set_test_int00); 02462 tolua_function(tolua_S,"maxlenof_test_int",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_maxlenof_test_int00); 02463 tolua_endmodule(tolua_S); 02464 #ifdef __cplusplus 02465 tolua_cclass(tolua_S,"SetTestStringMessage","fawkes::TestInterface::SetTestStringMessage","Message",tolua_collect_fawkes__TestInterface__SetTestStringMessage); 02466 #else 02467 tolua_cclass(tolua_S,"SetTestStringMessage","fawkes::TestInterface::SetTestStringMessage","Message",NULL); 02468 #endif 02469 tolua_beginmodule(tolua_S,"SetTestStringMessage"); 02470 tolua_function(tolua_S,"new",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_new00); 02471 tolua_function(tolua_S,"new_local",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_new00_local); 02472 tolua_function(tolua_S,".call",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_new00_local); 02473 tolua_function(tolua_S,"new",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_new01); 02474 tolua_function(tolua_S,"new_local",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_new01_local); 02475 tolua_function(tolua_S,".call",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_new01_local); 02476 tolua_function(tolua_S,"delete",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_delete00); 02477 tolua_function(tolua_S,"test_string",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_test_string00); 02478 tolua_function(tolua_S,"set_test_string",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_set_test_string00); 02479 tolua_function(tolua_S,"maxlenof_test_string",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_maxlenof_test_string00); 02480 tolua_endmodule(tolua_S); 02481 #ifdef __cplusplus 02482 tolua_cclass(tolua_S,"CalculateMessage","fawkes::TestInterface::CalculateMessage","Message",tolua_collect_fawkes__TestInterface__CalculateMessage); 02483 #else 02484 tolua_cclass(tolua_S,"CalculateMessage","fawkes::TestInterface::CalculateMessage","Message",NULL); 02485 #endif 02486 tolua_beginmodule(tolua_S,"CalculateMessage"); 02487 tolua_function(tolua_S,"new",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_new00); 02488 tolua_function(tolua_S,"new_local",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_new00_local); 02489 tolua_function(tolua_S,".call",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_new00_local); 02490 tolua_function(tolua_S,"new",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_new01); 02491 tolua_function(tolua_S,"new_local",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_new01_local); 02492 tolua_function(tolua_S,".call",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_new01_local); 02493 tolua_function(tolua_S,"delete",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_delete00); 02494 tolua_function(tolua_S,"summand",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_summand00); 02495 tolua_function(tolua_S,"set_summand",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_set_summand00); 02496 tolua_function(tolua_S,"maxlenof_summand",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_maxlenof_summand00); 02497 tolua_function(tolua_S,"addend",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_addend00); 02498 tolua_function(tolua_S,"set_addend",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_set_addend00); 02499 tolua_function(tolua_S,"maxlenof_addend",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_maxlenof_addend00); 02500 tolua_endmodule(tolua_S); 02501 tolua_function(tolua_S,"is_test_bool",tolua_interfaces_TestInterface_fawkes_TestInterface_is_test_bool00); 02502 tolua_function(tolua_S,"set_test_bool",tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_bool00); 02503 tolua_function(tolua_S,"maxlenof_test_bool",tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_bool00); 02504 tolua_function(tolua_S,"test_int",tolua_interfaces_TestInterface_fawkes_TestInterface_test_int00); 02505 tolua_function(tolua_S,"set_test_int",tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_int00); 02506 tolua_function(tolua_S,"maxlenof_test_int",tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_int00); 02507 tolua_function(tolua_S,"flags",tolua_interfaces_TestInterface_fawkes_TestInterface_flags00); 02508 tolua_function(tolua_S,"set_flags",tolua_interfaces_TestInterface_fawkes_TestInterface_set_flags00); 02509 tolua_function(tolua_S,"maxlenof_flags",tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_flags00); 02510 tolua_function(tolua_S,"test_string",tolua_interfaces_TestInterface_fawkes_TestInterface_test_string00); 02511 tolua_function(tolua_S,"set_test_string",tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_string00); 02512 tolua_function(tolua_S,"maxlenof_test_string",tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_string00); 02513 tolua_function(tolua_S,"result",tolua_interfaces_TestInterface_fawkes_TestInterface_result00); 02514 tolua_function(tolua_S,"set_result",tolua_interfaces_TestInterface_fawkes_TestInterface_set_result00); 02515 tolua_function(tolua_S,"maxlenof_result",tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_result00); 02516 tolua_function(tolua_S,"test_uint",tolua_interfaces_TestInterface_fawkes_TestInterface_test_uint00); 02517 tolua_function(tolua_S,"set_test_uint",tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_uint00); 02518 tolua_function(tolua_S,"maxlenof_test_uint",tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_uint00); 02519 tolua_function(tolua_S,"oftype",tolua_interfaces_TestInterface_fawkes_TestInterface_oftype00); 02520 tolua_function(tolua_S,"datachunk",tolua_interfaces_TestInterface_fawkes_TestInterface_datachunk00); 02521 tolua_function(tolua_S,"datasize",tolua_interfaces_TestInterface_fawkes_TestInterface_datasize00); 02522 tolua_function(tolua_S,"type",tolua_interfaces_TestInterface_fawkes_TestInterface_type00); 02523 tolua_function(tolua_S,"id",tolua_interfaces_TestInterface_fawkes_TestInterface_id00); 02524 tolua_function(tolua_S,"uid",tolua_interfaces_TestInterface_fawkes_TestInterface_uid00); 02525 tolua_function(tolua_S,"serial",tolua_interfaces_TestInterface_fawkes_TestInterface_serial00); 02526 tolua_function(tolua_S,"mem_serial",tolua_interfaces_TestInterface_fawkes_TestInterface_mem_serial00); 02527 tolua_function(tolua_S,".eq",tolua_interfaces_TestInterface_fawkes_TestInterface__eq00); 02528 tolua_function(tolua_S,"hash",tolua_interfaces_TestInterface_fawkes_TestInterface_hash00); 02529 tolua_function(tolua_S,"hash_size",tolua_interfaces_TestInterface_fawkes_TestInterface_hash_size00); 02530 tolua_function(tolua_S,"hash_printable",tolua_interfaces_TestInterface_fawkes_TestInterface_hash_printable00); 02531 tolua_function(tolua_S,"is_writer",tolua_interfaces_TestInterface_fawkes_TestInterface_is_writer00); 02532 tolua_function(tolua_S,"set_from_chunk",tolua_interfaces_TestInterface_fawkes_TestInterface_set_from_chunk00); 02533 tolua_function(tolua_S,"create_message",tolua_interfaces_TestInterface_fawkes_TestInterface_create_message00); 02534 tolua_function(tolua_S,"read",tolua_interfaces_TestInterface_fawkes_TestInterface_read00); 02535 tolua_function(tolua_S,"write",tolua_interfaces_TestInterface_fawkes_TestInterface_write00); 02536 tolua_function(tolua_S,"has_writer",tolua_interfaces_TestInterface_fawkes_TestInterface_has_writer00); 02537 tolua_function(tolua_S,"num_readers",tolua_interfaces_TestInterface_fawkes_TestInterface_num_readers00); 02538 tolua_function(tolua_S,"msgq_enqueue_copy",tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_enqueue_copy00); 02539 tolua_function(tolua_S,"msgq_remove",tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_remove00); 02540 tolua_function(tolua_S,"msgq_remove",tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_remove01); 02541 tolua_function(tolua_S,"msgq_size",tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_size00); 02542 tolua_function(tolua_S,"msgq_flush",tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_flush00); 02543 tolua_function(tolua_S,"msgq_lock",tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_lock00); 02544 tolua_function(tolua_S,"msgq_try_lock",tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_try_lock00); 02545 tolua_function(tolua_S,"msgq_unlock",tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_unlock00); 02546 tolua_function(tolua_S,"msgq_pop",tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_pop00); 02547 tolua_function(tolua_S,"msgq_first",tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_first00); 02548 tolua_function(tolua_S,"msgq_empty",tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_empty00); 02549 tolua_endmodule(tolua_S); 02550 tolua_endmodule(tolua_S); 02551 tolua_endmodule(tolua_S); 02552 return 1; 02553 } 02554 02555 02556 extern "C" { 02557 #if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501 02558 TOLUA_API int luaopen_interfaces_TestInterface (lua_State* tolua_S) { 02559 return tolua_interfaces_TestInterface_open(tolua_S); 02560 }; 02561 #endif 02562 } 02563 02564