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