LedInterface_tolua.cpp

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