Fawkes API  Fawkes Development Version
Roomba500Interface_tolua.cpp
00001 /*
00002 ** Lua binding: interfaces_Roomba500Interface
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_Roomba500Interface_open (lua_State* tolua_S);
00028 
00029 #include <interfaces/Roomba500Interface.h>
00030 using namespace fawkes;
00031 
00032 /* function to release collected object via destructor */
00033 #ifdef __cplusplus
00034 
00035 static int tolua_collect_fawkes__Roomba500Interface__DockMessage (lua_State* tolua_S)
00036 {
00037  fawkes::Roomba500Interface::DockMessage* self = (fawkes::Roomba500Interface::DockMessage*) tolua_tousertype(tolua_S,1,0);
00038         Mtolua_delete(self);
00039         return 0;
00040 }
00041 
00042 static int tolua_collect_fawkes__Roomba500Interface__SetMotorsMessage (lua_State* tolua_S)
00043 {
00044  fawkes::Roomba500Interface::SetMotorsMessage* self = (fawkes::Roomba500Interface::SetMotorsMessage*) tolua_tousertype(tolua_S,1,0);
00045         Mtolua_delete(self);
00046         return 0;
00047 }
00048 
00049 static int tolua_collect_fawkes__Roomba500Interface__DriveMessage (lua_State* tolua_S)
00050 {
00051  fawkes::Roomba500Interface::DriveMessage* self = (fawkes::Roomba500Interface::DriveMessage*) tolua_tousertype(tolua_S,1,0);
00052         Mtolua_delete(self);
00053         return 0;
00054 }
00055 
00056 static int tolua_collect_fawkes__Roomba500Interface__StopMessage (lua_State* tolua_S)
00057 {
00058  fawkes::Roomba500Interface::StopMessage* self = (fawkes::Roomba500Interface::StopMessage*) tolua_tousertype(tolua_S,1,0);
00059         Mtolua_delete(self);
00060         return 0;
00061 }
00062 
00063 static int tolua_collect_fawkes__Roomba500Interface__DriveStraightMessage (lua_State* tolua_S)
00064 {
00065  fawkes::Roomba500Interface::DriveStraightMessage* self = (fawkes::Roomba500Interface::DriveStraightMessage*) tolua_tousertype(tolua_S,1,0);
00066         Mtolua_delete(self);
00067         return 0;
00068 }
00069 
00070 static int tolua_collect_fawkes__Roomba500Interface__SetModeMessage (lua_State* tolua_S)
00071 {
00072  fawkes::Roomba500Interface::SetModeMessage* self = (fawkes::Roomba500Interface::SetModeMessage*) tolua_tousertype(tolua_S,1,0);
00073         Mtolua_delete(self);
00074         return 0;
00075 }
00076 #endif
00077 
00078 
00079 /* function to register type */
00080 static void tolua_reg_types (lua_State* tolua_S)
00081 {
00082  tolua_usertype(tolua_S,"fawkes::Roomba500Interface");
00083  tolua_usertype(tolua_S,"fawkes::Roomba500Interface::SetModeMessage");
00084  tolua_usertype(tolua_S,"fawkes::Roomba500Interface::StopMessage");
00085  tolua_usertype(tolua_S,"Message");
00086  tolua_usertype(tolua_S,"fawkes::Roomba500Interface::DriveMessage");
00087  tolua_usertype(tolua_S,"fawkes::Roomba500Interface::DockMessage");
00088  tolua_usertype(tolua_S,"fawkes::Roomba500Interface::SetMotorsMessage");
00089  tolua_usertype(tolua_S,"fawkes::Roomba500Interface::DriveStraightMessage");
00090  tolua_usertype(tolua_S,"Interface");
00091 }
00092 
00093 /* method: new of class  StopMessage */
00094 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_StopMessage_new00
00095 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_StopMessage_new00(lua_State* tolua_S)
00096 {
00097 #ifndef TOLUA_RELEASE
00098  tolua_Error tolua_err;
00099  if (
00100      !tolua_isusertable(tolua_S,1,"fawkes::Roomba500Interface::StopMessage",0,&tolua_err) ||
00101      !tolua_isnoobj(tolua_S,2,&tolua_err)
00102  )
00103   goto tolua_lerror;
00104  else
00105 #endif
00106  {
00107   {
00108    fawkes::Roomba500Interface::StopMessage* tolua_ret = (fawkes::Roomba500Interface::StopMessage*)  Mtolua_new((fawkes::Roomba500Interface::StopMessage)());
00109     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Roomba500Interface::StopMessage");
00110   }
00111  }
00112  return 1;
00113 #ifndef TOLUA_RELEASE
00114  tolua_lerror:
00115  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00116  return 0;
00117 #endif
00118 }
00119 #endif //#ifndef TOLUA_DISABLE
00120 
00121 /* method: new_local of class  StopMessage */
00122 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_StopMessage_new00_local
00123 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_StopMessage_new00_local(lua_State* tolua_S)
00124 {
00125 #ifndef TOLUA_RELEASE
00126  tolua_Error tolua_err;
00127  if (
00128      !tolua_isusertable(tolua_S,1,"fawkes::Roomba500Interface::StopMessage",0,&tolua_err) ||
00129      !tolua_isnoobj(tolua_S,2,&tolua_err)
00130  )
00131   goto tolua_lerror;
00132  else
00133 #endif
00134  {
00135   {
00136    fawkes::Roomba500Interface::StopMessage* tolua_ret = (fawkes::Roomba500Interface::StopMessage*)  Mtolua_new((fawkes::Roomba500Interface::StopMessage)());
00137     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Roomba500Interface::StopMessage");
00138     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00139   }
00140  }
00141  return 1;
00142 #ifndef TOLUA_RELEASE
00143  tolua_lerror:
00144  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00145  return 0;
00146 #endif
00147 }
00148 #endif //#ifndef TOLUA_DISABLE
00149 
00150 /* method: delete of class  StopMessage */
00151 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_StopMessage_delete00
00152 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_StopMessage_delete00(lua_State* tolua_S)
00153 {
00154 #ifndef TOLUA_RELEASE
00155  tolua_Error tolua_err;
00156  if (
00157      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface::StopMessage",0,&tolua_err) ||
00158      !tolua_isnoobj(tolua_S,2,&tolua_err)
00159  )
00160   goto tolua_lerror;
00161  else
00162 #endif
00163  {
00164   fawkes::Roomba500Interface::StopMessage* self = (fawkes::Roomba500Interface::StopMessage*)  tolua_tousertype(tolua_S,1,0);
00165 #ifndef TOLUA_RELEASE
00166   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
00167 #endif
00168   Mtolua_delete(self);
00169  }
00170  return 0;
00171 #ifndef TOLUA_RELEASE
00172  tolua_lerror:
00173  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
00174  return 0;
00175 #endif
00176 }
00177 #endif //#ifndef TOLUA_DISABLE
00178 
00179 /* method: new of class  DockMessage */
00180 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DockMessage_new00
00181 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DockMessage_new00(lua_State* tolua_S)
00182 {
00183 #ifndef TOLUA_RELEASE
00184  tolua_Error tolua_err;
00185  if (
00186      !tolua_isusertable(tolua_S,1,"fawkes::Roomba500Interface::DockMessage",0,&tolua_err) ||
00187      !tolua_isnoobj(tolua_S,2,&tolua_err)
00188  )
00189   goto tolua_lerror;
00190  else
00191 #endif
00192  {
00193   {
00194    fawkes::Roomba500Interface::DockMessage* tolua_ret = (fawkes::Roomba500Interface::DockMessage*)  Mtolua_new((fawkes::Roomba500Interface::DockMessage)());
00195     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Roomba500Interface::DockMessage");
00196   }
00197  }
00198  return 1;
00199 #ifndef TOLUA_RELEASE
00200  tolua_lerror:
00201  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00202  return 0;
00203 #endif
00204 }
00205 #endif //#ifndef TOLUA_DISABLE
00206 
00207 /* method: new_local of class  DockMessage */
00208 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DockMessage_new00_local
00209 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DockMessage_new00_local(lua_State* tolua_S)
00210 {
00211 #ifndef TOLUA_RELEASE
00212  tolua_Error tolua_err;
00213  if (
00214      !tolua_isusertable(tolua_S,1,"fawkes::Roomba500Interface::DockMessage",0,&tolua_err) ||
00215      !tolua_isnoobj(tolua_S,2,&tolua_err)
00216  )
00217   goto tolua_lerror;
00218  else
00219 #endif
00220  {
00221   {
00222    fawkes::Roomba500Interface::DockMessage* tolua_ret = (fawkes::Roomba500Interface::DockMessage*)  Mtolua_new((fawkes::Roomba500Interface::DockMessage)());
00223     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Roomba500Interface::DockMessage");
00224     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00225   }
00226  }
00227  return 1;
00228 #ifndef TOLUA_RELEASE
00229  tolua_lerror:
00230  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00231  return 0;
00232 #endif
00233 }
00234 #endif //#ifndef TOLUA_DISABLE
00235 
00236 /* method: delete of class  DockMessage */
00237 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DockMessage_delete00
00238 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DockMessage_delete00(lua_State* tolua_S)
00239 {
00240 #ifndef TOLUA_RELEASE
00241  tolua_Error tolua_err;
00242  if (
00243      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface::DockMessage",0,&tolua_err) ||
00244      !tolua_isnoobj(tolua_S,2,&tolua_err)
00245  )
00246   goto tolua_lerror;
00247  else
00248 #endif
00249  {
00250   fawkes::Roomba500Interface::DockMessage* self = (fawkes::Roomba500Interface::DockMessage*)  tolua_tousertype(tolua_S,1,0);
00251 #ifndef TOLUA_RELEASE
00252   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
00253 #endif
00254   Mtolua_delete(self);
00255  }
00256  return 0;
00257 #ifndef TOLUA_RELEASE
00258  tolua_lerror:
00259  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
00260  return 0;
00261 #endif
00262 }
00263 #endif //#ifndef TOLUA_DISABLE
00264 
00265 /* method: new of class  SetModeMessage */
00266 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetModeMessage_new00
00267 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetModeMessage_new00(lua_State* tolua_S)
00268 {
00269 #ifndef TOLUA_RELEASE
00270  tolua_Error tolua_err;
00271  if (
00272      !tolua_isusertable(tolua_S,1,"fawkes::Roomba500Interface::SetModeMessage",0,&tolua_err) ||
00273      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00274      !tolua_isnoobj(tolua_S,3,&tolua_err)
00275  )
00276   goto tolua_lerror;
00277  else
00278 #endif
00279  {
00280   fawkes::Roomba500Interface::Mode ini_mode = ((fawkes::Roomba500Interface::Mode) (int)  tolua_tonumber(tolua_S,2,0));
00281   {
00282    fawkes::Roomba500Interface::SetModeMessage* tolua_ret = (fawkes::Roomba500Interface::SetModeMessage*)  Mtolua_new((fawkes::Roomba500Interface::SetModeMessage)(ini_mode));
00283     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Roomba500Interface::SetModeMessage");
00284   }
00285  }
00286  return 1;
00287 #ifndef TOLUA_RELEASE
00288  tolua_lerror:
00289  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00290  return 0;
00291 #endif
00292 }
00293 #endif //#ifndef TOLUA_DISABLE
00294 
00295 /* method: new_local of class  SetModeMessage */
00296 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetModeMessage_new00_local
00297 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetModeMessage_new00_local(lua_State* tolua_S)
00298 {
00299 #ifndef TOLUA_RELEASE
00300  tolua_Error tolua_err;
00301  if (
00302      !tolua_isusertable(tolua_S,1,"fawkes::Roomba500Interface::SetModeMessage",0,&tolua_err) ||
00303      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00304      !tolua_isnoobj(tolua_S,3,&tolua_err)
00305  )
00306   goto tolua_lerror;
00307  else
00308 #endif
00309  {
00310   fawkes::Roomba500Interface::Mode ini_mode = ((fawkes::Roomba500Interface::Mode) (int)  tolua_tonumber(tolua_S,2,0));
00311   {
00312    fawkes::Roomba500Interface::SetModeMessage* tolua_ret = (fawkes::Roomba500Interface::SetModeMessage*)  Mtolua_new((fawkes::Roomba500Interface::SetModeMessage)(ini_mode));
00313     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Roomba500Interface::SetModeMessage");
00314     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00315   }
00316  }
00317  return 1;
00318 #ifndef TOLUA_RELEASE
00319  tolua_lerror:
00320  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00321  return 0;
00322 #endif
00323 }
00324 #endif //#ifndef TOLUA_DISABLE
00325 
00326 /* method: new of class  SetModeMessage */
00327 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetModeMessage_new01
00328 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetModeMessage_new01(lua_State* tolua_S)
00329 {
00330  tolua_Error tolua_err;
00331  if (
00332      !tolua_isusertable(tolua_S,1,"fawkes::Roomba500Interface::SetModeMessage",0,&tolua_err) ||
00333      !tolua_isnoobj(tolua_S,2,&tolua_err)
00334  )
00335   goto tolua_lerror;
00336  else
00337  {
00338   {
00339    fawkes::Roomba500Interface::SetModeMessage* tolua_ret = (fawkes::Roomba500Interface::SetModeMessage*)  Mtolua_new((fawkes::Roomba500Interface::SetModeMessage)());
00340     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Roomba500Interface::SetModeMessage");
00341   }
00342  }
00343  return 1;
00344 tolua_lerror:
00345  return tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetModeMessage_new00(tolua_S);
00346 }
00347 #endif //#ifndef TOLUA_DISABLE
00348 
00349 /* method: new_local of class  SetModeMessage */
00350 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetModeMessage_new01_local
00351 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetModeMessage_new01_local(lua_State* tolua_S)
00352 {
00353  tolua_Error tolua_err;
00354  if (
00355      !tolua_isusertable(tolua_S,1,"fawkes::Roomba500Interface::SetModeMessage",0,&tolua_err) ||
00356      !tolua_isnoobj(tolua_S,2,&tolua_err)
00357  )
00358   goto tolua_lerror;
00359  else
00360  {
00361   {
00362    fawkes::Roomba500Interface::SetModeMessage* tolua_ret = (fawkes::Roomba500Interface::SetModeMessage*)  Mtolua_new((fawkes::Roomba500Interface::SetModeMessage)());
00363     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Roomba500Interface::SetModeMessage");
00364     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00365   }
00366  }
00367  return 1;
00368 tolua_lerror:
00369  return tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetModeMessage_new00_local(tolua_S);
00370 }
00371 #endif //#ifndef TOLUA_DISABLE
00372 
00373 /* method: delete of class  SetModeMessage */
00374 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetModeMessage_delete00
00375 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetModeMessage_delete00(lua_State* tolua_S)
00376 {
00377 #ifndef TOLUA_RELEASE
00378  tolua_Error tolua_err;
00379  if (
00380      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface::SetModeMessage",0,&tolua_err) ||
00381      !tolua_isnoobj(tolua_S,2,&tolua_err)
00382  )
00383   goto tolua_lerror;
00384  else
00385 #endif
00386  {
00387   fawkes::Roomba500Interface::SetModeMessage* self = (fawkes::Roomba500Interface::SetModeMessage*)  tolua_tousertype(tolua_S,1,0);
00388 #ifndef TOLUA_RELEASE
00389   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
00390 #endif
00391   Mtolua_delete(self);
00392  }
00393  return 0;
00394 #ifndef TOLUA_RELEASE
00395  tolua_lerror:
00396  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
00397  return 0;
00398 #endif
00399 }
00400 #endif //#ifndef TOLUA_DISABLE
00401 
00402 /* method: mode of class  SetModeMessage */
00403 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetModeMessage_mode00
00404 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetModeMessage_mode00(lua_State* tolua_S)
00405 {
00406 #ifndef TOLUA_RELEASE
00407  tolua_Error tolua_err;
00408  if (
00409      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface::SetModeMessage",0,&tolua_err) ||
00410      !tolua_isnoobj(tolua_S,2,&tolua_err)
00411  )
00412   goto tolua_lerror;
00413  else
00414 #endif
00415  {
00416   fawkes::Roomba500Interface::SetModeMessage* self = (fawkes::Roomba500Interface::SetModeMessage*)  tolua_tousertype(tolua_S,1,0);
00417 #ifndef TOLUA_RELEASE
00418   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'mode'", NULL);
00419 #endif
00420   {
00421    fawkes::Roomba500Interface::Mode tolua_ret = (fawkes::Roomba500Interface::Mode)  self->mode();
00422    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00423   }
00424  }
00425  return 1;
00426 #ifndef TOLUA_RELEASE
00427  tolua_lerror:
00428  tolua_error(tolua_S,"#ferror in function 'mode'.",&tolua_err);
00429  return 0;
00430 #endif
00431 }
00432 #endif //#ifndef TOLUA_DISABLE
00433 
00434 /* method: set_mode of class  SetModeMessage */
00435 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetModeMessage_set_mode00
00436 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetModeMessage_set_mode00(lua_State* tolua_S)
00437 {
00438 #ifndef TOLUA_RELEASE
00439  tolua_Error tolua_err;
00440  if (
00441      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface::SetModeMessage",0,&tolua_err) ||
00442      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00443      !tolua_isnoobj(tolua_S,3,&tolua_err)
00444  )
00445   goto tolua_lerror;
00446  else
00447 #endif
00448  {
00449   fawkes::Roomba500Interface::SetModeMessage* self = (fawkes::Roomba500Interface::SetModeMessage*)  tolua_tousertype(tolua_S,1,0);
00450   const fawkes::Roomba500Interface::Mode new_mode = ((const fawkes::Roomba500Interface::Mode) (int)  tolua_tonumber(tolua_S,2,0));
00451 #ifndef TOLUA_RELEASE
00452   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_mode'", NULL);
00453 #endif
00454   {
00455    self->set_mode(new_mode);
00456   }
00457  }
00458  return 0;
00459 #ifndef TOLUA_RELEASE
00460  tolua_lerror:
00461  tolua_error(tolua_S,"#ferror in function 'set_mode'.",&tolua_err);
00462  return 0;
00463 #endif
00464 }
00465 #endif //#ifndef TOLUA_DISABLE
00466 
00467 /* method: maxlenof_mode of class  SetModeMessage */
00468 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetModeMessage_maxlenof_mode00
00469 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetModeMessage_maxlenof_mode00(lua_State* tolua_S)
00470 {
00471 #ifndef TOLUA_RELEASE
00472  tolua_Error tolua_err;
00473  if (
00474      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface::SetModeMessage",0,&tolua_err) ||
00475      !tolua_isnoobj(tolua_S,2,&tolua_err)
00476  )
00477   goto tolua_lerror;
00478  else
00479 #endif
00480  {
00481   const fawkes::Roomba500Interface::SetModeMessage* self = (const fawkes::Roomba500Interface::SetModeMessage*)  tolua_tousertype(tolua_S,1,0);
00482 #ifndef TOLUA_RELEASE
00483   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_mode'", NULL);
00484 #endif
00485   {
00486    int tolua_ret = (int)  self->maxlenof_mode();
00487    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00488   }
00489  }
00490  return 1;
00491 #ifndef TOLUA_RELEASE
00492  tolua_lerror:
00493  tolua_error(tolua_S,"#ferror in function 'maxlenof_mode'.",&tolua_err);
00494  return 0;
00495 #endif
00496 }
00497 #endif //#ifndef TOLUA_DISABLE
00498 
00499 /* method: new of class  DriveStraightMessage */
00500 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveStraightMessage_new00
00501 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveStraightMessage_new00(lua_State* tolua_S)
00502 {
00503 #ifndef TOLUA_RELEASE
00504  tolua_Error tolua_err;
00505  if (
00506      !tolua_isusertable(tolua_S,1,"fawkes::Roomba500Interface::DriveStraightMessage",0,&tolua_err) ||
00507      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00508      !tolua_isnoobj(tolua_S,3,&tolua_err)
00509  )
00510   goto tolua_lerror;
00511  else
00512 #endif
00513  {
00514   short ini_velocity = ((short)  tolua_tonumber(tolua_S,2,0));
00515   {
00516    fawkes::Roomba500Interface::DriveStraightMessage* tolua_ret = (fawkes::Roomba500Interface::DriveStraightMessage*)  Mtolua_new((fawkes::Roomba500Interface::DriveStraightMessage)(ini_velocity));
00517     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Roomba500Interface::DriveStraightMessage");
00518   }
00519  }
00520  return 1;
00521 #ifndef TOLUA_RELEASE
00522  tolua_lerror:
00523  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00524  return 0;
00525 #endif
00526 }
00527 #endif //#ifndef TOLUA_DISABLE
00528 
00529 /* method: new_local of class  DriveStraightMessage */
00530 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveStraightMessage_new00_local
00531 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveStraightMessage_new00_local(lua_State* tolua_S)
00532 {
00533 #ifndef TOLUA_RELEASE
00534  tolua_Error tolua_err;
00535  if (
00536      !tolua_isusertable(tolua_S,1,"fawkes::Roomba500Interface::DriveStraightMessage",0,&tolua_err) ||
00537      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00538      !tolua_isnoobj(tolua_S,3,&tolua_err)
00539  )
00540   goto tolua_lerror;
00541  else
00542 #endif
00543  {
00544   short ini_velocity = ((short)  tolua_tonumber(tolua_S,2,0));
00545   {
00546    fawkes::Roomba500Interface::DriveStraightMessage* tolua_ret = (fawkes::Roomba500Interface::DriveStraightMessage*)  Mtolua_new((fawkes::Roomba500Interface::DriveStraightMessage)(ini_velocity));
00547     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Roomba500Interface::DriveStraightMessage");
00548     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00549   }
00550  }
00551  return 1;
00552 #ifndef TOLUA_RELEASE
00553  tolua_lerror:
00554  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00555  return 0;
00556 #endif
00557 }
00558 #endif //#ifndef TOLUA_DISABLE
00559 
00560 /* method: new of class  DriveStraightMessage */
00561 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveStraightMessage_new01
00562 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveStraightMessage_new01(lua_State* tolua_S)
00563 {
00564  tolua_Error tolua_err;
00565  if (
00566      !tolua_isusertable(tolua_S,1,"fawkes::Roomba500Interface::DriveStraightMessage",0,&tolua_err) ||
00567      !tolua_isnoobj(tolua_S,2,&tolua_err)
00568  )
00569   goto tolua_lerror;
00570  else
00571  {
00572   {
00573    fawkes::Roomba500Interface::DriveStraightMessage* tolua_ret = (fawkes::Roomba500Interface::DriveStraightMessage*)  Mtolua_new((fawkes::Roomba500Interface::DriveStraightMessage)());
00574     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Roomba500Interface::DriveStraightMessage");
00575   }
00576  }
00577  return 1;
00578 tolua_lerror:
00579  return tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveStraightMessage_new00(tolua_S);
00580 }
00581 #endif //#ifndef TOLUA_DISABLE
00582 
00583 /* method: new_local of class  DriveStraightMessage */
00584 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveStraightMessage_new01_local
00585 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveStraightMessage_new01_local(lua_State* tolua_S)
00586 {
00587  tolua_Error tolua_err;
00588  if (
00589      !tolua_isusertable(tolua_S,1,"fawkes::Roomba500Interface::DriveStraightMessage",0,&tolua_err) ||
00590      !tolua_isnoobj(tolua_S,2,&tolua_err)
00591  )
00592   goto tolua_lerror;
00593  else
00594  {
00595   {
00596    fawkes::Roomba500Interface::DriveStraightMessage* tolua_ret = (fawkes::Roomba500Interface::DriveStraightMessage*)  Mtolua_new((fawkes::Roomba500Interface::DriveStraightMessage)());
00597     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Roomba500Interface::DriveStraightMessage");
00598     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00599   }
00600  }
00601  return 1;
00602 tolua_lerror:
00603  return tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveStraightMessage_new00_local(tolua_S);
00604 }
00605 #endif //#ifndef TOLUA_DISABLE
00606 
00607 /* method: delete of class  DriveStraightMessage */
00608 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveStraightMessage_delete00
00609 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveStraightMessage_delete00(lua_State* tolua_S)
00610 {
00611 #ifndef TOLUA_RELEASE
00612  tolua_Error tolua_err;
00613  if (
00614      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface::DriveStraightMessage",0,&tolua_err) ||
00615      !tolua_isnoobj(tolua_S,2,&tolua_err)
00616  )
00617   goto tolua_lerror;
00618  else
00619 #endif
00620  {
00621   fawkes::Roomba500Interface::DriveStraightMessage* self = (fawkes::Roomba500Interface::DriveStraightMessage*)  tolua_tousertype(tolua_S,1,0);
00622 #ifndef TOLUA_RELEASE
00623   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
00624 #endif
00625   Mtolua_delete(self);
00626  }
00627  return 0;
00628 #ifndef TOLUA_RELEASE
00629  tolua_lerror:
00630  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
00631  return 0;
00632 #endif
00633 }
00634 #endif //#ifndef TOLUA_DISABLE
00635 
00636 /* method: velocity of class  DriveStraightMessage */
00637 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveStraightMessage_velocity00
00638 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveStraightMessage_velocity00(lua_State* tolua_S)
00639 {
00640 #ifndef TOLUA_RELEASE
00641  tolua_Error tolua_err;
00642  if (
00643      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface::DriveStraightMessage",0,&tolua_err) ||
00644      !tolua_isnoobj(tolua_S,2,&tolua_err)
00645  )
00646   goto tolua_lerror;
00647  else
00648 #endif
00649  {
00650   fawkes::Roomba500Interface::DriveStraightMessage* self = (fawkes::Roomba500Interface::DriveStraightMessage*)  tolua_tousertype(tolua_S,1,0);
00651 #ifndef TOLUA_RELEASE
00652   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'velocity'", NULL);
00653 #endif
00654   {
00655    short tolua_ret = (short)  self->velocity();
00656    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00657   }
00658  }
00659  return 1;
00660 #ifndef TOLUA_RELEASE
00661  tolua_lerror:
00662  tolua_error(tolua_S,"#ferror in function 'velocity'.",&tolua_err);
00663  return 0;
00664 #endif
00665 }
00666 #endif //#ifndef TOLUA_DISABLE
00667 
00668 /* method: set_velocity of class  DriveStraightMessage */
00669 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveStraightMessage_set_velocity00
00670 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveStraightMessage_set_velocity00(lua_State* tolua_S)
00671 {
00672 #ifndef TOLUA_RELEASE
00673  tolua_Error tolua_err;
00674  if (
00675      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface::DriveStraightMessage",0,&tolua_err) ||
00676      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00677      !tolua_isnoobj(tolua_S,3,&tolua_err)
00678  )
00679   goto tolua_lerror;
00680  else
00681 #endif
00682  {
00683   fawkes::Roomba500Interface::DriveStraightMessage* self = (fawkes::Roomba500Interface::DriveStraightMessage*)  tolua_tousertype(tolua_S,1,0);
00684   const short new_velocity = ((const short)  tolua_tonumber(tolua_S,2,0));
00685 #ifndef TOLUA_RELEASE
00686   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_velocity'", NULL);
00687 #endif
00688   {
00689    self->set_velocity(new_velocity);
00690   }
00691  }
00692  return 0;
00693 #ifndef TOLUA_RELEASE
00694  tolua_lerror:
00695  tolua_error(tolua_S,"#ferror in function 'set_velocity'.",&tolua_err);
00696  return 0;
00697 #endif
00698 }
00699 #endif //#ifndef TOLUA_DISABLE
00700 
00701 /* method: maxlenof_velocity of class  DriveStraightMessage */
00702 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveStraightMessage_maxlenof_velocity00
00703 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveStraightMessage_maxlenof_velocity00(lua_State* tolua_S)
00704 {
00705 #ifndef TOLUA_RELEASE
00706  tolua_Error tolua_err;
00707  if (
00708      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface::DriveStraightMessage",0,&tolua_err) ||
00709      !tolua_isnoobj(tolua_S,2,&tolua_err)
00710  )
00711   goto tolua_lerror;
00712  else
00713 #endif
00714  {
00715   const fawkes::Roomba500Interface::DriveStraightMessage* self = (const fawkes::Roomba500Interface::DriveStraightMessage*)  tolua_tousertype(tolua_S,1,0);
00716 #ifndef TOLUA_RELEASE
00717   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_velocity'", NULL);
00718 #endif
00719   {
00720    int tolua_ret = (int)  self->maxlenof_velocity();
00721    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00722   }
00723  }
00724  return 1;
00725 #ifndef TOLUA_RELEASE
00726  tolua_lerror:
00727  tolua_error(tolua_S,"#ferror in function 'maxlenof_velocity'.",&tolua_err);
00728  return 0;
00729 #endif
00730 }
00731 #endif //#ifndef TOLUA_DISABLE
00732 
00733 /* method: new of class  DriveMessage */
00734 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveMessage_new00
00735 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveMessage_new00(lua_State* tolua_S)
00736 {
00737 #ifndef TOLUA_RELEASE
00738  tolua_Error tolua_err;
00739  if (
00740      !tolua_isusertable(tolua_S,1,"fawkes::Roomba500Interface::DriveMessage",0,&tolua_err) ||
00741      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00742      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
00743      !tolua_isnoobj(tolua_S,4,&tolua_err)
00744  )
00745   goto tolua_lerror;
00746  else
00747 #endif
00748  {
00749   short ini_velocity = ((short)  tolua_tonumber(tolua_S,2,0));
00750   short ini_radius = ((short)  tolua_tonumber(tolua_S,3,0));
00751   {
00752    fawkes::Roomba500Interface::DriveMessage* tolua_ret = (fawkes::Roomba500Interface::DriveMessage*)  Mtolua_new((fawkes::Roomba500Interface::DriveMessage)(ini_velocity,ini_radius));
00753     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Roomba500Interface::DriveMessage");
00754   }
00755  }
00756  return 1;
00757 #ifndef TOLUA_RELEASE
00758  tolua_lerror:
00759  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00760  return 0;
00761 #endif
00762 }
00763 #endif //#ifndef TOLUA_DISABLE
00764 
00765 /* method: new_local of class  DriveMessage */
00766 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveMessage_new00_local
00767 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveMessage_new00_local(lua_State* tolua_S)
00768 {
00769 #ifndef TOLUA_RELEASE
00770  tolua_Error tolua_err;
00771  if (
00772      !tolua_isusertable(tolua_S,1,"fawkes::Roomba500Interface::DriveMessage",0,&tolua_err) ||
00773      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00774      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
00775      !tolua_isnoobj(tolua_S,4,&tolua_err)
00776  )
00777   goto tolua_lerror;
00778  else
00779 #endif
00780  {
00781   short ini_velocity = ((short)  tolua_tonumber(tolua_S,2,0));
00782   short ini_radius = ((short)  tolua_tonumber(tolua_S,3,0));
00783   {
00784    fawkes::Roomba500Interface::DriveMessage* tolua_ret = (fawkes::Roomba500Interface::DriveMessage*)  Mtolua_new((fawkes::Roomba500Interface::DriveMessage)(ini_velocity,ini_radius));
00785     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Roomba500Interface::DriveMessage");
00786     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00787   }
00788  }
00789  return 1;
00790 #ifndef TOLUA_RELEASE
00791  tolua_lerror:
00792  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00793  return 0;
00794 #endif
00795 }
00796 #endif //#ifndef TOLUA_DISABLE
00797 
00798 /* method: new of class  DriveMessage */
00799 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveMessage_new01
00800 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveMessage_new01(lua_State* tolua_S)
00801 {
00802  tolua_Error tolua_err;
00803  if (
00804      !tolua_isusertable(tolua_S,1,"fawkes::Roomba500Interface::DriveMessage",0,&tolua_err) ||
00805      !tolua_isnoobj(tolua_S,2,&tolua_err)
00806  )
00807   goto tolua_lerror;
00808  else
00809  {
00810   {
00811    fawkes::Roomba500Interface::DriveMessage* tolua_ret = (fawkes::Roomba500Interface::DriveMessage*)  Mtolua_new((fawkes::Roomba500Interface::DriveMessage)());
00812     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Roomba500Interface::DriveMessage");
00813   }
00814  }
00815  return 1;
00816 tolua_lerror:
00817  return tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveMessage_new00(tolua_S);
00818 }
00819 #endif //#ifndef TOLUA_DISABLE
00820 
00821 /* method: new_local of class  DriveMessage */
00822 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveMessage_new01_local
00823 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveMessage_new01_local(lua_State* tolua_S)
00824 {
00825  tolua_Error tolua_err;
00826  if (
00827      !tolua_isusertable(tolua_S,1,"fawkes::Roomba500Interface::DriveMessage",0,&tolua_err) ||
00828      !tolua_isnoobj(tolua_S,2,&tolua_err)
00829  )
00830   goto tolua_lerror;
00831  else
00832  {
00833   {
00834    fawkes::Roomba500Interface::DriveMessage* tolua_ret = (fawkes::Roomba500Interface::DriveMessage*)  Mtolua_new((fawkes::Roomba500Interface::DriveMessage)());
00835     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Roomba500Interface::DriveMessage");
00836     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00837   }
00838  }
00839  return 1;
00840 tolua_lerror:
00841  return tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveMessage_new00_local(tolua_S);
00842 }
00843 #endif //#ifndef TOLUA_DISABLE
00844 
00845 /* method: delete of class  DriveMessage */
00846 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveMessage_delete00
00847 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveMessage_delete00(lua_State* tolua_S)
00848 {
00849 #ifndef TOLUA_RELEASE
00850  tolua_Error tolua_err;
00851  if (
00852      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface::DriveMessage",0,&tolua_err) ||
00853      !tolua_isnoobj(tolua_S,2,&tolua_err)
00854  )
00855   goto tolua_lerror;
00856  else
00857 #endif
00858  {
00859   fawkes::Roomba500Interface::DriveMessage* self = (fawkes::Roomba500Interface::DriveMessage*)  tolua_tousertype(tolua_S,1,0);
00860 #ifndef TOLUA_RELEASE
00861   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
00862 #endif
00863   Mtolua_delete(self);
00864  }
00865  return 0;
00866 #ifndef TOLUA_RELEASE
00867  tolua_lerror:
00868  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
00869  return 0;
00870 #endif
00871 }
00872 #endif //#ifndef TOLUA_DISABLE
00873 
00874 /* method: velocity of class  DriveMessage */
00875 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveMessage_velocity00
00876 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveMessage_velocity00(lua_State* tolua_S)
00877 {
00878 #ifndef TOLUA_RELEASE
00879  tolua_Error tolua_err;
00880  if (
00881      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface::DriveMessage",0,&tolua_err) ||
00882      !tolua_isnoobj(tolua_S,2,&tolua_err)
00883  )
00884   goto tolua_lerror;
00885  else
00886 #endif
00887  {
00888   fawkes::Roomba500Interface::DriveMessage* self = (fawkes::Roomba500Interface::DriveMessage*)  tolua_tousertype(tolua_S,1,0);
00889 #ifndef TOLUA_RELEASE
00890   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'velocity'", NULL);
00891 #endif
00892   {
00893    short tolua_ret = (short)  self->velocity();
00894    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00895   }
00896  }
00897  return 1;
00898 #ifndef TOLUA_RELEASE
00899  tolua_lerror:
00900  tolua_error(tolua_S,"#ferror in function 'velocity'.",&tolua_err);
00901  return 0;
00902 #endif
00903 }
00904 #endif //#ifndef TOLUA_DISABLE
00905 
00906 /* method: set_velocity of class  DriveMessage */
00907 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveMessage_set_velocity00
00908 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveMessage_set_velocity00(lua_State* tolua_S)
00909 {
00910 #ifndef TOLUA_RELEASE
00911  tolua_Error tolua_err;
00912  if (
00913      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface::DriveMessage",0,&tolua_err) ||
00914      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00915      !tolua_isnoobj(tolua_S,3,&tolua_err)
00916  )
00917   goto tolua_lerror;
00918  else
00919 #endif
00920  {
00921   fawkes::Roomba500Interface::DriveMessage* self = (fawkes::Roomba500Interface::DriveMessage*)  tolua_tousertype(tolua_S,1,0);
00922   const short new_velocity = ((const short)  tolua_tonumber(tolua_S,2,0));
00923 #ifndef TOLUA_RELEASE
00924   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_velocity'", NULL);
00925 #endif
00926   {
00927    self->set_velocity(new_velocity);
00928   }
00929  }
00930  return 0;
00931 #ifndef TOLUA_RELEASE
00932  tolua_lerror:
00933  tolua_error(tolua_S,"#ferror in function 'set_velocity'.",&tolua_err);
00934  return 0;
00935 #endif
00936 }
00937 #endif //#ifndef TOLUA_DISABLE
00938 
00939 /* method: maxlenof_velocity of class  DriveMessage */
00940 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveMessage_maxlenof_velocity00
00941 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveMessage_maxlenof_velocity00(lua_State* tolua_S)
00942 {
00943 #ifndef TOLUA_RELEASE
00944  tolua_Error tolua_err;
00945  if (
00946      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface::DriveMessage",0,&tolua_err) ||
00947      !tolua_isnoobj(tolua_S,2,&tolua_err)
00948  )
00949   goto tolua_lerror;
00950  else
00951 #endif
00952  {
00953   const fawkes::Roomba500Interface::DriveMessage* self = (const fawkes::Roomba500Interface::DriveMessage*)  tolua_tousertype(tolua_S,1,0);
00954 #ifndef TOLUA_RELEASE
00955   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_velocity'", NULL);
00956 #endif
00957   {
00958    int tolua_ret = (int)  self->maxlenof_velocity();
00959    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00960   }
00961  }
00962  return 1;
00963 #ifndef TOLUA_RELEASE
00964  tolua_lerror:
00965  tolua_error(tolua_S,"#ferror in function 'maxlenof_velocity'.",&tolua_err);
00966  return 0;
00967 #endif
00968 }
00969 #endif //#ifndef TOLUA_DISABLE
00970 
00971 /* method: radius of class  DriveMessage */
00972 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveMessage_radius00
00973 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveMessage_radius00(lua_State* tolua_S)
00974 {
00975 #ifndef TOLUA_RELEASE
00976  tolua_Error tolua_err;
00977  if (
00978      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface::DriveMessage",0,&tolua_err) ||
00979      !tolua_isnoobj(tolua_S,2,&tolua_err)
00980  )
00981   goto tolua_lerror;
00982  else
00983 #endif
00984  {
00985   fawkes::Roomba500Interface::DriveMessage* self = (fawkes::Roomba500Interface::DriveMessage*)  tolua_tousertype(tolua_S,1,0);
00986 #ifndef TOLUA_RELEASE
00987   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'radius'", NULL);
00988 #endif
00989   {
00990    short tolua_ret = (short)  self->radius();
00991    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00992   }
00993  }
00994  return 1;
00995 #ifndef TOLUA_RELEASE
00996  tolua_lerror:
00997  tolua_error(tolua_S,"#ferror in function 'radius'.",&tolua_err);
00998  return 0;
00999 #endif
01000 }
01001 #endif //#ifndef TOLUA_DISABLE
01002 
01003 /* method: set_radius of class  DriveMessage */
01004 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveMessage_set_radius00
01005 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveMessage_set_radius00(lua_State* tolua_S)
01006 {
01007 #ifndef TOLUA_RELEASE
01008  tolua_Error tolua_err;
01009  if (
01010      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface::DriveMessage",0,&tolua_err) ||
01011      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01012      !tolua_isnoobj(tolua_S,3,&tolua_err)
01013  )
01014   goto tolua_lerror;
01015  else
01016 #endif
01017  {
01018   fawkes::Roomba500Interface::DriveMessage* self = (fawkes::Roomba500Interface::DriveMessage*)  tolua_tousertype(tolua_S,1,0);
01019   const short new_radius = ((const short)  tolua_tonumber(tolua_S,2,0));
01020 #ifndef TOLUA_RELEASE
01021   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_radius'", NULL);
01022 #endif
01023   {
01024    self->set_radius(new_radius);
01025   }
01026  }
01027  return 0;
01028 #ifndef TOLUA_RELEASE
01029  tolua_lerror:
01030  tolua_error(tolua_S,"#ferror in function 'set_radius'.",&tolua_err);
01031  return 0;
01032 #endif
01033 }
01034 #endif //#ifndef TOLUA_DISABLE
01035 
01036 /* method: maxlenof_radius of class  DriveMessage */
01037 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveMessage_maxlenof_radius00
01038 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveMessage_maxlenof_radius00(lua_State* tolua_S)
01039 {
01040 #ifndef TOLUA_RELEASE
01041  tolua_Error tolua_err;
01042  if (
01043      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface::DriveMessage",0,&tolua_err) ||
01044      !tolua_isnoobj(tolua_S,2,&tolua_err)
01045  )
01046   goto tolua_lerror;
01047  else
01048 #endif
01049  {
01050   const fawkes::Roomba500Interface::DriveMessage* self = (const fawkes::Roomba500Interface::DriveMessage*)  tolua_tousertype(tolua_S,1,0);
01051 #ifndef TOLUA_RELEASE
01052   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_radius'", NULL);
01053 #endif
01054   {
01055    int tolua_ret = (int)  self->maxlenof_radius();
01056    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01057   }
01058  }
01059  return 1;
01060 #ifndef TOLUA_RELEASE
01061  tolua_lerror:
01062  tolua_error(tolua_S,"#ferror in function 'maxlenof_radius'.",&tolua_err);
01063  return 0;
01064 #endif
01065 }
01066 #endif //#ifndef TOLUA_DISABLE
01067 
01068 /* method: new of class  SetMotorsMessage */
01069 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetMotorsMessage_new00
01070 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetMotorsMessage_new00(lua_State* tolua_S)
01071 {
01072 #ifndef TOLUA_RELEASE
01073  tolua_Error tolua_err;
01074  if (
01075      !tolua_isusertable(tolua_S,1,"fawkes::Roomba500Interface::SetMotorsMessage",0,&tolua_err) ||
01076      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
01077      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
01078      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
01079      !tolua_isnoobj(tolua_S,5,&tolua_err)
01080  )
01081   goto tolua_lerror;
01082  else
01083 #endif
01084  {
01085   bool ini_vacuuming = ((bool)  tolua_toboolean(tolua_S,2,0));
01086   fawkes::Roomba500Interface::BrushState ini_main = ((fawkes::Roomba500Interface::BrushState) (int)  tolua_tonumber(tolua_S,3,0));
01087   fawkes::Roomba500Interface::BrushState ini_side = ((fawkes::Roomba500Interface::BrushState) (int)  tolua_tonumber(tolua_S,4,0));
01088   {
01089    fawkes::Roomba500Interface::SetMotorsMessage* tolua_ret = (fawkes::Roomba500Interface::SetMotorsMessage*)  Mtolua_new((fawkes::Roomba500Interface::SetMotorsMessage)(ini_vacuuming,ini_main,ini_side));
01090     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Roomba500Interface::SetMotorsMessage");
01091   }
01092  }
01093  return 1;
01094 #ifndef TOLUA_RELEASE
01095  tolua_lerror:
01096  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
01097  return 0;
01098 #endif
01099 }
01100 #endif //#ifndef TOLUA_DISABLE
01101 
01102 /* method: new_local of class  SetMotorsMessage */
01103 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetMotorsMessage_new00_local
01104 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetMotorsMessage_new00_local(lua_State* tolua_S)
01105 {
01106 #ifndef TOLUA_RELEASE
01107  tolua_Error tolua_err;
01108  if (
01109      !tolua_isusertable(tolua_S,1,"fawkes::Roomba500Interface::SetMotorsMessage",0,&tolua_err) ||
01110      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
01111      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
01112      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
01113      !tolua_isnoobj(tolua_S,5,&tolua_err)
01114  )
01115   goto tolua_lerror;
01116  else
01117 #endif
01118  {
01119   bool ini_vacuuming = ((bool)  tolua_toboolean(tolua_S,2,0));
01120   fawkes::Roomba500Interface::BrushState ini_main = ((fawkes::Roomba500Interface::BrushState) (int)  tolua_tonumber(tolua_S,3,0));
01121   fawkes::Roomba500Interface::BrushState ini_side = ((fawkes::Roomba500Interface::BrushState) (int)  tolua_tonumber(tolua_S,4,0));
01122   {
01123    fawkes::Roomba500Interface::SetMotorsMessage* tolua_ret = (fawkes::Roomba500Interface::SetMotorsMessage*)  Mtolua_new((fawkes::Roomba500Interface::SetMotorsMessage)(ini_vacuuming,ini_main,ini_side));
01124     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Roomba500Interface::SetMotorsMessage");
01125     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01126   }
01127  }
01128  return 1;
01129 #ifndef TOLUA_RELEASE
01130  tolua_lerror:
01131  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
01132  return 0;
01133 #endif
01134 }
01135 #endif //#ifndef TOLUA_DISABLE
01136 
01137 /* method: new of class  SetMotorsMessage */
01138 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetMotorsMessage_new01
01139 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetMotorsMessage_new01(lua_State* tolua_S)
01140 {
01141  tolua_Error tolua_err;
01142  if (
01143      !tolua_isusertable(tolua_S,1,"fawkes::Roomba500Interface::SetMotorsMessage",0,&tolua_err) ||
01144      !tolua_isnoobj(tolua_S,2,&tolua_err)
01145  )
01146   goto tolua_lerror;
01147  else
01148  {
01149   {
01150    fawkes::Roomba500Interface::SetMotorsMessage* tolua_ret = (fawkes::Roomba500Interface::SetMotorsMessage*)  Mtolua_new((fawkes::Roomba500Interface::SetMotorsMessage)());
01151     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Roomba500Interface::SetMotorsMessage");
01152   }
01153  }
01154  return 1;
01155 tolua_lerror:
01156  return tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetMotorsMessage_new00(tolua_S);
01157 }
01158 #endif //#ifndef TOLUA_DISABLE
01159 
01160 /* method: new_local of class  SetMotorsMessage */
01161 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetMotorsMessage_new01_local
01162 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetMotorsMessage_new01_local(lua_State* tolua_S)
01163 {
01164  tolua_Error tolua_err;
01165  if (
01166      !tolua_isusertable(tolua_S,1,"fawkes::Roomba500Interface::SetMotorsMessage",0,&tolua_err) ||
01167      !tolua_isnoobj(tolua_S,2,&tolua_err)
01168  )
01169   goto tolua_lerror;
01170  else
01171  {
01172   {
01173    fawkes::Roomba500Interface::SetMotorsMessage* tolua_ret = (fawkes::Roomba500Interface::SetMotorsMessage*)  Mtolua_new((fawkes::Roomba500Interface::SetMotorsMessage)());
01174     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Roomba500Interface::SetMotorsMessage");
01175     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01176   }
01177  }
01178  return 1;
01179 tolua_lerror:
01180  return tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetMotorsMessage_new00_local(tolua_S);
01181 }
01182 #endif //#ifndef TOLUA_DISABLE
01183 
01184 /* method: delete of class  SetMotorsMessage */
01185 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetMotorsMessage_delete00
01186 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetMotorsMessage_delete00(lua_State* tolua_S)
01187 {
01188 #ifndef TOLUA_RELEASE
01189  tolua_Error tolua_err;
01190  if (
01191      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface::SetMotorsMessage",0,&tolua_err) ||
01192      !tolua_isnoobj(tolua_S,2,&tolua_err)
01193  )
01194   goto tolua_lerror;
01195  else
01196 #endif
01197  {
01198   fawkes::Roomba500Interface::SetMotorsMessage* self = (fawkes::Roomba500Interface::SetMotorsMessage*)  tolua_tousertype(tolua_S,1,0);
01199 #ifndef TOLUA_RELEASE
01200   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
01201 #endif
01202   Mtolua_delete(self);
01203  }
01204  return 0;
01205 #ifndef TOLUA_RELEASE
01206  tolua_lerror:
01207  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
01208  return 0;
01209 #endif
01210 }
01211 #endif //#ifndef TOLUA_DISABLE
01212 
01213 /* method: is_vacuuming of class  SetMotorsMessage */
01214 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetMotorsMessage_is_vacuuming00
01215 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetMotorsMessage_is_vacuuming00(lua_State* tolua_S)
01216 {
01217 #ifndef TOLUA_RELEASE
01218  tolua_Error tolua_err;
01219  if (
01220      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface::SetMotorsMessage",0,&tolua_err) ||
01221      !tolua_isnoobj(tolua_S,2,&tolua_err)
01222  )
01223   goto tolua_lerror;
01224  else
01225 #endif
01226  {
01227   fawkes::Roomba500Interface::SetMotorsMessage* self = (fawkes::Roomba500Interface::SetMotorsMessage*)  tolua_tousertype(tolua_S,1,0);
01228 #ifndef TOLUA_RELEASE
01229   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_vacuuming'", NULL);
01230 #endif
01231   {
01232    bool tolua_ret = (bool)  self->is_vacuuming();
01233    tolua_pushboolean(tolua_S,(bool)tolua_ret);
01234   }
01235  }
01236  return 1;
01237 #ifndef TOLUA_RELEASE
01238  tolua_lerror:
01239  tolua_error(tolua_S,"#ferror in function 'is_vacuuming'.",&tolua_err);
01240  return 0;
01241 #endif
01242 }
01243 #endif //#ifndef TOLUA_DISABLE
01244 
01245 /* method: set_vacuuming of class  SetMotorsMessage */
01246 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetMotorsMessage_set_vacuuming00
01247 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetMotorsMessage_set_vacuuming00(lua_State* tolua_S)
01248 {
01249 #ifndef TOLUA_RELEASE
01250  tolua_Error tolua_err;
01251  if (
01252      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface::SetMotorsMessage",0,&tolua_err) ||
01253      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
01254      !tolua_isnoobj(tolua_S,3,&tolua_err)
01255  )
01256   goto tolua_lerror;
01257  else
01258 #endif
01259  {
01260   fawkes::Roomba500Interface::SetMotorsMessage* self = (fawkes::Roomba500Interface::SetMotorsMessage*)  tolua_tousertype(tolua_S,1,0);
01261   const bool new_vacuuming = ((const bool)  tolua_toboolean(tolua_S,2,0));
01262 #ifndef TOLUA_RELEASE
01263   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_vacuuming'", NULL);
01264 #endif
01265   {
01266    self->set_vacuuming(new_vacuuming);
01267   }
01268  }
01269  return 0;
01270 #ifndef TOLUA_RELEASE
01271  tolua_lerror:
01272  tolua_error(tolua_S,"#ferror in function 'set_vacuuming'.",&tolua_err);
01273  return 0;
01274 #endif
01275 }
01276 #endif //#ifndef TOLUA_DISABLE
01277 
01278 /* method: maxlenof_vacuuming of class  SetMotorsMessage */
01279 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetMotorsMessage_maxlenof_vacuuming00
01280 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetMotorsMessage_maxlenof_vacuuming00(lua_State* tolua_S)
01281 {
01282 #ifndef TOLUA_RELEASE
01283  tolua_Error tolua_err;
01284  if (
01285      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface::SetMotorsMessage",0,&tolua_err) ||
01286      !tolua_isnoobj(tolua_S,2,&tolua_err)
01287  )
01288   goto tolua_lerror;
01289  else
01290 #endif
01291  {
01292   const fawkes::Roomba500Interface::SetMotorsMessage* self = (const fawkes::Roomba500Interface::SetMotorsMessage*)  tolua_tousertype(tolua_S,1,0);
01293 #ifndef TOLUA_RELEASE
01294   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_vacuuming'", NULL);
01295 #endif
01296   {
01297    int tolua_ret = (int)  self->maxlenof_vacuuming();
01298    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01299   }
01300  }
01301  return 1;
01302 #ifndef TOLUA_RELEASE
01303  tolua_lerror:
01304  tolua_error(tolua_S,"#ferror in function 'maxlenof_vacuuming'.",&tolua_err);
01305  return 0;
01306 #endif
01307 }
01308 #endif //#ifndef TOLUA_DISABLE
01309 
01310 /* method: main of class  SetMotorsMessage */
01311 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetMotorsMessage_main00
01312 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetMotorsMessage_main00(lua_State* tolua_S)
01313 {
01314 #ifndef TOLUA_RELEASE
01315  tolua_Error tolua_err;
01316  if (
01317      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface::SetMotorsMessage",0,&tolua_err) ||
01318      !tolua_isnoobj(tolua_S,2,&tolua_err)
01319  )
01320   goto tolua_lerror;
01321  else
01322 #endif
01323  {
01324   fawkes::Roomba500Interface::SetMotorsMessage* self = (fawkes::Roomba500Interface::SetMotorsMessage*)  tolua_tousertype(tolua_S,1,0);
01325 #ifndef TOLUA_RELEASE
01326   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'main'", NULL);
01327 #endif
01328   {
01329    fawkes::Roomba500Interface::BrushState tolua_ret = (fawkes::Roomba500Interface::BrushState)  self->main();
01330    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01331   }
01332  }
01333  return 1;
01334 #ifndef TOLUA_RELEASE
01335  tolua_lerror:
01336  tolua_error(tolua_S,"#ferror in function 'main'.",&tolua_err);
01337  return 0;
01338 #endif
01339 }
01340 #endif //#ifndef TOLUA_DISABLE
01341 
01342 /* method: set_main of class  SetMotorsMessage */
01343 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetMotorsMessage_set_main00
01344 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetMotorsMessage_set_main00(lua_State* tolua_S)
01345 {
01346 #ifndef TOLUA_RELEASE
01347  tolua_Error tolua_err;
01348  if (
01349      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface::SetMotorsMessage",0,&tolua_err) ||
01350      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01351      !tolua_isnoobj(tolua_S,3,&tolua_err)
01352  )
01353   goto tolua_lerror;
01354  else
01355 #endif
01356  {
01357   fawkes::Roomba500Interface::SetMotorsMessage* self = (fawkes::Roomba500Interface::SetMotorsMessage*)  tolua_tousertype(tolua_S,1,0);
01358   const fawkes::Roomba500Interface::BrushState new_main = ((const fawkes::Roomba500Interface::BrushState) (int)  tolua_tonumber(tolua_S,2,0));
01359 #ifndef TOLUA_RELEASE
01360   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_main'", NULL);
01361 #endif
01362   {
01363    self->set_main(new_main);
01364   }
01365  }
01366  return 0;
01367 #ifndef TOLUA_RELEASE
01368  tolua_lerror:
01369  tolua_error(tolua_S,"#ferror in function 'set_main'.",&tolua_err);
01370  return 0;
01371 #endif
01372 }
01373 #endif //#ifndef TOLUA_DISABLE
01374 
01375 /* method: maxlenof_main of class  SetMotorsMessage */
01376 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetMotorsMessage_maxlenof_main00
01377 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetMotorsMessage_maxlenof_main00(lua_State* tolua_S)
01378 {
01379 #ifndef TOLUA_RELEASE
01380  tolua_Error tolua_err;
01381  if (
01382      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface::SetMotorsMessage",0,&tolua_err) ||
01383      !tolua_isnoobj(tolua_S,2,&tolua_err)
01384  )
01385   goto tolua_lerror;
01386  else
01387 #endif
01388  {
01389   const fawkes::Roomba500Interface::SetMotorsMessage* self = (const fawkes::Roomba500Interface::SetMotorsMessage*)  tolua_tousertype(tolua_S,1,0);
01390 #ifndef TOLUA_RELEASE
01391   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_main'", NULL);
01392 #endif
01393   {
01394    int tolua_ret = (int)  self->maxlenof_main();
01395    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01396   }
01397  }
01398  return 1;
01399 #ifndef TOLUA_RELEASE
01400  tolua_lerror:
01401  tolua_error(tolua_S,"#ferror in function 'maxlenof_main'.",&tolua_err);
01402  return 0;
01403 #endif
01404 }
01405 #endif //#ifndef TOLUA_DISABLE
01406 
01407 /* method: side of class  SetMotorsMessage */
01408 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetMotorsMessage_side00
01409 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetMotorsMessage_side00(lua_State* tolua_S)
01410 {
01411 #ifndef TOLUA_RELEASE
01412  tolua_Error tolua_err;
01413  if (
01414      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface::SetMotorsMessage",0,&tolua_err) ||
01415      !tolua_isnoobj(tolua_S,2,&tolua_err)
01416  )
01417   goto tolua_lerror;
01418  else
01419 #endif
01420  {
01421   fawkes::Roomba500Interface::SetMotorsMessage* self = (fawkes::Roomba500Interface::SetMotorsMessage*)  tolua_tousertype(tolua_S,1,0);
01422 #ifndef TOLUA_RELEASE
01423   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'side'", NULL);
01424 #endif
01425   {
01426    fawkes::Roomba500Interface::BrushState tolua_ret = (fawkes::Roomba500Interface::BrushState)  self->side();
01427    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01428   }
01429  }
01430  return 1;
01431 #ifndef TOLUA_RELEASE
01432  tolua_lerror:
01433  tolua_error(tolua_S,"#ferror in function 'side'.",&tolua_err);
01434  return 0;
01435 #endif
01436 }
01437 #endif //#ifndef TOLUA_DISABLE
01438 
01439 /* method: set_side of class  SetMotorsMessage */
01440 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetMotorsMessage_set_side00
01441 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetMotorsMessage_set_side00(lua_State* tolua_S)
01442 {
01443 #ifndef TOLUA_RELEASE
01444  tolua_Error tolua_err;
01445  if (
01446      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface::SetMotorsMessage",0,&tolua_err) ||
01447      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01448      !tolua_isnoobj(tolua_S,3,&tolua_err)
01449  )
01450   goto tolua_lerror;
01451  else
01452 #endif
01453  {
01454   fawkes::Roomba500Interface::SetMotorsMessage* self = (fawkes::Roomba500Interface::SetMotorsMessage*)  tolua_tousertype(tolua_S,1,0);
01455   const fawkes::Roomba500Interface::BrushState new_side = ((const fawkes::Roomba500Interface::BrushState) (int)  tolua_tonumber(tolua_S,2,0));
01456 #ifndef TOLUA_RELEASE
01457   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_side'", NULL);
01458 #endif
01459   {
01460    self->set_side(new_side);
01461   }
01462  }
01463  return 0;
01464 #ifndef TOLUA_RELEASE
01465  tolua_lerror:
01466  tolua_error(tolua_S,"#ferror in function 'set_side'.",&tolua_err);
01467  return 0;
01468 #endif
01469 }
01470 #endif //#ifndef TOLUA_DISABLE
01471 
01472 /* method: maxlenof_side of class  SetMotorsMessage */
01473 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetMotorsMessage_maxlenof_side00
01474 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetMotorsMessage_maxlenof_side00(lua_State* tolua_S)
01475 {
01476 #ifndef TOLUA_RELEASE
01477  tolua_Error tolua_err;
01478  if (
01479      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface::SetMotorsMessage",0,&tolua_err) ||
01480      !tolua_isnoobj(tolua_S,2,&tolua_err)
01481  )
01482   goto tolua_lerror;
01483  else
01484 #endif
01485  {
01486   const fawkes::Roomba500Interface::SetMotorsMessage* self = (const fawkes::Roomba500Interface::SetMotorsMessage*)  tolua_tousertype(tolua_S,1,0);
01487 #ifndef TOLUA_RELEASE
01488   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_side'", NULL);
01489 #endif
01490   {
01491    int tolua_ret = (int)  self->maxlenof_side();
01492    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01493   }
01494  }
01495  return 1;
01496 #ifndef TOLUA_RELEASE
01497  tolua_lerror:
01498  tolua_error(tolua_S,"#ferror in function 'maxlenof_side'.",&tolua_err);
01499  return 0;
01500 #endif
01501 }
01502 #endif //#ifndef TOLUA_DISABLE
01503 
01504 /* method: mode of class  fawkes::Roomba500Interface */
01505 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_mode00
01506 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_mode00(lua_State* tolua_S)
01507 {
01508 #ifndef TOLUA_RELEASE
01509  tolua_Error tolua_err;
01510  if (
01511      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
01512      !tolua_isnoobj(tolua_S,2,&tolua_err)
01513  )
01514   goto tolua_lerror;
01515  else
01516 #endif
01517  {
01518   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
01519 #ifndef TOLUA_RELEASE
01520   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'mode'", NULL);
01521 #endif
01522   {
01523    fawkes::Roomba500Interface::Mode tolua_ret = (fawkes::Roomba500Interface::Mode)  self->mode();
01524    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01525   }
01526  }
01527  return 1;
01528 #ifndef TOLUA_RELEASE
01529  tolua_lerror:
01530  tolua_error(tolua_S,"#ferror in function 'mode'.",&tolua_err);
01531  return 0;
01532 #endif
01533 }
01534 #endif //#ifndef TOLUA_DISABLE
01535 
01536 /* method: set_mode of class  fawkes::Roomba500Interface */
01537 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_mode00
01538 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_mode00(lua_State* tolua_S)
01539 {
01540 #ifndef TOLUA_RELEASE
01541  tolua_Error tolua_err;
01542  if (
01543      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
01544      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01545      !tolua_isnoobj(tolua_S,3,&tolua_err)
01546  )
01547   goto tolua_lerror;
01548  else
01549 #endif
01550  {
01551   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
01552   const fawkes::Roomba500Interface::Mode new_mode = ((const fawkes::Roomba500Interface::Mode) (int)  tolua_tonumber(tolua_S,2,0));
01553 #ifndef TOLUA_RELEASE
01554   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_mode'", NULL);
01555 #endif
01556   {
01557    self->set_mode(new_mode);
01558   }
01559  }
01560  return 0;
01561 #ifndef TOLUA_RELEASE
01562  tolua_lerror:
01563  tolua_error(tolua_S,"#ferror in function 'set_mode'.",&tolua_err);
01564  return 0;
01565 #endif
01566 }
01567 #endif //#ifndef TOLUA_DISABLE
01568 
01569 /* method: maxlenof_mode of class  fawkes::Roomba500Interface */
01570 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_mode00
01571 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_mode00(lua_State* tolua_S)
01572 {
01573 #ifndef TOLUA_RELEASE
01574  tolua_Error tolua_err;
01575  if (
01576      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
01577      !tolua_isnoobj(tolua_S,2,&tolua_err)
01578  )
01579   goto tolua_lerror;
01580  else
01581 #endif
01582  {
01583   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
01584 #ifndef TOLUA_RELEASE
01585   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_mode'", NULL);
01586 #endif
01587   {
01588    int tolua_ret = (int)  self->maxlenof_mode();
01589    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01590   }
01591  }
01592  return 1;
01593 #ifndef TOLUA_RELEASE
01594  tolua_lerror:
01595  tolua_error(tolua_S,"#ferror in function 'maxlenof_mode'.",&tolua_err);
01596  return 0;
01597 #endif
01598 }
01599 #endif //#ifndef TOLUA_DISABLE
01600 
01601 /* method: is_wheel_drop_left of class  fawkes::Roomba500Interface */
01602 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_wheel_drop_left00
01603 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_wheel_drop_left00(lua_State* tolua_S)
01604 {
01605 #ifndef TOLUA_RELEASE
01606  tolua_Error tolua_err;
01607  if (
01608      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
01609      !tolua_isnoobj(tolua_S,2,&tolua_err)
01610  )
01611   goto tolua_lerror;
01612  else
01613 #endif
01614  {
01615   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
01616 #ifndef TOLUA_RELEASE
01617   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_wheel_drop_left'", NULL);
01618 #endif
01619   {
01620    bool tolua_ret = (bool)  self->is_wheel_drop_left();
01621    tolua_pushboolean(tolua_S,(bool)tolua_ret);
01622   }
01623  }
01624  return 1;
01625 #ifndef TOLUA_RELEASE
01626  tolua_lerror:
01627  tolua_error(tolua_S,"#ferror in function 'is_wheel_drop_left'.",&tolua_err);
01628  return 0;
01629 #endif
01630 }
01631 #endif //#ifndef TOLUA_DISABLE
01632 
01633 /* method: set_wheel_drop_left of class  fawkes::Roomba500Interface */
01634 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_wheel_drop_left00
01635 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_wheel_drop_left00(lua_State* tolua_S)
01636 {
01637 #ifndef TOLUA_RELEASE
01638  tolua_Error tolua_err;
01639  if (
01640      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
01641      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
01642      !tolua_isnoobj(tolua_S,3,&tolua_err)
01643  )
01644   goto tolua_lerror;
01645  else
01646 #endif
01647  {
01648   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
01649   const bool new_wheel_drop_left = ((const bool)  tolua_toboolean(tolua_S,2,0));
01650 #ifndef TOLUA_RELEASE
01651   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_wheel_drop_left'", NULL);
01652 #endif
01653   {
01654    self->set_wheel_drop_left(new_wheel_drop_left);
01655   }
01656  }
01657  return 0;
01658 #ifndef TOLUA_RELEASE
01659  tolua_lerror:
01660  tolua_error(tolua_S,"#ferror in function 'set_wheel_drop_left'.",&tolua_err);
01661  return 0;
01662 #endif
01663 }
01664 #endif //#ifndef TOLUA_DISABLE
01665 
01666 /* method: maxlenof_wheel_drop_left of class  fawkes::Roomba500Interface */
01667 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_wheel_drop_left00
01668 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_wheel_drop_left00(lua_State* tolua_S)
01669 {
01670 #ifndef TOLUA_RELEASE
01671  tolua_Error tolua_err;
01672  if (
01673      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
01674      !tolua_isnoobj(tolua_S,2,&tolua_err)
01675  )
01676   goto tolua_lerror;
01677  else
01678 #endif
01679  {
01680   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
01681 #ifndef TOLUA_RELEASE
01682   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_wheel_drop_left'", NULL);
01683 #endif
01684   {
01685    int tolua_ret = (int)  self->maxlenof_wheel_drop_left();
01686    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01687   }
01688  }
01689  return 1;
01690 #ifndef TOLUA_RELEASE
01691  tolua_lerror:
01692  tolua_error(tolua_S,"#ferror in function 'maxlenof_wheel_drop_left'.",&tolua_err);
01693  return 0;
01694 #endif
01695 }
01696 #endif //#ifndef TOLUA_DISABLE
01697 
01698 /* method: is_wheel_drop_right of class  fawkes::Roomba500Interface */
01699 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_wheel_drop_right00
01700 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_wheel_drop_right00(lua_State* tolua_S)
01701 {
01702 #ifndef TOLUA_RELEASE
01703  tolua_Error tolua_err;
01704  if (
01705      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
01706      !tolua_isnoobj(tolua_S,2,&tolua_err)
01707  )
01708   goto tolua_lerror;
01709  else
01710 #endif
01711  {
01712   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
01713 #ifndef TOLUA_RELEASE
01714   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_wheel_drop_right'", NULL);
01715 #endif
01716   {
01717    bool tolua_ret = (bool)  self->is_wheel_drop_right();
01718    tolua_pushboolean(tolua_S,(bool)tolua_ret);
01719   }
01720  }
01721  return 1;
01722 #ifndef TOLUA_RELEASE
01723  tolua_lerror:
01724  tolua_error(tolua_S,"#ferror in function 'is_wheel_drop_right'.",&tolua_err);
01725  return 0;
01726 #endif
01727 }
01728 #endif //#ifndef TOLUA_DISABLE
01729 
01730 /* method: set_wheel_drop_right of class  fawkes::Roomba500Interface */
01731 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_wheel_drop_right00
01732 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_wheel_drop_right00(lua_State* tolua_S)
01733 {
01734 #ifndef TOLUA_RELEASE
01735  tolua_Error tolua_err;
01736  if (
01737      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
01738      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
01739      !tolua_isnoobj(tolua_S,3,&tolua_err)
01740  )
01741   goto tolua_lerror;
01742  else
01743 #endif
01744  {
01745   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
01746   const bool new_wheel_drop_right = ((const bool)  tolua_toboolean(tolua_S,2,0));
01747 #ifndef TOLUA_RELEASE
01748   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_wheel_drop_right'", NULL);
01749 #endif
01750   {
01751    self->set_wheel_drop_right(new_wheel_drop_right);
01752   }
01753  }
01754  return 0;
01755 #ifndef TOLUA_RELEASE
01756  tolua_lerror:
01757  tolua_error(tolua_S,"#ferror in function 'set_wheel_drop_right'.",&tolua_err);
01758  return 0;
01759 #endif
01760 }
01761 #endif //#ifndef TOLUA_DISABLE
01762 
01763 /* method: maxlenof_wheel_drop_right of class  fawkes::Roomba500Interface */
01764 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_wheel_drop_right00
01765 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_wheel_drop_right00(lua_State* tolua_S)
01766 {
01767 #ifndef TOLUA_RELEASE
01768  tolua_Error tolua_err;
01769  if (
01770      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
01771      !tolua_isnoobj(tolua_S,2,&tolua_err)
01772  )
01773   goto tolua_lerror;
01774  else
01775 #endif
01776  {
01777   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
01778 #ifndef TOLUA_RELEASE
01779   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_wheel_drop_right'", NULL);
01780 #endif
01781   {
01782    int tolua_ret = (int)  self->maxlenof_wheel_drop_right();
01783    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01784   }
01785  }
01786  return 1;
01787 #ifndef TOLUA_RELEASE
01788  tolua_lerror:
01789  tolua_error(tolua_S,"#ferror in function 'maxlenof_wheel_drop_right'.",&tolua_err);
01790  return 0;
01791 #endif
01792 }
01793 #endif //#ifndef TOLUA_DISABLE
01794 
01795 /* method: is_bump_left of class  fawkes::Roomba500Interface */
01796 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_bump_left00
01797 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_bump_left00(lua_State* tolua_S)
01798 {
01799 #ifndef TOLUA_RELEASE
01800  tolua_Error tolua_err;
01801  if (
01802      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
01803      !tolua_isnoobj(tolua_S,2,&tolua_err)
01804  )
01805   goto tolua_lerror;
01806  else
01807 #endif
01808  {
01809   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
01810 #ifndef TOLUA_RELEASE
01811   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_bump_left'", NULL);
01812 #endif
01813   {
01814    bool tolua_ret = (bool)  self->is_bump_left();
01815    tolua_pushboolean(tolua_S,(bool)tolua_ret);
01816   }
01817  }
01818  return 1;
01819 #ifndef TOLUA_RELEASE
01820  tolua_lerror:
01821  tolua_error(tolua_S,"#ferror in function 'is_bump_left'.",&tolua_err);
01822  return 0;
01823 #endif
01824 }
01825 #endif //#ifndef TOLUA_DISABLE
01826 
01827 /* method: set_bump_left of class  fawkes::Roomba500Interface */
01828 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_bump_left00
01829 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_bump_left00(lua_State* tolua_S)
01830 {
01831 #ifndef TOLUA_RELEASE
01832  tolua_Error tolua_err;
01833  if (
01834      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
01835      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
01836      !tolua_isnoobj(tolua_S,3,&tolua_err)
01837  )
01838   goto tolua_lerror;
01839  else
01840 #endif
01841  {
01842   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
01843   const bool new_bump_left = ((const bool)  tolua_toboolean(tolua_S,2,0));
01844 #ifndef TOLUA_RELEASE
01845   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_bump_left'", NULL);
01846 #endif
01847   {
01848    self->set_bump_left(new_bump_left);
01849   }
01850  }
01851  return 0;
01852 #ifndef TOLUA_RELEASE
01853  tolua_lerror:
01854  tolua_error(tolua_S,"#ferror in function 'set_bump_left'.",&tolua_err);
01855  return 0;
01856 #endif
01857 }
01858 #endif //#ifndef TOLUA_DISABLE
01859 
01860 /* method: maxlenof_bump_left of class  fawkes::Roomba500Interface */
01861 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_bump_left00
01862 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_bump_left00(lua_State* tolua_S)
01863 {
01864 #ifndef TOLUA_RELEASE
01865  tolua_Error tolua_err;
01866  if (
01867      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
01868      !tolua_isnoobj(tolua_S,2,&tolua_err)
01869  )
01870   goto tolua_lerror;
01871  else
01872 #endif
01873  {
01874   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
01875 #ifndef TOLUA_RELEASE
01876   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_bump_left'", NULL);
01877 #endif
01878   {
01879    int tolua_ret = (int)  self->maxlenof_bump_left();
01880    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01881   }
01882  }
01883  return 1;
01884 #ifndef TOLUA_RELEASE
01885  tolua_lerror:
01886  tolua_error(tolua_S,"#ferror in function 'maxlenof_bump_left'.",&tolua_err);
01887  return 0;
01888 #endif
01889 }
01890 #endif //#ifndef TOLUA_DISABLE
01891 
01892 /* method: is_bump_right of class  fawkes::Roomba500Interface */
01893 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_bump_right00
01894 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_bump_right00(lua_State* tolua_S)
01895 {
01896 #ifndef TOLUA_RELEASE
01897  tolua_Error tolua_err;
01898  if (
01899      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
01900      !tolua_isnoobj(tolua_S,2,&tolua_err)
01901  )
01902   goto tolua_lerror;
01903  else
01904 #endif
01905  {
01906   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
01907 #ifndef TOLUA_RELEASE
01908   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_bump_right'", NULL);
01909 #endif
01910   {
01911    bool tolua_ret = (bool)  self->is_bump_right();
01912    tolua_pushboolean(tolua_S,(bool)tolua_ret);
01913   }
01914  }
01915  return 1;
01916 #ifndef TOLUA_RELEASE
01917  tolua_lerror:
01918  tolua_error(tolua_S,"#ferror in function 'is_bump_right'.",&tolua_err);
01919  return 0;
01920 #endif
01921 }
01922 #endif //#ifndef TOLUA_DISABLE
01923 
01924 /* method: set_bump_right of class  fawkes::Roomba500Interface */
01925 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_bump_right00
01926 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_bump_right00(lua_State* tolua_S)
01927 {
01928 #ifndef TOLUA_RELEASE
01929  tolua_Error tolua_err;
01930  if (
01931      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
01932      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
01933      !tolua_isnoobj(tolua_S,3,&tolua_err)
01934  )
01935   goto tolua_lerror;
01936  else
01937 #endif
01938  {
01939   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
01940   const bool new_bump_right = ((const bool)  tolua_toboolean(tolua_S,2,0));
01941 #ifndef TOLUA_RELEASE
01942   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_bump_right'", NULL);
01943 #endif
01944   {
01945    self->set_bump_right(new_bump_right);
01946   }
01947  }
01948  return 0;
01949 #ifndef TOLUA_RELEASE
01950  tolua_lerror:
01951  tolua_error(tolua_S,"#ferror in function 'set_bump_right'.",&tolua_err);
01952  return 0;
01953 #endif
01954 }
01955 #endif //#ifndef TOLUA_DISABLE
01956 
01957 /* method: maxlenof_bump_right of class  fawkes::Roomba500Interface */
01958 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_bump_right00
01959 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_bump_right00(lua_State* tolua_S)
01960 {
01961 #ifndef TOLUA_RELEASE
01962  tolua_Error tolua_err;
01963  if (
01964      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
01965      !tolua_isnoobj(tolua_S,2,&tolua_err)
01966  )
01967   goto tolua_lerror;
01968  else
01969 #endif
01970  {
01971   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
01972 #ifndef TOLUA_RELEASE
01973   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_bump_right'", NULL);
01974 #endif
01975   {
01976    int tolua_ret = (int)  self->maxlenof_bump_right();
01977    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01978   }
01979  }
01980  return 1;
01981 #ifndef TOLUA_RELEASE
01982  tolua_lerror:
01983  tolua_error(tolua_S,"#ferror in function 'maxlenof_bump_right'.",&tolua_err);
01984  return 0;
01985 #endif
01986 }
01987 #endif //#ifndef TOLUA_DISABLE
01988 
01989 /* method: is_wall of class  fawkes::Roomba500Interface */
01990 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_wall00
01991 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_wall00(lua_State* tolua_S)
01992 {
01993 #ifndef TOLUA_RELEASE
01994  tolua_Error tolua_err;
01995  if (
01996      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
01997      !tolua_isnoobj(tolua_S,2,&tolua_err)
01998  )
01999   goto tolua_lerror;
02000  else
02001 #endif
02002  {
02003   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
02004 #ifndef TOLUA_RELEASE
02005   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_wall'", NULL);
02006 #endif
02007   {
02008    bool tolua_ret = (bool)  self->is_wall();
02009    tolua_pushboolean(tolua_S,(bool)tolua_ret);
02010   }
02011  }
02012  return 1;
02013 #ifndef TOLUA_RELEASE
02014  tolua_lerror:
02015  tolua_error(tolua_S,"#ferror in function 'is_wall'.",&tolua_err);
02016  return 0;
02017 #endif
02018 }
02019 #endif //#ifndef TOLUA_DISABLE
02020 
02021 /* method: set_wall of class  fawkes::Roomba500Interface */
02022 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_wall00
02023 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_wall00(lua_State* tolua_S)
02024 {
02025 #ifndef TOLUA_RELEASE
02026  tolua_Error tolua_err;
02027  if (
02028      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
02029      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
02030      !tolua_isnoobj(tolua_S,3,&tolua_err)
02031  )
02032   goto tolua_lerror;
02033  else
02034 #endif
02035  {
02036   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
02037   const bool new_wall = ((const bool)  tolua_toboolean(tolua_S,2,0));
02038 #ifndef TOLUA_RELEASE
02039   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_wall'", NULL);
02040 #endif
02041   {
02042    self->set_wall(new_wall);
02043   }
02044  }
02045  return 0;
02046 #ifndef TOLUA_RELEASE
02047  tolua_lerror:
02048  tolua_error(tolua_S,"#ferror in function 'set_wall'.",&tolua_err);
02049  return 0;
02050 #endif
02051 }
02052 #endif //#ifndef TOLUA_DISABLE
02053 
02054 /* method: maxlenof_wall of class  fawkes::Roomba500Interface */
02055 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_wall00
02056 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_wall00(lua_State* tolua_S)
02057 {
02058 #ifndef TOLUA_RELEASE
02059  tolua_Error tolua_err;
02060  if (
02061      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
02062      !tolua_isnoobj(tolua_S,2,&tolua_err)
02063  )
02064   goto tolua_lerror;
02065  else
02066 #endif
02067  {
02068   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
02069 #ifndef TOLUA_RELEASE
02070   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_wall'", NULL);
02071 #endif
02072   {
02073    int tolua_ret = (int)  self->maxlenof_wall();
02074    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02075   }
02076  }
02077  return 1;
02078 #ifndef TOLUA_RELEASE
02079  tolua_lerror:
02080  tolua_error(tolua_S,"#ferror in function 'maxlenof_wall'.",&tolua_err);
02081  return 0;
02082 #endif
02083 }
02084 #endif //#ifndef TOLUA_DISABLE
02085 
02086 /* method: is_cliff_left of class  fawkes::Roomba500Interface */
02087 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_cliff_left00
02088 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_cliff_left00(lua_State* tolua_S)
02089 {
02090 #ifndef TOLUA_RELEASE
02091  tolua_Error tolua_err;
02092  if (
02093      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
02094      !tolua_isnoobj(tolua_S,2,&tolua_err)
02095  )
02096   goto tolua_lerror;
02097  else
02098 #endif
02099  {
02100   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
02101 #ifndef TOLUA_RELEASE
02102   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_cliff_left'", NULL);
02103 #endif
02104   {
02105    bool tolua_ret = (bool)  self->is_cliff_left();
02106    tolua_pushboolean(tolua_S,(bool)tolua_ret);
02107   }
02108  }
02109  return 1;
02110 #ifndef TOLUA_RELEASE
02111  tolua_lerror:
02112  tolua_error(tolua_S,"#ferror in function 'is_cliff_left'.",&tolua_err);
02113  return 0;
02114 #endif
02115 }
02116 #endif //#ifndef TOLUA_DISABLE
02117 
02118 /* method: set_cliff_left of class  fawkes::Roomba500Interface */
02119 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_cliff_left00
02120 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_cliff_left00(lua_State* tolua_S)
02121 {
02122 #ifndef TOLUA_RELEASE
02123  tolua_Error tolua_err;
02124  if (
02125      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
02126      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
02127      !tolua_isnoobj(tolua_S,3,&tolua_err)
02128  )
02129   goto tolua_lerror;
02130  else
02131 #endif
02132  {
02133   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
02134   const bool new_cliff_left = ((const bool)  tolua_toboolean(tolua_S,2,0));
02135 #ifndef TOLUA_RELEASE
02136   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_cliff_left'", NULL);
02137 #endif
02138   {
02139    self->set_cliff_left(new_cliff_left);
02140   }
02141  }
02142  return 0;
02143 #ifndef TOLUA_RELEASE
02144  tolua_lerror:
02145  tolua_error(tolua_S,"#ferror in function 'set_cliff_left'.",&tolua_err);
02146  return 0;
02147 #endif
02148 }
02149 #endif //#ifndef TOLUA_DISABLE
02150 
02151 /* method: maxlenof_cliff_left of class  fawkes::Roomba500Interface */
02152 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_cliff_left00
02153 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_cliff_left00(lua_State* tolua_S)
02154 {
02155 #ifndef TOLUA_RELEASE
02156  tolua_Error tolua_err;
02157  if (
02158      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
02159      !tolua_isnoobj(tolua_S,2,&tolua_err)
02160  )
02161   goto tolua_lerror;
02162  else
02163 #endif
02164  {
02165   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
02166 #ifndef TOLUA_RELEASE
02167   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_cliff_left'", NULL);
02168 #endif
02169   {
02170    int tolua_ret = (int)  self->maxlenof_cliff_left();
02171    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02172   }
02173  }
02174  return 1;
02175 #ifndef TOLUA_RELEASE
02176  tolua_lerror:
02177  tolua_error(tolua_S,"#ferror in function 'maxlenof_cliff_left'.",&tolua_err);
02178  return 0;
02179 #endif
02180 }
02181 #endif //#ifndef TOLUA_DISABLE
02182 
02183 /* method: is_cliff_front_left of class  fawkes::Roomba500Interface */
02184 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_cliff_front_left00
02185 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_cliff_front_left00(lua_State* tolua_S)
02186 {
02187 #ifndef TOLUA_RELEASE
02188  tolua_Error tolua_err;
02189  if (
02190      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
02191      !tolua_isnoobj(tolua_S,2,&tolua_err)
02192  )
02193   goto tolua_lerror;
02194  else
02195 #endif
02196  {
02197   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
02198 #ifndef TOLUA_RELEASE
02199   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_cliff_front_left'", NULL);
02200 #endif
02201   {
02202    bool tolua_ret = (bool)  self->is_cliff_front_left();
02203    tolua_pushboolean(tolua_S,(bool)tolua_ret);
02204   }
02205  }
02206  return 1;
02207 #ifndef TOLUA_RELEASE
02208  tolua_lerror:
02209  tolua_error(tolua_S,"#ferror in function 'is_cliff_front_left'.",&tolua_err);
02210  return 0;
02211 #endif
02212 }
02213 #endif //#ifndef TOLUA_DISABLE
02214 
02215 /* method: set_cliff_front_left of class  fawkes::Roomba500Interface */
02216 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_cliff_front_left00
02217 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_cliff_front_left00(lua_State* tolua_S)
02218 {
02219 #ifndef TOLUA_RELEASE
02220  tolua_Error tolua_err;
02221  if (
02222      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
02223      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
02224      !tolua_isnoobj(tolua_S,3,&tolua_err)
02225  )
02226   goto tolua_lerror;
02227  else
02228 #endif
02229  {
02230   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
02231   const bool new_cliff_front_left = ((const bool)  tolua_toboolean(tolua_S,2,0));
02232 #ifndef TOLUA_RELEASE
02233   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_cliff_front_left'", NULL);
02234 #endif
02235   {
02236    self->set_cliff_front_left(new_cliff_front_left);
02237   }
02238  }
02239  return 0;
02240 #ifndef TOLUA_RELEASE
02241  tolua_lerror:
02242  tolua_error(tolua_S,"#ferror in function 'set_cliff_front_left'.",&tolua_err);
02243  return 0;
02244 #endif
02245 }
02246 #endif //#ifndef TOLUA_DISABLE
02247 
02248 /* method: maxlenof_cliff_front_left of class  fawkes::Roomba500Interface */
02249 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_cliff_front_left00
02250 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_cliff_front_left00(lua_State* tolua_S)
02251 {
02252 #ifndef TOLUA_RELEASE
02253  tolua_Error tolua_err;
02254  if (
02255      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
02256      !tolua_isnoobj(tolua_S,2,&tolua_err)
02257  )
02258   goto tolua_lerror;
02259  else
02260 #endif
02261  {
02262   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
02263 #ifndef TOLUA_RELEASE
02264   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_cliff_front_left'", NULL);
02265 #endif
02266   {
02267    int tolua_ret = (int)  self->maxlenof_cliff_front_left();
02268    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02269   }
02270  }
02271  return 1;
02272 #ifndef TOLUA_RELEASE
02273  tolua_lerror:
02274  tolua_error(tolua_S,"#ferror in function 'maxlenof_cliff_front_left'.",&tolua_err);
02275  return 0;
02276 #endif
02277 }
02278 #endif //#ifndef TOLUA_DISABLE
02279 
02280 /* method: is_cliff_front_right of class  fawkes::Roomba500Interface */
02281 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_cliff_front_right00
02282 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_cliff_front_right00(lua_State* tolua_S)
02283 {
02284 #ifndef TOLUA_RELEASE
02285  tolua_Error tolua_err;
02286  if (
02287      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
02288      !tolua_isnoobj(tolua_S,2,&tolua_err)
02289  )
02290   goto tolua_lerror;
02291  else
02292 #endif
02293  {
02294   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
02295 #ifndef TOLUA_RELEASE
02296   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_cliff_front_right'", NULL);
02297 #endif
02298   {
02299    bool tolua_ret = (bool)  self->is_cliff_front_right();
02300    tolua_pushboolean(tolua_S,(bool)tolua_ret);
02301   }
02302  }
02303  return 1;
02304 #ifndef TOLUA_RELEASE
02305  tolua_lerror:
02306  tolua_error(tolua_S,"#ferror in function 'is_cliff_front_right'.",&tolua_err);
02307  return 0;
02308 #endif
02309 }
02310 #endif //#ifndef TOLUA_DISABLE
02311 
02312 /* method: set_cliff_front_right of class  fawkes::Roomba500Interface */
02313 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_cliff_front_right00
02314 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_cliff_front_right00(lua_State* tolua_S)
02315 {
02316 #ifndef TOLUA_RELEASE
02317  tolua_Error tolua_err;
02318  if (
02319      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
02320      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
02321      !tolua_isnoobj(tolua_S,3,&tolua_err)
02322  )
02323   goto tolua_lerror;
02324  else
02325 #endif
02326  {
02327   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
02328   const bool new_cliff_front_right = ((const bool)  tolua_toboolean(tolua_S,2,0));
02329 #ifndef TOLUA_RELEASE
02330   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_cliff_front_right'", NULL);
02331 #endif
02332   {
02333    self->set_cliff_front_right(new_cliff_front_right);
02334   }
02335  }
02336  return 0;
02337 #ifndef TOLUA_RELEASE
02338  tolua_lerror:
02339  tolua_error(tolua_S,"#ferror in function 'set_cliff_front_right'.",&tolua_err);
02340  return 0;
02341 #endif
02342 }
02343 #endif //#ifndef TOLUA_DISABLE
02344 
02345 /* method: maxlenof_cliff_front_right of class  fawkes::Roomba500Interface */
02346 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_cliff_front_right00
02347 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_cliff_front_right00(lua_State* tolua_S)
02348 {
02349 #ifndef TOLUA_RELEASE
02350  tolua_Error tolua_err;
02351  if (
02352      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
02353      !tolua_isnoobj(tolua_S,2,&tolua_err)
02354  )
02355   goto tolua_lerror;
02356  else
02357 #endif
02358  {
02359   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
02360 #ifndef TOLUA_RELEASE
02361   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_cliff_front_right'", NULL);
02362 #endif
02363   {
02364    int tolua_ret = (int)  self->maxlenof_cliff_front_right();
02365    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02366   }
02367  }
02368  return 1;
02369 #ifndef TOLUA_RELEASE
02370  tolua_lerror:
02371  tolua_error(tolua_S,"#ferror in function 'maxlenof_cliff_front_right'.",&tolua_err);
02372  return 0;
02373 #endif
02374 }
02375 #endif //#ifndef TOLUA_DISABLE
02376 
02377 /* method: is_cliff_right of class  fawkes::Roomba500Interface */
02378 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_cliff_right00
02379 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_cliff_right00(lua_State* tolua_S)
02380 {
02381 #ifndef TOLUA_RELEASE
02382  tolua_Error tolua_err;
02383  if (
02384      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
02385      !tolua_isnoobj(tolua_S,2,&tolua_err)
02386  )
02387   goto tolua_lerror;
02388  else
02389 #endif
02390  {
02391   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
02392 #ifndef TOLUA_RELEASE
02393   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_cliff_right'", NULL);
02394 #endif
02395   {
02396    bool tolua_ret = (bool)  self->is_cliff_right();
02397    tolua_pushboolean(tolua_S,(bool)tolua_ret);
02398   }
02399  }
02400  return 1;
02401 #ifndef TOLUA_RELEASE
02402  tolua_lerror:
02403  tolua_error(tolua_S,"#ferror in function 'is_cliff_right'.",&tolua_err);
02404  return 0;
02405 #endif
02406 }
02407 #endif //#ifndef TOLUA_DISABLE
02408 
02409 /* method: set_cliff_right of class  fawkes::Roomba500Interface */
02410 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_cliff_right00
02411 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_cliff_right00(lua_State* tolua_S)
02412 {
02413 #ifndef TOLUA_RELEASE
02414  tolua_Error tolua_err;
02415  if (
02416      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
02417      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
02418      !tolua_isnoobj(tolua_S,3,&tolua_err)
02419  )
02420   goto tolua_lerror;
02421  else
02422 #endif
02423  {
02424   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
02425   const bool new_cliff_right = ((const bool)  tolua_toboolean(tolua_S,2,0));
02426 #ifndef TOLUA_RELEASE
02427   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_cliff_right'", NULL);
02428 #endif
02429   {
02430    self->set_cliff_right(new_cliff_right);
02431   }
02432  }
02433  return 0;
02434 #ifndef TOLUA_RELEASE
02435  tolua_lerror:
02436  tolua_error(tolua_S,"#ferror in function 'set_cliff_right'.",&tolua_err);
02437  return 0;
02438 #endif
02439 }
02440 #endif //#ifndef TOLUA_DISABLE
02441 
02442 /* method: maxlenof_cliff_right of class  fawkes::Roomba500Interface */
02443 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_cliff_right00
02444 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_cliff_right00(lua_State* tolua_S)
02445 {
02446 #ifndef TOLUA_RELEASE
02447  tolua_Error tolua_err;
02448  if (
02449      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
02450      !tolua_isnoobj(tolua_S,2,&tolua_err)
02451  )
02452   goto tolua_lerror;
02453  else
02454 #endif
02455  {
02456   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
02457 #ifndef TOLUA_RELEASE
02458   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_cliff_right'", NULL);
02459 #endif
02460   {
02461    int tolua_ret = (int)  self->maxlenof_cliff_right();
02462    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02463   }
02464  }
02465  return 1;
02466 #ifndef TOLUA_RELEASE
02467  tolua_lerror:
02468  tolua_error(tolua_S,"#ferror in function 'maxlenof_cliff_right'.",&tolua_err);
02469  return 0;
02470 #endif
02471 }
02472 #endif //#ifndef TOLUA_DISABLE
02473 
02474 /* method: is_virtual_wall of class  fawkes::Roomba500Interface */
02475 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_virtual_wall00
02476 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_virtual_wall00(lua_State* tolua_S)
02477 {
02478 #ifndef TOLUA_RELEASE
02479  tolua_Error tolua_err;
02480  if (
02481      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
02482      !tolua_isnoobj(tolua_S,2,&tolua_err)
02483  )
02484   goto tolua_lerror;
02485  else
02486 #endif
02487  {
02488   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
02489 #ifndef TOLUA_RELEASE
02490   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_virtual_wall'", NULL);
02491 #endif
02492   {
02493    bool tolua_ret = (bool)  self->is_virtual_wall();
02494    tolua_pushboolean(tolua_S,(bool)tolua_ret);
02495   }
02496  }
02497  return 1;
02498 #ifndef TOLUA_RELEASE
02499  tolua_lerror:
02500  tolua_error(tolua_S,"#ferror in function 'is_virtual_wall'.",&tolua_err);
02501  return 0;
02502 #endif
02503 }
02504 #endif //#ifndef TOLUA_DISABLE
02505 
02506 /* method: set_virtual_wall of class  fawkes::Roomba500Interface */
02507 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_virtual_wall00
02508 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_virtual_wall00(lua_State* tolua_S)
02509 {
02510 #ifndef TOLUA_RELEASE
02511  tolua_Error tolua_err;
02512  if (
02513      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
02514      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
02515      !tolua_isnoobj(tolua_S,3,&tolua_err)
02516  )
02517   goto tolua_lerror;
02518  else
02519 #endif
02520  {
02521   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
02522   const bool new_virtual_wall = ((const bool)  tolua_toboolean(tolua_S,2,0));
02523 #ifndef TOLUA_RELEASE
02524   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_virtual_wall'", NULL);
02525 #endif
02526   {
02527    self->set_virtual_wall(new_virtual_wall);
02528   }
02529  }
02530  return 0;
02531 #ifndef TOLUA_RELEASE
02532  tolua_lerror:
02533  tolua_error(tolua_S,"#ferror in function 'set_virtual_wall'.",&tolua_err);
02534  return 0;
02535 #endif
02536 }
02537 #endif //#ifndef TOLUA_DISABLE
02538 
02539 /* method: maxlenof_virtual_wall of class  fawkes::Roomba500Interface */
02540 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_virtual_wall00
02541 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_virtual_wall00(lua_State* tolua_S)
02542 {
02543 #ifndef TOLUA_RELEASE
02544  tolua_Error tolua_err;
02545  if (
02546      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
02547      !tolua_isnoobj(tolua_S,2,&tolua_err)
02548  )
02549   goto tolua_lerror;
02550  else
02551 #endif
02552  {
02553   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
02554 #ifndef TOLUA_RELEASE
02555   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_virtual_wall'", NULL);
02556 #endif
02557   {
02558    int tolua_ret = (int)  self->maxlenof_virtual_wall();
02559    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02560   }
02561  }
02562  return 1;
02563 #ifndef TOLUA_RELEASE
02564  tolua_lerror:
02565  tolua_error(tolua_S,"#ferror in function 'maxlenof_virtual_wall'.",&tolua_err);
02566  return 0;
02567 #endif
02568 }
02569 #endif //#ifndef TOLUA_DISABLE
02570 
02571 /* method: is_overcurrent_side_brush of class  fawkes::Roomba500Interface */
02572 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_overcurrent_side_brush00
02573 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_overcurrent_side_brush00(lua_State* tolua_S)
02574 {
02575 #ifndef TOLUA_RELEASE
02576  tolua_Error tolua_err;
02577  if (
02578      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
02579      !tolua_isnoobj(tolua_S,2,&tolua_err)
02580  )
02581   goto tolua_lerror;
02582  else
02583 #endif
02584  {
02585   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
02586 #ifndef TOLUA_RELEASE
02587   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_overcurrent_side_brush'", NULL);
02588 #endif
02589   {
02590    bool tolua_ret = (bool)  self->is_overcurrent_side_brush();
02591    tolua_pushboolean(tolua_S,(bool)tolua_ret);
02592   }
02593  }
02594  return 1;
02595 #ifndef TOLUA_RELEASE
02596  tolua_lerror:
02597  tolua_error(tolua_S,"#ferror in function 'is_overcurrent_side_brush'.",&tolua_err);
02598  return 0;
02599 #endif
02600 }
02601 #endif //#ifndef TOLUA_DISABLE
02602 
02603 /* method: set_overcurrent_side_brush of class  fawkes::Roomba500Interface */
02604 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_overcurrent_side_brush00
02605 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_overcurrent_side_brush00(lua_State* tolua_S)
02606 {
02607 #ifndef TOLUA_RELEASE
02608  tolua_Error tolua_err;
02609  if (
02610      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
02611      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
02612      !tolua_isnoobj(tolua_S,3,&tolua_err)
02613  )
02614   goto tolua_lerror;
02615  else
02616 #endif
02617  {
02618   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
02619   const bool new_overcurrent_side_brush = ((const bool)  tolua_toboolean(tolua_S,2,0));
02620 #ifndef TOLUA_RELEASE
02621   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_overcurrent_side_brush'", NULL);
02622 #endif
02623   {
02624    self->set_overcurrent_side_brush(new_overcurrent_side_brush);
02625   }
02626  }
02627  return 0;
02628 #ifndef TOLUA_RELEASE
02629  tolua_lerror:
02630  tolua_error(tolua_S,"#ferror in function 'set_overcurrent_side_brush'.",&tolua_err);
02631  return 0;
02632 #endif
02633 }
02634 #endif //#ifndef TOLUA_DISABLE
02635 
02636 /* method: maxlenof_overcurrent_side_brush of class  fawkes::Roomba500Interface */
02637 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_overcurrent_side_brush00
02638 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_overcurrent_side_brush00(lua_State* tolua_S)
02639 {
02640 #ifndef TOLUA_RELEASE
02641  tolua_Error tolua_err;
02642  if (
02643      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
02644      !tolua_isnoobj(tolua_S,2,&tolua_err)
02645  )
02646   goto tolua_lerror;
02647  else
02648 #endif
02649  {
02650   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
02651 #ifndef TOLUA_RELEASE
02652   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_overcurrent_side_brush'", NULL);
02653 #endif
02654   {
02655    int tolua_ret = (int)  self->maxlenof_overcurrent_side_brush();
02656    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02657   }
02658  }
02659  return 1;
02660 #ifndef TOLUA_RELEASE
02661  tolua_lerror:
02662  tolua_error(tolua_S,"#ferror in function 'maxlenof_overcurrent_side_brush'.",&tolua_err);
02663  return 0;
02664 #endif
02665 }
02666 #endif //#ifndef TOLUA_DISABLE
02667 
02668 /* method: is_overcurrent_main_brush of class  fawkes::Roomba500Interface */
02669 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_overcurrent_main_brush00
02670 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_overcurrent_main_brush00(lua_State* tolua_S)
02671 {
02672 #ifndef TOLUA_RELEASE
02673  tolua_Error tolua_err;
02674  if (
02675      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
02676      !tolua_isnoobj(tolua_S,2,&tolua_err)
02677  )
02678   goto tolua_lerror;
02679  else
02680 #endif
02681  {
02682   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
02683 #ifndef TOLUA_RELEASE
02684   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_overcurrent_main_brush'", NULL);
02685 #endif
02686   {
02687    bool tolua_ret = (bool)  self->is_overcurrent_main_brush();
02688    tolua_pushboolean(tolua_S,(bool)tolua_ret);
02689   }
02690  }
02691  return 1;
02692 #ifndef TOLUA_RELEASE
02693  tolua_lerror:
02694  tolua_error(tolua_S,"#ferror in function 'is_overcurrent_main_brush'.",&tolua_err);
02695  return 0;
02696 #endif
02697 }
02698 #endif //#ifndef TOLUA_DISABLE
02699 
02700 /* method: set_overcurrent_main_brush of class  fawkes::Roomba500Interface */
02701 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_overcurrent_main_brush00
02702 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_overcurrent_main_brush00(lua_State* tolua_S)
02703 {
02704 #ifndef TOLUA_RELEASE
02705  tolua_Error tolua_err;
02706  if (
02707      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
02708      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
02709      !tolua_isnoobj(tolua_S,3,&tolua_err)
02710  )
02711   goto tolua_lerror;
02712  else
02713 #endif
02714  {
02715   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
02716   const bool new_overcurrent_main_brush = ((const bool)  tolua_toboolean(tolua_S,2,0));
02717 #ifndef TOLUA_RELEASE
02718   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_overcurrent_main_brush'", NULL);
02719 #endif
02720   {
02721    self->set_overcurrent_main_brush(new_overcurrent_main_brush);
02722   }
02723  }
02724  return 0;
02725 #ifndef TOLUA_RELEASE
02726  tolua_lerror:
02727  tolua_error(tolua_S,"#ferror in function 'set_overcurrent_main_brush'.",&tolua_err);
02728  return 0;
02729 #endif
02730 }
02731 #endif //#ifndef TOLUA_DISABLE
02732 
02733 /* method: maxlenof_overcurrent_main_brush of class  fawkes::Roomba500Interface */
02734 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_overcurrent_main_brush00
02735 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_overcurrent_main_brush00(lua_State* tolua_S)
02736 {
02737 #ifndef TOLUA_RELEASE
02738  tolua_Error tolua_err;
02739  if (
02740      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
02741      !tolua_isnoobj(tolua_S,2,&tolua_err)
02742  )
02743   goto tolua_lerror;
02744  else
02745 #endif
02746  {
02747   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
02748 #ifndef TOLUA_RELEASE
02749   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_overcurrent_main_brush'", NULL);
02750 #endif
02751   {
02752    int tolua_ret = (int)  self->maxlenof_overcurrent_main_brush();
02753    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02754   }
02755  }
02756  return 1;
02757 #ifndef TOLUA_RELEASE
02758  tolua_lerror:
02759  tolua_error(tolua_S,"#ferror in function 'maxlenof_overcurrent_main_brush'.",&tolua_err);
02760  return 0;
02761 #endif
02762 }
02763 #endif //#ifndef TOLUA_DISABLE
02764 
02765 /* method: is_overcurrent_left_wheel of class  fawkes::Roomba500Interface */
02766 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_overcurrent_left_wheel00
02767 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_overcurrent_left_wheel00(lua_State* tolua_S)
02768 {
02769 #ifndef TOLUA_RELEASE
02770  tolua_Error tolua_err;
02771  if (
02772      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
02773      !tolua_isnoobj(tolua_S,2,&tolua_err)
02774  )
02775   goto tolua_lerror;
02776  else
02777 #endif
02778  {
02779   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
02780 #ifndef TOLUA_RELEASE
02781   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_overcurrent_left_wheel'", NULL);
02782 #endif
02783   {
02784    bool tolua_ret = (bool)  self->is_overcurrent_left_wheel();
02785    tolua_pushboolean(tolua_S,(bool)tolua_ret);
02786   }
02787  }
02788  return 1;
02789 #ifndef TOLUA_RELEASE
02790  tolua_lerror:
02791  tolua_error(tolua_S,"#ferror in function 'is_overcurrent_left_wheel'.",&tolua_err);
02792  return 0;
02793 #endif
02794 }
02795 #endif //#ifndef TOLUA_DISABLE
02796 
02797 /* method: set_overcurrent_left_wheel of class  fawkes::Roomba500Interface */
02798 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_overcurrent_left_wheel00
02799 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_overcurrent_left_wheel00(lua_State* tolua_S)
02800 {
02801 #ifndef TOLUA_RELEASE
02802  tolua_Error tolua_err;
02803  if (
02804      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
02805      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
02806      !tolua_isnoobj(tolua_S,3,&tolua_err)
02807  )
02808   goto tolua_lerror;
02809  else
02810 #endif
02811  {
02812   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
02813   const bool new_overcurrent_left_wheel = ((const bool)  tolua_toboolean(tolua_S,2,0));
02814 #ifndef TOLUA_RELEASE
02815   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_overcurrent_left_wheel'", NULL);
02816 #endif
02817   {
02818    self->set_overcurrent_left_wheel(new_overcurrent_left_wheel);
02819   }
02820  }
02821  return 0;
02822 #ifndef TOLUA_RELEASE
02823  tolua_lerror:
02824  tolua_error(tolua_S,"#ferror in function 'set_overcurrent_left_wheel'.",&tolua_err);
02825  return 0;
02826 #endif
02827 }
02828 #endif //#ifndef TOLUA_DISABLE
02829 
02830 /* method: maxlenof_overcurrent_left_wheel of class  fawkes::Roomba500Interface */
02831 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_overcurrent_left_wheel00
02832 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_overcurrent_left_wheel00(lua_State* tolua_S)
02833 {
02834 #ifndef TOLUA_RELEASE
02835  tolua_Error tolua_err;
02836  if (
02837      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
02838      !tolua_isnoobj(tolua_S,2,&tolua_err)
02839  )
02840   goto tolua_lerror;
02841  else
02842 #endif
02843  {
02844   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
02845 #ifndef TOLUA_RELEASE
02846   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_overcurrent_left_wheel'", NULL);
02847 #endif
02848   {
02849    int tolua_ret = (int)  self->maxlenof_overcurrent_left_wheel();
02850    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02851   }
02852  }
02853  return 1;
02854 #ifndef TOLUA_RELEASE
02855  tolua_lerror:
02856  tolua_error(tolua_S,"#ferror in function 'maxlenof_overcurrent_left_wheel'.",&tolua_err);
02857  return 0;
02858 #endif
02859 }
02860 #endif //#ifndef TOLUA_DISABLE
02861 
02862 /* method: is_overcurrent_right_wheel of class  fawkes::Roomba500Interface */
02863 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_overcurrent_right_wheel00
02864 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_overcurrent_right_wheel00(lua_State* tolua_S)
02865 {
02866 #ifndef TOLUA_RELEASE
02867  tolua_Error tolua_err;
02868  if (
02869      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
02870      !tolua_isnoobj(tolua_S,2,&tolua_err)
02871  )
02872   goto tolua_lerror;
02873  else
02874 #endif
02875  {
02876   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
02877 #ifndef TOLUA_RELEASE
02878   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_overcurrent_right_wheel'", NULL);
02879 #endif
02880   {
02881    bool tolua_ret = (bool)  self->is_overcurrent_right_wheel();
02882    tolua_pushboolean(tolua_S,(bool)tolua_ret);
02883   }
02884  }
02885  return 1;
02886 #ifndef TOLUA_RELEASE
02887  tolua_lerror:
02888  tolua_error(tolua_S,"#ferror in function 'is_overcurrent_right_wheel'.",&tolua_err);
02889  return 0;
02890 #endif
02891 }
02892 #endif //#ifndef TOLUA_DISABLE
02893 
02894 /* method: set_overcurrent_right_wheel of class  fawkes::Roomba500Interface */
02895 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_overcurrent_right_wheel00
02896 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_overcurrent_right_wheel00(lua_State* tolua_S)
02897 {
02898 #ifndef TOLUA_RELEASE
02899  tolua_Error tolua_err;
02900  if (
02901      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
02902      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
02903      !tolua_isnoobj(tolua_S,3,&tolua_err)
02904  )
02905   goto tolua_lerror;
02906  else
02907 #endif
02908  {
02909   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
02910   const bool new_overcurrent_right_wheel = ((const bool)  tolua_toboolean(tolua_S,2,0));
02911 #ifndef TOLUA_RELEASE
02912   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_overcurrent_right_wheel'", NULL);
02913 #endif
02914   {
02915    self->set_overcurrent_right_wheel(new_overcurrent_right_wheel);
02916   }
02917  }
02918  return 0;
02919 #ifndef TOLUA_RELEASE
02920  tolua_lerror:
02921  tolua_error(tolua_S,"#ferror in function 'set_overcurrent_right_wheel'.",&tolua_err);
02922  return 0;
02923 #endif
02924 }
02925 #endif //#ifndef TOLUA_DISABLE
02926 
02927 /* method: maxlenof_overcurrent_right_wheel of class  fawkes::Roomba500Interface */
02928 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_overcurrent_right_wheel00
02929 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_overcurrent_right_wheel00(lua_State* tolua_S)
02930 {
02931 #ifndef TOLUA_RELEASE
02932  tolua_Error tolua_err;
02933  if (
02934      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
02935      !tolua_isnoobj(tolua_S,2,&tolua_err)
02936  )
02937   goto tolua_lerror;
02938  else
02939 #endif
02940  {
02941   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
02942 #ifndef TOLUA_RELEASE
02943   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_overcurrent_right_wheel'", NULL);
02944 #endif
02945   {
02946    int tolua_ret = (int)  self->maxlenof_overcurrent_right_wheel();
02947    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02948   }
02949  }
02950  return 1;
02951 #ifndef TOLUA_RELEASE
02952  tolua_lerror:
02953  tolua_error(tolua_S,"#ferror in function 'maxlenof_overcurrent_right_wheel'.",&tolua_err);
02954  return 0;
02955 #endif
02956 }
02957 #endif //#ifndef TOLUA_DISABLE
02958 
02959 /* method: is_dirt_detect of class  fawkes::Roomba500Interface */
02960 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_dirt_detect00
02961 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_dirt_detect00(lua_State* tolua_S)
02962 {
02963 #ifndef TOLUA_RELEASE
02964  tolua_Error tolua_err;
02965  if (
02966      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
02967      !tolua_isnoobj(tolua_S,2,&tolua_err)
02968  )
02969   goto tolua_lerror;
02970  else
02971 #endif
02972  {
02973   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
02974 #ifndef TOLUA_RELEASE
02975   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_dirt_detect'", NULL);
02976 #endif
02977   {
02978    bool tolua_ret = (bool)  self->is_dirt_detect();
02979    tolua_pushboolean(tolua_S,(bool)tolua_ret);
02980   }
02981  }
02982  return 1;
02983 #ifndef TOLUA_RELEASE
02984  tolua_lerror:
02985  tolua_error(tolua_S,"#ferror in function 'is_dirt_detect'.",&tolua_err);
02986  return 0;
02987 #endif
02988 }
02989 #endif //#ifndef TOLUA_DISABLE
02990 
02991 /* method: set_dirt_detect of class  fawkes::Roomba500Interface */
02992 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_dirt_detect00
02993 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_dirt_detect00(lua_State* tolua_S)
02994 {
02995 #ifndef TOLUA_RELEASE
02996  tolua_Error tolua_err;
02997  if (
02998      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
02999      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
03000      !tolua_isnoobj(tolua_S,3,&tolua_err)
03001  )
03002   goto tolua_lerror;
03003  else
03004 #endif
03005  {
03006   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
03007   const bool new_dirt_detect = ((const bool)  tolua_toboolean(tolua_S,2,0));
03008 #ifndef TOLUA_RELEASE
03009   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_dirt_detect'", NULL);
03010 #endif
03011   {
03012    self->set_dirt_detect(new_dirt_detect);
03013   }
03014  }
03015  return 0;
03016 #ifndef TOLUA_RELEASE
03017  tolua_lerror:
03018  tolua_error(tolua_S,"#ferror in function 'set_dirt_detect'.",&tolua_err);
03019  return 0;
03020 #endif
03021 }
03022 #endif //#ifndef TOLUA_DISABLE
03023 
03024 /* method: maxlenof_dirt_detect of class  fawkes::Roomba500Interface */
03025 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_dirt_detect00
03026 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_dirt_detect00(lua_State* tolua_S)
03027 {
03028 #ifndef TOLUA_RELEASE
03029  tolua_Error tolua_err;
03030  if (
03031      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
03032      !tolua_isnoobj(tolua_S,2,&tolua_err)
03033  )
03034   goto tolua_lerror;
03035  else
03036 #endif
03037  {
03038   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
03039 #ifndef TOLUA_RELEASE
03040   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_dirt_detect'", NULL);
03041 #endif
03042   {
03043    int tolua_ret = (int)  self->maxlenof_dirt_detect();
03044    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03045   }
03046  }
03047  return 1;
03048 #ifndef TOLUA_RELEASE
03049  tolua_lerror:
03050  tolua_error(tolua_S,"#ferror in function 'maxlenof_dirt_detect'.",&tolua_err);
03051  return 0;
03052 #endif
03053 }
03054 #endif //#ifndef TOLUA_DISABLE
03055 
03056 /* method: ir_opcode_omni of class  fawkes::Roomba500Interface */
03057 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_ir_opcode_omni00
03058 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_ir_opcode_omni00(lua_State* tolua_S)
03059 {
03060 #ifndef TOLUA_RELEASE
03061  tolua_Error tolua_err;
03062  if (
03063      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
03064      !tolua_isnoobj(tolua_S,2,&tolua_err)
03065  )
03066   goto tolua_lerror;
03067  else
03068 #endif
03069  {
03070   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
03071 #ifndef TOLUA_RELEASE
03072   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ir_opcode_omni'", NULL);
03073 #endif
03074   {
03075    fawkes::Roomba500Interface::InfraredCharacter tolua_ret = (fawkes::Roomba500Interface::InfraredCharacter)  self->ir_opcode_omni();
03076    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03077   }
03078  }
03079  return 1;
03080 #ifndef TOLUA_RELEASE
03081  tolua_lerror:
03082  tolua_error(tolua_S,"#ferror in function 'ir_opcode_omni'.",&tolua_err);
03083  return 0;
03084 #endif
03085 }
03086 #endif //#ifndef TOLUA_DISABLE
03087 
03088 /* method: set_ir_opcode_omni of class  fawkes::Roomba500Interface */
03089 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_ir_opcode_omni00
03090 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_ir_opcode_omni00(lua_State* tolua_S)
03091 {
03092 #ifndef TOLUA_RELEASE
03093  tolua_Error tolua_err;
03094  if (
03095      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
03096      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
03097      !tolua_isnoobj(tolua_S,3,&tolua_err)
03098  )
03099   goto tolua_lerror;
03100  else
03101 #endif
03102  {
03103   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
03104   const fawkes::Roomba500Interface::InfraredCharacter new_ir_opcode_omni = ((const fawkes::Roomba500Interface::InfraredCharacter) (int)  tolua_tonumber(tolua_S,2,0));
03105 #ifndef TOLUA_RELEASE
03106   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_ir_opcode_omni'", NULL);
03107 #endif
03108   {
03109    self->set_ir_opcode_omni(new_ir_opcode_omni);
03110   }
03111  }
03112  return 0;
03113 #ifndef TOLUA_RELEASE
03114  tolua_lerror:
03115  tolua_error(tolua_S,"#ferror in function 'set_ir_opcode_omni'.",&tolua_err);
03116  return 0;
03117 #endif
03118 }
03119 #endif //#ifndef TOLUA_DISABLE
03120 
03121 /* method: maxlenof_ir_opcode_omni of class  fawkes::Roomba500Interface */
03122 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_ir_opcode_omni00
03123 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_ir_opcode_omni00(lua_State* tolua_S)
03124 {
03125 #ifndef TOLUA_RELEASE
03126  tolua_Error tolua_err;
03127  if (
03128      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
03129      !tolua_isnoobj(tolua_S,2,&tolua_err)
03130  )
03131   goto tolua_lerror;
03132  else
03133 #endif
03134  {
03135   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
03136 #ifndef TOLUA_RELEASE
03137   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_ir_opcode_omni'", NULL);
03138 #endif
03139   {
03140    int tolua_ret = (int)  self->maxlenof_ir_opcode_omni();
03141    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03142   }
03143  }
03144  return 1;
03145 #ifndef TOLUA_RELEASE
03146  tolua_lerror:
03147  tolua_error(tolua_S,"#ferror in function 'maxlenof_ir_opcode_omni'.",&tolua_err);
03148  return 0;
03149 #endif
03150 }
03151 #endif //#ifndef TOLUA_DISABLE
03152 
03153 /* method: is_button_clean of class  fawkes::Roomba500Interface */
03154 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_button_clean00
03155 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_button_clean00(lua_State* tolua_S)
03156 {
03157 #ifndef TOLUA_RELEASE
03158  tolua_Error tolua_err;
03159  if (
03160      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
03161      !tolua_isnoobj(tolua_S,2,&tolua_err)
03162  )
03163   goto tolua_lerror;
03164  else
03165 #endif
03166  {
03167   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
03168 #ifndef TOLUA_RELEASE
03169   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_button_clean'", NULL);
03170 #endif
03171   {
03172    bool tolua_ret = (bool)  self->is_button_clean();
03173    tolua_pushboolean(tolua_S,(bool)tolua_ret);
03174   }
03175  }
03176  return 1;
03177 #ifndef TOLUA_RELEASE
03178  tolua_lerror:
03179  tolua_error(tolua_S,"#ferror in function 'is_button_clean'.",&tolua_err);
03180  return 0;
03181 #endif
03182 }
03183 #endif //#ifndef TOLUA_DISABLE
03184 
03185 /* method: set_button_clean of class  fawkes::Roomba500Interface */
03186 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_button_clean00
03187 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_button_clean00(lua_State* tolua_S)
03188 {
03189 #ifndef TOLUA_RELEASE
03190  tolua_Error tolua_err;
03191  if (
03192      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
03193      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
03194      !tolua_isnoobj(tolua_S,3,&tolua_err)
03195  )
03196   goto tolua_lerror;
03197  else
03198 #endif
03199  {
03200   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
03201   const bool new_button_clean = ((const bool)  tolua_toboolean(tolua_S,2,0));
03202 #ifndef TOLUA_RELEASE
03203   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_button_clean'", NULL);
03204 #endif
03205   {
03206    self->set_button_clean(new_button_clean);
03207   }
03208  }
03209  return 0;
03210 #ifndef TOLUA_RELEASE
03211  tolua_lerror:
03212  tolua_error(tolua_S,"#ferror in function 'set_button_clean'.",&tolua_err);
03213  return 0;
03214 #endif
03215 }
03216 #endif //#ifndef TOLUA_DISABLE
03217 
03218 /* method: maxlenof_button_clean of class  fawkes::Roomba500Interface */
03219 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_button_clean00
03220 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_button_clean00(lua_State* tolua_S)
03221 {
03222 #ifndef TOLUA_RELEASE
03223  tolua_Error tolua_err;
03224  if (
03225      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
03226      !tolua_isnoobj(tolua_S,2,&tolua_err)
03227  )
03228   goto tolua_lerror;
03229  else
03230 #endif
03231  {
03232   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
03233 #ifndef TOLUA_RELEASE
03234   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_button_clean'", NULL);
03235 #endif
03236   {
03237    int tolua_ret = (int)  self->maxlenof_button_clean();
03238    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03239   }
03240  }
03241  return 1;
03242 #ifndef TOLUA_RELEASE
03243  tolua_lerror:
03244  tolua_error(tolua_S,"#ferror in function 'maxlenof_button_clean'.",&tolua_err);
03245  return 0;
03246 #endif
03247 }
03248 #endif //#ifndef TOLUA_DISABLE
03249 
03250 /* method: is_button_spot of class  fawkes::Roomba500Interface */
03251 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_button_spot00
03252 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_button_spot00(lua_State* tolua_S)
03253 {
03254 #ifndef TOLUA_RELEASE
03255  tolua_Error tolua_err;
03256  if (
03257      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
03258      !tolua_isnoobj(tolua_S,2,&tolua_err)
03259  )
03260   goto tolua_lerror;
03261  else
03262 #endif
03263  {
03264   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
03265 #ifndef TOLUA_RELEASE
03266   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_button_spot'", NULL);
03267 #endif
03268   {
03269    bool tolua_ret = (bool)  self->is_button_spot();
03270    tolua_pushboolean(tolua_S,(bool)tolua_ret);
03271   }
03272  }
03273  return 1;
03274 #ifndef TOLUA_RELEASE
03275  tolua_lerror:
03276  tolua_error(tolua_S,"#ferror in function 'is_button_spot'.",&tolua_err);
03277  return 0;
03278 #endif
03279 }
03280 #endif //#ifndef TOLUA_DISABLE
03281 
03282 /* method: set_button_spot of class  fawkes::Roomba500Interface */
03283 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_button_spot00
03284 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_button_spot00(lua_State* tolua_S)
03285 {
03286 #ifndef TOLUA_RELEASE
03287  tolua_Error tolua_err;
03288  if (
03289      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
03290      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
03291      !tolua_isnoobj(tolua_S,3,&tolua_err)
03292  )
03293   goto tolua_lerror;
03294  else
03295 #endif
03296  {
03297   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
03298   const bool new_button_spot = ((const bool)  tolua_toboolean(tolua_S,2,0));
03299 #ifndef TOLUA_RELEASE
03300   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_button_spot'", NULL);
03301 #endif
03302   {
03303    self->set_button_spot(new_button_spot);
03304   }
03305  }
03306  return 0;
03307 #ifndef TOLUA_RELEASE
03308  tolua_lerror:
03309  tolua_error(tolua_S,"#ferror in function 'set_button_spot'.",&tolua_err);
03310  return 0;
03311 #endif
03312 }
03313 #endif //#ifndef TOLUA_DISABLE
03314 
03315 /* method: maxlenof_button_spot of class  fawkes::Roomba500Interface */
03316 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_button_spot00
03317 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_button_spot00(lua_State* tolua_S)
03318 {
03319 #ifndef TOLUA_RELEASE
03320  tolua_Error tolua_err;
03321  if (
03322      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
03323      !tolua_isnoobj(tolua_S,2,&tolua_err)
03324  )
03325   goto tolua_lerror;
03326  else
03327 #endif
03328  {
03329   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
03330 #ifndef TOLUA_RELEASE
03331   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_button_spot'", NULL);
03332 #endif
03333   {
03334    int tolua_ret = (int)  self->maxlenof_button_spot();
03335    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03336   }
03337  }
03338  return 1;
03339 #ifndef TOLUA_RELEASE
03340  tolua_lerror:
03341  tolua_error(tolua_S,"#ferror in function 'maxlenof_button_spot'.",&tolua_err);
03342  return 0;
03343 #endif
03344 }
03345 #endif //#ifndef TOLUA_DISABLE
03346 
03347 /* method: is_button_dock of class  fawkes::Roomba500Interface */
03348 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_button_dock00
03349 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_button_dock00(lua_State* tolua_S)
03350 {
03351 #ifndef TOLUA_RELEASE
03352  tolua_Error tolua_err;
03353  if (
03354      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
03355      !tolua_isnoobj(tolua_S,2,&tolua_err)
03356  )
03357   goto tolua_lerror;
03358  else
03359 #endif
03360  {
03361   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
03362 #ifndef TOLUA_RELEASE
03363   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_button_dock'", NULL);
03364 #endif
03365   {
03366    bool tolua_ret = (bool)  self->is_button_dock();
03367    tolua_pushboolean(tolua_S,(bool)tolua_ret);
03368   }
03369  }
03370  return 1;
03371 #ifndef TOLUA_RELEASE
03372  tolua_lerror:
03373  tolua_error(tolua_S,"#ferror in function 'is_button_dock'.",&tolua_err);
03374  return 0;
03375 #endif
03376 }
03377 #endif //#ifndef TOLUA_DISABLE
03378 
03379 /* method: set_button_dock of class  fawkes::Roomba500Interface */
03380 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_button_dock00
03381 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_button_dock00(lua_State* tolua_S)
03382 {
03383 #ifndef TOLUA_RELEASE
03384  tolua_Error tolua_err;
03385  if (
03386      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
03387      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
03388      !tolua_isnoobj(tolua_S,3,&tolua_err)
03389  )
03390   goto tolua_lerror;
03391  else
03392 #endif
03393  {
03394   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
03395   const bool new_button_dock = ((const bool)  tolua_toboolean(tolua_S,2,0));
03396 #ifndef TOLUA_RELEASE
03397   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_button_dock'", NULL);
03398 #endif
03399   {
03400    self->set_button_dock(new_button_dock);
03401   }
03402  }
03403  return 0;
03404 #ifndef TOLUA_RELEASE
03405  tolua_lerror:
03406  tolua_error(tolua_S,"#ferror in function 'set_button_dock'.",&tolua_err);
03407  return 0;
03408 #endif
03409 }
03410 #endif //#ifndef TOLUA_DISABLE
03411 
03412 /* method: maxlenof_button_dock of class  fawkes::Roomba500Interface */
03413 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_button_dock00
03414 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_button_dock00(lua_State* tolua_S)
03415 {
03416 #ifndef TOLUA_RELEASE
03417  tolua_Error tolua_err;
03418  if (
03419      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
03420      !tolua_isnoobj(tolua_S,2,&tolua_err)
03421  )
03422   goto tolua_lerror;
03423  else
03424 #endif
03425  {
03426   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
03427 #ifndef TOLUA_RELEASE
03428   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_button_dock'", NULL);
03429 #endif
03430   {
03431    int tolua_ret = (int)  self->maxlenof_button_dock();
03432    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03433   }
03434  }
03435  return 1;
03436 #ifndef TOLUA_RELEASE
03437  tolua_lerror:
03438  tolua_error(tolua_S,"#ferror in function 'maxlenof_button_dock'.",&tolua_err);
03439  return 0;
03440 #endif
03441 }
03442 #endif //#ifndef TOLUA_DISABLE
03443 
03444 /* method: is_button_minute of class  fawkes::Roomba500Interface */
03445 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_button_minute00
03446 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_button_minute00(lua_State* tolua_S)
03447 {
03448 #ifndef TOLUA_RELEASE
03449  tolua_Error tolua_err;
03450  if (
03451      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
03452      !tolua_isnoobj(tolua_S,2,&tolua_err)
03453  )
03454   goto tolua_lerror;
03455  else
03456 #endif
03457  {
03458   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
03459 #ifndef TOLUA_RELEASE
03460   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_button_minute'", NULL);
03461 #endif
03462   {
03463    bool tolua_ret = (bool)  self->is_button_minute();
03464    tolua_pushboolean(tolua_S,(bool)tolua_ret);
03465   }
03466  }
03467  return 1;
03468 #ifndef TOLUA_RELEASE
03469  tolua_lerror:
03470  tolua_error(tolua_S,"#ferror in function 'is_button_minute'.",&tolua_err);
03471  return 0;
03472 #endif
03473 }
03474 #endif //#ifndef TOLUA_DISABLE
03475 
03476 /* method: set_button_minute of class  fawkes::Roomba500Interface */
03477 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_button_minute00
03478 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_button_minute00(lua_State* tolua_S)
03479 {
03480 #ifndef TOLUA_RELEASE
03481  tolua_Error tolua_err;
03482  if (
03483      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
03484      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
03485      !tolua_isnoobj(tolua_S,3,&tolua_err)
03486  )
03487   goto tolua_lerror;
03488  else
03489 #endif
03490  {
03491   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
03492   const bool new_button_minute = ((const bool)  tolua_toboolean(tolua_S,2,0));
03493 #ifndef TOLUA_RELEASE
03494   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_button_minute'", NULL);
03495 #endif
03496   {
03497    self->set_button_minute(new_button_minute);
03498   }
03499  }
03500  return 0;
03501 #ifndef TOLUA_RELEASE
03502  tolua_lerror:
03503  tolua_error(tolua_S,"#ferror in function 'set_button_minute'.",&tolua_err);
03504  return 0;
03505 #endif
03506 }
03507 #endif //#ifndef TOLUA_DISABLE
03508 
03509 /* method: maxlenof_button_minute of class  fawkes::Roomba500Interface */
03510 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_button_minute00
03511 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_button_minute00(lua_State* tolua_S)
03512 {
03513 #ifndef TOLUA_RELEASE
03514  tolua_Error tolua_err;
03515  if (
03516      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
03517      !tolua_isnoobj(tolua_S,2,&tolua_err)
03518  )
03519   goto tolua_lerror;
03520  else
03521 #endif
03522  {
03523   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
03524 #ifndef TOLUA_RELEASE
03525   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_button_minute'", NULL);
03526 #endif
03527   {
03528    int tolua_ret = (int)  self->maxlenof_button_minute();
03529    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03530   }
03531  }
03532  return 1;
03533 #ifndef TOLUA_RELEASE
03534  tolua_lerror:
03535  tolua_error(tolua_S,"#ferror in function 'maxlenof_button_minute'.",&tolua_err);
03536  return 0;
03537 #endif
03538 }
03539 #endif //#ifndef TOLUA_DISABLE
03540 
03541 /* method: is_button_hour of class  fawkes::Roomba500Interface */
03542 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_button_hour00
03543 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_button_hour00(lua_State* tolua_S)
03544 {
03545 #ifndef TOLUA_RELEASE
03546  tolua_Error tolua_err;
03547  if (
03548      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
03549      !tolua_isnoobj(tolua_S,2,&tolua_err)
03550  )
03551   goto tolua_lerror;
03552  else
03553 #endif
03554  {
03555   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
03556 #ifndef TOLUA_RELEASE
03557   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_button_hour'", NULL);
03558 #endif
03559   {
03560    bool tolua_ret = (bool)  self->is_button_hour();
03561    tolua_pushboolean(tolua_S,(bool)tolua_ret);
03562   }
03563  }
03564  return 1;
03565 #ifndef TOLUA_RELEASE
03566  tolua_lerror:
03567  tolua_error(tolua_S,"#ferror in function 'is_button_hour'.",&tolua_err);
03568  return 0;
03569 #endif
03570 }
03571 #endif //#ifndef TOLUA_DISABLE
03572 
03573 /* method: set_button_hour of class  fawkes::Roomba500Interface */
03574 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_button_hour00
03575 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_button_hour00(lua_State* tolua_S)
03576 {
03577 #ifndef TOLUA_RELEASE
03578  tolua_Error tolua_err;
03579  if (
03580      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
03581      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
03582      !tolua_isnoobj(tolua_S,3,&tolua_err)
03583  )
03584   goto tolua_lerror;
03585  else
03586 #endif
03587  {
03588   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
03589   const bool new_button_hour = ((const bool)  tolua_toboolean(tolua_S,2,0));
03590 #ifndef TOLUA_RELEASE
03591   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_button_hour'", NULL);
03592 #endif
03593   {
03594    self->set_button_hour(new_button_hour);
03595   }
03596  }
03597  return 0;
03598 #ifndef TOLUA_RELEASE
03599  tolua_lerror:
03600  tolua_error(tolua_S,"#ferror in function 'set_button_hour'.",&tolua_err);
03601  return 0;
03602 #endif
03603 }
03604 #endif //#ifndef TOLUA_DISABLE
03605 
03606 /* method: maxlenof_button_hour of class  fawkes::Roomba500Interface */
03607 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_button_hour00
03608 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_button_hour00(lua_State* tolua_S)
03609 {
03610 #ifndef TOLUA_RELEASE
03611  tolua_Error tolua_err;
03612  if (
03613      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
03614      !tolua_isnoobj(tolua_S,2,&tolua_err)
03615  )
03616   goto tolua_lerror;
03617  else
03618 #endif
03619  {
03620   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
03621 #ifndef TOLUA_RELEASE
03622   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_button_hour'", NULL);
03623 #endif
03624   {
03625    int tolua_ret = (int)  self->maxlenof_button_hour();
03626    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03627   }
03628  }
03629  return 1;
03630 #ifndef TOLUA_RELEASE
03631  tolua_lerror:
03632  tolua_error(tolua_S,"#ferror in function 'maxlenof_button_hour'.",&tolua_err);
03633  return 0;
03634 #endif
03635 }
03636 #endif //#ifndef TOLUA_DISABLE
03637 
03638 /* method: is_button_day of class  fawkes::Roomba500Interface */
03639 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_button_day00
03640 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_button_day00(lua_State* tolua_S)
03641 {
03642 #ifndef TOLUA_RELEASE
03643  tolua_Error tolua_err;
03644  if (
03645      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
03646      !tolua_isnoobj(tolua_S,2,&tolua_err)
03647  )
03648   goto tolua_lerror;
03649  else
03650 #endif
03651  {
03652   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
03653 #ifndef TOLUA_RELEASE
03654   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_button_day'", NULL);
03655 #endif
03656   {
03657    bool tolua_ret = (bool)  self->is_button_day();
03658    tolua_pushboolean(tolua_S,(bool)tolua_ret);
03659   }
03660  }
03661  return 1;
03662 #ifndef TOLUA_RELEASE
03663  tolua_lerror:
03664  tolua_error(tolua_S,"#ferror in function 'is_button_day'.",&tolua_err);
03665  return 0;
03666 #endif
03667 }
03668 #endif //#ifndef TOLUA_DISABLE
03669 
03670 /* method: set_button_day of class  fawkes::Roomba500Interface */
03671 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_button_day00
03672 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_button_day00(lua_State* tolua_S)
03673 {
03674 #ifndef TOLUA_RELEASE
03675  tolua_Error tolua_err;
03676  if (
03677      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
03678      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
03679      !tolua_isnoobj(tolua_S,3,&tolua_err)
03680  )
03681   goto tolua_lerror;
03682  else
03683 #endif
03684  {
03685   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
03686   const bool new_button_day = ((const bool)  tolua_toboolean(tolua_S,2,0));
03687 #ifndef TOLUA_RELEASE
03688   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_button_day'", NULL);
03689 #endif
03690   {
03691    self->set_button_day(new_button_day);
03692   }
03693  }
03694  return 0;
03695 #ifndef TOLUA_RELEASE
03696  tolua_lerror:
03697  tolua_error(tolua_S,"#ferror in function 'set_button_day'.",&tolua_err);
03698  return 0;
03699 #endif
03700 }
03701 #endif //#ifndef TOLUA_DISABLE
03702 
03703 /* method: maxlenof_button_day of class  fawkes::Roomba500Interface */
03704 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_button_day00
03705 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_button_day00(lua_State* tolua_S)
03706 {
03707 #ifndef TOLUA_RELEASE
03708  tolua_Error tolua_err;
03709  if (
03710      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
03711      !tolua_isnoobj(tolua_S,2,&tolua_err)
03712  )
03713   goto tolua_lerror;
03714  else
03715 #endif
03716  {
03717   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
03718 #ifndef TOLUA_RELEASE
03719   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_button_day'", NULL);
03720 #endif
03721   {
03722    int tolua_ret = (int)  self->maxlenof_button_day();
03723    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03724   }
03725  }
03726  return 1;
03727 #ifndef TOLUA_RELEASE
03728  tolua_lerror:
03729  tolua_error(tolua_S,"#ferror in function 'maxlenof_button_day'.",&tolua_err);
03730  return 0;
03731 #endif
03732 }
03733 #endif //#ifndef TOLUA_DISABLE
03734 
03735 /* method: is_button_schedule of class  fawkes::Roomba500Interface */
03736 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_button_schedule00
03737 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_button_schedule00(lua_State* tolua_S)
03738 {
03739 #ifndef TOLUA_RELEASE
03740  tolua_Error tolua_err;
03741  if (
03742      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
03743      !tolua_isnoobj(tolua_S,2,&tolua_err)
03744  )
03745   goto tolua_lerror;
03746  else
03747 #endif
03748  {
03749   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
03750 #ifndef TOLUA_RELEASE
03751   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_button_schedule'", NULL);
03752 #endif
03753   {
03754    bool tolua_ret = (bool)  self->is_button_schedule();
03755    tolua_pushboolean(tolua_S,(bool)tolua_ret);
03756   }
03757  }
03758  return 1;
03759 #ifndef TOLUA_RELEASE
03760  tolua_lerror:
03761  tolua_error(tolua_S,"#ferror in function 'is_button_schedule'.",&tolua_err);
03762  return 0;
03763 #endif
03764 }
03765 #endif //#ifndef TOLUA_DISABLE
03766 
03767 /* method: set_button_schedule of class  fawkes::Roomba500Interface */
03768 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_button_schedule00
03769 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_button_schedule00(lua_State* tolua_S)
03770 {
03771 #ifndef TOLUA_RELEASE
03772  tolua_Error tolua_err;
03773  if (
03774      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
03775      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
03776      !tolua_isnoobj(tolua_S,3,&tolua_err)
03777  )
03778   goto tolua_lerror;
03779  else
03780 #endif
03781  {
03782   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
03783   const bool new_button_schedule = ((const bool)  tolua_toboolean(tolua_S,2,0));
03784 #ifndef TOLUA_RELEASE
03785   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_button_schedule'", NULL);
03786 #endif
03787   {
03788    self->set_button_schedule(new_button_schedule);
03789   }
03790  }
03791  return 0;
03792 #ifndef TOLUA_RELEASE
03793  tolua_lerror:
03794  tolua_error(tolua_S,"#ferror in function 'set_button_schedule'.",&tolua_err);
03795  return 0;
03796 #endif
03797 }
03798 #endif //#ifndef TOLUA_DISABLE
03799 
03800 /* method: maxlenof_button_schedule of class  fawkes::Roomba500Interface */
03801 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_button_schedule00
03802 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_button_schedule00(lua_State* tolua_S)
03803 {
03804 #ifndef TOLUA_RELEASE
03805  tolua_Error tolua_err;
03806  if (
03807      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
03808      !tolua_isnoobj(tolua_S,2,&tolua_err)
03809  )
03810   goto tolua_lerror;
03811  else
03812 #endif
03813  {
03814   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
03815 #ifndef TOLUA_RELEASE
03816   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_button_schedule'", NULL);
03817 #endif
03818   {
03819    int tolua_ret = (int)  self->maxlenof_button_schedule();
03820    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03821   }
03822  }
03823  return 1;
03824 #ifndef TOLUA_RELEASE
03825  tolua_lerror:
03826  tolua_error(tolua_S,"#ferror in function 'maxlenof_button_schedule'.",&tolua_err);
03827  return 0;
03828 #endif
03829 }
03830 #endif //#ifndef TOLUA_DISABLE
03831 
03832 /* method: is_button_clock of class  fawkes::Roomba500Interface */
03833 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_button_clock00
03834 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_button_clock00(lua_State* tolua_S)
03835 {
03836 #ifndef TOLUA_RELEASE
03837  tolua_Error tolua_err;
03838  if (
03839      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
03840      !tolua_isnoobj(tolua_S,2,&tolua_err)
03841  )
03842   goto tolua_lerror;
03843  else
03844 #endif
03845  {
03846   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
03847 #ifndef TOLUA_RELEASE
03848   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_button_clock'", NULL);
03849 #endif
03850   {
03851    bool tolua_ret = (bool)  self->is_button_clock();
03852    tolua_pushboolean(tolua_S,(bool)tolua_ret);
03853   }
03854  }
03855  return 1;
03856 #ifndef TOLUA_RELEASE
03857  tolua_lerror:
03858  tolua_error(tolua_S,"#ferror in function 'is_button_clock'.",&tolua_err);
03859  return 0;
03860 #endif
03861 }
03862 #endif //#ifndef TOLUA_DISABLE
03863 
03864 /* method: set_button_clock of class  fawkes::Roomba500Interface */
03865 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_button_clock00
03866 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_button_clock00(lua_State* tolua_S)
03867 {
03868 #ifndef TOLUA_RELEASE
03869  tolua_Error tolua_err;
03870  if (
03871      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
03872      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
03873      !tolua_isnoobj(tolua_S,3,&tolua_err)
03874  )
03875   goto tolua_lerror;
03876  else
03877 #endif
03878  {
03879   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
03880   const bool new_button_clock = ((const bool)  tolua_toboolean(tolua_S,2,0));
03881 #ifndef TOLUA_RELEASE
03882   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_button_clock'", NULL);
03883 #endif
03884   {
03885    self->set_button_clock(new_button_clock);
03886   }
03887  }
03888  return 0;
03889 #ifndef TOLUA_RELEASE
03890  tolua_lerror:
03891  tolua_error(tolua_S,"#ferror in function 'set_button_clock'.",&tolua_err);
03892  return 0;
03893 #endif
03894 }
03895 #endif //#ifndef TOLUA_DISABLE
03896 
03897 /* method: maxlenof_button_clock of class  fawkes::Roomba500Interface */
03898 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_button_clock00
03899 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_button_clock00(lua_State* tolua_S)
03900 {
03901 #ifndef TOLUA_RELEASE
03902  tolua_Error tolua_err;
03903  if (
03904      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
03905      !tolua_isnoobj(tolua_S,2,&tolua_err)
03906  )
03907   goto tolua_lerror;
03908  else
03909 #endif
03910  {
03911   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
03912 #ifndef TOLUA_RELEASE
03913   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_button_clock'", NULL);
03914 #endif
03915   {
03916    int tolua_ret = (int)  self->maxlenof_button_clock();
03917    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03918   }
03919  }
03920  return 1;
03921 #ifndef TOLUA_RELEASE
03922  tolua_lerror:
03923  tolua_error(tolua_S,"#ferror in function 'maxlenof_button_clock'.",&tolua_err);
03924  return 0;
03925 #endif
03926 }
03927 #endif //#ifndef TOLUA_DISABLE
03928 
03929 /* method: distance of class  fawkes::Roomba500Interface */
03930 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_distance00
03931 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_distance00(lua_State* tolua_S)
03932 {
03933 #ifndef TOLUA_RELEASE
03934  tolua_Error tolua_err;
03935  if (
03936      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
03937      !tolua_isnoobj(tolua_S,2,&tolua_err)
03938  )
03939   goto tolua_lerror;
03940  else
03941 #endif
03942  {
03943   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
03944 #ifndef TOLUA_RELEASE
03945   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'distance'", NULL);
03946 #endif
03947   {
03948    short tolua_ret = (short)  self->distance();
03949    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03950   }
03951  }
03952  return 1;
03953 #ifndef TOLUA_RELEASE
03954  tolua_lerror:
03955  tolua_error(tolua_S,"#ferror in function 'distance'.",&tolua_err);
03956  return 0;
03957 #endif
03958 }
03959 #endif //#ifndef TOLUA_DISABLE
03960 
03961 /* method: set_distance of class  fawkes::Roomba500Interface */
03962 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_distance00
03963 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_distance00(lua_State* tolua_S)
03964 {
03965 #ifndef TOLUA_RELEASE
03966  tolua_Error tolua_err;
03967  if (
03968      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
03969      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
03970      !tolua_isnoobj(tolua_S,3,&tolua_err)
03971  )
03972   goto tolua_lerror;
03973  else
03974 #endif
03975  {
03976   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
03977   const short new_distance = ((const short)  tolua_tonumber(tolua_S,2,0));
03978 #ifndef TOLUA_RELEASE
03979   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_distance'", NULL);
03980 #endif
03981   {
03982    self->set_distance(new_distance);
03983   }
03984  }
03985  return 0;
03986 #ifndef TOLUA_RELEASE
03987  tolua_lerror:
03988  tolua_error(tolua_S,"#ferror in function 'set_distance'.",&tolua_err);
03989  return 0;
03990 #endif
03991 }
03992 #endif //#ifndef TOLUA_DISABLE
03993 
03994 /* method: maxlenof_distance of class  fawkes::Roomba500Interface */
03995 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_distance00
03996 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_distance00(lua_State* tolua_S)
03997 {
03998 #ifndef TOLUA_RELEASE
03999  tolua_Error tolua_err;
04000  if (
04001      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
04002      !tolua_isnoobj(tolua_S,2,&tolua_err)
04003  )
04004   goto tolua_lerror;
04005  else
04006 #endif
04007  {
04008   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
04009 #ifndef TOLUA_RELEASE
04010   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_distance'", NULL);
04011 #endif
04012   {
04013    int tolua_ret = (int)  self->maxlenof_distance();
04014    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04015   }
04016  }
04017  return 1;
04018 #ifndef TOLUA_RELEASE
04019  tolua_lerror:
04020  tolua_error(tolua_S,"#ferror in function 'maxlenof_distance'.",&tolua_err);
04021  return 0;
04022 #endif
04023 }
04024 #endif //#ifndef TOLUA_DISABLE
04025 
04026 /* method: angle of class  fawkes::Roomba500Interface */
04027 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_angle00
04028 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_angle00(lua_State* tolua_S)
04029 {
04030 #ifndef TOLUA_RELEASE
04031  tolua_Error tolua_err;
04032  if (
04033      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
04034      !tolua_isnoobj(tolua_S,2,&tolua_err)
04035  )
04036   goto tolua_lerror;
04037  else
04038 #endif
04039  {
04040   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
04041 #ifndef TOLUA_RELEASE
04042   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'angle'", NULL);
04043 #endif
04044   {
04045    short tolua_ret = (short)  self->angle();
04046    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04047   }
04048  }
04049  return 1;
04050 #ifndef TOLUA_RELEASE
04051  tolua_lerror:
04052  tolua_error(tolua_S,"#ferror in function 'angle'.",&tolua_err);
04053  return 0;
04054 #endif
04055 }
04056 #endif //#ifndef TOLUA_DISABLE
04057 
04058 /* method: set_angle of class  fawkes::Roomba500Interface */
04059 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_angle00
04060 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_angle00(lua_State* tolua_S)
04061 {
04062 #ifndef TOLUA_RELEASE
04063  tolua_Error tolua_err;
04064  if (
04065      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
04066      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
04067      !tolua_isnoobj(tolua_S,3,&tolua_err)
04068  )
04069   goto tolua_lerror;
04070  else
04071 #endif
04072  {
04073   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
04074   const short new_angle = ((const short)  tolua_tonumber(tolua_S,2,0));
04075 #ifndef TOLUA_RELEASE
04076   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_angle'", NULL);
04077 #endif
04078   {
04079    self->set_angle(new_angle);
04080   }
04081  }
04082  return 0;
04083 #ifndef TOLUA_RELEASE
04084  tolua_lerror:
04085  tolua_error(tolua_S,"#ferror in function 'set_angle'.",&tolua_err);
04086  return 0;
04087 #endif
04088 }
04089 #endif //#ifndef TOLUA_DISABLE
04090 
04091 /* method: maxlenof_angle of class  fawkes::Roomba500Interface */
04092 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_angle00
04093 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_angle00(lua_State* tolua_S)
04094 {
04095 #ifndef TOLUA_RELEASE
04096  tolua_Error tolua_err;
04097  if (
04098      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
04099      !tolua_isnoobj(tolua_S,2,&tolua_err)
04100  )
04101   goto tolua_lerror;
04102  else
04103 #endif
04104  {
04105   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
04106 #ifndef TOLUA_RELEASE
04107   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_angle'", NULL);
04108 #endif
04109   {
04110    int tolua_ret = (int)  self->maxlenof_angle();
04111    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04112   }
04113  }
04114  return 1;
04115 #ifndef TOLUA_RELEASE
04116  tolua_lerror:
04117  tolua_error(tolua_S,"#ferror in function 'maxlenof_angle'.",&tolua_err);
04118  return 0;
04119 #endif
04120 }
04121 #endif //#ifndef TOLUA_DISABLE
04122 
04123 /* method: charging_state of class  fawkes::Roomba500Interface */
04124 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_charging_state00
04125 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_charging_state00(lua_State* tolua_S)
04126 {
04127 #ifndef TOLUA_RELEASE
04128  tolua_Error tolua_err;
04129  if (
04130      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
04131      !tolua_isnoobj(tolua_S,2,&tolua_err)
04132  )
04133   goto tolua_lerror;
04134  else
04135 #endif
04136  {
04137   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
04138 #ifndef TOLUA_RELEASE
04139   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'charging_state'", NULL);
04140 #endif
04141   {
04142    fawkes::Roomba500Interface::ChargingState tolua_ret = (fawkes::Roomba500Interface::ChargingState)  self->charging_state();
04143    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04144   }
04145  }
04146  return 1;
04147 #ifndef TOLUA_RELEASE
04148  tolua_lerror:
04149  tolua_error(tolua_S,"#ferror in function 'charging_state'.",&tolua_err);
04150  return 0;
04151 #endif
04152 }
04153 #endif //#ifndef TOLUA_DISABLE
04154 
04155 /* method: set_charging_state of class  fawkes::Roomba500Interface */
04156 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_charging_state00
04157 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_charging_state00(lua_State* tolua_S)
04158 {
04159 #ifndef TOLUA_RELEASE
04160  tolua_Error tolua_err;
04161  if (
04162      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
04163      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
04164      !tolua_isnoobj(tolua_S,3,&tolua_err)
04165  )
04166   goto tolua_lerror;
04167  else
04168 #endif
04169  {
04170   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
04171   const fawkes::Roomba500Interface::ChargingState new_charging_state = ((const fawkes::Roomba500Interface::ChargingState) (int)  tolua_tonumber(tolua_S,2,0));
04172 #ifndef TOLUA_RELEASE
04173   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_charging_state'", NULL);
04174 #endif
04175   {
04176    self->set_charging_state(new_charging_state);
04177   }
04178  }
04179  return 0;
04180 #ifndef TOLUA_RELEASE
04181  tolua_lerror:
04182  tolua_error(tolua_S,"#ferror in function 'set_charging_state'.",&tolua_err);
04183  return 0;
04184 #endif
04185 }
04186 #endif //#ifndef TOLUA_DISABLE
04187 
04188 /* method: maxlenof_charging_state of class  fawkes::Roomba500Interface */
04189 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_charging_state00
04190 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_charging_state00(lua_State* tolua_S)
04191 {
04192 #ifndef TOLUA_RELEASE
04193  tolua_Error tolua_err;
04194  if (
04195      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
04196      !tolua_isnoobj(tolua_S,2,&tolua_err)
04197  )
04198   goto tolua_lerror;
04199  else
04200 #endif
04201  {
04202   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
04203 #ifndef TOLUA_RELEASE
04204   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_charging_state'", NULL);
04205 #endif
04206   {
04207    int tolua_ret = (int)  self->maxlenof_charging_state();
04208    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04209   }
04210  }
04211  return 1;
04212 #ifndef TOLUA_RELEASE
04213  tolua_lerror:
04214  tolua_error(tolua_S,"#ferror in function 'maxlenof_charging_state'.",&tolua_err);
04215  return 0;
04216 #endif
04217 }
04218 #endif //#ifndef TOLUA_DISABLE
04219 
04220 /* method: voltage of class  fawkes::Roomba500Interface */
04221 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_voltage00
04222 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_voltage00(lua_State* tolua_S)
04223 {
04224 #ifndef TOLUA_RELEASE
04225  tolua_Error tolua_err;
04226  if (
04227      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
04228      !tolua_isnoobj(tolua_S,2,&tolua_err)
04229  )
04230   goto tolua_lerror;
04231  else
04232 #endif
04233  {
04234   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
04235 #ifndef TOLUA_RELEASE
04236   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'voltage'", NULL);
04237 #endif
04238   {
04239    unsigned short tolua_ret = (unsigned short)  self->voltage();
04240    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04241   }
04242  }
04243  return 1;
04244 #ifndef TOLUA_RELEASE
04245  tolua_lerror:
04246  tolua_error(tolua_S,"#ferror in function 'voltage'.",&tolua_err);
04247  return 0;
04248 #endif
04249 }
04250 #endif //#ifndef TOLUA_DISABLE
04251 
04252 /* method: set_voltage of class  fawkes::Roomba500Interface */
04253 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_voltage00
04254 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_voltage00(lua_State* tolua_S)
04255 {
04256 #ifndef TOLUA_RELEASE
04257  tolua_Error tolua_err;
04258  if (
04259      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
04260      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
04261      !tolua_isnoobj(tolua_S,3,&tolua_err)
04262  )
04263   goto tolua_lerror;
04264  else
04265 #endif
04266  {
04267   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
04268   unsigned const short new_voltage = ((unsigned const short)  tolua_tonumber(tolua_S,2,0));
04269 #ifndef TOLUA_RELEASE
04270   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_voltage'", NULL);
04271 #endif
04272   {
04273    self->set_voltage(new_voltage);
04274   }
04275  }
04276  return 0;
04277 #ifndef TOLUA_RELEASE
04278  tolua_lerror:
04279  tolua_error(tolua_S,"#ferror in function 'set_voltage'.",&tolua_err);
04280  return 0;
04281 #endif
04282 }
04283 #endif //#ifndef TOLUA_DISABLE
04284 
04285 /* method: maxlenof_voltage of class  fawkes::Roomba500Interface */
04286 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_voltage00
04287 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_voltage00(lua_State* tolua_S)
04288 {
04289 #ifndef TOLUA_RELEASE
04290  tolua_Error tolua_err;
04291  if (
04292      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
04293      !tolua_isnoobj(tolua_S,2,&tolua_err)
04294  )
04295   goto tolua_lerror;
04296  else
04297 #endif
04298  {
04299   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
04300 #ifndef TOLUA_RELEASE
04301   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_voltage'", NULL);
04302 #endif
04303   {
04304    int tolua_ret = (int)  self->maxlenof_voltage();
04305    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04306   }
04307  }
04308  return 1;
04309 #ifndef TOLUA_RELEASE
04310  tolua_lerror:
04311  tolua_error(tolua_S,"#ferror in function 'maxlenof_voltage'.",&tolua_err);
04312  return 0;
04313 #endif
04314 }
04315 #endif //#ifndef TOLUA_DISABLE
04316 
04317 /* method: current of class  fawkes::Roomba500Interface */
04318 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_current00
04319 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_current00(lua_State* tolua_S)
04320 {
04321 #ifndef TOLUA_RELEASE
04322  tolua_Error tolua_err;
04323  if (
04324      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
04325      !tolua_isnoobj(tolua_S,2,&tolua_err)
04326  )
04327   goto tolua_lerror;
04328  else
04329 #endif
04330  {
04331   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
04332 #ifndef TOLUA_RELEASE
04333   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'current'", NULL);
04334 #endif
04335   {
04336    short tolua_ret = (short)  self->current();
04337    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04338   }
04339  }
04340  return 1;
04341 #ifndef TOLUA_RELEASE
04342  tolua_lerror:
04343  tolua_error(tolua_S,"#ferror in function 'current'.",&tolua_err);
04344  return 0;
04345 #endif
04346 }
04347 #endif //#ifndef TOLUA_DISABLE
04348 
04349 /* method: set_current of class  fawkes::Roomba500Interface */
04350 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_current00
04351 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_current00(lua_State* tolua_S)
04352 {
04353 #ifndef TOLUA_RELEASE
04354  tolua_Error tolua_err;
04355  if (
04356      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
04357      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
04358      !tolua_isnoobj(tolua_S,3,&tolua_err)
04359  )
04360   goto tolua_lerror;
04361  else
04362 #endif
04363  {
04364   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
04365   const short new_current = ((const short)  tolua_tonumber(tolua_S,2,0));
04366 #ifndef TOLUA_RELEASE
04367   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_current'", NULL);
04368 #endif
04369   {
04370    self->set_current(new_current);
04371   }
04372  }
04373  return 0;
04374 #ifndef TOLUA_RELEASE
04375  tolua_lerror:
04376  tolua_error(tolua_S,"#ferror in function 'set_current'.",&tolua_err);
04377  return 0;
04378 #endif
04379 }
04380 #endif //#ifndef TOLUA_DISABLE
04381 
04382 /* method: maxlenof_current of class  fawkes::Roomba500Interface */
04383 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_current00
04384 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_current00(lua_State* tolua_S)
04385 {
04386 #ifndef TOLUA_RELEASE
04387  tolua_Error tolua_err;
04388  if (
04389      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
04390      !tolua_isnoobj(tolua_S,2,&tolua_err)
04391  )
04392   goto tolua_lerror;
04393  else
04394 #endif
04395  {
04396   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
04397 #ifndef TOLUA_RELEASE
04398   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_current'", NULL);
04399 #endif
04400   {
04401    int tolua_ret = (int)  self->maxlenof_current();
04402    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04403   }
04404  }
04405  return 1;
04406 #ifndef TOLUA_RELEASE
04407  tolua_lerror:
04408  tolua_error(tolua_S,"#ferror in function 'maxlenof_current'.",&tolua_err);
04409  return 0;
04410 #endif
04411 }
04412 #endif //#ifndef TOLUA_DISABLE
04413 
04414 /* method: temperature of class  fawkes::Roomba500Interface */
04415 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_temperature00
04416 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_temperature00(lua_State* tolua_S)
04417 {
04418 #ifndef TOLUA_RELEASE
04419  tolua_Error tolua_err;
04420  if (
04421      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
04422      !tolua_isnoobj(tolua_S,2,&tolua_err)
04423  )
04424   goto tolua_lerror;
04425  else
04426 #endif
04427  {
04428   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
04429 #ifndef TOLUA_RELEASE
04430   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'temperature'", NULL);
04431 #endif
04432   {
04433    char tolua_ret = (char)  self->temperature();
04434    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04435   }
04436  }
04437  return 1;
04438 #ifndef TOLUA_RELEASE
04439  tolua_lerror:
04440  tolua_error(tolua_S,"#ferror in function 'temperature'.",&tolua_err);
04441  return 0;
04442 #endif
04443 }
04444 #endif //#ifndef TOLUA_DISABLE
04445 
04446 /* method: set_temperature of class  fawkes::Roomba500Interface */
04447 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_temperature00
04448 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_temperature00(lua_State* tolua_S)
04449 {
04450 #ifndef TOLUA_RELEASE
04451  tolua_Error tolua_err;
04452  if (
04453      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
04454      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
04455      !tolua_isnoobj(tolua_S,3,&tolua_err)
04456  )
04457   goto tolua_lerror;
04458  else
04459 #endif
04460  {
04461   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
04462   const char new_temperature = ((const char)  tolua_tonumber(tolua_S,2,0));
04463 #ifndef TOLUA_RELEASE
04464   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_temperature'", NULL);
04465 #endif
04466   {
04467    self->set_temperature(new_temperature);
04468   }
04469  }
04470  return 0;
04471 #ifndef TOLUA_RELEASE
04472  tolua_lerror:
04473  tolua_error(tolua_S,"#ferror in function 'set_temperature'.",&tolua_err);
04474  return 0;
04475 #endif
04476 }
04477 #endif //#ifndef TOLUA_DISABLE
04478 
04479 /* method: maxlenof_temperature of class  fawkes::Roomba500Interface */
04480 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_temperature00
04481 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_temperature00(lua_State* tolua_S)
04482 {
04483 #ifndef TOLUA_RELEASE
04484  tolua_Error tolua_err;
04485  if (
04486      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
04487      !tolua_isnoobj(tolua_S,2,&tolua_err)
04488  )
04489   goto tolua_lerror;
04490  else
04491 #endif
04492  {
04493   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
04494 #ifndef TOLUA_RELEASE
04495   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_temperature'", NULL);
04496 #endif
04497   {
04498    int tolua_ret = (int)  self->maxlenof_temperature();
04499    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04500   }
04501  }
04502  return 1;
04503 #ifndef TOLUA_RELEASE
04504  tolua_lerror:
04505  tolua_error(tolua_S,"#ferror in function 'maxlenof_temperature'.",&tolua_err);
04506  return 0;
04507 #endif
04508 }
04509 #endif //#ifndef TOLUA_DISABLE
04510 
04511 /* method: battery_charge of class  fawkes::Roomba500Interface */
04512 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_battery_charge00
04513 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_battery_charge00(lua_State* tolua_S)
04514 {
04515 #ifndef TOLUA_RELEASE
04516  tolua_Error tolua_err;
04517  if (
04518      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
04519      !tolua_isnoobj(tolua_S,2,&tolua_err)
04520  )
04521   goto tolua_lerror;
04522  else
04523 #endif
04524  {
04525   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
04526 #ifndef TOLUA_RELEASE
04527   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'battery_charge'", NULL);
04528 #endif
04529   {
04530    unsigned short tolua_ret = (unsigned short)  self->battery_charge();
04531    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04532   }
04533  }
04534  return 1;
04535 #ifndef TOLUA_RELEASE
04536  tolua_lerror:
04537  tolua_error(tolua_S,"#ferror in function 'battery_charge'.",&tolua_err);
04538  return 0;
04539 #endif
04540 }
04541 #endif //#ifndef TOLUA_DISABLE
04542 
04543 /* method: set_battery_charge of class  fawkes::Roomba500Interface */
04544 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_battery_charge00
04545 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_battery_charge00(lua_State* tolua_S)
04546 {
04547 #ifndef TOLUA_RELEASE
04548  tolua_Error tolua_err;
04549  if (
04550      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
04551      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
04552      !tolua_isnoobj(tolua_S,3,&tolua_err)
04553  )
04554   goto tolua_lerror;
04555  else
04556 #endif
04557  {
04558   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
04559   unsigned const short new_battery_charge = ((unsigned const short)  tolua_tonumber(tolua_S,2,0));
04560 #ifndef TOLUA_RELEASE
04561   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_battery_charge'", NULL);
04562 #endif
04563   {
04564    self->set_battery_charge(new_battery_charge);
04565   }
04566  }
04567  return 0;
04568 #ifndef TOLUA_RELEASE
04569  tolua_lerror:
04570  tolua_error(tolua_S,"#ferror in function 'set_battery_charge'.",&tolua_err);
04571  return 0;
04572 #endif
04573 }
04574 #endif //#ifndef TOLUA_DISABLE
04575 
04576 /* method: maxlenof_battery_charge of class  fawkes::Roomba500Interface */
04577 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_battery_charge00
04578 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_battery_charge00(lua_State* tolua_S)
04579 {
04580 #ifndef TOLUA_RELEASE
04581  tolua_Error tolua_err;
04582  if (
04583      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
04584      !tolua_isnoobj(tolua_S,2,&tolua_err)
04585  )
04586   goto tolua_lerror;
04587  else
04588 #endif
04589  {
04590   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
04591 #ifndef TOLUA_RELEASE
04592   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_battery_charge'", NULL);
04593 #endif
04594   {
04595    int tolua_ret = (int)  self->maxlenof_battery_charge();
04596    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04597   }
04598  }
04599  return 1;
04600 #ifndef TOLUA_RELEASE
04601  tolua_lerror:
04602  tolua_error(tolua_S,"#ferror in function 'maxlenof_battery_charge'.",&tolua_err);
04603  return 0;
04604 #endif
04605 }
04606 #endif //#ifndef TOLUA_DISABLE
04607 
04608 /* method: battery_capacity of class  fawkes::Roomba500Interface */
04609 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_battery_capacity00
04610 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_battery_capacity00(lua_State* tolua_S)
04611 {
04612 #ifndef TOLUA_RELEASE
04613  tolua_Error tolua_err;
04614  if (
04615      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
04616      !tolua_isnoobj(tolua_S,2,&tolua_err)
04617  )
04618   goto tolua_lerror;
04619  else
04620 #endif
04621  {
04622   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
04623 #ifndef TOLUA_RELEASE
04624   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'battery_capacity'", NULL);
04625 #endif
04626   {
04627    unsigned short tolua_ret = (unsigned short)  self->battery_capacity();
04628    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04629   }
04630  }
04631  return 1;
04632 #ifndef TOLUA_RELEASE
04633  tolua_lerror:
04634  tolua_error(tolua_S,"#ferror in function 'battery_capacity'.",&tolua_err);
04635  return 0;
04636 #endif
04637 }
04638 #endif //#ifndef TOLUA_DISABLE
04639 
04640 /* method: set_battery_capacity of class  fawkes::Roomba500Interface */
04641 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_battery_capacity00
04642 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_battery_capacity00(lua_State* tolua_S)
04643 {
04644 #ifndef TOLUA_RELEASE
04645  tolua_Error tolua_err;
04646  if (
04647      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
04648      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
04649      !tolua_isnoobj(tolua_S,3,&tolua_err)
04650  )
04651   goto tolua_lerror;
04652  else
04653 #endif
04654  {
04655   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
04656   unsigned const short new_battery_capacity = ((unsigned const short)  tolua_tonumber(tolua_S,2,0));
04657 #ifndef TOLUA_RELEASE
04658   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_battery_capacity'", NULL);
04659 #endif
04660   {
04661    self->set_battery_capacity(new_battery_capacity);
04662   }
04663  }
04664  return 0;
04665 #ifndef TOLUA_RELEASE
04666  tolua_lerror:
04667  tolua_error(tolua_S,"#ferror in function 'set_battery_capacity'.",&tolua_err);
04668  return 0;
04669 #endif
04670 }
04671 #endif //#ifndef TOLUA_DISABLE
04672 
04673 /* method: maxlenof_battery_capacity of class  fawkes::Roomba500Interface */
04674 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_battery_capacity00
04675 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_battery_capacity00(lua_State* tolua_S)
04676 {
04677 #ifndef TOLUA_RELEASE
04678  tolua_Error tolua_err;
04679  if (
04680      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
04681      !tolua_isnoobj(tolua_S,2,&tolua_err)
04682  )
04683   goto tolua_lerror;
04684  else
04685 #endif
04686  {
04687   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
04688 #ifndef TOLUA_RELEASE
04689   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_battery_capacity'", NULL);
04690 #endif
04691   {
04692    int tolua_ret = (int)  self->maxlenof_battery_capacity();
04693    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04694   }
04695  }
04696  return 1;
04697 #ifndef TOLUA_RELEASE
04698  tolua_lerror:
04699  tolua_error(tolua_S,"#ferror in function 'maxlenof_battery_capacity'.",&tolua_err);
04700  return 0;
04701 #endif
04702 }
04703 #endif //#ifndef TOLUA_DISABLE
04704 
04705 /* method: wall_signal of class  fawkes::Roomba500Interface */
04706 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_wall_signal00
04707 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_wall_signal00(lua_State* tolua_S)
04708 {
04709 #ifndef TOLUA_RELEASE
04710  tolua_Error tolua_err;
04711  if (
04712      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
04713      !tolua_isnoobj(tolua_S,2,&tolua_err)
04714  )
04715   goto tolua_lerror;
04716  else
04717 #endif
04718  {
04719   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
04720 #ifndef TOLUA_RELEASE
04721   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'wall_signal'", NULL);
04722 #endif
04723   {
04724    unsigned short tolua_ret = (unsigned short)  self->wall_signal();
04725    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04726   }
04727  }
04728  return 1;
04729 #ifndef TOLUA_RELEASE
04730  tolua_lerror:
04731  tolua_error(tolua_S,"#ferror in function 'wall_signal'.",&tolua_err);
04732  return 0;
04733 #endif
04734 }
04735 #endif //#ifndef TOLUA_DISABLE
04736 
04737 /* method: set_wall_signal of class  fawkes::Roomba500Interface */
04738 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_wall_signal00
04739 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_wall_signal00(lua_State* tolua_S)
04740 {
04741 #ifndef TOLUA_RELEASE
04742  tolua_Error tolua_err;
04743  if (
04744      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
04745      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
04746      !tolua_isnoobj(tolua_S,3,&tolua_err)
04747  )
04748   goto tolua_lerror;
04749  else
04750 #endif
04751  {
04752   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
04753   unsigned const short new_wall_signal = ((unsigned const short)  tolua_tonumber(tolua_S,2,0));
04754 #ifndef TOLUA_RELEASE
04755   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_wall_signal'", NULL);
04756 #endif
04757   {
04758    self->set_wall_signal(new_wall_signal);
04759   }
04760  }
04761  return 0;
04762 #ifndef TOLUA_RELEASE
04763  tolua_lerror:
04764  tolua_error(tolua_S,"#ferror in function 'set_wall_signal'.",&tolua_err);
04765  return 0;
04766 #endif
04767 }
04768 #endif //#ifndef TOLUA_DISABLE
04769 
04770 /* method: maxlenof_wall_signal of class  fawkes::Roomba500Interface */
04771 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_wall_signal00
04772 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_wall_signal00(lua_State* tolua_S)
04773 {
04774 #ifndef TOLUA_RELEASE
04775  tolua_Error tolua_err;
04776  if (
04777      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
04778      !tolua_isnoobj(tolua_S,2,&tolua_err)
04779  )
04780   goto tolua_lerror;
04781  else
04782 #endif
04783  {
04784   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
04785 #ifndef TOLUA_RELEASE
04786   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_wall_signal'", NULL);
04787 #endif
04788   {
04789    int tolua_ret = (int)  self->maxlenof_wall_signal();
04790    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04791   }
04792  }
04793  return 1;
04794 #ifndef TOLUA_RELEASE
04795  tolua_lerror:
04796  tolua_error(tolua_S,"#ferror in function 'maxlenof_wall_signal'.",&tolua_err);
04797  return 0;
04798 #endif
04799 }
04800 #endif //#ifndef TOLUA_DISABLE
04801 
04802 /* method: cliff_left_signal of class  fawkes::Roomba500Interface */
04803 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_cliff_left_signal00
04804 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_cliff_left_signal00(lua_State* tolua_S)
04805 {
04806 #ifndef TOLUA_RELEASE
04807  tolua_Error tolua_err;
04808  if (
04809      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
04810      !tolua_isnoobj(tolua_S,2,&tolua_err)
04811  )
04812   goto tolua_lerror;
04813  else
04814 #endif
04815  {
04816   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
04817 #ifndef TOLUA_RELEASE
04818   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'cliff_left_signal'", NULL);
04819 #endif
04820   {
04821    unsigned short tolua_ret = (unsigned short)  self->cliff_left_signal();
04822    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04823   }
04824  }
04825  return 1;
04826 #ifndef TOLUA_RELEASE
04827  tolua_lerror:
04828  tolua_error(tolua_S,"#ferror in function 'cliff_left_signal'.",&tolua_err);
04829  return 0;
04830 #endif
04831 }
04832 #endif //#ifndef TOLUA_DISABLE
04833 
04834 /* method: set_cliff_left_signal of class  fawkes::Roomba500Interface */
04835 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_cliff_left_signal00
04836 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_cliff_left_signal00(lua_State* tolua_S)
04837 {
04838 #ifndef TOLUA_RELEASE
04839  tolua_Error tolua_err;
04840  if (
04841      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
04842      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
04843      !tolua_isnoobj(tolua_S,3,&tolua_err)
04844  )
04845   goto tolua_lerror;
04846  else
04847 #endif
04848  {
04849   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
04850   unsigned const short new_cliff_left_signal = ((unsigned const short)  tolua_tonumber(tolua_S,2,0));
04851 #ifndef TOLUA_RELEASE
04852   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_cliff_left_signal'", NULL);
04853 #endif
04854   {
04855    self->set_cliff_left_signal(new_cliff_left_signal);
04856   }
04857  }
04858  return 0;
04859 #ifndef TOLUA_RELEASE
04860  tolua_lerror:
04861  tolua_error(tolua_S,"#ferror in function 'set_cliff_left_signal'.",&tolua_err);
04862  return 0;
04863 #endif
04864 }
04865 #endif //#ifndef TOLUA_DISABLE
04866 
04867 /* method: maxlenof_cliff_left_signal of class  fawkes::Roomba500Interface */
04868 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_cliff_left_signal00
04869 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_cliff_left_signal00(lua_State* tolua_S)
04870 {
04871 #ifndef TOLUA_RELEASE
04872  tolua_Error tolua_err;
04873  if (
04874      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
04875      !tolua_isnoobj(tolua_S,2,&tolua_err)
04876  )
04877   goto tolua_lerror;
04878  else
04879 #endif
04880  {
04881   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
04882 #ifndef TOLUA_RELEASE
04883   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_cliff_left_signal'", NULL);
04884 #endif
04885   {
04886    int tolua_ret = (int)  self->maxlenof_cliff_left_signal();
04887    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04888   }
04889  }
04890  return 1;
04891 #ifndef TOLUA_RELEASE
04892  tolua_lerror:
04893  tolua_error(tolua_S,"#ferror in function 'maxlenof_cliff_left_signal'.",&tolua_err);
04894  return 0;
04895 #endif
04896 }
04897 #endif //#ifndef TOLUA_DISABLE
04898 
04899 /* method: cliff_front_left_signal of class  fawkes::Roomba500Interface */
04900 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_cliff_front_left_signal00
04901 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_cliff_front_left_signal00(lua_State* tolua_S)
04902 {
04903 #ifndef TOLUA_RELEASE
04904  tolua_Error tolua_err;
04905  if (
04906      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
04907      !tolua_isnoobj(tolua_S,2,&tolua_err)
04908  )
04909   goto tolua_lerror;
04910  else
04911 #endif
04912  {
04913   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
04914 #ifndef TOLUA_RELEASE
04915   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'cliff_front_left_signal'", NULL);
04916 #endif
04917   {
04918    unsigned short tolua_ret = (unsigned short)  self->cliff_front_left_signal();
04919    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04920   }
04921  }
04922  return 1;
04923 #ifndef TOLUA_RELEASE
04924  tolua_lerror:
04925  tolua_error(tolua_S,"#ferror in function 'cliff_front_left_signal'.",&tolua_err);
04926  return 0;
04927 #endif
04928 }
04929 #endif //#ifndef TOLUA_DISABLE
04930 
04931 /* method: set_cliff_front_left_signal of class  fawkes::Roomba500Interface */
04932 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_cliff_front_left_signal00
04933 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_cliff_front_left_signal00(lua_State* tolua_S)
04934 {
04935 #ifndef TOLUA_RELEASE
04936  tolua_Error tolua_err;
04937  if (
04938      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
04939      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
04940      !tolua_isnoobj(tolua_S,3,&tolua_err)
04941  )
04942   goto tolua_lerror;
04943  else
04944 #endif
04945  {
04946   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
04947   unsigned const short new_cliff_front_left_signal = ((unsigned const short)  tolua_tonumber(tolua_S,2,0));
04948 #ifndef TOLUA_RELEASE
04949   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_cliff_front_left_signal'", NULL);
04950 #endif
04951   {
04952    self->set_cliff_front_left_signal(new_cliff_front_left_signal);
04953   }
04954  }
04955  return 0;
04956 #ifndef TOLUA_RELEASE
04957  tolua_lerror:
04958  tolua_error(tolua_S,"#ferror in function 'set_cliff_front_left_signal'.",&tolua_err);
04959  return 0;
04960 #endif
04961 }
04962 #endif //#ifndef TOLUA_DISABLE
04963 
04964 /* method: maxlenof_cliff_front_left_signal of class  fawkes::Roomba500Interface */
04965 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_cliff_front_left_signal00
04966 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_cliff_front_left_signal00(lua_State* tolua_S)
04967 {
04968 #ifndef TOLUA_RELEASE
04969  tolua_Error tolua_err;
04970  if (
04971      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
04972      !tolua_isnoobj(tolua_S,2,&tolua_err)
04973  )
04974   goto tolua_lerror;
04975  else
04976 #endif
04977  {
04978   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
04979 #ifndef TOLUA_RELEASE
04980   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_cliff_front_left_signal'", NULL);
04981 #endif
04982   {
04983    int tolua_ret = (int)  self->maxlenof_cliff_front_left_signal();
04984    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04985   }
04986  }
04987  return 1;
04988 #ifndef TOLUA_RELEASE
04989  tolua_lerror:
04990  tolua_error(tolua_S,"#ferror in function 'maxlenof_cliff_front_left_signal'.",&tolua_err);
04991  return 0;
04992 #endif
04993 }
04994 #endif //#ifndef TOLUA_DISABLE
04995 
04996 /* method: cliff_front_right_signal of class  fawkes::Roomba500Interface */
04997 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_cliff_front_right_signal00
04998 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_cliff_front_right_signal00(lua_State* tolua_S)
04999 {
05000 #ifndef TOLUA_RELEASE
05001  tolua_Error tolua_err;
05002  if (
05003      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
05004      !tolua_isnoobj(tolua_S,2,&tolua_err)
05005  )
05006   goto tolua_lerror;
05007  else
05008 #endif
05009  {
05010   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
05011 #ifndef TOLUA_RELEASE
05012   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'cliff_front_right_signal'", NULL);
05013 #endif
05014   {
05015    unsigned short tolua_ret = (unsigned short)  self->cliff_front_right_signal();
05016    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
05017   }
05018  }
05019  return 1;
05020 #ifndef TOLUA_RELEASE
05021  tolua_lerror:
05022  tolua_error(tolua_S,"#ferror in function 'cliff_front_right_signal'.",&tolua_err);
05023  return 0;
05024 #endif
05025 }
05026 #endif //#ifndef TOLUA_DISABLE
05027 
05028 /* method: set_cliff_front_right_signal of class  fawkes::Roomba500Interface */
05029 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_cliff_front_right_signal00
05030 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_cliff_front_right_signal00(lua_State* tolua_S)
05031 {
05032 #ifndef TOLUA_RELEASE
05033  tolua_Error tolua_err;
05034  if (
05035      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
05036      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
05037      !tolua_isnoobj(tolua_S,3,&tolua_err)
05038  )
05039   goto tolua_lerror;
05040  else
05041 #endif
05042  {
05043   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
05044   unsigned const short new_cliff_front_right_signal = ((unsigned const short)  tolua_tonumber(tolua_S,2,0));
05045 #ifndef TOLUA_RELEASE
05046   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_cliff_front_right_signal'", NULL);
05047 #endif
05048   {
05049    self->set_cliff_front_right_signal(new_cliff_front_right_signal);
05050   }
05051  }
05052  return 0;
05053 #ifndef TOLUA_RELEASE
05054  tolua_lerror:
05055  tolua_error(tolua_S,"#ferror in function 'set_cliff_front_right_signal'.",&tolua_err);
05056  return 0;
05057 #endif
05058 }
05059 #endif //#ifndef TOLUA_DISABLE
05060 
05061 /* method: maxlenof_cliff_front_right_signal of class  fawkes::Roomba500Interface */
05062 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_cliff_front_right_signal00
05063 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_cliff_front_right_signal00(lua_State* tolua_S)
05064 {
05065 #ifndef TOLUA_RELEASE
05066  tolua_Error tolua_err;
05067  if (
05068      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
05069      !tolua_isnoobj(tolua_S,2,&tolua_err)
05070  )
05071   goto tolua_lerror;
05072  else
05073 #endif
05074  {
05075   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
05076 #ifndef TOLUA_RELEASE
05077   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_cliff_front_right_signal'", NULL);
05078 #endif
05079   {
05080    int tolua_ret = (int)  self->maxlenof_cliff_front_right_signal();
05081    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
05082   }
05083  }
05084  return 1;
05085 #ifndef TOLUA_RELEASE
05086  tolua_lerror:
05087  tolua_error(tolua_S,"#ferror in function 'maxlenof_cliff_front_right_signal'.",&tolua_err);
05088  return 0;
05089 #endif
05090 }
05091 #endif //#ifndef TOLUA_DISABLE
05092 
05093 /* method: cliff_right_signal of class  fawkes::Roomba500Interface */
05094 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_cliff_right_signal00
05095 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_cliff_right_signal00(lua_State* tolua_S)
05096 {
05097 #ifndef TOLUA_RELEASE
05098  tolua_Error tolua_err;
05099  if (
05100      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
05101      !tolua_isnoobj(tolua_S,2,&tolua_err)
05102  )
05103   goto tolua_lerror;
05104  else
05105 #endif
05106  {
05107   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
05108 #ifndef TOLUA_RELEASE
05109   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'cliff_right_signal'", NULL);
05110 #endif
05111   {
05112    unsigned short tolua_ret = (unsigned short)  self->cliff_right_signal();
05113    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
05114   }
05115  }
05116  return 1;
05117 #ifndef TOLUA_RELEASE
05118  tolua_lerror:
05119  tolua_error(tolua_S,"#ferror in function 'cliff_right_signal'.",&tolua_err);
05120  return 0;
05121 #endif
05122 }
05123 #endif //#ifndef TOLUA_DISABLE
05124 
05125 /* method: set_cliff_right_signal of class  fawkes::Roomba500Interface */
05126 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_cliff_right_signal00
05127 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_cliff_right_signal00(lua_State* tolua_S)
05128 {
05129 #ifndef TOLUA_RELEASE
05130  tolua_Error tolua_err;
05131  if (
05132      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
05133      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
05134      !tolua_isnoobj(tolua_S,3,&tolua_err)
05135  )
05136   goto tolua_lerror;
05137  else
05138 #endif
05139  {
05140   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
05141   unsigned const short new_cliff_right_signal = ((unsigned const short)  tolua_tonumber(tolua_S,2,0));
05142 #ifndef TOLUA_RELEASE
05143   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_cliff_right_signal'", NULL);
05144 #endif
05145   {
05146    self->set_cliff_right_signal(new_cliff_right_signal);
05147   }
05148  }
05149  return 0;
05150 #ifndef TOLUA_RELEASE
05151  tolua_lerror:
05152  tolua_error(tolua_S,"#ferror in function 'set_cliff_right_signal'.",&tolua_err);
05153  return 0;
05154 #endif
05155 }
05156 #endif //#ifndef TOLUA_DISABLE
05157 
05158 /* method: maxlenof_cliff_right_signal of class  fawkes::Roomba500Interface */
05159 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_cliff_right_signal00
05160 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_cliff_right_signal00(lua_State* tolua_S)
05161 {
05162 #ifndef TOLUA_RELEASE
05163  tolua_Error tolua_err;
05164  if (
05165      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
05166      !tolua_isnoobj(tolua_S,2,&tolua_err)
05167  )
05168   goto tolua_lerror;
05169  else
05170 #endif
05171  {
05172   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
05173 #ifndef TOLUA_RELEASE
05174   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_cliff_right_signal'", NULL);
05175 #endif
05176   {
05177    int tolua_ret = (int)  self->maxlenof_cliff_right_signal();
05178    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
05179   }
05180  }
05181  return 1;
05182 #ifndef TOLUA_RELEASE
05183  tolua_lerror:
05184  tolua_error(tolua_S,"#ferror in function 'maxlenof_cliff_right_signal'.",&tolua_err);
05185  return 0;
05186 #endif
05187 }
05188 #endif //#ifndef TOLUA_DISABLE
05189 
05190 /* method: is_home_base_charger_available of class  fawkes::Roomba500Interface */
05191 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_home_base_charger_available00
05192 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_home_base_charger_available00(lua_State* tolua_S)
05193 {
05194 #ifndef TOLUA_RELEASE
05195  tolua_Error tolua_err;
05196  if (
05197      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
05198      !tolua_isnoobj(tolua_S,2,&tolua_err)
05199  )
05200   goto tolua_lerror;
05201  else
05202 #endif
05203  {
05204   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
05205 #ifndef TOLUA_RELEASE
05206   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_home_base_charger_available'", NULL);
05207 #endif
05208   {
05209    bool tolua_ret = (bool)  self->is_home_base_charger_available();
05210    tolua_pushboolean(tolua_S,(bool)tolua_ret);
05211   }
05212  }
05213  return 1;
05214 #ifndef TOLUA_RELEASE
05215  tolua_lerror:
05216  tolua_error(tolua_S,"#ferror in function 'is_home_base_charger_available'.",&tolua_err);
05217  return 0;
05218 #endif
05219 }
05220 #endif //#ifndef TOLUA_DISABLE
05221 
05222 /* method: set_home_base_charger_available of class  fawkes::Roomba500Interface */
05223 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_home_base_charger_available00
05224 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_home_base_charger_available00(lua_State* tolua_S)
05225 {
05226 #ifndef TOLUA_RELEASE
05227  tolua_Error tolua_err;
05228  if (
05229      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
05230      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
05231      !tolua_isnoobj(tolua_S,3,&tolua_err)
05232  )
05233   goto tolua_lerror;
05234  else
05235 #endif
05236  {
05237   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
05238   const bool new_home_base_charger_available = ((const bool)  tolua_toboolean(tolua_S,2,0));
05239 #ifndef TOLUA_RELEASE
05240   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_home_base_charger_available'", NULL);
05241 #endif
05242   {
05243    self->set_home_base_charger_available(new_home_base_charger_available);
05244   }
05245  }
05246  return 0;
05247 #ifndef TOLUA_RELEASE
05248  tolua_lerror:
05249  tolua_error(tolua_S,"#ferror in function 'set_home_base_charger_available'.",&tolua_err);
05250  return 0;
05251 #endif
05252 }
05253 #endif //#ifndef TOLUA_DISABLE
05254 
05255 /* method: maxlenof_home_base_charger_available of class  fawkes::Roomba500Interface */
05256 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_home_base_charger_available00
05257 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_home_base_charger_available00(lua_State* tolua_S)
05258 {
05259 #ifndef TOLUA_RELEASE
05260  tolua_Error tolua_err;
05261  if (
05262      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
05263      !tolua_isnoobj(tolua_S,2,&tolua_err)
05264  )
05265   goto tolua_lerror;
05266  else
05267 #endif
05268  {
05269   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
05270 #ifndef TOLUA_RELEASE
05271   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_home_base_charger_available'", NULL);
05272 #endif
05273   {
05274    int tolua_ret = (int)  self->maxlenof_home_base_charger_available();
05275    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
05276   }
05277  }
05278  return 1;
05279 #ifndef TOLUA_RELEASE
05280  tolua_lerror:
05281  tolua_error(tolua_S,"#ferror in function 'maxlenof_home_base_charger_available'.",&tolua_err);
05282  return 0;
05283 #endif
05284 }
05285 #endif //#ifndef TOLUA_DISABLE
05286 
05287 /* method: is_internal_charger_available of class  fawkes::Roomba500Interface */
05288 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_internal_charger_available00
05289 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_internal_charger_available00(lua_State* tolua_S)
05290 {
05291 #ifndef TOLUA_RELEASE
05292  tolua_Error tolua_err;
05293  if (
05294      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
05295      !tolua_isnoobj(tolua_S,2,&tolua_err)
05296  )
05297   goto tolua_lerror;
05298  else
05299 #endif
05300  {
05301   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
05302 #ifndef TOLUA_RELEASE
05303   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_internal_charger_available'", NULL);
05304 #endif
05305   {
05306    bool tolua_ret = (bool)  self->is_internal_charger_available();
05307    tolua_pushboolean(tolua_S,(bool)tolua_ret);
05308   }
05309  }
05310  return 1;
05311 #ifndef TOLUA_RELEASE
05312  tolua_lerror:
05313  tolua_error(tolua_S,"#ferror in function 'is_internal_charger_available'.",&tolua_err);
05314  return 0;
05315 #endif
05316 }
05317 #endif //#ifndef TOLUA_DISABLE
05318 
05319 /* method: set_internal_charger_available of class  fawkes::Roomba500Interface */
05320 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_internal_charger_available00
05321 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_internal_charger_available00(lua_State* tolua_S)
05322 {
05323 #ifndef TOLUA_RELEASE
05324  tolua_Error tolua_err;
05325  if (
05326      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
05327      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
05328      !tolua_isnoobj(tolua_S,3,&tolua_err)
05329  )
05330   goto tolua_lerror;
05331  else
05332 #endif
05333  {
05334   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
05335   const bool new_internal_charger_available = ((const bool)  tolua_toboolean(tolua_S,2,0));
05336 #ifndef TOLUA_RELEASE
05337   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_internal_charger_available'", NULL);
05338 #endif
05339   {
05340    self->set_internal_charger_available(new_internal_charger_available);
05341   }
05342  }
05343  return 0;
05344 #ifndef TOLUA_RELEASE
05345  tolua_lerror:
05346  tolua_error(tolua_S,"#ferror in function 'set_internal_charger_available'.",&tolua_err);
05347  return 0;
05348 #endif
05349 }
05350 #endif //#ifndef TOLUA_DISABLE
05351 
05352 /* method: maxlenof_internal_charger_available of class  fawkes::Roomba500Interface */
05353 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_internal_charger_available00
05354 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_internal_charger_available00(lua_State* tolua_S)
05355 {
05356 #ifndef TOLUA_RELEASE
05357  tolua_Error tolua_err;
05358  if (
05359      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
05360      !tolua_isnoobj(tolua_S,2,&tolua_err)
05361  )
05362   goto tolua_lerror;
05363  else
05364 #endif
05365  {
05366   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
05367 #ifndef TOLUA_RELEASE
05368   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_internal_charger_available'", NULL);
05369 #endif
05370   {
05371    int tolua_ret = (int)  self->maxlenof_internal_charger_available();
05372    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
05373   }
05374  }
05375  return 1;
05376 #ifndef TOLUA_RELEASE
05377  tolua_lerror:
05378  tolua_error(tolua_S,"#ferror in function 'maxlenof_internal_charger_available'.",&tolua_err);
05379  return 0;
05380 #endif
05381 }
05382 #endif //#ifndef TOLUA_DISABLE
05383 
05384 /* method: song_number of class  fawkes::Roomba500Interface */
05385 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_song_number00
05386 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_song_number00(lua_State* tolua_S)
05387 {
05388 #ifndef TOLUA_RELEASE
05389  tolua_Error tolua_err;
05390  if (
05391      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
05392      !tolua_isnoobj(tolua_S,2,&tolua_err)
05393  )
05394   goto tolua_lerror;
05395  else
05396 #endif
05397  {
05398   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
05399 #ifndef TOLUA_RELEASE
05400   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'song_number'", NULL);
05401 #endif
05402   {
05403    unsigned char tolua_ret = (unsigned char)  self->song_number();
05404    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
05405   }
05406  }
05407  return 1;
05408 #ifndef TOLUA_RELEASE
05409  tolua_lerror:
05410  tolua_error(tolua_S,"#ferror in function 'song_number'.",&tolua_err);
05411  return 0;
05412 #endif
05413 }
05414 #endif //#ifndef TOLUA_DISABLE
05415 
05416 /* method: set_song_number of class  fawkes::Roomba500Interface */
05417 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_song_number00
05418 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_song_number00(lua_State* tolua_S)
05419 {
05420 #ifndef TOLUA_RELEASE
05421  tolua_Error tolua_err;
05422  if (
05423      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
05424      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
05425      !tolua_isnoobj(tolua_S,3,&tolua_err)
05426  )
05427   goto tolua_lerror;
05428  else
05429 #endif
05430  {
05431   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
05432   unsigned const char new_song_number = ((unsigned const char)  tolua_tonumber(tolua_S,2,0));
05433 #ifndef TOLUA_RELEASE
05434   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_song_number'", NULL);
05435 #endif
05436   {
05437    self->set_song_number(new_song_number);
05438   }
05439  }
05440  return 0;
05441 #ifndef TOLUA_RELEASE
05442  tolua_lerror:
05443  tolua_error(tolua_S,"#ferror in function 'set_song_number'.",&tolua_err);
05444  return 0;
05445 #endif
05446 }
05447 #endif //#ifndef TOLUA_DISABLE
05448 
05449 /* method: maxlenof_song_number of class  fawkes::Roomba500Interface */
05450 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_song_number00
05451 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_song_number00(lua_State* tolua_S)
05452 {
05453 #ifndef TOLUA_RELEASE
05454  tolua_Error tolua_err;
05455  if (
05456      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
05457      !tolua_isnoobj(tolua_S,2,&tolua_err)
05458  )
05459   goto tolua_lerror;
05460  else
05461 #endif
05462  {
05463   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
05464 #ifndef TOLUA_RELEASE
05465   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_song_number'", NULL);
05466 #endif
05467   {
05468    int tolua_ret = (int)  self->maxlenof_song_number();
05469    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
05470   }
05471  }
05472  return 1;
05473 #ifndef TOLUA_RELEASE
05474  tolua_lerror:
05475  tolua_error(tolua_S,"#ferror in function 'maxlenof_song_number'.",&tolua_err);
05476  return 0;
05477 #endif
05478 }
05479 #endif //#ifndef TOLUA_DISABLE
05480 
05481 /* method: is_song_playing of class  fawkes::Roomba500Interface */
05482 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_song_playing00
05483 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_song_playing00(lua_State* tolua_S)
05484 {
05485 #ifndef TOLUA_RELEASE
05486  tolua_Error tolua_err;
05487  if (
05488      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
05489      !tolua_isnoobj(tolua_S,2,&tolua_err)
05490  )
05491   goto tolua_lerror;
05492  else
05493 #endif
05494  {
05495   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
05496 #ifndef TOLUA_RELEASE
05497   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_song_playing'", NULL);
05498 #endif
05499   {
05500    bool tolua_ret = (bool)  self->is_song_playing();
05501    tolua_pushboolean(tolua_S,(bool)tolua_ret);
05502   }
05503  }
05504  return 1;
05505 #ifndef TOLUA_RELEASE
05506  tolua_lerror:
05507  tolua_error(tolua_S,"#ferror in function 'is_song_playing'.",&tolua_err);
05508  return 0;
05509 #endif
05510 }
05511 #endif //#ifndef TOLUA_DISABLE
05512 
05513 /* method: set_song_playing of class  fawkes::Roomba500Interface */
05514 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_song_playing00
05515 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_song_playing00(lua_State* tolua_S)
05516 {
05517 #ifndef TOLUA_RELEASE
05518  tolua_Error tolua_err;
05519  if (
05520      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
05521      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
05522      !tolua_isnoobj(tolua_S,3,&tolua_err)
05523  )
05524   goto tolua_lerror;
05525  else
05526 #endif
05527  {
05528   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
05529   const bool new_song_playing = ((const bool)  tolua_toboolean(tolua_S,2,0));
05530 #ifndef TOLUA_RELEASE
05531   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_song_playing'", NULL);
05532 #endif
05533   {
05534    self->set_song_playing(new_song_playing);
05535   }
05536  }
05537  return 0;
05538 #ifndef TOLUA_RELEASE
05539  tolua_lerror:
05540  tolua_error(tolua_S,"#ferror in function 'set_song_playing'.",&tolua_err);
05541  return 0;
05542 #endif
05543 }
05544 #endif //#ifndef TOLUA_DISABLE
05545 
05546 /* method: maxlenof_song_playing of class  fawkes::Roomba500Interface */
05547 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_song_playing00
05548 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_song_playing00(lua_State* tolua_S)
05549 {
05550 #ifndef TOLUA_RELEASE
05551  tolua_Error tolua_err;
05552  if (
05553      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
05554      !tolua_isnoobj(tolua_S,2,&tolua_err)
05555  )
05556   goto tolua_lerror;
05557  else
05558 #endif
05559  {
05560   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
05561 #ifndef TOLUA_RELEASE
05562   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_song_playing'", NULL);
05563 #endif
05564   {
05565    int tolua_ret = (int)  self->maxlenof_song_playing();
05566    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
05567   }
05568  }
05569  return 1;
05570 #ifndef TOLUA_RELEASE
05571  tolua_lerror:
05572  tolua_error(tolua_S,"#ferror in function 'maxlenof_song_playing'.",&tolua_err);
05573  return 0;
05574 #endif
05575 }
05576 #endif //#ifndef TOLUA_DISABLE
05577 
05578 /* method: velocity of class  fawkes::Roomba500Interface */
05579 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_velocity00
05580 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_velocity00(lua_State* tolua_S)
05581 {
05582 #ifndef TOLUA_RELEASE
05583  tolua_Error tolua_err;
05584  if (
05585      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
05586      !tolua_isnoobj(tolua_S,2,&tolua_err)
05587  )
05588   goto tolua_lerror;
05589  else
05590 #endif
05591  {
05592   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
05593 #ifndef TOLUA_RELEASE
05594   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'velocity'", NULL);
05595 #endif
05596   {
05597    short tolua_ret = (short)  self->velocity();
05598    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
05599   }
05600  }
05601  return 1;
05602 #ifndef TOLUA_RELEASE
05603  tolua_lerror:
05604  tolua_error(tolua_S,"#ferror in function 'velocity'.",&tolua_err);
05605  return 0;
05606 #endif
05607 }
05608 #endif //#ifndef TOLUA_DISABLE
05609 
05610 /* method: set_velocity of class  fawkes::Roomba500Interface */
05611 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_velocity00
05612 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_velocity00(lua_State* tolua_S)
05613 {
05614 #ifndef TOLUA_RELEASE
05615  tolua_Error tolua_err;
05616  if (
05617      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
05618      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
05619      !tolua_isnoobj(tolua_S,3,&tolua_err)
05620  )
05621   goto tolua_lerror;
05622  else
05623 #endif
05624  {
05625   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
05626   const short new_velocity = ((const short)  tolua_tonumber(tolua_S,2,0));
05627 #ifndef TOLUA_RELEASE
05628   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_velocity'", NULL);
05629 #endif
05630   {
05631    self->set_velocity(new_velocity);
05632   }
05633  }
05634  return 0;
05635 #ifndef TOLUA_RELEASE
05636  tolua_lerror:
05637  tolua_error(tolua_S,"#ferror in function 'set_velocity'.",&tolua_err);
05638  return 0;
05639 #endif
05640 }
05641 #endif //#ifndef TOLUA_DISABLE
05642 
05643 /* method: maxlenof_velocity of class  fawkes::Roomba500Interface */
05644 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_velocity00
05645 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_velocity00(lua_State* tolua_S)
05646 {
05647 #ifndef TOLUA_RELEASE
05648  tolua_Error tolua_err;
05649  if (
05650      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
05651      !tolua_isnoobj(tolua_S,2,&tolua_err)
05652  )
05653   goto tolua_lerror;
05654  else
05655 #endif
05656  {
05657   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
05658 #ifndef TOLUA_RELEASE
05659   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_velocity'", NULL);
05660 #endif
05661   {
05662    int tolua_ret = (int)  self->maxlenof_velocity();
05663    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
05664   }
05665  }
05666  return 1;
05667 #ifndef TOLUA_RELEASE
05668  tolua_lerror:
05669  tolua_error(tolua_S,"#ferror in function 'maxlenof_velocity'.",&tolua_err);
05670  return 0;
05671 #endif
05672 }
05673 #endif //#ifndef TOLUA_DISABLE
05674 
05675 /* method: radius of class  fawkes::Roomba500Interface */
05676 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_radius00
05677 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_radius00(lua_State* tolua_S)
05678 {
05679 #ifndef TOLUA_RELEASE
05680  tolua_Error tolua_err;
05681  if (
05682      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
05683      !tolua_isnoobj(tolua_S,2,&tolua_err)
05684  )
05685   goto tolua_lerror;
05686  else
05687 #endif
05688  {
05689   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
05690 #ifndef TOLUA_RELEASE
05691   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'radius'", NULL);
05692 #endif
05693   {
05694    short tolua_ret = (short)  self->radius();
05695    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
05696   }
05697  }
05698  return 1;
05699 #ifndef TOLUA_RELEASE
05700  tolua_lerror:
05701  tolua_error(tolua_S,"#ferror in function 'radius'.",&tolua_err);
05702  return 0;
05703 #endif
05704 }
05705 #endif //#ifndef TOLUA_DISABLE
05706 
05707 /* method: set_radius of class  fawkes::Roomba500Interface */
05708 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_radius00
05709 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_radius00(lua_State* tolua_S)
05710 {
05711 #ifndef TOLUA_RELEASE
05712  tolua_Error tolua_err;
05713  if (
05714      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
05715      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
05716      !tolua_isnoobj(tolua_S,3,&tolua_err)
05717  )
05718   goto tolua_lerror;
05719  else
05720 #endif
05721  {
05722   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
05723   const short new_radius = ((const short)  tolua_tonumber(tolua_S,2,0));
05724 #ifndef TOLUA_RELEASE
05725   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_radius'", NULL);
05726 #endif
05727   {
05728    self->set_radius(new_radius);
05729   }
05730  }
05731  return 0;
05732 #ifndef TOLUA_RELEASE
05733  tolua_lerror:
05734  tolua_error(tolua_S,"#ferror in function 'set_radius'.",&tolua_err);
05735  return 0;
05736 #endif
05737 }
05738 #endif //#ifndef TOLUA_DISABLE
05739 
05740 /* method: maxlenof_radius of class  fawkes::Roomba500Interface */
05741 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_radius00
05742 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_radius00(lua_State* tolua_S)
05743 {
05744 #ifndef TOLUA_RELEASE
05745  tolua_Error tolua_err;
05746  if (
05747      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
05748      !tolua_isnoobj(tolua_S,2,&tolua_err)
05749  )
05750   goto tolua_lerror;
05751  else
05752 #endif
05753  {
05754   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
05755 #ifndef TOLUA_RELEASE
05756   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_radius'", NULL);
05757 #endif
05758   {
05759    int tolua_ret = (int)  self->maxlenof_radius();
05760    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
05761   }
05762  }
05763  return 1;
05764 #ifndef TOLUA_RELEASE
05765  tolua_lerror:
05766  tolua_error(tolua_S,"#ferror in function 'maxlenof_radius'.",&tolua_err);
05767  return 0;
05768 #endif
05769 }
05770 #endif //#ifndef TOLUA_DISABLE
05771 
05772 /* method: velocity_right of class  fawkes::Roomba500Interface */
05773 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_velocity_right00
05774 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_velocity_right00(lua_State* tolua_S)
05775 {
05776 #ifndef TOLUA_RELEASE
05777  tolua_Error tolua_err;
05778  if (
05779      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
05780      !tolua_isnoobj(tolua_S,2,&tolua_err)
05781  )
05782   goto tolua_lerror;
05783  else
05784 #endif
05785  {
05786   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
05787 #ifndef TOLUA_RELEASE
05788   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'velocity_right'", NULL);
05789 #endif
05790   {
05791    short tolua_ret = (short)  self->velocity_right();
05792    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
05793   }
05794  }
05795  return 1;
05796 #ifndef TOLUA_RELEASE
05797  tolua_lerror:
05798  tolua_error(tolua_S,"#ferror in function 'velocity_right'.",&tolua_err);
05799  return 0;
05800 #endif
05801 }
05802 #endif //#ifndef TOLUA_DISABLE
05803 
05804 /* method: set_velocity_right of class  fawkes::Roomba500Interface */
05805 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_velocity_right00
05806 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_velocity_right00(lua_State* tolua_S)
05807 {
05808 #ifndef TOLUA_RELEASE
05809  tolua_Error tolua_err;
05810  if (
05811      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
05812      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
05813      !tolua_isnoobj(tolua_S,3,&tolua_err)
05814  )
05815   goto tolua_lerror;
05816  else
05817 #endif
05818  {
05819   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
05820   const short new_velocity_right = ((const short)  tolua_tonumber(tolua_S,2,0));
05821 #ifndef TOLUA_RELEASE
05822   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_velocity_right'", NULL);
05823 #endif
05824   {
05825    self->set_velocity_right(new_velocity_right);
05826   }
05827  }
05828  return 0;
05829 #ifndef TOLUA_RELEASE
05830  tolua_lerror:
05831  tolua_error(tolua_S,"#ferror in function 'set_velocity_right'.",&tolua_err);
05832  return 0;
05833 #endif
05834 }
05835 #endif //#ifndef TOLUA_DISABLE
05836 
05837 /* method: maxlenof_velocity_right of class  fawkes::Roomba500Interface */
05838 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_velocity_right00
05839 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_velocity_right00(lua_State* tolua_S)
05840 {
05841 #ifndef TOLUA_RELEASE
05842  tolua_Error tolua_err;
05843  if (
05844      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
05845      !tolua_isnoobj(tolua_S,2,&tolua_err)
05846  )
05847   goto tolua_lerror;
05848  else
05849 #endif
05850  {
05851   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
05852 #ifndef TOLUA_RELEASE
05853   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_velocity_right'", NULL);
05854 #endif
05855   {
05856    int tolua_ret = (int)  self->maxlenof_velocity_right();
05857    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
05858   }
05859  }
05860  return 1;
05861 #ifndef TOLUA_RELEASE
05862  tolua_lerror:
05863  tolua_error(tolua_S,"#ferror in function 'maxlenof_velocity_right'.",&tolua_err);
05864  return 0;
05865 #endif
05866 }
05867 #endif //#ifndef TOLUA_DISABLE
05868 
05869 /* method: velocity_left of class  fawkes::Roomba500Interface */
05870 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_velocity_left00
05871 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_velocity_left00(lua_State* tolua_S)
05872 {
05873 #ifndef TOLUA_RELEASE
05874  tolua_Error tolua_err;
05875  if (
05876      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
05877      !tolua_isnoobj(tolua_S,2,&tolua_err)
05878  )
05879   goto tolua_lerror;
05880  else
05881 #endif
05882  {
05883   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
05884 #ifndef TOLUA_RELEASE
05885   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'velocity_left'", NULL);
05886 #endif
05887   {
05888    short tolua_ret = (short)  self->velocity_left();
05889    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
05890   }
05891  }
05892  return 1;
05893 #ifndef TOLUA_RELEASE
05894  tolua_lerror:
05895  tolua_error(tolua_S,"#ferror in function 'velocity_left'.",&tolua_err);
05896  return 0;
05897 #endif
05898 }
05899 #endif //#ifndef TOLUA_DISABLE
05900 
05901 /* method: set_velocity_left of class  fawkes::Roomba500Interface */
05902 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_velocity_left00
05903 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_velocity_left00(lua_State* tolua_S)
05904 {
05905 #ifndef TOLUA_RELEASE
05906  tolua_Error tolua_err;
05907  if (
05908      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
05909      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
05910      !tolua_isnoobj(tolua_S,3,&tolua_err)
05911  )
05912   goto tolua_lerror;
05913  else
05914 #endif
05915  {
05916   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
05917   const short new_velocity_left = ((const short)  tolua_tonumber(tolua_S,2,0));
05918 #ifndef TOLUA_RELEASE
05919   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_velocity_left'", NULL);
05920 #endif
05921   {
05922    self->set_velocity_left(new_velocity_left);
05923   }
05924  }
05925  return 0;
05926 #ifndef TOLUA_RELEASE
05927  tolua_lerror:
05928  tolua_error(tolua_S,"#ferror in function 'set_velocity_left'.",&tolua_err);
05929  return 0;
05930 #endif
05931 }
05932 #endif //#ifndef TOLUA_DISABLE
05933 
05934 /* method: maxlenof_velocity_left of class  fawkes::Roomba500Interface */
05935 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_velocity_left00
05936 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_velocity_left00(lua_State* tolua_S)
05937 {
05938 #ifndef TOLUA_RELEASE
05939  tolua_Error tolua_err;
05940  if (
05941      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
05942      !tolua_isnoobj(tolua_S,2,&tolua_err)
05943  )
05944   goto tolua_lerror;
05945  else
05946 #endif
05947  {
05948   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
05949 #ifndef TOLUA_RELEASE
05950   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_velocity_left'", NULL);
05951 #endif
05952   {
05953    int tolua_ret = (int)  self->maxlenof_velocity_left();
05954    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
05955   }
05956  }
05957  return 1;
05958 #ifndef TOLUA_RELEASE
05959  tolua_lerror:
05960  tolua_error(tolua_S,"#ferror in function 'maxlenof_velocity_left'.",&tolua_err);
05961  return 0;
05962 #endif
05963 }
05964 #endif //#ifndef TOLUA_DISABLE
05965 
05966 /* method: encoder_counts_left of class  fawkes::Roomba500Interface */
05967 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_encoder_counts_left00
05968 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_encoder_counts_left00(lua_State* tolua_S)
05969 {
05970 #ifndef TOLUA_RELEASE
05971  tolua_Error tolua_err;
05972  if (
05973      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
05974      !tolua_isnoobj(tolua_S,2,&tolua_err)
05975  )
05976   goto tolua_lerror;
05977  else
05978 #endif
05979  {
05980   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
05981 #ifndef TOLUA_RELEASE
05982   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'encoder_counts_left'", NULL);
05983 #endif
05984   {
05985    unsigned short tolua_ret = (unsigned short)  self->encoder_counts_left();
05986    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
05987   }
05988  }
05989  return 1;
05990 #ifndef TOLUA_RELEASE
05991  tolua_lerror:
05992  tolua_error(tolua_S,"#ferror in function 'encoder_counts_left'.",&tolua_err);
05993  return 0;
05994 #endif
05995 }
05996 #endif //#ifndef TOLUA_DISABLE
05997 
05998 /* method: set_encoder_counts_left of class  fawkes::Roomba500Interface */
05999 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_encoder_counts_left00
06000 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_encoder_counts_left00(lua_State* tolua_S)
06001 {
06002 #ifndef TOLUA_RELEASE
06003  tolua_Error tolua_err;
06004  if (
06005      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
06006      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
06007      !tolua_isnoobj(tolua_S,3,&tolua_err)
06008  )
06009   goto tolua_lerror;
06010  else
06011 #endif
06012  {
06013   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
06014   unsigned const short new_encoder_counts_left = ((unsigned const short)  tolua_tonumber(tolua_S,2,0));
06015 #ifndef TOLUA_RELEASE
06016   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_encoder_counts_left'", NULL);
06017 #endif
06018   {
06019    self->set_encoder_counts_left(new_encoder_counts_left);
06020   }
06021  }
06022  return 0;
06023 #ifndef TOLUA_RELEASE
06024  tolua_lerror:
06025  tolua_error(tolua_S,"#ferror in function 'set_encoder_counts_left'.",&tolua_err);
06026  return 0;
06027 #endif
06028 }
06029 #endif //#ifndef TOLUA_DISABLE
06030 
06031 /* method: maxlenof_encoder_counts_left of class  fawkes::Roomba500Interface */
06032 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_encoder_counts_left00
06033 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_encoder_counts_left00(lua_State* tolua_S)
06034 {
06035 #ifndef TOLUA_RELEASE
06036  tolua_Error tolua_err;
06037  if (
06038      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
06039      !tolua_isnoobj(tolua_S,2,&tolua_err)
06040  )
06041   goto tolua_lerror;
06042  else
06043 #endif
06044  {
06045   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
06046 #ifndef TOLUA_RELEASE
06047   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_encoder_counts_left'", NULL);
06048 #endif
06049   {
06050    int tolua_ret = (int)  self->maxlenof_encoder_counts_left();
06051    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
06052   }
06053  }
06054  return 1;
06055 #ifndef TOLUA_RELEASE
06056  tolua_lerror:
06057  tolua_error(tolua_S,"#ferror in function 'maxlenof_encoder_counts_left'.",&tolua_err);
06058  return 0;
06059 #endif
06060 }
06061 #endif //#ifndef TOLUA_DISABLE
06062 
06063 /* method: encoder_counts_right of class  fawkes::Roomba500Interface */
06064 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_encoder_counts_right00
06065 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_encoder_counts_right00(lua_State* tolua_S)
06066 {
06067 #ifndef TOLUA_RELEASE
06068  tolua_Error tolua_err;
06069  if (
06070      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
06071      !tolua_isnoobj(tolua_S,2,&tolua_err)
06072  )
06073   goto tolua_lerror;
06074  else
06075 #endif
06076  {
06077   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
06078 #ifndef TOLUA_RELEASE
06079   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'encoder_counts_right'", NULL);
06080 #endif
06081   {
06082    unsigned short tolua_ret = (unsigned short)  self->encoder_counts_right();
06083    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
06084   }
06085  }
06086  return 1;
06087 #ifndef TOLUA_RELEASE
06088  tolua_lerror:
06089  tolua_error(tolua_S,"#ferror in function 'encoder_counts_right'.",&tolua_err);
06090  return 0;
06091 #endif
06092 }
06093 #endif //#ifndef TOLUA_DISABLE
06094 
06095 /* method: set_encoder_counts_right of class  fawkes::Roomba500Interface */
06096 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_encoder_counts_right00
06097 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_encoder_counts_right00(lua_State* tolua_S)
06098 {
06099 #ifndef TOLUA_RELEASE
06100  tolua_Error tolua_err;
06101  if (
06102      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
06103      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
06104      !tolua_isnoobj(tolua_S,3,&tolua_err)
06105  )
06106   goto tolua_lerror;
06107  else
06108 #endif
06109  {
06110   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
06111   unsigned const short new_encoder_counts_right = ((unsigned const short)  tolua_tonumber(tolua_S,2,0));
06112 #ifndef TOLUA_RELEASE
06113   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_encoder_counts_right'", NULL);
06114 #endif
06115   {
06116    self->set_encoder_counts_right(new_encoder_counts_right);
06117   }
06118  }
06119  return 0;
06120 #ifndef TOLUA_RELEASE
06121  tolua_lerror:
06122  tolua_error(tolua_S,"#ferror in function 'set_encoder_counts_right'.",&tolua_err);
06123  return 0;
06124 #endif
06125 }
06126 #endif //#ifndef TOLUA_DISABLE
06127 
06128 /* method: maxlenof_encoder_counts_right of class  fawkes::Roomba500Interface */
06129 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_encoder_counts_right00
06130 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_encoder_counts_right00(lua_State* tolua_S)
06131 {
06132 #ifndef TOLUA_RELEASE
06133  tolua_Error tolua_err;
06134  if (
06135      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
06136      !tolua_isnoobj(tolua_S,2,&tolua_err)
06137  )
06138   goto tolua_lerror;
06139  else
06140 #endif
06141  {
06142   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
06143 #ifndef TOLUA_RELEASE
06144   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_encoder_counts_right'", NULL);
06145 #endif
06146   {
06147    int tolua_ret = (int)  self->maxlenof_encoder_counts_right();
06148    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
06149   }
06150  }
06151  return 1;
06152 #ifndef TOLUA_RELEASE
06153  tolua_lerror:
06154  tolua_error(tolua_S,"#ferror in function 'maxlenof_encoder_counts_right'.",&tolua_err);
06155  return 0;
06156 #endif
06157 }
06158 #endif //#ifndef TOLUA_DISABLE
06159 
06160 /* method: is_bumper_left of class  fawkes::Roomba500Interface */
06161 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_bumper_left00
06162 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_bumper_left00(lua_State* tolua_S)
06163 {
06164 #ifndef TOLUA_RELEASE
06165  tolua_Error tolua_err;
06166  if (
06167      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
06168      !tolua_isnoobj(tolua_S,2,&tolua_err)
06169  )
06170   goto tolua_lerror;
06171  else
06172 #endif
06173  {
06174   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
06175 #ifndef TOLUA_RELEASE
06176   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_bumper_left'", NULL);
06177 #endif
06178   {
06179    bool tolua_ret = (bool)  self->is_bumper_left();
06180    tolua_pushboolean(tolua_S,(bool)tolua_ret);
06181   }
06182  }
06183  return 1;
06184 #ifndef TOLUA_RELEASE
06185  tolua_lerror:
06186  tolua_error(tolua_S,"#ferror in function 'is_bumper_left'.",&tolua_err);
06187  return 0;
06188 #endif
06189 }
06190 #endif //#ifndef TOLUA_DISABLE
06191 
06192 /* method: set_bumper_left of class  fawkes::Roomba500Interface */
06193 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_bumper_left00
06194 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_bumper_left00(lua_State* tolua_S)
06195 {
06196 #ifndef TOLUA_RELEASE
06197  tolua_Error tolua_err;
06198  if (
06199      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
06200      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
06201      !tolua_isnoobj(tolua_S,3,&tolua_err)
06202  )
06203   goto tolua_lerror;
06204  else
06205 #endif
06206  {
06207   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
06208   const bool new_bumper_left = ((const bool)  tolua_toboolean(tolua_S,2,0));
06209 #ifndef TOLUA_RELEASE
06210   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_bumper_left'", NULL);
06211 #endif
06212   {
06213    self->set_bumper_left(new_bumper_left);
06214   }
06215  }
06216  return 0;
06217 #ifndef TOLUA_RELEASE
06218  tolua_lerror:
06219  tolua_error(tolua_S,"#ferror in function 'set_bumper_left'.",&tolua_err);
06220  return 0;
06221 #endif
06222 }
06223 #endif //#ifndef TOLUA_DISABLE
06224 
06225 /* method: maxlenof_bumper_left of class  fawkes::Roomba500Interface */
06226 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_bumper_left00
06227 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_bumper_left00(lua_State* tolua_S)
06228 {
06229 #ifndef TOLUA_RELEASE
06230  tolua_Error tolua_err;
06231  if (
06232      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
06233      !tolua_isnoobj(tolua_S,2,&tolua_err)
06234  )
06235   goto tolua_lerror;
06236  else
06237 #endif
06238  {
06239   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
06240 #ifndef TOLUA_RELEASE
06241   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_bumper_left'", NULL);
06242 #endif
06243   {
06244    int tolua_ret = (int)  self->maxlenof_bumper_left();
06245    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
06246   }
06247  }
06248  return 1;
06249 #ifndef TOLUA_RELEASE
06250  tolua_lerror:
06251  tolua_error(tolua_S,"#ferror in function 'maxlenof_bumper_left'.",&tolua_err);
06252  return 0;
06253 #endif
06254 }
06255 #endif //#ifndef TOLUA_DISABLE
06256 
06257 /* method: is_bumper_front_left of class  fawkes::Roomba500Interface */
06258 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_bumper_front_left00
06259 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_bumper_front_left00(lua_State* tolua_S)
06260 {
06261 #ifndef TOLUA_RELEASE
06262  tolua_Error tolua_err;
06263  if (
06264      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
06265      !tolua_isnoobj(tolua_S,2,&tolua_err)
06266  )
06267   goto tolua_lerror;
06268  else
06269 #endif
06270  {
06271   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
06272 #ifndef TOLUA_RELEASE
06273   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_bumper_front_left'", NULL);
06274 #endif
06275   {
06276    bool tolua_ret = (bool)  self->is_bumper_front_left();
06277    tolua_pushboolean(tolua_S,(bool)tolua_ret);
06278   }
06279  }
06280  return 1;
06281 #ifndef TOLUA_RELEASE
06282  tolua_lerror:
06283  tolua_error(tolua_S,"#ferror in function 'is_bumper_front_left'.",&tolua_err);
06284  return 0;
06285 #endif
06286 }
06287 #endif //#ifndef TOLUA_DISABLE
06288 
06289 /* method: set_bumper_front_left of class  fawkes::Roomba500Interface */
06290 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_bumper_front_left00
06291 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_bumper_front_left00(lua_State* tolua_S)
06292 {
06293 #ifndef TOLUA_RELEASE
06294  tolua_Error tolua_err;
06295  if (
06296      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
06297      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
06298      !tolua_isnoobj(tolua_S,3,&tolua_err)
06299  )
06300   goto tolua_lerror;
06301  else
06302 #endif
06303  {
06304   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
06305   const bool new_bumper_front_left = ((const bool)  tolua_toboolean(tolua_S,2,0));
06306 #ifndef TOLUA_RELEASE
06307   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_bumper_front_left'", NULL);
06308 #endif
06309   {
06310    self->set_bumper_front_left(new_bumper_front_left);
06311   }
06312  }
06313  return 0;
06314 #ifndef TOLUA_RELEASE
06315  tolua_lerror:
06316  tolua_error(tolua_S,"#ferror in function 'set_bumper_front_left'.",&tolua_err);
06317  return 0;
06318 #endif
06319 }
06320 #endif //#ifndef TOLUA_DISABLE
06321 
06322 /* method: maxlenof_bumper_front_left of class  fawkes::Roomba500Interface */
06323 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_bumper_front_left00
06324 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_bumper_front_left00(lua_State* tolua_S)
06325 {
06326 #ifndef TOLUA_RELEASE
06327  tolua_Error tolua_err;
06328  if (
06329      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
06330      !tolua_isnoobj(tolua_S,2,&tolua_err)
06331  )
06332   goto tolua_lerror;
06333  else
06334 #endif
06335  {
06336   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
06337 #ifndef TOLUA_RELEASE
06338   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_bumper_front_left'", NULL);
06339 #endif
06340   {
06341    int tolua_ret = (int)  self->maxlenof_bumper_front_left();
06342    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
06343   }
06344  }
06345  return 1;
06346 #ifndef TOLUA_RELEASE
06347  tolua_lerror:
06348  tolua_error(tolua_S,"#ferror in function 'maxlenof_bumper_front_left'.",&tolua_err);
06349  return 0;
06350 #endif
06351 }
06352 #endif //#ifndef TOLUA_DISABLE
06353 
06354 /* method: is_bumper_center_left of class  fawkes::Roomba500Interface */
06355 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_bumper_center_left00
06356 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_bumper_center_left00(lua_State* tolua_S)
06357 {
06358 #ifndef TOLUA_RELEASE
06359  tolua_Error tolua_err;
06360  if (
06361      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
06362      !tolua_isnoobj(tolua_S,2,&tolua_err)
06363  )
06364   goto tolua_lerror;
06365  else
06366 #endif
06367  {
06368   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
06369 #ifndef TOLUA_RELEASE
06370   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_bumper_center_left'", NULL);
06371 #endif
06372   {
06373    bool tolua_ret = (bool)  self->is_bumper_center_left();
06374    tolua_pushboolean(tolua_S,(bool)tolua_ret);
06375   }
06376  }
06377  return 1;
06378 #ifndef TOLUA_RELEASE
06379  tolua_lerror:
06380  tolua_error(tolua_S,"#ferror in function 'is_bumper_center_left'.",&tolua_err);
06381  return 0;
06382 #endif
06383 }
06384 #endif //#ifndef TOLUA_DISABLE
06385 
06386 /* method: set_bumper_center_left of class  fawkes::Roomba500Interface */
06387 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_bumper_center_left00
06388 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_bumper_center_left00(lua_State* tolua_S)
06389 {
06390 #ifndef TOLUA_RELEASE
06391  tolua_Error tolua_err;
06392  if (
06393      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
06394      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
06395      !tolua_isnoobj(tolua_S,3,&tolua_err)
06396  )
06397   goto tolua_lerror;
06398  else
06399 #endif
06400  {
06401   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
06402   const bool new_bumper_center_left = ((const bool)  tolua_toboolean(tolua_S,2,0));
06403 #ifndef TOLUA_RELEASE
06404   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_bumper_center_left'", NULL);
06405 #endif
06406   {
06407    self->set_bumper_center_left(new_bumper_center_left);
06408   }
06409  }
06410  return 0;
06411 #ifndef TOLUA_RELEASE
06412  tolua_lerror:
06413  tolua_error(tolua_S,"#ferror in function 'set_bumper_center_left'.",&tolua_err);
06414  return 0;
06415 #endif
06416 }
06417 #endif //#ifndef TOLUA_DISABLE
06418 
06419 /* method: maxlenof_bumper_center_left of class  fawkes::Roomba500Interface */
06420 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_bumper_center_left00
06421 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_bumper_center_left00(lua_State* tolua_S)
06422 {
06423 #ifndef TOLUA_RELEASE
06424  tolua_Error tolua_err;
06425  if (
06426      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
06427      !tolua_isnoobj(tolua_S,2,&tolua_err)
06428  )
06429   goto tolua_lerror;
06430  else
06431 #endif
06432  {
06433   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
06434 #ifndef TOLUA_RELEASE
06435   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_bumper_center_left'", NULL);
06436 #endif
06437   {
06438    int tolua_ret = (int)  self->maxlenof_bumper_center_left();
06439    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
06440   }
06441  }
06442  return 1;
06443 #ifndef TOLUA_RELEASE
06444  tolua_lerror:
06445  tolua_error(tolua_S,"#ferror in function 'maxlenof_bumper_center_left'.",&tolua_err);
06446  return 0;
06447 #endif
06448 }
06449 #endif //#ifndef TOLUA_DISABLE
06450 
06451 /* method: is_bumper_center_right of class  fawkes::Roomba500Interface */
06452 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_bumper_center_right00
06453 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_bumper_center_right00(lua_State* tolua_S)
06454 {
06455 #ifndef TOLUA_RELEASE
06456  tolua_Error tolua_err;
06457  if (
06458      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
06459      !tolua_isnoobj(tolua_S,2,&tolua_err)
06460  )
06461   goto tolua_lerror;
06462  else
06463 #endif
06464  {
06465   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
06466 #ifndef TOLUA_RELEASE
06467   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_bumper_center_right'", NULL);
06468 #endif
06469   {
06470    bool tolua_ret = (bool)  self->is_bumper_center_right();
06471    tolua_pushboolean(tolua_S,(bool)tolua_ret);
06472   }
06473  }
06474  return 1;
06475 #ifndef TOLUA_RELEASE
06476  tolua_lerror:
06477  tolua_error(tolua_S,"#ferror in function 'is_bumper_center_right'.",&tolua_err);
06478  return 0;
06479 #endif
06480 }
06481 #endif //#ifndef TOLUA_DISABLE
06482 
06483 /* method: set_bumper_center_right of class  fawkes::Roomba500Interface */
06484 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_bumper_center_right00
06485 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_bumper_center_right00(lua_State* tolua_S)
06486 {
06487 #ifndef TOLUA_RELEASE
06488  tolua_Error tolua_err;
06489  if (
06490      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
06491      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
06492      !tolua_isnoobj(tolua_S,3,&tolua_err)
06493  )
06494   goto tolua_lerror;
06495  else
06496 #endif
06497  {
06498   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
06499   const bool new_bumper_center_right = ((const bool)  tolua_toboolean(tolua_S,2,0));
06500 #ifndef TOLUA_RELEASE
06501   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_bumper_center_right'", NULL);
06502 #endif
06503   {
06504    self->set_bumper_center_right(new_bumper_center_right);
06505   }
06506  }
06507  return 0;
06508 #ifndef TOLUA_RELEASE
06509  tolua_lerror:
06510  tolua_error(tolua_S,"#ferror in function 'set_bumper_center_right'.",&tolua_err);
06511  return 0;
06512 #endif
06513 }
06514 #endif //#ifndef TOLUA_DISABLE
06515 
06516 /* method: maxlenof_bumper_center_right of class  fawkes::Roomba500Interface */
06517 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_bumper_center_right00
06518 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_bumper_center_right00(lua_State* tolua_S)
06519 {
06520 #ifndef TOLUA_RELEASE
06521  tolua_Error tolua_err;
06522  if (
06523      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
06524      !tolua_isnoobj(tolua_S,2,&tolua_err)
06525  )
06526   goto tolua_lerror;
06527  else
06528 #endif
06529  {
06530   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
06531 #ifndef TOLUA_RELEASE
06532   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_bumper_center_right'", NULL);
06533 #endif
06534   {
06535    int tolua_ret = (int)  self->maxlenof_bumper_center_right();
06536    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
06537   }
06538  }
06539  return 1;
06540 #ifndef TOLUA_RELEASE
06541  tolua_lerror:
06542  tolua_error(tolua_S,"#ferror in function 'maxlenof_bumper_center_right'.",&tolua_err);
06543  return 0;
06544 #endif
06545 }
06546 #endif //#ifndef TOLUA_DISABLE
06547 
06548 /* method: is_bumper_front_right of class  fawkes::Roomba500Interface */
06549 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_bumper_front_right00
06550 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_bumper_front_right00(lua_State* tolua_S)
06551 {
06552 #ifndef TOLUA_RELEASE
06553  tolua_Error tolua_err;
06554  if (
06555      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
06556      !tolua_isnoobj(tolua_S,2,&tolua_err)
06557  )
06558   goto tolua_lerror;
06559  else
06560 #endif
06561  {
06562   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
06563 #ifndef TOLUA_RELEASE
06564   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_bumper_front_right'", NULL);
06565 #endif
06566   {
06567    bool tolua_ret = (bool)  self->is_bumper_front_right();
06568    tolua_pushboolean(tolua_S,(bool)tolua_ret);
06569   }
06570  }
06571  return 1;
06572 #ifndef TOLUA_RELEASE
06573  tolua_lerror:
06574  tolua_error(tolua_S,"#ferror in function 'is_bumper_front_right'.",&tolua_err);
06575  return 0;
06576 #endif
06577 }
06578 #endif //#ifndef TOLUA_DISABLE
06579 
06580 /* method: set_bumper_front_right of class  fawkes::Roomba500Interface */
06581 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_bumper_front_right00
06582 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_bumper_front_right00(lua_State* tolua_S)
06583 {
06584 #ifndef TOLUA_RELEASE
06585  tolua_Error tolua_err;
06586  if (
06587      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
06588      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
06589      !tolua_isnoobj(tolua_S,3,&tolua_err)
06590  )
06591   goto tolua_lerror;
06592  else
06593 #endif
06594  {
06595   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
06596   const bool new_bumper_front_right = ((const bool)  tolua_toboolean(tolua_S,2,0));
06597 #ifndef TOLUA_RELEASE
06598   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_bumper_front_right'", NULL);
06599 #endif
06600   {
06601    self->set_bumper_front_right(new_bumper_front_right);
06602   }
06603  }
06604  return 0;
06605 #ifndef TOLUA_RELEASE
06606  tolua_lerror:
06607  tolua_error(tolua_S,"#ferror in function 'set_bumper_front_right'.",&tolua_err);
06608  return 0;
06609 #endif
06610 }
06611 #endif //#ifndef TOLUA_DISABLE
06612 
06613 /* method: maxlenof_bumper_front_right of class  fawkes::Roomba500Interface */
06614 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_bumper_front_right00
06615 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_bumper_front_right00(lua_State* tolua_S)
06616 {
06617 #ifndef TOLUA_RELEASE
06618  tolua_Error tolua_err;
06619  if (
06620      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
06621      !tolua_isnoobj(tolua_S,2,&tolua_err)
06622  )
06623   goto tolua_lerror;
06624  else
06625 #endif
06626  {
06627   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
06628 #ifndef TOLUA_RELEASE
06629   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_bumper_front_right'", NULL);
06630 #endif
06631   {
06632    int tolua_ret = (int)  self->maxlenof_bumper_front_right();
06633    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
06634   }
06635  }
06636  return 1;
06637 #ifndef TOLUA_RELEASE
06638  tolua_lerror:
06639  tolua_error(tolua_S,"#ferror in function 'maxlenof_bumper_front_right'.",&tolua_err);
06640  return 0;
06641 #endif
06642 }
06643 #endif //#ifndef TOLUA_DISABLE
06644 
06645 /* method: is_bumper_right of class  fawkes::Roomba500Interface */
06646 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_bumper_right00
06647 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_bumper_right00(lua_State* tolua_S)
06648 {
06649 #ifndef TOLUA_RELEASE
06650  tolua_Error tolua_err;
06651  if (
06652      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
06653      !tolua_isnoobj(tolua_S,2,&tolua_err)
06654  )
06655   goto tolua_lerror;
06656  else
06657 #endif
06658  {
06659   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
06660 #ifndef TOLUA_RELEASE
06661   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_bumper_right'", NULL);
06662 #endif
06663   {
06664    bool tolua_ret = (bool)  self->is_bumper_right();
06665    tolua_pushboolean(tolua_S,(bool)tolua_ret);
06666   }
06667  }
06668  return 1;
06669 #ifndef TOLUA_RELEASE
06670  tolua_lerror:
06671  tolua_error(tolua_S,"#ferror in function 'is_bumper_right'.",&tolua_err);
06672  return 0;
06673 #endif
06674 }
06675 #endif //#ifndef TOLUA_DISABLE
06676 
06677 /* method: set_bumper_right of class  fawkes::Roomba500Interface */
06678 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_bumper_right00
06679 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_bumper_right00(lua_State* tolua_S)
06680 {
06681 #ifndef TOLUA_RELEASE
06682  tolua_Error tolua_err;
06683  if (
06684      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
06685      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
06686      !tolua_isnoobj(tolua_S,3,&tolua_err)
06687  )
06688   goto tolua_lerror;
06689  else
06690 #endif
06691  {
06692   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
06693   const bool new_bumper_right = ((const bool)  tolua_toboolean(tolua_S,2,0));
06694 #ifndef TOLUA_RELEASE
06695   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_bumper_right'", NULL);
06696 #endif
06697   {
06698    self->set_bumper_right(new_bumper_right);
06699   }
06700  }
06701  return 0;
06702 #ifndef TOLUA_RELEASE
06703  tolua_lerror:
06704  tolua_error(tolua_S,"#ferror in function 'set_bumper_right'.",&tolua_err);
06705  return 0;
06706 #endif
06707 }
06708 #endif //#ifndef TOLUA_DISABLE
06709 
06710 /* method: maxlenof_bumper_right of class  fawkes::Roomba500Interface */
06711 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_bumper_right00
06712 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_bumper_right00(lua_State* tolua_S)
06713 {
06714 #ifndef TOLUA_RELEASE
06715  tolua_Error tolua_err;
06716  if (
06717      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
06718      !tolua_isnoobj(tolua_S,2,&tolua_err)
06719  )
06720   goto tolua_lerror;
06721  else
06722 #endif
06723  {
06724   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
06725 #ifndef TOLUA_RELEASE
06726   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_bumper_right'", NULL);
06727 #endif
06728   {
06729    int tolua_ret = (int)  self->maxlenof_bumper_right();
06730    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
06731   }
06732  }
06733  return 1;
06734 #ifndef TOLUA_RELEASE
06735  tolua_lerror:
06736  tolua_error(tolua_S,"#ferror in function 'maxlenof_bumper_right'.",&tolua_err);
06737  return 0;
06738 #endif
06739 }
06740 #endif //#ifndef TOLUA_DISABLE
06741 
06742 /* method: light_bump_left of class  fawkes::Roomba500Interface */
06743 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_light_bump_left00
06744 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_light_bump_left00(lua_State* tolua_S)
06745 {
06746 #ifndef TOLUA_RELEASE
06747  tolua_Error tolua_err;
06748  if (
06749      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
06750      !tolua_isnoobj(tolua_S,2,&tolua_err)
06751  )
06752   goto tolua_lerror;
06753  else
06754 #endif
06755  {
06756   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
06757 #ifndef TOLUA_RELEASE
06758   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'light_bump_left'", NULL);
06759 #endif
06760   {
06761    unsigned short tolua_ret = (unsigned short)  self->light_bump_left();
06762    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
06763   }
06764  }
06765  return 1;
06766 #ifndef TOLUA_RELEASE
06767  tolua_lerror:
06768  tolua_error(tolua_S,"#ferror in function 'light_bump_left'.",&tolua_err);
06769  return 0;
06770 #endif
06771 }
06772 #endif //#ifndef TOLUA_DISABLE
06773 
06774 /* method: set_light_bump_left of class  fawkes::Roomba500Interface */
06775 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_light_bump_left00
06776 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_light_bump_left00(lua_State* tolua_S)
06777 {
06778 #ifndef TOLUA_RELEASE
06779  tolua_Error tolua_err;
06780  if (
06781      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
06782      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
06783      !tolua_isnoobj(tolua_S,3,&tolua_err)
06784  )
06785   goto tolua_lerror;
06786  else
06787 #endif
06788  {
06789   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
06790   unsigned const short new_light_bump_left = ((unsigned const short)  tolua_tonumber(tolua_S,2,0));
06791 #ifndef TOLUA_RELEASE
06792   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_light_bump_left'", NULL);
06793 #endif
06794   {
06795    self->set_light_bump_left(new_light_bump_left);
06796   }
06797  }
06798  return 0;
06799 #ifndef TOLUA_RELEASE
06800  tolua_lerror:
06801  tolua_error(tolua_S,"#ferror in function 'set_light_bump_left'.",&tolua_err);
06802  return 0;
06803 #endif
06804 }
06805 #endif //#ifndef TOLUA_DISABLE
06806 
06807 /* method: maxlenof_light_bump_left of class  fawkes::Roomba500Interface */
06808 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_light_bump_left00
06809 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_light_bump_left00(lua_State* tolua_S)
06810 {
06811 #ifndef TOLUA_RELEASE
06812  tolua_Error tolua_err;
06813  if (
06814      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
06815      !tolua_isnoobj(tolua_S,2,&tolua_err)
06816  )
06817   goto tolua_lerror;
06818  else
06819 #endif
06820  {
06821   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
06822 #ifndef TOLUA_RELEASE
06823   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_light_bump_left'", NULL);
06824 #endif
06825   {
06826    int tolua_ret = (int)  self->maxlenof_light_bump_left();
06827    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
06828   }
06829  }
06830  return 1;
06831 #ifndef TOLUA_RELEASE
06832  tolua_lerror:
06833  tolua_error(tolua_S,"#ferror in function 'maxlenof_light_bump_left'.",&tolua_err);
06834  return 0;
06835 #endif
06836 }
06837 #endif //#ifndef TOLUA_DISABLE
06838 
06839 /* method: light_bump_front_left of class  fawkes::Roomba500Interface */
06840 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_light_bump_front_left00
06841 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_light_bump_front_left00(lua_State* tolua_S)
06842 {
06843 #ifndef TOLUA_RELEASE
06844  tolua_Error tolua_err;
06845  if (
06846      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
06847      !tolua_isnoobj(tolua_S,2,&tolua_err)
06848  )
06849   goto tolua_lerror;
06850  else
06851 #endif
06852  {
06853   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
06854 #ifndef TOLUA_RELEASE
06855   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'light_bump_front_left'", NULL);
06856 #endif
06857   {
06858    unsigned short tolua_ret = (unsigned short)  self->light_bump_front_left();
06859    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
06860   }
06861  }
06862  return 1;
06863 #ifndef TOLUA_RELEASE
06864  tolua_lerror:
06865  tolua_error(tolua_S,"#ferror in function 'light_bump_front_left'.",&tolua_err);
06866  return 0;
06867 #endif
06868 }
06869 #endif //#ifndef TOLUA_DISABLE
06870 
06871 /* method: set_light_bump_front_left of class  fawkes::Roomba500Interface */
06872 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_light_bump_front_left00
06873 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_light_bump_front_left00(lua_State* tolua_S)
06874 {
06875 #ifndef TOLUA_RELEASE
06876  tolua_Error tolua_err;
06877  if (
06878      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
06879      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
06880      !tolua_isnoobj(tolua_S,3,&tolua_err)
06881  )
06882   goto tolua_lerror;
06883  else
06884 #endif
06885  {
06886   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
06887   unsigned const short new_light_bump_front_left = ((unsigned const short)  tolua_tonumber(tolua_S,2,0));
06888 #ifndef TOLUA_RELEASE
06889   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_light_bump_front_left'", NULL);
06890 #endif
06891   {
06892    self->set_light_bump_front_left(new_light_bump_front_left);
06893   }
06894  }
06895  return 0;
06896 #ifndef TOLUA_RELEASE
06897  tolua_lerror:
06898  tolua_error(tolua_S,"#ferror in function 'set_light_bump_front_left'.",&tolua_err);
06899  return 0;
06900 #endif
06901 }
06902 #endif //#ifndef TOLUA_DISABLE
06903 
06904 /* method: maxlenof_light_bump_front_left of class  fawkes::Roomba500Interface */
06905 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_light_bump_front_left00
06906 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_light_bump_front_left00(lua_State* tolua_S)
06907 {
06908 #ifndef TOLUA_RELEASE
06909  tolua_Error tolua_err;
06910  if (
06911      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
06912      !tolua_isnoobj(tolua_S,2,&tolua_err)
06913  )
06914   goto tolua_lerror;
06915  else
06916 #endif
06917  {
06918   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
06919 #ifndef TOLUA_RELEASE
06920   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_light_bump_front_left'", NULL);
06921 #endif
06922   {
06923    int tolua_ret = (int)  self->maxlenof_light_bump_front_left();
06924    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
06925   }
06926  }
06927  return 1;
06928 #ifndef TOLUA_RELEASE
06929  tolua_lerror:
06930  tolua_error(tolua_S,"#ferror in function 'maxlenof_light_bump_front_left'.",&tolua_err);
06931  return 0;
06932 #endif
06933 }
06934 #endif //#ifndef TOLUA_DISABLE
06935 
06936 /* method: light_bump_center_left of class  fawkes::Roomba500Interface */
06937 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_light_bump_center_left00
06938 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_light_bump_center_left00(lua_State* tolua_S)
06939 {
06940 #ifndef TOLUA_RELEASE
06941  tolua_Error tolua_err;
06942  if (
06943      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
06944      !tolua_isnoobj(tolua_S,2,&tolua_err)
06945  )
06946   goto tolua_lerror;
06947  else
06948 #endif
06949  {
06950   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
06951 #ifndef TOLUA_RELEASE
06952   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'light_bump_center_left'", NULL);
06953 #endif
06954   {
06955    unsigned short tolua_ret = (unsigned short)  self->light_bump_center_left();
06956    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
06957   }
06958  }
06959  return 1;
06960 #ifndef TOLUA_RELEASE
06961  tolua_lerror:
06962  tolua_error(tolua_S,"#ferror in function 'light_bump_center_left'.",&tolua_err);
06963  return 0;
06964 #endif
06965 }
06966 #endif //#ifndef TOLUA_DISABLE
06967 
06968 /* method: set_light_bump_center_left of class  fawkes::Roomba500Interface */
06969 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_light_bump_center_left00
06970 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_light_bump_center_left00(lua_State* tolua_S)
06971 {
06972 #ifndef TOLUA_RELEASE
06973  tolua_Error tolua_err;
06974  if (
06975      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
06976      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
06977      !tolua_isnoobj(tolua_S,3,&tolua_err)
06978  )
06979   goto tolua_lerror;
06980  else
06981 #endif
06982  {
06983   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
06984   unsigned const short new_light_bump_center_left = ((unsigned const short)  tolua_tonumber(tolua_S,2,0));
06985 #ifndef TOLUA_RELEASE
06986   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_light_bump_center_left'", NULL);
06987 #endif
06988   {
06989    self->set_light_bump_center_left(new_light_bump_center_left);
06990   }
06991  }
06992  return 0;
06993 #ifndef TOLUA_RELEASE
06994  tolua_lerror:
06995  tolua_error(tolua_S,"#ferror in function 'set_light_bump_center_left'.",&tolua_err);
06996  return 0;
06997 #endif
06998 }
06999 #endif //#ifndef TOLUA_DISABLE
07000 
07001 /* method: maxlenof_light_bump_center_left of class  fawkes::Roomba500Interface */
07002 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_light_bump_center_left00
07003 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_light_bump_center_left00(lua_State* tolua_S)
07004 {
07005 #ifndef TOLUA_RELEASE
07006  tolua_Error tolua_err;
07007  if (
07008      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
07009      !tolua_isnoobj(tolua_S,2,&tolua_err)
07010  )
07011   goto tolua_lerror;
07012  else
07013 #endif
07014  {
07015   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
07016 #ifndef TOLUA_RELEASE
07017   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_light_bump_center_left'", NULL);
07018 #endif
07019   {
07020    int tolua_ret = (int)  self->maxlenof_light_bump_center_left();
07021    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
07022   }
07023  }
07024  return 1;
07025 #ifndef TOLUA_RELEASE
07026  tolua_lerror:
07027  tolua_error(tolua_S,"#ferror in function 'maxlenof_light_bump_center_left'.",&tolua_err);
07028  return 0;
07029 #endif
07030 }
07031 #endif //#ifndef TOLUA_DISABLE
07032 
07033 /* method: light_bump_center_right of class  fawkes::Roomba500Interface */
07034 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_light_bump_center_right00
07035 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_light_bump_center_right00(lua_State* tolua_S)
07036 {
07037 #ifndef TOLUA_RELEASE
07038  tolua_Error tolua_err;
07039  if (
07040      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
07041      !tolua_isnoobj(tolua_S,2,&tolua_err)
07042  )
07043   goto tolua_lerror;
07044  else
07045 #endif
07046  {
07047   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
07048 #ifndef TOLUA_RELEASE
07049   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'light_bump_center_right'", NULL);
07050 #endif
07051   {
07052    unsigned short tolua_ret = (unsigned short)  self->light_bump_center_right();
07053    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
07054   }
07055  }
07056  return 1;
07057 #ifndef TOLUA_RELEASE
07058  tolua_lerror:
07059  tolua_error(tolua_S,"#ferror in function 'light_bump_center_right'.",&tolua_err);
07060  return 0;
07061 #endif
07062 }
07063 #endif //#ifndef TOLUA_DISABLE
07064 
07065 /* method: set_light_bump_center_right of class  fawkes::Roomba500Interface */
07066 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_light_bump_center_right00
07067 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_light_bump_center_right00(lua_State* tolua_S)
07068 {
07069 #ifndef TOLUA_RELEASE
07070  tolua_Error tolua_err;
07071  if (
07072      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
07073      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
07074      !tolua_isnoobj(tolua_S,3,&tolua_err)
07075  )
07076   goto tolua_lerror;
07077  else
07078 #endif
07079  {
07080   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
07081   unsigned const short new_light_bump_center_right = ((unsigned const short)  tolua_tonumber(tolua_S,2,0));
07082 #ifndef TOLUA_RELEASE
07083   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_light_bump_center_right'", NULL);
07084 #endif
07085   {
07086    self->set_light_bump_center_right(new_light_bump_center_right);
07087   }
07088  }
07089  return 0;
07090 #ifndef TOLUA_RELEASE
07091  tolua_lerror:
07092  tolua_error(tolua_S,"#ferror in function 'set_light_bump_center_right'.",&tolua_err);
07093  return 0;
07094 #endif
07095 }
07096 #endif //#ifndef TOLUA_DISABLE
07097 
07098 /* method: maxlenof_light_bump_center_right of class  fawkes::Roomba500Interface */
07099 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_light_bump_center_right00
07100 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_light_bump_center_right00(lua_State* tolua_S)
07101 {
07102 #ifndef TOLUA_RELEASE
07103  tolua_Error tolua_err;
07104  if (
07105      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
07106      !tolua_isnoobj(tolua_S,2,&tolua_err)
07107  )
07108   goto tolua_lerror;
07109  else
07110 #endif
07111  {
07112   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
07113 #ifndef TOLUA_RELEASE
07114   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_light_bump_center_right'", NULL);
07115 #endif
07116   {
07117    int tolua_ret = (int)  self->maxlenof_light_bump_center_right();
07118    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
07119   }
07120  }
07121  return 1;
07122 #ifndef TOLUA_RELEASE
07123  tolua_lerror:
07124  tolua_error(tolua_S,"#ferror in function 'maxlenof_light_bump_center_right'.",&tolua_err);
07125  return 0;
07126 #endif
07127 }
07128 #endif //#ifndef TOLUA_DISABLE
07129 
07130 /* method: light_bump_front_right of class  fawkes::Roomba500Interface */
07131 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_light_bump_front_right00
07132 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_light_bump_front_right00(lua_State* tolua_S)
07133 {
07134 #ifndef TOLUA_RELEASE
07135  tolua_Error tolua_err;
07136  if (
07137      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
07138      !tolua_isnoobj(tolua_S,2,&tolua_err)
07139  )
07140   goto tolua_lerror;
07141  else
07142 #endif
07143  {
07144   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
07145 #ifndef TOLUA_RELEASE
07146   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'light_bump_front_right'", NULL);
07147 #endif
07148   {
07149    unsigned short tolua_ret = (unsigned short)  self->light_bump_front_right();
07150    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
07151   }
07152  }
07153  return 1;
07154 #ifndef TOLUA_RELEASE
07155  tolua_lerror:
07156  tolua_error(tolua_S,"#ferror in function 'light_bump_front_right'.",&tolua_err);
07157  return 0;
07158 #endif
07159 }
07160 #endif //#ifndef TOLUA_DISABLE
07161 
07162 /* method: set_light_bump_front_right of class  fawkes::Roomba500Interface */
07163 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_light_bump_front_right00
07164 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_light_bump_front_right00(lua_State* tolua_S)
07165 {
07166 #ifndef TOLUA_RELEASE
07167  tolua_Error tolua_err;
07168  if (
07169      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
07170      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
07171      !tolua_isnoobj(tolua_S,3,&tolua_err)
07172  )
07173   goto tolua_lerror;
07174  else
07175 #endif
07176  {
07177   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
07178   unsigned const short new_light_bump_front_right = ((unsigned const short)  tolua_tonumber(tolua_S,2,0));
07179 #ifndef TOLUA_RELEASE
07180   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_light_bump_front_right'", NULL);
07181 #endif
07182   {
07183    self->set_light_bump_front_right(new_light_bump_front_right);
07184   }
07185  }
07186  return 0;
07187 #ifndef TOLUA_RELEASE
07188  tolua_lerror:
07189  tolua_error(tolua_S,"#ferror in function 'set_light_bump_front_right'.",&tolua_err);
07190  return 0;
07191 #endif
07192 }
07193 #endif //#ifndef TOLUA_DISABLE
07194 
07195 /* method: maxlenof_light_bump_front_right of class  fawkes::Roomba500Interface */
07196 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_light_bump_front_right00
07197 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_light_bump_front_right00(lua_State* tolua_S)
07198 {
07199 #ifndef TOLUA_RELEASE
07200  tolua_Error tolua_err;
07201  if (
07202      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
07203      !tolua_isnoobj(tolua_S,2,&tolua_err)
07204  )
07205   goto tolua_lerror;
07206  else
07207 #endif
07208  {
07209   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
07210 #ifndef TOLUA_RELEASE
07211   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_light_bump_front_right'", NULL);
07212 #endif
07213   {
07214    int tolua_ret = (int)  self->maxlenof_light_bump_front_right();
07215    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
07216   }
07217  }
07218  return 1;
07219 #ifndef TOLUA_RELEASE
07220  tolua_lerror:
07221  tolua_error(tolua_S,"#ferror in function 'maxlenof_light_bump_front_right'.",&tolua_err);
07222  return 0;
07223 #endif
07224 }
07225 #endif //#ifndef TOLUA_DISABLE
07226 
07227 /* method: light_bump_right of class  fawkes::Roomba500Interface */
07228 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_light_bump_right00
07229 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_light_bump_right00(lua_State* tolua_S)
07230 {
07231 #ifndef TOLUA_RELEASE
07232  tolua_Error tolua_err;
07233  if (
07234      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
07235      !tolua_isnoobj(tolua_S,2,&tolua_err)
07236  )
07237   goto tolua_lerror;
07238  else
07239 #endif
07240  {
07241   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
07242 #ifndef TOLUA_RELEASE
07243   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'light_bump_right'", NULL);
07244 #endif
07245   {
07246    unsigned short tolua_ret = (unsigned short)  self->light_bump_right();
07247    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
07248   }
07249  }
07250  return 1;
07251 #ifndef TOLUA_RELEASE
07252  tolua_lerror:
07253  tolua_error(tolua_S,"#ferror in function 'light_bump_right'.",&tolua_err);
07254  return 0;
07255 #endif
07256 }
07257 #endif //#ifndef TOLUA_DISABLE
07258 
07259 /* method: set_light_bump_right of class  fawkes::Roomba500Interface */
07260 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_light_bump_right00
07261 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_light_bump_right00(lua_State* tolua_S)
07262 {
07263 #ifndef TOLUA_RELEASE
07264  tolua_Error tolua_err;
07265  if (
07266      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
07267      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
07268      !tolua_isnoobj(tolua_S,3,&tolua_err)
07269  )
07270   goto tolua_lerror;
07271  else
07272 #endif
07273  {
07274   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
07275   unsigned const short new_light_bump_right = ((unsigned const short)  tolua_tonumber(tolua_S,2,0));
07276 #ifndef TOLUA_RELEASE
07277   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_light_bump_right'", NULL);
07278 #endif
07279   {
07280    self->set_light_bump_right(new_light_bump_right);
07281   }
07282  }
07283  return 0;
07284 #ifndef TOLUA_RELEASE
07285  tolua_lerror:
07286  tolua_error(tolua_S,"#ferror in function 'set_light_bump_right'.",&tolua_err);
07287  return 0;
07288 #endif
07289 }
07290 #endif //#ifndef TOLUA_DISABLE
07291 
07292 /* method: maxlenof_light_bump_right of class  fawkes::Roomba500Interface */
07293 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_light_bump_right00
07294 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_light_bump_right00(lua_State* tolua_S)
07295 {
07296 #ifndef TOLUA_RELEASE
07297  tolua_Error tolua_err;
07298  if (
07299      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
07300      !tolua_isnoobj(tolua_S,2,&tolua_err)
07301  )
07302   goto tolua_lerror;
07303  else
07304 #endif
07305  {
07306   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
07307 #ifndef TOLUA_RELEASE
07308   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_light_bump_right'", NULL);
07309 #endif
07310   {
07311    int tolua_ret = (int)  self->maxlenof_light_bump_right();
07312    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
07313   }
07314  }
07315  return 1;
07316 #ifndef TOLUA_RELEASE
07317  tolua_lerror:
07318  tolua_error(tolua_S,"#ferror in function 'maxlenof_light_bump_right'.",&tolua_err);
07319  return 0;
07320 #endif
07321 }
07322 #endif //#ifndef TOLUA_DISABLE
07323 
07324 /* method: ir_opcode_left of class  fawkes::Roomba500Interface */
07325 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_ir_opcode_left00
07326 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_ir_opcode_left00(lua_State* tolua_S)
07327 {
07328 #ifndef TOLUA_RELEASE
07329  tolua_Error tolua_err;
07330  if (
07331      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
07332      !tolua_isnoobj(tolua_S,2,&tolua_err)
07333  )
07334   goto tolua_lerror;
07335  else
07336 #endif
07337  {
07338   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
07339 #ifndef TOLUA_RELEASE
07340   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ir_opcode_left'", NULL);
07341 #endif
07342   {
07343    fawkes::Roomba500Interface::InfraredCharacter tolua_ret = (fawkes::Roomba500Interface::InfraredCharacter)  self->ir_opcode_left();
07344    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
07345   }
07346  }
07347  return 1;
07348 #ifndef TOLUA_RELEASE
07349  tolua_lerror:
07350  tolua_error(tolua_S,"#ferror in function 'ir_opcode_left'.",&tolua_err);
07351  return 0;
07352 #endif
07353 }
07354 #endif //#ifndef TOLUA_DISABLE
07355 
07356 /* method: set_ir_opcode_left of class  fawkes::Roomba500Interface */
07357 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_ir_opcode_left00
07358 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_ir_opcode_left00(lua_State* tolua_S)
07359 {
07360 #ifndef TOLUA_RELEASE
07361  tolua_Error tolua_err;
07362  if (
07363      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
07364      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
07365      !tolua_isnoobj(tolua_S,3,&tolua_err)
07366  )
07367   goto tolua_lerror;
07368  else
07369 #endif
07370  {
07371   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
07372   const fawkes::Roomba500Interface::InfraredCharacter new_ir_opcode_left = ((const fawkes::Roomba500Interface::InfraredCharacter) (int)  tolua_tonumber(tolua_S,2,0));
07373 #ifndef TOLUA_RELEASE
07374   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_ir_opcode_left'", NULL);
07375 #endif
07376   {
07377    self->set_ir_opcode_left(new_ir_opcode_left);
07378   }
07379  }
07380  return 0;
07381 #ifndef TOLUA_RELEASE
07382  tolua_lerror:
07383  tolua_error(tolua_S,"#ferror in function 'set_ir_opcode_left'.",&tolua_err);
07384  return 0;
07385 #endif
07386 }
07387 #endif //#ifndef TOLUA_DISABLE
07388 
07389 /* method: maxlenof_ir_opcode_left of class  fawkes::Roomba500Interface */
07390 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_ir_opcode_left00
07391 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_ir_opcode_left00(lua_State* tolua_S)
07392 {
07393 #ifndef TOLUA_RELEASE
07394  tolua_Error tolua_err;
07395  if (
07396      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
07397      !tolua_isnoobj(tolua_S,2,&tolua_err)
07398  )
07399   goto tolua_lerror;
07400  else
07401 #endif
07402  {
07403   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
07404 #ifndef TOLUA_RELEASE
07405   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_ir_opcode_left'", NULL);
07406 #endif
07407   {
07408    int tolua_ret = (int)  self->maxlenof_ir_opcode_left();
07409    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
07410   }
07411  }
07412  return 1;
07413 #ifndef TOLUA_RELEASE
07414  tolua_lerror:
07415  tolua_error(tolua_S,"#ferror in function 'maxlenof_ir_opcode_left'.",&tolua_err);
07416  return 0;
07417 #endif
07418 }
07419 #endif //#ifndef TOLUA_DISABLE
07420 
07421 /* method: ir_opcode_right of class  fawkes::Roomba500Interface */
07422 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_ir_opcode_right00
07423 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_ir_opcode_right00(lua_State* tolua_S)
07424 {
07425 #ifndef TOLUA_RELEASE
07426  tolua_Error tolua_err;
07427  if (
07428      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
07429      !tolua_isnoobj(tolua_S,2,&tolua_err)
07430  )
07431   goto tolua_lerror;
07432  else
07433 #endif
07434  {
07435   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
07436 #ifndef TOLUA_RELEASE
07437   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ir_opcode_right'", NULL);
07438 #endif
07439   {
07440    fawkes::Roomba500Interface::InfraredCharacter tolua_ret = (fawkes::Roomba500Interface::InfraredCharacter)  self->ir_opcode_right();
07441    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
07442   }
07443  }
07444  return 1;
07445 #ifndef TOLUA_RELEASE
07446  tolua_lerror:
07447  tolua_error(tolua_S,"#ferror in function 'ir_opcode_right'.",&tolua_err);
07448  return 0;
07449 #endif
07450 }
07451 #endif //#ifndef TOLUA_DISABLE
07452 
07453 /* method: set_ir_opcode_right of class  fawkes::Roomba500Interface */
07454 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_ir_opcode_right00
07455 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_ir_opcode_right00(lua_State* tolua_S)
07456 {
07457 #ifndef TOLUA_RELEASE
07458  tolua_Error tolua_err;
07459  if (
07460      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
07461      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
07462      !tolua_isnoobj(tolua_S,3,&tolua_err)
07463  )
07464   goto tolua_lerror;
07465  else
07466 #endif
07467  {
07468   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
07469   const fawkes::Roomba500Interface::InfraredCharacter new_ir_opcode_right = ((const fawkes::Roomba500Interface::InfraredCharacter) (int)  tolua_tonumber(tolua_S,2,0));
07470 #ifndef TOLUA_RELEASE
07471   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_ir_opcode_right'", NULL);
07472 #endif
07473   {
07474    self->set_ir_opcode_right(new_ir_opcode_right);
07475   }
07476  }
07477  return 0;
07478 #ifndef TOLUA_RELEASE
07479  tolua_lerror:
07480  tolua_error(tolua_S,"#ferror in function 'set_ir_opcode_right'.",&tolua_err);
07481  return 0;
07482 #endif
07483 }
07484 #endif //#ifndef TOLUA_DISABLE
07485 
07486 /* method: maxlenof_ir_opcode_right of class  fawkes::Roomba500Interface */
07487 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_ir_opcode_right00
07488 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_ir_opcode_right00(lua_State* tolua_S)
07489 {
07490 #ifndef TOLUA_RELEASE
07491  tolua_Error tolua_err;
07492  if (
07493      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
07494      !tolua_isnoobj(tolua_S,2,&tolua_err)
07495  )
07496   goto tolua_lerror;
07497  else
07498 #endif
07499  {
07500   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
07501 #ifndef TOLUA_RELEASE
07502   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_ir_opcode_right'", NULL);
07503 #endif
07504   {
07505    int tolua_ret = (int)  self->maxlenof_ir_opcode_right();
07506    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
07507   }
07508  }
07509  return 1;
07510 #ifndef TOLUA_RELEASE
07511  tolua_lerror:
07512  tolua_error(tolua_S,"#ferror in function 'maxlenof_ir_opcode_right'.",&tolua_err);
07513  return 0;
07514 #endif
07515 }
07516 #endif //#ifndef TOLUA_DISABLE
07517 
07518 /* method: left_motor_current of class  fawkes::Roomba500Interface */
07519 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_left_motor_current00
07520 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_left_motor_current00(lua_State* tolua_S)
07521 {
07522 #ifndef TOLUA_RELEASE
07523  tolua_Error tolua_err;
07524  if (
07525      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
07526      !tolua_isnoobj(tolua_S,2,&tolua_err)
07527  )
07528   goto tolua_lerror;
07529  else
07530 #endif
07531  {
07532   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
07533 #ifndef TOLUA_RELEASE
07534   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'left_motor_current'", NULL);
07535 #endif
07536   {
07537    short tolua_ret = (short)  self->left_motor_current();
07538    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
07539   }
07540  }
07541  return 1;
07542 #ifndef TOLUA_RELEASE
07543  tolua_lerror:
07544  tolua_error(tolua_S,"#ferror in function 'left_motor_current'.",&tolua_err);
07545  return 0;
07546 #endif
07547 }
07548 #endif //#ifndef TOLUA_DISABLE
07549 
07550 /* method: set_left_motor_current of class  fawkes::Roomba500Interface */
07551 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_left_motor_current00
07552 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_left_motor_current00(lua_State* tolua_S)
07553 {
07554 #ifndef TOLUA_RELEASE
07555  tolua_Error tolua_err;
07556  if (
07557      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
07558      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
07559      !tolua_isnoobj(tolua_S,3,&tolua_err)
07560  )
07561   goto tolua_lerror;
07562  else
07563 #endif
07564  {
07565   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
07566   const short new_left_motor_current = ((const short)  tolua_tonumber(tolua_S,2,0));
07567 #ifndef TOLUA_RELEASE
07568   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_left_motor_current'", NULL);
07569 #endif
07570   {
07571    self->set_left_motor_current(new_left_motor_current);
07572   }
07573  }
07574  return 0;
07575 #ifndef TOLUA_RELEASE
07576  tolua_lerror:
07577  tolua_error(tolua_S,"#ferror in function 'set_left_motor_current'.",&tolua_err);
07578  return 0;
07579 #endif
07580 }
07581 #endif //#ifndef TOLUA_DISABLE
07582 
07583 /* method: maxlenof_left_motor_current of class  fawkes::Roomba500Interface */
07584 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_left_motor_current00
07585 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_left_motor_current00(lua_State* tolua_S)
07586 {
07587 #ifndef TOLUA_RELEASE
07588  tolua_Error tolua_err;
07589  if (
07590      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
07591      !tolua_isnoobj(tolua_S,2,&tolua_err)
07592  )
07593   goto tolua_lerror;
07594  else
07595 #endif
07596  {
07597   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
07598 #ifndef TOLUA_RELEASE
07599   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_left_motor_current'", NULL);
07600 #endif
07601   {
07602    int tolua_ret = (int)  self->maxlenof_left_motor_current();
07603    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
07604   }
07605  }
07606  return 1;
07607 #ifndef TOLUA_RELEASE
07608  tolua_lerror:
07609  tolua_error(tolua_S,"#ferror in function 'maxlenof_left_motor_current'.",&tolua_err);
07610  return 0;
07611 #endif
07612 }
07613 #endif //#ifndef TOLUA_DISABLE
07614 
07615 /* method: right_motor_current of class  fawkes::Roomba500Interface */
07616 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_right_motor_current00
07617 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_right_motor_current00(lua_State* tolua_S)
07618 {
07619 #ifndef TOLUA_RELEASE
07620  tolua_Error tolua_err;
07621  if (
07622      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
07623      !tolua_isnoobj(tolua_S,2,&tolua_err)
07624  )
07625   goto tolua_lerror;
07626  else
07627 #endif
07628  {
07629   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
07630 #ifndef TOLUA_RELEASE
07631   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'right_motor_current'", NULL);
07632 #endif
07633   {
07634    short tolua_ret = (short)  self->right_motor_current();
07635    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
07636   }
07637  }
07638  return 1;
07639 #ifndef TOLUA_RELEASE
07640  tolua_lerror:
07641  tolua_error(tolua_S,"#ferror in function 'right_motor_current'.",&tolua_err);
07642  return 0;
07643 #endif
07644 }
07645 #endif //#ifndef TOLUA_DISABLE
07646 
07647 /* method: set_right_motor_current of class  fawkes::Roomba500Interface */
07648 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_right_motor_current00
07649 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_right_motor_current00(lua_State* tolua_S)
07650 {
07651 #ifndef TOLUA_RELEASE
07652  tolua_Error tolua_err;
07653  if (
07654      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
07655      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
07656      !tolua_isnoobj(tolua_S,3,&tolua_err)
07657  )
07658   goto tolua_lerror;
07659  else
07660 #endif
07661  {
07662   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
07663   const short new_right_motor_current = ((const short)  tolua_tonumber(tolua_S,2,0));
07664 #ifndef TOLUA_RELEASE
07665   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_right_motor_current'", NULL);
07666 #endif
07667   {
07668    self->set_right_motor_current(new_right_motor_current);
07669   }
07670  }
07671  return 0;
07672 #ifndef TOLUA_RELEASE
07673  tolua_lerror:
07674  tolua_error(tolua_S,"#ferror in function 'set_right_motor_current'.",&tolua_err);
07675  return 0;
07676 #endif
07677 }
07678 #endif //#ifndef TOLUA_DISABLE
07679 
07680 /* method: maxlenof_right_motor_current of class  fawkes::Roomba500Interface */
07681 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_right_motor_current00
07682 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_right_motor_current00(lua_State* tolua_S)
07683 {
07684 #ifndef TOLUA_RELEASE
07685  tolua_Error tolua_err;
07686  if (
07687      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
07688      !tolua_isnoobj(tolua_S,2,&tolua_err)
07689  )
07690   goto tolua_lerror;
07691  else
07692 #endif
07693  {
07694   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
07695 #ifndef TOLUA_RELEASE
07696   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_right_motor_current'", NULL);
07697 #endif
07698   {
07699    int tolua_ret = (int)  self->maxlenof_right_motor_current();
07700    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
07701   }
07702  }
07703  return 1;
07704 #ifndef TOLUA_RELEASE
07705  tolua_lerror:
07706  tolua_error(tolua_S,"#ferror in function 'maxlenof_right_motor_current'.",&tolua_err);
07707  return 0;
07708 #endif
07709 }
07710 #endif //#ifndef TOLUA_DISABLE
07711 
07712 /* method: main_brush_current of class  fawkes::Roomba500Interface */
07713 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_main_brush_current00
07714 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_main_brush_current00(lua_State* tolua_S)
07715 {
07716 #ifndef TOLUA_RELEASE
07717  tolua_Error tolua_err;
07718  if (
07719      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
07720      !tolua_isnoobj(tolua_S,2,&tolua_err)
07721  )
07722   goto tolua_lerror;
07723  else
07724 #endif
07725  {
07726   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
07727 #ifndef TOLUA_RELEASE
07728   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'main_brush_current'", NULL);
07729 #endif
07730   {
07731    short tolua_ret = (short)  self->main_brush_current();
07732    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
07733   }
07734  }
07735  return 1;
07736 #ifndef TOLUA_RELEASE
07737  tolua_lerror:
07738  tolua_error(tolua_S,"#ferror in function 'main_brush_current'.",&tolua_err);
07739  return 0;
07740 #endif
07741 }
07742 #endif //#ifndef TOLUA_DISABLE
07743 
07744 /* method: set_main_brush_current of class  fawkes::Roomba500Interface */
07745 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_main_brush_current00
07746 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_main_brush_current00(lua_State* tolua_S)
07747 {
07748 #ifndef TOLUA_RELEASE
07749  tolua_Error tolua_err;
07750  if (
07751      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
07752      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
07753      !tolua_isnoobj(tolua_S,3,&tolua_err)
07754  )
07755   goto tolua_lerror;
07756  else
07757 #endif
07758  {
07759   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
07760   const short new_main_brush_current = ((const short)  tolua_tonumber(tolua_S,2,0));
07761 #ifndef TOLUA_RELEASE
07762   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_main_brush_current'", NULL);
07763 #endif
07764   {
07765    self->set_main_brush_current(new_main_brush_current);
07766   }
07767  }
07768  return 0;
07769 #ifndef TOLUA_RELEASE
07770  tolua_lerror:
07771  tolua_error(tolua_S,"#ferror in function 'set_main_brush_current'.",&tolua_err);
07772  return 0;
07773 #endif
07774 }
07775 #endif //#ifndef TOLUA_DISABLE
07776 
07777 /* method: maxlenof_main_brush_current of class  fawkes::Roomba500Interface */
07778 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_main_brush_current00
07779 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_main_brush_current00(lua_State* tolua_S)
07780 {
07781 #ifndef TOLUA_RELEASE
07782  tolua_Error tolua_err;
07783  if (
07784      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
07785      !tolua_isnoobj(tolua_S,2,&tolua_err)
07786  )
07787   goto tolua_lerror;
07788  else
07789 #endif
07790  {
07791   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
07792 #ifndef TOLUA_RELEASE
07793   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_main_brush_current'", NULL);
07794 #endif
07795   {
07796    int tolua_ret = (int)  self->maxlenof_main_brush_current();
07797    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
07798   }
07799  }
07800  return 1;
07801 #ifndef TOLUA_RELEASE
07802  tolua_lerror:
07803  tolua_error(tolua_S,"#ferror in function 'maxlenof_main_brush_current'.",&tolua_err);
07804  return 0;
07805 #endif
07806 }
07807 #endif //#ifndef TOLUA_DISABLE
07808 
07809 /* method: side_brush_current of class  fawkes::Roomba500Interface */
07810 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_side_brush_current00
07811 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_side_brush_current00(lua_State* tolua_S)
07812 {
07813 #ifndef TOLUA_RELEASE
07814  tolua_Error tolua_err;
07815  if (
07816      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
07817      !tolua_isnoobj(tolua_S,2,&tolua_err)
07818  )
07819   goto tolua_lerror;
07820  else
07821 #endif
07822  {
07823   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
07824 #ifndef TOLUA_RELEASE
07825   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'side_brush_current'", NULL);
07826 #endif
07827   {
07828    short tolua_ret = (short)  self->side_brush_current();
07829    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
07830   }
07831  }
07832  return 1;
07833 #ifndef TOLUA_RELEASE
07834  tolua_lerror:
07835  tolua_error(tolua_S,"#ferror in function 'side_brush_current'.",&tolua_err);
07836  return 0;
07837 #endif
07838 }
07839 #endif //#ifndef TOLUA_DISABLE
07840 
07841 /* method: set_side_brush_current of class  fawkes::Roomba500Interface */
07842 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_side_brush_current00
07843 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_side_brush_current00(lua_State* tolua_S)
07844 {
07845 #ifndef TOLUA_RELEASE
07846  tolua_Error tolua_err;
07847  if (
07848      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
07849      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
07850      !tolua_isnoobj(tolua_S,3,&tolua_err)
07851  )
07852   goto tolua_lerror;
07853  else
07854 #endif
07855  {
07856   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
07857   const short new_side_brush_current = ((const short)  tolua_tonumber(tolua_S,2,0));
07858 #ifndef TOLUA_RELEASE
07859   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_side_brush_current'", NULL);
07860 #endif
07861   {
07862    self->set_side_brush_current(new_side_brush_current);
07863   }
07864  }
07865  return 0;
07866 #ifndef TOLUA_RELEASE
07867  tolua_lerror:
07868  tolua_error(tolua_S,"#ferror in function 'set_side_brush_current'.",&tolua_err);
07869  return 0;
07870 #endif
07871 }
07872 #endif //#ifndef TOLUA_DISABLE
07873 
07874 /* method: maxlenof_side_brush_current of class  fawkes::Roomba500Interface */
07875 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_side_brush_current00
07876 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_side_brush_current00(lua_State* tolua_S)
07877 {
07878 #ifndef TOLUA_RELEASE
07879  tolua_Error tolua_err;
07880  if (
07881      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
07882      !tolua_isnoobj(tolua_S,2,&tolua_err)
07883  )
07884   goto tolua_lerror;
07885  else
07886 #endif
07887  {
07888   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
07889 #ifndef TOLUA_RELEASE
07890   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_side_brush_current'", NULL);
07891 #endif
07892   {
07893    int tolua_ret = (int)  self->maxlenof_side_brush_current();
07894    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
07895   }
07896  }
07897  return 1;
07898 #ifndef TOLUA_RELEASE
07899  tolua_lerror:
07900  tolua_error(tolua_S,"#ferror in function 'maxlenof_side_brush_current'.",&tolua_err);
07901  return 0;
07902 #endif
07903 }
07904 #endif //#ifndef TOLUA_DISABLE
07905 
07906 /* method: is_caster_stasis of class  fawkes::Roomba500Interface */
07907 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_caster_stasis00
07908 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_caster_stasis00(lua_State* tolua_S)
07909 {
07910 #ifndef TOLUA_RELEASE
07911  tolua_Error tolua_err;
07912  if (
07913      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
07914      !tolua_isnoobj(tolua_S,2,&tolua_err)
07915  )
07916   goto tolua_lerror;
07917  else
07918 #endif
07919  {
07920   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
07921 #ifndef TOLUA_RELEASE
07922   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_caster_stasis'", NULL);
07923 #endif
07924   {
07925    bool tolua_ret = (bool)  self->is_caster_stasis();
07926    tolua_pushboolean(tolua_S,(bool)tolua_ret);
07927   }
07928  }
07929  return 1;
07930 #ifndef TOLUA_RELEASE
07931  tolua_lerror:
07932  tolua_error(tolua_S,"#ferror in function 'is_caster_stasis'.",&tolua_err);
07933  return 0;
07934 #endif
07935 }
07936 #endif //#ifndef TOLUA_DISABLE
07937 
07938 /* method: set_caster_stasis of class  fawkes::Roomba500Interface */
07939 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_caster_stasis00
07940 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_caster_stasis00(lua_State* tolua_S)
07941 {
07942 #ifndef TOLUA_RELEASE
07943  tolua_Error tolua_err;
07944  if (
07945      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
07946      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
07947      !tolua_isnoobj(tolua_S,3,&tolua_err)
07948  )
07949   goto tolua_lerror;
07950  else
07951 #endif
07952  {
07953   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
07954   const bool new_caster_stasis = ((const bool)  tolua_toboolean(tolua_S,2,0));
07955 #ifndef TOLUA_RELEASE
07956   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_caster_stasis'", NULL);
07957 #endif
07958   {
07959    self->set_caster_stasis(new_caster_stasis);
07960   }
07961  }
07962  return 0;
07963 #ifndef TOLUA_RELEASE
07964  tolua_lerror:
07965  tolua_error(tolua_S,"#ferror in function 'set_caster_stasis'.",&tolua_err);
07966  return 0;
07967 #endif
07968 }
07969 #endif //#ifndef TOLUA_DISABLE
07970 
07971 /* method: maxlenof_caster_stasis of class  fawkes::Roomba500Interface */
07972 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_caster_stasis00
07973 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_caster_stasis00(lua_State* tolua_S)
07974 {
07975 #ifndef TOLUA_RELEASE
07976  tolua_Error tolua_err;
07977  if (
07978      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
07979      !tolua_isnoobj(tolua_S,2,&tolua_err)
07980  )
07981   goto tolua_lerror;
07982  else
07983 #endif
07984  {
07985   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
07986 #ifndef TOLUA_RELEASE
07987   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_caster_stasis'", NULL);
07988 #endif
07989   {
07990    int tolua_ret = (int)  self->maxlenof_caster_stasis();
07991    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
07992   }
07993  }
07994  return 1;
07995 #ifndef TOLUA_RELEASE
07996  tolua_lerror:
07997  tolua_error(tolua_S,"#ferror in function 'maxlenof_caster_stasis'.",&tolua_err);
07998  return 0;
07999 #endif
08000 }
08001 #endif //#ifndef TOLUA_DISABLE
08002 
08003 /* method: oftype of class  fawkes::Roomba500Interface */
08004 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_oftype00
08005 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_oftype00(lua_State* tolua_S)
08006 {
08007 #ifndef TOLUA_RELEASE
08008  tolua_Error tolua_err;
08009  if (
08010      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
08011      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
08012      !tolua_isnoobj(tolua_S,3,&tolua_err)
08013  )
08014   goto tolua_lerror;
08015  else
08016 #endif
08017  {
08018   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
08019   const char* interface_type = ((const char*)  tolua_tostring(tolua_S,2,0));
08020 #ifndef TOLUA_RELEASE
08021   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'oftype'", NULL);
08022 #endif
08023   {
08024    bool tolua_ret = (bool)  self->oftype(interface_type);
08025    tolua_pushboolean(tolua_S,(bool)tolua_ret);
08026   }
08027  }
08028  return 1;
08029 #ifndef TOLUA_RELEASE
08030  tolua_lerror:
08031  tolua_error(tolua_S,"#ferror in function 'oftype'.",&tolua_err);
08032  return 0;
08033 #endif
08034 }
08035 #endif //#ifndef TOLUA_DISABLE
08036 
08037 /* method: datachunk of class  fawkes::Roomba500Interface */
08038 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_datachunk00
08039 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_datachunk00(lua_State* tolua_S)
08040 {
08041 #ifndef TOLUA_RELEASE
08042  tolua_Error tolua_err;
08043  if (
08044      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
08045      !tolua_isnoobj(tolua_S,2,&tolua_err)
08046  )
08047   goto tolua_lerror;
08048  else
08049 #endif
08050  {
08051   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
08052 #ifndef TOLUA_RELEASE
08053   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datachunk'", NULL);
08054 #endif
08055   {
08056    const void* tolua_ret = (const void*)  self->datachunk();
08057    tolua_pushuserdata(tolua_S,(void*)tolua_ret);
08058   }
08059  }
08060  return 1;
08061 #ifndef TOLUA_RELEASE
08062  tolua_lerror:
08063  tolua_error(tolua_S,"#ferror in function 'datachunk'.",&tolua_err);
08064  return 0;
08065 #endif
08066 }
08067 #endif //#ifndef TOLUA_DISABLE
08068 
08069 /* method: datasize of class  fawkes::Roomba500Interface */
08070 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_datasize00
08071 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_datasize00(lua_State* tolua_S)
08072 {
08073 #ifndef TOLUA_RELEASE
08074  tolua_Error tolua_err;
08075  if (
08076      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
08077      !tolua_isnoobj(tolua_S,2,&tolua_err)
08078  )
08079   goto tolua_lerror;
08080  else
08081 #endif
08082  {
08083   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
08084 #ifndef TOLUA_RELEASE
08085   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datasize'", NULL);
08086 #endif
08087   {
08088    unsigned int tolua_ret = (unsigned int)  self->datasize();
08089    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
08090   }
08091  }
08092  return 1;
08093 #ifndef TOLUA_RELEASE
08094  tolua_lerror:
08095  tolua_error(tolua_S,"#ferror in function 'datasize'.",&tolua_err);
08096  return 0;
08097 #endif
08098 }
08099 #endif //#ifndef TOLUA_DISABLE
08100 
08101 /* method: type of class  fawkes::Roomba500Interface */
08102 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_type00
08103 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_type00(lua_State* tolua_S)
08104 {
08105 #ifndef TOLUA_RELEASE
08106  tolua_Error tolua_err;
08107  if (
08108      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
08109      !tolua_isnoobj(tolua_S,2,&tolua_err)
08110  )
08111   goto tolua_lerror;
08112  else
08113 #endif
08114  {
08115   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
08116 #ifndef TOLUA_RELEASE
08117   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'type'", NULL);
08118 #endif
08119   {
08120    const char* tolua_ret = (const char*)  self->type();
08121    tolua_pushstring(tolua_S,(const char*)tolua_ret);
08122   }
08123  }
08124  return 1;
08125 #ifndef TOLUA_RELEASE
08126  tolua_lerror:
08127  tolua_error(tolua_S,"#ferror in function 'type'.",&tolua_err);
08128  return 0;
08129 #endif
08130 }
08131 #endif //#ifndef TOLUA_DISABLE
08132 
08133 /* method: id of class  fawkes::Roomba500Interface */
08134 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_id00
08135 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_id00(lua_State* tolua_S)
08136 {
08137 #ifndef TOLUA_RELEASE
08138  tolua_Error tolua_err;
08139  if (
08140      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
08141      !tolua_isnoobj(tolua_S,2,&tolua_err)
08142  )
08143   goto tolua_lerror;
08144  else
08145 #endif
08146  {
08147   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
08148 #ifndef TOLUA_RELEASE
08149   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'id'", NULL);
08150 #endif
08151   {
08152    const char* tolua_ret = (const char*)  self->id();
08153    tolua_pushstring(tolua_S,(const char*)tolua_ret);
08154   }
08155  }
08156  return 1;
08157 #ifndef TOLUA_RELEASE
08158  tolua_lerror:
08159  tolua_error(tolua_S,"#ferror in function 'id'.",&tolua_err);
08160  return 0;
08161 #endif
08162 }
08163 #endif //#ifndef TOLUA_DISABLE
08164 
08165 /* method: uid of class  fawkes::Roomba500Interface */
08166 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_uid00
08167 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_uid00(lua_State* tolua_S)
08168 {
08169 #ifndef TOLUA_RELEASE
08170  tolua_Error tolua_err;
08171  if (
08172      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
08173      !tolua_isnoobj(tolua_S,2,&tolua_err)
08174  )
08175   goto tolua_lerror;
08176  else
08177 #endif
08178  {
08179   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
08180 #ifndef TOLUA_RELEASE
08181   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'uid'", NULL);
08182 #endif
08183   {
08184    const char* tolua_ret = (const char*)  self->uid();
08185    tolua_pushstring(tolua_S,(const char*)tolua_ret);
08186   }
08187  }
08188  return 1;
08189 #ifndef TOLUA_RELEASE
08190  tolua_lerror:
08191  tolua_error(tolua_S,"#ferror in function 'uid'.",&tolua_err);
08192  return 0;
08193 #endif
08194 }
08195 #endif //#ifndef TOLUA_DISABLE
08196 
08197 /* method: serial of class  fawkes::Roomba500Interface */
08198 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_serial00
08199 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_serial00(lua_State* tolua_S)
08200 {
08201 #ifndef TOLUA_RELEASE
08202  tolua_Error tolua_err;
08203  if (
08204      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
08205      !tolua_isnoobj(tolua_S,2,&tolua_err)
08206  )
08207   goto tolua_lerror;
08208  else
08209 #endif
08210  {
08211   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
08212 #ifndef TOLUA_RELEASE
08213   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'serial'", NULL);
08214 #endif
08215   {
08216    unsigned int tolua_ret = (unsigned int)  self->serial();
08217    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
08218   }
08219  }
08220  return 1;
08221 #ifndef TOLUA_RELEASE
08222  tolua_lerror:
08223  tolua_error(tolua_S,"#ferror in function 'serial'.",&tolua_err);
08224  return 0;
08225 #endif
08226 }
08227 #endif //#ifndef TOLUA_DISABLE
08228 
08229 /* method: mem_serial of class  fawkes::Roomba500Interface */
08230 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_mem_serial00
08231 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_mem_serial00(lua_State* tolua_S)
08232 {
08233 #ifndef TOLUA_RELEASE
08234  tolua_Error tolua_err;
08235  if (
08236      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
08237      !tolua_isnoobj(tolua_S,2,&tolua_err)
08238  )
08239   goto tolua_lerror;
08240  else
08241 #endif
08242  {
08243   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
08244 #ifndef TOLUA_RELEASE
08245   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'mem_serial'", NULL);
08246 #endif
08247   {
08248    unsigned int tolua_ret = (unsigned int)  self->mem_serial();
08249    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
08250   }
08251  }
08252  return 1;
08253 #ifndef TOLUA_RELEASE
08254  tolua_lerror:
08255  tolua_error(tolua_S,"#ferror in function 'mem_serial'.",&tolua_err);
08256  return 0;
08257 #endif
08258 }
08259 #endif //#ifndef TOLUA_DISABLE
08260 
08261 /* method: operator== of class  fawkes::Roomba500Interface */
08262 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface__eq00
08263 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface__eq00(lua_State* tolua_S)
08264 {
08265 #ifndef TOLUA_RELEASE
08266  tolua_Error tolua_err;
08267  if (
08268      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
08269      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Interface",0,&tolua_err)) ||
08270      !tolua_isnoobj(tolua_S,3,&tolua_err)
08271  )
08272   goto tolua_lerror;
08273  else
08274 #endif
08275  {
08276   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
08277   Interface* comp = ((Interface*)  tolua_tousertype(tolua_S,2,0));
08278 #ifndef TOLUA_RELEASE
08279   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='", NULL);
08280 #endif
08281   {
08282    bool tolua_ret = (bool)  self->operator==(*comp);
08283    tolua_pushboolean(tolua_S,(bool)tolua_ret);
08284   }
08285  }
08286  return 1;
08287 #ifndef TOLUA_RELEASE
08288  tolua_lerror:
08289  tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err);
08290  return 0;
08291 #endif
08292 }
08293 #endif //#ifndef TOLUA_DISABLE
08294 
08295 /* method: hash of class  fawkes::Roomba500Interface */
08296 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_hash00
08297 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_hash00(lua_State* tolua_S)
08298 {
08299 #ifndef TOLUA_RELEASE
08300  tolua_Error tolua_err;
08301  if (
08302      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
08303      !tolua_isnoobj(tolua_S,2,&tolua_err)
08304  )
08305   goto tolua_lerror;
08306  else
08307 #endif
08308  {
08309   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
08310 #ifndef TOLUA_RELEASE
08311   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash'", NULL);
08312 #endif
08313   {
08314    unsigned const char* tolua_ret = ( unsigned const char*)  self->hash();
08315    tolua_pushstring(tolua_S,(const char*)tolua_ret);
08316   }
08317  }
08318  return 1;
08319 #ifndef TOLUA_RELEASE
08320  tolua_lerror:
08321  tolua_error(tolua_S,"#ferror in function 'hash'.",&tolua_err);
08322  return 0;
08323 #endif
08324 }
08325 #endif //#ifndef TOLUA_DISABLE
08326 
08327 /* method: hash_size of class  fawkes::Roomba500Interface */
08328 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_hash_size00
08329 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_hash_size00(lua_State* tolua_S)
08330 {
08331 #ifndef TOLUA_RELEASE
08332  tolua_Error tolua_err;
08333  if (
08334      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
08335      !tolua_isnoobj(tolua_S,2,&tolua_err)
08336  )
08337   goto tolua_lerror;
08338  else
08339 #endif
08340  {
08341   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
08342 #ifndef TOLUA_RELEASE
08343   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash_size'", NULL);
08344 #endif
08345   {
08346    int tolua_ret = (int)  self->hash_size();
08347    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
08348   }
08349  }
08350  return 1;
08351 #ifndef TOLUA_RELEASE
08352  tolua_lerror:
08353  tolua_error(tolua_S,"#ferror in function 'hash_size'.",&tolua_err);
08354  return 0;
08355 #endif
08356 }
08357 #endif //#ifndef TOLUA_DISABLE
08358 
08359 /* method: hash_printable of class  fawkes::Roomba500Interface */
08360 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_hash_printable00
08361 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_hash_printable00(lua_State* tolua_S)
08362 {
08363 #ifndef TOLUA_RELEASE
08364  tolua_Error tolua_err;
08365  if (
08366      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
08367      !tolua_isnoobj(tolua_S,2,&tolua_err)
08368  )
08369   goto tolua_lerror;
08370  else
08371 #endif
08372  {
08373   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
08374 #ifndef TOLUA_RELEASE
08375   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash_printable'", NULL);
08376 #endif
08377   {
08378    const char* tolua_ret = (const char*)  self->hash_printable();
08379    tolua_pushstring(tolua_S,(const char*)tolua_ret);
08380   }
08381  }
08382  return 1;
08383 #ifndef TOLUA_RELEASE
08384  tolua_lerror:
08385  tolua_error(tolua_S,"#ferror in function 'hash_printable'.",&tolua_err);
08386  return 0;
08387 #endif
08388 }
08389 #endif //#ifndef TOLUA_DISABLE
08390 
08391 /* method: is_writer of class  fawkes::Roomba500Interface */
08392 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_writer00
08393 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_writer00(lua_State* tolua_S)
08394 {
08395 #ifndef TOLUA_RELEASE
08396  tolua_Error tolua_err;
08397  if (
08398      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
08399      !tolua_isnoobj(tolua_S,2,&tolua_err)
08400  )
08401   goto tolua_lerror;
08402  else
08403 #endif
08404  {
08405   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
08406 #ifndef TOLUA_RELEASE
08407   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_writer'", NULL);
08408 #endif
08409   {
08410    bool tolua_ret = (bool)  self->is_writer();
08411    tolua_pushboolean(tolua_S,(bool)tolua_ret);
08412   }
08413  }
08414  return 1;
08415 #ifndef TOLUA_RELEASE
08416  tolua_lerror:
08417  tolua_error(tolua_S,"#ferror in function 'is_writer'.",&tolua_err);
08418  return 0;
08419 #endif
08420 }
08421 #endif //#ifndef TOLUA_DISABLE
08422 
08423 /* method: set_from_chunk of class  fawkes::Roomba500Interface */
08424 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_from_chunk00
08425 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_from_chunk00(lua_State* tolua_S)
08426 {
08427 #ifndef TOLUA_RELEASE
08428  tolua_Error tolua_err;
08429  if (
08430      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
08431      !tolua_isuserdata(tolua_S,2,0,&tolua_err) ||
08432      !tolua_isnoobj(tolua_S,3,&tolua_err)
08433  )
08434   goto tolua_lerror;
08435  else
08436 #endif
08437  {
08438   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
08439   void* chunk = ((void*)  tolua_touserdata(tolua_S,2,0));
08440 #ifndef TOLUA_RELEASE
08441   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_from_chunk'", NULL);
08442 #endif
08443   {
08444    self->set_from_chunk(chunk);
08445   }
08446  }
08447  return 0;
08448 #ifndef TOLUA_RELEASE
08449  tolua_lerror:
08450  tolua_error(tolua_S,"#ferror in function 'set_from_chunk'.",&tolua_err);
08451  return 0;
08452 #endif
08453 }
08454 #endif //#ifndef TOLUA_DISABLE
08455 
08456 /* method: create_message of class  fawkes::Roomba500Interface */
08457 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_create_message00
08458 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_create_message00(lua_State* tolua_S)
08459 {
08460 #ifndef TOLUA_RELEASE
08461  tolua_Error tolua_err;
08462  if (
08463      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
08464      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
08465      !tolua_isnoobj(tolua_S,3,&tolua_err)
08466  )
08467   goto tolua_lerror;
08468  else
08469 #endif
08470  {
08471   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
08472   const char* type = ((const char*)  tolua_tostring(tolua_S,2,0));
08473 #ifndef TOLUA_RELEASE
08474   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'create_message'", NULL);
08475 #endif
08476   {
08477    Message* tolua_ret = (Message*)  self->create_message(type);
08478     tolua_pushusertype(tolua_S,(void*)tolua_ret,"Message");
08479   }
08480  }
08481  return 1;
08482 #ifndef TOLUA_RELEASE
08483  tolua_lerror:
08484  tolua_error(tolua_S,"#ferror in function 'create_message'.",&tolua_err);
08485  return 0;
08486 #endif
08487 }
08488 #endif //#ifndef TOLUA_DISABLE
08489 
08490 /* method: read of class  fawkes::Roomba500Interface */
08491 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_read00
08492 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_read00(lua_State* tolua_S)
08493 {
08494 #ifndef TOLUA_RELEASE
08495  tolua_Error tolua_err;
08496  if (
08497      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
08498      !tolua_isnoobj(tolua_S,2,&tolua_err)
08499  )
08500   goto tolua_lerror;
08501  else
08502 #endif
08503  {
08504   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
08505 #ifndef TOLUA_RELEASE
08506   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'read'", NULL);
08507 #endif
08508   {
08509    self->read();
08510   }
08511  }
08512  return 0;
08513 #ifndef TOLUA_RELEASE
08514  tolua_lerror:
08515  tolua_error(tolua_S,"#ferror in function 'read'.",&tolua_err);
08516  return 0;
08517 #endif
08518 }
08519 #endif //#ifndef TOLUA_DISABLE
08520 
08521 /* method: write of class  fawkes::Roomba500Interface */
08522 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_write00
08523 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_write00(lua_State* tolua_S)
08524 {
08525 #ifndef TOLUA_RELEASE
08526  tolua_Error tolua_err;
08527  if (
08528      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
08529      !tolua_isnoobj(tolua_S,2,&tolua_err)
08530  )
08531   goto tolua_lerror;
08532  else
08533 #endif
08534  {
08535   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
08536 #ifndef TOLUA_RELEASE
08537   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'write'", NULL);
08538 #endif
08539   {
08540    self->write();
08541   }
08542  }
08543  return 0;
08544 #ifndef TOLUA_RELEASE
08545  tolua_lerror:
08546  tolua_error(tolua_S,"#ferror in function 'write'.",&tolua_err);
08547  return 0;
08548 #endif
08549 }
08550 #endif //#ifndef TOLUA_DISABLE
08551 
08552 /* method: has_writer of class  fawkes::Roomba500Interface */
08553 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_has_writer00
08554 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_has_writer00(lua_State* tolua_S)
08555 {
08556 #ifndef TOLUA_RELEASE
08557  tolua_Error tolua_err;
08558  if (
08559      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
08560      !tolua_isnoobj(tolua_S,2,&tolua_err)
08561  )
08562   goto tolua_lerror;
08563  else
08564 #endif
08565  {
08566   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
08567 #ifndef TOLUA_RELEASE
08568   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'has_writer'", NULL);
08569 #endif
08570   {
08571    bool tolua_ret = (bool)  self->has_writer();
08572    tolua_pushboolean(tolua_S,(bool)tolua_ret);
08573   }
08574  }
08575  return 1;
08576 #ifndef TOLUA_RELEASE
08577  tolua_lerror:
08578  tolua_error(tolua_S,"#ferror in function 'has_writer'.",&tolua_err);
08579  return 0;
08580 #endif
08581 }
08582 #endif //#ifndef TOLUA_DISABLE
08583 
08584 /* method: num_readers of class  fawkes::Roomba500Interface */
08585 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_num_readers00
08586 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_num_readers00(lua_State* tolua_S)
08587 {
08588 #ifndef TOLUA_RELEASE
08589  tolua_Error tolua_err;
08590  if (
08591      !tolua_isusertype(tolua_S,1,"const fawkes::Roomba500Interface",0,&tolua_err) ||
08592      !tolua_isnoobj(tolua_S,2,&tolua_err)
08593  )
08594   goto tolua_lerror;
08595  else
08596 #endif
08597  {
08598   const fawkes::Roomba500Interface* self = (const fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
08599 #ifndef TOLUA_RELEASE
08600   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'num_readers'", NULL);
08601 #endif
08602   {
08603    unsigned int tolua_ret = (unsigned int)  self->num_readers();
08604    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
08605   }
08606  }
08607  return 1;
08608 #ifndef TOLUA_RELEASE
08609  tolua_lerror:
08610  tolua_error(tolua_S,"#ferror in function 'num_readers'.",&tolua_err);
08611  return 0;
08612 #endif
08613 }
08614 #endif //#ifndef TOLUA_DISABLE
08615 
08616 /* method: msgq_enqueue_copy of class  fawkes::Roomba500Interface */
08617 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_msgq_enqueue_copy00
08618 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_msgq_enqueue_copy00(lua_State* tolua_S)
08619 {
08620 #ifndef TOLUA_RELEASE
08621  tolua_Error tolua_err;
08622  if (
08623      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
08624      !tolua_isusertype(tolua_S,2,"Message",0,&tolua_err) ||
08625      !tolua_isnoobj(tolua_S,3,&tolua_err)
08626  )
08627   goto tolua_lerror;
08628  else
08629 #endif
08630  {
08631   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
08632   Message* message = ((Message*)  tolua_tousertype(tolua_S,2,0));
08633 #ifndef TOLUA_RELEASE
08634   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_enqueue_copy'", NULL);
08635 #endif
08636   {
08637    unsigned int tolua_ret = (unsigned int)  self->msgq_enqueue_copy(message);
08638    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
08639   }
08640  }
08641  return 1;
08642 #ifndef TOLUA_RELEASE
08643  tolua_lerror:
08644  tolua_error(tolua_S,"#ferror in function 'msgq_enqueue_copy'.",&tolua_err);
08645  return 0;
08646 #endif
08647 }
08648 #endif //#ifndef TOLUA_DISABLE
08649 
08650 /* method: msgq_remove of class  fawkes::Roomba500Interface */
08651 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_msgq_remove00
08652 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_msgq_remove00(lua_State* tolua_S)
08653 {
08654 #ifndef TOLUA_RELEASE
08655  tolua_Error tolua_err;
08656  if (
08657      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
08658      !tolua_isusertype(tolua_S,2,"Message",0,&tolua_err) ||
08659      !tolua_isnoobj(tolua_S,3,&tolua_err)
08660  )
08661   goto tolua_lerror;
08662  else
08663 #endif
08664  {
08665   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
08666   Message* message = ((Message*)  tolua_tousertype(tolua_S,2,0));
08667 #ifndef TOLUA_RELEASE
08668   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_remove'", NULL);
08669 #endif
08670   {
08671    self->msgq_remove(message);
08672   }
08673  }
08674  return 0;
08675 #ifndef TOLUA_RELEASE
08676  tolua_lerror:
08677  tolua_error(tolua_S,"#ferror in function 'msgq_remove'.",&tolua_err);
08678  return 0;
08679 #endif
08680 }
08681 #endif //#ifndef TOLUA_DISABLE
08682 
08683 /* method: msgq_remove of class  fawkes::Roomba500Interface */
08684 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_msgq_remove01
08685 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_msgq_remove01(lua_State* tolua_S)
08686 {
08687  tolua_Error tolua_err;
08688  if (
08689      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
08690      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
08691      !tolua_isnoobj(tolua_S,3,&tolua_err)
08692  )
08693   goto tolua_lerror;
08694  else
08695  {
08696   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
08697   unsigned int message_id = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
08698 #ifndef TOLUA_RELEASE
08699   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_remove'", NULL);
08700 #endif
08701   {
08702    self->msgq_remove(message_id);
08703   }
08704  }
08705  return 0;
08706 tolua_lerror:
08707  return tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_msgq_remove00(tolua_S);
08708 }
08709 #endif //#ifndef TOLUA_DISABLE
08710 
08711 /* method: msgq_size of class  fawkes::Roomba500Interface */
08712 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_msgq_size00
08713 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_msgq_size00(lua_State* tolua_S)
08714 {
08715 #ifndef TOLUA_RELEASE
08716  tolua_Error tolua_err;
08717  if (
08718      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
08719      !tolua_isnoobj(tolua_S,2,&tolua_err)
08720  )
08721   goto tolua_lerror;
08722  else
08723 #endif
08724  {
08725   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
08726 #ifndef TOLUA_RELEASE
08727   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_size'", NULL);
08728 #endif
08729   {
08730    unsigned int tolua_ret = (unsigned int)  self->msgq_size();
08731    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
08732   }
08733  }
08734  return 1;
08735 #ifndef TOLUA_RELEASE
08736  tolua_lerror:
08737  tolua_error(tolua_S,"#ferror in function 'msgq_size'.",&tolua_err);
08738  return 0;
08739 #endif
08740 }
08741 #endif //#ifndef TOLUA_DISABLE
08742 
08743 /* method: msgq_flush of class  fawkes::Roomba500Interface */
08744 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_msgq_flush00
08745 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_msgq_flush00(lua_State* tolua_S)
08746 {
08747 #ifndef TOLUA_RELEASE
08748  tolua_Error tolua_err;
08749  if (
08750      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
08751      !tolua_isnoobj(tolua_S,2,&tolua_err)
08752  )
08753   goto tolua_lerror;
08754  else
08755 #endif
08756  {
08757   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
08758 #ifndef TOLUA_RELEASE
08759   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_flush'", NULL);
08760 #endif
08761   {
08762    self->msgq_flush();
08763   }
08764  }
08765  return 0;
08766 #ifndef TOLUA_RELEASE
08767  tolua_lerror:
08768  tolua_error(tolua_S,"#ferror in function 'msgq_flush'.",&tolua_err);
08769  return 0;
08770 #endif
08771 }
08772 #endif //#ifndef TOLUA_DISABLE
08773 
08774 /* method: msgq_lock of class  fawkes::Roomba500Interface */
08775 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_msgq_lock00
08776 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_msgq_lock00(lua_State* tolua_S)
08777 {
08778 #ifndef TOLUA_RELEASE
08779  tolua_Error tolua_err;
08780  if (
08781      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
08782      !tolua_isnoobj(tolua_S,2,&tolua_err)
08783  )
08784   goto tolua_lerror;
08785  else
08786 #endif
08787  {
08788   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
08789 #ifndef TOLUA_RELEASE
08790   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_lock'", NULL);
08791 #endif
08792   {
08793    self->msgq_lock();
08794   }
08795  }
08796  return 0;
08797 #ifndef TOLUA_RELEASE
08798  tolua_lerror:
08799  tolua_error(tolua_S,"#ferror in function 'msgq_lock'.",&tolua_err);
08800  return 0;
08801 #endif
08802 }
08803 #endif //#ifndef TOLUA_DISABLE
08804 
08805 /* method: msgq_try_lock of class  fawkes::Roomba500Interface */
08806 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_msgq_try_lock00
08807 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_msgq_try_lock00(lua_State* tolua_S)
08808 {
08809 #ifndef TOLUA_RELEASE
08810  tolua_Error tolua_err;
08811  if (
08812      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
08813      !tolua_isnoobj(tolua_S,2,&tolua_err)
08814  )
08815   goto tolua_lerror;
08816  else
08817 #endif
08818  {
08819   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
08820 #ifndef TOLUA_RELEASE
08821   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_try_lock'", NULL);
08822 #endif
08823   {
08824    bool tolua_ret = (bool)  self->msgq_try_lock();
08825    tolua_pushboolean(tolua_S,(bool)tolua_ret);
08826   }
08827  }
08828  return 1;
08829 #ifndef TOLUA_RELEASE
08830  tolua_lerror:
08831  tolua_error(tolua_S,"#ferror in function 'msgq_try_lock'.",&tolua_err);
08832  return 0;
08833 #endif
08834 }
08835 #endif //#ifndef TOLUA_DISABLE
08836 
08837 /* method: msgq_unlock of class  fawkes::Roomba500Interface */
08838 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_msgq_unlock00
08839 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_msgq_unlock00(lua_State* tolua_S)
08840 {
08841 #ifndef TOLUA_RELEASE
08842  tolua_Error tolua_err;
08843  if (
08844      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
08845      !tolua_isnoobj(tolua_S,2,&tolua_err)
08846  )
08847   goto tolua_lerror;
08848  else
08849 #endif
08850  {
08851   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
08852 #ifndef TOLUA_RELEASE
08853   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_unlock'", NULL);
08854 #endif
08855   {
08856    self->msgq_unlock();
08857   }
08858  }
08859  return 0;
08860 #ifndef TOLUA_RELEASE
08861  tolua_lerror:
08862  tolua_error(tolua_S,"#ferror in function 'msgq_unlock'.",&tolua_err);
08863  return 0;
08864 #endif
08865 }
08866 #endif //#ifndef TOLUA_DISABLE
08867 
08868 /* method: msgq_pop of class  fawkes::Roomba500Interface */
08869 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_msgq_pop00
08870 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_msgq_pop00(lua_State* tolua_S)
08871 {
08872 #ifndef TOLUA_RELEASE
08873  tolua_Error tolua_err;
08874  if (
08875      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
08876      !tolua_isnoobj(tolua_S,2,&tolua_err)
08877  )
08878   goto tolua_lerror;
08879  else
08880 #endif
08881  {
08882   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
08883 #ifndef TOLUA_RELEASE
08884   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_pop'", NULL);
08885 #endif
08886   {
08887    self->msgq_pop();
08888   }
08889  }
08890  return 0;
08891 #ifndef TOLUA_RELEASE
08892  tolua_lerror:
08893  tolua_error(tolua_S,"#ferror in function 'msgq_pop'.",&tolua_err);
08894  return 0;
08895 #endif
08896 }
08897 #endif //#ifndef TOLUA_DISABLE
08898 
08899 /* method: msgq_first of class  fawkes::Roomba500Interface */
08900 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_msgq_first00
08901 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_msgq_first00(lua_State* tolua_S)
08902 {
08903 #ifndef TOLUA_RELEASE
08904  tolua_Error tolua_err;
08905  if (
08906      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
08907      !tolua_isnoobj(tolua_S,2,&tolua_err)
08908  )
08909   goto tolua_lerror;
08910  else
08911 #endif
08912  {
08913   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
08914 #ifndef TOLUA_RELEASE
08915   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_first'", NULL);
08916 #endif
08917   {
08918    Message* tolua_ret = (Message*)  self->msgq_first();
08919     tolua_pushusertype(tolua_S,(void*)tolua_ret,"Message");
08920   }
08921  }
08922  return 1;
08923 #ifndef TOLUA_RELEASE
08924  tolua_lerror:
08925  tolua_error(tolua_S,"#ferror in function 'msgq_first'.",&tolua_err);
08926  return 0;
08927 #endif
08928 }
08929 #endif //#ifndef TOLUA_DISABLE
08930 
08931 /* method: msgq_empty of class  fawkes::Roomba500Interface */
08932 #ifndef TOLUA_DISABLE_tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_msgq_empty00
08933 static int tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_msgq_empty00(lua_State* tolua_S)
08934 {
08935 #ifndef TOLUA_RELEASE
08936  tolua_Error tolua_err;
08937  if (
08938      !tolua_isusertype(tolua_S,1,"fawkes::Roomba500Interface",0,&tolua_err) ||
08939      !tolua_isnoobj(tolua_S,2,&tolua_err)
08940  )
08941   goto tolua_lerror;
08942  else
08943 #endif
08944  {
08945   fawkes::Roomba500Interface* self = (fawkes::Roomba500Interface*)  tolua_tousertype(tolua_S,1,0);
08946 #ifndef TOLUA_RELEASE
08947   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_empty'", NULL);
08948 #endif
08949   {
08950    bool tolua_ret = (bool)  self->msgq_empty();
08951    tolua_pushboolean(tolua_S,(bool)tolua_ret);
08952   }
08953  }
08954  return 1;
08955 #ifndef TOLUA_RELEASE
08956  tolua_lerror:
08957  tolua_error(tolua_S,"#ferror in function 'msgq_empty'.",&tolua_err);
08958  return 0;
08959 #endif
08960 }
08961 #endif //#ifndef TOLUA_DISABLE
08962 
08963 /* Open function */
08964 TOLUA_API int tolua_interfaces_Roomba500Interface_open (lua_State* tolua_S)
08965 {
08966  tolua_open(tolua_S);
08967  tolua_reg_types(tolua_S);
08968  tolua_module(tolua_S,NULL,0);
08969  tolua_beginmodule(tolua_S,NULL);
08970   tolua_module(tolua_S,"fawkes",0);
08971   tolua_beginmodule(tolua_S,"fawkes");
08972    tolua_cclass(tolua_S,"Roomba500Interface","fawkes::Roomba500Interface","Interface",NULL);
08973    tolua_beginmodule(tolua_S,"Roomba500Interface");
08974     tolua_constant(tolua_S,"MODE_OFF",fawkes::Roomba500Interface::MODE_OFF);
08975     tolua_constant(tolua_S,"MODE_PASSIVE",fawkes::Roomba500Interface::MODE_PASSIVE);
08976     tolua_constant(tolua_S,"MODE_SAFE",fawkes::Roomba500Interface::MODE_SAFE);
08977     tolua_constant(tolua_S,"MODE_FULL",fawkes::Roomba500Interface::MODE_FULL);
08978     tolua_constant(tolua_S,"IR_NONE",fawkes::Roomba500Interface::IR_NONE);
08979     tolua_constant(tolua_S,"IR_REMOTE_LEFT",fawkes::Roomba500Interface::IR_REMOTE_LEFT);
08980     tolua_constant(tolua_S,"IR_REMOTE_FORWARD",fawkes::Roomba500Interface::IR_REMOTE_FORWARD);
08981     tolua_constant(tolua_S,"IR_REMOTE_RIGHT",fawkes::Roomba500Interface::IR_REMOTE_RIGHT);
08982     tolua_constant(tolua_S,"IR_REMOTE_SPOT",fawkes::Roomba500Interface::IR_REMOTE_SPOT);
08983     tolua_constant(tolua_S,"IR_REMOTE_MAX",fawkes::Roomba500Interface::IR_REMOTE_MAX);
08984     tolua_constant(tolua_S,"IR_REMOTE_SMALL",fawkes::Roomba500Interface::IR_REMOTE_SMALL);
08985     tolua_constant(tolua_S,"IR_REMOTE_MEDIUM",fawkes::Roomba500Interface::IR_REMOTE_MEDIUM);
08986     tolua_constant(tolua_S,"IR_REMOTE_LARGE_CLEAN",fawkes::Roomba500Interface::IR_REMOTE_LARGE_CLEAN);
08987     tolua_constant(tolua_S,"IR_REMOTE_STOP",fawkes::Roomba500Interface::IR_REMOTE_STOP);
08988     tolua_constant(tolua_S,"IR_REMOTE_POWER",fawkes::Roomba500Interface::IR_REMOTE_POWER);
08989     tolua_constant(tolua_S,"IR_REMOTE_ARC_LEFT",fawkes::Roomba500Interface::IR_REMOTE_ARC_LEFT);
08990     tolua_constant(tolua_S,"IR_REMOTE_ARC_RIGHT",fawkes::Roomba500Interface::IR_REMOTE_ARC_RIGHT);
08991     tolua_constant(tolua_S,"IR_REMOTE_STOP2",fawkes::Roomba500Interface::IR_REMOTE_STOP2);
08992     tolua_constant(tolua_S,"IR_SCHED_REMOTE_DOWNLOAD",fawkes::Roomba500Interface::IR_SCHED_REMOTE_DOWNLOAD);
08993     tolua_constant(tolua_S,"IR_SCHED_REMOTE_SEEK_DOCK",fawkes::Roomba500Interface::IR_SCHED_REMOTE_SEEK_DOCK);
08994     tolua_constant(tolua_S,"IR_DISC_DOCK_RESERVED",fawkes::Roomba500Interface::IR_DISC_DOCK_RESERVED);
08995     tolua_constant(tolua_S,"IR_DISC_DOCK_RED_BUOY",fawkes::Roomba500Interface::IR_DISC_DOCK_RED_BUOY);
08996     tolua_constant(tolua_S,"IR_DISC_DOCK_GREEN_BUOY",fawkes::Roomba500Interface::IR_DISC_DOCK_GREEN_BUOY);
08997     tolua_constant(tolua_S,"IR_DISC_DOCK_FORCE_FIELD",fawkes::Roomba500Interface::IR_DISC_DOCK_FORCE_FIELD);
08998     tolua_constant(tolua_S,"IR_DISC_DOCK_RED_GREEN_BUOY",fawkes::Roomba500Interface::IR_DISC_DOCK_RED_GREEN_BUOY);
08999     tolua_constant(tolua_S,"IR_DISC_DOCK_RED_BUOY_FORCE_FIELD",fawkes::Roomba500Interface::IR_DISC_DOCK_RED_BUOY_FORCE_FIELD);
09000     tolua_constant(tolua_S,"IR_DISC_DOCK_GREEN_BUOY_FORCE_FIELD",fawkes::Roomba500Interface::IR_DISC_DOCK_GREEN_BUOY_FORCE_FIELD);
09001     tolua_constant(tolua_S,"IR_DISC_DOCK_RED_GREEN_BUOY_FORCE_FIELD",fawkes::Roomba500Interface::IR_DISC_DOCK_RED_GREEN_BUOY_FORCE_FIELD);
09002     tolua_constant(tolua_S,"IR_DOCK_RESERVED",fawkes::Roomba500Interface::IR_DOCK_RESERVED);
09003     tolua_constant(tolua_S,"IR_DOCK_RED_BUOY",fawkes::Roomba500Interface::IR_DOCK_RED_BUOY);
09004     tolua_constant(tolua_S,"IR_DOCK_GREEN_BUOY",fawkes::Roomba500Interface::IR_DOCK_GREEN_BUOY);
09005     tolua_constant(tolua_S,"IR_DOCK_FORCE_FIELD",fawkes::Roomba500Interface::IR_DOCK_FORCE_FIELD);
09006     tolua_constant(tolua_S,"IR_DOCK_RED_GREEN_BUOY",fawkes::Roomba500Interface::IR_DOCK_RED_GREEN_BUOY);
09007     tolua_constant(tolua_S,"IR_DOCK_RED_BUOY_FORCE_FIELD",fawkes::Roomba500Interface::IR_DOCK_RED_BUOY_FORCE_FIELD);
09008     tolua_constant(tolua_S,"IR_DOCK_GREEN_BUOY_FORCE_FIELD",fawkes::Roomba500Interface::IR_DOCK_GREEN_BUOY_FORCE_FIELD);
09009     tolua_constant(tolua_S,"IR_DOCK_RED_GREEN_BUOY_FORCE_FIELD",fawkes::Roomba500Interface::IR_DOCK_RED_GREEN_BUOY_FORCE_FIELD);
09010     tolua_constant(tolua_S,"IR_VIRTUAL_WALL",fawkes::Roomba500Interface::IR_VIRTUAL_WALL);
09011     tolua_constant(tolua_S,"CHARGING_NO",fawkes::Roomba500Interface::CHARGING_NO);
09012     tolua_constant(tolua_S,"CHARGING_RECONDITIONING",fawkes::Roomba500Interface::CHARGING_RECONDITIONING);
09013     tolua_constant(tolua_S,"CHARGING_FULL",fawkes::Roomba500Interface::CHARGING_FULL);
09014     tolua_constant(tolua_S,"CHARGING_TRICKLE",fawkes::Roomba500Interface::CHARGING_TRICKLE);
09015     tolua_constant(tolua_S,"CHARGING_WAITING",fawkes::Roomba500Interface::CHARGING_WAITING);
09016     tolua_constant(tolua_S,"CHARGING_ERROR",fawkes::Roomba500Interface::CHARGING_ERROR);
09017     tolua_constant(tolua_S,"BRUSHSTATE_OFF",fawkes::Roomba500Interface::BRUSHSTATE_OFF);
09018     tolua_constant(tolua_S,"BRUSHSTATE_FORWARD",fawkes::Roomba500Interface::BRUSHSTATE_FORWARD);
09019     tolua_constant(tolua_S,"BRUSHSTATE_BACKWARD",fawkes::Roomba500Interface::BRUSHSTATE_BACKWARD);
09020     #ifdef __cplusplus
09021     tolua_cclass(tolua_S,"StopMessage","fawkes::Roomba500Interface::StopMessage","Message",tolua_collect_fawkes__Roomba500Interface__StopMessage);
09022     #else
09023     tolua_cclass(tolua_S,"StopMessage","fawkes::Roomba500Interface::StopMessage","Message",NULL);
09024     #endif
09025     tolua_beginmodule(tolua_S,"StopMessage");
09026      tolua_function(tolua_S,"new",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_StopMessage_new00);
09027      tolua_function(tolua_S,"new_local",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_StopMessage_new00_local);
09028      tolua_function(tolua_S,".call",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_StopMessage_new00_local);
09029      tolua_function(tolua_S,"delete",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_StopMessage_delete00);
09030     tolua_endmodule(tolua_S);
09031     #ifdef __cplusplus
09032     tolua_cclass(tolua_S,"DockMessage","fawkes::Roomba500Interface::DockMessage","Message",tolua_collect_fawkes__Roomba500Interface__DockMessage);
09033     #else
09034     tolua_cclass(tolua_S,"DockMessage","fawkes::Roomba500Interface::DockMessage","Message",NULL);
09035     #endif
09036     tolua_beginmodule(tolua_S,"DockMessage");
09037      tolua_function(tolua_S,"new",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DockMessage_new00);
09038      tolua_function(tolua_S,"new_local",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DockMessage_new00_local);
09039      tolua_function(tolua_S,".call",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DockMessage_new00_local);
09040      tolua_function(tolua_S,"delete",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DockMessage_delete00);
09041     tolua_endmodule(tolua_S);
09042     #ifdef __cplusplus
09043     tolua_cclass(tolua_S,"SetModeMessage","fawkes::Roomba500Interface::SetModeMessage","Message",tolua_collect_fawkes__Roomba500Interface__SetModeMessage);
09044     #else
09045     tolua_cclass(tolua_S,"SetModeMessage","fawkes::Roomba500Interface::SetModeMessage","Message",NULL);
09046     #endif
09047     tolua_beginmodule(tolua_S,"SetModeMessage");
09048      tolua_function(tolua_S,"new",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetModeMessage_new00);
09049      tolua_function(tolua_S,"new_local",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetModeMessage_new00_local);
09050      tolua_function(tolua_S,".call",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetModeMessage_new00_local);
09051      tolua_function(tolua_S,"new",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetModeMessage_new01);
09052      tolua_function(tolua_S,"new_local",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetModeMessage_new01_local);
09053      tolua_function(tolua_S,".call",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetModeMessage_new01_local);
09054      tolua_function(tolua_S,"delete",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetModeMessage_delete00);
09055      tolua_function(tolua_S,"mode",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetModeMessage_mode00);
09056      tolua_function(tolua_S,"set_mode",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetModeMessage_set_mode00);
09057      tolua_function(tolua_S,"maxlenof_mode",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetModeMessage_maxlenof_mode00);
09058     tolua_endmodule(tolua_S);
09059     #ifdef __cplusplus
09060     tolua_cclass(tolua_S,"DriveStraightMessage","fawkes::Roomba500Interface::DriveStraightMessage","Message",tolua_collect_fawkes__Roomba500Interface__DriveStraightMessage);
09061     #else
09062     tolua_cclass(tolua_S,"DriveStraightMessage","fawkes::Roomba500Interface::DriveStraightMessage","Message",NULL);
09063     #endif
09064     tolua_beginmodule(tolua_S,"DriveStraightMessage");
09065      tolua_function(tolua_S,"new",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveStraightMessage_new00);
09066      tolua_function(tolua_S,"new_local",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveStraightMessage_new00_local);
09067      tolua_function(tolua_S,".call",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveStraightMessage_new00_local);
09068      tolua_function(tolua_S,"new",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveStraightMessage_new01);
09069      tolua_function(tolua_S,"new_local",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveStraightMessage_new01_local);
09070      tolua_function(tolua_S,".call",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveStraightMessage_new01_local);
09071      tolua_function(tolua_S,"delete",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveStraightMessage_delete00);
09072      tolua_function(tolua_S,"velocity",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveStraightMessage_velocity00);
09073      tolua_function(tolua_S,"set_velocity",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveStraightMessage_set_velocity00);
09074      tolua_function(tolua_S,"maxlenof_velocity",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveStraightMessage_maxlenof_velocity00);
09075     tolua_endmodule(tolua_S);
09076     #ifdef __cplusplus
09077     tolua_cclass(tolua_S,"DriveMessage","fawkes::Roomba500Interface::DriveMessage","Message",tolua_collect_fawkes__Roomba500Interface__DriveMessage);
09078     #else
09079     tolua_cclass(tolua_S,"DriveMessage","fawkes::Roomba500Interface::DriveMessage","Message",NULL);
09080     #endif
09081     tolua_beginmodule(tolua_S,"DriveMessage");
09082      tolua_function(tolua_S,"new",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveMessage_new00);
09083      tolua_function(tolua_S,"new_local",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveMessage_new00_local);
09084      tolua_function(tolua_S,".call",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveMessage_new00_local);
09085      tolua_function(tolua_S,"new",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveMessage_new01);
09086      tolua_function(tolua_S,"new_local",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveMessage_new01_local);
09087      tolua_function(tolua_S,".call",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveMessage_new01_local);
09088      tolua_function(tolua_S,"delete",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveMessage_delete00);
09089      tolua_function(tolua_S,"velocity",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveMessage_velocity00);
09090      tolua_function(tolua_S,"set_velocity",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveMessage_set_velocity00);
09091      tolua_function(tolua_S,"maxlenof_velocity",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveMessage_maxlenof_velocity00);
09092      tolua_function(tolua_S,"radius",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveMessage_radius00);
09093      tolua_function(tolua_S,"set_radius",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveMessage_set_radius00);
09094      tolua_function(tolua_S,"maxlenof_radius",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_DriveMessage_maxlenof_radius00);
09095     tolua_endmodule(tolua_S);
09096     #ifdef __cplusplus
09097     tolua_cclass(tolua_S,"SetMotorsMessage","fawkes::Roomba500Interface::SetMotorsMessage","Message",tolua_collect_fawkes__Roomba500Interface__SetMotorsMessage);
09098     #else
09099     tolua_cclass(tolua_S,"SetMotorsMessage","fawkes::Roomba500Interface::SetMotorsMessage","Message",NULL);
09100     #endif
09101     tolua_beginmodule(tolua_S,"SetMotorsMessage");
09102      tolua_function(tolua_S,"new",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetMotorsMessage_new00);
09103      tolua_function(tolua_S,"new_local",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetMotorsMessage_new00_local);
09104      tolua_function(tolua_S,".call",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetMotorsMessage_new00_local);
09105      tolua_function(tolua_S,"new",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetMotorsMessage_new01);
09106      tolua_function(tolua_S,"new_local",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetMotorsMessage_new01_local);
09107      tolua_function(tolua_S,".call",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetMotorsMessage_new01_local);
09108      tolua_function(tolua_S,"delete",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetMotorsMessage_delete00);
09109      tolua_function(tolua_S,"is_vacuuming",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetMotorsMessage_is_vacuuming00);
09110      tolua_function(tolua_S,"set_vacuuming",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetMotorsMessage_set_vacuuming00);
09111      tolua_function(tolua_S,"maxlenof_vacuuming",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetMotorsMessage_maxlenof_vacuuming00);
09112      tolua_function(tolua_S,"main",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetMotorsMessage_main00);
09113      tolua_function(tolua_S,"set_main",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetMotorsMessage_set_main00);
09114      tolua_function(tolua_S,"maxlenof_main",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetMotorsMessage_maxlenof_main00);
09115      tolua_function(tolua_S,"side",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetMotorsMessage_side00);
09116      tolua_function(tolua_S,"set_side",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetMotorsMessage_set_side00);
09117      tolua_function(tolua_S,"maxlenof_side",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_SetMotorsMessage_maxlenof_side00);
09118     tolua_endmodule(tolua_S);
09119     tolua_function(tolua_S,"mode",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_mode00);
09120     tolua_function(tolua_S,"set_mode",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_mode00);
09121     tolua_function(tolua_S,"maxlenof_mode",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_mode00);
09122     tolua_function(tolua_S,"is_wheel_drop_left",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_wheel_drop_left00);
09123     tolua_function(tolua_S,"set_wheel_drop_left",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_wheel_drop_left00);
09124     tolua_function(tolua_S,"maxlenof_wheel_drop_left",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_wheel_drop_left00);
09125     tolua_function(tolua_S,"is_wheel_drop_right",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_wheel_drop_right00);
09126     tolua_function(tolua_S,"set_wheel_drop_right",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_wheel_drop_right00);
09127     tolua_function(tolua_S,"maxlenof_wheel_drop_right",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_wheel_drop_right00);
09128     tolua_function(tolua_S,"is_bump_left",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_bump_left00);
09129     tolua_function(tolua_S,"set_bump_left",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_bump_left00);
09130     tolua_function(tolua_S,"maxlenof_bump_left",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_bump_left00);
09131     tolua_function(tolua_S,"is_bump_right",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_bump_right00);
09132     tolua_function(tolua_S,"set_bump_right",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_bump_right00);
09133     tolua_function(tolua_S,"maxlenof_bump_right",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_bump_right00);
09134     tolua_function(tolua_S,"is_wall",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_wall00);
09135     tolua_function(tolua_S,"set_wall",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_wall00);
09136     tolua_function(tolua_S,"maxlenof_wall",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_wall00);
09137     tolua_function(tolua_S,"is_cliff_left",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_cliff_left00);
09138     tolua_function(tolua_S,"set_cliff_left",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_cliff_left00);
09139     tolua_function(tolua_S,"maxlenof_cliff_left",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_cliff_left00);
09140     tolua_function(tolua_S,"is_cliff_front_left",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_cliff_front_left00);
09141     tolua_function(tolua_S,"set_cliff_front_left",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_cliff_front_left00);
09142     tolua_function(tolua_S,"maxlenof_cliff_front_left",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_cliff_front_left00);
09143     tolua_function(tolua_S,"is_cliff_front_right",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_cliff_front_right00);
09144     tolua_function(tolua_S,"set_cliff_front_right",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_cliff_front_right00);
09145     tolua_function(tolua_S,"maxlenof_cliff_front_right",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_cliff_front_right00);
09146     tolua_function(tolua_S,"is_cliff_right",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_cliff_right00);
09147     tolua_function(tolua_S,"set_cliff_right",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_cliff_right00);
09148     tolua_function(tolua_S,"maxlenof_cliff_right",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_cliff_right00);
09149     tolua_function(tolua_S,"is_virtual_wall",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_virtual_wall00);
09150     tolua_function(tolua_S,"set_virtual_wall",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_virtual_wall00);
09151     tolua_function(tolua_S,"maxlenof_virtual_wall",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_virtual_wall00);
09152     tolua_function(tolua_S,"is_overcurrent_side_brush",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_overcurrent_side_brush00);
09153     tolua_function(tolua_S,"set_overcurrent_side_brush",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_overcurrent_side_brush00);
09154     tolua_function(tolua_S,"maxlenof_overcurrent_side_brush",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_overcurrent_side_brush00);
09155     tolua_function(tolua_S,"is_overcurrent_main_brush",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_overcurrent_main_brush00);
09156     tolua_function(tolua_S,"set_overcurrent_main_brush",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_overcurrent_main_brush00);
09157     tolua_function(tolua_S,"maxlenof_overcurrent_main_brush",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_overcurrent_main_brush00);
09158     tolua_function(tolua_S,"is_overcurrent_left_wheel",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_overcurrent_left_wheel00);
09159     tolua_function(tolua_S,"set_overcurrent_left_wheel",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_overcurrent_left_wheel00);
09160     tolua_function(tolua_S,"maxlenof_overcurrent_left_wheel",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_overcurrent_left_wheel00);
09161     tolua_function(tolua_S,"is_overcurrent_right_wheel",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_overcurrent_right_wheel00);
09162     tolua_function(tolua_S,"set_overcurrent_right_wheel",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_overcurrent_right_wheel00);
09163     tolua_function(tolua_S,"maxlenof_overcurrent_right_wheel",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_overcurrent_right_wheel00);
09164     tolua_function(tolua_S,"is_dirt_detect",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_dirt_detect00);
09165     tolua_function(tolua_S,"set_dirt_detect",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_dirt_detect00);
09166     tolua_function(tolua_S,"maxlenof_dirt_detect",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_dirt_detect00);
09167     tolua_function(tolua_S,"ir_opcode_omni",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_ir_opcode_omni00);
09168     tolua_function(tolua_S,"set_ir_opcode_omni",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_ir_opcode_omni00);
09169     tolua_function(tolua_S,"maxlenof_ir_opcode_omni",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_ir_opcode_omni00);
09170     tolua_function(tolua_S,"is_button_clean",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_button_clean00);
09171     tolua_function(tolua_S,"set_button_clean",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_button_clean00);
09172     tolua_function(tolua_S,"maxlenof_button_clean",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_button_clean00);
09173     tolua_function(tolua_S,"is_button_spot",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_button_spot00);
09174     tolua_function(tolua_S,"set_button_spot",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_button_spot00);
09175     tolua_function(tolua_S,"maxlenof_button_spot",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_button_spot00);
09176     tolua_function(tolua_S,"is_button_dock",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_button_dock00);
09177     tolua_function(tolua_S,"set_button_dock",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_button_dock00);
09178     tolua_function(tolua_S,"maxlenof_button_dock",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_button_dock00);
09179     tolua_function(tolua_S,"is_button_minute",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_button_minute00);
09180     tolua_function(tolua_S,"set_button_minute",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_button_minute00);
09181     tolua_function(tolua_S,"maxlenof_button_minute",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_button_minute00);
09182     tolua_function(tolua_S,"is_button_hour",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_button_hour00);
09183     tolua_function(tolua_S,"set_button_hour",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_button_hour00);
09184     tolua_function(tolua_S,"maxlenof_button_hour",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_button_hour00);
09185     tolua_function(tolua_S,"is_button_day",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_button_day00);
09186     tolua_function(tolua_S,"set_button_day",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_button_day00);
09187     tolua_function(tolua_S,"maxlenof_button_day",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_button_day00);
09188     tolua_function(tolua_S,"is_button_schedule",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_button_schedule00);
09189     tolua_function(tolua_S,"set_button_schedule",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_button_schedule00);
09190     tolua_function(tolua_S,"maxlenof_button_schedule",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_button_schedule00);
09191     tolua_function(tolua_S,"is_button_clock",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_button_clock00);
09192     tolua_function(tolua_S,"set_button_clock",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_button_clock00);
09193     tolua_function(tolua_S,"maxlenof_button_clock",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_button_clock00);
09194     tolua_function(tolua_S,"distance",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_distance00);
09195     tolua_function(tolua_S,"set_distance",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_distance00);
09196     tolua_function(tolua_S,"maxlenof_distance",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_distance00);
09197     tolua_function(tolua_S,"angle",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_angle00);
09198     tolua_function(tolua_S,"set_angle",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_angle00);
09199     tolua_function(tolua_S,"maxlenof_angle",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_angle00);
09200     tolua_function(tolua_S,"charging_state",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_charging_state00);
09201     tolua_function(tolua_S,"set_charging_state",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_charging_state00);
09202     tolua_function(tolua_S,"maxlenof_charging_state",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_charging_state00);
09203     tolua_function(tolua_S,"voltage",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_voltage00);
09204     tolua_function(tolua_S,"set_voltage",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_voltage00);
09205     tolua_function(tolua_S,"maxlenof_voltage",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_voltage00);
09206     tolua_function(tolua_S,"current",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_current00);
09207     tolua_function(tolua_S,"set_current",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_current00);
09208     tolua_function(tolua_S,"maxlenof_current",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_current00);
09209     tolua_function(tolua_S,"temperature",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_temperature00);
09210     tolua_function(tolua_S,"set_temperature",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_temperature00);
09211     tolua_function(tolua_S,"maxlenof_temperature",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_temperature00);
09212     tolua_function(tolua_S,"battery_charge",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_battery_charge00);
09213     tolua_function(tolua_S,"set_battery_charge",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_battery_charge00);
09214     tolua_function(tolua_S,"maxlenof_battery_charge",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_battery_charge00);
09215     tolua_function(tolua_S,"battery_capacity",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_battery_capacity00);
09216     tolua_function(tolua_S,"set_battery_capacity",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_battery_capacity00);
09217     tolua_function(tolua_S,"maxlenof_battery_capacity",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_battery_capacity00);
09218     tolua_function(tolua_S,"wall_signal",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_wall_signal00);
09219     tolua_function(tolua_S,"set_wall_signal",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_wall_signal00);
09220     tolua_function(tolua_S,"maxlenof_wall_signal",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_wall_signal00);
09221     tolua_function(tolua_S,"cliff_left_signal",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_cliff_left_signal00);
09222     tolua_function(tolua_S,"set_cliff_left_signal",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_cliff_left_signal00);
09223     tolua_function(tolua_S,"maxlenof_cliff_left_signal",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_cliff_left_signal00);
09224     tolua_function(tolua_S,"cliff_front_left_signal",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_cliff_front_left_signal00);
09225     tolua_function(tolua_S,"set_cliff_front_left_signal",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_cliff_front_left_signal00);
09226     tolua_function(tolua_S,"maxlenof_cliff_front_left_signal",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_cliff_front_left_signal00);
09227     tolua_function(tolua_S,"cliff_front_right_signal",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_cliff_front_right_signal00);
09228     tolua_function(tolua_S,"set_cliff_front_right_signal",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_cliff_front_right_signal00);
09229     tolua_function(tolua_S,"maxlenof_cliff_front_right_signal",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_cliff_front_right_signal00);
09230     tolua_function(tolua_S,"cliff_right_signal",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_cliff_right_signal00);
09231     tolua_function(tolua_S,"set_cliff_right_signal",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_cliff_right_signal00);
09232     tolua_function(tolua_S,"maxlenof_cliff_right_signal",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_cliff_right_signal00);
09233     tolua_function(tolua_S,"is_home_base_charger_available",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_home_base_charger_available00);
09234     tolua_function(tolua_S,"set_home_base_charger_available",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_home_base_charger_available00);
09235     tolua_function(tolua_S,"maxlenof_home_base_charger_available",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_home_base_charger_available00);
09236     tolua_function(tolua_S,"is_internal_charger_available",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_internal_charger_available00);
09237     tolua_function(tolua_S,"set_internal_charger_available",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_internal_charger_available00);
09238     tolua_function(tolua_S,"maxlenof_internal_charger_available",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_internal_charger_available00);
09239     tolua_function(tolua_S,"song_number",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_song_number00);
09240     tolua_function(tolua_S,"set_song_number",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_song_number00);
09241     tolua_function(tolua_S,"maxlenof_song_number",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_song_number00);
09242     tolua_function(tolua_S,"is_song_playing",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_song_playing00);
09243     tolua_function(tolua_S,"set_song_playing",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_song_playing00);
09244     tolua_function(tolua_S,"maxlenof_song_playing",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_song_playing00);
09245     tolua_function(tolua_S,"velocity",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_velocity00);
09246     tolua_function(tolua_S,"set_velocity",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_velocity00);
09247     tolua_function(tolua_S,"maxlenof_velocity",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_velocity00);
09248     tolua_function(tolua_S,"radius",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_radius00);
09249     tolua_function(tolua_S,"set_radius",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_radius00);
09250     tolua_function(tolua_S,"maxlenof_radius",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_radius00);
09251     tolua_function(tolua_S,"velocity_right",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_velocity_right00);
09252     tolua_function(tolua_S,"set_velocity_right",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_velocity_right00);
09253     tolua_function(tolua_S,"maxlenof_velocity_right",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_velocity_right00);
09254     tolua_function(tolua_S,"velocity_left",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_velocity_left00);
09255     tolua_function(tolua_S,"set_velocity_left",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_velocity_left00);
09256     tolua_function(tolua_S,"maxlenof_velocity_left",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_velocity_left00);
09257     tolua_function(tolua_S,"encoder_counts_left",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_encoder_counts_left00);
09258     tolua_function(tolua_S,"set_encoder_counts_left",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_encoder_counts_left00);
09259     tolua_function(tolua_S,"maxlenof_encoder_counts_left",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_encoder_counts_left00);
09260     tolua_function(tolua_S,"encoder_counts_right",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_encoder_counts_right00);
09261     tolua_function(tolua_S,"set_encoder_counts_right",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_encoder_counts_right00);
09262     tolua_function(tolua_S,"maxlenof_encoder_counts_right",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_encoder_counts_right00);
09263     tolua_function(tolua_S,"is_bumper_left",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_bumper_left00);
09264     tolua_function(tolua_S,"set_bumper_left",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_bumper_left00);
09265     tolua_function(tolua_S,"maxlenof_bumper_left",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_bumper_left00);
09266     tolua_function(tolua_S,"is_bumper_front_left",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_bumper_front_left00);
09267     tolua_function(tolua_S,"set_bumper_front_left",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_bumper_front_left00);
09268     tolua_function(tolua_S,"maxlenof_bumper_front_left",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_bumper_front_left00);
09269     tolua_function(tolua_S,"is_bumper_center_left",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_bumper_center_left00);
09270     tolua_function(tolua_S,"set_bumper_center_left",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_bumper_center_left00);
09271     tolua_function(tolua_S,"maxlenof_bumper_center_left",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_bumper_center_left00);
09272     tolua_function(tolua_S,"is_bumper_center_right",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_bumper_center_right00);
09273     tolua_function(tolua_S,"set_bumper_center_right",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_bumper_center_right00);
09274     tolua_function(tolua_S,"maxlenof_bumper_center_right",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_bumper_center_right00);
09275     tolua_function(tolua_S,"is_bumper_front_right",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_bumper_front_right00);
09276     tolua_function(tolua_S,"set_bumper_front_right",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_bumper_front_right00);
09277     tolua_function(tolua_S,"maxlenof_bumper_front_right",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_bumper_front_right00);
09278     tolua_function(tolua_S,"is_bumper_right",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_bumper_right00);
09279     tolua_function(tolua_S,"set_bumper_right",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_bumper_right00);
09280     tolua_function(tolua_S,"maxlenof_bumper_right",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_bumper_right00);
09281     tolua_function(tolua_S,"light_bump_left",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_light_bump_left00);
09282     tolua_function(tolua_S,"set_light_bump_left",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_light_bump_left00);
09283     tolua_function(tolua_S,"maxlenof_light_bump_left",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_light_bump_left00);
09284     tolua_function(tolua_S,"light_bump_front_left",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_light_bump_front_left00);
09285     tolua_function(tolua_S,"set_light_bump_front_left",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_light_bump_front_left00);
09286     tolua_function(tolua_S,"maxlenof_light_bump_front_left",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_light_bump_front_left00);
09287     tolua_function(tolua_S,"light_bump_center_left",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_light_bump_center_left00);
09288     tolua_function(tolua_S,"set_light_bump_center_left",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_light_bump_center_left00);
09289     tolua_function(tolua_S,"maxlenof_light_bump_center_left",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_light_bump_center_left00);
09290     tolua_function(tolua_S,"light_bump_center_right",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_light_bump_center_right00);
09291     tolua_function(tolua_S,"set_light_bump_center_right",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_light_bump_center_right00);
09292     tolua_function(tolua_S,"maxlenof_light_bump_center_right",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_light_bump_center_right00);
09293     tolua_function(tolua_S,"light_bump_front_right",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_light_bump_front_right00);
09294     tolua_function(tolua_S,"set_light_bump_front_right",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_light_bump_front_right00);
09295     tolua_function(tolua_S,"maxlenof_light_bump_front_right",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_light_bump_front_right00);
09296     tolua_function(tolua_S,"light_bump_right",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_light_bump_right00);
09297     tolua_function(tolua_S,"set_light_bump_right",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_light_bump_right00);
09298     tolua_function(tolua_S,"maxlenof_light_bump_right",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_light_bump_right00);
09299     tolua_function(tolua_S,"ir_opcode_left",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_ir_opcode_left00);
09300     tolua_function(tolua_S,"set_ir_opcode_left",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_ir_opcode_left00);
09301     tolua_function(tolua_S,"maxlenof_ir_opcode_left",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_ir_opcode_left00);
09302     tolua_function(tolua_S,"ir_opcode_right",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_ir_opcode_right00);
09303     tolua_function(tolua_S,"set_ir_opcode_right",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_ir_opcode_right00);
09304     tolua_function(tolua_S,"maxlenof_ir_opcode_right",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_ir_opcode_right00);
09305     tolua_function(tolua_S,"left_motor_current",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_left_motor_current00);
09306     tolua_function(tolua_S,"set_left_motor_current",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_left_motor_current00);
09307     tolua_function(tolua_S,"maxlenof_left_motor_current",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_left_motor_current00);
09308     tolua_function(tolua_S,"right_motor_current",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_right_motor_current00);
09309     tolua_function(tolua_S,"set_right_motor_current",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_right_motor_current00);
09310     tolua_function(tolua_S,"maxlenof_right_motor_current",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_right_motor_current00);
09311     tolua_function(tolua_S,"main_brush_current",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_main_brush_current00);
09312     tolua_function(tolua_S,"set_main_brush_current",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_main_brush_current00);
09313     tolua_function(tolua_S,"maxlenof_main_brush_current",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_main_brush_current00);
09314     tolua_function(tolua_S,"side_brush_current",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_side_brush_current00);
09315     tolua_function(tolua_S,"set_side_brush_current",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_side_brush_current00);
09316     tolua_function(tolua_S,"maxlenof_side_brush_current",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_side_brush_current00);
09317     tolua_function(tolua_S,"is_caster_stasis",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_caster_stasis00);
09318     tolua_function(tolua_S,"set_caster_stasis",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_caster_stasis00);
09319     tolua_function(tolua_S,"maxlenof_caster_stasis",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_maxlenof_caster_stasis00);
09320     tolua_function(tolua_S,"oftype",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_oftype00);
09321     tolua_function(tolua_S,"datachunk",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_datachunk00);
09322     tolua_function(tolua_S,"datasize",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_datasize00);
09323     tolua_function(tolua_S,"type",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_type00);
09324     tolua_function(tolua_S,"id",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_id00);
09325     tolua_function(tolua_S,"uid",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_uid00);
09326     tolua_function(tolua_S,"serial",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_serial00);
09327     tolua_function(tolua_S,"mem_serial",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_mem_serial00);
09328     tolua_function(tolua_S,".eq",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface__eq00);
09329     tolua_function(tolua_S,"hash",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_hash00);
09330     tolua_function(tolua_S,"hash_size",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_hash_size00);
09331     tolua_function(tolua_S,"hash_printable",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_hash_printable00);
09332     tolua_function(tolua_S,"is_writer",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_is_writer00);
09333     tolua_function(tolua_S,"set_from_chunk",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_set_from_chunk00);
09334     tolua_function(tolua_S,"create_message",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_create_message00);
09335     tolua_function(tolua_S,"read",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_read00);
09336     tolua_function(tolua_S,"write",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_write00);
09337     tolua_function(tolua_S,"has_writer",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_has_writer00);
09338     tolua_function(tolua_S,"num_readers",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_num_readers00);
09339     tolua_function(tolua_S,"msgq_enqueue_copy",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_msgq_enqueue_copy00);
09340     tolua_function(tolua_S,"msgq_remove",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_msgq_remove00);
09341     tolua_function(tolua_S,"msgq_remove",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_msgq_remove01);
09342     tolua_function(tolua_S,"msgq_size",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_msgq_size00);
09343     tolua_function(tolua_S,"msgq_flush",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_msgq_flush00);
09344     tolua_function(tolua_S,"msgq_lock",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_msgq_lock00);
09345     tolua_function(tolua_S,"msgq_try_lock",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_msgq_try_lock00);
09346     tolua_function(tolua_S,"msgq_unlock",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_msgq_unlock00);
09347     tolua_function(tolua_S,"msgq_pop",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_msgq_pop00);
09348     tolua_function(tolua_S,"msgq_first",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_msgq_first00);
09349     tolua_function(tolua_S,"msgq_empty",tolua_interfaces_Roomba500Interface_fawkes_Roomba500Interface_msgq_empty00);
09350    tolua_endmodule(tolua_S);
09351   tolua_endmodule(tolua_S);
09352  tolua_endmodule(tolua_S);
09353  return 1;
09354 }
09355 
09356 
09357 extern "C" {
09358 #if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501
09359  TOLUA_API int luaopen_interfaces_Roomba500Interface (lua_State* tolua_S) {
09360  return tolua_interfaces_Roomba500Interface_open(tolua_S);
09361 };
09362 #endif
09363 }
09364 
09365