Fawkes API Fawkes Development Version
|
00001 /* 00002 ** Lua binding: interfaces_BatteryInterface 00003 ** Generated automatically by tolua++-1.0.92 00004 */ 00005 /* This program is free software; you can redistribute it and/or modify 00006 * it under the terms of the GNU General Public License as published by 00007 * the Free Software Foundation; either version 2 of the License, or 00008 * (at your option) any later version. A runtime exception applies to 00009 * this software (see LICENSE.GPL_WRE file mentioned below for details). 00010 * 00011 * This program is distributed in the hope that it will be useful, 00012 * but WITHOUT ANY WARRANTY; without even the implied warranty of 00013 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 00014 * GNU Library General Public License for more details. 00015 * 00016 * Read the full text in the LICENSE.GPL_WRE file in the doc directory. 00017 */ 00018 00019 #ifndef __cplusplus 00020 #include "stdlib.h" 00021 #endif 00022 #include "string.h" 00023 00024 #include "tolua++.h" 00025 00026 /* Exported function */ 00027 TOLUA_API int tolua_interfaces_BatteryInterface_open (lua_State* tolua_S); 00028 00029 #include <interfaces/BatteryInterface.h> 00030 using namespace fawkes; 00031 00032 /* function to release collected object via destructor */ 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 /* function to register type */ 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 /* method: new of class PushButtonMessage */ 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 /* method: new_local of class PushButtonMessage */ 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 /* method: delete of class PushButtonMessage */ 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 /* method: new of class SleepMessage */ 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 /* method: new_local of class SleepMessage */ 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 /* method: delete of class SleepMessage */ 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 /* method: current of class fawkes::BatteryInterface */ 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 /* method: set_current of class fawkes::BatteryInterface */ 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 /* method: maxlenof_current of class fawkes::BatteryInterface */ 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 /* method: voltage of class fawkes::BatteryInterface */ 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 /* method: set_voltage of class fawkes::BatteryInterface */ 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 /* method: maxlenof_voltage of class fawkes::BatteryInterface */ 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 /* method: temperature of class fawkes::BatteryInterface */ 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 /* method: set_temperature of class fawkes::BatteryInterface */ 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 /* method: maxlenof_temperature of class fawkes::BatteryInterface */ 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 /* method: absolute_soc of class fawkes::BatteryInterface */ 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 /* method: set_absolute_soc of class fawkes::BatteryInterface */ 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 /* method: maxlenof_absolute_soc of class fawkes::BatteryInterface */ 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 /* method: relative_soc of class fawkes::BatteryInterface */ 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 /* method: set_relative_soc of class fawkes::BatteryInterface */ 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 /* method: maxlenof_relative_soc of class fawkes::BatteryInterface */ 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 /* method: oftype of class fawkes::BatteryInterface */ 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 /* method: datachunk of class fawkes::BatteryInterface */ 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 /* method: datasize of class fawkes::BatteryInterface */ 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 /* method: type of class fawkes::BatteryInterface */ 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 /* method: id of class fawkes::BatteryInterface */ 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 /* method: uid of class fawkes::BatteryInterface */ 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 /* method: serial of class fawkes::BatteryInterface */ 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 /* method: mem_serial of class fawkes::BatteryInterface */ 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 /* method: operator== of class fawkes::BatteryInterface */ 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 /* method: hash of class fawkes::BatteryInterface */ 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 /* method: hash_size of class fawkes::BatteryInterface */ 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 /* method: hash_printable of class fawkes::BatteryInterface */ 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 /* method: is_writer of class fawkes::BatteryInterface */ 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 /* method: set_from_chunk of class fawkes::BatteryInterface */ 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 /* method: create_message of class fawkes::BatteryInterface */ 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 /* method: read of class fawkes::BatteryInterface */ 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 /* method: write of class fawkes::BatteryInterface */ 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 /* method: has_writer of class fawkes::BatteryInterface */ 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 /* method: num_readers of class fawkes::BatteryInterface */ 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 /* method: msgq_enqueue_copy of class fawkes::BatteryInterface */ 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 /* method: msgq_remove of class fawkes::BatteryInterface */ 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 /* method: msgq_remove of class fawkes::BatteryInterface */ 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 /* method: msgq_size of class fawkes::BatteryInterface */ 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 /* method: msgq_flush of class fawkes::BatteryInterface */ 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 /* method: msgq_lock of class fawkes::BatteryInterface */ 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 /* method: msgq_try_lock of class fawkes::BatteryInterface */ 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 /* method: msgq_unlock of class fawkes::BatteryInterface */ 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 /* method: msgq_pop of class fawkes::BatteryInterface */ 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 /* method: msgq_first of class fawkes::BatteryInterface */ 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 /* method: msgq_empty of class fawkes::BatteryInterface */ 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 /* Open function */ 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