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