00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019 #ifndef __cplusplus
00020 #include "stdlib.h"
00021 #endif
00022 #include "string.h"
00023
00024 #include "tolua++.h"
00025
00026
00027 TOLUA_API int tolua_interfaces_TestInterface_open (lua_State* tolua_S);
00028
00029 #include <interfaces/TestInterface.h>
00030 using namespace fawkes;
00031
00032
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
01473 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_test_ulint00
01474 static int tolua_interfaces_TestInterface_fawkes_TestInterface_test_ulint00(lua_State* tolua_S)
01475 {
01476 #ifndef TOLUA_RELEASE
01477 tolua_Error tolua_err;
01478 if (
01479 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
01480 !tolua_isnoobj(tolua_S,2,&tolua_err)
01481 )
01482 goto tolua_lerror;
01483 else
01484 #endif
01485 {
01486 fawkes::TestInterface* self = (fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0);
01487 #ifndef TOLUA_RELEASE
01488 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'test_ulint'", NULL);
01489 #endif
01490 {
01491 unsigned long long tolua_ret = (unsigned long long) self->test_ulint();
01492 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01493 }
01494 }
01495 return 1;
01496 #ifndef TOLUA_RELEASE
01497 tolua_lerror:
01498 tolua_error(tolua_S,"#ferror in function 'test_ulint'.",&tolua_err);
01499 return 0;
01500 #endif
01501 }
01502 #endif //#ifndef TOLUA_DISABLE
01503
01504
01505 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_ulint00
01506 static int tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_ulint00(lua_State* tolua_S)
01507 {
01508 #ifndef TOLUA_RELEASE
01509 tolua_Error tolua_err;
01510 if (
01511 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
01512 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01513 !tolua_isnoobj(tolua_S,3,&tolua_err)
01514 )
01515 goto tolua_lerror;
01516 else
01517 #endif
01518 {
01519 fawkes::TestInterface* self = (fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0);
01520 unsigned long const long new_test_ulint = ((unsigned long const long) tolua_tonumber(tolua_S,2,0));
01521 #ifndef TOLUA_RELEASE
01522 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_test_ulint'", NULL);
01523 #endif
01524 {
01525 self->set_test_ulint(new_test_ulint);
01526 }
01527 }
01528 return 0;
01529 #ifndef TOLUA_RELEASE
01530 tolua_lerror:
01531 tolua_error(tolua_S,"#ferror in function 'set_test_ulint'.",&tolua_err);
01532 return 0;
01533 #endif
01534 }
01535 #endif //#ifndef TOLUA_DISABLE
01536
01537
01538 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_ulint00
01539 static int tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_ulint00(lua_State* tolua_S)
01540 {
01541 #ifndef TOLUA_RELEASE
01542 tolua_Error tolua_err;
01543 if (
01544 !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
01545 !tolua_isnoobj(tolua_S,2,&tolua_err)
01546 )
01547 goto tolua_lerror;
01548 else
01549 #endif
01550 {
01551 const fawkes::TestInterface* self = (const fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0);
01552 #ifndef TOLUA_RELEASE
01553 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_test_ulint'", NULL);
01554 #endif
01555 {
01556 int tolua_ret = (int) self->maxlenof_test_ulint();
01557 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01558 }
01559 }
01560 return 1;
01561 #ifndef TOLUA_RELEASE
01562 tolua_lerror:
01563 tolua_error(tolua_S,"#ferror in function 'maxlenof_test_ulint'.",&tolua_err);
01564 return 0;
01565 #endif
01566 }
01567 #endif //#ifndef TOLUA_DISABLE
01568
01569
01570 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_test_lint00
01571 static int tolua_interfaces_TestInterface_fawkes_TestInterface_test_lint00(lua_State* tolua_S)
01572 {
01573 #ifndef TOLUA_RELEASE
01574 tolua_Error tolua_err;
01575 if (
01576 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
01577 !tolua_isnoobj(tolua_S,2,&tolua_err)
01578 )
01579 goto tolua_lerror;
01580 else
01581 #endif
01582 {
01583 fawkes::TestInterface* self = (fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0);
01584 #ifndef TOLUA_RELEASE
01585 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'test_lint'", NULL);
01586 #endif
01587 {
01588 long long tolua_ret = (long long) self->test_lint();
01589 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01590 }
01591 }
01592 return 1;
01593 #ifndef TOLUA_RELEASE
01594 tolua_lerror:
01595 tolua_error(tolua_S,"#ferror in function 'test_lint'.",&tolua_err);
01596 return 0;
01597 #endif
01598 }
01599 #endif //#ifndef TOLUA_DISABLE
01600
01601
01602 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_lint00
01603 static int tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_lint00(lua_State* tolua_S)
01604 {
01605 #ifndef TOLUA_RELEASE
01606 tolua_Error tolua_err;
01607 if (
01608 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
01609 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01610 !tolua_isnoobj(tolua_S,3,&tolua_err)
01611 )
01612 goto tolua_lerror;
01613 else
01614 #endif
01615 {
01616 fawkes::TestInterface* self = (fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0);
01617 long const long new_test_lint = ((long const long) tolua_tonumber(tolua_S,2,0));
01618 #ifndef TOLUA_RELEASE
01619 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_test_lint'", NULL);
01620 #endif
01621 {
01622 self->set_test_lint(new_test_lint);
01623 }
01624 }
01625 return 0;
01626 #ifndef TOLUA_RELEASE
01627 tolua_lerror:
01628 tolua_error(tolua_S,"#ferror in function 'set_test_lint'.",&tolua_err);
01629 return 0;
01630 #endif
01631 }
01632 #endif //#ifndef TOLUA_DISABLE
01633
01634
01635 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_lint00
01636 static int tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_lint00(lua_State* tolua_S)
01637 {
01638 #ifndef TOLUA_RELEASE
01639 tolua_Error tolua_err;
01640 if (
01641 !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
01642 !tolua_isnoobj(tolua_S,2,&tolua_err)
01643 )
01644 goto tolua_lerror;
01645 else
01646 #endif
01647 {
01648 const fawkes::TestInterface* self = (const fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0);
01649 #ifndef TOLUA_RELEASE
01650 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_test_lint'", NULL);
01651 #endif
01652 {
01653 int tolua_ret = (int) self->maxlenof_test_lint();
01654 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01655 }
01656 }
01657 return 1;
01658 #ifndef TOLUA_RELEASE
01659 tolua_lerror:
01660 tolua_error(tolua_S,"#ferror in function 'maxlenof_test_lint'.",&tolua_err);
01661 return 0;
01662 #endif
01663 }
01664 #endif //#ifndef TOLUA_DISABLE
01665
01666
01667 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_oftype00
01668 static int tolua_interfaces_TestInterface_fawkes_TestInterface_oftype00(lua_State* tolua_S)
01669 {
01670 #ifndef TOLUA_RELEASE
01671 tolua_Error tolua_err;
01672 if (
01673 !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
01674 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
01675 !tolua_isnoobj(tolua_S,3,&tolua_err)
01676 )
01677 goto tolua_lerror;
01678 else
01679 #endif
01680 {
01681 const fawkes::TestInterface* self = (const fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0);
01682 const char* interface_type = ((const char*) tolua_tostring(tolua_S,2,0));
01683 #ifndef TOLUA_RELEASE
01684 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'oftype'", NULL);
01685 #endif
01686 {
01687 bool tolua_ret = (bool) self->oftype(interface_type);
01688 tolua_pushboolean(tolua_S,(bool)tolua_ret);
01689 }
01690 }
01691 return 1;
01692 #ifndef TOLUA_RELEASE
01693 tolua_lerror:
01694 tolua_error(tolua_S,"#ferror in function 'oftype'.",&tolua_err);
01695 return 0;
01696 #endif
01697 }
01698 #endif //#ifndef TOLUA_DISABLE
01699
01700
01701 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_datachunk00
01702 static int tolua_interfaces_TestInterface_fawkes_TestInterface_datachunk00(lua_State* tolua_S)
01703 {
01704 #ifndef TOLUA_RELEASE
01705 tolua_Error tolua_err;
01706 if (
01707 !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
01708 !tolua_isnoobj(tolua_S,2,&tolua_err)
01709 )
01710 goto tolua_lerror;
01711 else
01712 #endif
01713 {
01714 const fawkes::TestInterface* self = (const fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0);
01715 #ifndef TOLUA_RELEASE
01716 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datachunk'", NULL);
01717 #endif
01718 {
01719 const void* tolua_ret = (const void*) self->datachunk();
01720 tolua_pushuserdata(tolua_S,(void*)tolua_ret);
01721 }
01722 }
01723 return 1;
01724 #ifndef TOLUA_RELEASE
01725 tolua_lerror:
01726 tolua_error(tolua_S,"#ferror in function 'datachunk'.",&tolua_err);
01727 return 0;
01728 #endif
01729 }
01730 #endif //#ifndef TOLUA_DISABLE
01731
01732
01733 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_datasize00
01734 static int tolua_interfaces_TestInterface_fawkes_TestInterface_datasize00(lua_State* tolua_S)
01735 {
01736 #ifndef TOLUA_RELEASE
01737 tolua_Error tolua_err;
01738 if (
01739 !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
01740 !tolua_isnoobj(tolua_S,2,&tolua_err)
01741 )
01742 goto tolua_lerror;
01743 else
01744 #endif
01745 {
01746 const fawkes::TestInterface* self = (const fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0);
01747 #ifndef TOLUA_RELEASE
01748 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datasize'", NULL);
01749 #endif
01750 {
01751 unsigned int tolua_ret = (unsigned int) self->datasize();
01752 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01753 }
01754 }
01755 return 1;
01756 #ifndef TOLUA_RELEASE
01757 tolua_lerror:
01758 tolua_error(tolua_S,"#ferror in function 'datasize'.",&tolua_err);
01759 return 0;
01760 #endif
01761 }
01762 #endif //#ifndef TOLUA_DISABLE
01763
01764
01765 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_type00
01766 static int tolua_interfaces_TestInterface_fawkes_TestInterface_type00(lua_State* tolua_S)
01767 {
01768 #ifndef TOLUA_RELEASE
01769 tolua_Error tolua_err;
01770 if (
01771 !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
01772 !tolua_isnoobj(tolua_S,2,&tolua_err)
01773 )
01774 goto tolua_lerror;
01775 else
01776 #endif
01777 {
01778 const fawkes::TestInterface* self = (const fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0);
01779 #ifndef TOLUA_RELEASE
01780 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'type'", NULL);
01781 #endif
01782 {
01783 const char* tolua_ret = (const char*) self->type();
01784 tolua_pushstring(tolua_S,(const char*)tolua_ret);
01785 }
01786 }
01787 return 1;
01788 #ifndef TOLUA_RELEASE
01789 tolua_lerror:
01790 tolua_error(tolua_S,"#ferror in function 'type'.",&tolua_err);
01791 return 0;
01792 #endif
01793 }
01794 #endif //#ifndef TOLUA_DISABLE
01795
01796
01797 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_id00
01798 static int tolua_interfaces_TestInterface_fawkes_TestInterface_id00(lua_State* tolua_S)
01799 {
01800 #ifndef TOLUA_RELEASE
01801 tolua_Error tolua_err;
01802 if (
01803 !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
01804 !tolua_isnoobj(tolua_S,2,&tolua_err)
01805 )
01806 goto tolua_lerror;
01807 else
01808 #endif
01809 {
01810 const fawkes::TestInterface* self = (const fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0);
01811 #ifndef TOLUA_RELEASE
01812 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'id'", NULL);
01813 #endif
01814 {
01815 const char* tolua_ret = (const char*) self->id();
01816 tolua_pushstring(tolua_S,(const char*)tolua_ret);
01817 }
01818 }
01819 return 1;
01820 #ifndef TOLUA_RELEASE
01821 tolua_lerror:
01822 tolua_error(tolua_S,"#ferror in function 'id'.",&tolua_err);
01823 return 0;
01824 #endif
01825 }
01826 #endif //#ifndef TOLUA_DISABLE
01827
01828
01829 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_uid00
01830 static int tolua_interfaces_TestInterface_fawkes_TestInterface_uid00(lua_State* tolua_S)
01831 {
01832 #ifndef TOLUA_RELEASE
01833 tolua_Error tolua_err;
01834 if (
01835 !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
01836 !tolua_isnoobj(tolua_S,2,&tolua_err)
01837 )
01838 goto tolua_lerror;
01839 else
01840 #endif
01841 {
01842 const fawkes::TestInterface* self = (const fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0);
01843 #ifndef TOLUA_RELEASE
01844 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'uid'", NULL);
01845 #endif
01846 {
01847 const char* tolua_ret = (const char*) self->uid();
01848 tolua_pushstring(tolua_S,(const char*)tolua_ret);
01849 }
01850 }
01851 return 1;
01852 #ifndef TOLUA_RELEASE
01853 tolua_lerror:
01854 tolua_error(tolua_S,"#ferror in function 'uid'.",&tolua_err);
01855 return 0;
01856 #endif
01857 }
01858 #endif //#ifndef TOLUA_DISABLE
01859
01860
01861 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_serial00
01862 static int tolua_interfaces_TestInterface_fawkes_TestInterface_serial00(lua_State* tolua_S)
01863 {
01864 #ifndef TOLUA_RELEASE
01865 tolua_Error tolua_err;
01866 if (
01867 !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
01868 !tolua_isnoobj(tolua_S,2,&tolua_err)
01869 )
01870 goto tolua_lerror;
01871 else
01872 #endif
01873 {
01874 const fawkes::TestInterface* self = (const fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0);
01875 #ifndef TOLUA_RELEASE
01876 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'serial'", NULL);
01877 #endif
01878 {
01879 unsigned int tolua_ret = (unsigned int) self->serial();
01880 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01881 }
01882 }
01883 return 1;
01884 #ifndef TOLUA_RELEASE
01885 tolua_lerror:
01886 tolua_error(tolua_S,"#ferror in function 'serial'.",&tolua_err);
01887 return 0;
01888 #endif
01889 }
01890 #endif //#ifndef TOLUA_DISABLE
01891
01892
01893 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_mem_serial00
01894 static int tolua_interfaces_TestInterface_fawkes_TestInterface_mem_serial00(lua_State* tolua_S)
01895 {
01896 #ifndef TOLUA_RELEASE
01897 tolua_Error tolua_err;
01898 if (
01899 !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
01900 !tolua_isnoobj(tolua_S,2,&tolua_err)
01901 )
01902 goto tolua_lerror;
01903 else
01904 #endif
01905 {
01906 const fawkes::TestInterface* self = (const fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0);
01907 #ifndef TOLUA_RELEASE
01908 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'mem_serial'", NULL);
01909 #endif
01910 {
01911 unsigned int tolua_ret = (unsigned int) self->mem_serial();
01912 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01913 }
01914 }
01915 return 1;
01916 #ifndef TOLUA_RELEASE
01917 tolua_lerror:
01918 tolua_error(tolua_S,"#ferror in function 'mem_serial'.",&tolua_err);
01919 return 0;
01920 #endif
01921 }
01922 #endif //#ifndef TOLUA_DISABLE
01923
01924
01925 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface__eq00
01926 static int tolua_interfaces_TestInterface_fawkes_TestInterface__eq00(lua_State* tolua_S)
01927 {
01928 #ifndef TOLUA_RELEASE
01929 tolua_Error tolua_err;
01930 if (
01931 !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
01932 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Interface",0,&tolua_err)) ||
01933 !tolua_isnoobj(tolua_S,3,&tolua_err)
01934 )
01935 goto tolua_lerror;
01936 else
01937 #endif
01938 {
01939 const fawkes::TestInterface* self = (const fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0);
01940 Interface* comp = ((Interface*) tolua_tousertype(tolua_S,2,0));
01941 #ifndef TOLUA_RELEASE
01942 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='", NULL);
01943 #endif
01944 {
01945 bool tolua_ret = (bool) self->operator==(*comp);
01946 tolua_pushboolean(tolua_S,(bool)tolua_ret);
01947 }
01948 }
01949 return 1;
01950 #ifndef TOLUA_RELEASE
01951 tolua_lerror:
01952 tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err);
01953 return 0;
01954 #endif
01955 }
01956 #endif //#ifndef TOLUA_DISABLE
01957
01958
01959 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_hash00
01960 static int tolua_interfaces_TestInterface_fawkes_TestInterface_hash00(lua_State* tolua_S)
01961 {
01962 #ifndef TOLUA_RELEASE
01963 tolua_Error tolua_err;
01964 if (
01965 !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
01966 !tolua_isnoobj(tolua_S,2,&tolua_err)
01967 )
01968 goto tolua_lerror;
01969 else
01970 #endif
01971 {
01972 const fawkes::TestInterface* self = (const fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0);
01973 #ifndef TOLUA_RELEASE
01974 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash'", NULL);
01975 #endif
01976 {
01977 unsigned const char* tolua_ret = ( unsigned const char*) self->hash();
01978 tolua_pushstring(tolua_S,(const char*)tolua_ret);
01979 }
01980 }
01981 return 1;
01982 #ifndef TOLUA_RELEASE
01983 tolua_lerror:
01984 tolua_error(tolua_S,"#ferror in function 'hash'.",&tolua_err);
01985 return 0;
01986 #endif
01987 }
01988 #endif //#ifndef TOLUA_DISABLE
01989
01990
01991 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_hash_size00
01992 static int tolua_interfaces_TestInterface_fawkes_TestInterface_hash_size00(lua_State* tolua_S)
01993 {
01994 #ifndef TOLUA_RELEASE
01995 tolua_Error tolua_err;
01996 if (
01997 !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
01998 !tolua_isnoobj(tolua_S,2,&tolua_err)
01999 )
02000 goto tolua_lerror;
02001 else
02002 #endif
02003 {
02004 const fawkes::TestInterface* self = (const fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0);
02005 #ifndef TOLUA_RELEASE
02006 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash_size'", NULL);
02007 #endif
02008 {
02009 int tolua_ret = (int) self->hash_size();
02010 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02011 }
02012 }
02013 return 1;
02014 #ifndef TOLUA_RELEASE
02015 tolua_lerror:
02016 tolua_error(tolua_S,"#ferror in function 'hash_size'.",&tolua_err);
02017 return 0;
02018 #endif
02019 }
02020 #endif //#ifndef TOLUA_DISABLE
02021
02022
02023 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_hash_printable00
02024 static int tolua_interfaces_TestInterface_fawkes_TestInterface_hash_printable00(lua_State* tolua_S)
02025 {
02026 #ifndef TOLUA_RELEASE
02027 tolua_Error tolua_err;
02028 if (
02029 !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
02030 !tolua_isnoobj(tolua_S,2,&tolua_err)
02031 )
02032 goto tolua_lerror;
02033 else
02034 #endif
02035 {
02036 const fawkes::TestInterface* self = (const fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0);
02037 #ifndef TOLUA_RELEASE
02038 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash_printable'", NULL);
02039 #endif
02040 {
02041 const char* tolua_ret = (const char*) self->hash_printable();
02042 tolua_pushstring(tolua_S,(const char*)tolua_ret);
02043 }
02044 }
02045 return 1;
02046 #ifndef TOLUA_RELEASE
02047 tolua_lerror:
02048 tolua_error(tolua_S,"#ferror in function 'hash_printable'.",&tolua_err);
02049 return 0;
02050 #endif
02051 }
02052 #endif //#ifndef TOLUA_DISABLE
02053
02054
02055 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_is_writer00
02056 static int tolua_interfaces_TestInterface_fawkes_TestInterface_is_writer00(lua_State* tolua_S)
02057 {
02058 #ifndef TOLUA_RELEASE
02059 tolua_Error tolua_err;
02060 if (
02061 !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
02062 !tolua_isnoobj(tolua_S,2,&tolua_err)
02063 )
02064 goto tolua_lerror;
02065 else
02066 #endif
02067 {
02068 const fawkes::TestInterface* self = (const fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0);
02069 #ifndef TOLUA_RELEASE
02070 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_writer'", NULL);
02071 #endif
02072 {
02073 bool tolua_ret = (bool) self->is_writer();
02074 tolua_pushboolean(tolua_S,(bool)tolua_ret);
02075 }
02076 }
02077 return 1;
02078 #ifndef TOLUA_RELEASE
02079 tolua_lerror:
02080 tolua_error(tolua_S,"#ferror in function 'is_writer'.",&tolua_err);
02081 return 0;
02082 #endif
02083 }
02084 #endif //#ifndef TOLUA_DISABLE
02085
02086
02087 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_set_from_chunk00
02088 static int tolua_interfaces_TestInterface_fawkes_TestInterface_set_from_chunk00(lua_State* tolua_S)
02089 {
02090 #ifndef TOLUA_RELEASE
02091 tolua_Error tolua_err;
02092 if (
02093 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
02094 !tolua_isuserdata(tolua_S,2,0,&tolua_err) ||
02095 !tolua_isnoobj(tolua_S,3,&tolua_err)
02096 )
02097 goto tolua_lerror;
02098 else
02099 #endif
02100 {
02101 fawkes::TestInterface* self = (fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0);
02102 void* chunk = ((void*) tolua_touserdata(tolua_S,2,0));
02103 #ifndef TOLUA_RELEASE
02104 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_from_chunk'", NULL);
02105 #endif
02106 {
02107 self->set_from_chunk(chunk);
02108 }
02109 }
02110 return 0;
02111 #ifndef TOLUA_RELEASE
02112 tolua_lerror:
02113 tolua_error(tolua_S,"#ferror in function 'set_from_chunk'.",&tolua_err);
02114 return 0;
02115 #endif
02116 }
02117 #endif //#ifndef TOLUA_DISABLE
02118
02119
02120 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_create_message00
02121 static int tolua_interfaces_TestInterface_fawkes_TestInterface_create_message00(lua_State* tolua_S)
02122 {
02123 #ifndef TOLUA_RELEASE
02124 tolua_Error tolua_err;
02125 if (
02126 !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
02127 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
02128 !tolua_isnoobj(tolua_S,3,&tolua_err)
02129 )
02130 goto tolua_lerror;
02131 else
02132 #endif
02133 {
02134 const fawkes::TestInterface* self = (const fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0);
02135 const char* type = ((const char*) tolua_tostring(tolua_S,2,0));
02136 #ifndef TOLUA_RELEASE
02137 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'create_message'", NULL);
02138 #endif
02139 {
02140 Message* tolua_ret = (Message*) self->create_message(type);
02141 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Message");
02142 }
02143 }
02144 return 1;
02145 #ifndef TOLUA_RELEASE
02146 tolua_lerror:
02147 tolua_error(tolua_S,"#ferror in function 'create_message'.",&tolua_err);
02148 return 0;
02149 #endif
02150 }
02151 #endif //#ifndef TOLUA_DISABLE
02152
02153
02154 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_read00
02155 static int tolua_interfaces_TestInterface_fawkes_TestInterface_read00(lua_State* tolua_S)
02156 {
02157 #ifndef TOLUA_RELEASE
02158 tolua_Error tolua_err;
02159 if (
02160 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
02161 !tolua_isnoobj(tolua_S,2,&tolua_err)
02162 )
02163 goto tolua_lerror;
02164 else
02165 #endif
02166 {
02167 fawkes::TestInterface* self = (fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0);
02168 #ifndef TOLUA_RELEASE
02169 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'read'", NULL);
02170 #endif
02171 {
02172 self->read();
02173 }
02174 }
02175 return 0;
02176 #ifndef TOLUA_RELEASE
02177 tolua_lerror:
02178 tolua_error(tolua_S,"#ferror in function 'read'.",&tolua_err);
02179 return 0;
02180 #endif
02181 }
02182 #endif //#ifndef TOLUA_DISABLE
02183
02184
02185 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_write00
02186 static int tolua_interfaces_TestInterface_fawkes_TestInterface_write00(lua_State* tolua_S)
02187 {
02188 #ifndef TOLUA_RELEASE
02189 tolua_Error tolua_err;
02190 if (
02191 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
02192 !tolua_isnoobj(tolua_S,2,&tolua_err)
02193 )
02194 goto tolua_lerror;
02195 else
02196 #endif
02197 {
02198 fawkes::TestInterface* self = (fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0);
02199 #ifndef TOLUA_RELEASE
02200 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'write'", NULL);
02201 #endif
02202 {
02203 self->write();
02204 }
02205 }
02206 return 0;
02207 #ifndef TOLUA_RELEASE
02208 tolua_lerror:
02209 tolua_error(tolua_S,"#ferror in function 'write'.",&tolua_err);
02210 return 0;
02211 #endif
02212 }
02213 #endif //#ifndef TOLUA_DISABLE
02214
02215
02216 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_has_writer00
02217 static int tolua_interfaces_TestInterface_fawkes_TestInterface_has_writer00(lua_State* tolua_S)
02218 {
02219 #ifndef TOLUA_RELEASE
02220 tolua_Error tolua_err;
02221 if (
02222 !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
02223 !tolua_isnoobj(tolua_S,2,&tolua_err)
02224 )
02225 goto tolua_lerror;
02226 else
02227 #endif
02228 {
02229 const fawkes::TestInterface* self = (const fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0);
02230 #ifndef TOLUA_RELEASE
02231 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'has_writer'", NULL);
02232 #endif
02233 {
02234 bool tolua_ret = (bool) self->has_writer();
02235 tolua_pushboolean(tolua_S,(bool)tolua_ret);
02236 }
02237 }
02238 return 1;
02239 #ifndef TOLUA_RELEASE
02240 tolua_lerror:
02241 tolua_error(tolua_S,"#ferror in function 'has_writer'.",&tolua_err);
02242 return 0;
02243 #endif
02244 }
02245 #endif //#ifndef TOLUA_DISABLE
02246
02247
02248 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_num_readers00
02249 static int tolua_interfaces_TestInterface_fawkes_TestInterface_num_readers00(lua_State* tolua_S)
02250 {
02251 #ifndef TOLUA_RELEASE
02252 tolua_Error tolua_err;
02253 if (
02254 !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
02255 !tolua_isnoobj(tolua_S,2,&tolua_err)
02256 )
02257 goto tolua_lerror;
02258 else
02259 #endif
02260 {
02261 const fawkes::TestInterface* self = (const fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0);
02262 #ifndef TOLUA_RELEASE
02263 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'num_readers'", NULL);
02264 #endif
02265 {
02266 unsigned int tolua_ret = (unsigned int) self->num_readers();
02267 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02268 }
02269 }
02270 return 1;
02271 #ifndef TOLUA_RELEASE
02272 tolua_lerror:
02273 tolua_error(tolua_S,"#ferror in function 'num_readers'.",&tolua_err);
02274 return 0;
02275 #endif
02276 }
02277 #endif //#ifndef TOLUA_DISABLE
02278
02279
02280 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_enqueue_copy00
02281 static int tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_enqueue_copy00(lua_State* tolua_S)
02282 {
02283 #ifndef TOLUA_RELEASE
02284 tolua_Error tolua_err;
02285 if (
02286 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
02287 !tolua_isusertype(tolua_S,2,"Message",0,&tolua_err) ||
02288 !tolua_isnoobj(tolua_S,3,&tolua_err)
02289 )
02290 goto tolua_lerror;
02291 else
02292 #endif
02293 {
02294 fawkes::TestInterface* self = (fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0);
02295 Message* message = ((Message*) tolua_tousertype(tolua_S,2,0));
02296 #ifndef TOLUA_RELEASE
02297 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_enqueue_copy'", NULL);
02298 #endif
02299 {
02300 unsigned int tolua_ret = (unsigned int) self->msgq_enqueue_copy(message);
02301 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02302 }
02303 }
02304 return 1;
02305 #ifndef TOLUA_RELEASE
02306 tolua_lerror:
02307 tolua_error(tolua_S,"#ferror in function 'msgq_enqueue_copy'.",&tolua_err);
02308 return 0;
02309 #endif
02310 }
02311 #endif //#ifndef TOLUA_DISABLE
02312
02313
02314 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_remove00
02315 static int tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_remove00(lua_State* tolua_S)
02316 {
02317 #ifndef TOLUA_RELEASE
02318 tolua_Error tolua_err;
02319 if (
02320 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
02321 !tolua_isusertype(tolua_S,2,"Message",0,&tolua_err) ||
02322 !tolua_isnoobj(tolua_S,3,&tolua_err)
02323 )
02324 goto tolua_lerror;
02325 else
02326 #endif
02327 {
02328 fawkes::TestInterface* self = (fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0);
02329 Message* message = ((Message*) tolua_tousertype(tolua_S,2,0));
02330 #ifndef TOLUA_RELEASE
02331 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_remove'", NULL);
02332 #endif
02333 {
02334 self->msgq_remove(message);
02335 }
02336 }
02337 return 0;
02338 #ifndef TOLUA_RELEASE
02339 tolua_lerror:
02340 tolua_error(tolua_S,"#ferror in function 'msgq_remove'.",&tolua_err);
02341 return 0;
02342 #endif
02343 }
02344 #endif //#ifndef TOLUA_DISABLE
02345
02346
02347 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_remove01
02348 static int tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_remove01(lua_State* tolua_S)
02349 {
02350 tolua_Error tolua_err;
02351 if (
02352 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
02353 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02354 !tolua_isnoobj(tolua_S,3,&tolua_err)
02355 )
02356 goto tolua_lerror;
02357 else
02358 {
02359 fawkes::TestInterface* self = (fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0);
02360 unsigned int message_id = ((unsigned int) tolua_tonumber(tolua_S,2,0));
02361 #ifndef TOLUA_RELEASE
02362 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_remove'", NULL);
02363 #endif
02364 {
02365 self->msgq_remove(message_id);
02366 }
02367 }
02368 return 0;
02369 tolua_lerror:
02370 return tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_remove00(tolua_S);
02371 }
02372 #endif //#ifndef TOLUA_DISABLE
02373
02374
02375 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_size00
02376 static int tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_size00(lua_State* tolua_S)
02377 {
02378 #ifndef TOLUA_RELEASE
02379 tolua_Error tolua_err;
02380 if (
02381 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
02382 !tolua_isnoobj(tolua_S,2,&tolua_err)
02383 )
02384 goto tolua_lerror;
02385 else
02386 #endif
02387 {
02388 fawkes::TestInterface* self = (fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0);
02389 #ifndef TOLUA_RELEASE
02390 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_size'", NULL);
02391 #endif
02392 {
02393 unsigned int tolua_ret = (unsigned int) self->msgq_size();
02394 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02395 }
02396 }
02397 return 1;
02398 #ifndef TOLUA_RELEASE
02399 tolua_lerror:
02400 tolua_error(tolua_S,"#ferror in function 'msgq_size'.",&tolua_err);
02401 return 0;
02402 #endif
02403 }
02404 #endif //#ifndef TOLUA_DISABLE
02405
02406
02407 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_flush00
02408 static int tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_flush00(lua_State* tolua_S)
02409 {
02410 #ifndef TOLUA_RELEASE
02411 tolua_Error tolua_err;
02412 if (
02413 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
02414 !tolua_isnoobj(tolua_S,2,&tolua_err)
02415 )
02416 goto tolua_lerror;
02417 else
02418 #endif
02419 {
02420 fawkes::TestInterface* self = (fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0);
02421 #ifndef TOLUA_RELEASE
02422 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_flush'", NULL);
02423 #endif
02424 {
02425 self->msgq_flush();
02426 }
02427 }
02428 return 0;
02429 #ifndef TOLUA_RELEASE
02430 tolua_lerror:
02431 tolua_error(tolua_S,"#ferror in function 'msgq_flush'.",&tolua_err);
02432 return 0;
02433 #endif
02434 }
02435 #endif //#ifndef TOLUA_DISABLE
02436
02437
02438 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_lock00
02439 static int tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_lock00(lua_State* tolua_S)
02440 {
02441 #ifndef TOLUA_RELEASE
02442 tolua_Error tolua_err;
02443 if (
02444 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
02445 !tolua_isnoobj(tolua_S,2,&tolua_err)
02446 )
02447 goto tolua_lerror;
02448 else
02449 #endif
02450 {
02451 fawkes::TestInterface* self = (fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0);
02452 #ifndef TOLUA_RELEASE
02453 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_lock'", NULL);
02454 #endif
02455 {
02456 self->msgq_lock();
02457 }
02458 }
02459 return 0;
02460 #ifndef TOLUA_RELEASE
02461 tolua_lerror:
02462 tolua_error(tolua_S,"#ferror in function 'msgq_lock'.",&tolua_err);
02463 return 0;
02464 #endif
02465 }
02466 #endif //#ifndef TOLUA_DISABLE
02467
02468
02469 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_try_lock00
02470 static int tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_try_lock00(lua_State* tolua_S)
02471 {
02472 #ifndef TOLUA_RELEASE
02473 tolua_Error tolua_err;
02474 if (
02475 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
02476 !tolua_isnoobj(tolua_S,2,&tolua_err)
02477 )
02478 goto tolua_lerror;
02479 else
02480 #endif
02481 {
02482 fawkes::TestInterface* self = (fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0);
02483 #ifndef TOLUA_RELEASE
02484 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_try_lock'", NULL);
02485 #endif
02486 {
02487 bool tolua_ret = (bool) self->msgq_try_lock();
02488 tolua_pushboolean(tolua_S,(bool)tolua_ret);
02489 }
02490 }
02491 return 1;
02492 #ifndef TOLUA_RELEASE
02493 tolua_lerror:
02494 tolua_error(tolua_S,"#ferror in function 'msgq_try_lock'.",&tolua_err);
02495 return 0;
02496 #endif
02497 }
02498 #endif //#ifndef TOLUA_DISABLE
02499
02500
02501 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_unlock00
02502 static int tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_unlock00(lua_State* tolua_S)
02503 {
02504 #ifndef TOLUA_RELEASE
02505 tolua_Error tolua_err;
02506 if (
02507 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
02508 !tolua_isnoobj(tolua_S,2,&tolua_err)
02509 )
02510 goto tolua_lerror;
02511 else
02512 #endif
02513 {
02514 fawkes::TestInterface* self = (fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0);
02515 #ifndef TOLUA_RELEASE
02516 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_unlock'", NULL);
02517 #endif
02518 {
02519 self->msgq_unlock();
02520 }
02521 }
02522 return 0;
02523 #ifndef TOLUA_RELEASE
02524 tolua_lerror:
02525 tolua_error(tolua_S,"#ferror in function 'msgq_unlock'.",&tolua_err);
02526 return 0;
02527 #endif
02528 }
02529 #endif //#ifndef TOLUA_DISABLE
02530
02531
02532 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_pop00
02533 static int tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_pop00(lua_State* tolua_S)
02534 {
02535 #ifndef TOLUA_RELEASE
02536 tolua_Error tolua_err;
02537 if (
02538 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
02539 !tolua_isnoobj(tolua_S,2,&tolua_err)
02540 )
02541 goto tolua_lerror;
02542 else
02543 #endif
02544 {
02545 fawkes::TestInterface* self = (fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0);
02546 #ifndef TOLUA_RELEASE
02547 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_pop'", NULL);
02548 #endif
02549 {
02550 self->msgq_pop();
02551 }
02552 }
02553 return 0;
02554 #ifndef TOLUA_RELEASE
02555 tolua_lerror:
02556 tolua_error(tolua_S,"#ferror in function 'msgq_pop'.",&tolua_err);
02557 return 0;
02558 #endif
02559 }
02560 #endif //#ifndef TOLUA_DISABLE
02561
02562
02563 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_first00
02564 static int tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_first00(lua_State* tolua_S)
02565 {
02566 #ifndef TOLUA_RELEASE
02567 tolua_Error tolua_err;
02568 if (
02569 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
02570 !tolua_isnoobj(tolua_S,2,&tolua_err)
02571 )
02572 goto tolua_lerror;
02573 else
02574 #endif
02575 {
02576 fawkes::TestInterface* self = (fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0);
02577 #ifndef TOLUA_RELEASE
02578 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_first'", NULL);
02579 #endif
02580 {
02581 Message* tolua_ret = (Message*) self->msgq_first();
02582 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Message");
02583 }
02584 }
02585 return 1;
02586 #ifndef TOLUA_RELEASE
02587 tolua_lerror:
02588 tolua_error(tolua_S,"#ferror in function 'msgq_first'.",&tolua_err);
02589 return 0;
02590 #endif
02591 }
02592 #endif //#ifndef TOLUA_DISABLE
02593
02594
02595 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_empty00
02596 static int tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_empty00(lua_State* tolua_S)
02597 {
02598 #ifndef TOLUA_RELEASE
02599 tolua_Error tolua_err;
02600 if (
02601 !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
02602 !tolua_isnoobj(tolua_S,2,&tolua_err)
02603 )
02604 goto tolua_lerror;
02605 else
02606 #endif
02607 {
02608 fawkes::TestInterface* self = (fawkes::TestInterface*) tolua_tousertype(tolua_S,1,0);
02609 #ifndef TOLUA_RELEASE
02610 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_empty'", NULL);
02611 #endif
02612 {
02613 bool tolua_ret = (bool) self->msgq_empty();
02614 tolua_pushboolean(tolua_S,(bool)tolua_ret);
02615 }
02616 }
02617 return 1;
02618 #ifndef TOLUA_RELEASE
02619 tolua_lerror:
02620 tolua_error(tolua_S,"#ferror in function 'msgq_empty'.",&tolua_err);
02621 return 0;
02622 #endif
02623 }
02624 #endif //#ifndef TOLUA_DISABLE
02625
02626
02627 TOLUA_API int tolua_interfaces_TestInterface_open (lua_State* tolua_S)
02628 {
02629 tolua_open(tolua_S);
02630 tolua_reg_types(tolua_S);
02631 tolua_module(tolua_S,NULL,0);
02632 tolua_beginmodule(tolua_S,NULL);
02633 tolua_module(tolua_S,"fawkes",0);
02634 tolua_beginmodule(tolua_S,"fawkes");
02635 tolua_cclass(tolua_S,"TestInterface","fawkes::TestInterface","Interface",NULL);
02636 tolua_beginmodule(tolua_S,"TestInterface");
02637 tolua_variable(tolua_S,"TEST_CONSTANT",tolua_get_fawkes__TestInterface_TEST_CONSTANT,NULL);
02638 tolua_variable(tolua_S,"TEST_FLOAT_CONSTANT",tolua_get_fawkes__TestInterface_TEST_FLOAT_CONSTANT,NULL);
02639 tolua_constant(tolua_S,"TEST_ENUM_1",fawkes::TestInterface::TEST_ENUM_1);
02640 tolua_constant(tolua_S,"TEST_ENUM_2",fawkes::TestInterface::TEST_ENUM_2);
02641 #ifdef __cplusplus
02642 tolua_cclass(tolua_S,"SetTestIntMessage","fawkes::TestInterface::SetTestIntMessage","Message",tolua_collect_fawkes__TestInterface__SetTestIntMessage);
02643 #else
02644 tolua_cclass(tolua_S,"SetTestIntMessage","fawkes::TestInterface::SetTestIntMessage","Message",NULL);
02645 #endif
02646 tolua_beginmodule(tolua_S,"SetTestIntMessage");
02647 tolua_function(tolua_S,"new",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_new00);
02648 tolua_function(tolua_S,"new_local",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_new00_local);
02649 tolua_function(tolua_S,".call",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_new00_local);
02650 tolua_function(tolua_S,"new",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_new01);
02651 tolua_function(tolua_S,"new_local",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_new01_local);
02652 tolua_function(tolua_S,".call",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_new01_local);
02653 tolua_function(tolua_S,"delete",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_delete00);
02654 tolua_function(tolua_S,"test_int",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_test_int00);
02655 tolua_function(tolua_S,"set_test_int",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_set_test_int00);
02656 tolua_function(tolua_S,"maxlenof_test_int",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_maxlenof_test_int00);
02657 tolua_endmodule(tolua_S);
02658 #ifdef __cplusplus
02659 tolua_cclass(tolua_S,"SetTestStringMessage","fawkes::TestInterface::SetTestStringMessage","Message",tolua_collect_fawkes__TestInterface__SetTestStringMessage);
02660 #else
02661 tolua_cclass(tolua_S,"SetTestStringMessage","fawkes::TestInterface::SetTestStringMessage","Message",NULL);
02662 #endif
02663 tolua_beginmodule(tolua_S,"SetTestStringMessage");
02664 tolua_function(tolua_S,"new",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_new00);
02665 tolua_function(tolua_S,"new_local",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_new00_local);
02666 tolua_function(tolua_S,".call",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_new00_local);
02667 tolua_function(tolua_S,"new",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_new01);
02668 tolua_function(tolua_S,"new_local",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_new01_local);
02669 tolua_function(tolua_S,".call",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_new01_local);
02670 tolua_function(tolua_S,"delete",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_delete00);
02671 tolua_function(tolua_S,"test_string",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_test_string00);
02672 tolua_function(tolua_S,"set_test_string",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_set_test_string00);
02673 tolua_function(tolua_S,"maxlenof_test_string",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_maxlenof_test_string00);
02674 tolua_endmodule(tolua_S);
02675 #ifdef __cplusplus
02676 tolua_cclass(tolua_S,"CalculateMessage","fawkes::TestInterface::CalculateMessage","Message",tolua_collect_fawkes__TestInterface__CalculateMessage);
02677 #else
02678 tolua_cclass(tolua_S,"CalculateMessage","fawkes::TestInterface::CalculateMessage","Message",NULL);
02679 #endif
02680 tolua_beginmodule(tolua_S,"CalculateMessage");
02681 tolua_function(tolua_S,"new",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_new00);
02682 tolua_function(tolua_S,"new_local",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_new00_local);
02683 tolua_function(tolua_S,".call",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_new00_local);
02684 tolua_function(tolua_S,"new",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_new01);
02685 tolua_function(tolua_S,"new_local",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_new01_local);
02686 tolua_function(tolua_S,".call",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_new01_local);
02687 tolua_function(tolua_S,"delete",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_delete00);
02688 tolua_function(tolua_S,"summand",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_summand00);
02689 tolua_function(tolua_S,"set_summand",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_set_summand00);
02690 tolua_function(tolua_S,"maxlenof_summand",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_maxlenof_summand00);
02691 tolua_function(tolua_S,"addend",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_addend00);
02692 tolua_function(tolua_S,"set_addend",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_set_addend00);
02693 tolua_function(tolua_S,"maxlenof_addend",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_maxlenof_addend00);
02694 tolua_endmodule(tolua_S);
02695 tolua_function(tolua_S,"is_test_bool",tolua_interfaces_TestInterface_fawkes_TestInterface_is_test_bool00);
02696 tolua_function(tolua_S,"set_test_bool",tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_bool00);
02697 tolua_function(tolua_S,"maxlenof_test_bool",tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_bool00);
02698 tolua_function(tolua_S,"test_int",tolua_interfaces_TestInterface_fawkes_TestInterface_test_int00);
02699 tolua_function(tolua_S,"set_test_int",tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_int00);
02700 tolua_function(tolua_S,"maxlenof_test_int",tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_int00);
02701 tolua_function(tolua_S,"flags",tolua_interfaces_TestInterface_fawkes_TestInterface_flags00);
02702 tolua_function(tolua_S,"set_flags",tolua_interfaces_TestInterface_fawkes_TestInterface_set_flags00);
02703 tolua_function(tolua_S,"maxlenof_flags",tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_flags00);
02704 tolua_function(tolua_S,"test_string",tolua_interfaces_TestInterface_fawkes_TestInterface_test_string00);
02705 tolua_function(tolua_S,"set_test_string",tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_string00);
02706 tolua_function(tolua_S,"maxlenof_test_string",tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_string00);
02707 tolua_function(tolua_S,"result",tolua_interfaces_TestInterface_fawkes_TestInterface_result00);
02708 tolua_function(tolua_S,"set_result",tolua_interfaces_TestInterface_fawkes_TestInterface_set_result00);
02709 tolua_function(tolua_S,"maxlenof_result",tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_result00);
02710 tolua_function(tolua_S,"test_uint",tolua_interfaces_TestInterface_fawkes_TestInterface_test_uint00);
02711 tolua_function(tolua_S,"set_test_uint",tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_uint00);
02712 tolua_function(tolua_S,"maxlenof_test_uint",tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_uint00);
02713 tolua_function(tolua_S,"test_ulint",tolua_interfaces_TestInterface_fawkes_TestInterface_test_ulint00);
02714 tolua_function(tolua_S,"set_test_ulint",tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_ulint00);
02715 tolua_function(tolua_S,"maxlenof_test_ulint",tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_ulint00);
02716 tolua_function(tolua_S,"test_lint",tolua_interfaces_TestInterface_fawkes_TestInterface_test_lint00);
02717 tolua_function(tolua_S,"set_test_lint",tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_lint00);
02718 tolua_function(tolua_S,"maxlenof_test_lint",tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_lint00);
02719 tolua_function(tolua_S,"oftype",tolua_interfaces_TestInterface_fawkes_TestInterface_oftype00);
02720 tolua_function(tolua_S,"datachunk",tolua_interfaces_TestInterface_fawkes_TestInterface_datachunk00);
02721 tolua_function(tolua_S,"datasize",tolua_interfaces_TestInterface_fawkes_TestInterface_datasize00);
02722 tolua_function(tolua_S,"type",tolua_interfaces_TestInterface_fawkes_TestInterface_type00);
02723 tolua_function(tolua_S,"id",tolua_interfaces_TestInterface_fawkes_TestInterface_id00);
02724 tolua_function(tolua_S,"uid",tolua_interfaces_TestInterface_fawkes_TestInterface_uid00);
02725 tolua_function(tolua_S,"serial",tolua_interfaces_TestInterface_fawkes_TestInterface_serial00);
02726 tolua_function(tolua_S,"mem_serial",tolua_interfaces_TestInterface_fawkes_TestInterface_mem_serial00);
02727 tolua_function(tolua_S,".eq",tolua_interfaces_TestInterface_fawkes_TestInterface__eq00);
02728 tolua_function(tolua_S,"hash",tolua_interfaces_TestInterface_fawkes_TestInterface_hash00);
02729 tolua_function(tolua_S,"hash_size",tolua_interfaces_TestInterface_fawkes_TestInterface_hash_size00);
02730 tolua_function(tolua_S,"hash_printable",tolua_interfaces_TestInterface_fawkes_TestInterface_hash_printable00);
02731 tolua_function(tolua_S,"is_writer",tolua_interfaces_TestInterface_fawkes_TestInterface_is_writer00);
02732 tolua_function(tolua_S,"set_from_chunk",tolua_interfaces_TestInterface_fawkes_TestInterface_set_from_chunk00);
02733 tolua_function(tolua_S,"create_message",tolua_interfaces_TestInterface_fawkes_TestInterface_create_message00);
02734 tolua_function(tolua_S,"read",tolua_interfaces_TestInterface_fawkes_TestInterface_read00);
02735 tolua_function(tolua_S,"write",tolua_interfaces_TestInterface_fawkes_TestInterface_write00);
02736 tolua_function(tolua_S,"has_writer",tolua_interfaces_TestInterface_fawkes_TestInterface_has_writer00);
02737 tolua_function(tolua_S,"num_readers",tolua_interfaces_TestInterface_fawkes_TestInterface_num_readers00);
02738 tolua_function(tolua_S,"msgq_enqueue_copy",tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_enqueue_copy00);
02739 tolua_function(tolua_S,"msgq_remove",tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_remove00);
02740 tolua_function(tolua_S,"msgq_remove",tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_remove01);
02741 tolua_function(tolua_S,"msgq_size",tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_size00);
02742 tolua_function(tolua_S,"msgq_flush",tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_flush00);
02743 tolua_function(tolua_S,"msgq_lock",tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_lock00);
02744 tolua_function(tolua_S,"msgq_try_lock",tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_try_lock00);
02745 tolua_function(tolua_S,"msgq_unlock",tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_unlock00);
02746 tolua_function(tolua_S,"msgq_pop",tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_pop00);
02747 tolua_function(tolua_S,"msgq_first",tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_first00);
02748 tolua_function(tolua_S,"msgq_empty",tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_empty00);
02749 tolua_endmodule(tolua_S);
02750 tolua_endmodule(tolua_S);
02751 tolua_endmodule(tolua_S);
02752 return 1;
02753 }
02754
02755
02756 extern "C" {
02757 #if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501
02758 TOLUA_API int luaopen_interfaces_TestInterface (lua_State* tolua_S) {
02759 return tolua_interfaces_TestInterface_open(tolua_S);
02760 };
02761 #endif
02762 }
02763
02764