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