BatteryInterface_tolua.cpp

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 

Generated on 1 Mar 2011 for Fawkes API by  doxygen 1.6.1