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