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_LedInterface_open (lua_State* tolua_S);
00028
00029 #include <interfaces/LedInterface.h>
00030 using namespace fawkes;
00031
00032
00033 #ifdef __cplusplus
00034
00035 static int tolua_collect_fawkes__LedInterface__TurnOffMessage (lua_State* tolua_S)
00036 {
00037 fawkes::LedInterface::TurnOffMessage* self = (fawkes::LedInterface::TurnOffMessage*) tolua_tousertype(tolua_S,1,0);
00038 delete self;
00039 return 0;
00040 }
00041
00042 static int tolua_collect_fawkes__LedInterface__TurnOnMessage (lua_State* tolua_S)
00043 {
00044 fawkes::LedInterface::TurnOnMessage* self = (fawkes::LedInterface::TurnOnMessage*) tolua_tousertype(tolua_S,1,0);
00045 delete self;
00046 return 0;
00047 }
00048
00049 static int tolua_collect_fawkes__LedInterface__SetIntensityMessage (lua_State* tolua_S)
00050 {
00051 fawkes::LedInterface::SetIntensityMessage* self = (fawkes::LedInterface::SetIntensityMessage*) tolua_tousertype(tolua_S,1,0);
00052 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::LedInterface::SetIntensityMessage");
00063 tolua_usertype(tolua_S,"Interface");
00064 tolua_usertype(tolua_S,"fawkes::LedInterface::TurnOffMessage");
00065 tolua_usertype(tolua_S,"fawkes::LedInterface::TurnOnMessage");
00066 tolua_usertype(tolua_S,"fawkes::LedInterface");
00067 }
00068
00069
00070 #ifndef TOLUA_DISABLE_tolua_get_fawkes__LedInterface_ON
00071 static int tolua_get_fawkes__LedInterface_ON(lua_State* tolua_S)
00072 {
00073 tolua_pushnumber(tolua_S,(lua_Number)fawkes::LedInterface::ON);
00074 return 1;
00075 }
00076 #endif //#ifndef TOLUA_DISABLE
00077
00078
00079 #ifndef TOLUA_DISABLE_tolua_get_fawkes__LedInterface_OFF
00080 static int tolua_get_fawkes__LedInterface_OFF(lua_State* tolua_S)
00081 {
00082 tolua_pushnumber(tolua_S,(lua_Number)fawkes::LedInterface::OFF);
00083 return 1;
00084 }
00085 #endif //#ifndef TOLUA_DISABLE
00086
00087
00088 #ifndef TOLUA_DISABLE_tolua_interfaces_LedInterface_fawkes_LedInterface_SetIntensityMessage_new00
00089 static int tolua_interfaces_LedInterface_fawkes_LedInterface_SetIntensityMessage_new00(lua_State* tolua_S)
00090 {
00091 #ifndef TOLUA_RELEASE
00092 tolua_Error tolua_err;
00093 if (
00094 !tolua_isusertable(tolua_S,1,"fawkes::LedInterface::SetIntensityMessage",0,&tolua_err) ||
00095 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00096 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
00097 !tolua_isnoobj(tolua_S,4,&tolua_err)
00098 )
00099 goto tolua_lerror;
00100 else
00101 #endif
00102 {
00103 float ini_time_sec = ((float) tolua_tonumber(tolua_S,2,0));
00104 float ini_intensity = ((float) tolua_tonumber(tolua_S,3,0));
00105 {
00106 fawkes::LedInterface::SetIntensityMessage* tolua_ret = (fawkes::LedInterface::SetIntensityMessage*) new fawkes::LedInterface::SetIntensityMessage(ini_time_sec,ini_intensity);
00107 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::LedInterface::SetIntensityMessage");
00108 }
00109 }
00110 return 1;
00111 #ifndef TOLUA_RELEASE
00112 tolua_lerror:
00113 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00114 return 0;
00115 #endif
00116 }
00117 #endif //#ifndef TOLUA_DISABLE
00118
00119
00120 #ifndef TOLUA_DISABLE_tolua_interfaces_LedInterface_fawkes_LedInterface_SetIntensityMessage_new00_local
00121 static int tolua_interfaces_LedInterface_fawkes_LedInterface_SetIntensityMessage_new00_local(lua_State* tolua_S)
00122 {
00123 #ifndef TOLUA_RELEASE
00124 tolua_Error tolua_err;
00125 if (
00126 !tolua_isusertable(tolua_S,1,"fawkes::LedInterface::SetIntensityMessage",0,&tolua_err) ||
00127 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00128 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
00129 !tolua_isnoobj(tolua_S,4,&tolua_err)
00130 )
00131 goto tolua_lerror;
00132 else
00133 #endif
00134 {
00135 float ini_time_sec = ((float) tolua_tonumber(tolua_S,2,0));
00136 float ini_intensity = ((float) tolua_tonumber(tolua_S,3,0));
00137 {
00138 fawkes::LedInterface::SetIntensityMessage* tolua_ret = (fawkes::LedInterface::SetIntensityMessage*) new fawkes::LedInterface::SetIntensityMessage(ini_time_sec,ini_intensity);
00139 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"fawkes::LedInterface::SetIntensityMessage");
00140 }
00141 }
00142 return 1;
00143 #ifndef TOLUA_RELEASE
00144 tolua_lerror:
00145 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00146 return 0;
00147 #endif
00148 }
00149 #endif //#ifndef TOLUA_DISABLE
00150
00151
00152 #ifndef TOLUA_DISABLE_tolua_interfaces_LedInterface_fawkes_LedInterface_SetIntensityMessage_new01
00153 static int tolua_interfaces_LedInterface_fawkes_LedInterface_SetIntensityMessage_new01(lua_State* tolua_S)
00154 {
00155 tolua_Error tolua_err;
00156 if (
00157 !tolua_isusertable(tolua_S,1,"fawkes::LedInterface::SetIntensityMessage",0,&tolua_err) ||
00158 !tolua_isnoobj(tolua_S,2,&tolua_err)
00159 )
00160 goto tolua_lerror;
00161 else
00162 {
00163 {
00164 fawkes::LedInterface::SetIntensityMessage* tolua_ret = (fawkes::LedInterface::SetIntensityMessage*) new fawkes::LedInterface::SetIntensityMessage();
00165 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::LedInterface::SetIntensityMessage");
00166 }
00167 }
00168 return 1;
00169 tolua_lerror:
00170 return tolua_interfaces_LedInterface_fawkes_LedInterface_SetIntensityMessage_new00(tolua_S);
00171 }
00172 #endif //#ifndef TOLUA_DISABLE
00173
00174
00175 #ifndef TOLUA_DISABLE_tolua_interfaces_LedInterface_fawkes_LedInterface_SetIntensityMessage_new01_local
00176 static int tolua_interfaces_LedInterface_fawkes_LedInterface_SetIntensityMessage_new01_local(lua_State* tolua_S)
00177 {
00178 tolua_Error tolua_err;
00179 if (
00180 !tolua_isusertable(tolua_S,1,"fawkes::LedInterface::SetIntensityMessage",0,&tolua_err) ||
00181 !tolua_isnoobj(tolua_S,2,&tolua_err)
00182 )
00183 goto tolua_lerror;
00184 else
00185 {
00186 {
00187 fawkes::LedInterface::SetIntensityMessage* tolua_ret = (fawkes::LedInterface::SetIntensityMessage*) new fawkes::LedInterface::SetIntensityMessage();
00188 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"fawkes::LedInterface::SetIntensityMessage");
00189 }
00190 }
00191 return 1;
00192 tolua_lerror:
00193 return tolua_interfaces_LedInterface_fawkes_LedInterface_SetIntensityMessage_new00_local(tolua_S);
00194 }
00195 #endif //#ifndef TOLUA_DISABLE
00196
00197
00198 #ifndef TOLUA_DISABLE_tolua_interfaces_LedInterface_fawkes_LedInterface_SetIntensityMessage_delete00
00199 static int tolua_interfaces_LedInterface_fawkes_LedInterface_SetIntensityMessage_delete00(lua_State* tolua_S)
00200 {
00201 #ifndef TOLUA_RELEASE
00202 tolua_Error tolua_err;
00203 if (
00204 !tolua_isusertype(tolua_S,1,"fawkes::LedInterface::SetIntensityMessage",0,&tolua_err) ||
00205 !tolua_isnoobj(tolua_S,2,&tolua_err)
00206 )
00207 goto tolua_lerror;
00208 else
00209 #endif
00210 {
00211 fawkes::LedInterface::SetIntensityMessage* self = (fawkes::LedInterface::SetIntensityMessage*) tolua_tousertype(tolua_S,1,0);
00212 #ifndef TOLUA_RELEASE
00213 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
00214 #endif
00215 delete self;
00216 }
00217 return 0;
00218 #ifndef TOLUA_RELEASE
00219 tolua_lerror:
00220 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
00221 return 0;
00222 #endif
00223 }
00224 #endif //#ifndef TOLUA_DISABLE
00225
00226
00227 #ifndef TOLUA_DISABLE_tolua_interfaces_LedInterface_fawkes_LedInterface_SetIntensityMessage_time_sec00
00228 static int tolua_interfaces_LedInterface_fawkes_LedInterface_SetIntensityMessage_time_sec00(lua_State* tolua_S)
00229 {
00230 #ifndef TOLUA_RELEASE
00231 tolua_Error tolua_err;
00232 if (
00233 !tolua_isusertype(tolua_S,1,"fawkes::LedInterface::SetIntensityMessage",0,&tolua_err) ||
00234 !tolua_isnoobj(tolua_S,2,&tolua_err)
00235 )
00236 goto tolua_lerror;
00237 else
00238 #endif
00239 {
00240 fawkes::LedInterface::SetIntensityMessage* self = (fawkes::LedInterface::SetIntensityMessage*) tolua_tousertype(tolua_S,1,0);
00241 #ifndef TOLUA_RELEASE
00242 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'time_sec'",NULL);
00243 #endif
00244 {
00245 float tolua_ret = (float) self->time_sec();
00246 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00247 }
00248 }
00249 return 1;
00250 #ifndef TOLUA_RELEASE
00251 tolua_lerror:
00252 tolua_error(tolua_S,"#ferror in function 'time_sec'.",&tolua_err);
00253 return 0;
00254 #endif
00255 }
00256 #endif //#ifndef TOLUA_DISABLE
00257
00258
00259 #ifndef TOLUA_DISABLE_tolua_interfaces_LedInterface_fawkes_LedInterface_SetIntensityMessage_set_time_sec00
00260 static int tolua_interfaces_LedInterface_fawkes_LedInterface_SetIntensityMessage_set_time_sec00(lua_State* tolua_S)
00261 {
00262 #ifndef TOLUA_RELEASE
00263 tolua_Error tolua_err;
00264 if (
00265 !tolua_isusertype(tolua_S,1,"fawkes::LedInterface::SetIntensityMessage",0,&tolua_err) ||
00266 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00267 !tolua_isnoobj(tolua_S,3,&tolua_err)
00268 )
00269 goto tolua_lerror;
00270 else
00271 #endif
00272 {
00273 fawkes::LedInterface::SetIntensityMessage* self = (fawkes::LedInterface::SetIntensityMessage*) tolua_tousertype(tolua_S,1,0);
00274 const float new_time_sec = ((const float) tolua_tonumber(tolua_S,2,0));
00275 #ifndef TOLUA_RELEASE
00276 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_time_sec'",NULL);
00277 #endif
00278 {
00279 self->set_time_sec(new_time_sec);
00280 }
00281 }
00282 return 0;
00283 #ifndef TOLUA_RELEASE
00284 tolua_lerror:
00285 tolua_error(tolua_S,"#ferror in function 'set_time_sec'.",&tolua_err);
00286 return 0;
00287 #endif
00288 }
00289 #endif //#ifndef TOLUA_DISABLE
00290
00291
00292 #ifndef TOLUA_DISABLE_tolua_interfaces_LedInterface_fawkes_LedInterface_SetIntensityMessage_maxlenof_time_sec00
00293 static int tolua_interfaces_LedInterface_fawkes_LedInterface_SetIntensityMessage_maxlenof_time_sec00(lua_State* tolua_S)
00294 {
00295 #ifndef TOLUA_RELEASE
00296 tolua_Error tolua_err;
00297 if (
00298 !tolua_isusertype(tolua_S,1,"const fawkes::LedInterface::SetIntensityMessage",0,&tolua_err) ||
00299 !tolua_isnoobj(tolua_S,2,&tolua_err)
00300 )
00301 goto tolua_lerror;
00302 else
00303 #endif
00304 {
00305 const fawkes::LedInterface::SetIntensityMessage* self = (const fawkes::LedInterface::SetIntensityMessage*) tolua_tousertype(tolua_S,1,0);
00306 #ifndef TOLUA_RELEASE
00307 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_time_sec'",NULL);
00308 #endif
00309 {
00310 int tolua_ret = (int) self->maxlenof_time_sec();
00311 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00312 }
00313 }
00314 return 1;
00315 #ifndef TOLUA_RELEASE
00316 tolua_lerror:
00317 tolua_error(tolua_S,"#ferror in function 'maxlenof_time_sec'.",&tolua_err);
00318 return 0;
00319 #endif
00320 }
00321 #endif //#ifndef TOLUA_DISABLE
00322
00323
00324 #ifndef TOLUA_DISABLE_tolua_interfaces_LedInterface_fawkes_LedInterface_SetIntensityMessage_intensity00
00325 static int tolua_interfaces_LedInterface_fawkes_LedInterface_SetIntensityMessage_intensity00(lua_State* tolua_S)
00326 {
00327 #ifndef TOLUA_RELEASE
00328 tolua_Error tolua_err;
00329 if (
00330 !tolua_isusertype(tolua_S,1,"fawkes::LedInterface::SetIntensityMessage",0,&tolua_err) ||
00331 !tolua_isnoobj(tolua_S,2,&tolua_err)
00332 )
00333 goto tolua_lerror;
00334 else
00335 #endif
00336 {
00337 fawkes::LedInterface::SetIntensityMessage* self = (fawkes::LedInterface::SetIntensityMessage*) tolua_tousertype(tolua_S,1,0);
00338 #ifndef TOLUA_RELEASE
00339 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'intensity'",NULL);
00340 #endif
00341 {
00342 float tolua_ret = (float) self->intensity();
00343 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00344 }
00345 }
00346 return 1;
00347 #ifndef TOLUA_RELEASE
00348 tolua_lerror:
00349 tolua_error(tolua_S,"#ferror in function 'intensity'.",&tolua_err);
00350 return 0;
00351 #endif
00352 }
00353 #endif //#ifndef TOLUA_DISABLE
00354
00355
00356 #ifndef TOLUA_DISABLE_tolua_interfaces_LedInterface_fawkes_LedInterface_SetIntensityMessage_set_intensity00
00357 static int tolua_interfaces_LedInterface_fawkes_LedInterface_SetIntensityMessage_set_intensity00(lua_State* tolua_S)
00358 {
00359 #ifndef TOLUA_RELEASE
00360 tolua_Error tolua_err;
00361 if (
00362 !tolua_isusertype(tolua_S,1,"fawkes::LedInterface::SetIntensityMessage",0,&tolua_err) ||
00363 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00364 !tolua_isnoobj(tolua_S,3,&tolua_err)
00365 )
00366 goto tolua_lerror;
00367 else
00368 #endif
00369 {
00370 fawkes::LedInterface::SetIntensityMessage* self = (fawkes::LedInterface::SetIntensityMessage*) tolua_tousertype(tolua_S,1,0);
00371 const float new_intensity = ((const float) tolua_tonumber(tolua_S,2,0));
00372 #ifndef TOLUA_RELEASE
00373 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_intensity'",NULL);
00374 #endif
00375 {
00376 self->set_intensity(new_intensity);
00377 }
00378 }
00379 return 0;
00380 #ifndef TOLUA_RELEASE
00381 tolua_lerror:
00382 tolua_error(tolua_S,"#ferror in function 'set_intensity'.",&tolua_err);
00383 return 0;
00384 #endif
00385 }
00386 #endif //#ifndef TOLUA_DISABLE
00387
00388
00389 #ifndef TOLUA_DISABLE_tolua_interfaces_LedInterface_fawkes_LedInterface_SetIntensityMessage_maxlenof_intensity00
00390 static int tolua_interfaces_LedInterface_fawkes_LedInterface_SetIntensityMessage_maxlenof_intensity00(lua_State* tolua_S)
00391 {
00392 #ifndef TOLUA_RELEASE
00393 tolua_Error tolua_err;
00394 if (
00395 !tolua_isusertype(tolua_S,1,"const fawkes::LedInterface::SetIntensityMessage",0,&tolua_err) ||
00396 !tolua_isnoobj(tolua_S,2,&tolua_err)
00397 )
00398 goto tolua_lerror;
00399 else
00400 #endif
00401 {
00402 const fawkes::LedInterface::SetIntensityMessage* self = (const fawkes::LedInterface::SetIntensityMessage*) tolua_tousertype(tolua_S,1,0);
00403 #ifndef TOLUA_RELEASE
00404 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_intensity'",NULL);
00405 #endif
00406 {
00407 int tolua_ret = (int) self->maxlenof_intensity();
00408 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00409 }
00410 }
00411 return 1;
00412 #ifndef TOLUA_RELEASE
00413 tolua_lerror:
00414 tolua_error(tolua_S,"#ferror in function 'maxlenof_intensity'.",&tolua_err);
00415 return 0;
00416 #endif
00417 }
00418 #endif //#ifndef TOLUA_DISABLE
00419
00420
00421 #ifndef TOLUA_DISABLE_tolua_interfaces_LedInterface_fawkes_LedInterface_TurnOnMessage_new00
00422 static int tolua_interfaces_LedInterface_fawkes_LedInterface_TurnOnMessage_new00(lua_State* tolua_S)
00423 {
00424 #ifndef TOLUA_RELEASE
00425 tolua_Error tolua_err;
00426 if (
00427 !tolua_isusertable(tolua_S,1,"fawkes::LedInterface::TurnOnMessage",0,&tolua_err) ||
00428 !tolua_isnoobj(tolua_S,2,&tolua_err)
00429 )
00430 goto tolua_lerror;
00431 else
00432 #endif
00433 {
00434 {
00435 fawkes::LedInterface::TurnOnMessage* tolua_ret = (fawkes::LedInterface::TurnOnMessage*) new fawkes::LedInterface::TurnOnMessage();
00436 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::LedInterface::TurnOnMessage");
00437 }
00438 }
00439 return 1;
00440 #ifndef TOLUA_RELEASE
00441 tolua_lerror:
00442 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00443 return 0;
00444 #endif
00445 }
00446 #endif //#ifndef TOLUA_DISABLE
00447
00448
00449 #ifndef TOLUA_DISABLE_tolua_interfaces_LedInterface_fawkes_LedInterface_TurnOnMessage_new00_local
00450 static int tolua_interfaces_LedInterface_fawkes_LedInterface_TurnOnMessage_new00_local(lua_State* tolua_S)
00451 {
00452 #ifndef TOLUA_RELEASE
00453 tolua_Error tolua_err;
00454 if (
00455 !tolua_isusertable(tolua_S,1,"fawkes::LedInterface::TurnOnMessage",0,&tolua_err) ||
00456 !tolua_isnoobj(tolua_S,2,&tolua_err)
00457 )
00458 goto tolua_lerror;
00459 else
00460 #endif
00461 {
00462 {
00463 fawkes::LedInterface::TurnOnMessage* tolua_ret = (fawkes::LedInterface::TurnOnMessage*) new fawkes::LedInterface::TurnOnMessage();
00464 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"fawkes::LedInterface::TurnOnMessage");
00465 }
00466 }
00467 return 1;
00468 #ifndef TOLUA_RELEASE
00469 tolua_lerror:
00470 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00471 return 0;
00472 #endif
00473 }
00474 #endif //#ifndef TOLUA_DISABLE
00475
00476
00477 #ifndef TOLUA_DISABLE_tolua_interfaces_LedInterface_fawkes_LedInterface_TurnOnMessage_delete00
00478 static int tolua_interfaces_LedInterface_fawkes_LedInterface_TurnOnMessage_delete00(lua_State* tolua_S)
00479 {
00480 #ifndef TOLUA_RELEASE
00481 tolua_Error tolua_err;
00482 if (
00483 !tolua_isusertype(tolua_S,1,"fawkes::LedInterface::TurnOnMessage",0,&tolua_err) ||
00484 !tolua_isnoobj(tolua_S,2,&tolua_err)
00485 )
00486 goto tolua_lerror;
00487 else
00488 #endif
00489 {
00490 fawkes::LedInterface::TurnOnMessage* self = (fawkes::LedInterface::TurnOnMessage*) tolua_tousertype(tolua_S,1,0);
00491 #ifndef TOLUA_RELEASE
00492 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
00493 #endif
00494 delete self;
00495 }
00496 return 0;
00497 #ifndef TOLUA_RELEASE
00498 tolua_lerror:
00499 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
00500 return 0;
00501 #endif
00502 }
00503 #endif //#ifndef TOLUA_DISABLE
00504
00505
00506 #ifndef TOLUA_DISABLE_tolua_interfaces_LedInterface_fawkes_LedInterface_TurnOffMessage_new00
00507 static int tolua_interfaces_LedInterface_fawkes_LedInterface_TurnOffMessage_new00(lua_State* tolua_S)
00508 {
00509 #ifndef TOLUA_RELEASE
00510 tolua_Error tolua_err;
00511 if (
00512 !tolua_isusertable(tolua_S,1,"fawkes::LedInterface::TurnOffMessage",0,&tolua_err) ||
00513 !tolua_isnoobj(tolua_S,2,&tolua_err)
00514 )
00515 goto tolua_lerror;
00516 else
00517 #endif
00518 {
00519 {
00520 fawkes::LedInterface::TurnOffMessage* tolua_ret = (fawkes::LedInterface::TurnOffMessage*) new fawkes::LedInterface::TurnOffMessage();
00521 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::LedInterface::TurnOffMessage");
00522 }
00523 }
00524 return 1;
00525 #ifndef TOLUA_RELEASE
00526 tolua_lerror:
00527 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00528 return 0;
00529 #endif
00530 }
00531 #endif //#ifndef TOLUA_DISABLE
00532
00533
00534 #ifndef TOLUA_DISABLE_tolua_interfaces_LedInterface_fawkes_LedInterface_TurnOffMessage_new00_local
00535 static int tolua_interfaces_LedInterface_fawkes_LedInterface_TurnOffMessage_new00_local(lua_State* tolua_S)
00536 {
00537 #ifndef TOLUA_RELEASE
00538 tolua_Error tolua_err;
00539 if (
00540 !tolua_isusertable(tolua_S,1,"fawkes::LedInterface::TurnOffMessage",0,&tolua_err) ||
00541 !tolua_isnoobj(tolua_S,2,&tolua_err)
00542 )
00543 goto tolua_lerror;
00544 else
00545 #endif
00546 {
00547 {
00548 fawkes::LedInterface::TurnOffMessage* tolua_ret = (fawkes::LedInterface::TurnOffMessage*) new fawkes::LedInterface::TurnOffMessage();
00549 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"fawkes::LedInterface::TurnOffMessage");
00550 }
00551 }
00552 return 1;
00553 #ifndef TOLUA_RELEASE
00554 tolua_lerror:
00555 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00556 return 0;
00557 #endif
00558 }
00559 #endif //#ifndef TOLUA_DISABLE
00560
00561
00562 #ifndef TOLUA_DISABLE_tolua_interfaces_LedInterface_fawkes_LedInterface_TurnOffMessage_delete00
00563 static int tolua_interfaces_LedInterface_fawkes_LedInterface_TurnOffMessage_delete00(lua_State* tolua_S)
00564 {
00565 #ifndef TOLUA_RELEASE
00566 tolua_Error tolua_err;
00567 if (
00568 !tolua_isusertype(tolua_S,1,"fawkes::LedInterface::TurnOffMessage",0,&tolua_err) ||
00569 !tolua_isnoobj(tolua_S,2,&tolua_err)
00570 )
00571 goto tolua_lerror;
00572 else
00573 #endif
00574 {
00575 fawkes::LedInterface::TurnOffMessage* self = (fawkes::LedInterface::TurnOffMessage*) tolua_tousertype(tolua_S,1,0);
00576 #ifndef TOLUA_RELEASE
00577 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
00578 #endif
00579 delete self;
00580 }
00581 return 0;
00582 #ifndef TOLUA_RELEASE
00583 tolua_lerror:
00584 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
00585 return 0;
00586 #endif
00587 }
00588 #endif //#ifndef TOLUA_DISABLE
00589
00590
00591 #ifndef TOLUA_DISABLE_tolua_interfaces_LedInterface_fawkes_LedInterface_intensity00
00592 static int tolua_interfaces_LedInterface_fawkes_LedInterface_intensity00(lua_State* tolua_S)
00593 {
00594 #ifndef TOLUA_RELEASE
00595 tolua_Error tolua_err;
00596 if (
00597 !tolua_isusertype(tolua_S,1,"fawkes::LedInterface",0,&tolua_err) ||
00598 !tolua_isnoobj(tolua_S,2,&tolua_err)
00599 )
00600 goto tolua_lerror;
00601 else
00602 #endif
00603 {
00604 fawkes::LedInterface* self = (fawkes::LedInterface*) tolua_tousertype(tolua_S,1,0);
00605 #ifndef TOLUA_RELEASE
00606 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'intensity'",NULL);
00607 #endif
00608 {
00609 float tolua_ret = (float) self->intensity();
00610 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00611 }
00612 }
00613 return 1;
00614 #ifndef TOLUA_RELEASE
00615 tolua_lerror:
00616 tolua_error(tolua_S,"#ferror in function 'intensity'.",&tolua_err);
00617 return 0;
00618 #endif
00619 }
00620 #endif //#ifndef TOLUA_DISABLE
00621
00622
00623 #ifndef TOLUA_DISABLE_tolua_interfaces_LedInterface_fawkes_LedInterface_set_intensity00
00624 static int tolua_interfaces_LedInterface_fawkes_LedInterface_set_intensity00(lua_State* tolua_S)
00625 {
00626 #ifndef TOLUA_RELEASE
00627 tolua_Error tolua_err;
00628 if (
00629 !tolua_isusertype(tolua_S,1,"fawkes::LedInterface",0,&tolua_err) ||
00630 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00631 !tolua_isnoobj(tolua_S,3,&tolua_err)
00632 )
00633 goto tolua_lerror;
00634 else
00635 #endif
00636 {
00637 fawkes::LedInterface* self = (fawkes::LedInterface*) tolua_tousertype(tolua_S,1,0);
00638 const float new_intensity = ((const float) tolua_tonumber(tolua_S,2,0));
00639 #ifndef TOLUA_RELEASE
00640 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_intensity'",NULL);
00641 #endif
00642 {
00643 self->set_intensity(new_intensity);
00644 }
00645 }
00646 return 0;
00647 #ifndef TOLUA_RELEASE
00648 tolua_lerror:
00649 tolua_error(tolua_S,"#ferror in function 'set_intensity'.",&tolua_err);
00650 return 0;
00651 #endif
00652 }
00653 #endif //#ifndef TOLUA_DISABLE
00654
00655
00656 #ifndef TOLUA_DISABLE_tolua_interfaces_LedInterface_fawkes_LedInterface_maxlenof_intensity00
00657 static int tolua_interfaces_LedInterface_fawkes_LedInterface_maxlenof_intensity00(lua_State* tolua_S)
00658 {
00659 #ifndef TOLUA_RELEASE
00660 tolua_Error tolua_err;
00661 if (
00662 !tolua_isusertype(tolua_S,1,"const fawkes::LedInterface",0,&tolua_err) ||
00663 !tolua_isnoobj(tolua_S,2,&tolua_err)
00664 )
00665 goto tolua_lerror;
00666 else
00667 #endif
00668 {
00669 const fawkes::LedInterface* self = (const fawkes::LedInterface*) tolua_tousertype(tolua_S,1,0);
00670 #ifndef TOLUA_RELEASE
00671 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_intensity'",NULL);
00672 #endif
00673 {
00674 int tolua_ret = (int) self->maxlenof_intensity();
00675 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00676 }
00677 }
00678 return 1;
00679 #ifndef TOLUA_RELEASE
00680 tolua_lerror:
00681 tolua_error(tolua_S,"#ferror in function 'maxlenof_intensity'.",&tolua_err);
00682 return 0;
00683 #endif
00684 }
00685 #endif //#ifndef TOLUA_DISABLE
00686
00687
00688 #ifndef TOLUA_DISABLE_tolua_interfaces_LedInterface_fawkes_LedInterface_oftype00
00689 static int tolua_interfaces_LedInterface_fawkes_LedInterface_oftype00(lua_State* tolua_S)
00690 {
00691 #ifndef TOLUA_RELEASE
00692 tolua_Error tolua_err;
00693 if (
00694 !tolua_isusertype(tolua_S,1,"const fawkes::LedInterface",0,&tolua_err) ||
00695 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
00696 !tolua_isnoobj(tolua_S,3,&tolua_err)
00697 )
00698 goto tolua_lerror;
00699 else
00700 #endif
00701 {
00702 const fawkes::LedInterface* self = (const fawkes::LedInterface*) tolua_tousertype(tolua_S,1,0);
00703 const char* interface_type = ((const char*) tolua_tostring(tolua_S,2,0));
00704 #ifndef TOLUA_RELEASE
00705 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'oftype'",NULL);
00706 #endif
00707 {
00708 bool tolua_ret = (bool) self->oftype(interface_type);
00709 tolua_pushboolean(tolua_S,(bool)tolua_ret);
00710 }
00711 }
00712 return 1;
00713 #ifndef TOLUA_RELEASE
00714 tolua_lerror:
00715 tolua_error(tolua_S,"#ferror in function 'oftype'.",&tolua_err);
00716 return 0;
00717 #endif
00718 }
00719 #endif //#ifndef TOLUA_DISABLE
00720
00721
00722 #ifndef TOLUA_DISABLE_tolua_interfaces_LedInterface_fawkes_LedInterface_datachunk00
00723 static int tolua_interfaces_LedInterface_fawkes_LedInterface_datachunk00(lua_State* tolua_S)
00724 {
00725 #ifndef TOLUA_RELEASE
00726 tolua_Error tolua_err;
00727 if (
00728 !tolua_isusertype(tolua_S,1,"const fawkes::LedInterface",0,&tolua_err) ||
00729 !tolua_isnoobj(tolua_S,2,&tolua_err)
00730 )
00731 goto tolua_lerror;
00732 else
00733 #endif
00734 {
00735 const fawkes::LedInterface* self = (const fawkes::LedInterface*) tolua_tousertype(tolua_S,1,0);
00736 #ifndef TOLUA_RELEASE
00737 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datachunk'",NULL);
00738 #endif
00739 {
00740 const void* tolua_ret = (const void*) self->datachunk();
00741 tolua_pushuserdata(tolua_S,(void*)tolua_ret);
00742 }
00743 }
00744 return 1;
00745 #ifndef TOLUA_RELEASE
00746 tolua_lerror:
00747 tolua_error(tolua_S,"#ferror in function 'datachunk'.",&tolua_err);
00748 return 0;
00749 #endif
00750 }
00751 #endif //#ifndef TOLUA_DISABLE
00752
00753
00754 #ifndef TOLUA_DISABLE_tolua_interfaces_LedInterface_fawkes_LedInterface_datasize00
00755 static int tolua_interfaces_LedInterface_fawkes_LedInterface_datasize00(lua_State* tolua_S)
00756 {
00757 #ifndef TOLUA_RELEASE
00758 tolua_Error tolua_err;
00759 if (
00760 !tolua_isusertype(tolua_S,1,"const fawkes::LedInterface",0,&tolua_err) ||
00761 !tolua_isnoobj(tolua_S,2,&tolua_err)
00762 )
00763 goto tolua_lerror;
00764 else
00765 #endif
00766 {
00767 const fawkes::LedInterface* self = (const fawkes::LedInterface*) tolua_tousertype(tolua_S,1,0);
00768 #ifndef TOLUA_RELEASE
00769 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datasize'",NULL);
00770 #endif
00771 {
00772 unsigned int tolua_ret = (unsigned int) self->datasize();
00773 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00774 }
00775 }
00776 return 1;
00777 #ifndef TOLUA_RELEASE
00778 tolua_lerror:
00779 tolua_error(tolua_S,"#ferror in function 'datasize'.",&tolua_err);
00780 return 0;
00781 #endif
00782 }
00783 #endif //#ifndef TOLUA_DISABLE
00784
00785
00786 #ifndef TOLUA_DISABLE_tolua_interfaces_LedInterface_fawkes_LedInterface_type00
00787 static int tolua_interfaces_LedInterface_fawkes_LedInterface_type00(lua_State* tolua_S)
00788 {
00789 #ifndef TOLUA_RELEASE
00790 tolua_Error tolua_err;
00791 if (
00792 !tolua_isusertype(tolua_S,1,"const fawkes::LedInterface",0,&tolua_err) ||
00793 !tolua_isnoobj(tolua_S,2,&tolua_err)
00794 )
00795 goto tolua_lerror;
00796 else
00797 #endif
00798 {
00799 const fawkes::LedInterface* self = (const fawkes::LedInterface*) tolua_tousertype(tolua_S,1,0);
00800 #ifndef TOLUA_RELEASE
00801 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'type'",NULL);
00802 #endif
00803 {
00804 const char* tolua_ret = (const char*) self->type();
00805 tolua_pushstring(tolua_S,(const char*)tolua_ret);
00806 }
00807 }
00808 return 1;
00809 #ifndef TOLUA_RELEASE
00810 tolua_lerror:
00811 tolua_error(tolua_S,"#ferror in function 'type'.",&tolua_err);
00812 return 0;
00813 #endif
00814 }
00815 #endif //#ifndef TOLUA_DISABLE
00816
00817
00818 #ifndef TOLUA_DISABLE_tolua_interfaces_LedInterface_fawkes_LedInterface_id00
00819 static int tolua_interfaces_LedInterface_fawkes_LedInterface_id00(lua_State* tolua_S)
00820 {
00821 #ifndef TOLUA_RELEASE
00822 tolua_Error tolua_err;
00823 if (
00824 !tolua_isusertype(tolua_S,1,"const fawkes::LedInterface",0,&tolua_err) ||
00825 !tolua_isnoobj(tolua_S,2,&tolua_err)
00826 )
00827 goto tolua_lerror;
00828 else
00829 #endif
00830 {
00831 const fawkes::LedInterface* self = (const fawkes::LedInterface*) tolua_tousertype(tolua_S,1,0);
00832 #ifndef TOLUA_RELEASE
00833 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'id'",NULL);
00834 #endif
00835 {
00836 const char* tolua_ret = (const char*) self->id();
00837 tolua_pushstring(tolua_S,(const char*)tolua_ret);
00838 }
00839 }
00840 return 1;
00841 #ifndef TOLUA_RELEASE
00842 tolua_lerror:
00843 tolua_error(tolua_S,"#ferror in function 'id'.",&tolua_err);
00844 return 0;
00845 #endif
00846 }
00847 #endif //#ifndef TOLUA_DISABLE
00848
00849
00850 #ifndef TOLUA_DISABLE_tolua_interfaces_LedInterface_fawkes_LedInterface_uid00
00851 static int tolua_interfaces_LedInterface_fawkes_LedInterface_uid00(lua_State* tolua_S)
00852 {
00853 #ifndef TOLUA_RELEASE
00854 tolua_Error tolua_err;
00855 if (
00856 !tolua_isusertype(tolua_S,1,"const fawkes::LedInterface",0,&tolua_err) ||
00857 !tolua_isnoobj(tolua_S,2,&tolua_err)
00858 )
00859 goto tolua_lerror;
00860 else
00861 #endif
00862 {
00863 const fawkes::LedInterface* self = (const fawkes::LedInterface*) tolua_tousertype(tolua_S,1,0);
00864 #ifndef TOLUA_RELEASE
00865 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'uid'",NULL);
00866 #endif
00867 {
00868 const char* tolua_ret = (const char*) self->uid();
00869 tolua_pushstring(tolua_S,(const char*)tolua_ret);
00870 }
00871 }
00872 return 1;
00873 #ifndef TOLUA_RELEASE
00874 tolua_lerror:
00875 tolua_error(tolua_S,"#ferror in function 'uid'.",&tolua_err);
00876 return 0;
00877 #endif
00878 }
00879 #endif //#ifndef TOLUA_DISABLE
00880
00881
00882 #ifndef TOLUA_DISABLE_tolua_interfaces_LedInterface_fawkes_LedInterface_serial00
00883 static int tolua_interfaces_LedInterface_fawkes_LedInterface_serial00(lua_State* tolua_S)
00884 {
00885 #ifndef TOLUA_RELEASE
00886 tolua_Error tolua_err;
00887 if (
00888 !tolua_isusertype(tolua_S,1,"const fawkes::LedInterface",0,&tolua_err) ||
00889 !tolua_isnoobj(tolua_S,2,&tolua_err)
00890 )
00891 goto tolua_lerror;
00892 else
00893 #endif
00894 {
00895 const fawkes::LedInterface* self = (const fawkes::LedInterface*) tolua_tousertype(tolua_S,1,0);
00896 #ifndef TOLUA_RELEASE
00897 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'serial'",NULL);
00898 #endif
00899 {
00900 unsigned int tolua_ret = (unsigned int) self->serial();
00901 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00902 }
00903 }
00904 return 1;
00905 #ifndef TOLUA_RELEASE
00906 tolua_lerror:
00907 tolua_error(tolua_S,"#ferror in function 'serial'.",&tolua_err);
00908 return 0;
00909 #endif
00910 }
00911 #endif //#ifndef TOLUA_DISABLE
00912
00913
00914 #ifndef TOLUA_DISABLE_tolua_interfaces_LedInterface_fawkes_LedInterface_mem_serial00
00915 static int tolua_interfaces_LedInterface_fawkes_LedInterface_mem_serial00(lua_State* tolua_S)
00916 {
00917 #ifndef TOLUA_RELEASE
00918 tolua_Error tolua_err;
00919 if (
00920 !tolua_isusertype(tolua_S,1,"const fawkes::LedInterface",0,&tolua_err) ||
00921 !tolua_isnoobj(tolua_S,2,&tolua_err)
00922 )
00923 goto tolua_lerror;
00924 else
00925 #endif
00926 {
00927 const fawkes::LedInterface* self = (const fawkes::LedInterface*) tolua_tousertype(tolua_S,1,0);
00928 #ifndef TOLUA_RELEASE
00929 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'mem_serial'",NULL);
00930 #endif
00931 {
00932 unsigned int tolua_ret = (unsigned int) self->mem_serial();
00933 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00934 }
00935 }
00936 return 1;
00937 #ifndef TOLUA_RELEASE
00938 tolua_lerror:
00939 tolua_error(tolua_S,"#ferror in function 'mem_serial'.",&tolua_err);
00940 return 0;
00941 #endif
00942 }
00943 #endif //#ifndef TOLUA_DISABLE
00944
00945
00946 #ifndef TOLUA_DISABLE_tolua_interfaces_LedInterface_fawkes_LedInterface__eq00
00947 static int tolua_interfaces_LedInterface_fawkes_LedInterface__eq00(lua_State* tolua_S)
00948 {
00949 #ifndef TOLUA_RELEASE
00950 tolua_Error tolua_err;
00951 if (
00952 !tolua_isusertype(tolua_S,1,"const fawkes::LedInterface",0,&tolua_err) ||
00953 !tolua_isusertype(tolua_S,2,"Interface",0,&tolua_err) ||
00954 !tolua_isnoobj(tolua_S,3,&tolua_err)
00955 )
00956 goto tolua_lerror;
00957 else
00958 #endif
00959 {
00960 const fawkes::LedInterface* self = (const fawkes::LedInterface*) tolua_tousertype(tolua_S,1,0);
00961 Interface* comp = ((Interface*) tolua_tousertype(tolua_S,2,0));
00962 #ifndef TOLUA_RELEASE
00963 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='",NULL);
00964 #endif
00965 {
00966 bool tolua_ret = (bool) self->operator==(*comp);
00967 tolua_pushboolean(tolua_S,(bool)tolua_ret);
00968 }
00969 }
00970 return 1;
00971 #ifndef TOLUA_RELEASE
00972 tolua_lerror:
00973 tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err);
00974 return 0;
00975 #endif
00976 }
00977 #endif //#ifndef TOLUA_DISABLE
00978
00979
00980 #ifndef TOLUA_DISABLE_tolua_interfaces_LedInterface_fawkes_LedInterface_hash00
00981 static int tolua_interfaces_LedInterface_fawkes_LedInterface_hash00(lua_State* tolua_S)
00982 {
00983 #ifndef TOLUA_RELEASE
00984 tolua_Error tolua_err;
00985 if (
00986 !tolua_isusertype(tolua_S,1,"const fawkes::LedInterface",0,&tolua_err) ||
00987 !tolua_isnoobj(tolua_S,2,&tolua_err)
00988 )
00989 goto tolua_lerror;
00990 else
00991 #endif
00992 {
00993 const fawkes::LedInterface* self = (const fawkes::LedInterface*) tolua_tousertype(tolua_S,1,0);
00994 #ifndef TOLUA_RELEASE
00995 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash'",NULL);
00996 #endif
00997 {
00998 unsigned const char* tolua_ret = ( unsigned const char*) self->hash();
00999 tolua_pushstring(tolua_S,(const char*)tolua_ret);
01000 }
01001 }
01002 return 1;
01003 #ifndef TOLUA_RELEASE
01004 tolua_lerror:
01005 tolua_error(tolua_S,"#ferror in function 'hash'.",&tolua_err);
01006 return 0;
01007 #endif
01008 }
01009 #endif //#ifndef TOLUA_DISABLE
01010
01011
01012 #ifndef TOLUA_DISABLE_tolua_interfaces_LedInterface_fawkes_LedInterface_hash_size00
01013 static int tolua_interfaces_LedInterface_fawkes_LedInterface_hash_size00(lua_State* tolua_S)
01014 {
01015 #ifndef TOLUA_RELEASE
01016 tolua_Error tolua_err;
01017 if (
01018 !tolua_isusertype(tolua_S,1,"const fawkes::LedInterface",0,&tolua_err) ||
01019 !tolua_isnoobj(tolua_S,2,&tolua_err)
01020 )
01021 goto tolua_lerror;
01022 else
01023 #endif
01024 {
01025 const fawkes::LedInterface* self = (const fawkes::LedInterface*) tolua_tousertype(tolua_S,1,0);
01026 #ifndef TOLUA_RELEASE
01027 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash_size'",NULL);
01028 #endif
01029 {
01030 int tolua_ret = (int) self->hash_size();
01031 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01032 }
01033 }
01034 return 1;
01035 #ifndef TOLUA_RELEASE
01036 tolua_lerror:
01037 tolua_error(tolua_S,"#ferror in function 'hash_size'.",&tolua_err);
01038 return 0;
01039 #endif
01040 }
01041 #endif //#ifndef TOLUA_DISABLE
01042
01043
01044 #ifndef TOLUA_DISABLE_tolua_interfaces_LedInterface_fawkes_LedInterface_hash_printable00
01045 static int tolua_interfaces_LedInterface_fawkes_LedInterface_hash_printable00(lua_State* tolua_S)
01046 {
01047 #ifndef TOLUA_RELEASE
01048 tolua_Error tolua_err;
01049 if (
01050 !tolua_isusertype(tolua_S,1,"const fawkes::LedInterface",0,&tolua_err) ||
01051 !tolua_isnoobj(tolua_S,2,&tolua_err)
01052 )
01053 goto tolua_lerror;
01054 else
01055 #endif
01056 {
01057 const fawkes::LedInterface* self = (const fawkes::LedInterface*) tolua_tousertype(tolua_S,1,0);
01058 #ifndef TOLUA_RELEASE
01059 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash_printable'",NULL);
01060 #endif
01061 {
01062 const char* tolua_ret = (const char*) self->hash_printable();
01063 tolua_pushstring(tolua_S,(const char*)tolua_ret);
01064 }
01065 }
01066 return 1;
01067 #ifndef TOLUA_RELEASE
01068 tolua_lerror:
01069 tolua_error(tolua_S,"#ferror in function 'hash_printable'.",&tolua_err);
01070 return 0;
01071 #endif
01072 }
01073 #endif //#ifndef TOLUA_DISABLE
01074
01075
01076 #ifndef TOLUA_DISABLE_tolua_interfaces_LedInterface_fawkes_LedInterface_is_writer00
01077 static int tolua_interfaces_LedInterface_fawkes_LedInterface_is_writer00(lua_State* tolua_S)
01078 {
01079 #ifndef TOLUA_RELEASE
01080 tolua_Error tolua_err;
01081 if (
01082 !tolua_isusertype(tolua_S,1,"const fawkes::LedInterface",0,&tolua_err) ||
01083 !tolua_isnoobj(tolua_S,2,&tolua_err)
01084 )
01085 goto tolua_lerror;
01086 else
01087 #endif
01088 {
01089 const fawkes::LedInterface* self = (const fawkes::LedInterface*) tolua_tousertype(tolua_S,1,0);
01090 #ifndef TOLUA_RELEASE
01091 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_writer'",NULL);
01092 #endif
01093 {
01094 bool tolua_ret = (bool) self->is_writer();
01095 tolua_pushboolean(tolua_S,(bool)tolua_ret);
01096 }
01097 }
01098 return 1;
01099 #ifndef TOLUA_RELEASE
01100 tolua_lerror:
01101 tolua_error(tolua_S,"#ferror in function 'is_writer'.",&tolua_err);
01102 return 0;
01103 #endif
01104 }
01105 #endif //#ifndef TOLUA_DISABLE
01106
01107
01108 #ifndef TOLUA_DISABLE_tolua_interfaces_LedInterface_fawkes_LedInterface_set_from_chunk00
01109 static int tolua_interfaces_LedInterface_fawkes_LedInterface_set_from_chunk00(lua_State* tolua_S)
01110 {
01111 #ifndef TOLUA_RELEASE
01112 tolua_Error tolua_err;
01113 if (
01114 !tolua_isusertype(tolua_S,1,"fawkes::LedInterface",0,&tolua_err) ||
01115 !tolua_isuserdata(tolua_S,2,0,&tolua_err) ||
01116 !tolua_isnoobj(tolua_S,3,&tolua_err)
01117 )
01118 goto tolua_lerror;
01119 else
01120 #endif
01121 {
01122 fawkes::LedInterface* self = (fawkes::LedInterface*) tolua_tousertype(tolua_S,1,0);
01123 void* chunk = ((void*) tolua_touserdata(tolua_S,2,0));
01124 #ifndef TOLUA_RELEASE
01125 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_from_chunk'",NULL);
01126 #endif
01127 {
01128 self->set_from_chunk(chunk);
01129 }
01130 }
01131 return 0;
01132 #ifndef TOLUA_RELEASE
01133 tolua_lerror:
01134 tolua_error(tolua_S,"#ferror in function 'set_from_chunk'.",&tolua_err);
01135 return 0;
01136 #endif
01137 }
01138 #endif //#ifndef TOLUA_DISABLE
01139
01140
01141 #ifndef TOLUA_DISABLE_tolua_interfaces_LedInterface_fawkes_LedInterface_create_message00
01142 static int tolua_interfaces_LedInterface_fawkes_LedInterface_create_message00(lua_State* tolua_S)
01143 {
01144 #ifndef TOLUA_RELEASE
01145 tolua_Error tolua_err;
01146 if (
01147 !tolua_isusertype(tolua_S,1,"const fawkes::LedInterface",0,&tolua_err) ||
01148 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
01149 !tolua_isnoobj(tolua_S,3,&tolua_err)
01150 )
01151 goto tolua_lerror;
01152 else
01153 #endif
01154 {
01155 const fawkes::LedInterface* self = (const fawkes::LedInterface*) tolua_tousertype(tolua_S,1,0);
01156 const char* type = ((const char*) tolua_tostring(tolua_S,2,0));
01157 #ifndef TOLUA_RELEASE
01158 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'create_message'",NULL);
01159 #endif
01160 {
01161 Message* tolua_ret = (Message*) self->create_message(type);
01162 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Message");
01163 }
01164 }
01165 return 1;
01166 #ifndef TOLUA_RELEASE
01167 tolua_lerror:
01168 tolua_error(tolua_S,"#ferror in function 'create_message'.",&tolua_err);
01169 return 0;
01170 #endif
01171 }
01172 #endif //#ifndef TOLUA_DISABLE
01173
01174
01175 #ifndef TOLUA_DISABLE_tolua_interfaces_LedInterface_fawkes_LedInterface_read00
01176 static int tolua_interfaces_LedInterface_fawkes_LedInterface_read00(lua_State* tolua_S)
01177 {
01178 #ifndef TOLUA_RELEASE
01179 tolua_Error tolua_err;
01180 if (
01181 !tolua_isusertype(tolua_S,1,"fawkes::LedInterface",0,&tolua_err) ||
01182 !tolua_isnoobj(tolua_S,2,&tolua_err)
01183 )
01184 goto tolua_lerror;
01185 else
01186 #endif
01187 {
01188 fawkes::LedInterface* self = (fawkes::LedInterface*) tolua_tousertype(tolua_S,1,0);
01189 #ifndef TOLUA_RELEASE
01190 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'read'",NULL);
01191 #endif
01192 {
01193 self->read();
01194 }
01195 }
01196 return 0;
01197 #ifndef TOLUA_RELEASE
01198 tolua_lerror:
01199 tolua_error(tolua_S,"#ferror in function 'read'.",&tolua_err);
01200 return 0;
01201 #endif
01202 }
01203 #endif //#ifndef TOLUA_DISABLE
01204
01205
01206 #ifndef TOLUA_DISABLE_tolua_interfaces_LedInterface_fawkes_LedInterface_write00
01207 static int tolua_interfaces_LedInterface_fawkes_LedInterface_write00(lua_State* tolua_S)
01208 {
01209 #ifndef TOLUA_RELEASE
01210 tolua_Error tolua_err;
01211 if (
01212 !tolua_isusertype(tolua_S,1,"fawkes::LedInterface",0,&tolua_err) ||
01213 !tolua_isnoobj(tolua_S,2,&tolua_err)
01214 )
01215 goto tolua_lerror;
01216 else
01217 #endif
01218 {
01219 fawkes::LedInterface* self = (fawkes::LedInterface*) tolua_tousertype(tolua_S,1,0);
01220 #ifndef TOLUA_RELEASE
01221 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'write'",NULL);
01222 #endif
01223 {
01224 self->write();
01225 }
01226 }
01227 return 0;
01228 #ifndef TOLUA_RELEASE
01229 tolua_lerror:
01230 tolua_error(tolua_S,"#ferror in function 'write'.",&tolua_err);
01231 return 0;
01232 #endif
01233 }
01234 #endif //#ifndef TOLUA_DISABLE
01235
01236
01237 #ifndef TOLUA_DISABLE_tolua_interfaces_LedInterface_fawkes_LedInterface_has_writer00
01238 static int tolua_interfaces_LedInterface_fawkes_LedInterface_has_writer00(lua_State* tolua_S)
01239 {
01240 #ifndef TOLUA_RELEASE
01241 tolua_Error tolua_err;
01242 if (
01243 !tolua_isusertype(tolua_S,1,"const fawkes::LedInterface",0,&tolua_err) ||
01244 !tolua_isnoobj(tolua_S,2,&tolua_err)
01245 )
01246 goto tolua_lerror;
01247 else
01248 #endif
01249 {
01250 const fawkes::LedInterface* self = (const fawkes::LedInterface*) tolua_tousertype(tolua_S,1,0);
01251 #ifndef TOLUA_RELEASE
01252 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'has_writer'",NULL);
01253 #endif
01254 {
01255 bool tolua_ret = (bool) self->has_writer();
01256 tolua_pushboolean(tolua_S,(bool)tolua_ret);
01257 }
01258 }
01259 return 1;
01260 #ifndef TOLUA_RELEASE
01261 tolua_lerror:
01262 tolua_error(tolua_S,"#ferror in function 'has_writer'.",&tolua_err);
01263 return 0;
01264 #endif
01265 }
01266 #endif //#ifndef TOLUA_DISABLE
01267
01268
01269 #ifndef TOLUA_DISABLE_tolua_interfaces_LedInterface_fawkes_LedInterface_num_readers00
01270 static int tolua_interfaces_LedInterface_fawkes_LedInterface_num_readers00(lua_State* tolua_S)
01271 {
01272 #ifndef TOLUA_RELEASE
01273 tolua_Error tolua_err;
01274 if (
01275 !tolua_isusertype(tolua_S,1,"const fawkes::LedInterface",0,&tolua_err) ||
01276 !tolua_isnoobj(tolua_S,2,&tolua_err)
01277 )
01278 goto tolua_lerror;
01279 else
01280 #endif
01281 {
01282 const fawkes::LedInterface* self = (const fawkes::LedInterface*) tolua_tousertype(tolua_S,1,0);
01283 #ifndef TOLUA_RELEASE
01284 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'num_readers'",NULL);
01285 #endif
01286 {
01287 unsigned int tolua_ret = (unsigned int) self->num_readers();
01288 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01289 }
01290 }
01291 return 1;
01292 #ifndef TOLUA_RELEASE
01293 tolua_lerror:
01294 tolua_error(tolua_S,"#ferror in function 'num_readers'.",&tolua_err);
01295 return 0;
01296 #endif
01297 }
01298 #endif //#ifndef TOLUA_DISABLE
01299
01300
01301 #ifndef TOLUA_DISABLE_tolua_interfaces_LedInterface_fawkes_LedInterface_msgq_enqueue_copy00
01302 static int tolua_interfaces_LedInterface_fawkes_LedInterface_msgq_enqueue_copy00(lua_State* tolua_S)
01303 {
01304 #ifndef TOLUA_RELEASE
01305 tolua_Error tolua_err;
01306 if (
01307 !tolua_isusertype(tolua_S,1,"fawkes::LedInterface",0,&tolua_err) ||
01308 !tolua_isusertype(tolua_S,2,"Message",0,&tolua_err) ||
01309 !tolua_isnoobj(tolua_S,3,&tolua_err)
01310 )
01311 goto tolua_lerror;
01312 else
01313 #endif
01314 {
01315 fawkes::LedInterface* self = (fawkes::LedInterface*) tolua_tousertype(tolua_S,1,0);
01316 Message* message = ((Message*) tolua_tousertype(tolua_S,2,0));
01317 #ifndef TOLUA_RELEASE
01318 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_enqueue_copy'",NULL);
01319 #endif
01320 {
01321 unsigned int tolua_ret = (unsigned int) self->msgq_enqueue_copy(message);
01322 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01323 }
01324 }
01325 return 1;
01326 #ifndef TOLUA_RELEASE
01327 tolua_lerror:
01328 tolua_error(tolua_S,"#ferror in function 'msgq_enqueue_copy'.",&tolua_err);
01329 return 0;
01330 #endif
01331 }
01332 #endif //#ifndef TOLUA_DISABLE
01333
01334
01335 #ifndef TOLUA_DISABLE_tolua_interfaces_LedInterface_fawkes_LedInterface_msgq_remove00
01336 static int tolua_interfaces_LedInterface_fawkes_LedInterface_msgq_remove00(lua_State* tolua_S)
01337 {
01338 #ifndef TOLUA_RELEASE
01339 tolua_Error tolua_err;
01340 if (
01341 !tolua_isusertype(tolua_S,1,"fawkes::LedInterface",0,&tolua_err) ||
01342 !tolua_isusertype(tolua_S,2,"Message",0,&tolua_err) ||
01343 !tolua_isnoobj(tolua_S,3,&tolua_err)
01344 )
01345 goto tolua_lerror;
01346 else
01347 #endif
01348 {
01349 fawkes::LedInterface* self = (fawkes::LedInterface*) tolua_tousertype(tolua_S,1,0);
01350 Message* message = ((Message*) tolua_tousertype(tolua_S,2,0));
01351 #ifndef TOLUA_RELEASE
01352 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_remove'",NULL);
01353 #endif
01354 {
01355 self->msgq_remove(message);
01356 }
01357 }
01358 return 0;
01359 #ifndef TOLUA_RELEASE
01360 tolua_lerror:
01361 tolua_error(tolua_S,"#ferror in function 'msgq_remove'.",&tolua_err);
01362 return 0;
01363 #endif
01364 }
01365 #endif //#ifndef TOLUA_DISABLE
01366
01367
01368 #ifndef TOLUA_DISABLE_tolua_interfaces_LedInterface_fawkes_LedInterface_msgq_remove01
01369 static int tolua_interfaces_LedInterface_fawkes_LedInterface_msgq_remove01(lua_State* tolua_S)
01370 {
01371 tolua_Error tolua_err;
01372 if (
01373 !tolua_isusertype(tolua_S,1,"fawkes::LedInterface",0,&tolua_err) ||
01374 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01375 !tolua_isnoobj(tolua_S,3,&tolua_err)
01376 )
01377 goto tolua_lerror;
01378 else
01379 {
01380 fawkes::LedInterface* self = (fawkes::LedInterface*) tolua_tousertype(tolua_S,1,0);
01381 unsigned int message_id = ((unsigned int) tolua_tonumber(tolua_S,2,0));
01382 #ifndef TOLUA_RELEASE
01383 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_remove'",NULL);
01384 #endif
01385 {
01386 self->msgq_remove(message_id);
01387 }
01388 }
01389 return 0;
01390 tolua_lerror:
01391 return tolua_interfaces_LedInterface_fawkes_LedInterface_msgq_remove00(tolua_S);
01392 }
01393 #endif //#ifndef TOLUA_DISABLE
01394
01395
01396 #ifndef TOLUA_DISABLE_tolua_interfaces_LedInterface_fawkes_LedInterface_msgq_size00
01397 static int tolua_interfaces_LedInterface_fawkes_LedInterface_msgq_size00(lua_State* tolua_S)
01398 {
01399 #ifndef TOLUA_RELEASE
01400 tolua_Error tolua_err;
01401 if (
01402 !tolua_isusertype(tolua_S,1,"fawkes::LedInterface",0,&tolua_err) ||
01403 !tolua_isnoobj(tolua_S,2,&tolua_err)
01404 )
01405 goto tolua_lerror;
01406 else
01407 #endif
01408 {
01409 fawkes::LedInterface* self = (fawkes::LedInterface*) tolua_tousertype(tolua_S,1,0);
01410 #ifndef TOLUA_RELEASE
01411 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_size'",NULL);
01412 #endif
01413 {
01414 unsigned int tolua_ret = (unsigned int) self->msgq_size();
01415 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01416 }
01417 }
01418 return 1;
01419 #ifndef TOLUA_RELEASE
01420 tolua_lerror:
01421 tolua_error(tolua_S,"#ferror in function 'msgq_size'.",&tolua_err);
01422 return 0;
01423 #endif
01424 }
01425 #endif //#ifndef TOLUA_DISABLE
01426
01427
01428 #ifndef TOLUA_DISABLE_tolua_interfaces_LedInterface_fawkes_LedInterface_msgq_flush00
01429 static int tolua_interfaces_LedInterface_fawkes_LedInterface_msgq_flush00(lua_State* tolua_S)
01430 {
01431 #ifndef TOLUA_RELEASE
01432 tolua_Error tolua_err;
01433 if (
01434 !tolua_isusertype(tolua_S,1,"fawkes::LedInterface",0,&tolua_err) ||
01435 !tolua_isnoobj(tolua_S,2,&tolua_err)
01436 )
01437 goto tolua_lerror;
01438 else
01439 #endif
01440 {
01441 fawkes::LedInterface* self = (fawkes::LedInterface*) tolua_tousertype(tolua_S,1,0);
01442 #ifndef TOLUA_RELEASE
01443 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_flush'",NULL);
01444 #endif
01445 {
01446 self->msgq_flush();
01447 }
01448 }
01449 return 0;
01450 #ifndef TOLUA_RELEASE
01451 tolua_lerror:
01452 tolua_error(tolua_S,"#ferror in function 'msgq_flush'.",&tolua_err);
01453 return 0;
01454 #endif
01455 }
01456 #endif //#ifndef TOLUA_DISABLE
01457
01458
01459 #ifndef TOLUA_DISABLE_tolua_interfaces_LedInterface_fawkes_LedInterface_msgq_lock00
01460 static int tolua_interfaces_LedInterface_fawkes_LedInterface_msgq_lock00(lua_State* tolua_S)
01461 {
01462 #ifndef TOLUA_RELEASE
01463 tolua_Error tolua_err;
01464 if (
01465 !tolua_isusertype(tolua_S,1,"fawkes::LedInterface",0,&tolua_err) ||
01466 !tolua_isnoobj(tolua_S,2,&tolua_err)
01467 )
01468 goto tolua_lerror;
01469 else
01470 #endif
01471 {
01472 fawkes::LedInterface* self = (fawkes::LedInterface*) tolua_tousertype(tolua_S,1,0);
01473 #ifndef TOLUA_RELEASE
01474 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_lock'",NULL);
01475 #endif
01476 {
01477 self->msgq_lock();
01478 }
01479 }
01480 return 0;
01481 #ifndef TOLUA_RELEASE
01482 tolua_lerror:
01483 tolua_error(tolua_S,"#ferror in function 'msgq_lock'.",&tolua_err);
01484 return 0;
01485 #endif
01486 }
01487 #endif //#ifndef TOLUA_DISABLE
01488
01489
01490 #ifndef TOLUA_DISABLE_tolua_interfaces_LedInterface_fawkes_LedInterface_msgq_try_lock00
01491 static int tolua_interfaces_LedInterface_fawkes_LedInterface_msgq_try_lock00(lua_State* tolua_S)
01492 {
01493 #ifndef TOLUA_RELEASE
01494 tolua_Error tolua_err;
01495 if (
01496 !tolua_isusertype(tolua_S,1,"fawkes::LedInterface",0,&tolua_err) ||
01497 !tolua_isnoobj(tolua_S,2,&tolua_err)
01498 )
01499 goto tolua_lerror;
01500 else
01501 #endif
01502 {
01503 fawkes::LedInterface* self = (fawkes::LedInterface*) tolua_tousertype(tolua_S,1,0);
01504 #ifndef TOLUA_RELEASE
01505 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_try_lock'",NULL);
01506 #endif
01507 {
01508 bool tolua_ret = (bool) self->msgq_try_lock();
01509 tolua_pushboolean(tolua_S,(bool)tolua_ret);
01510 }
01511 }
01512 return 1;
01513 #ifndef TOLUA_RELEASE
01514 tolua_lerror:
01515 tolua_error(tolua_S,"#ferror in function 'msgq_try_lock'.",&tolua_err);
01516 return 0;
01517 #endif
01518 }
01519 #endif //#ifndef TOLUA_DISABLE
01520
01521
01522 #ifndef TOLUA_DISABLE_tolua_interfaces_LedInterface_fawkes_LedInterface_msgq_unlock00
01523 static int tolua_interfaces_LedInterface_fawkes_LedInterface_msgq_unlock00(lua_State* tolua_S)
01524 {
01525 #ifndef TOLUA_RELEASE
01526 tolua_Error tolua_err;
01527 if (
01528 !tolua_isusertype(tolua_S,1,"fawkes::LedInterface",0,&tolua_err) ||
01529 !tolua_isnoobj(tolua_S,2,&tolua_err)
01530 )
01531 goto tolua_lerror;
01532 else
01533 #endif
01534 {
01535 fawkes::LedInterface* self = (fawkes::LedInterface*) tolua_tousertype(tolua_S,1,0);
01536 #ifndef TOLUA_RELEASE
01537 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_unlock'",NULL);
01538 #endif
01539 {
01540 self->msgq_unlock();
01541 }
01542 }
01543 return 0;
01544 #ifndef TOLUA_RELEASE
01545 tolua_lerror:
01546 tolua_error(tolua_S,"#ferror in function 'msgq_unlock'.",&tolua_err);
01547 return 0;
01548 #endif
01549 }
01550 #endif //#ifndef TOLUA_DISABLE
01551
01552
01553 #ifndef TOLUA_DISABLE_tolua_interfaces_LedInterface_fawkes_LedInterface_msgq_pop00
01554 static int tolua_interfaces_LedInterface_fawkes_LedInterface_msgq_pop00(lua_State* tolua_S)
01555 {
01556 #ifndef TOLUA_RELEASE
01557 tolua_Error tolua_err;
01558 if (
01559 !tolua_isusertype(tolua_S,1,"fawkes::LedInterface",0,&tolua_err) ||
01560 !tolua_isnoobj(tolua_S,2,&tolua_err)
01561 )
01562 goto tolua_lerror;
01563 else
01564 #endif
01565 {
01566 fawkes::LedInterface* self = (fawkes::LedInterface*) tolua_tousertype(tolua_S,1,0);
01567 #ifndef TOLUA_RELEASE
01568 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_pop'",NULL);
01569 #endif
01570 {
01571 self->msgq_pop();
01572 }
01573 }
01574 return 0;
01575 #ifndef TOLUA_RELEASE
01576 tolua_lerror:
01577 tolua_error(tolua_S,"#ferror in function 'msgq_pop'.",&tolua_err);
01578 return 0;
01579 #endif
01580 }
01581 #endif //#ifndef TOLUA_DISABLE
01582
01583
01584 #ifndef TOLUA_DISABLE_tolua_interfaces_LedInterface_fawkes_LedInterface_msgq_first00
01585 static int tolua_interfaces_LedInterface_fawkes_LedInterface_msgq_first00(lua_State* tolua_S)
01586 {
01587 #ifndef TOLUA_RELEASE
01588 tolua_Error tolua_err;
01589 if (
01590 !tolua_isusertype(tolua_S,1,"fawkes::LedInterface",0,&tolua_err) ||
01591 !tolua_isnoobj(tolua_S,2,&tolua_err)
01592 )
01593 goto tolua_lerror;
01594 else
01595 #endif
01596 {
01597 fawkes::LedInterface* self = (fawkes::LedInterface*) tolua_tousertype(tolua_S,1,0);
01598 #ifndef TOLUA_RELEASE
01599 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_first'",NULL);
01600 #endif
01601 {
01602 Message* tolua_ret = (Message*) self->msgq_first();
01603 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Message");
01604 }
01605 }
01606 return 1;
01607 #ifndef TOLUA_RELEASE
01608 tolua_lerror:
01609 tolua_error(tolua_S,"#ferror in function 'msgq_first'.",&tolua_err);
01610 return 0;
01611 #endif
01612 }
01613 #endif //#ifndef TOLUA_DISABLE
01614
01615
01616 #ifndef TOLUA_DISABLE_tolua_interfaces_LedInterface_fawkes_LedInterface_msgq_empty00
01617 static int tolua_interfaces_LedInterface_fawkes_LedInterface_msgq_empty00(lua_State* tolua_S)
01618 {
01619 #ifndef TOLUA_RELEASE
01620 tolua_Error tolua_err;
01621 if (
01622 !tolua_isusertype(tolua_S,1,"fawkes::LedInterface",0,&tolua_err) ||
01623 !tolua_isnoobj(tolua_S,2,&tolua_err)
01624 )
01625 goto tolua_lerror;
01626 else
01627 #endif
01628 {
01629 fawkes::LedInterface* self = (fawkes::LedInterface*) tolua_tousertype(tolua_S,1,0);
01630 #ifndef TOLUA_RELEASE
01631 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_empty'",NULL);
01632 #endif
01633 {
01634 bool tolua_ret = (bool) self->msgq_empty();
01635 tolua_pushboolean(tolua_S,(bool)tolua_ret);
01636 }
01637 }
01638 return 1;
01639 #ifndef TOLUA_RELEASE
01640 tolua_lerror:
01641 tolua_error(tolua_S,"#ferror in function 'msgq_empty'.",&tolua_err);
01642 return 0;
01643 #endif
01644 }
01645 #endif //#ifndef TOLUA_DISABLE
01646
01647
01648 TOLUA_API int tolua_interfaces_LedInterface_open (lua_State* tolua_S)
01649 {
01650 tolua_open(tolua_S);
01651 tolua_reg_types(tolua_S);
01652 tolua_module(tolua_S,NULL,0);
01653 tolua_beginmodule(tolua_S,NULL);
01654 tolua_module(tolua_S,"fawkes",0);
01655 tolua_beginmodule(tolua_S,"fawkes");
01656 tolua_cclass(tolua_S,"LedInterface","fawkes::LedInterface","Interface",NULL);
01657 tolua_beginmodule(tolua_S,"LedInterface");
01658 tolua_variable(tolua_S,"ON",tolua_get_fawkes__LedInterface_ON,NULL);
01659 tolua_variable(tolua_S,"OFF",tolua_get_fawkes__LedInterface_OFF,NULL);
01660 #ifdef __cplusplus
01661 tolua_cclass(tolua_S,"SetIntensityMessage","fawkes::LedInterface::SetIntensityMessage","Message",tolua_collect_fawkes__LedInterface__SetIntensityMessage);
01662 #else
01663 tolua_cclass(tolua_S,"SetIntensityMessage","fawkes::LedInterface::SetIntensityMessage","Message",NULL);
01664 #endif
01665 tolua_beginmodule(tolua_S,"SetIntensityMessage");
01666 tolua_function(tolua_S,"new",tolua_interfaces_LedInterface_fawkes_LedInterface_SetIntensityMessage_new00);
01667 tolua_function(tolua_S,"new_local",tolua_interfaces_LedInterface_fawkes_LedInterface_SetIntensityMessage_new00_local);
01668 tolua_function(tolua_S,".call",tolua_interfaces_LedInterface_fawkes_LedInterface_SetIntensityMessage_new00_local);
01669 tolua_function(tolua_S,"new",tolua_interfaces_LedInterface_fawkes_LedInterface_SetIntensityMessage_new01);
01670 tolua_function(tolua_S,"new_local",tolua_interfaces_LedInterface_fawkes_LedInterface_SetIntensityMessage_new01_local);
01671 tolua_function(tolua_S,".call",tolua_interfaces_LedInterface_fawkes_LedInterface_SetIntensityMessage_new01_local);
01672 tolua_function(tolua_S,"delete",tolua_interfaces_LedInterface_fawkes_LedInterface_SetIntensityMessage_delete00);
01673 tolua_function(tolua_S,"time_sec",tolua_interfaces_LedInterface_fawkes_LedInterface_SetIntensityMessage_time_sec00);
01674 tolua_function(tolua_S,"set_time_sec",tolua_interfaces_LedInterface_fawkes_LedInterface_SetIntensityMessage_set_time_sec00);
01675 tolua_function(tolua_S,"maxlenof_time_sec",tolua_interfaces_LedInterface_fawkes_LedInterface_SetIntensityMessage_maxlenof_time_sec00);
01676 tolua_function(tolua_S,"intensity",tolua_interfaces_LedInterface_fawkes_LedInterface_SetIntensityMessage_intensity00);
01677 tolua_function(tolua_S,"set_intensity",tolua_interfaces_LedInterface_fawkes_LedInterface_SetIntensityMessage_set_intensity00);
01678 tolua_function(tolua_S,"maxlenof_intensity",tolua_interfaces_LedInterface_fawkes_LedInterface_SetIntensityMessage_maxlenof_intensity00);
01679 tolua_endmodule(tolua_S);
01680 #ifdef __cplusplus
01681 tolua_cclass(tolua_S,"TurnOnMessage","fawkes::LedInterface::TurnOnMessage","Message",tolua_collect_fawkes__LedInterface__TurnOnMessage);
01682 #else
01683 tolua_cclass(tolua_S,"TurnOnMessage","fawkes::LedInterface::TurnOnMessage","Message",NULL);
01684 #endif
01685 tolua_beginmodule(tolua_S,"TurnOnMessage");
01686 tolua_function(tolua_S,"new",tolua_interfaces_LedInterface_fawkes_LedInterface_TurnOnMessage_new00);
01687 tolua_function(tolua_S,"new_local",tolua_interfaces_LedInterface_fawkes_LedInterface_TurnOnMessage_new00_local);
01688 tolua_function(tolua_S,".call",tolua_interfaces_LedInterface_fawkes_LedInterface_TurnOnMessage_new00_local);
01689 tolua_function(tolua_S,"delete",tolua_interfaces_LedInterface_fawkes_LedInterface_TurnOnMessage_delete00);
01690 tolua_endmodule(tolua_S);
01691 #ifdef __cplusplus
01692 tolua_cclass(tolua_S,"TurnOffMessage","fawkes::LedInterface::TurnOffMessage","Message",tolua_collect_fawkes__LedInterface__TurnOffMessage);
01693 #else
01694 tolua_cclass(tolua_S,"TurnOffMessage","fawkes::LedInterface::TurnOffMessage","Message",NULL);
01695 #endif
01696 tolua_beginmodule(tolua_S,"TurnOffMessage");
01697 tolua_function(tolua_S,"new",tolua_interfaces_LedInterface_fawkes_LedInterface_TurnOffMessage_new00);
01698 tolua_function(tolua_S,"new_local",tolua_interfaces_LedInterface_fawkes_LedInterface_TurnOffMessage_new00_local);
01699 tolua_function(tolua_S,".call",tolua_interfaces_LedInterface_fawkes_LedInterface_TurnOffMessage_new00_local);
01700 tolua_function(tolua_S,"delete",tolua_interfaces_LedInterface_fawkes_LedInterface_TurnOffMessage_delete00);
01701 tolua_endmodule(tolua_S);
01702 tolua_function(tolua_S,"intensity",tolua_interfaces_LedInterface_fawkes_LedInterface_intensity00);
01703 tolua_function(tolua_S,"set_intensity",tolua_interfaces_LedInterface_fawkes_LedInterface_set_intensity00);
01704 tolua_function(tolua_S,"maxlenof_intensity",tolua_interfaces_LedInterface_fawkes_LedInterface_maxlenof_intensity00);
01705 tolua_function(tolua_S,"oftype",tolua_interfaces_LedInterface_fawkes_LedInterface_oftype00);
01706 tolua_function(tolua_S,"datachunk",tolua_interfaces_LedInterface_fawkes_LedInterface_datachunk00);
01707 tolua_function(tolua_S,"datasize",tolua_interfaces_LedInterface_fawkes_LedInterface_datasize00);
01708 tolua_function(tolua_S,"type",tolua_interfaces_LedInterface_fawkes_LedInterface_type00);
01709 tolua_function(tolua_S,"id",tolua_interfaces_LedInterface_fawkes_LedInterface_id00);
01710 tolua_function(tolua_S,"uid",tolua_interfaces_LedInterface_fawkes_LedInterface_uid00);
01711 tolua_function(tolua_S,"serial",tolua_interfaces_LedInterface_fawkes_LedInterface_serial00);
01712 tolua_function(tolua_S,"mem_serial",tolua_interfaces_LedInterface_fawkes_LedInterface_mem_serial00);
01713 tolua_function(tolua_S,".eq",tolua_interfaces_LedInterface_fawkes_LedInterface__eq00);
01714 tolua_function(tolua_S,"hash",tolua_interfaces_LedInterface_fawkes_LedInterface_hash00);
01715 tolua_function(tolua_S,"hash_size",tolua_interfaces_LedInterface_fawkes_LedInterface_hash_size00);
01716 tolua_function(tolua_S,"hash_printable",tolua_interfaces_LedInterface_fawkes_LedInterface_hash_printable00);
01717 tolua_function(tolua_S,"is_writer",tolua_interfaces_LedInterface_fawkes_LedInterface_is_writer00);
01718 tolua_function(tolua_S,"set_from_chunk",tolua_interfaces_LedInterface_fawkes_LedInterface_set_from_chunk00);
01719 tolua_function(tolua_S,"create_message",tolua_interfaces_LedInterface_fawkes_LedInterface_create_message00);
01720 tolua_function(tolua_S,"read",tolua_interfaces_LedInterface_fawkes_LedInterface_read00);
01721 tolua_function(tolua_S,"write",tolua_interfaces_LedInterface_fawkes_LedInterface_write00);
01722 tolua_function(tolua_S,"has_writer",tolua_interfaces_LedInterface_fawkes_LedInterface_has_writer00);
01723 tolua_function(tolua_S,"num_readers",tolua_interfaces_LedInterface_fawkes_LedInterface_num_readers00);
01724 tolua_function(tolua_S,"msgq_enqueue_copy",tolua_interfaces_LedInterface_fawkes_LedInterface_msgq_enqueue_copy00);
01725 tolua_function(tolua_S,"msgq_remove",tolua_interfaces_LedInterface_fawkes_LedInterface_msgq_remove00);
01726 tolua_function(tolua_S,"msgq_remove",tolua_interfaces_LedInterface_fawkes_LedInterface_msgq_remove01);
01727 tolua_function(tolua_S,"msgq_size",tolua_interfaces_LedInterface_fawkes_LedInterface_msgq_size00);
01728 tolua_function(tolua_S,"msgq_flush",tolua_interfaces_LedInterface_fawkes_LedInterface_msgq_flush00);
01729 tolua_function(tolua_S,"msgq_lock",tolua_interfaces_LedInterface_fawkes_LedInterface_msgq_lock00);
01730 tolua_function(tolua_S,"msgq_try_lock",tolua_interfaces_LedInterface_fawkes_LedInterface_msgq_try_lock00);
01731 tolua_function(tolua_S,"msgq_unlock",tolua_interfaces_LedInterface_fawkes_LedInterface_msgq_unlock00);
01732 tolua_function(tolua_S,"msgq_pop",tolua_interfaces_LedInterface_fawkes_LedInterface_msgq_pop00);
01733 tolua_function(tolua_S,"msgq_first",tolua_interfaces_LedInterface_fawkes_LedInterface_msgq_first00);
01734 tolua_function(tolua_S,"msgq_empty",tolua_interfaces_LedInterface_fawkes_LedInterface_msgq_empty00);
01735 tolua_endmodule(tolua_S);
01736 tolua_endmodule(tolua_S);
01737 tolua_endmodule(tolua_S);
01738 return 1;
01739 }
01740
01741
01742 extern "C" {
01743 #if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501
01744 TOLUA_API int luaopen_interfaces_LedInterface (lua_State* tolua_S) {
01745 return tolua_interfaces_LedInterface_open(tolua_S);
01746 };
01747 #endif
01748 }
01749
01750
