00001 /*
00002 ** Lua binding: interfaces_MotorInterface
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_MotorInterface_open (lua_State* tolua_S);
00028
00029 #include <interfaces/MotorInterface.h>
00030 using namespace fawkes;
00031
00032 /* function to release collected object via destructor */
00033 #ifdef __cplusplus
00034 
00035 static int tolua_collect_fawkes__MotorInterface__OrbitMessage (lua_State* tolua_S)
00036 {
00037  fawkes::MotorInterface::OrbitMessage* self = (fawkes::MotorInterface::OrbitMessage*) tolua_tousertype(tolua_S,1,0);
00038         delete self;
00039         return 0;
00040 }
00041
00042 static int tolua_collect_fawkes__MotorInterface__ResetOdometryMessage (lua_State* tolua_S)
00043 {
00044  fawkes::MotorInterface::ResetOdometryMessage* self = (fawkes::MotorInterface::ResetOdometryMessage*) tolua_tousertype(tolua_S,1,0);
00045         delete self;
00046         return 0;
00047 }
00048
00049 static int tolua_collect_fawkes__MotorInterface__GotoMessage (lua_State* tolua_S)
00050 {
00051  fawkes::MotorInterface::GotoMessage* self = (fawkes::MotorInterface::GotoMessage*) tolua_tousertype(tolua_S,1,0);
00052         delete self;
00053         return 0;
00054 }
00055
00056 static int tolua_collect_fawkes__MotorInterface__TransMessage (lua_State* tolua_S)
00057 {
00058  fawkes::MotorInterface::TransMessage* self = (fawkes::MotorInterface::TransMessage*) tolua_tousertype(tolua_S,1,0);
00059         delete self;
00060         return 0;
00061 }
00062
00063 static int tolua_collect_fawkes__MotorInterface__AcquireControlMessage (lua_State* tolua_S)
00064 {
00065  fawkes::MotorInterface::AcquireControlMessage* self = (fawkes::MotorInterface::AcquireControlMessage*) tolua_tousertype(tolua_S,1,0);
00066         delete self;
00067         return 0;
00068 }
00069
00070 static int tolua_collect_fawkes__MotorInterface__LinTransRotMessage (lua_State* tolua_S)
00071 {
00072  fawkes::MotorInterface::LinTransRotMessage* self = (fawkes::MotorInterface::LinTransRotMessage*) tolua_tousertype(tolua_S,1,0);
00073         delete self;
00074         return 0;
00075 }
00076
00077 static int tolua_collect_fawkes__MotorInterface__SetMotorStateMessage (lua_State* tolua_S)
00078 {
00079  fawkes::MotorInterface::SetMotorStateMessage* self = (fawkes::MotorInterface::SetMotorStateMessage*) tolua_tousertype(tolua_S,1,0);
00080         delete self;
00081         return 0;
00082 }
00083
00084 static int tolua_collect_fawkes__MotorInterface__TransRotMessage (lua_State* tolua_S)
00085 {
00086  fawkes::MotorInterface::TransRotMessage* self = (fawkes::MotorInterface::TransRotMessage*) tolua_tousertype(tolua_S,1,0);
00087         delete self;
00088         return 0;
00089 }
00090
00091 static int tolua_collect_fawkes__MotorInterface__DriveRPMMessage (lua_State* tolua_S)
00092 {
00093  fawkes::MotorInterface::DriveRPMMessage* self = (fawkes::MotorInterface::DriveRPMMessage*) tolua_tousertype(tolua_S,1,0);
00094         delete self;
00095         return 0;
00096 }
00097
00098 static int tolua_collect_fawkes__MotorInterface__RotMessage (lua_State* tolua_S)
00099 {
00100  fawkes::MotorInterface::RotMessage* self = (fawkes::MotorInterface::RotMessage*) tolua_tousertype(tolua_S,1,0);
00101         delete self;
00102         return 0;
00103 }
00104 #endif
00105 
00106
00107 /* function to register type */
00108 static void tolua_reg_types (lua_State* tolua_S)
00109 {
00110  tolua_usertype(tolua_S,"fawkes::MotorInterface::OrbitMessage");
00111  tolua_usertype(tolua_S,"fawkes::MotorInterface::ResetOdometryMessage");
00112  tolua_usertype(tolua_S,"fawkes::MotorInterface::GotoMessage");
00113  tolua_usertype(tolua_S,"fawkes::MotorInterface");
00114  tolua_usertype(tolua_S,"fawkes::MotorInterface::TransMessage");
00115  tolua_usertype(tolua_S,"fawkes::MotorInterface::AcquireControlMessage");
00116  tolua_usertype(tolua_S,"fawkes::MotorInterface::TransRotMessage");
00117  tolua_usertype(tolua_S,"fawkes::MotorInterface::LinTransRotMessage");
00118  tolua_usertype(tolua_S,"fawkes::MotorInterface::SetMotorStateMessage");
00119  tolua_usertype(tolua_S,"fawkes::MotorInterface::RotMessage");
00120  tolua_usertype(tolua_S,"Message");
00121  tolua_usertype(tolua_S,"fawkes::MotorInterface::DriveRPMMessage");
00122  tolua_usertype(tolua_S,"Interface");
00123 }
00124
00125 /* get function: MOTOR_ENABLED of class  fawkes::MotorInterface */
00126 #ifndef TOLUA_DISABLE_tolua_get_fawkes__MotorInterface_unsigned_MOTOR_ENABLED
00127 static int tolua_get_fawkes__MotorInterface_unsigned_MOTOR_ENABLED(lua_State* tolua_S)
00128 {
00129   tolua_pushnumber(tolua_S,(lua_Number)fawkes::MotorInterface::MOTOR_ENABLED);
00130  return 1;
00131 }
00132 #endif //#ifndef TOLUA_DISABLE
00133 
00134 /* get function: MOTOR_DISABLED of class  fawkes::MotorInterface */
00135 #ifndef TOLUA_DISABLE_tolua_get_fawkes__MotorInterface_unsigned_MOTOR_DISABLED
00136 static int tolua_get_fawkes__MotorInterface_unsigned_MOTOR_DISABLED(lua_State* tolua_S)
00137 {
00138   tolua_pushnumber(tolua_S,(lua_Number)fawkes::MotorInterface::MOTOR_DISABLED);
00139  return 1;
00140 }
00141 #endif //#ifndef TOLUA_DISABLE
00142 
00143 /* get function: DRIVE_MODE_RPM of class  fawkes::MotorInterface */
00144 #ifndef TOLUA_DISABLE_tolua_get_fawkes__MotorInterface_unsigned_DRIVE_MODE_RPM
00145 static int tolua_get_fawkes__MotorInterface_unsigned_DRIVE_MODE_RPM(lua_State* tolua_S)
00146 {
00147   tolua_pushnumber(tolua_S,(lua_Number)fawkes::MotorInterface::DRIVE_MODE_RPM);
00148  return 1;
00149 }
00150 #endif //#ifndef TOLUA_DISABLE
00151 
00152 /* get function: DRIVE_MODE_TRANS of class  fawkes::MotorInterface */
00153 #ifndef TOLUA_DISABLE_tolua_get_fawkes__MotorInterface_unsigned_DRIVE_MODE_TRANS
00154 static int tolua_get_fawkes__MotorInterface_unsigned_DRIVE_MODE_TRANS(lua_State* tolua_S)
00155 {
00156   tolua_pushnumber(tolua_S,(lua_Number)fawkes::MotorInterface::DRIVE_MODE_TRANS);
00157  return 1;
00158 }
00159 #endif //#ifndef TOLUA_DISABLE
00160 
00161 /* get function: DRIVE_MODE_ROT of class  fawkes::MotorInterface */
00162 #ifndef TOLUA_DISABLE_tolua_get_fawkes__MotorInterface_unsigned_DRIVE_MODE_ROT
00163 static int tolua_get_fawkes__MotorInterface_unsigned_DRIVE_MODE_ROT(lua_State* tolua_S)
00164 {
00165   tolua_pushnumber(tolua_S,(lua_Number)fawkes::MotorInterface::DRIVE_MODE_ROT);
00166  return 1;
00167 }
00168 #endif //#ifndef TOLUA_DISABLE
00169 
00170 /* get function: DRIVE_MODE_TRANS_ROT of class  fawkes::MotorInterface */
00171 #ifndef TOLUA_DISABLE_tolua_get_fawkes__MotorInterface_unsigned_DRIVE_MODE_TRANS_ROT
00172 static int tolua_get_fawkes__MotorInterface_unsigned_DRIVE_MODE_TRANS_ROT(lua_State* tolua_S)
00173 {
00174   tolua_pushnumber(tolua_S,(lua_Number)fawkes::MotorInterface::DRIVE_MODE_TRANS_ROT);
00175  return 1;
00176 }
00177 #endif //#ifndef TOLUA_DISABLE
00178 
00179 /* get function: DRIVE_MODE_ORBIT of class  fawkes::MotorInterface */
00180 #ifndef TOLUA_DISABLE_tolua_get_fawkes__MotorInterface_unsigned_DRIVE_MODE_ORBIT
00181 static int tolua_get_fawkes__MotorInterface_unsigned_DRIVE_MODE_ORBIT(lua_State* tolua_S)
00182 {
00183   tolua_pushnumber(tolua_S,(lua_Number)fawkes::MotorInterface::DRIVE_MODE_ORBIT);
00184  return 1;
00185 }
00186 #endif //#ifndef TOLUA_DISABLE
00187 
00188 /* get function: DRIVE_MODE_LINE_TRANS_ROT of class  fawkes::MotorInterface */
00189 #ifndef TOLUA_DISABLE_tolua_get_fawkes__MotorInterface_unsigned_DRIVE_MODE_LINE_TRANS_ROT
00190 static int tolua_get_fawkes__MotorInterface_unsigned_DRIVE_MODE_LINE_TRANS_ROT(lua_State* tolua_S)
00191 {
00192   tolua_pushnumber(tolua_S,(lua_Number)fawkes::MotorInterface::DRIVE_MODE_LINE_TRANS_ROT);
00193  return 1;
00194 }
00195 #endif //#ifndef TOLUA_DISABLE
00196 
00197 /* method: new of class  SetMotorStateMessage */
00198 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_SetMotorStateMessage_new00
00199 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_SetMotorStateMessage_new00(lua_State* tolua_S)
00200 {
00201 #ifndef TOLUA_RELEASE
00202  tolua_Error tolua_err;
00203  if (
00204      !tolua_isusertable(tolua_S,1,"fawkes::MotorInterface::SetMotorStateMessage",0,&tolua_err) ||
00205      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00206      !tolua_isnoobj(tolua_S,3,&tolua_err)
00207  )
00208   goto tolua_lerror;
00209  else
00210 #endif
00211  {
00212   unsigned int ini_motor_state = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
00213   {
00214    fawkes::MotorInterface::SetMotorStateMessage* tolua_ret = (fawkes::MotorInterface::SetMotorStateMessage*)  new fawkes::MotorInterface::SetMotorStateMessage(ini_motor_state);
00215    tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::MotorInterface::SetMotorStateMessage");
00216   }
00217  }
00218  return 1;
00219 #ifndef TOLUA_RELEASE
00220  tolua_lerror:
00221  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00222  return 0;
00223 #endif
00224 }
00225 #endif //#ifndef TOLUA_DISABLE
00226 
00227 /* method: new_local of class  SetMotorStateMessage */
00228 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_SetMotorStateMessage_new00_local
00229 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_SetMotorStateMessage_new00_local(lua_State* tolua_S)
00230 {
00231 #ifndef TOLUA_RELEASE
00232  tolua_Error tolua_err;
00233  if (
00234      !tolua_isusertable(tolua_S,1,"fawkes::MotorInterface::SetMotorStateMessage",0,&tolua_err) ||
00235      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00236      !tolua_isnoobj(tolua_S,3,&tolua_err)
00237  )
00238   goto tolua_lerror;
00239  else
00240 #endif
00241  {
00242   unsigned int ini_motor_state = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
00243   {
00244    fawkes::MotorInterface::SetMotorStateMessage* tolua_ret = (fawkes::MotorInterface::SetMotorStateMessage*)  new fawkes::MotorInterface::SetMotorStateMessage(ini_motor_state);
00245    tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"fawkes::MotorInterface::SetMotorStateMessage");
00246   }
00247  }
00248  return 1;
00249 #ifndef TOLUA_RELEASE
00250  tolua_lerror:
00251  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00252  return 0;
00253 #endif
00254 }
00255 #endif //#ifndef TOLUA_DISABLE
00256 
00257 /* method: new of class  SetMotorStateMessage */
00258 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_SetMotorStateMessage_new01
00259 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_SetMotorStateMessage_new01(lua_State* tolua_S)
00260 {
00261  tolua_Error tolua_err;
00262  if (
00263      !tolua_isusertable(tolua_S,1,"fawkes::MotorInterface::SetMotorStateMessage",0,&tolua_err) ||
00264      !tolua_isnoobj(tolua_S,2,&tolua_err)
00265  )
00266   goto tolua_lerror;
00267  else
00268  {
00269   {
00270    fawkes::MotorInterface::SetMotorStateMessage* tolua_ret = (fawkes::MotorInterface::SetMotorStateMessage*)  new fawkes::MotorInterface::SetMotorStateMessage();
00271    tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::MotorInterface::SetMotorStateMessage");
00272   }
00273  }
00274  return 1;
00275 tolua_lerror:
00276  return tolua_interfaces_MotorInterface_fawkes_MotorInterface_SetMotorStateMessage_new00(tolua_S);
00277 }
00278 #endif //#ifndef TOLUA_DISABLE
00279 
00280 /* method: new_local of class  SetMotorStateMessage */
00281 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_SetMotorStateMessage_new01_local
00282 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_SetMotorStateMessage_new01_local(lua_State* tolua_S)
00283 {
00284  tolua_Error tolua_err;
00285  if (
00286      !tolua_isusertable(tolua_S,1,"fawkes::MotorInterface::SetMotorStateMessage",0,&tolua_err) ||
00287      !tolua_isnoobj(tolua_S,2,&tolua_err)
00288  )
00289   goto tolua_lerror;
00290  else
00291  {
00292   {
00293    fawkes::MotorInterface::SetMotorStateMessage* tolua_ret = (fawkes::MotorInterface::SetMotorStateMessage*)  new fawkes::MotorInterface::SetMotorStateMessage();
00294    tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"fawkes::MotorInterface::SetMotorStateMessage");
00295   }
00296  }
00297  return 1;
00298 tolua_lerror:
00299  return tolua_interfaces_MotorInterface_fawkes_MotorInterface_SetMotorStateMessage_new00_local(tolua_S);
00300 }
00301 #endif //#ifndef TOLUA_DISABLE
00302 
00303 /* method: delete of class  SetMotorStateMessage */
00304 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_SetMotorStateMessage_delete00
00305 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_SetMotorStateMessage_delete00(lua_State* tolua_S)
00306 {
00307 #ifndef TOLUA_RELEASE
00308  tolua_Error tolua_err;
00309  if (
00310      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface::SetMotorStateMessage",0,&tolua_err) ||
00311      !tolua_isnoobj(tolua_S,2,&tolua_err)
00312  )
00313   goto tolua_lerror;
00314  else
00315 #endif
00316  {
00317   fawkes::MotorInterface::SetMotorStateMessage* self = (fawkes::MotorInterface::SetMotorStateMessage*)  tolua_tousertype(tolua_S,1,0);
00318 #ifndef TOLUA_RELEASE
00319   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
00320 #endif
00321   delete self;
00322  }
00323  return 0;
00324 #ifndef TOLUA_RELEASE
00325  tolua_lerror:
00326  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
00327  return 0;
00328 #endif
00329 }
00330 #endif //#ifndef TOLUA_DISABLE
00331 
00332 /* method: motor_state of class  SetMotorStateMessage */
00333 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_SetMotorStateMessage_motor_state00
00334 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_SetMotorStateMessage_motor_state00(lua_State* tolua_S)
00335 {
00336 #ifndef TOLUA_RELEASE
00337  tolua_Error tolua_err;
00338  if (
00339      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface::SetMotorStateMessage",0,&tolua_err) ||
00340      !tolua_isnoobj(tolua_S,2,&tolua_err)
00341  )
00342   goto tolua_lerror;
00343  else
00344 #endif
00345  {
00346   fawkes::MotorInterface::SetMotorStateMessage* self = (fawkes::MotorInterface::SetMotorStateMessage*)  tolua_tousertype(tolua_S,1,0);
00347 #ifndef TOLUA_RELEASE
00348   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'motor_state'",NULL);
00349 #endif
00350   {
00351    unsigned int tolua_ret = (unsigned int)  self->motor_state();
00352    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00353   }
00354  }
00355  return 1;
00356 #ifndef TOLUA_RELEASE
00357  tolua_lerror:
00358  tolua_error(tolua_S,"#ferror in function 'motor_state'.",&tolua_err);
00359  return 0;
00360 #endif
00361 }
00362 #endif //#ifndef TOLUA_DISABLE
00363 
00364 /* method: set_motor_state of class  SetMotorStateMessage */
00365 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_SetMotorStateMessage_set_motor_state00
00366 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_SetMotorStateMessage_set_motor_state00(lua_State* tolua_S)
00367 {
00368 #ifndef TOLUA_RELEASE
00369  tolua_Error tolua_err;
00370  if (
00371      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface::SetMotorStateMessage",0,&tolua_err) ||
00372      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00373      !tolua_isnoobj(tolua_S,3,&tolua_err)
00374  )
00375   goto tolua_lerror;
00376  else
00377 #endif
00378  {
00379   fawkes::MotorInterface::SetMotorStateMessage* self = (fawkes::MotorInterface::SetMotorStateMessage*)  tolua_tousertype(tolua_S,1,0);
00380   unsigned const int new_motor_state = ((unsigned const int)  tolua_tonumber(tolua_S,2,0));
00381 #ifndef TOLUA_RELEASE
00382   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_motor_state'",NULL);
00383 #endif
00384   {
00385    self->set_motor_state(new_motor_state);
00386   }
00387  }
00388  return 0;
00389 #ifndef TOLUA_RELEASE
00390  tolua_lerror:
00391  tolua_error(tolua_S,"#ferror in function 'set_motor_state'.",&tolua_err);
00392  return 0;
00393 #endif
00394 }
00395 #endif //#ifndef TOLUA_DISABLE
00396 
00397 /* method: maxlenof_motor_state of class  SetMotorStateMessage */
00398 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_SetMotorStateMessage_maxlenof_motor_state00
00399 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_SetMotorStateMessage_maxlenof_motor_state00(lua_State* tolua_S)
00400 {
00401 #ifndef TOLUA_RELEASE
00402  tolua_Error tolua_err;
00403  if (
00404      !tolua_isusertype(tolua_S,1,"const fawkes::MotorInterface::SetMotorStateMessage",0,&tolua_err) ||
00405      !tolua_isnoobj(tolua_S,2,&tolua_err)
00406  )
00407   goto tolua_lerror;
00408  else
00409 #endif
00410  {
00411   const fawkes::MotorInterface::SetMotorStateMessage* self = (const fawkes::MotorInterface::SetMotorStateMessage*)  tolua_tousertype(tolua_S,1,0);
00412 #ifndef TOLUA_RELEASE
00413   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_motor_state'",NULL);
00414 #endif
00415   {
00416    int tolua_ret = (int)  self->maxlenof_motor_state();
00417    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00418   }
00419  }
00420  return 1;
00421 #ifndef TOLUA_RELEASE
00422  tolua_lerror:
00423  tolua_error(tolua_S,"#ferror in function 'maxlenof_motor_state'.",&tolua_err);
00424  return 0;
00425 #endif
00426 }
00427 #endif //#ifndef TOLUA_DISABLE
00428 
00429 /* method: new of class  AcquireControlMessage */
00430 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_AcquireControlMessage_new00
00431 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_AcquireControlMessage_new00(lua_State* tolua_S)
00432 {
00433 #ifndef TOLUA_RELEASE
00434  tolua_Error tolua_err;
00435  if (
00436      !tolua_isusertable(tolua_S,1,"fawkes::MotorInterface::AcquireControlMessage",0,&tolua_err) ||
00437      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00438      !tolua_isstring(tolua_S,3,0,&tolua_err) ||
00439      !tolua_isnoobj(tolua_S,4,&tolua_err)
00440  )
00441   goto tolua_lerror;
00442  else
00443 #endif
00444  {
00445   unsigned int ini_controller = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
00446   char* ini_controller_thread_name = ((char*)  tolua_tostring(tolua_S,3,0));
00447   {
00448    fawkes::MotorInterface::AcquireControlMessage* tolua_ret = (fawkes::MotorInterface::AcquireControlMessage*)  new fawkes::MotorInterface::AcquireControlMessage(ini_controller,ini_controller_thread_name);
00449    tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::MotorInterface::AcquireControlMessage");
00450   }
00451  }
00452  return 1;
00453 #ifndef TOLUA_RELEASE
00454  tolua_lerror:
00455  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00456  return 0;
00457 #endif
00458 }
00459 #endif //#ifndef TOLUA_DISABLE
00460 
00461 /* method: new_local of class  AcquireControlMessage */
00462 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_AcquireControlMessage_new00_local
00463 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_AcquireControlMessage_new00_local(lua_State* tolua_S)
00464 {
00465 #ifndef TOLUA_RELEASE
00466  tolua_Error tolua_err;
00467  if (
00468      !tolua_isusertable(tolua_S,1,"fawkes::MotorInterface::AcquireControlMessage",0,&tolua_err) ||
00469      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00470      !tolua_isstring(tolua_S,3,0,&tolua_err) ||
00471      !tolua_isnoobj(tolua_S,4,&tolua_err)
00472  )
00473   goto tolua_lerror;
00474  else
00475 #endif
00476  {
00477   unsigned int ini_controller = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
00478   char* ini_controller_thread_name = ((char*)  tolua_tostring(tolua_S,3,0));
00479   {
00480    fawkes::MotorInterface::AcquireControlMessage* tolua_ret = (fawkes::MotorInterface::AcquireControlMessage*)  new fawkes::MotorInterface::AcquireControlMessage(ini_controller,ini_controller_thread_name);
00481    tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"fawkes::MotorInterface::AcquireControlMessage");
00482   }
00483  }
00484  return 1;
00485 #ifndef TOLUA_RELEASE
00486  tolua_lerror:
00487  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00488  return 0;
00489 #endif
00490 }
00491 #endif //#ifndef TOLUA_DISABLE
00492 
00493 /* method: new of class  AcquireControlMessage */
00494 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_AcquireControlMessage_new01
00495 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_AcquireControlMessage_new01(lua_State* tolua_S)
00496 {
00497  tolua_Error tolua_err;
00498  if (
00499      !tolua_isusertable(tolua_S,1,"fawkes::MotorInterface::AcquireControlMessage",0,&tolua_err) ||
00500      !tolua_isnoobj(tolua_S,2,&tolua_err)
00501  )
00502   goto tolua_lerror;
00503  else
00504  {
00505   {
00506    fawkes::MotorInterface::AcquireControlMessage* tolua_ret = (fawkes::MotorInterface::AcquireControlMessage*)  new fawkes::MotorInterface::AcquireControlMessage();
00507    tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::MotorInterface::AcquireControlMessage");
00508   }
00509  }
00510  return 1;
00511 tolua_lerror:
00512  return tolua_interfaces_MotorInterface_fawkes_MotorInterface_AcquireControlMessage_new00(tolua_S);
00513 }
00514 #endif //#ifndef TOLUA_DISABLE
00515 
00516 /* method: new_local of class  AcquireControlMessage */
00517 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_AcquireControlMessage_new01_local
00518 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_AcquireControlMessage_new01_local(lua_State* tolua_S)
00519 {
00520  tolua_Error tolua_err;
00521  if (
00522      !tolua_isusertable(tolua_S,1,"fawkes::MotorInterface::AcquireControlMessage",0,&tolua_err) ||
00523      !tolua_isnoobj(tolua_S,2,&tolua_err)
00524  )
00525   goto tolua_lerror;
00526  else
00527  {
00528   {
00529    fawkes::MotorInterface::AcquireControlMessage* tolua_ret = (fawkes::MotorInterface::AcquireControlMessage*)  new fawkes::MotorInterface::AcquireControlMessage();
00530    tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"fawkes::MotorInterface::AcquireControlMessage");
00531   }
00532  }
00533  return 1;
00534 tolua_lerror:
00535  return tolua_interfaces_MotorInterface_fawkes_MotorInterface_AcquireControlMessage_new00_local(tolua_S);
00536 }
00537 #endif //#ifndef TOLUA_DISABLE
00538 
00539 /* method: delete of class  AcquireControlMessage */
00540 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_AcquireControlMessage_delete00
00541 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_AcquireControlMessage_delete00(lua_State* tolua_S)
00542 {
00543 #ifndef TOLUA_RELEASE
00544  tolua_Error tolua_err;
00545  if (
00546      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface::AcquireControlMessage",0,&tolua_err) ||
00547      !tolua_isnoobj(tolua_S,2,&tolua_err)
00548  )
00549   goto tolua_lerror;
00550  else
00551 #endif
00552  {
00553   fawkes::MotorInterface::AcquireControlMessage* self = (fawkes::MotorInterface::AcquireControlMessage*)  tolua_tousertype(tolua_S,1,0);
00554 #ifndef TOLUA_RELEASE
00555   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
00556 #endif
00557   delete self;
00558  }
00559  return 0;
00560 #ifndef TOLUA_RELEASE
00561  tolua_lerror:
00562  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
00563  return 0;
00564 #endif
00565 }
00566 #endif //#ifndef TOLUA_DISABLE
00567 
00568 /* method: controller of class  AcquireControlMessage */
00569 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_AcquireControlMessage_controller00
00570 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_AcquireControlMessage_controller00(lua_State* tolua_S)
00571 {
00572 #ifndef TOLUA_RELEASE
00573  tolua_Error tolua_err;
00574  if (
00575      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface::AcquireControlMessage",0,&tolua_err) ||
00576      !tolua_isnoobj(tolua_S,2,&tolua_err)
00577  )
00578   goto tolua_lerror;
00579  else
00580 #endif
00581  {
00582   fawkes::MotorInterface::AcquireControlMessage* self = (fawkes::MotorInterface::AcquireControlMessage*)  tolua_tousertype(tolua_S,1,0);
00583 #ifndef TOLUA_RELEASE
00584   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'controller'",NULL);
00585 #endif
00586   {
00587    unsigned int tolua_ret = (unsigned int)  self->controller();
00588    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00589   }
00590  }
00591  return 1;
00592 #ifndef TOLUA_RELEASE
00593  tolua_lerror:
00594  tolua_error(tolua_S,"#ferror in function 'controller'.",&tolua_err);
00595  return 0;
00596 #endif
00597 }
00598 #endif //#ifndef TOLUA_DISABLE
00599 
00600 /* method: set_controller of class  AcquireControlMessage */
00601 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_AcquireControlMessage_set_controller00
00602 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_AcquireControlMessage_set_controller00(lua_State* tolua_S)
00603 {
00604 #ifndef TOLUA_RELEASE
00605  tolua_Error tolua_err;
00606  if (
00607      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface::AcquireControlMessage",0,&tolua_err) ||
00608      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00609      !tolua_isnoobj(tolua_S,3,&tolua_err)
00610  )
00611   goto tolua_lerror;
00612  else
00613 #endif
00614  {
00615   fawkes::MotorInterface::AcquireControlMessage* self = (fawkes::MotorInterface::AcquireControlMessage*)  tolua_tousertype(tolua_S,1,0);
00616   unsigned const int new_controller = ((unsigned const int)  tolua_tonumber(tolua_S,2,0));
00617 #ifndef TOLUA_RELEASE
00618   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_controller'",NULL);
00619 #endif
00620   {
00621    self->set_controller(new_controller);
00622   }
00623  }
00624  return 0;
00625 #ifndef TOLUA_RELEASE
00626  tolua_lerror:
00627  tolua_error(tolua_S,"#ferror in function 'set_controller'.",&tolua_err);
00628  return 0;
00629 #endif
00630 }
00631 #endif //#ifndef TOLUA_DISABLE
00632 
00633 /* method: maxlenof_controller of class  AcquireControlMessage */
00634 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_AcquireControlMessage_maxlenof_controller00
00635 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_AcquireControlMessage_maxlenof_controller00(lua_State* tolua_S)
00636 {
00637 #ifndef TOLUA_RELEASE
00638  tolua_Error tolua_err;
00639  if (
00640      !tolua_isusertype(tolua_S,1,"const fawkes::MotorInterface::AcquireControlMessage",0,&tolua_err) ||
00641      !tolua_isnoobj(tolua_S,2,&tolua_err)
00642  )
00643   goto tolua_lerror;
00644  else
00645 #endif
00646  {
00647   const fawkes::MotorInterface::AcquireControlMessage* self = (const fawkes::MotorInterface::AcquireControlMessage*)  tolua_tousertype(tolua_S,1,0);
00648 #ifndef TOLUA_RELEASE
00649   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_controller'",NULL);
00650 #endif
00651   {
00652    int tolua_ret = (int)  self->maxlenof_controller();
00653    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00654   }
00655  }
00656  return 1;
00657 #ifndef TOLUA_RELEASE
00658  tolua_lerror:
00659  tolua_error(tolua_S,"#ferror in function 'maxlenof_controller'.",&tolua_err);
00660  return 0;
00661 #endif
00662 }
00663 #endif //#ifndef TOLUA_DISABLE
00664 
00665 /* method: controller_thread_name of class  AcquireControlMessage */
00666 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_AcquireControlMessage_controller_thread_name00
00667 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_AcquireControlMessage_controller_thread_name00(lua_State* tolua_S)
00668 {
00669 #ifndef TOLUA_RELEASE
00670  tolua_Error tolua_err;
00671  if (
00672      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface::AcquireControlMessage",0,&tolua_err) ||
00673      !tolua_isnoobj(tolua_S,2,&tolua_err)
00674  )
00675   goto tolua_lerror;
00676  else
00677 #endif
00678  {
00679   fawkes::MotorInterface::AcquireControlMessage* self = (fawkes::MotorInterface::AcquireControlMessage*)  tolua_tousertype(tolua_S,1,0);
00680 #ifndef TOLUA_RELEASE
00681   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'controller_thread_name'",NULL);
00682 #endif
00683   {
00684    char* tolua_ret = (char*)  self->controller_thread_name();
00685    tolua_pushstring(tolua_S,(const char*)tolua_ret);
00686   }
00687  }
00688  return 1;
00689 #ifndef TOLUA_RELEASE
00690  tolua_lerror:
00691  tolua_error(tolua_S,"#ferror in function 'controller_thread_name'.",&tolua_err);
00692  return 0;
00693 #endif
00694 }
00695 #endif //#ifndef TOLUA_DISABLE
00696 
00697 /* method: set_controller_thread_name of class  AcquireControlMessage */
00698 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_AcquireControlMessage_set_controller_thread_name00
00699 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_AcquireControlMessage_set_controller_thread_name00(lua_State* tolua_S)
00700 {
00701 #ifndef TOLUA_RELEASE
00702  tolua_Error tolua_err;
00703  if (
00704      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface::AcquireControlMessage",0,&tolua_err) ||
00705      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
00706      !tolua_isnoobj(tolua_S,3,&tolua_err)
00707  )
00708   goto tolua_lerror;
00709  else
00710 #endif
00711  {
00712   fawkes::MotorInterface::AcquireControlMessage* self = (fawkes::MotorInterface::AcquireControlMessage*)  tolua_tousertype(tolua_S,1,0);
00713   const char* new_controller_thread_name = ((const char*)  tolua_tostring(tolua_S,2,0));
00714 #ifndef TOLUA_RELEASE
00715   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_controller_thread_name'",NULL);
00716 #endif
00717   {
00718    self->set_controller_thread_name(new_controller_thread_name);
00719   }
00720  }
00721  return 0;
00722 #ifndef TOLUA_RELEASE
00723  tolua_lerror:
00724  tolua_error(tolua_S,"#ferror in function 'set_controller_thread_name'.",&tolua_err);
00725  return 0;
00726 #endif
00727 }
00728 #endif //#ifndef TOLUA_DISABLE
00729 
00730 /* method: maxlenof_controller_thread_name of class  AcquireControlMessage */
00731 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_AcquireControlMessage_maxlenof_controller_thread_name00
00732 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_AcquireControlMessage_maxlenof_controller_thread_name00(lua_State* tolua_S)
00733 {
00734 #ifndef TOLUA_RELEASE
00735  tolua_Error tolua_err;
00736  if (
00737      !tolua_isusertype(tolua_S,1,"const fawkes::MotorInterface::AcquireControlMessage",0,&tolua_err) ||
00738      !tolua_isnoobj(tolua_S,2,&tolua_err)
00739  )
00740   goto tolua_lerror;
00741  else
00742 #endif
00743  {
00744   const fawkes::MotorInterface::AcquireControlMessage* self = (const fawkes::MotorInterface::AcquireControlMessage*)  tolua_tousertype(tolua_S,1,0);
00745 #ifndef TOLUA_RELEASE
00746   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_controller_thread_name'",NULL);
00747 #endif
00748   {
00749    int tolua_ret = (int)  self->maxlenof_controller_thread_name();
00750    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00751   }
00752  }
00753  return 1;
00754 #ifndef TOLUA_RELEASE
00755  tolua_lerror:
00756  tolua_error(tolua_S,"#ferror in function 'maxlenof_controller_thread_name'.",&tolua_err);
00757  return 0;
00758 #endif
00759 }
00760 #endif //#ifndef TOLUA_DISABLE
00761 
00762 /* method: new of class  ResetOdometryMessage */
00763 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_ResetOdometryMessage_new00
00764 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_ResetOdometryMessage_new00(lua_State* tolua_S)
00765 {
00766 #ifndef TOLUA_RELEASE
00767  tolua_Error tolua_err;
00768  if (
00769      !tolua_isusertable(tolua_S,1,"fawkes::MotorInterface::ResetOdometryMessage",0,&tolua_err) ||
00770      !tolua_isnoobj(tolua_S,2,&tolua_err)
00771  )
00772   goto tolua_lerror;
00773  else
00774 #endif
00775  {
00776   {
00777    fawkes::MotorInterface::ResetOdometryMessage* tolua_ret = (fawkes::MotorInterface::ResetOdometryMessage*)  new fawkes::MotorInterface::ResetOdometryMessage();
00778    tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::MotorInterface::ResetOdometryMessage");
00779   }
00780  }
00781  return 1;
00782 #ifndef TOLUA_RELEASE
00783  tolua_lerror:
00784  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00785  return 0;
00786 #endif
00787 }
00788 #endif //#ifndef TOLUA_DISABLE
00789 
00790 /* method: new_local of class  ResetOdometryMessage */
00791 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_ResetOdometryMessage_new00_local
00792 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_ResetOdometryMessage_new00_local(lua_State* tolua_S)
00793 {
00794 #ifndef TOLUA_RELEASE
00795  tolua_Error tolua_err;
00796  if (
00797      !tolua_isusertable(tolua_S,1,"fawkes::MotorInterface::ResetOdometryMessage",0,&tolua_err) ||
00798      !tolua_isnoobj(tolua_S,2,&tolua_err)
00799  )
00800   goto tolua_lerror;
00801  else
00802 #endif
00803  {
00804   {
00805    fawkes::MotorInterface::ResetOdometryMessage* tolua_ret = (fawkes::MotorInterface::ResetOdometryMessage*)  new fawkes::MotorInterface::ResetOdometryMessage();
00806    tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"fawkes::MotorInterface::ResetOdometryMessage");
00807   }
00808  }
00809  return 1;
00810 #ifndef TOLUA_RELEASE
00811  tolua_lerror:
00812  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00813  return 0;
00814 #endif
00815 }
00816 #endif //#ifndef TOLUA_DISABLE
00817 
00818 /* method: delete of class  ResetOdometryMessage */
00819 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_ResetOdometryMessage_delete00
00820 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_ResetOdometryMessage_delete00(lua_State* tolua_S)
00821 {
00822 #ifndef TOLUA_RELEASE
00823  tolua_Error tolua_err;
00824  if (
00825      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface::ResetOdometryMessage",0,&tolua_err) ||
00826      !tolua_isnoobj(tolua_S,2,&tolua_err)
00827  )
00828   goto tolua_lerror;
00829  else
00830 #endif
00831  {
00832   fawkes::MotorInterface::ResetOdometryMessage* self = (fawkes::MotorInterface::ResetOdometryMessage*)  tolua_tousertype(tolua_S,1,0);
00833 #ifndef TOLUA_RELEASE
00834   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
00835 #endif
00836   delete self;
00837  }
00838  return 0;
00839 #ifndef TOLUA_RELEASE
00840  tolua_lerror:
00841  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
00842  return 0;
00843 #endif
00844 }
00845 #endif //#ifndef TOLUA_DISABLE
00846 
00847 /* method: new of class  DriveRPMMessage */
00848 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_DriveRPMMessage_new00
00849 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_DriveRPMMessage_new00(lua_State* tolua_S)
00850 {
00851 #ifndef TOLUA_RELEASE
00852  tolua_Error tolua_err;
00853  if (
00854      !tolua_isusertable(tolua_S,1,"fawkes::MotorInterface::DriveRPMMessage",0,&tolua_err) ||
00855      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00856      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
00857      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
00858      !tolua_isnoobj(tolua_S,5,&tolua_err)
00859  )
00860   goto tolua_lerror;
00861  else
00862 #endif
00863  {
00864   float ini_front_right = ((float)  tolua_tonumber(tolua_S,2,0));
00865   float ini_front_left = ((float)  tolua_tonumber(tolua_S,3,0));
00866   float ini_rear = ((float)  tolua_tonumber(tolua_S,4,0));
00867   {
00868    fawkes::MotorInterface::DriveRPMMessage* tolua_ret = (fawkes::MotorInterface::DriveRPMMessage*)  new fawkes::MotorInterface::DriveRPMMessage(ini_front_right,ini_front_left,ini_rear);
00869    tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::MotorInterface::DriveRPMMessage");
00870   }
00871  }
00872  return 1;
00873 #ifndef TOLUA_RELEASE
00874  tolua_lerror:
00875  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00876  return 0;
00877 #endif
00878 }
00879 #endif //#ifndef TOLUA_DISABLE
00880 
00881 /* method: new_local of class  DriveRPMMessage */
00882 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_DriveRPMMessage_new00_local
00883 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_DriveRPMMessage_new00_local(lua_State* tolua_S)
00884 {
00885 #ifndef TOLUA_RELEASE
00886  tolua_Error tolua_err;
00887  if (
00888      !tolua_isusertable(tolua_S,1,"fawkes::MotorInterface::DriveRPMMessage",0,&tolua_err) ||
00889      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00890      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
00891      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
00892      !tolua_isnoobj(tolua_S,5,&tolua_err)
00893  )
00894   goto tolua_lerror;
00895  else
00896 #endif
00897  {
00898   float ini_front_right = ((float)  tolua_tonumber(tolua_S,2,0));
00899   float ini_front_left = ((float)  tolua_tonumber(tolua_S,3,0));
00900   float ini_rear = ((float)  tolua_tonumber(tolua_S,4,0));
00901   {
00902    fawkes::MotorInterface::DriveRPMMessage* tolua_ret = (fawkes::MotorInterface::DriveRPMMessage*)  new fawkes::MotorInterface::DriveRPMMessage(ini_front_right,ini_front_left,ini_rear);
00903    tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"fawkes::MotorInterface::DriveRPMMessage");
00904   }
00905  }
00906  return 1;
00907 #ifndef TOLUA_RELEASE
00908  tolua_lerror:
00909  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00910  return 0;
00911 #endif
00912 }
00913 #endif //#ifndef TOLUA_DISABLE
00914 
00915 /* method: new of class  DriveRPMMessage */
00916 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_DriveRPMMessage_new01
00917 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_DriveRPMMessage_new01(lua_State* tolua_S)
00918 {
00919  tolua_Error tolua_err;
00920  if (
00921      !tolua_isusertable(tolua_S,1,"fawkes::MotorInterface::DriveRPMMessage",0,&tolua_err) ||
00922      !tolua_isnoobj(tolua_S,2,&tolua_err)
00923  )
00924   goto tolua_lerror;
00925  else
00926  {
00927   {
00928    fawkes::MotorInterface::DriveRPMMessage* tolua_ret = (fawkes::MotorInterface::DriveRPMMessage*)  new fawkes::MotorInterface::DriveRPMMessage();
00929    tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::MotorInterface::DriveRPMMessage");
00930   }
00931  }
00932  return 1;
00933 tolua_lerror:
00934  return tolua_interfaces_MotorInterface_fawkes_MotorInterface_DriveRPMMessage_new00(tolua_S);
00935 }
00936 #endif //#ifndef TOLUA_DISABLE
00937 
00938 /* method: new_local of class  DriveRPMMessage */
00939 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_DriveRPMMessage_new01_local
00940 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_DriveRPMMessage_new01_local(lua_State* tolua_S)
00941 {
00942  tolua_Error tolua_err;
00943  if (
00944      !tolua_isusertable(tolua_S,1,"fawkes::MotorInterface::DriveRPMMessage",0,&tolua_err) ||
00945      !tolua_isnoobj(tolua_S,2,&tolua_err)
00946  )
00947   goto tolua_lerror;
00948  else
00949  {
00950   {
00951    fawkes::MotorInterface::DriveRPMMessage* tolua_ret = (fawkes::MotorInterface::DriveRPMMessage*)  new fawkes::MotorInterface::DriveRPMMessage();
00952    tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"fawkes::MotorInterface::DriveRPMMessage");
00953   }
00954  }
00955  return 1;
00956 tolua_lerror:
00957  return tolua_interfaces_MotorInterface_fawkes_MotorInterface_DriveRPMMessage_new00_local(tolua_S);
00958 }
00959 #endif //#ifndef TOLUA_DISABLE
00960 
00961 /* method: delete of class  DriveRPMMessage */
00962 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_DriveRPMMessage_delete00
00963 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_DriveRPMMessage_delete00(lua_State* tolua_S)
00964 {
00965 #ifndef TOLUA_RELEASE
00966  tolua_Error tolua_err;
00967  if (
00968      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface::DriveRPMMessage",0,&tolua_err) ||
00969      !tolua_isnoobj(tolua_S,2,&tolua_err)
00970  )
00971   goto tolua_lerror;
00972  else
00973 #endif
00974  {
00975   fawkes::MotorInterface::DriveRPMMessage* self = (fawkes::MotorInterface::DriveRPMMessage*)  tolua_tousertype(tolua_S,1,0);
00976 #ifndef TOLUA_RELEASE
00977   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
00978 #endif
00979   delete self;
00980  }
00981  return 0;
00982 #ifndef TOLUA_RELEASE
00983  tolua_lerror:
00984  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
00985  return 0;
00986 #endif
00987 }
00988 #endif //#ifndef TOLUA_DISABLE
00989 
00990 /* method: front_right of class  DriveRPMMessage */
00991 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_DriveRPMMessage_front_right00
00992 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_DriveRPMMessage_front_right00(lua_State* tolua_S)
00993 {
00994 #ifndef TOLUA_RELEASE
00995  tolua_Error tolua_err;
00996  if (
00997      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface::DriveRPMMessage",0,&tolua_err) ||
00998      !tolua_isnoobj(tolua_S,2,&tolua_err)
00999  )
01000   goto tolua_lerror;
01001  else
01002 #endif
01003  {
01004   fawkes::MotorInterface::DriveRPMMessage* self = (fawkes::MotorInterface::DriveRPMMessage*)  tolua_tousertype(tolua_S,1,0);
01005 #ifndef TOLUA_RELEASE
01006   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'front_right'",NULL);
01007 #endif
01008   {
01009    float tolua_ret = (float)  self->front_right();
01010    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01011   }
01012  }
01013  return 1;
01014 #ifndef TOLUA_RELEASE
01015  tolua_lerror:
01016  tolua_error(tolua_S,"#ferror in function 'front_right'.",&tolua_err);
01017  return 0;
01018 #endif
01019 }
01020 #endif //#ifndef TOLUA_DISABLE
01021 
01022 /* method: set_front_right of class  DriveRPMMessage */
01023 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_DriveRPMMessage_set_front_right00
01024 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_DriveRPMMessage_set_front_right00(lua_State* tolua_S)
01025 {
01026 #ifndef TOLUA_RELEASE
01027  tolua_Error tolua_err;
01028  if (
01029      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface::DriveRPMMessage",0,&tolua_err) ||
01030      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01031      !tolua_isnoobj(tolua_S,3,&tolua_err)
01032  )
01033   goto tolua_lerror;
01034  else
01035 #endif
01036  {
01037   fawkes::MotorInterface::DriveRPMMessage* self = (fawkes::MotorInterface::DriveRPMMessage*)  tolua_tousertype(tolua_S,1,0);
01038   const float new_front_right = ((const float)  tolua_tonumber(tolua_S,2,0));
01039 #ifndef TOLUA_RELEASE
01040   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_front_right'",NULL);
01041 #endif
01042   {
01043    self->set_front_right(new_front_right);
01044   }
01045  }
01046  return 0;
01047 #ifndef TOLUA_RELEASE
01048  tolua_lerror:
01049  tolua_error(tolua_S,"#ferror in function 'set_front_right'.",&tolua_err);
01050  return 0;
01051 #endif
01052 }
01053 #endif //#ifndef TOLUA_DISABLE
01054 
01055 /* method: maxlenof_front_right of class  DriveRPMMessage */
01056 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_DriveRPMMessage_maxlenof_front_right00
01057 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_DriveRPMMessage_maxlenof_front_right00(lua_State* tolua_S)
01058 {
01059 #ifndef TOLUA_RELEASE
01060  tolua_Error tolua_err;
01061  if (
01062      !tolua_isusertype(tolua_S,1,"const fawkes::MotorInterface::DriveRPMMessage",0,&tolua_err) ||
01063      !tolua_isnoobj(tolua_S,2,&tolua_err)
01064  )
01065   goto tolua_lerror;
01066  else
01067 #endif
01068  {
01069   const fawkes::MotorInterface::DriveRPMMessage* self = (const fawkes::MotorInterface::DriveRPMMessage*)  tolua_tousertype(tolua_S,1,0);
01070 #ifndef TOLUA_RELEASE
01071   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_front_right'",NULL);
01072 #endif
01073   {
01074    int tolua_ret = (int)  self->maxlenof_front_right();
01075    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01076   }
01077  }
01078  return 1;
01079 #ifndef TOLUA_RELEASE
01080  tolua_lerror:
01081  tolua_error(tolua_S,"#ferror in function 'maxlenof_front_right'.",&tolua_err);
01082  return 0;
01083 #endif
01084 }
01085 #endif //#ifndef TOLUA_DISABLE
01086 
01087 /* method: front_left of class  DriveRPMMessage */
01088 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_DriveRPMMessage_front_left00
01089 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_DriveRPMMessage_front_left00(lua_State* tolua_S)
01090 {
01091 #ifndef TOLUA_RELEASE
01092  tolua_Error tolua_err;
01093  if (
01094      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface::DriveRPMMessage",0,&tolua_err) ||
01095      !tolua_isnoobj(tolua_S,2,&tolua_err)
01096  )
01097   goto tolua_lerror;
01098  else
01099 #endif
01100  {
01101   fawkes::MotorInterface::DriveRPMMessage* self = (fawkes::MotorInterface::DriveRPMMessage*)  tolua_tousertype(tolua_S,1,0);
01102 #ifndef TOLUA_RELEASE
01103   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'front_left'",NULL);
01104 #endif
01105   {
01106    float tolua_ret = (float)  self->front_left();
01107    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01108   }
01109  }
01110  return 1;
01111 #ifndef TOLUA_RELEASE
01112  tolua_lerror:
01113  tolua_error(tolua_S,"#ferror in function 'front_left'.",&tolua_err);
01114  return 0;
01115 #endif
01116 }
01117 #endif //#ifndef TOLUA_DISABLE
01118 
01119 /* method: set_front_left of class  DriveRPMMessage */
01120 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_DriveRPMMessage_set_front_left00
01121 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_DriveRPMMessage_set_front_left00(lua_State* tolua_S)
01122 {
01123 #ifndef TOLUA_RELEASE
01124  tolua_Error tolua_err;
01125  if (
01126      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface::DriveRPMMessage",0,&tolua_err) ||
01127      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01128      !tolua_isnoobj(tolua_S,3,&tolua_err)
01129  )
01130   goto tolua_lerror;
01131  else
01132 #endif
01133  {
01134   fawkes::MotorInterface::DriveRPMMessage* self = (fawkes::MotorInterface::DriveRPMMessage*)  tolua_tousertype(tolua_S,1,0);
01135   const float new_front_left = ((const float)  tolua_tonumber(tolua_S,2,0));
01136 #ifndef TOLUA_RELEASE
01137   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_front_left'",NULL);
01138 #endif
01139   {
01140    self->set_front_left(new_front_left);
01141   }
01142  }
01143  return 0;
01144 #ifndef TOLUA_RELEASE
01145  tolua_lerror:
01146  tolua_error(tolua_S,"#ferror in function 'set_front_left'.",&tolua_err);
01147  return 0;
01148 #endif
01149 }
01150 #endif //#ifndef TOLUA_DISABLE
01151 
01152 /* method: maxlenof_front_left of class  DriveRPMMessage */
01153 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_DriveRPMMessage_maxlenof_front_left00
01154 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_DriveRPMMessage_maxlenof_front_left00(lua_State* tolua_S)
01155 {
01156 #ifndef TOLUA_RELEASE
01157  tolua_Error tolua_err;
01158  if (
01159      !tolua_isusertype(tolua_S,1,"const fawkes::MotorInterface::DriveRPMMessage",0,&tolua_err) ||
01160      !tolua_isnoobj(tolua_S,2,&tolua_err)
01161  )
01162   goto tolua_lerror;
01163  else
01164 #endif
01165  {
01166   const fawkes::MotorInterface::DriveRPMMessage* self = (const fawkes::MotorInterface::DriveRPMMessage*)  tolua_tousertype(tolua_S,1,0);
01167 #ifndef TOLUA_RELEASE
01168   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_front_left'",NULL);
01169 #endif
01170   {
01171    int tolua_ret = (int)  self->maxlenof_front_left();
01172    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01173   }
01174  }
01175  return 1;
01176 #ifndef TOLUA_RELEASE
01177  tolua_lerror:
01178  tolua_error(tolua_S,"#ferror in function 'maxlenof_front_left'.",&tolua_err);
01179  return 0;
01180 #endif
01181 }
01182 #endif //#ifndef TOLUA_DISABLE
01183 
01184 /* method: rear of class  DriveRPMMessage */
01185 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_DriveRPMMessage_rear00
01186 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_DriveRPMMessage_rear00(lua_State* tolua_S)
01187 {
01188 #ifndef TOLUA_RELEASE
01189  tolua_Error tolua_err;
01190  if (
01191      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface::DriveRPMMessage",0,&tolua_err) ||
01192      !tolua_isnoobj(tolua_S,2,&tolua_err)
01193  )
01194   goto tolua_lerror;
01195  else
01196 #endif
01197  {
01198   fawkes::MotorInterface::DriveRPMMessage* self = (fawkes::MotorInterface::DriveRPMMessage*)  tolua_tousertype(tolua_S,1,0);
01199 #ifndef TOLUA_RELEASE
01200   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'rear'",NULL);
01201 #endif
01202   {
01203    float tolua_ret = (float)  self->rear();
01204    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01205   }
01206  }
01207  return 1;
01208 #ifndef TOLUA_RELEASE
01209  tolua_lerror:
01210  tolua_error(tolua_S,"#ferror in function 'rear'.",&tolua_err);
01211  return 0;
01212 #endif
01213 }
01214 #endif //#ifndef TOLUA_DISABLE
01215 
01216 /* method: set_rear of class  DriveRPMMessage */
01217 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_DriveRPMMessage_set_rear00
01218 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_DriveRPMMessage_set_rear00(lua_State* tolua_S)
01219 {
01220 #ifndef TOLUA_RELEASE
01221  tolua_Error tolua_err;
01222  if (
01223      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface::DriveRPMMessage",0,&tolua_err) ||
01224      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01225      !tolua_isnoobj(tolua_S,3,&tolua_err)
01226  )
01227   goto tolua_lerror;
01228  else
01229 #endif
01230  {
01231   fawkes::MotorInterface::DriveRPMMessage* self = (fawkes::MotorInterface::DriveRPMMessage*)  tolua_tousertype(tolua_S,1,0);
01232   const float new_rear = ((const float)  tolua_tonumber(tolua_S,2,0));
01233 #ifndef TOLUA_RELEASE
01234   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_rear'",NULL);
01235 #endif
01236   {
01237    self->set_rear(new_rear);
01238   }
01239  }
01240  return 0;
01241 #ifndef TOLUA_RELEASE
01242  tolua_lerror:
01243  tolua_error(tolua_S,"#ferror in function 'set_rear'.",&tolua_err);
01244  return 0;
01245 #endif
01246 }
01247 #endif //#ifndef TOLUA_DISABLE
01248 
01249 /* method: maxlenof_rear of class  DriveRPMMessage */
01250 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_DriveRPMMessage_maxlenof_rear00
01251 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_DriveRPMMessage_maxlenof_rear00(lua_State* tolua_S)
01252 {
01253 #ifndef TOLUA_RELEASE
01254  tolua_Error tolua_err;
01255  if (
01256      !tolua_isusertype(tolua_S,1,"const fawkes::MotorInterface::DriveRPMMessage",0,&tolua_err) ||
01257      !tolua_isnoobj(tolua_S,2,&tolua_err)
01258  )
01259   goto tolua_lerror;
01260  else
01261 #endif
01262  {
01263   const fawkes::MotorInterface::DriveRPMMessage* self = (const fawkes::MotorInterface::DriveRPMMessage*)  tolua_tousertype(tolua_S,1,0);
01264 #ifndef TOLUA_RELEASE
01265   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_rear'",NULL);
01266 #endif
01267   {
01268    int tolua_ret = (int)  self->maxlenof_rear();
01269    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01270   }
01271  }
01272  return 1;
01273 #ifndef TOLUA_RELEASE
01274  tolua_lerror:
01275  tolua_error(tolua_S,"#ferror in function 'maxlenof_rear'.",&tolua_err);
01276  return 0;
01277 #endif
01278 }
01279 #endif //#ifndef TOLUA_DISABLE
01280 
01281 /* method: new of class  GotoMessage */
01282 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_GotoMessage_new00
01283 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_GotoMessage_new00(lua_State* tolua_S)
01284 {
01285 #ifndef TOLUA_RELEASE
01286  tolua_Error tolua_err;
01287  if (
01288      !tolua_isusertable(tolua_S,1,"fawkes::MotorInterface::GotoMessage",0,&tolua_err) ||
01289      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01290      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
01291      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
01292      !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
01293      !tolua_isnoobj(tolua_S,6,&tolua_err)
01294  )
01295   goto tolua_lerror;
01296  else
01297 #endif
01298  {
01299   float ini_x = ((float)  tolua_tonumber(tolua_S,2,0));
01300   float ini_y = ((float)  tolua_tonumber(tolua_S,3,0));
01301   float ini_phi = ((float)  tolua_tonumber(tolua_S,4,0));
01302   float ini_time_sec = ((float)  tolua_tonumber(tolua_S,5,0));
01303   {
01304    fawkes::MotorInterface::GotoMessage* tolua_ret = (fawkes::MotorInterface::GotoMessage*)  new fawkes::MotorInterface::GotoMessage(ini_x,ini_y,ini_phi,ini_time_sec);
01305    tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::MotorInterface::GotoMessage");
01306   }
01307  }
01308  return 1;
01309 #ifndef TOLUA_RELEASE
01310  tolua_lerror:
01311  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
01312  return 0;
01313 #endif
01314 }
01315 #endif //#ifndef TOLUA_DISABLE
01316 
01317 /* method: new_local of class  GotoMessage */
01318 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_GotoMessage_new00_local
01319 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_GotoMessage_new00_local(lua_State* tolua_S)
01320 {
01321 #ifndef TOLUA_RELEASE
01322  tolua_Error tolua_err;
01323  if (
01324      !tolua_isusertable(tolua_S,1,"fawkes::MotorInterface::GotoMessage",0,&tolua_err) ||
01325      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01326      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
01327      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
01328      !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
01329      !tolua_isnoobj(tolua_S,6,&tolua_err)
01330  )
01331   goto tolua_lerror;
01332  else
01333 #endif
01334  {
01335   float ini_x = ((float)  tolua_tonumber(tolua_S,2,0));
01336   float ini_y = ((float)  tolua_tonumber(tolua_S,3,0));
01337   float ini_phi = ((float)  tolua_tonumber(tolua_S,4,0));
01338   float ini_time_sec = ((float)  tolua_tonumber(tolua_S,5,0));
01339   {
01340    fawkes::MotorInterface::GotoMessage* tolua_ret = (fawkes::MotorInterface::GotoMessage*)  new fawkes::MotorInterface::GotoMessage(ini_x,ini_y,ini_phi,ini_time_sec);
01341    tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"fawkes::MotorInterface::GotoMessage");
01342   }
01343  }
01344  return 1;
01345 #ifndef TOLUA_RELEASE
01346  tolua_lerror:
01347  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
01348  return 0;
01349 #endif
01350 }
01351 #endif //#ifndef TOLUA_DISABLE
01352 
01353 /* method: new of class  GotoMessage */
01354 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_GotoMessage_new01
01355 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_GotoMessage_new01(lua_State* tolua_S)
01356 {
01357  tolua_Error tolua_err;
01358  if (
01359      !tolua_isusertable(tolua_S,1,"fawkes::MotorInterface::GotoMessage",0,&tolua_err) ||
01360      !tolua_isnoobj(tolua_S,2,&tolua_err)
01361  )
01362   goto tolua_lerror;
01363  else
01364  {
01365   {
01366    fawkes::MotorInterface::GotoMessage* tolua_ret = (fawkes::MotorInterface::GotoMessage*)  new fawkes::MotorInterface::GotoMessage();
01367    tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::MotorInterface::GotoMessage");
01368   }
01369  }
01370  return 1;
01371 tolua_lerror:
01372  return tolua_interfaces_MotorInterface_fawkes_MotorInterface_GotoMessage_new00(tolua_S);
01373 }
01374 #endif //#ifndef TOLUA_DISABLE
01375 
01376 /* method: new_local of class  GotoMessage */
01377 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_GotoMessage_new01_local
01378 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_GotoMessage_new01_local(lua_State* tolua_S)
01379 {
01380  tolua_Error tolua_err;
01381  if (
01382      !tolua_isusertable(tolua_S,1,"fawkes::MotorInterface::GotoMessage",0,&tolua_err) ||
01383      !tolua_isnoobj(tolua_S,2,&tolua_err)
01384  )
01385   goto tolua_lerror;
01386  else
01387  {
01388   {
01389    fawkes::MotorInterface::GotoMessage* tolua_ret = (fawkes::MotorInterface::GotoMessage*)  new fawkes::MotorInterface::GotoMessage();
01390    tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"fawkes::MotorInterface::GotoMessage");
01391   }
01392  }
01393  return 1;
01394 tolua_lerror:
01395  return tolua_interfaces_MotorInterface_fawkes_MotorInterface_GotoMessage_new00_local(tolua_S);
01396 }
01397 #endif //#ifndef TOLUA_DISABLE
01398 
01399 /* method: delete of class  GotoMessage */
01400 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_GotoMessage_delete00
01401 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_GotoMessage_delete00(lua_State* tolua_S)
01402 {
01403 #ifndef TOLUA_RELEASE
01404  tolua_Error tolua_err;
01405  if (
01406      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface::GotoMessage",0,&tolua_err) ||
01407      !tolua_isnoobj(tolua_S,2,&tolua_err)
01408  )
01409   goto tolua_lerror;
01410  else
01411 #endif
01412  {
01413   fawkes::MotorInterface::GotoMessage* self = (fawkes::MotorInterface::GotoMessage*)  tolua_tousertype(tolua_S,1,0);
01414 #ifndef TOLUA_RELEASE
01415   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
01416 #endif
01417   delete self;
01418  }
01419  return 0;
01420 #ifndef TOLUA_RELEASE
01421  tolua_lerror:
01422  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
01423  return 0;
01424 #endif
01425 }
01426 #endif //#ifndef TOLUA_DISABLE
01427 
01428 /* method: x of class  GotoMessage */
01429 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_GotoMessage_x00
01430 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_GotoMessage_x00(lua_State* tolua_S)
01431 {
01432 #ifndef TOLUA_RELEASE
01433  tolua_Error tolua_err;
01434  if (
01435      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface::GotoMessage",0,&tolua_err) ||
01436      !tolua_isnoobj(tolua_S,2,&tolua_err)
01437  )
01438   goto tolua_lerror;
01439  else
01440 #endif
01441  {
01442   fawkes::MotorInterface::GotoMessage* self = (fawkes::MotorInterface::GotoMessage*)  tolua_tousertype(tolua_S,1,0);
01443 #ifndef TOLUA_RELEASE
01444   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'x'",NULL);
01445 #endif
01446   {
01447    float tolua_ret = (float)  self->x();
01448    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01449   }
01450  }
01451  return 1;
01452 #ifndef TOLUA_RELEASE
01453  tolua_lerror:
01454  tolua_error(tolua_S,"#ferror in function 'x'.",&tolua_err);
01455  return 0;
01456 #endif
01457 }
01458 #endif //#ifndef TOLUA_DISABLE
01459 
01460 /* method: set_x of class  GotoMessage */
01461 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_GotoMessage_set_x00
01462 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_GotoMessage_set_x00(lua_State* tolua_S)
01463 {
01464 #ifndef TOLUA_RELEASE
01465  tolua_Error tolua_err;
01466  if (
01467      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface::GotoMessage",0,&tolua_err) ||
01468      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01469      !tolua_isnoobj(tolua_S,3,&tolua_err)
01470  )
01471   goto tolua_lerror;
01472  else
01473 #endif
01474  {
01475   fawkes::MotorInterface::GotoMessage* self = (fawkes::MotorInterface::GotoMessage*)  tolua_tousertype(tolua_S,1,0);
01476   const float new_x = ((const float)  tolua_tonumber(tolua_S,2,0));
01477 #ifndef TOLUA_RELEASE
01478   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_x'",NULL);
01479 #endif
01480   {
01481    self->set_x(new_x);
01482   }
01483  }
01484  return 0;
01485 #ifndef TOLUA_RELEASE
01486  tolua_lerror:
01487  tolua_error(tolua_S,"#ferror in function 'set_x'.",&tolua_err);
01488  return 0;
01489 #endif
01490 }
01491 #endif //#ifndef TOLUA_DISABLE
01492 
01493 /* method: maxlenof_x of class  GotoMessage */
01494 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_GotoMessage_maxlenof_x00
01495 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_GotoMessage_maxlenof_x00(lua_State* tolua_S)
01496 {
01497 #ifndef TOLUA_RELEASE
01498  tolua_Error tolua_err;
01499  if (
01500      !tolua_isusertype(tolua_S,1,"const fawkes::MotorInterface::GotoMessage",0,&tolua_err) ||
01501      !tolua_isnoobj(tolua_S,2,&tolua_err)
01502  )
01503   goto tolua_lerror;
01504  else
01505 #endif
01506  {
01507   const fawkes::MotorInterface::GotoMessage* self = (const fawkes::MotorInterface::GotoMessage*)  tolua_tousertype(tolua_S,1,0);
01508 #ifndef TOLUA_RELEASE
01509   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_x'",NULL);
01510 #endif
01511   {
01512    int tolua_ret = (int)  self->maxlenof_x();
01513    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01514   }
01515  }
01516  return 1;
01517 #ifndef TOLUA_RELEASE
01518  tolua_lerror:
01519  tolua_error(tolua_S,"#ferror in function 'maxlenof_x'.",&tolua_err);
01520  return 0;
01521 #endif
01522 }
01523 #endif //#ifndef TOLUA_DISABLE
01524 
01525 /* method: y of class  GotoMessage */
01526 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_GotoMessage_y00
01527 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_GotoMessage_y00(lua_State* tolua_S)
01528 {
01529 #ifndef TOLUA_RELEASE
01530  tolua_Error tolua_err;
01531  if (
01532      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface::GotoMessage",0,&tolua_err) ||
01533      !tolua_isnoobj(tolua_S,2,&tolua_err)
01534  )
01535   goto tolua_lerror;
01536  else
01537 #endif
01538  {
01539   fawkes::MotorInterface::GotoMessage* self = (fawkes::MotorInterface::GotoMessage*)  tolua_tousertype(tolua_S,1,0);
01540 #ifndef TOLUA_RELEASE
01541   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'y'",NULL);
01542 #endif
01543   {
01544    float tolua_ret = (float)  self->y();
01545    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01546   }
01547  }
01548  return 1;
01549 #ifndef TOLUA_RELEASE
01550  tolua_lerror:
01551  tolua_error(tolua_S,"#ferror in function 'y'.",&tolua_err);
01552  return 0;
01553 #endif
01554 }
01555 #endif //#ifndef TOLUA_DISABLE
01556 
01557 /* method: set_y of class  GotoMessage */
01558 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_GotoMessage_set_y00
01559 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_GotoMessage_set_y00(lua_State* tolua_S)
01560 {
01561 #ifndef TOLUA_RELEASE
01562  tolua_Error tolua_err;
01563  if (
01564      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface::GotoMessage",0,&tolua_err) ||
01565      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01566      !tolua_isnoobj(tolua_S,3,&tolua_err)
01567  )
01568   goto tolua_lerror;
01569  else
01570 #endif
01571  {
01572   fawkes::MotorInterface::GotoMessage* self = (fawkes::MotorInterface::GotoMessage*)  tolua_tousertype(tolua_S,1,0);
01573   const float new_y = ((const float)  tolua_tonumber(tolua_S,2,0));
01574 #ifndef TOLUA_RELEASE
01575   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_y'",NULL);
01576 #endif
01577   {
01578    self->set_y(new_y);
01579   }
01580  }
01581  return 0;
01582 #ifndef TOLUA_RELEASE
01583  tolua_lerror:
01584  tolua_error(tolua_S,"#ferror in function 'set_y'.",&tolua_err);
01585  return 0;
01586 #endif
01587 }
01588 #endif //#ifndef TOLUA_DISABLE
01589 
01590 /* method: maxlenof_y of class  GotoMessage */
01591 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_GotoMessage_maxlenof_y00
01592 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_GotoMessage_maxlenof_y00(lua_State* tolua_S)
01593 {
01594 #ifndef TOLUA_RELEASE
01595  tolua_Error tolua_err;
01596  if (
01597      !tolua_isusertype(tolua_S,1,"const fawkes::MotorInterface::GotoMessage",0,&tolua_err) ||
01598      !tolua_isnoobj(tolua_S,2,&tolua_err)
01599  )
01600   goto tolua_lerror;
01601  else
01602 #endif
01603  {
01604   const fawkes::MotorInterface::GotoMessage* self = (const fawkes::MotorInterface::GotoMessage*)  tolua_tousertype(tolua_S,1,0);
01605 #ifndef TOLUA_RELEASE
01606   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_y'",NULL);
01607 #endif
01608   {
01609    int tolua_ret = (int)  self->maxlenof_y();
01610    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01611   }
01612  }
01613  return 1;
01614 #ifndef TOLUA_RELEASE
01615  tolua_lerror:
01616  tolua_error(tolua_S,"#ferror in function 'maxlenof_y'.",&tolua_err);
01617  return 0;
01618 #endif
01619 }
01620 #endif //#ifndef TOLUA_DISABLE
01621 
01622 /* method: phi of class  GotoMessage */
01623 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_GotoMessage_phi00
01624 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_GotoMessage_phi00(lua_State* tolua_S)
01625 {
01626 #ifndef TOLUA_RELEASE
01627  tolua_Error tolua_err;
01628  if (
01629      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface::GotoMessage",0,&tolua_err) ||
01630      !tolua_isnoobj(tolua_S,2,&tolua_err)
01631  )
01632   goto tolua_lerror;
01633  else
01634 #endif
01635  {
01636   fawkes::MotorInterface::GotoMessage* self = (fawkes::MotorInterface::GotoMessage*)  tolua_tousertype(tolua_S,1,0);
01637 #ifndef TOLUA_RELEASE
01638   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'phi'",NULL);
01639 #endif
01640   {
01641    float tolua_ret = (float)  self->phi();
01642    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01643   }
01644  }
01645  return 1;
01646 #ifndef TOLUA_RELEASE
01647  tolua_lerror:
01648  tolua_error(tolua_S,"#ferror in function 'phi'.",&tolua_err);
01649  return 0;
01650 #endif
01651 }
01652 #endif //#ifndef TOLUA_DISABLE
01653 
01654 /* method: set_phi of class  GotoMessage */
01655 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_GotoMessage_set_phi00
01656 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_GotoMessage_set_phi00(lua_State* tolua_S)
01657 {
01658 #ifndef TOLUA_RELEASE
01659  tolua_Error tolua_err;
01660  if (
01661      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface::GotoMessage",0,&tolua_err) ||
01662      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01663      !tolua_isnoobj(tolua_S,3,&tolua_err)
01664  )
01665   goto tolua_lerror;
01666  else
01667 #endif
01668  {
01669   fawkes::MotorInterface::GotoMessage* self = (fawkes::MotorInterface::GotoMessage*)  tolua_tousertype(tolua_S,1,0);
01670   const float new_phi = ((const float)  tolua_tonumber(tolua_S,2,0));
01671 #ifndef TOLUA_RELEASE
01672   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_phi'",NULL);
01673 #endif
01674   {
01675    self->set_phi(new_phi);
01676   }
01677  }
01678  return 0;
01679 #ifndef TOLUA_RELEASE
01680  tolua_lerror:
01681  tolua_error(tolua_S,"#ferror in function 'set_phi'.",&tolua_err);
01682  return 0;
01683 #endif
01684 }
01685 #endif //#ifndef TOLUA_DISABLE
01686 
01687 /* method: maxlenof_phi of class  GotoMessage */
01688 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_GotoMessage_maxlenof_phi00
01689 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_GotoMessage_maxlenof_phi00(lua_State* tolua_S)
01690 {
01691 #ifndef TOLUA_RELEASE
01692  tolua_Error tolua_err;
01693  if (
01694      !tolua_isusertype(tolua_S,1,"const fawkes::MotorInterface::GotoMessage",0,&tolua_err) ||
01695      !tolua_isnoobj(tolua_S,2,&tolua_err)
01696  )
01697   goto tolua_lerror;
01698  else
01699 #endif
01700  {
01701   const fawkes::MotorInterface::GotoMessage* self = (const fawkes::MotorInterface::GotoMessage*)  tolua_tousertype(tolua_S,1,0);
01702 #ifndef TOLUA_RELEASE
01703   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_phi'",NULL);
01704 #endif
01705   {
01706    int tolua_ret = (int)  self->maxlenof_phi();
01707    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01708   }
01709  }
01710  return 1;
01711 #ifndef TOLUA_RELEASE
01712  tolua_lerror:
01713  tolua_error(tolua_S,"#ferror in function 'maxlenof_phi'.",&tolua_err);
01714  return 0;
01715 #endif
01716 }
01717 #endif //#ifndef TOLUA_DISABLE
01718 
01719 /* method: time_sec of class  GotoMessage */
01720 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_GotoMessage_time_sec00
01721 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_GotoMessage_time_sec00(lua_State* tolua_S)
01722 {
01723 #ifndef TOLUA_RELEASE
01724  tolua_Error tolua_err;
01725  if (
01726      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface::GotoMessage",0,&tolua_err) ||
01727      !tolua_isnoobj(tolua_S,2,&tolua_err)
01728  )
01729   goto tolua_lerror;
01730  else
01731 #endif
01732  {
01733   fawkes::MotorInterface::GotoMessage* self = (fawkes::MotorInterface::GotoMessage*)  tolua_tousertype(tolua_S,1,0);
01734 #ifndef TOLUA_RELEASE
01735   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'time_sec'",NULL);
01736 #endif
01737   {
01738    float tolua_ret = (float)  self->time_sec();
01739    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01740   }
01741  }
01742  return 1;
01743 #ifndef TOLUA_RELEASE
01744  tolua_lerror:
01745  tolua_error(tolua_S,"#ferror in function 'time_sec'.",&tolua_err);
01746  return 0;
01747 #endif
01748 }
01749 #endif //#ifndef TOLUA_DISABLE
01750 
01751 /* method: set_time_sec of class  GotoMessage */
01752 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_GotoMessage_set_time_sec00
01753 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_GotoMessage_set_time_sec00(lua_State* tolua_S)
01754 {
01755 #ifndef TOLUA_RELEASE
01756  tolua_Error tolua_err;
01757  if (
01758      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface::GotoMessage",0,&tolua_err) ||
01759      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01760      !tolua_isnoobj(tolua_S,3,&tolua_err)
01761  )
01762   goto tolua_lerror;
01763  else
01764 #endif
01765  {
01766   fawkes::MotorInterface::GotoMessage* self = (fawkes::MotorInterface::GotoMessage*)  tolua_tousertype(tolua_S,1,0);
01767   const float new_time_sec = ((const float)  tolua_tonumber(tolua_S,2,0));
01768 #ifndef TOLUA_RELEASE
01769   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_time_sec'",NULL);
01770 #endif
01771   {
01772    self->set_time_sec(new_time_sec);
01773   }
01774  }
01775  return 0;
01776 #ifndef TOLUA_RELEASE
01777  tolua_lerror:
01778  tolua_error(tolua_S,"#ferror in function 'set_time_sec'.",&tolua_err);
01779  return 0;
01780 #endif
01781 }
01782 #endif //#ifndef TOLUA_DISABLE
01783 
01784 /* method: maxlenof_time_sec of class  GotoMessage */
01785 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_GotoMessage_maxlenof_time_sec00
01786 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_GotoMessage_maxlenof_time_sec00(lua_State* tolua_S)
01787 {
01788 #ifndef TOLUA_RELEASE
01789  tolua_Error tolua_err;
01790  if (
01791      !tolua_isusertype(tolua_S,1,"const fawkes::MotorInterface::GotoMessage",0,&tolua_err) ||
01792      !tolua_isnoobj(tolua_S,2,&tolua_err)
01793  )
01794   goto tolua_lerror;
01795  else
01796 #endif
01797  {
01798   const fawkes::MotorInterface::GotoMessage* self = (const fawkes::MotorInterface::GotoMessage*)  tolua_tousertype(tolua_S,1,0);
01799 #ifndef TOLUA_RELEASE
01800   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_time_sec'",NULL);
01801 #endif
01802   {
01803    int tolua_ret = (int)  self->maxlenof_time_sec();
01804    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01805   }
01806  }
01807  return 1;
01808 #ifndef TOLUA_RELEASE
01809  tolua_lerror:
01810  tolua_error(tolua_S,"#ferror in function 'maxlenof_time_sec'.",&tolua_err);
01811  return 0;
01812 #endif
01813 }
01814 #endif //#ifndef TOLUA_DISABLE
01815 
01816 /* method: new of class  TransMessage */
01817 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransMessage_new00
01818 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransMessage_new00(lua_State* tolua_S)
01819 {
01820 #ifndef TOLUA_RELEASE
01821  tolua_Error tolua_err;
01822  if (
01823      !tolua_isusertable(tolua_S,1,"fawkes::MotorInterface::TransMessage",0,&tolua_err) ||
01824      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01825      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
01826      !tolua_isnoobj(tolua_S,4,&tolua_err)
01827  )
01828   goto tolua_lerror;
01829  else
01830 #endif
01831  {
01832   float ini_vx = ((float)  tolua_tonumber(tolua_S,2,0));
01833   float ini_vy = ((float)  tolua_tonumber(tolua_S,3,0));
01834   {
01835    fawkes::MotorInterface::TransMessage* tolua_ret = (fawkes::MotorInterface::TransMessage*)  new fawkes::MotorInterface::TransMessage(ini_vx,ini_vy);
01836    tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::MotorInterface::TransMessage");
01837   }
01838  }
01839  return 1;
01840 #ifndef TOLUA_RELEASE
01841  tolua_lerror:
01842  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
01843  return 0;
01844 #endif
01845 }
01846 #endif //#ifndef TOLUA_DISABLE
01847 
01848 /* method: new_local of class  TransMessage */
01849 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransMessage_new00_local
01850 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransMessage_new00_local(lua_State* tolua_S)
01851 {
01852 #ifndef TOLUA_RELEASE
01853  tolua_Error tolua_err;
01854  if (
01855      !tolua_isusertable(tolua_S,1,"fawkes::MotorInterface::TransMessage",0,&tolua_err) ||
01856      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01857      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
01858      !tolua_isnoobj(tolua_S,4,&tolua_err)
01859  )
01860   goto tolua_lerror;
01861  else
01862 #endif
01863  {
01864   float ini_vx = ((float)  tolua_tonumber(tolua_S,2,0));
01865   float ini_vy = ((float)  tolua_tonumber(tolua_S,3,0));
01866   {
01867    fawkes::MotorInterface::TransMessage* tolua_ret = (fawkes::MotorInterface::TransMessage*)  new fawkes::MotorInterface::TransMessage(ini_vx,ini_vy);
01868    tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"fawkes::MotorInterface::TransMessage");
01869   }
01870  }
01871  return 1;
01872 #ifndef TOLUA_RELEASE
01873  tolua_lerror:
01874  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
01875  return 0;
01876 #endif
01877 }
01878 #endif //#ifndef TOLUA_DISABLE
01879 
01880 /* method: new of class  TransMessage */
01881 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransMessage_new01
01882 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransMessage_new01(lua_State* tolua_S)
01883 {
01884  tolua_Error tolua_err;
01885  if (
01886      !tolua_isusertable(tolua_S,1,"fawkes::MotorInterface::TransMessage",0,&tolua_err) ||
01887      !tolua_isnoobj(tolua_S,2,&tolua_err)
01888  )
01889   goto tolua_lerror;
01890  else
01891  {
01892   {
01893    fawkes::MotorInterface::TransMessage* tolua_ret = (fawkes::MotorInterface::TransMessage*)  new fawkes::MotorInterface::TransMessage();
01894    tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::MotorInterface::TransMessage");
01895   }
01896  }
01897  return 1;
01898 tolua_lerror:
01899  return tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransMessage_new00(tolua_S);
01900 }
01901 #endif //#ifndef TOLUA_DISABLE
01902 
01903 /* method: new_local of class  TransMessage */
01904 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransMessage_new01_local
01905 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransMessage_new01_local(lua_State* tolua_S)
01906 {
01907  tolua_Error tolua_err;
01908  if (
01909      !tolua_isusertable(tolua_S,1,"fawkes::MotorInterface::TransMessage",0,&tolua_err) ||
01910      !tolua_isnoobj(tolua_S,2,&tolua_err)
01911  )
01912   goto tolua_lerror;
01913  else
01914  {
01915   {
01916    fawkes::MotorInterface::TransMessage* tolua_ret = (fawkes::MotorInterface::TransMessage*)  new fawkes::MotorInterface::TransMessage();
01917    tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"fawkes::MotorInterface::TransMessage");
01918   }
01919  }
01920  return 1;
01921 tolua_lerror:
01922  return tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransMessage_new00_local(tolua_S);
01923 }
01924 #endif //#ifndef TOLUA_DISABLE
01925 
01926 /* method: delete of class  TransMessage */
01927 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransMessage_delete00
01928 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransMessage_delete00(lua_State* tolua_S)
01929 {
01930 #ifndef TOLUA_RELEASE
01931  tolua_Error tolua_err;
01932  if (
01933      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface::TransMessage",0,&tolua_err) ||
01934      !tolua_isnoobj(tolua_S,2,&tolua_err)
01935  )
01936   goto tolua_lerror;
01937  else
01938 #endif
01939  {
01940   fawkes::MotorInterface::TransMessage* self = (fawkes::MotorInterface::TransMessage*)  tolua_tousertype(tolua_S,1,0);
01941 #ifndef TOLUA_RELEASE
01942   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
01943 #endif
01944   delete self;
01945  }
01946  return 0;
01947 #ifndef TOLUA_RELEASE
01948  tolua_lerror:
01949  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
01950  return 0;
01951 #endif
01952 }
01953 #endif //#ifndef TOLUA_DISABLE
01954 
01955 /* method: vx of class  TransMessage */
01956 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransMessage_vx00
01957 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransMessage_vx00(lua_State* tolua_S)
01958 {
01959 #ifndef TOLUA_RELEASE
01960  tolua_Error tolua_err;
01961  if (
01962      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface::TransMessage",0,&tolua_err) ||
01963      !tolua_isnoobj(tolua_S,2,&tolua_err)
01964  )
01965   goto tolua_lerror;
01966  else
01967 #endif
01968  {
01969   fawkes::MotorInterface::TransMessage* self = (fawkes::MotorInterface::TransMessage*)  tolua_tousertype(tolua_S,1,0);
01970 #ifndef TOLUA_RELEASE
01971   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'vx'",NULL);
01972 #endif
01973   {
01974    float tolua_ret = (float)  self->vx();
01975    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01976   }
01977  }
01978  return 1;
01979 #ifndef TOLUA_RELEASE
01980  tolua_lerror:
01981  tolua_error(tolua_S,"#ferror in function 'vx'.",&tolua_err);
01982  return 0;
01983 #endif
01984 }
01985 #endif //#ifndef TOLUA_DISABLE
01986 
01987 /* method: set_vx of class  TransMessage */
01988 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransMessage_set_vx00
01989 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransMessage_set_vx00(lua_State* tolua_S)
01990 {
01991 #ifndef TOLUA_RELEASE
01992  tolua_Error tolua_err;
01993  if (
01994      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface::TransMessage",0,&tolua_err) ||
01995      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01996      !tolua_isnoobj(tolua_S,3,&tolua_err)
01997  )
01998   goto tolua_lerror;
01999  else
02000 #endif
02001  {
02002   fawkes::MotorInterface::TransMessage* self = (fawkes::MotorInterface::TransMessage*)  tolua_tousertype(tolua_S,1,0);
02003   const float new_vx = ((const float)  tolua_tonumber(tolua_S,2,0));
02004 #ifndef TOLUA_RELEASE
02005   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_vx'",NULL);
02006 #endif
02007   {
02008    self->set_vx(new_vx);
02009   }
02010  }
02011  return 0;
02012 #ifndef TOLUA_RELEASE
02013  tolua_lerror:
02014  tolua_error(tolua_S,"#ferror in function 'set_vx'.",&tolua_err);
02015  return 0;
02016 #endif
02017 }
02018 #endif //#ifndef TOLUA_DISABLE
02019 
02020 /* method: maxlenof_vx of class  TransMessage */
02021 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransMessage_maxlenof_vx00
02022 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransMessage_maxlenof_vx00(lua_State* tolua_S)
02023 {
02024 #ifndef TOLUA_RELEASE
02025  tolua_Error tolua_err;
02026  if (
02027      !tolua_isusertype(tolua_S,1,"const fawkes::MotorInterface::TransMessage",0,&tolua_err) ||
02028      !tolua_isnoobj(tolua_S,2,&tolua_err)
02029  )
02030   goto tolua_lerror;
02031  else
02032 #endif
02033  {
02034   const fawkes::MotorInterface::TransMessage* self = (const fawkes::MotorInterface::TransMessage*)  tolua_tousertype(tolua_S,1,0);
02035 #ifndef TOLUA_RELEASE
02036   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_vx'",NULL);
02037 #endif
02038   {
02039    int tolua_ret = (int)  self->maxlenof_vx();
02040    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02041   }
02042  }
02043  return 1;
02044 #ifndef TOLUA_RELEASE
02045  tolua_lerror:
02046  tolua_error(tolua_S,"#ferror in function 'maxlenof_vx'.",&tolua_err);
02047  return 0;
02048 #endif
02049 }
02050 #endif //#ifndef TOLUA_DISABLE
02051 
02052 /* method: vy of class  TransMessage */
02053 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransMessage_vy00
02054 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransMessage_vy00(lua_State* tolua_S)
02055 {
02056 #ifndef TOLUA_RELEASE
02057  tolua_Error tolua_err;
02058  if (
02059      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface::TransMessage",0,&tolua_err) ||
02060      !tolua_isnoobj(tolua_S,2,&tolua_err)
02061  )
02062   goto tolua_lerror;
02063  else
02064 #endif
02065  {
02066   fawkes::MotorInterface::TransMessage* self = (fawkes::MotorInterface::TransMessage*)  tolua_tousertype(tolua_S,1,0);
02067 #ifndef TOLUA_RELEASE
02068   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'vy'",NULL);
02069 #endif
02070   {
02071    float tolua_ret = (float)  self->vy();
02072    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02073   }
02074  }
02075  return 1;
02076 #ifndef TOLUA_RELEASE
02077  tolua_lerror:
02078  tolua_error(tolua_S,"#ferror in function 'vy'.",&tolua_err);
02079  return 0;
02080 #endif
02081 }
02082 #endif //#ifndef TOLUA_DISABLE
02083 
02084 /* method: set_vy of class  TransMessage */
02085 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransMessage_set_vy00
02086 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransMessage_set_vy00(lua_State* tolua_S)
02087 {
02088 #ifndef TOLUA_RELEASE
02089  tolua_Error tolua_err;
02090  if (
02091      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface::TransMessage",0,&tolua_err) ||
02092      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02093      !tolua_isnoobj(tolua_S,3,&tolua_err)
02094  )
02095   goto tolua_lerror;
02096  else
02097 #endif
02098  {
02099   fawkes::MotorInterface::TransMessage* self = (fawkes::MotorInterface::TransMessage*)  tolua_tousertype(tolua_S,1,0);
02100   const float new_vy = ((const float)  tolua_tonumber(tolua_S,2,0));
02101 #ifndef TOLUA_RELEASE
02102   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_vy'",NULL);
02103 #endif
02104   {
02105    self->set_vy(new_vy);
02106   }
02107  }
02108  return 0;
02109 #ifndef TOLUA_RELEASE
02110  tolua_lerror:
02111  tolua_error(tolua_S,"#ferror in function 'set_vy'.",&tolua_err);
02112  return 0;
02113 #endif
02114 }
02115 #endif //#ifndef TOLUA_DISABLE
02116 
02117 /* method: maxlenof_vy of class  TransMessage */
02118 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransMessage_maxlenof_vy00
02119 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransMessage_maxlenof_vy00(lua_State* tolua_S)
02120 {
02121 #ifndef TOLUA_RELEASE
02122  tolua_Error tolua_err;
02123  if (
02124      !tolua_isusertype(tolua_S,1,"const fawkes::MotorInterface::TransMessage",0,&tolua_err) ||
02125      !tolua_isnoobj(tolua_S,2,&tolua_err)
02126  )
02127   goto tolua_lerror;
02128  else
02129 #endif
02130  {
02131   const fawkes::MotorInterface::TransMessage* self = (const fawkes::MotorInterface::TransMessage*)  tolua_tousertype(tolua_S,1,0);
02132 #ifndef TOLUA_RELEASE
02133   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_vy'",NULL);
02134 #endif
02135   {
02136    int tolua_ret = (int)  self->maxlenof_vy();
02137    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02138   }
02139  }
02140  return 1;
02141 #ifndef TOLUA_RELEASE
02142  tolua_lerror:
02143  tolua_error(tolua_S,"#ferror in function 'maxlenof_vy'.",&tolua_err);
02144  return 0;
02145 #endif
02146 }
02147 #endif //#ifndef TOLUA_DISABLE
02148 
02149 /* method: new of class  RotMessage */
02150 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_RotMessage_new00
02151 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_RotMessage_new00(lua_State* tolua_S)
02152 {
02153 #ifndef TOLUA_RELEASE
02154  tolua_Error tolua_err;
02155  if (
02156      !tolua_isusertable(tolua_S,1,"fawkes::MotorInterface::RotMessage",0,&tolua_err) ||
02157      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02158      !tolua_isnoobj(tolua_S,3,&tolua_err)
02159  )
02160   goto tolua_lerror;
02161  else
02162 #endif
02163  {
02164   float ini_omega = ((float)  tolua_tonumber(tolua_S,2,0));
02165   {
02166    fawkes::MotorInterface::RotMessage* tolua_ret = (fawkes::MotorInterface::RotMessage*)  new fawkes::MotorInterface::RotMessage(ini_omega);
02167    tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::MotorInterface::RotMessage");
02168   }
02169  }
02170  return 1;
02171 #ifndef TOLUA_RELEASE
02172  tolua_lerror:
02173  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
02174  return 0;
02175 #endif
02176 }
02177 #endif //#ifndef TOLUA_DISABLE
02178 
02179 /* method: new_local of class  RotMessage */
02180 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_RotMessage_new00_local
02181 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_RotMessage_new00_local(lua_State* tolua_S)
02182 {
02183 #ifndef TOLUA_RELEASE
02184  tolua_Error tolua_err;
02185  if (
02186      !tolua_isusertable(tolua_S,1,"fawkes::MotorInterface::RotMessage",0,&tolua_err) ||
02187      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02188      !tolua_isnoobj(tolua_S,3,&tolua_err)
02189  )
02190   goto tolua_lerror;
02191  else
02192 #endif
02193  {
02194   float ini_omega = ((float)  tolua_tonumber(tolua_S,2,0));
02195   {
02196    fawkes::MotorInterface::RotMessage* tolua_ret = (fawkes::MotorInterface::RotMessage*)  new fawkes::MotorInterface::RotMessage(ini_omega);
02197    tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"fawkes::MotorInterface::RotMessage");
02198   }
02199  }
02200  return 1;
02201 #ifndef TOLUA_RELEASE
02202  tolua_lerror:
02203  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
02204  return 0;
02205 #endif
02206 }
02207 #endif //#ifndef TOLUA_DISABLE
02208 
02209 /* method: new of class  RotMessage */
02210 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_RotMessage_new01
02211 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_RotMessage_new01(lua_State* tolua_S)
02212 {
02213  tolua_Error tolua_err;
02214  if (
02215      !tolua_isusertable(tolua_S,1,"fawkes::MotorInterface::RotMessage",0,&tolua_err) ||
02216      !tolua_isnoobj(tolua_S,2,&tolua_err)
02217  )
02218   goto tolua_lerror;
02219  else
02220  {
02221   {
02222    fawkes::MotorInterface::RotMessage* tolua_ret = (fawkes::MotorInterface::RotMessage*)  new fawkes::MotorInterface::RotMessage();
02223    tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::MotorInterface::RotMessage");
02224   }
02225  }
02226  return 1;
02227 tolua_lerror:
02228  return tolua_interfaces_MotorInterface_fawkes_MotorInterface_RotMessage_new00(tolua_S);
02229 }
02230 #endif //#ifndef TOLUA_DISABLE
02231 
02232 /* method: new_local of class  RotMessage */
02233 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_RotMessage_new01_local
02234 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_RotMessage_new01_local(lua_State* tolua_S)
02235 {
02236  tolua_Error tolua_err;
02237  if (
02238      !tolua_isusertable(tolua_S,1,"fawkes::MotorInterface::RotMessage",0,&tolua_err) ||
02239      !tolua_isnoobj(tolua_S,2,&tolua_err)
02240  )
02241   goto tolua_lerror;
02242  else
02243  {
02244   {
02245    fawkes::MotorInterface::RotMessage* tolua_ret = (fawkes::MotorInterface::RotMessage*)  new fawkes::MotorInterface::RotMessage();
02246    tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"fawkes::MotorInterface::RotMessage");
02247   }
02248  }
02249  return 1;
02250 tolua_lerror:
02251  return tolua_interfaces_MotorInterface_fawkes_MotorInterface_RotMessage_new00_local(tolua_S);
02252 }
02253 #endif //#ifndef TOLUA_DISABLE
02254 
02255 /* method: delete of class  RotMessage */
02256 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_RotMessage_delete00
02257 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_RotMessage_delete00(lua_State* tolua_S)
02258 {
02259 #ifndef TOLUA_RELEASE
02260  tolua_Error tolua_err;
02261  if (
02262      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface::RotMessage",0,&tolua_err) ||
02263      !tolua_isnoobj(tolua_S,2,&tolua_err)
02264  )
02265   goto tolua_lerror;
02266  else
02267 #endif
02268  {
02269   fawkes::MotorInterface::RotMessage* self = (fawkes::MotorInterface::RotMessage*)  tolua_tousertype(tolua_S,1,0);
02270 #ifndef TOLUA_RELEASE
02271   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
02272 #endif
02273   delete self;
02274  }
02275  return 0;
02276 #ifndef TOLUA_RELEASE
02277  tolua_lerror:
02278  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
02279  return 0;
02280 #endif
02281 }
02282 #endif //#ifndef TOLUA_DISABLE
02283 
02284 /* method: omega of class  RotMessage */
02285 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_RotMessage_omega00
02286 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_RotMessage_omega00(lua_State* tolua_S)
02287 {
02288 #ifndef TOLUA_RELEASE
02289  tolua_Error tolua_err;
02290  if (
02291      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface::RotMessage",0,&tolua_err) ||
02292      !tolua_isnoobj(tolua_S,2,&tolua_err)
02293  )
02294   goto tolua_lerror;
02295  else
02296 #endif
02297  {
02298   fawkes::MotorInterface::RotMessage* self = (fawkes::MotorInterface::RotMessage*)  tolua_tousertype(tolua_S,1,0);
02299 #ifndef TOLUA_RELEASE
02300   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'omega'",NULL);
02301 #endif
02302   {
02303    float tolua_ret = (float)  self->omega();
02304    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02305   }
02306  }
02307  return 1;
02308 #ifndef TOLUA_RELEASE
02309  tolua_lerror:
02310  tolua_error(tolua_S,"#ferror in function 'omega'.",&tolua_err);
02311  return 0;
02312 #endif
02313 }
02314 #endif //#ifndef TOLUA_DISABLE
02315 
02316 /* method: set_omega of class  RotMessage */
02317 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_RotMessage_set_omega00
02318 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_RotMessage_set_omega00(lua_State* tolua_S)
02319 {
02320 #ifndef TOLUA_RELEASE
02321  tolua_Error tolua_err;
02322  if (
02323      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface::RotMessage",0,&tolua_err) ||
02324      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02325      !tolua_isnoobj(tolua_S,3,&tolua_err)
02326  )
02327   goto tolua_lerror;
02328  else
02329 #endif
02330  {
02331   fawkes::MotorInterface::RotMessage* self = (fawkes::MotorInterface::RotMessage*)  tolua_tousertype(tolua_S,1,0);
02332   const float new_omega = ((const float)  tolua_tonumber(tolua_S,2,0));
02333 #ifndef TOLUA_RELEASE
02334   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_omega'",NULL);
02335 #endif
02336   {
02337    self->set_omega(new_omega);
02338   }
02339  }
02340  return 0;
02341 #ifndef TOLUA_RELEASE
02342  tolua_lerror:
02343  tolua_error(tolua_S,"#ferror in function 'set_omega'.",&tolua_err);
02344  return 0;
02345 #endif
02346 }
02347 #endif //#ifndef TOLUA_DISABLE
02348 
02349 /* method: maxlenof_omega of class  RotMessage */
02350 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_RotMessage_maxlenof_omega00
02351 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_RotMessage_maxlenof_omega00(lua_State* tolua_S)
02352 {
02353 #ifndef TOLUA_RELEASE
02354  tolua_Error tolua_err;
02355  if (
02356      !tolua_isusertype(tolua_S,1,"const fawkes::MotorInterface::RotMessage",0,&tolua_err) ||
02357      !tolua_isnoobj(tolua_S,2,&tolua_err)
02358  )
02359   goto tolua_lerror;
02360  else
02361 #endif
02362  {
02363   const fawkes::MotorInterface::RotMessage* self = (const fawkes::MotorInterface::RotMessage*)  tolua_tousertype(tolua_S,1,0);
02364 #ifndef TOLUA_RELEASE
02365   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_omega'",NULL);
02366 #endif
02367   {
02368    int tolua_ret = (int)  self->maxlenof_omega();
02369    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02370   }
02371  }
02372  return 1;
02373 #ifndef TOLUA_RELEASE
02374  tolua_lerror:
02375  tolua_error(tolua_S,"#ferror in function 'maxlenof_omega'.",&tolua_err);
02376  return 0;
02377 #endif
02378 }
02379 #endif //#ifndef TOLUA_DISABLE
02380 
02381 /* method: new of class  TransRotMessage */
02382 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransRotMessage_new00
02383 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransRotMessage_new00(lua_State* tolua_S)
02384 {
02385 #ifndef TOLUA_RELEASE
02386  tolua_Error tolua_err;
02387  if (
02388      !tolua_isusertable(tolua_S,1,"fawkes::MotorInterface::TransRotMessage",0,&tolua_err) ||
02389      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02390      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
02391      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
02392      !tolua_isnoobj(tolua_S,5,&tolua_err)
02393  )
02394   goto tolua_lerror;
02395  else
02396 #endif
02397  {
02398   float ini_vx = ((float)  tolua_tonumber(tolua_S,2,0));
02399   float ini_vy = ((float)  tolua_tonumber(tolua_S,3,0));
02400   float ini_omega = ((float)  tolua_tonumber(tolua_S,4,0));
02401   {
02402    fawkes::MotorInterface::TransRotMessage* tolua_ret = (fawkes::MotorInterface::TransRotMessage*)  new fawkes::MotorInterface::TransRotMessage(ini_vx,ini_vy,ini_omega);
02403    tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::MotorInterface::TransRotMessage");
02404   }
02405  }
02406  return 1;
02407 #ifndef TOLUA_RELEASE
02408  tolua_lerror:
02409  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
02410  return 0;
02411 #endif
02412 }
02413 #endif //#ifndef TOLUA_DISABLE
02414 
02415 /* method: new_local of class  TransRotMessage */
02416 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransRotMessage_new00_local
02417 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransRotMessage_new00_local(lua_State* tolua_S)
02418 {
02419 #ifndef TOLUA_RELEASE
02420  tolua_Error tolua_err;
02421  if (
02422      !tolua_isusertable(tolua_S,1,"fawkes::MotorInterface::TransRotMessage",0,&tolua_err) ||
02423      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02424      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
02425      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
02426      !tolua_isnoobj(tolua_S,5,&tolua_err)
02427  )
02428   goto tolua_lerror;
02429  else
02430 #endif
02431  {
02432   float ini_vx = ((float)  tolua_tonumber(tolua_S,2,0));
02433   float ini_vy = ((float)  tolua_tonumber(tolua_S,3,0));
02434   float ini_omega = ((float)  tolua_tonumber(tolua_S,4,0));
02435   {
02436    fawkes::MotorInterface::TransRotMessage* tolua_ret = (fawkes::MotorInterface::TransRotMessage*)  new fawkes::MotorInterface::TransRotMessage(ini_vx,ini_vy,ini_omega);
02437    tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"fawkes::MotorInterface::TransRotMessage");
02438   }
02439  }
02440  return 1;
02441 #ifndef TOLUA_RELEASE
02442  tolua_lerror:
02443  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
02444  return 0;
02445 #endif
02446 }
02447 #endif //#ifndef TOLUA_DISABLE
02448 
02449 /* method: new of class  TransRotMessage */
02450 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransRotMessage_new01
02451 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransRotMessage_new01(lua_State* tolua_S)
02452 {
02453  tolua_Error tolua_err;
02454  if (
02455      !tolua_isusertable(tolua_S,1,"fawkes::MotorInterface::TransRotMessage",0,&tolua_err) ||
02456      !tolua_isnoobj(tolua_S,2,&tolua_err)
02457  )
02458   goto tolua_lerror;
02459  else
02460  {
02461   {
02462    fawkes::MotorInterface::TransRotMessage* tolua_ret = (fawkes::MotorInterface::TransRotMessage*)  new fawkes::MotorInterface::TransRotMessage();
02463    tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::MotorInterface::TransRotMessage");
02464   }
02465  }
02466  return 1;
02467 tolua_lerror:
02468  return tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransRotMessage_new00(tolua_S);
02469 }
02470 #endif //#ifndef TOLUA_DISABLE
02471 
02472 /* method: new_local of class  TransRotMessage */
02473 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransRotMessage_new01_local
02474 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransRotMessage_new01_local(lua_State* tolua_S)
02475 {
02476  tolua_Error tolua_err;
02477  if (
02478      !tolua_isusertable(tolua_S,1,"fawkes::MotorInterface::TransRotMessage",0,&tolua_err) ||
02479      !tolua_isnoobj(tolua_S,2,&tolua_err)
02480  )
02481   goto tolua_lerror;
02482  else
02483  {
02484   {
02485    fawkes::MotorInterface::TransRotMessage* tolua_ret = (fawkes::MotorInterface::TransRotMessage*)  new fawkes::MotorInterface::TransRotMessage();
02486    tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"fawkes::MotorInterface::TransRotMessage");
02487   }
02488  }
02489  return 1;
02490 tolua_lerror:
02491  return tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransRotMessage_new00_local(tolua_S);
02492 }
02493 #endif //#ifndef TOLUA_DISABLE
02494 
02495 /* method: delete of class  TransRotMessage */
02496 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransRotMessage_delete00
02497 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransRotMessage_delete00(lua_State* tolua_S)
02498 {
02499 #ifndef TOLUA_RELEASE
02500  tolua_Error tolua_err;
02501  if (
02502      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface::TransRotMessage",0,&tolua_err) ||
02503      !tolua_isnoobj(tolua_S,2,&tolua_err)
02504  )
02505   goto tolua_lerror;
02506  else
02507 #endif
02508  {
02509   fawkes::MotorInterface::TransRotMessage* self = (fawkes::MotorInterface::TransRotMessage*)  tolua_tousertype(tolua_S,1,0);
02510 #ifndef TOLUA_RELEASE
02511   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
02512 #endif
02513   delete self;
02514  }
02515  return 0;
02516 #ifndef TOLUA_RELEASE
02517  tolua_lerror:
02518  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
02519  return 0;
02520 #endif
02521 }
02522 #endif //#ifndef TOLUA_DISABLE
02523 
02524 /* method: vx of class  TransRotMessage */
02525 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransRotMessage_vx00
02526 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransRotMessage_vx00(lua_State* tolua_S)
02527 {
02528 #ifndef TOLUA_RELEASE
02529  tolua_Error tolua_err;
02530  if (
02531      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface::TransRotMessage",0,&tolua_err) ||
02532      !tolua_isnoobj(tolua_S,2,&tolua_err)
02533  )
02534   goto tolua_lerror;
02535  else
02536 #endif
02537  {
02538   fawkes::MotorInterface::TransRotMessage* self = (fawkes::MotorInterface::TransRotMessage*)  tolua_tousertype(tolua_S,1,0);
02539 #ifndef TOLUA_RELEASE
02540   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'vx'",NULL);
02541 #endif
02542   {
02543    float tolua_ret = (float)  self->vx();
02544    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02545   }
02546  }
02547  return 1;
02548 #ifndef TOLUA_RELEASE
02549  tolua_lerror:
02550  tolua_error(tolua_S,"#ferror in function 'vx'.",&tolua_err);
02551  return 0;
02552 #endif
02553 }
02554 #endif //#ifndef TOLUA_DISABLE
02555 
02556 /* method: set_vx of class  TransRotMessage */
02557 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransRotMessage_set_vx00
02558 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransRotMessage_set_vx00(lua_State* tolua_S)
02559 {
02560 #ifndef TOLUA_RELEASE
02561  tolua_Error tolua_err;
02562  if (
02563      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface::TransRotMessage",0,&tolua_err) ||
02564      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02565      !tolua_isnoobj(tolua_S,3,&tolua_err)
02566  )
02567   goto tolua_lerror;
02568  else
02569 #endif
02570  {
02571   fawkes::MotorInterface::TransRotMessage* self = (fawkes::MotorInterface::TransRotMessage*)  tolua_tousertype(tolua_S,1,0);
02572   const float new_vx = ((const float)  tolua_tonumber(tolua_S,2,0));
02573 #ifndef TOLUA_RELEASE
02574   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_vx'",NULL);
02575 #endif
02576   {
02577    self->set_vx(new_vx);
02578   }
02579  }
02580  return 0;
02581 #ifndef TOLUA_RELEASE
02582  tolua_lerror:
02583  tolua_error(tolua_S,"#ferror in function 'set_vx'.",&tolua_err);
02584  return 0;
02585 #endif
02586 }
02587 #endif //#ifndef TOLUA_DISABLE
02588 
02589 /* method: maxlenof_vx of class  TransRotMessage */
02590 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransRotMessage_maxlenof_vx00
02591 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransRotMessage_maxlenof_vx00(lua_State* tolua_S)
02592 {
02593 #ifndef TOLUA_RELEASE
02594  tolua_Error tolua_err;
02595  if (
02596      !tolua_isusertype(tolua_S,1,"const fawkes::MotorInterface::TransRotMessage",0,&tolua_err) ||
02597      !tolua_isnoobj(tolua_S,2,&tolua_err)
02598  )
02599   goto tolua_lerror;
02600  else
02601 #endif
02602  {
02603   const fawkes::MotorInterface::TransRotMessage* self = (const fawkes::MotorInterface::TransRotMessage*)  tolua_tousertype(tolua_S,1,0);
02604 #ifndef TOLUA_RELEASE
02605   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_vx'",NULL);
02606 #endif
02607   {
02608    int tolua_ret = (int)  self->maxlenof_vx();
02609    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02610   }
02611  }
02612  return 1;
02613 #ifndef TOLUA_RELEASE
02614  tolua_lerror:
02615  tolua_error(tolua_S,"#ferror in function 'maxlenof_vx'.",&tolua_err);
02616  return 0;
02617 #endif
02618 }
02619 #endif //#ifndef TOLUA_DISABLE
02620 
02621 /* method: vy of class  TransRotMessage */
02622 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransRotMessage_vy00
02623 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransRotMessage_vy00(lua_State* tolua_S)
02624 {
02625 #ifndef TOLUA_RELEASE
02626  tolua_Error tolua_err;
02627  if (
02628      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface::TransRotMessage",0,&tolua_err) ||
02629      !tolua_isnoobj(tolua_S,2,&tolua_err)
02630  )
02631   goto tolua_lerror;
02632  else
02633 #endif
02634  {
02635   fawkes::MotorInterface::TransRotMessage* self = (fawkes::MotorInterface::TransRotMessage*)  tolua_tousertype(tolua_S,1,0);
02636 #ifndef TOLUA_RELEASE
02637   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'vy'",NULL);
02638 #endif
02639   {
02640    float tolua_ret = (float)  self->vy();
02641    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02642   }
02643  }
02644  return 1;
02645 #ifndef TOLUA_RELEASE
02646  tolua_lerror:
02647  tolua_error(tolua_S,"#ferror in function 'vy'.",&tolua_err);
02648  return 0;
02649 #endif
02650 }
02651 #endif //#ifndef TOLUA_DISABLE
02652 
02653 /* method: set_vy of class  TransRotMessage */
02654 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransRotMessage_set_vy00
02655 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransRotMessage_set_vy00(lua_State* tolua_S)
02656 {
02657 #ifndef TOLUA_RELEASE
02658  tolua_Error tolua_err;
02659  if (
02660      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface::TransRotMessage",0,&tolua_err) ||
02661      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02662      !tolua_isnoobj(tolua_S,3,&tolua_err)
02663  )
02664   goto tolua_lerror;
02665  else
02666 #endif
02667  {
02668   fawkes::MotorInterface::TransRotMessage* self = (fawkes::MotorInterface::TransRotMessage*)  tolua_tousertype(tolua_S,1,0);
02669   const float new_vy = ((const float)  tolua_tonumber(tolua_S,2,0));
02670 #ifndef TOLUA_RELEASE
02671   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_vy'",NULL);
02672 #endif
02673   {
02674    self->set_vy(new_vy);
02675   }
02676  }
02677  return 0;
02678 #ifndef TOLUA_RELEASE
02679  tolua_lerror:
02680  tolua_error(tolua_S,"#ferror in function 'set_vy'.",&tolua_err);
02681  return 0;
02682 #endif
02683 }
02684 #endif //#ifndef TOLUA_DISABLE
02685 
02686 /* method: maxlenof_vy of class  TransRotMessage */
02687 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransRotMessage_maxlenof_vy00
02688 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransRotMessage_maxlenof_vy00(lua_State* tolua_S)
02689 {
02690 #ifndef TOLUA_RELEASE
02691  tolua_Error tolua_err;
02692  if (
02693      !tolua_isusertype(tolua_S,1,"const fawkes::MotorInterface::TransRotMessage",0,&tolua_err) ||
02694      !tolua_isnoobj(tolua_S,2,&tolua_err)
02695  )
02696   goto tolua_lerror;
02697  else
02698 #endif
02699  {
02700   const fawkes::MotorInterface::TransRotMessage* self = (const fawkes::MotorInterface::TransRotMessage*)  tolua_tousertype(tolua_S,1,0);
02701 #ifndef TOLUA_RELEASE
02702   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_vy'",NULL);
02703 #endif
02704   {
02705    int tolua_ret = (int)  self->maxlenof_vy();
02706    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02707   }
02708  }
02709  return 1;
02710 #ifndef TOLUA_RELEASE
02711  tolua_lerror:
02712  tolua_error(tolua_S,"#ferror in function 'maxlenof_vy'.",&tolua_err);
02713  return 0;
02714 #endif
02715 }
02716 #endif //#ifndef TOLUA_DISABLE
02717 
02718 /* method: omega of class  TransRotMessage */
02719 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransRotMessage_omega00
02720 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransRotMessage_omega00(lua_State* tolua_S)
02721 {
02722 #ifndef TOLUA_RELEASE
02723  tolua_Error tolua_err;
02724  if (
02725      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface::TransRotMessage",0,&tolua_err) ||
02726      !tolua_isnoobj(tolua_S,2,&tolua_err)
02727  )
02728   goto tolua_lerror;
02729  else
02730 #endif
02731  {
02732   fawkes::MotorInterface::TransRotMessage* self = (fawkes::MotorInterface::TransRotMessage*)  tolua_tousertype(tolua_S,1,0);
02733 #ifndef TOLUA_RELEASE
02734   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'omega'",NULL);
02735 #endif
02736   {
02737    float tolua_ret = (float)  self->omega();
02738    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02739   }
02740  }
02741  return 1;
02742 #ifndef TOLUA_RELEASE
02743  tolua_lerror:
02744  tolua_error(tolua_S,"#ferror in function 'omega'.",&tolua_err);
02745  return 0;
02746 #endif
02747 }
02748 #endif //#ifndef TOLUA_DISABLE
02749 
02750 /* method: set_omega of class  TransRotMessage */
02751 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransRotMessage_set_omega00
02752 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransRotMessage_set_omega00(lua_State* tolua_S)
02753 {
02754 #ifndef TOLUA_RELEASE
02755  tolua_Error tolua_err;
02756  if (
02757      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface::TransRotMessage",0,&tolua_err) ||
02758      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02759      !tolua_isnoobj(tolua_S,3,&tolua_err)
02760  )
02761   goto tolua_lerror;
02762  else
02763 #endif
02764  {
02765   fawkes::MotorInterface::TransRotMessage* self = (fawkes::MotorInterface::TransRotMessage*)  tolua_tousertype(tolua_S,1,0);
02766   const float new_omega = ((const float)  tolua_tonumber(tolua_S,2,0));
02767 #ifndef TOLUA_RELEASE
02768   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_omega'",NULL);
02769 #endif
02770   {
02771    self->set_omega(new_omega);
02772   }
02773  }
02774  return 0;
02775 #ifndef TOLUA_RELEASE
02776  tolua_lerror:
02777  tolua_error(tolua_S,"#ferror in function 'set_omega'.",&tolua_err);
02778  return 0;
02779 #endif
02780 }
02781 #endif //#ifndef TOLUA_DISABLE
02782 
02783 /* method: maxlenof_omega of class  TransRotMessage */
02784 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransRotMessage_maxlenof_omega00
02785 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransRotMessage_maxlenof_omega00(lua_State* tolua_S)
02786 {
02787 #ifndef TOLUA_RELEASE
02788  tolua_Error tolua_err;
02789  if (
02790      !tolua_isusertype(tolua_S,1,"const fawkes::MotorInterface::TransRotMessage",0,&tolua_err) ||
02791      !tolua_isnoobj(tolua_S,2,&tolua_err)
02792  )
02793   goto tolua_lerror;
02794  else
02795 #endif
02796  {
02797   const fawkes::MotorInterface::TransRotMessage* self = (const fawkes::MotorInterface::TransRotMessage*)  tolua_tousertype(tolua_S,1,0);
02798 #ifndef TOLUA_RELEASE
02799   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_omega'",NULL);
02800 #endif
02801   {
02802    int tolua_ret = (int)  self->maxlenof_omega();
02803    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02804   }
02805  }
02806  return 1;
02807 #ifndef TOLUA_RELEASE
02808  tolua_lerror:
02809  tolua_error(tolua_S,"#ferror in function 'maxlenof_omega'.",&tolua_err);
02810  return 0;
02811 #endif
02812 }
02813 #endif //#ifndef TOLUA_DISABLE
02814 
02815 /* method: new of class  OrbitMessage */
02816 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_OrbitMessage_new00
02817 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_OrbitMessage_new00(lua_State* tolua_S)
02818 {
02819 #ifndef TOLUA_RELEASE
02820  tolua_Error tolua_err;
02821  if (
02822      !tolua_isusertable(tolua_S,1,"fawkes::MotorInterface::OrbitMessage",0,&tolua_err) ||
02823      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02824      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
02825      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
02826      !tolua_isnoobj(tolua_S,5,&tolua_err)
02827  )
02828   goto tolua_lerror;
02829  else
02830 #endif
02831  {
02832   float ini_px = ((float)  tolua_tonumber(tolua_S,2,0));
02833   float ini_py = ((float)  tolua_tonumber(tolua_S,3,0));
02834   float ini_omega = ((float)  tolua_tonumber(tolua_S,4,0));
02835   {
02836    fawkes::MotorInterface::OrbitMessage* tolua_ret = (fawkes::MotorInterface::OrbitMessage*)  new fawkes::MotorInterface::OrbitMessage(ini_px,ini_py,ini_omega);
02837    tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::MotorInterface::OrbitMessage");
02838   }
02839  }
02840  return 1;
02841 #ifndef TOLUA_RELEASE
02842  tolua_lerror:
02843  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
02844  return 0;
02845 #endif
02846 }
02847 #endif //#ifndef TOLUA_DISABLE
02848 
02849 /* method: new_local of class  OrbitMessage */
02850 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_OrbitMessage_new00_local
02851 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_OrbitMessage_new00_local(lua_State* tolua_S)
02852 {
02853 #ifndef TOLUA_RELEASE
02854  tolua_Error tolua_err;
02855  if (
02856      !tolua_isusertable(tolua_S,1,"fawkes::MotorInterface::OrbitMessage",0,&tolua_err) ||
02857      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02858      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
02859      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
02860      !tolua_isnoobj(tolua_S,5,&tolua_err)
02861  )
02862   goto tolua_lerror;
02863  else
02864 #endif
02865  {
02866   float ini_px = ((float)  tolua_tonumber(tolua_S,2,0));
02867   float ini_py = ((float)  tolua_tonumber(tolua_S,3,0));
02868   float ini_omega = ((float)  tolua_tonumber(tolua_S,4,0));
02869   {
02870    fawkes::MotorInterface::OrbitMessage* tolua_ret = (fawkes::MotorInterface::OrbitMessage*)  new fawkes::MotorInterface::OrbitMessage(ini_px,ini_py,ini_omega);
02871    tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"fawkes::MotorInterface::OrbitMessage");
02872   }
02873  }
02874  return 1;
02875 #ifndef TOLUA_RELEASE
02876  tolua_lerror:
02877  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
02878  return 0;
02879 #endif
02880 }
02881 #endif //#ifndef TOLUA_DISABLE
02882 
02883 /* method: new of class  OrbitMessage */
02884 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_OrbitMessage_new01
02885 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_OrbitMessage_new01(lua_State* tolua_S)
02886 {
02887  tolua_Error tolua_err;
02888  if (
02889      !tolua_isusertable(tolua_S,1,"fawkes::MotorInterface::OrbitMessage",0,&tolua_err) ||
02890      !tolua_isnoobj(tolua_S,2,&tolua_err)
02891  )
02892   goto tolua_lerror;
02893  else
02894  {
02895   {
02896    fawkes::MotorInterface::OrbitMessage* tolua_ret = (fawkes::MotorInterface::OrbitMessage*)  new fawkes::MotorInterface::OrbitMessage();
02897    tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::MotorInterface::OrbitMessage");
02898   }
02899  }
02900  return 1;
02901 tolua_lerror:
02902  return tolua_interfaces_MotorInterface_fawkes_MotorInterface_OrbitMessage_new00(tolua_S);
02903 }
02904 #endif //#ifndef TOLUA_DISABLE
02905 
02906 /* method: new_local of class  OrbitMessage */
02907 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_OrbitMessage_new01_local
02908 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_OrbitMessage_new01_local(lua_State* tolua_S)
02909 {
02910  tolua_Error tolua_err;
02911  if (
02912      !tolua_isusertable(tolua_S,1,"fawkes::MotorInterface::OrbitMessage",0,&tolua_err) ||
02913      !tolua_isnoobj(tolua_S,2,&tolua_err)
02914  )
02915   goto tolua_lerror;
02916  else
02917  {
02918   {
02919    fawkes::MotorInterface::OrbitMessage* tolua_ret = (fawkes::MotorInterface::OrbitMessage*)  new fawkes::MotorInterface::OrbitMessage();
02920    tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"fawkes::MotorInterface::OrbitMessage");
02921   }
02922  }
02923  return 1;
02924 tolua_lerror:
02925  return tolua_interfaces_MotorInterface_fawkes_MotorInterface_OrbitMessage_new00_local(tolua_S);
02926 }
02927 #endif //#ifndef TOLUA_DISABLE
02928 
02929 /* method: delete of class  OrbitMessage */
02930 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_OrbitMessage_delete00
02931 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_OrbitMessage_delete00(lua_State* tolua_S)
02932 {
02933 #ifndef TOLUA_RELEASE
02934  tolua_Error tolua_err;
02935  if (
02936      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface::OrbitMessage",0,&tolua_err) ||
02937      !tolua_isnoobj(tolua_S,2,&tolua_err)
02938  )
02939   goto tolua_lerror;
02940  else
02941 #endif
02942  {
02943   fawkes::MotorInterface::OrbitMessage* self = (fawkes::MotorInterface::OrbitMessage*)  tolua_tousertype(tolua_S,1,0);
02944 #ifndef TOLUA_RELEASE
02945   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
02946 #endif
02947   delete self;
02948  }
02949  return 0;
02950 #ifndef TOLUA_RELEASE
02951  tolua_lerror:
02952  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
02953  return 0;
02954 #endif
02955 }
02956 #endif //#ifndef TOLUA_DISABLE
02957 
02958 /* method: px of class  OrbitMessage */
02959 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_OrbitMessage_px00
02960 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_OrbitMessage_px00(lua_State* tolua_S)
02961 {
02962 #ifndef TOLUA_RELEASE
02963  tolua_Error tolua_err;
02964  if (
02965      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface::OrbitMessage",0,&tolua_err) ||
02966      !tolua_isnoobj(tolua_S,2,&tolua_err)
02967  )
02968   goto tolua_lerror;
02969  else
02970 #endif
02971  {
02972   fawkes::MotorInterface::OrbitMessage* self = (fawkes::MotorInterface::OrbitMessage*)  tolua_tousertype(tolua_S,1,0);
02973 #ifndef TOLUA_RELEASE
02974   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'px'",NULL);
02975 #endif
02976   {
02977    float tolua_ret = (float)  self->px();
02978    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02979   }
02980  }
02981  return 1;
02982 #ifndef TOLUA_RELEASE
02983  tolua_lerror:
02984  tolua_error(tolua_S,"#ferror in function 'px'.",&tolua_err);
02985  return 0;
02986 #endif
02987 }
02988 #endif //#ifndef TOLUA_DISABLE
02989 
02990 /* method: set_px of class  OrbitMessage */
02991 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_OrbitMessage_set_px00
02992 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_OrbitMessage_set_px00(lua_State* tolua_S)
02993 {
02994 #ifndef TOLUA_RELEASE
02995  tolua_Error tolua_err;
02996  if (
02997      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface::OrbitMessage",0,&tolua_err) ||
02998      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02999      !tolua_isnoobj(tolua_S,3,&tolua_err)
03000  )
03001   goto tolua_lerror;
03002  else
03003 #endif
03004  {
03005   fawkes::MotorInterface::OrbitMessage* self = (fawkes::MotorInterface::OrbitMessage*)  tolua_tousertype(tolua_S,1,0);
03006   const float new_px = ((const float)  tolua_tonumber(tolua_S,2,0));
03007 #ifndef TOLUA_RELEASE
03008   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_px'",NULL);
03009 #endif
03010   {
03011    self->set_px(new_px);
03012   }
03013  }
03014  return 0;
03015 #ifndef TOLUA_RELEASE
03016  tolua_lerror:
03017  tolua_error(tolua_S,"#ferror in function 'set_px'.",&tolua_err);
03018  return 0;
03019 #endif
03020 }
03021 #endif //#ifndef TOLUA_DISABLE
03022 
03023 /* method: maxlenof_px of class  OrbitMessage */
03024 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_OrbitMessage_maxlenof_px00
03025 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_OrbitMessage_maxlenof_px00(lua_State* tolua_S)
03026 {
03027 #ifndef TOLUA_RELEASE
03028  tolua_Error tolua_err;
03029  if (
03030      !tolua_isusertype(tolua_S,1,"const fawkes::MotorInterface::OrbitMessage",0,&tolua_err) ||
03031      !tolua_isnoobj(tolua_S,2,&tolua_err)
03032  )
03033   goto tolua_lerror;
03034  else
03035 #endif
03036  {
03037   const fawkes::MotorInterface::OrbitMessage* self = (const fawkes::MotorInterface::OrbitMessage*)  tolua_tousertype(tolua_S,1,0);
03038 #ifndef TOLUA_RELEASE
03039   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_px'",NULL);
03040 #endif
03041   {
03042    int tolua_ret = (int)  self->maxlenof_px();
03043    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03044   }
03045  }
03046  return 1;
03047 #ifndef TOLUA_RELEASE
03048  tolua_lerror:
03049  tolua_error(tolua_S,"#ferror in function 'maxlenof_px'.",&tolua_err);
03050  return 0;
03051 #endif
03052 }
03053 #endif //#ifndef TOLUA_DISABLE
03054 
03055 /* method: py of class  OrbitMessage */
03056 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_OrbitMessage_py00
03057 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_OrbitMessage_py00(lua_State* tolua_S)
03058 {
03059 #ifndef TOLUA_RELEASE
03060  tolua_Error tolua_err;
03061  if (
03062      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface::OrbitMessage",0,&tolua_err) ||
03063      !tolua_isnoobj(tolua_S,2,&tolua_err)
03064  )
03065   goto tolua_lerror;
03066  else
03067 #endif
03068  {
03069   fawkes::MotorInterface::OrbitMessage* self = (fawkes::MotorInterface::OrbitMessage*)  tolua_tousertype(tolua_S,1,0);
03070 #ifndef TOLUA_RELEASE
03071   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'py'",NULL);
03072 #endif
03073   {
03074    float tolua_ret = (float)  self->py();
03075    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03076   }
03077  }
03078  return 1;
03079 #ifndef TOLUA_RELEASE
03080  tolua_lerror:
03081  tolua_error(tolua_S,"#ferror in function 'py'.",&tolua_err);
03082  return 0;
03083 #endif
03084 }
03085 #endif //#ifndef TOLUA_DISABLE
03086 
03087 /* method: set_py of class  OrbitMessage */
03088 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_OrbitMessage_set_py00
03089 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_OrbitMessage_set_py00(lua_State* tolua_S)
03090 {
03091 #ifndef TOLUA_RELEASE
03092  tolua_Error tolua_err;
03093  if (
03094      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface::OrbitMessage",0,&tolua_err) ||
03095      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
03096      !tolua_isnoobj(tolua_S,3,&tolua_err)
03097  )
03098   goto tolua_lerror;
03099  else
03100 #endif
03101  {
03102   fawkes::MotorInterface::OrbitMessage* self = (fawkes::MotorInterface::OrbitMessage*)  tolua_tousertype(tolua_S,1,0);
03103   const float new_py = ((const float)  tolua_tonumber(tolua_S,2,0));
03104 #ifndef TOLUA_RELEASE
03105   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_py'",NULL);
03106 #endif
03107   {
03108    self->set_py(new_py);
03109   }
03110  }
03111  return 0;
03112 #ifndef TOLUA_RELEASE
03113  tolua_lerror:
03114  tolua_error(tolua_S,"#ferror in function 'set_py'.",&tolua_err);
03115  return 0;
03116 #endif
03117 }
03118 #endif //#ifndef TOLUA_DISABLE
03119 
03120 /* method: maxlenof_py of class  OrbitMessage */
03121 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_OrbitMessage_maxlenof_py00
03122 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_OrbitMessage_maxlenof_py00(lua_State* tolua_S)
03123 {
03124 #ifndef TOLUA_RELEASE
03125  tolua_Error tolua_err;
03126  if (
03127      !tolua_isusertype(tolua_S,1,"const fawkes::MotorInterface::OrbitMessage",0,&tolua_err) ||
03128      !tolua_isnoobj(tolua_S,2,&tolua_err)
03129  )
03130   goto tolua_lerror;
03131  else
03132 #endif
03133  {
03134   const fawkes::MotorInterface::OrbitMessage* self = (const fawkes::MotorInterface::OrbitMessage*)  tolua_tousertype(tolua_S,1,0);
03135 #ifndef TOLUA_RELEASE
03136   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_py'",NULL);
03137 #endif
03138   {
03139    int tolua_ret = (int)  self->maxlenof_py();
03140    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03141   }
03142  }
03143  return 1;
03144 #ifndef TOLUA_RELEASE
03145  tolua_lerror:
03146  tolua_error(tolua_S,"#ferror in function 'maxlenof_py'.",&tolua_err);
03147  return 0;
03148 #endif
03149 }
03150 #endif //#ifndef TOLUA_DISABLE
03151 
03152 /* method: omega of class  OrbitMessage */
03153 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_OrbitMessage_omega00
03154 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_OrbitMessage_omega00(lua_State* tolua_S)
03155 {
03156 #ifndef TOLUA_RELEASE
03157  tolua_Error tolua_err;
03158  if (
03159      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface::OrbitMessage",0,&tolua_err) ||
03160      !tolua_isnoobj(tolua_S,2,&tolua_err)
03161  )
03162   goto tolua_lerror;
03163  else
03164 #endif
03165  {
03166   fawkes::MotorInterface::OrbitMessage* self = (fawkes::MotorInterface::OrbitMessage*)  tolua_tousertype(tolua_S,1,0);
03167 #ifndef TOLUA_RELEASE
03168   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'omega'",NULL);
03169 #endif
03170   {
03171    float tolua_ret = (float)  self->omega();
03172    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03173   }
03174  }
03175  return 1;
03176 #ifndef TOLUA_RELEASE
03177  tolua_lerror:
03178  tolua_error(tolua_S,"#ferror in function 'omega'.",&tolua_err);
03179  return 0;
03180 #endif
03181 }
03182 #endif //#ifndef TOLUA_DISABLE
03183 
03184 /* method: set_omega of class  OrbitMessage */
03185 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_OrbitMessage_set_omega00
03186 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_OrbitMessage_set_omega00(lua_State* tolua_S)
03187 {
03188 #ifndef TOLUA_RELEASE
03189  tolua_Error tolua_err;
03190  if (
03191      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface::OrbitMessage",0,&tolua_err) ||
03192      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
03193      !tolua_isnoobj(tolua_S,3,&tolua_err)
03194  )
03195   goto tolua_lerror;
03196  else
03197 #endif
03198  {
03199   fawkes::MotorInterface::OrbitMessage* self = (fawkes::MotorInterface::OrbitMessage*)  tolua_tousertype(tolua_S,1,0);
03200   const float new_omega = ((const float)  tolua_tonumber(tolua_S,2,0));
03201 #ifndef TOLUA_RELEASE
03202   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_omega'",NULL);
03203 #endif
03204   {
03205    self->set_omega(new_omega);
03206   }
03207  }
03208  return 0;
03209 #ifndef TOLUA_RELEASE
03210  tolua_lerror:
03211  tolua_error(tolua_S,"#ferror in function 'set_omega'.",&tolua_err);
03212  return 0;
03213 #endif
03214 }
03215 #endif //#ifndef TOLUA_DISABLE
03216 
03217 /* method: maxlenof_omega of class  OrbitMessage */
03218 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_OrbitMessage_maxlenof_omega00
03219 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_OrbitMessage_maxlenof_omega00(lua_State* tolua_S)
03220 {
03221 #ifndef TOLUA_RELEASE
03222  tolua_Error tolua_err;
03223  if (
03224      !tolua_isusertype(tolua_S,1,"const fawkes::MotorInterface::OrbitMessage",0,&tolua_err) ||
03225      !tolua_isnoobj(tolua_S,2,&tolua_err)
03226  )
03227   goto tolua_lerror;
03228  else
03229 #endif
03230  {
03231   const fawkes::MotorInterface::OrbitMessage* self = (const fawkes::MotorInterface::OrbitMessage*)  tolua_tousertype(tolua_S,1,0);
03232 #ifndef TOLUA_RELEASE
03233   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_omega'",NULL);
03234 #endif
03235   {
03236    int tolua_ret = (int)  self->maxlenof_omega();
03237    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03238   }
03239  }
03240  return 1;
03241 #ifndef TOLUA_RELEASE
03242  tolua_lerror:
03243  tolua_error(tolua_S,"#ferror in function 'maxlenof_omega'.",&tolua_err);
03244  return 0;
03245 #endif
03246 }
03247 #endif //#ifndef TOLUA_DISABLE
03248 
03249 /* method: new of class  LinTransRotMessage */
03250 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_LinTransRotMessage_new00
03251 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_LinTransRotMessage_new00(lua_State* tolua_S)
03252 {
03253 #ifndef TOLUA_RELEASE
03254  tolua_Error tolua_err;
03255  if (
03256      !tolua_isusertable(tolua_S,1,"fawkes::MotorInterface::LinTransRotMessage",0,&tolua_err) ||
03257      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
03258      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
03259      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
03260      !tolua_isnoobj(tolua_S,5,&tolua_err)
03261  )
03262   goto tolua_lerror;
03263  else
03264 #endif
03265  {
03266   float ini_vx = ((float)  tolua_tonumber(tolua_S,2,0));
03267   float ini_vy = ((float)  tolua_tonumber(tolua_S,3,0));
03268   float ini_omega = ((float)  tolua_tonumber(tolua_S,4,0));
03269   {
03270    fawkes::MotorInterface::LinTransRotMessage* tolua_ret = (fawkes::MotorInterface::LinTransRotMessage*)  new fawkes::MotorInterface::LinTransRotMessage(ini_vx,ini_vy,ini_omega);
03271    tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::MotorInterface::LinTransRotMessage");
03272   }
03273  }
03274  return 1;
03275 #ifndef TOLUA_RELEASE
03276  tolua_lerror:
03277  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
03278  return 0;
03279 #endif
03280 }
03281 #endif //#ifndef TOLUA_DISABLE
03282 
03283 /* method: new_local of class  LinTransRotMessage */
03284 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_LinTransRotMessage_new00_local
03285 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_LinTransRotMessage_new00_local(lua_State* tolua_S)
03286 {
03287 #ifndef TOLUA_RELEASE
03288  tolua_Error tolua_err;
03289  if (
03290      !tolua_isusertable(tolua_S,1,"fawkes::MotorInterface::LinTransRotMessage",0,&tolua_err) ||
03291      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
03292      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
03293      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
03294      !tolua_isnoobj(tolua_S,5,&tolua_err)
03295  )
03296   goto tolua_lerror;
03297  else
03298 #endif
03299  {
03300   float ini_vx = ((float)  tolua_tonumber(tolua_S,2,0));
03301   float ini_vy = ((float)  tolua_tonumber(tolua_S,3,0));
03302   float ini_omega = ((float)  tolua_tonumber(tolua_S,4,0));
03303   {
03304    fawkes::MotorInterface::LinTransRotMessage* tolua_ret = (fawkes::MotorInterface::LinTransRotMessage*)  new fawkes::MotorInterface::LinTransRotMessage(ini_vx,ini_vy,ini_omega);
03305    tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"fawkes::MotorInterface::LinTransRotMessage");
03306   }
03307  }
03308  return 1;
03309 #ifndef TOLUA_RELEASE
03310  tolua_lerror:
03311  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
03312  return 0;
03313 #endif
03314 }
03315 #endif //#ifndef TOLUA_DISABLE
03316 
03317 /* method: new of class  LinTransRotMessage */
03318 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_LinTransRotMessage_new01
03319 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_LinTransRotMessage_new01(lua_State* tolua_S)
03320 {
03321  tolua_Error tolua_err;
03322  if (
03323      !tolua_isusertable(tolua_S,1,"fawkes::MotorInterface::LinTransRotMessage",0,&tolua_err) ||
03324      !tolua_isnoobj(tolua_S,2,&tolua_err)
03325  )
03326   goto tolua_lerror;
03327  else
03328  {
03329   {
03330    fawkes::MotorInterface::LinTransRotMessage* tolua_ret = (fawkes::MotorInterface::LinTransRotMessage*)  new fawkes::MotorInterface::LinTransRotMessage();
03331    tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::MotorInterface::LinTransRotMessage");
03332   }
03333  }
03334  return 1;
03335 tolua_lerror:
03336  return tolua_interfaces_MotorInterface_fawkes_MotorInterface_LinTransRotMessage_new00(tolua_S);
03337 }
03338 #endif //#ifndef TOLUA_DISABLE
03339 
03340 /* method: new_local of class  LinTransRotMessage */
03341 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_LinTransRotMessage_new01_local
03342 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_LinTransRotMessage_new01_local(lua_State* tolua_S)
03343 {
03344  tolua_Error tolua_err;
03345  if (
03346      !tolua_isusertable(tolua_S,1,"fawkes::MotorInterface::LinTransRotMessage",0,&tolua_err) ||
03347      !tolua_isnoobj(tolua_S,2,&tolua_err)
03348  )
03349   goto tolua_lerror;
03350  else
03351  {
03352   {
03353    fawkes::MotorInterface::LinTransRotMessage* tolua_ret = (fawkes::MotorInterface::LinTransRotMessage*)  new fawkes::MotorInterface::LinTransRotMessage();
03354    tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"fawkes::MotorInterface::LinTransRotMessage");
03355   }
03356  }
03357  return 1;
03358 tolua_lerror:
03359  return tolua_interfaces_MotorInterface_fawkes_MotorInterface_LinTransRotMessage_new00_local(tolua_S);
03360 }
03361 #endif //#ifndef TOLUA_DISABLE
03362 
03363 /* method: delete of class  LinTransRotMessage */
03364 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_LinTransRotMessage_delete00
03365 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_LinTransRotMessage_delete00(lua_State* tolua_S)
03366 {
03367 #ifndef TOLUA_RELEASE
03368  tolua_Error tolua_err;
03369  if (
03370      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface::LinTransRotMessage",0,&tolua_err) ||
03371      !tolua_isnoobj(tolua_S,2,&tolua_err)
03372  )
03373   goto tolua_lerror;
03374  else
03375 #endif
03376  {
03377   fawkes::MotorInterface::LinTransRotMessage* self = (fawkes::MotorInterface::LinTransRotMessage*)  tolua_tousertype(tolua_S,1,0);
03378 #ifndef TOLUA_RELEASE
03379   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
03380 #endif
03381   delete self;
03382  }
03383  return 0;
03384 #ifndef TOLUA_RELEASE
03385  tolua_lerror:
03386  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
03387  return 0;
03388 #endif
03389 }
03390 #endif //#ifndef TOLUA_DISABLE
03391 
03392 /* method: vx of class  LinTransRotMessage */
03393 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_LinTransRotMessage_vx00
03394 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_LinTransRotMessage_vx00(lua_State* tolua_S)
03395 {
03396 #ifndef TOLUA_RELEASE
03397  tolua_Error tolua_err;
03398  if (
03399      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface::LinTransRotMessage",0,&tolua_err) ||
03400      !tolua_isnoobj(tolua_S,2,&tolua_err)
03401  )
03402   goto tolua_lerror;
03403  else
03404 #endif
03405  {
03406   fawkes::MotorInterface::LinTransRotMessage* self = (fawkes::MotorInterface::LinTransRotMessage*)  tolua_tousertype(tolua_S,1,0);
03407 #ifndef TOLUA_RELEASE
03408   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'vx'",NULL);
03409 #endif
03410   {
03411    float tolua_ret = (float)  self->vx();
03412    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03413   }
03414  }
03415  return 1;
03416 #ifndef TOLUA_RELEASE
03417  tolua_lerror:
03418  tolua_error(tolua_S,"#ferror in function 'vx'.",&tolua_err);
03419  return 0;
03420 #endif
03421 }
03422 #endif //#ifndef TOLUA_DISABLE
03423 
03424 /* method: set_vx of class  LinTransRotMessage */
03425 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_LinTransRotMessage_set_vx00
03426 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_LinTransRotMessage_set_vx00(lua_State* tolua_S)
03427 {
03428 #ifndef TOLUA_RELEASE
03429  tolua_Error tolua_err;
03430  if (
03431      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface::LinTransRotMessage",0,&tolua_err) ||
03432      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
03433      !tolua_isnoobj(tolua_S,3,&tolua_err)
03434  )
03435   goto tolua_lerror;
03436  else
03437 #endif
03438  {
03439   fawkes::MotorInterface::LinTransRotMessage* self = (fawkes::MotorInterface::LinTransRotMessage*)  tolua_tousertype(tolua_S,1,0);
03440   const float new_vx = ((const float)  tolua_tonumber(tolua_S,2,0));
03441 #ifndef TOLUA_RELEASE
03442   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_vx'",NULL);
03443 #endif
03444   {
03445    self->set_vx(new_vx);
03446   }
03447  }
03448  return 0;
03449 #ifndef TOLUA_RELEASE
03450  tolua_lerror:
03451  tolua_error(tolua_S,"#ferror in function 'set_vx'.",&tolua_err);
03452  return 0;
03453 #endif
03454 }
03455 #endif //#ifndef TOLUA_DISABLE
03456 
03457 /* method: maxlenof_vx of class  LinTransRotMessage */
03458 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_LinTransRotMessage_maxlenof_vx00
03459 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_LinTransRotMessage_maxlenof_vx00(lua_State* tolua_S)
03460 {
03461 #ifndef TOLUA_RELEASE
03462  tolua_Error tolua_err;
03463  if (
03464      !tolua_isusertype(tolua_S,1,"const fawkes::MotorInterface::LinTransRotMessage",0,&tolua_err) ||
03465      !tolua_isnoobj(tolua_S,2,&tolua_err)
03466  )
03467   goto tolua_lerror;
03468  else
03469 #endif
03470  {
03471   const fawkes::MotorInterface::LinTransRotMessage* self = (const fawkes::MotorInterface::LinTransRotMessage*)  tolua_tousertype(tolua_S,1,0);
03472 #ifndef TOLUA_RELEASE
03473   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_vx'",NULL);
03474 #endif
03475   {
03476    int tolua_ret = (int)  self->maxlenof_vx();
03477    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03478   }
03479  }
03480  return 1;
03481 #ifndef TOLUA_RELEASE
03482  tolua_lerror:
03483  tolua_error(tolua_S,"#ferror in function 'maxlenof_vx'.",&tolua_err);
03484  return 0;
03485 #endif
03486 }
03487 #endif //#ifndef TOLUA_DISABLE
03488 
03489 /* method: vy of class  LinTransRotMessage */
03490 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_LinTransRotMessage_vy00
03491 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_LinTransRotMessage_vy00(lua_State* tolua_S)
03492 {
03493 #ifndef TOLUA_RELEASE
03494  tolua_Error tolua_err;
03495  if (
03496      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface::LinTransRotMessage",0,&tolua_err) ||
03497      !tolua_isnoobj(tolua_S,2,&tolua_err)
03498  )
03499   goto tolua_lerror;
03500  else
03501 #endif
03502  {
03503   fawkes::MotorInterface::LinTransRotMessage* self = (fawkes::MotorInterface::LinTransRotMessage*)  tolua_tousertype(tolua_S,1,0);
03504 #ifndef TOLUA_RELEASE
03505   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'vy'",NULL);
03506 #endif
03507   {
03508    float tolua_ret = (float)  self->vy();
03509    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03510   }
03511  }
03512  return 1;
03513 #ifndef TOLUA_RELEASE
03514  tolua_lerror:
03515  tolua_error(tolua_S,"#ferror in function 'vy'.",&tolua_err);
03516  return 0;
03517 #endif
03518 }
03519 #endif //#ifndef TOLUA_DISABLE
03520 
03521 /* method: set_vy of class  LinTransRotMessage */
03522 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_LinTransRotMessage_set_vy00
03523 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_LinTransRotMessage_set_vy00(lua_State* tolua_S)
03524 {
03525 #ifndef TOLUA_RELEASE
03526  tolua_Error tolua_err;
03527  if (
03528      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface::LinTransRotMessage",0,&tolua_err) ||
03529      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
03530      !tolua_isnoobj(tolua_S,3,&tolua_err)
03531  )
03532   goto tolua_lerror;
03533  else
03534 #endif
03535  {
03536   fawkes::MotorInterface::LinTransRotMessage* self = (fawkes::MotorInterface::LinTransRotMessage*)  tolua_tousertype(tolua_S,1,0);
03537   const float new_vy = ((const float)  tolua_tonumber(tolua_S,2,0));
03538 #ifndef TOLUA_RELEASE
03539   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_vy'",NULL);
03540 #endif
03541   {
03542    self->set_vy(new_vy);
03543   }
03544  }
03545  return 0;
03546 #ifndef TOLUA_RELEASE
03547  tolua_lerror:
03548  tolua_error(tolua_S,"#ferror in function 'set_vy'.",&tolua_err);
03549  return 0;
03550 #endif
03551 }
03552 #endif //#ifndef TOLUA_DISABLE
03553 
03554 /* method: maxlenof_vy of class  LinTransRotMessage */
03555 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_LinTransRotMessage_maxlenof_vy00
03556 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_LinTransRotMessage_maxlenof_vy00(lua_State* tolua_S)
03557 {
03558 #ifndef TOLUA_RELEASE
03559  tolua_Error tolua_err;
03560  if (
03561      !tolua_isusertype(tolua_S,1,"const fawkes::MotorInterface::LinTransRotMessage",0,&tolua_err) ||
03562      !tolua_isnoobj(tolua_S,2,&tolua_err)
03563  )
03564   goto tolua_lerror;
03565  else
03566 #endif
03567  {
03568   const fawkes::MotorInterface::LinTransRotMessage* self = (const fawkes::MotorInterface::LinTransRotMessage*)  tolua_tousertype(tolua_S,1,0);
03569 #ifndef TOLUA_RELEASE
03570   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_vy'",NULL);
03571 #endif
03572   {
03573    int tolua_ret = (int)  self->maxlenof_vy();
03574    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03575   }
03576  }
03577  return 1;
03578 #ifndef TOLUA_RELEASE
03579  tolua_lerror:
03580  tolua_error(tolua_S,"#ferror in function 'maxlenof_vy'.",&tolua_err);
03581  return 0;
03582 #endif
03583 }
03584 #endif //#ifndef TOLUA_DISABLE
03585 
03586 /* method: omega of class  LinTransRotMessage */
03587 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_LinTransRotMessage_omega00
03588 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_LinTransRotMessage_omega00(lua_State* tolua_S)
03589 {
03590 #ifndef TOLUA_RELEASE
03591  tolua_Error tolua_err;
03592  if (
03593      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface::LinTransRotMessage",0,&tolua_err) ||
03594      !tolua_isnoobj(tolua_S,2,&tolua_err)
03595  )
03596   goto tolua_lerror;
03597  else
03598 #endif
03599  {
03600   fawkes::MotorInterface::LinTransRotMessage* self = (fawkes::MotorInterface::LinTransRotMessage*)  tolua_tousertype(tolua_S,1,0);
03601 #ifndef TOLUA_RELEASE
03602   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'omega'",NULL);
03603 #endif
03604   {
03605    float tolua_ret = (float)  self->omega();
03606    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03607   }
03608  }
03609  return 1;
03610 #ifndef TOLUA_RELEASE
03611  tolua_lerror:
03612  tolua_error(tolua_S,"#ferror in function 'omega'.",&tolua_err);
03613  return 0;
03614 #endif
03615 }
03616 #endif //#ifndef TOLUA_DISABLE
03617 
03618 /* method: set_omega of class  LinTransRotMessage */
03619 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_LinTransRotMessage_set_omega00
03620 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_LinTransRotMessage_set_omega00(lua_State* tolua_S)
03621 {
03622 #ifndef TOLUA_RELEASE
03623  tolua_Error tolua_err;
03624  if (
03625      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface::LinTransRotMessage",0,&tolua_err) ||
03626      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
03627      !tolua_isnoobj(tolua_S,3,&tolua_err)
03628  )
03629   goto tolua_lerror;
03630  else
03631 #endif
03632  {
03633   fawkes::MotorInterface::LinTransRotMessage* self = (fawkes::MotorInterface::LinTransRotMessage*)  tolua_tousertype(tolua_S,1,0);
03634   const float new_omega = ((const float)  tolua_tonumber(tolua_S,2,0));
03635 #ifndef TOLUA_RELEASE
03636   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_omega'",NULL);
03637 #endif
03638   {
03639    self->set_omega(new_omega);
03640   }
03641  }
03642  return 0;
03643 #ifndef TOLUA_RELEASE
03644  tolua_lerror:
03645  tolua_error(tolua_S,"#ferror in function 'set_omega'.",&tolua_err);
03646  return 0;
03647 #endif
03648 }
03649 #endif //#ifndef TOLUA_DISABLE
03650 
03651 /* method: maxlenof_omega of class  LinTransRotMessage */
03652 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_LinTransRotMessage_maxlenof_omega00
03653 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_LinTransRotMessage_maxlenof_omega00(lua_State* tolua_S)
03654 {
03655 #ifndef TOLUA_RELEASE
03656  tolua_Error tolua_err;
03657  if (
03658      !tolua_isusertype(tolua_S,1,"const fawkes::MotorInterface::LinTransRotMessage",0,&tolua_err) ||
03659      !tolua_isnoobj(tolua_S,2,&tolua_err)
03660  )
03661   goto tolua_lerror;
03662  else
03663 #endif
03664  {
03665   const fawkes::MotorInterface::LinTransRotMessage* self = (const fawkes::MotorInterface::LinTransRotMessage*)  tolua_tousertype(tolua_S,1,0);
03666 #ifndef TOLUA_RELEASE
03667   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_omega'",NULL);
03668 #endif
03669   {
03670    int tolua_ret = (int)  self->maxlenof_omega();
03671    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03672   }
03673  }
03674  return 1;
03675 #ifndef TOLUA_RELEASE
03676  tolua_lerror:
03677  tolua_error(tolua_S,"#ferror in function 'maxlenof_omega'.",&tolua_err);
03678  return 0;
03679 #endif
03680 }
03681 #endif //#ifndef TOLUA_DISABLE
03682 
03683 /* method: motor_state of class  fawkes::MotorInterface */
03684 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_motor_state00
03685 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_motor_state00(lua_State* tolua_S)
03686 {
03687 #ifndef TOLUA_RELEASE
03688  tolua_Error tolua_err;
03689  if (
03690      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface",0,&tolua_err) ||
03691      !tolua_isnoobj(tolua_S,2,&tolua_err)
03692  )
03693   goto tolua_lerror;
03694  else
03695 #endif
03696  {
03697   fawkes::MotorInterface* self = (fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
03698 #ifndef TOLUA_RELEASE
03699   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'motor_state'",NULL);
03700 #endif
03701   {
03702    unsigned int tolua_ret = (unsigned int)  self->motor_state();
03703    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03704   }
03705  }
03706  return 1;
03707 #ifndef TOLUA_RELEASE
03708  tolua_lerror:
03709  tolua_error(tolua_S,"#ferror in function 'motor_state'.",&tolua_err);
03710  return 0;
03711 #endif
03712 }
03713 #endif //#ifndef TOLUA_DISABLE
03714 
03715 /* method: set_motor_state of class  fawkes::MotorInterface */
03716 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_set_motor_state00
03717 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_set_motor_state00(lua_State* tolua_S)
03718 {
03719 #ifndef TOLUA_RELEASE
03720  tolua_Error tolua_err;
03721  if (
03722      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface",0,&tolua_err) ||
03723      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
03724      !tolua_isnoobj(tolua_S,3,&tolua_err)
03725  )
03726   goto tolua_lerror;
03727  else
03728 #endif
03729  {
03730   fawkes::MotorInterface* self = (fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
03731   unsigned const int new_motor_state = ((unsigned const int)  tolua_tonumber(tolua_S,2,0));
03732 #ifndef TOLUA_RELEASE
03733   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_motor_state'",NULL);
03734 #endif
03735   {
03736    self->set_motor_state(new_motor_state);
03737   }
03738  }
03739  return 0;
03740 #ifndef TOLUA_RELEASE
03741  tolua_lerror:
03742  tolua_error(tolua_S,"#ferror in function 'set_motor_state'.",&tolua_err);
03743  return 0;
03744 #endif
03745 }
03746 #endif //#ifndef TOLUA_DISABLE
03747 
03748 /* method: maxlenof_motor_state of class  fawkes::MotorInterface */
03749 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_maxlenof_motor_state00
03750 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_maxlenof_motor_state00(lua_State* tolua_S)
03751 {
03752 #ifndef TOLUA_RELEASE
03753  tolua_Error tolua_err;
03754  if (
03755      !tolua_isusertype(tolua_S,1,"const fawkes::MotorInterface",0,&tolua_err) ||
03756      !tolua_isnoobj(tolua_S,2,&tolua_err)
03757  )
03758   goto tolua_lerror;
03759  else
03760 #endif
03761  {
03762   const fawkes::MotorInterface* self = (const fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
03763 #ifndef TOLUA_RELEASE
03764   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_motor_state'",NULL);
03765 #endif
03766   {
03767    int tolua_ret = (int)  self->maxlenof_motor_state();
03768    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03769   }
03770  }
03771  return 1;
03772 #ifndef TOLUA_RELEASE
03773  tolua_lerror:
03774  tolua_error(tolua_S,"#ferror in function 'maxlenof_motor_state'.",&tolua_err);
03775  return 0;
03776 #endif
03777 }
03778 #endif //#ifndef TOLUA_DISABLE
03779 
03780 /* method: drive_mode of class  fawkes::MotorInterface */
03781 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_drive_mode00
03782 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_drive_mode00(lua_State* tolua_S)
03783 {
03784 #ifndef TOLUA_RELEASE
03785  tolua_Error tolua_err;
03786  if (
03787      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface",0,&tolua_err) ||
03788      !tolua_isnoobj(tolua_S,2,&tolua_err)
03789  )
03790   goto tolua_lerror;
03791  else
03792 #endif
03793  {
03794   fawkes::MotorInterface* self = (fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
03795 #ifndef TOLUA_RELEASE
03796   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'drive_mode'",NULL);
03797 #endif
03798   {
03799    unsigned int tolua_ret = (unsigned int)  self->drive_mode();
03800    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03801   }
03802  }
03803  return 1;
03804 #ifndef TOLUA_RELEASE
03805  tolua_lerror:
03806  tolua_error(tolua_S,"#ferror in function 'drive_mode'.",&tolua_err);
03807  return 0;
03808 #endif
03809 }
03810 #endif //#ifndef TOLUA_DISABLE
03811 
03812 /* method: set_drive_mode of class  fawkes::MotorInterface */
03813 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_set_drive_mode00
03814 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_set_drive_mode00(lua_State* tolua_S)
03815 {
03816 #ifndef TOLUA_RELEASE
03817  tolua_Error tolua_err;
03818  if (
03819      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface",0,&tolua_err) ||
03820      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
03821      !tolua_isnoobj(tolua_S,3,&tolua_err)
03822  )
03823   goto tolua_lerror;
03824  else
03825 #endif
03826  {
03827   fawkes::MotorInterface* self = (fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
03828   unsigned const int new_drive_mode = ((unsigned const int)  tolua_tonumber(tolua_S,2,0));
03829 #ifndef TOLUA_RELEASE
03830   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_drive_mode'",NULL);
03831 #endif
03832   {
03833    self->set_drive_mode(new_drive_mode);
03834   }
03835  }
03836  return 0;
03837 #ifndef TOLUA_RELEASE
03838  tolua_lerror:
03839  tolua_error(tolua_S,"#ferror in function 'set_drive_mode'.",&tolua_err);
03840  return 0;
03841 #endif
03842 }
03843 #endif //#ifndef TOLUA_DISABLE
03844 
03845 /* method: maxlenof_drive_mode of class  fawkes::MotorInterface */
03846 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_maxlenof_drive_mode00
03847 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_maxlenof_drive_mode00(lua_State* tolua_S)
03848 {
03849 #ifndef TOLUA_RELEASE
03850  tolua_Error tolua_err;
03851  if (
03852      !tolua_isusertype(tolua_S,1,"const fawkes::MotorInterface",0,&tolua_err) ||
03853      !tolua_isnoobj(tolua_S,2,&tolua_err)
03854  )
03855   goto tolua_lerror;
03856  else
03857 #endif
03858  {
03859   const fawkes::MotorInterface* self = (const fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
03860 #ifndef TOLUA_RELEASE
03861   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_drive_mode'",NULL);
03862 #endif
03863   {
03864    int tolua_ret = (int)  self->maxlenof_drive_mode();
03865    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03866   }
03867  }
03868  return 1;
03869 #ifndef TOLUA_RELEASE
03870  tolua_lerror:
03871  tolua_error(tolua_S,"#ferror in function 'maxlenof_drive_mode'.",&tolua_err);
03872  return 0;
03873 #endif
03874 }
03875 #endif //#ifndef TOLUA_DISABLE
03876 
03877 /* method: right_rpm of class  fawkes::MotorInterface */
03878 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_right_rpm00
03879 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_right_rpm00(lua_State* tolua_S)
03880 {
03881 #ifndef TOLUA_RELEASE
03882  tolua_Error tolua_err;
03883  if (
03884      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface",0,&tolua_err) ||
03885      !tolua_isnoobj(tolua_S,2,&tolua_err)
03886  )
03887   goto tolua_lerror;
03888  else
03889 #endif
03890  {
03891   fawkes::MotorInterface* self = (fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
03892 #ifndef TOLUA_RELEASE
03893   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'right_rpm'",NULL);
03894 #endif
03895   {
03896    int tolua_ret = (int)  self->right_rpm();
03897    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03898   }
03899  }
03900  return 1;
03901 #ifndef TOLUA_RELEASE
03902  tolua_lerror:
03903  tolua_error(tolua_S,"#ferror in function 'right_rpm'.",&tolua_err);
03904  return 0;
03905 #endif
03906 }
03907 #endif //#ifndef TOLUA_DISABLE
03908 
03909 /* method: set_right_rpm of class  fawkes::MotorInterface */
03910 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_set_right_rpm00
03911 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_set_right_rpm00(lua_State* tolua_S)
03912 {
03913 #ifndef TOLUA_RELEASE
03914  tolua_Error tolua_err;
03915  if (
03916      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface",0,&tolua_err) ||
03917      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
03918      !tolua_isnoobj(tolua_S,3,&tolua_err)
03919  )
03920   goto tolua_lerror;
03921  else
03922 #endif
03923  {
03924   fawkes::MotorInterface* self = (fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
03925   const int new_right_rpm = ((const int)  tolua_tonumber(tolua_S,2,0));
03926 #ifndef TOLUA_RELEASE
03927   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_right_rpm'",NULL);
03928 #endif
03929   {
03930    self->set_right_rpm(new_right_rpm);
03931   }
03932  }
03933  return 0;
03934 #ifndef TOLUA_RELEASE
03935  tolua_lerror:
03936  tolua_error(tolua_S,"#ferror in function 'set_right_rpm'.",&tolua_err);
03937  return 0;
03938 #endif
03939 }
03940 #endif //#ifndef TOLUA_DISABLE
03941 
03942 /* method: maxlenof_right_rpm of class  fawkes::MotorInterface */
03943 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_maxlenof_right_rpm00
03944 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_maxlenof_right_rpm00(lua_State* tolua_S)
03945 {
03946 #ifndef TOLUA_RELEASE
03947  tolua_Error tolua_err;
03948  if (
03949      !tolua_isusertype(tolua_S,1,"const fawkes::MotorInterface",0,&tolua_err) ||
03950      !tolua_isnoobj(tolua_S,2,&tolua_err)
03951  )
03952   goto tolua_lerror;
03953  else
03954 #endif
03955  {
03956   const fawkes::MotorInterface* self = (const fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
03957 #ifndef TOLUA_RELEASE
03958   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_right_rpm'",NULL);
03959 #endif
03960   {
03961    int tolua_ret = (int)  self->maxlenof_right_rpm();
03962    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03963   }
03964  }
03965  return 1;
03966 #ifndef TOLUA_RELEASE
03967  tolua_lerror:
03968  tolua_error(tolua_S,"#ferror in function 'maxlenof_right_rpm'.",&tolua_err);
03969  return 0;
03970 #endif
03971 }
03972 #endif //#ifndef TOLUA_DISABLE
03973 
03974 /* method: rear_rpm of class  fawkes::MotorInterface */
03975 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_rear_rpm00
03976 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_rear_rpm00(lua_State* tolua_S)
03977 {
03978 #ifndef TOLUA_RELEASE
03979  tolua_Error tolua_err;
03980  if (
03981      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface",0,&tolua_err) ||
03982      !tolua_isnoobj(tolua_S,2,&tolua_err)
03983  )
03984   goto tolua_lerror;
03985  else
03986 #endif
03987  {
03988   fawkes::MotorInterface* self = (fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
03989 #ifndef TOLUA_RELEASE
03990   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'rear_rpm'",NULL);
03991 #endif
03992   {
03993    int tolua_ret = (int)  self->rear_rpm();
03994    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03995   }
03996  }
03997  return 1;
03998 #ifndef TOLUA_RELEASE
03999  tolua_lerror:
04000  tolua_error(tolua_S,"#ferror in function 'rear_rpm'.",&tolua_err);
04001  return 0;
04002 #endif
04003 }
04004 #endif //#ifndef TOLUA_DISABLE
04005 
04006 /* method: set_rear_rpm of class  fawkes::MotorInterface */
04007 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_set_rear_rpm00
04008 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_set_rear_rpm00(lua_State* tolua_S)
04009 {
04010 #ifndef TOLUA_RELEASE
04011  tolua_Error tolua_err;
04012  if (
04013      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface",0,&tolua_err) ||
04014      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
04015      !tolua_isnoobj(tolua_S,3,&tolua_err)
04016  )
04017   goto tolua_lerror;
04018  else
04019 #endif
04020  {
04021   fawkes::MotorInterface* self = (fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
04022   const int new_rear_rpm = ((const int)  tolua_tonumber(tolua_S,2,0));
04023 #ifndef TOLUA_RELEASE
04024   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_rear_rpm'",NULL);
04025 #endif
04026   {
04027    self->set_rear_rpm(new_rear_rpm);
04028   }
04029  }
04030  return 0;
04031 #ifndef TOLUA_RELEASE
04032  tolua_lerror:
04033  tolua_error(tolua_S,"#ferror in function 'set_rear_rpm'.",&tolua_err);
04034  return 0;
04035 #endif
04036 }
04037 #endif //#ifndef TOLUA_DISABLE
04038 
04039 /* method: maxlenof_rear_rpm of class  fawkes::MotorInterface */
04040 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_maxlenof_rear_rpm00
04041 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_maxlenof_rear_rpm00(lua_State* tolua_S)
04042 {
04043 #ifndef TOLUA_RELEASE
04044  tolua_Error tolua_err;
04045  if (
04046      !tolua_isusertype(tolua_S,1,"const fawkes::MotorInterface",0,&tolua_err) ||
04047      !tolua_isnoobj(tolua_S,2,&tolua_err)
04048  )
04049   goto tolua_lerror;
04050  else
04051 #endif
04052  {
04053   const fawkes::MotorInterface* self = (const fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
04054 #ifndef TOLUA_RELEASE
04055   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_rear_rpm'",NULL);
04056 #endif
04057   {
04058    int tolua_ret = (int)  self->maxlenof_rear_rpm();
04059    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04060   }
04061  }
04062  return 1;
04063 #ifndef TOLUA_RELEASE
04064  tolua_lerror:
04065  tolua_error(tolua_S,"#ferror in function 'maxlenof_rear_rpm'.",&tolua_err);
04066  return 0;
04067 #endif
04068 }
04069 #endif //#ifndef TOLUA_DISABLE
04070 
04071 /* method: left_rpm of class  fawkes::MotorInterface */
04072 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_left_rpm00
04073 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_left_rpm00(lua_State* tolua_S)
04074 {
04075 #ifndef TOLUA_RELEASE
04076  tolua_Error tolua_err;
04077  if (
04078      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface",0,&tolua_err) ||
04079      !tolua_isnoobj(tolua_S,2,&tolua_err)
04080  )
04081   goto tolua_lerror;
04082  else
04083 #endif
04084  {
04085   fawkes::MotorInterface* self = (fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
04086 #ifndef TOLUA_RELEASE
04087   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'left_rpm'",NULL);
04088 #endif
04089   {
04090    int tolua_ret = (int)  self->left_rpm();
04091    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04092   }
04093  }
04094  return 1;
04095 #ifndef TOLUA_RELEASE
04096  tolua_lerror:
04097  tolua_error(tolua_S,"#ferror in function 'left_rpm'.",&tolua_err);
04098  return 0;
04099 #endif
04100 }
04101 #endif //#ifndef TOLUA_DISABLE
04102 
04103 /* method: set_left_rpm of class  fawkes::MotorInterface */
04104 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_set_left_rpm00
04105 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_set_left_rpm00(lua_State* tolua_S)
04106 {
04107 #ifndef TOLUA_RELEASE
04108  tolua_Error tolua_err;
04109  if (
04110      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface",0,&tolua_err) ||
04111      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
04112      !tolua_isnoobj(tolua_S,3,&tolua_err)
04113  )
04114   goto tolua_lerror;
04115  else
04116 #endif
04117  {
04118   fawkes::MotorInterface* self = (fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
04119   const int new_left_rpm = ((const int)  tolua_tonumber(tolua_S,2,0));
04120 #ifndef TOLUA_RELEASE
04121   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_left_rpm'",NULL);
04122 #endif
04123   {
04124    self->set_left_rpm(new_left_rpm);
04125   }
04126  }
04127  return 0;
04128 #ifndef TOLUA_RELEASE
04129  tolua_lerror:
04130  tolua_error(tolua_S,"#ferror in function 'set_left_rpm'.",&tolua_err);
04131  return 0;
04132 #endif
04133 }
04134 #endif //#ifndef TOLUA_DISABLE
04135 
04136 /* method: maxlenof_left_rpm of class  fawkes::MotorInterface */
04137 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_maxlenof_left_rpm00
04138 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_maxlenof_left_rpm00(lua_State* tolua_S)
04139 {
04140 #ifndef TOLUA_RELEASE
04141  tolua_Error tolua_err;
04142  if (
04143      !tolua_isusertype(tolua_S,1,"const fawkes::MotorInterface",0,&tolua_err) ||
04144      !tolua_isnoobj(tolua_S,2,&tolua_err)
04145  )
04146   goto tolua_lerror;
04147  else
04148 #endif
04149  {
04150   const fawkes::MotorInterface* self = (const fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
04151 #ifndef TOLUA_RELEASE
04152   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_left_rpm'",NULL);
04153 #endif
04154   {
04155    int tolua_ret = (int)  self->maxlenof_left_rpm();
04156    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04157   }
04158  }
04159  return 1;
04160 #ifndef TOLUA_RELEASE
04161  tolua_lerror:
04162  tolua_error(tolua_S,"#ferror in function 'maxlenof_left_rpm'.",&tolua_err);
04163  return 0;
04164 #endif
04165 }
04166 #endif //#ifndef TOLUA_DISABLE
04167 
04168 /* method: odometry_path_length of class  fawkes::MotorInterface */
04169 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_odometry_path_length00
04170 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_odometry_path_length00(lua_State* tolua_S)
04171 {
04172 #ifndef TOLUA_RELEASE
04173  tolua_Error tolua_err;
04174  if (
04175      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface",0,&tolua_err) ||
04176      !tolua_isnoobj(tolua_S,2,&tolua_err)
04177  )
04178   goto tolua_lerror;
04179  else
04180 #endif
04181  {
04182   fawkes::MotorInterface* self = (fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
04183 #ifndef TOLUA_RELEASE
04184   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'odometry_path_length'",NULL);
04185 #endif
04186   {
04187    float tolua_ret = (float)  self->odometry_path_length();
04188    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04189   }
04190  }
04191  return 1;
04192 #ifndef TOLUA_RELEASE
04193  tolua_lerror:
04194  tolua_error(tolua_S,"#ferror in function 'odometry_path_length'.",&tolua_err);
04195  return 0;
04196 #endif
04197 }
04198 #endif //#ifndef TOLUA_DISABLE
04199 
04200 /* method: set_odometry_path_length of class  fawkes::MotorInterface */
04201 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_set_odometry_path_length00
04202 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_set_odometry_path_length00(lua_State* tolua_S)
04203 {
04204 #ifndef TOLUA_RELEASE
04205  tolua_Error tolua_err;
04206  if (
04207      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface",0,&tolua_err) ||
04208      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
04209      !tolua_isnoobj(tolua_S,3,&tolua_err)
04210  )
04211   goto tolua_lerror;
04212  else
04213 #endif
04214  {
04215   fawkes::MotorInterface* self = (fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
04216   const float new_odometry_path_length = ((const float)  tolua_tonumber(tolua_S,2,0));
04217 #ifndef TOLUA_RELEASE
04218   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_odometry_path_length'",NULL);
04219 #endif
04220   {
04221    self->set_odometry_path_length(new_odometry_path_length);
04222   }
04223  }
04224  return 0;
04225 #ifndef TOLUA_RELEASE
04226  tolua_lerror:
04227  tolua_error(tolua_S,"#ferror in function 'set_odometry_path_length'.",&tolua_err);
04228  return 0;
04229 #endif
04230 }
04231 #endif //#ifndef TOLUA_DISABLE
04232 
04233 /* method: maxlenof_odometry_path_length of class  fawkes::MotorInterface */
04234 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_maxlenof_odometry_path_length00
04235 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_maxlenof_odometry_path_length00(lua_State* tolua_S)
04236 {
04237 #ifndef TOLUA_RELEASE
04238  tolua_Error tolua_err;
04239  if (
04240      !tolua_isusertype(tolua_S,1,"const fawkes::MotorInterface",0,&tolua_err) ||
04241      !tolua_isnoobj(tolua_S,2,&tolua_err)
04242  )
04243   goto tolua_lerror;
04244  else
04245 #endif
04246  {
04247   const fawkes::MotorInterface* self = (const fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
04248 #ifndef TOLUA_RELEASE
04249   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_odometry_path_length'",NULL);
04250 #endif
04251   {
04252    int tolua_ret = (int)  self->maxlenof_odometry_path_length();
04253    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04254   }
04255  }
04256  return 1;
04257 #ifndef TOLUA_RELEASE
04258  tolua_lerror:
04259  tolua_error(tolua_S,"#ferror in function 'maxlenof_odometry_path_length'.",&tolua_err);
04260  return 0;
04261 #endif
04262 }
04263 #endif //#ifndef TOLUA_DISABLE
04264 
04265 /* method: odometry_position_x of class  fawkes::MotorInterface */
04266 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_odometry_position_x00
04267 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_odometry_position_x00(lua_State* tolua_S)
04268 {
04269 #ifndef TOLUA_RELEASE
04270  tolua_Error tolua_err;
04271  if (
04272      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface",0,&tolua_err) ||
04273      !tolua_isnoobj(tolua_S,2,&tolua_err)
04274  )
04275   goto tolua_lerror;
04276  else
04277 #endif
04278  {
04279   fawkes::MotorInterface* self = (fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
04280 #ifndef TOLUA_RELEASE
04281   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'odometry_position_x'",NULL);
04282 #endif
04283   {
04284    float tolua_ret = (float)  self->odometry_position_x();
04285    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04286   }
04287  }
04288  return 1;
04289 #ifndef TOLUA_RELEASE
04290  tolua_lerror:
04291  tolua_error(tolua_S,"#ferror in function 'odometry_position_x'.",&tolua_err);
04292  return 0;
04293 #endif
04294 }
04295 #endif //#ifndef TOLUA_DISABLE
04296 
04297 /* method: set_odometry_position_x of class  fawkes::MotorInterface */
04298 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_set_odometry_position_x00
04299 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_set_odometry_position_x00(lua_State* tolua_S)
04300 {
04301 #ifndef TOLUA_RELEASE
04302  tolua_Error tolua_err;
04303  if (
04304      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface",0,&tolua_err) ||
04305      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
04306      !tolua_isnoobj(tolua_S,3,&tolua_err)
04307  )
04308   goto tolua_lerror;
04309  else
04310 #endif
04311  {
04312   fawkes::MotorInterface* self = (fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
04313   const float new_odometry_position_x = ((const float)  tolua_tonumber(tolua_S,2,0));
04314 #ifndef TOLUA_RELEASE
04315   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_odometry_position_x'",NULL);
04316 #endif
04317   {
04318    self->set_odometry_position_x(new_odometry_position_x);
04319   }
04320  }
04321  return 0;
04322 #ifndef TOLUA_RELEASE
04323  tolua_lerror:
04324  tolua_error(tolua_S,"#ferror in function 'set_odometry_position_x'.",&tolua_err);
04325  return 0;
04326 #endif
04327 }
04328 #endif //#ifndef TOLUA_DISABLE
04329 
04330 /* method: maxlenof_odometry_position_x of class  fawkes::MotorInterface */
04331 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_maxlenof_odometry_position_x00
04332 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_maxlenof_odometry_position_x00(lua_State* tolua_S)
04333 {
04334 #ifndef TOLUA_RELEASE
04335  tolua_Error tolua_err;
04336  if (
04337      !tolua_isusertype(tolua_S,1,"const fawkes::MotorInterface",0,&tolua_err) ||
04338      !tolua_isnoobj(tolua_S,2,&tolua_err)
04339  )
04340   goto tolua_lerror;
04341  else
04342 #endif
04343  {
04344   const fawkes::MotorInterface* self = (const fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
04345 #ifndef TOLUA_RELEASE
04346   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_odometry_position_x'",NULL);
04347 #endif
04348   {
04349    int tolua_ret = (int)  self->maxlenof_odometry_position_x();
04350    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04351   }
04352  }
04353  return 1;
04354 #ifndef TOLUA_RELEASE
04355  tolua_lerror:
04356  tolua_error(tolua_S,"#ferror in function 'maxlenof_odometry_position_x'.",&tolua_err);
04357  return 0;
04358 #endif
04359 }
04360 #endif //#ifndef TOLUA_DISABLE
04361 
04362 /* method: odometry_position_y of class  fawkes::MotorInterface */
04363 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_odometry_position_y00
04364 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_odometry_position_y00(lua_State* tolua_S)
04365 {
04366 #ifndef TOLUA_RELEASE
04367  tolua_Error tolua_err;
04368  if (
04369      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface",0,&tolua_err) ||
04370      !tolua_isnoobj(tolua_S,2,&tolua_err)
04371  )
04372   goto tolua_lerror;
04373  else
04374 #endif
04375  {
04376   fawkes::MotorInterface* self = (fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
04377 #ifndef TOLUA_RELEASE
04378   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'odometry_position_y'",NULL);
04379 #endif
04380   {
04381    float tolua_ret = (float)  self->odometry_position_y();
04382    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04383   }
04384  }
04385  return 1;
04386 #ifndef TOLUA_RELEASE
04387  tolua_lerror:
04388  tolua_error(tolua_S,"#ferror in function 'odometry_position_y'.",&tolua_err);
04389  return 0;
04390 #endif
04391 }
04392 #endif //#ifndef TOLUA_DISABLE
04393 
04394 /* method: set_odometry_position_y of class  fawkes::MotorInterface */
04395 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_set_odometry_position_y00
04396 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_set_odometry_position_y00(lua_State* tolua_S)
04397 {
04398 #ifndef TOLUA_RELEASE
04399  tolua_Error tolua_err;
04400  if (
04401      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface",0,&tolua_err) ||
04402      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
04403      !tolua_isnoobj(tolua_S,3,&tolua_err)
04404  )
04405   goto tolua_lerror;
04406  else
04407 #endif
04408  {
04409   fawkes::MotorInterface* self = (fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
04410   const float new_odometry_position_y = ((const float)  tolua_tonumber(tolua_S,2,0));
04411 #ifndef TOLUA_RELEASE
04412   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_odometry_position_y'",NULL);
04413 #endif
04414   {
04415    self->set_odometry_position_y(new_odometry_position_y);
04416   }
04417  }
04418  return 0;
04419 #ifndef TOLUA_RELEASE
04420  tolua_lerror:
04421  tolua_error(tolua_S,"#ferror in function 'set_odometry_position_y'.",&tolua_err);
04422  return 0;
04423 #endif
04424 }
04425 #endif //#ifndef TOLUA_DISABLE
04426 
04427 /* method: maxlenof_odometry_position_y of class  fawkes::MotorInterface */
04428 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_maxlenof_odometry_position_y00
04429 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_maxlenof_odometry_position_y00(lua_State* tolua_S)
04430 {
04431 #ifndef TOLUA_RELEASE
04432  tolua_Error tolua_err;
04433  if (
04434      !tolua_isusertype(tolua_S,1,"const fawkes::MotorInterface",0,&tolua_err) ||
04435      !tolua_isnoobj(tolua_S,2,&tolua_err)
04436  )
04437   goto tolua_lerror;
04438  else
04439 #endif
04440  {
04441   const fawkes::MotorInterface* self = (const fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
04442 #ifndef TOLUA_RELEASE
04443   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_odometry_position_y'",NULL);
04444 #endif
04445   {
04446    int tolua_ret = (int)  self->maxlenof_odometry_position_y();
04447    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04448   }
04449  }
04450  return 1;
04451 #ifndef TOLUA_RELEASE
04452  tolua_lerror:
04453  tolua_error(tolua_S,"#ferror in function 'maxlenof_odometry_position_y'.",&tolua_err);
04454  return 0;
04455 #endif
04456 }
04457 #endif //#ifndef TOLUA_DISABLE
04458 
04459 /* method: odometry_orientation of class  fawkes::MotorInterface */
04460 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_odometry_orientation00
04461 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_odometry_orientation00(lua_State* tolua_S)
04462 {
04463 #ifndef TOLUA_RELEASE
04464  tolua_Error tolua_err;
04465  if (
04466      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface",0,&tolua_err) ||
04467      !tolua_isnoobj(tolua_S,2,&tolua_err)
04468  )
04469   goto tolua_lerror;
04470  else
04471 #endif
04472  {
04473   fawkes::MotorInterface* self = (fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
04474 #ifndef TOLUA_RELEASE
04475   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'odometry_orientation'",NULL);
04476 #endif
04477   {
04478    float tolua_ret = (float)  self->odometry_orientation();
04479    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04480   }
04481  }
04482  return 1;
04483 #ifndef TOLUA_RELEASE
04484  tolua_lerror:
04485  tolua_error(tolua_S,"#ferror in function 'odometry_orientation'.",&tolua_err);
04486  return 0;
04487 #endif
04488 }
04489 #endif //#ifndef TOLUA_DISABLE
04490 
04491 /* method: set_odometry_orientation of class  fawkes::MotorInterface */
04492 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_set_odometry_orientation00
04493 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_set_odometry_orientation00(lua_State* tolua_S)
04494 {
04495 #ifndef TOLUA_RELEASE
04496  tolua_Error tolua_err;
04497  if (
04498      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface",0,&tolua_err) ||
04499      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
04500      !tolua_isnoobj(tolua_S,3,&tolua_err)
04501  )
04502   goto tolua_lerror;
04503  else
04504 #endif
04505  {
04506   fawkes::MotorInterface* self = (fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
04507   const float new_odometry_orientation = ((const float)  tolua_tonumber(tolua_S,2,0));
04508 #ifndef TOLUA_RELEASE
04509   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_odometry_orientation'",NULL);
04510 #endif
04511   {
04512    self->set_odometry_orientation(new_odometry_orientation);
04513   }
04514  }
04515  return 0;
04516 #ifndef TOLUA_RELEASE
04517  tolua_lerror:
04518  tolua_error(tolua_S,"#ferror in function 'set_odometry_orientation'.",&tolua_err);
04519  return 0;
04520 #endif
04521 }
04522 #endif //#ifndef TOLUA_DISABLE
04523 
04524 /* method: maxlenof_odometry_orientation of class  fawkes::MotorInterface */
04525 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_maxlenof_odometry_orientation00
04526 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_maxlenof_odometry_orientation00(lua_State* tolua_S)
04527 {
04528 #ifndef TOLUA_RELEASE
04529  tolua_Error tolua_err;
04530  if (
04531      !tolua_isusertype(tolua_S,1,"const fawkes::MotorInterface",0,&tolua_err) ||
04532      !tolua_isnoobj(tolua_S,2,&tolua_err)
04533  )
04534   goto tolua_lerror;
04535  else
04536 #endif
04537  {
04538   const fawkes::MotorInterface* self = (const fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
04539 #ifndef TOLUA_RELEASE
04540   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_odometry_orientation'",NULL);
04541 #endif
04542   {
04543    int tolua_ret = (int)  self->maxlenof_odometry_orientation();
04544    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04545   }
04546  }
04547  return 1;
04548 #ifndef TOLUA_RELEASE
04549  tolua_lerror:
04550  tolua_error(tolua_S,"#ferror in function 'maxlenof_odometry_orientation'.",&tolua_err);
04551  return 0;
04552 #endif
04553 }
04554 #endif //#ifndef TOLUA_DISABLE
04555 
04556 /* method: vx of class  fawkes::MotorInterface */
04557 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_vx00
04558 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_vx00(lua_State* tolua_S)
04559 {
04560 #ifndef TOLUA_RELEASE
04561  tolua_Error tolua_err;
04562  if (
04563      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface",0,&tolua_err) ||
04564      !tolua_isnoobj(tolua_S,2,&tolua_err)
04565  )
04566   goto tolua_lerror;
04567  else
04568 #endif
04569  {
04570   fawkes::MotorInterface* self = (fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
04571 #ifndef TOLUA_RELEASE
04572   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'vx'",NULL);
04573 #endif
04574   {
04575    float tolua_ret = (float)  self->vx();
04576    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04577   }
04578  }
04579  return 1;
04580 #ifndef TOLUA_RELEASE
04581  tolua_lerror:
04582  tolua_error(tolua_S,"#ferror in function 'vx'.",&tolua_err);
04583  return 0;
04584 #endif
04585 }
04586 #endif //#ifndef TOLUA_DISABLE
04587 
04588 /* method: set_vx of class  fawkes::MotorInterface */
04589 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_set_vx00
04590 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_set_vx00(lua_State* tolua_S)
04591 {
04592 #ifndef TOLUA_RELEASE
04593  tolua_Error tolua_err;
04594  if (
04595      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface",0,&tolua_err) ||
04596      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
04597      !tolua_isnoobj(tolua_S,3,&tolua_err)
04598  )
04599   goto tolua_lerror;
04600  else
04601 #endif
04602  {
04603   fawkes::MotorInterface* self = (fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
04604   const float new_vx = ((const float)  tolua_tonumber(tolua_S,2,0));
04605 #ifndef TOLUA_RELEASE
04606   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_vx'",NULL);
04607 #endif
04608   {
04609    self->set_vx(new_vx);
04610   }
04611  }
04612  return 0;
04613 #ifndef TOLUA_RELEASE
04614  tolua_lerror:
04615  tolua_error(tolua_S,"#ferror in function 'set_vx'.",&tolua_err);
04616  return 0;
04617 #endif
04618 }
04619 #endif //#ifndef TOLUA_DISABLE
04620 
04621 /* method: maxlenof_vx of class  fawkes::MotorInterface */
04622 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_maxlenof_vx00
04623 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_maxlenof_vx00(lua_State* tolua_S)
04624 {
04625 #ifndef TOLUA_RELEASE
04626  tolua_Error tolua_err;
04627  if (
04628      !tolua_isusertype(tolua_S,1,"const fawkes::MotorInterface",0,&tolua_err) ||
04629      !tolua_isnoobj(tolua_S,2,&tolua_err)
04630  )
04631   goto tolua_lerror;
04632  else
04633 #endif
04634  {
04635   const fawkes::MotorInterface* self = (const fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
04636 #ifndef TOLUA_RELEASE
04637   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_vx'",NULL);
04638 #endif
04639   {
04640    int tolua_ret = (int)  self->maxlenof_vx();
04641    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04642   }
04643  }
04644  return 1;
04645 #ifndef TOLUA_RELEASE
04646  tolua_lerror:
04647  tolua_error(tolua_S,"#ferror in function 'maxlenof_vx'.",&tolua_err);
04648  return 0;
04649 #endif
04650 }
04651 #endif //#ifndef TOLUA_DISABLE
04652 
04653 /* method: vy of class  fawkes::MotorInterface */
04654 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_vy00
04655 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_vy00(lua_State* tolua_S)
04656 {
04657 #ifndef TOLUA_RELEASE
04658  tolua_Error tolua_err;
04659  if (
04660      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface",0,&tolua_err) ||
04661      !tolua_isnoobj(tolua_S,2,&tolua_err)
04662  )
04663   goto tolua_lerror;
04664  else
04665 #endif
04666  {
04667   fawkes::MotorInterface* self = (fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
04668 #ifndef TOLUA_RELEASE
04669   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'vy'",NULL);
04670 #endif
04671   {
04672    float tolua_ret = (float)  self->vy();
04673    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04674   }
04675  }
04676  return 1;
04677 #ifndef TOLUA_RELEASE
04678  tolua_lerror:
04679  tolua_error(tolua_S,"#ferror in function 'vy'.",&tolua_err);
04680  return 0;
04681 #endif
04682 }
04683 #endif //#ifndef TOLUA_DISABLE
04684 
04685 /* method: set_vy of class  fawkes::MotorInterface */
04686 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_set_vy00
04687 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_set_vy00(lua_State* tolua_S)
04688 {
04689 #ifndef TOLUA_RELEASE
04690  tolua_Error tolua_err;
04691  if (
04692      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface",0,&tolua_err) ||
04693      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
04694      !tolua_isnoobj(tolua_S,3,&tolua_err)
04695  )
04696   goto tolua_lerror;
04697  else
04698 #endif
04699  {
04700   fawkes::MotorInterface* self = (fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
04701   const float new_vy = ((const float)  tolua_tonumber(tolua_S,2,0));
04702 #ifndef TOLUA_RELEASE
04703   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_vy'",NULL);
04704 #endif
04705   {
04706    self->set_vy(new_vy);
04707   }
04708  }
04709  return 0;
04710 #ifndef TOLUA_RELEASE
04711  tolua_lerror:
04712  tolua_error(tolua_S,"#ferror in function 'set_vy'.",&tolua_err);
04713  return 0;
04714 #endif
04715 }
04716 #endif //#ifndef TOLUA_DISABLE
04717 
04718 /* method: maxlenof_vy of class  fawkes::MotorInterface */
04719 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_maxlenof_vy00
04720 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_maxlenof_vy00(lua_State* tolua_S)
04721 {
04722 #ifndef TOLUA_RELEASE
04723  tolua_Error tolua_err;
04724  if (
04725      !tolua_isusertype(tolua_S,1,"const fawkes::MotorInterface",0,&tolua_err) ||
04726      !tolua_isnoobj(tolua_S,2,&tolua_err)
04727  )
04728   goto tolua_lerror;
04729  else
04730 #endif
04731  {
04732   const fawkes::MotorInterface* self = (const fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
04733 #ifndef TOLUA_RELEASE
04734   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_vy'",NULL);
04735 #endif
04736   {
04737    int tolua_ret = (int)  self->maxlenof_vy();
04738    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04739   }
04740  }
04741  return 1;
04742 #ifndef TOLUA_RELEASE
04743  tolua_lerror:
04744  tolua_error(tolua_S,"#ferror in function 'maxlenof_vy'.",&tolua_err);
04745  return 0;
04746 #endif
04747 }
04748 #endif //#ifndef TOLUA_DISABLE
04749 
04750 /* method: omega of class  fawkes::MotorInterface */
04751 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_omega00
04752 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_omega00(lua_State* tolua_S)
04753 {
04754 #ifndef TOLUA_RELEASE
04755  tolua_Error tolua_err;
04756  if (
04757      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface",0,&tolua_err) ||
04758      !tolua_isnoobj(tolua_S,2,&tolua_err)
04759  )
04760   goto tolua_lerror;
04761  else
04762 #endif
04763  {
04764   fawkes::MotorInterface* self = (fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
04765 #ifndef TOLUA_RELEASE
04766   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'omega'",NULL);
04767 #endif
04768   {
04769    float tolua_ret = (float)  self->omega();
04770    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04771   }
04772  }
04773  return 1;
04774 #ifndef TOLUA_RELEASE
04775  tolua_lerror:
04776  tolua_error(tolua_S,"#ferror in function 'omega'.",&tolua_err);
04777  return 0;
04778 #endif
04779 }
04780 #endif //#ifndef TOLUA_DISABLE
04781 
04782 /* method: set_omega of class  fawkes::MotorInterface */
04783 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_set_omega00
04784 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_set_omega00(lua_State* tolua_S)
04785 {
04786 #ifndef TOLUA_RELEASE
04787  tolua_Error tolua_err;
04788  if (
04789      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface",0,&tolua_err) ||
04790      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
04791      !tolua_isnoobj(tolua_S,3,&tolua_err)
04792  )
04793   goto tolua_lerror;
04794  else
04795 #endif
04796  {
04797   fawkes::MotorInterface* self = (fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
04798   const float new_omega = ((const float)  tolua_tonumber(tolua_S,2,0));
04799 #ifndef TOLUA_RELEASE
04800   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_omega'",NULL);
04801 #endif
04802   {
04803    self->set_omega(new_omega);
04804   }
04805  }
04806  return 0;
04807 #ifndef TOLUA_RELEASE
04808  tolua_lerror:
04809  tolua_error(tolua_S,"#ferror in function 'set_omega'.",&tolua_err);
04810  return 0;
04811 #endif
04812 }
04813 #endif //#ifndef TOLUA_DISABLE
04814 
04815 /* method: maxlenof_omega of class  fawkes::MotorInterface */
04816 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_maxlenof_omega00
04817 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_maxlenof_omega00(lua_State* tolua_S)
04818 {
04819 #ifndef TOLUA_RELEASE
04820  tolua_Error tolua_err;
04821  if (
04822      !tolua_isusertype(tolua_S,1,"const fawkes::MotorInterface",0,&tolua_err) ||
04823      !tolua_isnoobj(tolua_S,2,&tolua_err)
04824  )
04825   goto tolua_lerror;
04826  else
04827 #endif
04828  {
04829   const fawkes::MotorInterface* self = (const fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
04830 #ifndef TOLUA_RELEASE
04831   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_omega'",NULL);
04832 #endif
04833   {
04834    int tolua_ret = (int)  self->maxlenof_omega();
04835    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04836   }
04837  }
04838  return 1;
04839 #ifndef TOLUA_RELEASE
04840  tolua_lerror:
04841  tolua_error(tolua_S,"#ferror in function 'maxlenof_omega'.",&tolua_err);
04842  return 0;
04843 #endif
04844 }
04845 #endif //#ifndef TOLUA_DISABLE
04846 
04847 /* method: controller of class  fawkes::MotorInterface */
04848 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_controller00
04849 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_controller00(lua_State* tolua_S)
04850 {
04851 #ifndef TOLUA_RELEASE
04852  tolua_Error tolua_err;
04853  if (
04854      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface",0,&tolua_err) ||
04855      !tolua_isnoobj(tolua_S,2,&tolua_err)
04856  )
04857   goto tolua_lerror;
04858  else
04859 #endif
04860  {
04861   fawkes::MotorInterface* self = (fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
04862 #ifndef TOLUA_RELEASE
04863   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'controller'",NULL);
04864 #endif
04865   {
04866    unsigned int tolua_ret = (unsigned int)  self->controller();
04867    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04868   }
04869  }
04870  return 1;
04871 #ifndef TOLUA_RELEASE
04872  tolua_lerror:
04873  tolua_error(tolua_S,"#ferror in function 'controller'.",&tolua_err);
04874  return 0;
04875 #endif
04876 }
04877 #endif //#ifndef TOLUA_DISABLE
04878 
04879 /* method: set_controller of class  fawkes::MotorInterface */
04880 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_set_controller00
04881 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_set_controller00(lua_State* tolua_S)
04882 {
04883 #ifndef TOLUA_RELEASE
04884  tolua_Error tolua_err;
04885  if (
04886      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface",0,&tolua_err) ||
04887      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
04888      !tolua_isnoobj(tolua_S,3,&tolua_err)
04889  )
04890   goto tolua_lerror;
04891  else
04892 #endif
04893  {
04894   fawkes::MotorInterface* self = (fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
04895   unsigned const int new_controller = ((unsigned const int)  tolua_tonumber(tolua_S,2,0));
04896 #ifndef TOLUA_RELEASE
04897   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_controller'",NULL);
04898 #endif
04899   {
04900    self->set_controller(new_controller);
04901   }
04902  }
04903  return 0;
04904 #ifndef TOLUA_RELEASE
04905  tolua_lerror:
04906  tolua_error(tolua_S,"#ferror in function 'set_controller'.",&tolua_err);
04907  return 0;
04908 #endif
04909 }
04910 #endif //#ifndef TOLUA_DISABLE
04911 
04912 /* method: maxlenof_controller of class  fawkes::MotorInterface */
04913 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_maxlenof_controller00
04914 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_maxlenof_controller00(lua_State* tolua_S)
04915 {
04916 #ifndef TOLUA_RELEASE
04917  tolua_Error tolua_err;
04918  if (
04919      !tolua_isusertype(tolua_S,1,"const fawkes::MotorInterface",0,&tolua_err) ||
04920      !tolua_isnoobj(tolua_S,2,&tolua_err)
04921  )
04922   goto tolua_lerror;
04923  else
04924 #endif
04925  {
04926   const fawkes::MotorInterface* self = (const fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
04927 #ifndef TOLUA_RELEASE
04928   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_controller'",NULL);
04929 #endif
04930   {
04931    int tolua_ret = (int)  self->maxlenof_controller();
04932    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04933   }
04934  }
04935  return 1;
04936 #ifndef TOLUA_RELEASE
04937  tolua_lerror:
04938  tolua_error(tolua_S,"#ferror in function 'maxlenof_controller'.",&tolua_err);
04939  return 0;
04940 #endif
04941 }
04942 #endif //#ifndef TOLUA_DISABLE
04943 
04944 /* method: controller_thread_name of class  fawkes::MotorInterface */
04945 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_controller_thread_name00
04946 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_controller_thread_name00(lua_State* tolua_S)
04947 {
04948 #ifndef TOLUA_RELEASE
04949  tolua_Error tolua_err;
04950  if (
04951      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface",0,&tolua_err) ||
04952      !tolua_isnoobj(tolua_S,2,&tolua_err)
04953  )
04954   goto tolua_lerror;
04955  else
04956 #endif
04957  {
04958   fawkes::MotorInterface* self = (fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
04959 #ifndef TOLUA_RELEASE
04960   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'controller_thread_name'",NULL);
04961 #endif
04962   {
04963    char* tolua_ret = (char*)  self->controller_thread_name();
04964    tolua_pushstring(tolua_S,(const char*)tolua_ret);
04965   }
04966  }
04967  return 1;
04968 #ifndef TOLUA_RELEASE
04969  tolua_lerror:
04970  tolua_error(tolua_S,"#ferror in function 'controller_thread_name'.",&tolua_err);
04971  return 0;
04972 #endif
04973 }
04974 #endif //#ifndef TOLUA_DISABLE
04975 
04976 /* method: set_controller_thread_name of class  fawkes::MotorInterface */
04977 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_set_controller_thread_name00
04978 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_set_controller_thread_name00(lua_State* tolua_S)
04979 {
04980 #ifndef TOLUA_RELEASE
04981  tolua_Error tolua_err;
04982  if (
04983      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface",0,&tolua_err) ||
04984      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
04985      !tolua_isnoobj(tolua_S,3,&tolua_err)
04986  )
04987   goto tolua_lerror;
04988  else
04989 #endif
04990  {
04991   fawkes::MotorInterface* self = (fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
04992   const char* new_controller_thread_name = ((const char*)  tolua_tostring(tolua_S,2,0));
04993 #ifndef TOLUA_RELEASE
04994   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_controller_thread_name'",NULL);
04995 #endif
04996   {
04997    self->set_controller_thread_name(new_controller_thread_name);
04998   }
04999  }
05000  return 0;
05001 #ifndef TOLUA_RELEASE
05002  tolua_lerror:
05003  tolua_error(tolua_S,"#ferror in function 'set_controller_thread_name'.",&tolua_err);
05004  return 0;
05005 #endif
05006 }
05007 #endif //#ifndef TOLUA_DISABLE
05008 
05009 /* method: maxlenof_controller_thread_name of class  fawkes::MotorInterface */
05010 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_maxlenof_controller_thread_name00
05011 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_maxlenof_controller_thread_name00(lua_State* tolua_S)
05012 {
05013 #ifndef TOLUA_RELEASE
05014  tolua_Error tolua_err;
05015  if (
05016      !tolua_isusertype(tolua_S,1,"const fawkes::MotorInterface",0,&tolua_err) ||
05017      !tolua_isnoobj(tolua_S,2,&tolua_err)
05018  )
05019   goto tolua_lerror;
05020  else
05021 #endif
05022  {
05023   const fawkes::MotorInterface* self = (const fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
05024 #ifndef TOLUA_RELEASE
05025   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_controller_thread_name'",NULL);
05026 #endif
05027   {
05028    int tolua_ret = (int)  self->maxlenof_controller_thread_name();
05029    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
05030   }
05031  }
05032  return 1;
05033 #ifndef TOLUA_RELEASE
05034  tolua_lerror:
05035  tolua_error(tolua_S,"#ferror in function 'maxlenof_controller_thread_name'.",&tolua_err);
05036  return 0;
05037 #endif
05038 }
05039 #endif //#ifndef TOLUA_DISABLE
05040 
05041 /* method: oftype of class  fawkes::MotorInterface */
05042 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_oftype00
05043 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_oftype00(lua_State* tolua_S)
05044 {
05045 #ifndef TOLUA_RELEASE
05046  tolua_Error tolua_err;
05047  if (
05048      !tolua_isusertype(tolua_S,1,"const fawkes::MotorInterface",0,&tolua_err) ||
05049      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
05050      !tolua_isnoobj(tolua_S,3,&tolua_err)
05051  )
05052   goto tolua_lerror;
05053  else
05054 #endif
05055  {
05056   const fawkes::MotorInterface* self = (const fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
05057   const char* interface_type = ((const char*)  tolua_tostring(tolua_S,2,0));
05058 #ifndef TOLUA_RELEASE
05059   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'oftype'",NULL);
05060 #endif
05061   {
05062    bool tolua_ret = (bool)  self->oftype(interface_type);
05063    tolua_pushboolean(tolua_S,(bool)tolua_ret);
05064   }
05065  }
05066  return 1;
05067 #ifndef TOLUA_RELEASE
05068  tolua_lerror:
05069  tolua_error(tolua_S,"#ferror in function 'oftype'.",&tolua_err);
05070  return 0;
05071 #endif
05072 }
05073 #endif //#ifndef TOLUA_DISABLE
05074 
05075 /* method: datachunk of class  fawkes::MotorInterface */
05076 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_datachunk00
05077 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_datachunk00(lua_State* tolua_S)
05078 {
05079 #ifndef TOLUA_RELEASE
05080  tolua_Error tolua_err;
05081  if (
05082      !tolua_isusertype(tolua_S,1,"const fawkes::MotorInterface",0,&tolua_err) ||
05083      !tolua_isnoobj(tolua_S,2,&tolua_err)
05084  )
05085   goto tolua_lerror;
05086  else
05087 #endif
05088  {
05089   const fawkes::MotorInterface* self = (const fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
05090 #ifndef TOLUA_RELEASE
05091   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datachunk'",NULL);
05092 #endif
05093   {
05094    const void* tolua_ret = (const void*)  self->datachunk();
05095    tolua_pushuserdata(tolua_S,(void*)tolua_ret);
05096   }
05097  }
05098  return 1;
05099 #ifndef TOLUA_RELEASE
05100  tolua_lerror:
05101  tolua_error(tolua_S,"#ferror in function 'datachunk'.",&tolua_err);
05102  return 0;
05103 #endif
05104 }
05105 #endif //#ifndef TOLUA_DISABLE
05106 
05107 /* method: datasize of class  fawkes::MotorInterface */
05108 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_datasize00
05109 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_datasize00(lua_State* tolua_S)
05110 {
05111 #ifndef TOLUA_RELEASE
05112  tolua_Error tolua_err;
05113  if (
05114      !tolua_isusertype(tolua_S,1,"const fawkes::MotorInterface",0,&tolua_err) ||
05115      !tolua_isnoobj(tolua_S,2,&tolua_err)
05116  )
05117   goto tolua_lerror;
05118  else
05119 #endif
05120  {
05121   const fawkes::MotorInterface* self = (const fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
05122 #ifndef TOLUA_RELEASE
05123   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datasize'",NULL);
05124 #endif
05125   {
05126    unsigned int tolua_ret = (unsigned int)  self->datasize();
05127    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
05128   }
05129  }
05130  return 1;
05131 #ifndef TOLUA_RELEASE
05132  tolua_lerror:
05133  tolua_error(tolua_S,"#ferror in function 'datasize'.",&tolua_err);
05134  return 0;
05135 #endif
05136 }
05137 #endif //#ifndef TOLUA_DISABLE
05138 
05139 /* method: type of class  fawkes::MotorInterface */
05140 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_type00
05141 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_type00(lua_State* tolua_S)
05142 {
05143 #ifndef TOLUA_RELEASE
05144  tolua_Error tolua_err;
05145  if (
05146      !tolua_isusertype(tolua_S,1,"const fawkes::MotorInterface",0,&tolua_err) ||
05147      !tolua_isnoobj(tolua_S,2,&tolua_err)
05148  )
05149   goto tolua_lerror;
05150  else
05151 #endif
05152  {
05153   const fawkes::MotorInterface* self = (const fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
05154 #ifndef TOLUA_RELEASE
05155   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'type'",NULL);
05156 #endif
05157   {
05158    const char* tolua_ret = (const char*)  self->type();
05159    tolua_pushstring(tolua_S,(const char*)tolua_ret);
05160   }
05161  }
05162  return 1;
05163 #ifndef TOLUA_RELEASE
05164  tolua_lerror:
05165  tolua_error(tolua_S,"#ferror in function 'type'.",&tolua_err);
05166  return 0;
05167 #endif
05168 }
05169 #endif //#ifndef TOLUA_DISABLE
05170 
05171 /* method: id of class  fawkes::MotorInterface */
05172 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_id00
05173 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_id00(lua_State* tolua_S)
05174 {
05175 #ifndef TOLUA_RELEASE
05176  tolua_Error tolua_err;
05177  if (
05178      !tolua_isusertype(tolua_S,1,"const fawkes::MotorInterface",0,&tolua_err) ||
05179      !tolua_isnoobj(tolua_S,2,&tolua_err)
05180  )
05181   goto tolua_lerror;
05182  else
05183 #endif
05184  {
05185   const fawkes::MotorInterface* self = (const fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
05186 #ifndef TOLUA_RELEASE
05187   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'id'",NULL);
05188 #endif
05189   {
05190    const char* tolua_ret = (const char*)  self->id();
05191    tolua_pushstring(tolua_S,(const char*)tolua_ret);
05192   }
05193  }
05194  return 1;
05195 #ifndef TOLUA_RELEASE
05196  tolua_lerror:
05197  tolua_error(tolua_S,"#ferror in function 'id'.",&tolua_err);
05198  return 0;
05199 #endif
05200 }
05201 #endif //#ifndef TOLUA_DISABLE
05202 
05203 /* method: uid of class  fawkes::MotorInterface */
05204 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_uid00
05205 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_uid00(lua_State* tolua_S)
05206 {
05207 #ifndef TOLUA_RELEASE
05208  tolua_Error tolua_err;
05209  if (
05210      !tolua_isusertype(tolua_S,1,"const fawkes::MotorInterface",0,&tolua_err) ||
05211      !tolua_isnoobj(tolua_S,2,&tolua_err)
05212  )
05213   goto tolua_lerror;
05214  else
05215 #endif
05216  {
05217   const fawkes::MotorInterface* self = (const fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
05218 #ifndef TOLUA_RELEASE
05219   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'uid'",NULL);
05220 #endif
05221   {
05222    const char* tolua_ret = (const char*)  self->uid();
05223    tolua_pushstring(tolua_S,(const char*)tolua_ret);
05224   }
05225  }
05226  return 1;
05227 #ifndef TOLUA_RELEASE
05228  tolua_lerror:
05229  tolua_error(tolua_S,"#ferror in function 'uid'.",&tolua_err);
05230  return 0;
05231 #endif
05232 }
05233 #endif //#ifndef TOLUA_DISABLE
05234 
05235 /* method: serial of class  fawkes::MotorInterface */
05236 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_serial00
05237 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_serial00(lua_State* tolua_S)
05238 {
05239 #ifndef TOLUA_RELEASE
05240  tolua_Error tolua_err;
05241  if (
05242      !tolua_isusertype(tolua_S,1,"const fawkes::MotorInterface",0,&tolua_err) ||
05243      !tolua_isnoobj(tolua_S,2,&tolua_err)
05244  )
05245   goto tolua_lerror;
05246  else
05247 #endif
05248  {
05249   const fawkes::MotorInterface* self = (const fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
05250 #ifndef TOLUA_RELEASE
05251   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'serial'",NULL);
05252 #endif
05253   {
05254    unsigned int tolua_ret = (unsigned int)  self->serial();
05255    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
05256   }
05257  }
05258  return 1;
05259 #ifndef TOLUA_RELEASE
05260  tolua_lerror:
05261  tolua_error(tolua_S,"#ferror in function 'serial'.",&tolua_err);
05262  return 0;
05263 #endif
05264 }
05265 #endif //#ifndef TOLUA_DISABLE
05266 
05267 /* method: mem_serial of class  fawkes::MotorInterface */
05268 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_mem_serial00
05269 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_mem_serial00(lua_State* tolua_S)
05270 {
05271 #ifndef TOLUA_RELEASE
05272  tolua_Error tolua_err;
05273  if (
05274      !tolua_isusertype(tolua_S,1,"const fawkes::MotorInterface",0,&tolua_err) ||
05275      !tolua_isnoobj(tolua_S,2,&tolua_err)
05276  )
05277   goto tolua_lerror;
05278  else
05279 #endif
05280  {
05281   const fawkes::MotorInterface* self = (const fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
05282 #ifndef TOLUA_RELEASE
05283   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'mem_serial'",NULL);
05284 #endif
05285   {
05286    unsigned int tolua_ret = (unsigned int)  self->mem_serial();
05287    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
05288   }
05289  }
05290  return 1;
05291 #ifndef TOLUA_RELEASE
05292  tolua_lerror:
05293  tolua_error(tolua_S,"#ferror in function 'mem_serial'.",&tolua_err);
05294  return 0;
05295 #endif
05296 }
05297 #endif //#ifndef TOLUA_DISABLE
05298 
05299 /* method: operator== of class  fawkes::MotorInterface */
05300 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface__eq00
05301 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface__eq00(lua_State* tolua_S)
05302 {
05303 #ifndef TOLUA_RELEASE
05304  tolua_Error tolua_err;
05305  if (
05306      !tolua_isusertype(tolua_S,1,"const fawkes::MotorInterface",0,&tolua_err) ||
05307      !tolua_isusertype(tolua_S,2,"Interface",0,&tolua_err) ||
05308      !tolua_isnoobj(tolua_S,3,&tolua_err)
05309  )
05310   goto tolua_lerror;
05311  else
05312 #endif
05313  {
05314   const fawkes::MotorInterface* self = (const fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
05315   Interface* comp = ((Interface*)  tolua_tousertype(tolua_S,2,0));
05316 #ifndef TOLUA_RELEASE
05317   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='",NULL);
05318 #endif
05319   {
05320    bool tolua_ret = (bool)  self->operator==(*comp);
05321    tolua_pushboolean(tolua_S,(bool)tolua_ret);
05322   }
05323  }
05324  return 1;
05325 #ifndef TOLUA_RELEASE
05326  tolua_lerror:
05327  tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err);
05328  return 0;
05329 #endif
05330 }
05331 #endif //#ifndef TOLUA_DISABLE
05332 
05333 /* method: hash of class  fawkes::MotorInterface */
05334 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_hash00
05335 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_hash00(lua_State* tolua_S)
05336 {
05337 #ifndef TOLUA_RELEASE
05338  tolua_Error tolua_err;
05339  if (
05340      !tolua_isusertype(tolua_S,1,"const fawkes::MotorInterface",0,&tolua_err) ||
05341      !tolua_isnoobj(tolua_S,2,&tolua_err)
05342  )
05343   goto tolua_lerror;
05344  else
05345 #endif
05346  {
05347   const fawkes::MotorInterface* self = (const fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
05348 #ifndef TOLUA_RELEASE
05349   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash'",NULL);
05350 #endif
05351   {
05352    unsigned const char* tolua_ret = ( unsigned const char*)  self->hash();
05353    tolua_pushstring(tolua_S,(const char*)tolua_ret);
05354   }
05355  }
05356  return 1;
05357 #ifndef TOLUA_RELEASE
05358  tolua_lerror:
05359  tolua_error(tolua_S,"#ferror in function 'hash'.",&tolua_err);
05360  return 0;
05361 #endif
05362 }
05363 #endif //#ifndef TOLUA_DISABLE
05364 
05365 /* method: hash_size of class  fawkes::MotorInterface */
05366 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_hash_size00
05367 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_hash_size00(lua_State* tolua_S)
05368 {
05369 #ifndef TOLUA_RELEASE
05370  tolua_Error tolua_err;
05371  if (
05372      !tolua_isusertype(tolua_S,1,"const fawkes::MotorInterface",0,&tolua_err) ||
05373      !tolua_isnoobj(tolua_S,2,&tolua_err)
05374  )
05375   goto tolua_lerror;
05376  else
05377 #endif
05378  {
05379   const fawkes::MotorInterface* self = (const fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
05380 #ifndef TOLUA_RELEASE
05381   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash_size'",NULL);
05382 #endif
05383   {
05384    int tolua_ret = (int)  self->hash_size();
05385    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
05386   }
05387  }
05388  return 1;
05389 #ifndef TOLUA_RELEASE
05390  tolua_lerror:
05391  tolua_error(tolua_S,"#ferror in function 'hash_size'.",&tolua_err);
05392  return 0;
05393 #endif
05394 }
05395 #endif //#ifndef TOLUA_DISABLE
05396 
05397 /* method: hash_printable of class  fawkes::MotorInterface */
05398 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_hash_printable00
05399 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_hash_printable00(lua_State* tolua_S)
05400 {
05401 #ifndef TOLUA_RELEASE
05402  tolua_Error tolua_err;
05403  if (
05404      !tolua_isusertype(tolua_S,1,"const fawkes::MotorInterface",0,&tolua_err) ||
05405      !tolua_isnoobj(tolua_S,2,&tolua_err)
05406  )
05407   goto tolua_lerror;
05408  else
05409 #endif
05410  {
05411   const fawkes::MotorInterface* self = (const fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
05412 #ifndef TOLUA_RELEASE
05413   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash_printable'",NULL);
05414 #endif
05415   {
05416    const char* tolua_ret = (const char*)  self->hash_printable();
05417    tolua_pushstring(tolua_S,(const char*)tolua_ret);
05418   }
05419  }
05420  return 1;
05421 #ifndef TOLUA_RELEASE
05422  tolua_lerror:
05423  tolua_error(tolua_S,"#ferror in function 'hash_printable'.",&tolua_err);
05424  return 0;
05425 #endif
05426 }
05427 #endif //#ifndef TOLUA_DISABLE
05428 
05429 /* method: is_writer of class  fawkes::MotorInterface */
05430 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_is_writer00
05431 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_is_writer00(lua_State* tolua_S)
05432 {
05433 #ifndef TOLUA_RELEASE
05434  tolua_Error tolua_err;
05435  if (
05436      !tolua_isusertype(tolua_S,1,"const fawkes::MotorInterface",0,&tolua_err) ||
05437      !tolua_isnoobj(tolua_S,2,&tolua_err)
05438  )
05439   goto tolua_lerror;
05440  else
05441 #endif
05442  {
05443   const fawkes::MotorInterface* self = (const fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
05444 #ifndef TOLUA_RELEASE
05445   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_writer'",NULL);
05446 #endif
05447   {
05448    bool tolua_ret = (bool)  self->is_writer();
05449    tolua_pushboolean(tolua_S,(bool)tolua_ret);
05450   }
05451  }
05452  return 1;
05453 #ifndef TOLUA_RELEASE
05454  tolua_lerror:
05455  tolua_error(tolua_S,"#ferror in function 'is_writer'.",&tolua_err);
05456  return 0;
05457 #endif
05458 }
05459 #endif //#ifndef TOLUA_DISABLE
05460 
05461 /* method: set_from_chunk of class  fawkes::MotorInterface */
05462 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_set_from_chunk00
05463 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_set_from_chunk00(lua_State* tolua_S)
05464 {
05465 #ifndef TOLUA_RELEASE
05466  tolua_Error tolua_err;
05467  if (
05468      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface",0,&tolua_err) ||
05469      !tolua_isuserdata(tolua_S,2,0,&tolua_err) ||
05470      !tolua_isnoobj(tolua_S,3,&tolua_err)
05471  )
05472   goto tolua_lerror;
05473  else
05474 #endif
05475  {
05476   fawkes::MotorInterface* self = (fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
05477   void* chunk = ((void*)  tolua_touserdata(tolua_S,2,0));
05478 #ifndef TOLUA_RELEASE
05479   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_from_chunk'",NULL);
05480 #endif
05481   {
05482    self->set_from_chunk(chunk);
05483   }
05484  }
05485  return 0;
05486 #ifndef TOLUA_RELEASE
05487  tolua_lerror:
05488  tolua_error(tolua_S,"#ferror in function 'set_from_chunk'.",&tolua_err);
05489  return 0;
05490 #endif
05491 }
05492 #endif //#ifndef TOLUA_DISABLE
05493 
05494 /* method: create_message of class  fawkes::MotorInterface */
05495 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_create_message00
05496 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_create_message00(lua_State* tolua_S)
05497 {
05498 #ifndef TOLUA_RELEASE
05499  tolua_Error tolua_err;
05500  if (
05501      !tolua_isusertype(tolua_S,1,"const fawkes::MotorInterface",0,&tolua_err) ||
05502      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
05503      !tolua_isnoobj(tolua_S,3,&tolua_err)
05504  )
05505   goto tolua_lerror;
05506  else
05507 #endif
05508  {
05509   const fawkes::MotorInterface* self = (const fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
05510   const char* type = ((const char*)  tolua_tostring(tolua_S,2,0));
05511 #ifndef TOLUA_RELEASE
05512   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'create_message'",NULL);
05513 #endif
05514   {
05515    Message* tolua_ret = (Message*)  self->create_message(type);
05516    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Message");
05517   }
05518  }
05519  return 1;
05520 #ifndef TOLUA_RELEASE
05521  tolua_lerror:
05522  tolua_error(tolua_S,"#ferror in function 'create_message'.",&tolua_err);
05523  return 0;
05524 #endif
05525 }
05526 #endif //#ifndef TOLUA_DISABLE
05527 
05528 /* method: read of class  fawkes::MotorInterface */
05529 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_read00
05530 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_read00(lua_State* tolua_S)
05531 {
05532 #ifndef TOLUA_RELEASE
05533  tolua_Error tolua_err;
05534  if (
05535      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface",0,&tolua_err) ||
05536      !tolua_isnoobj(tolua_S,2,&tolua_err)
05537  )
05538   goto tolua_lerror;
05539  else
05540 #endif
05541  {
05542   fawkes::MotorInterface* self = (fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
05543 #ifndef TOLUA_RELEASE
05544   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'read'",NULL);
05545 #endif
05546   {
05547    self->read();
05548   }
05549  }
05550  return 0;
05551 #ifndef TOLUA_RELEASE
05552  tolua_lerror:
05553  tolua_error(tolua_S,"#ferror in function 'read'.",&tolua_err);
05554  return 0;
05555 #endif
05556 }
05557 #endif //#ifndef TOLUA_DISABLE
05558 
05559 /* method: write of class  fawkes::MotorInterface */
05560 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_write00
05561 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_write00(lua_State* tolua_S)
05562 {
05563 #ifndef TOLUA_RELEASE
05564  tolua_Error tolua_err;
05565  if (
05566      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface",0,&tolua_err) ||
05567      !tolua_isnoobj(tolua_S,2,&tolua_err)
05568  )
05569   goto tolua_lerror;
05570  else
05571 #endif
05572  {
05573   fawkes::MotorInterface* self = (fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
05574 #ifndef TOLUA_RELEASE
05575   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'write'",NULL);
05576 #endif
05577   {
05578    self->write();
05579   }
05580  }
05581  return 0;
05582 #ifndef TOLUA_RELEASE
05583  tolua_lerror:
05584  tolua_error(tolua_S,"#ferror in function 'write'.",&tolua_err);
05585  return 0;
05586 #endif
05587 }
05588 #endif //#ifndef TOLUA_DISABLE
05589 
05590 /* method: has_writer of class  fawkes::MotorInterface */
05591 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_has_writer00
05592 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_has_writer00(lua_State* tolua_S)
05593 {
05594 #ifndef TOLUA_RELEASE
05595  tolua_Error tolua_err;
05596  if (
05597      !tolua_isusertype(tolua_S,1,"const fawkes::MotorInterface",0,&tolua_err) ||
05598      !tolua_isnoobj(tolua_S,2,&tolua_err)
05599  )
05600   goto tolua_lerror;
05601  else
05602 #endif
05603  {
05604   const fawkes::MotorInterface* self = (const fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
05605 #ifndef TOLUA_RELEASE
05606   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'has_writer'",NULL);
05607 #endif
05608   {
05609    bool tolua_ret = (bool)  self->has_writer();
05610    tolua_pushboolean(tolua_S,(bool)tolua_ret);
05611   }
05612  }
05613  return 1;
05614 #ifndef TOLUA_RELEASE
05615  tolua_lerror:
05616  tolua_error(tolua_S,"#ferror in function 'has_writer'.",&tolua_err);
05617  return 0;
05618 #endif
05619 }
05620 #endif //#ifndef TOLUA_DISABLE
05621 
05622 /* method: num_readers of class  fawkes::MotorInterface */
05623 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_num_readers00
05624 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_num_readers00(lua_State* tolua_S)
05625 {
05626 #ifndef TOLUA_RELEASE
05627  tolua_Error tolua_err;
05628  if (
05629      !tolua_isusertype(tolua_S,1,"const fawkes::MotorInterface",0,&tolua_err) ||
05630      !tolua_isnoobj(tolua_S,2,&tolua_err)
05631  )
05632   goto tolua_lerror;
05633  else
05634 #endif
05635  {
05636   const fawkes::MotorInterface* self = (const fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
05637 #ifndef TOLUA_RELEASE
05638   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'num_readers'",NULL);
05639 #endif
05640   {
05641    unsigned int tolua_ret = (unsigned int)  self->num_readers();
05642    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
05643   }
05644  }
05645  return 1;
05646 #ifndef TOLUA_RELEASE
05647  tolua_lerror:
05648  tolua_error(tolua_S,"#ferror in function 'num_readers'.",&tolua_err);
05649  return 0;
05650 #endif
05651 }
05652 #endif //#ifndef TOLUA_DISABLE
05653 
05654 /* method: msgq_enqueue_copy of class  fawkes::MotorInterface */
05655 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_msgq_enqueue_copy00
05656 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_msgq_enqueue_copy00(lua_State* tolua_S)
05657 {
05658 #ifndef TOLUA_RELEASE
05659  tolua_Error tolua_err;
05660  if (
05661      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface",0,&tolua_err) ||
05662      !tolua_isusertype(tolua_S,2,"Message",0,&tolua_err) ||
05663      !tolua_isnoobj(tolua_S,3,&tolua_err)
05664  )
05665   goto tolua_lerror;
05666  else
05667 #endif
05668  {
05669   fawkes::MotorInterface* self = (fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
05670   Message* message = ((Message*)  tolua_tousertype(tolua_S,2,0));
05671 #ifndef TOLUA_RELEASE
05672   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_enqueue_copy'",NULL);
05673 #endif
05674   {
05675    unsigned int tolua_ret = (unsigned int)  self->msgq_enqueue_copy(message);
05676    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
05677   }
05678  }
05679  return 1;
05680 #ifndef TOLUA_RELEASE
05681  tolua_lerror:
05682  tolua_error(tolua_S,"#ferror in function 'msgq_enqueue_copy'.",&tolua_err);
05683  return 0;
05684 #endif
05685 }
05686 #endif //#ifndef TOLUA_DISABLE
05687 
05688 /* method: msgq_remove of class  fawkes::MotorInterface */
05689 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_msgq_remove00
05690 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_msgq_remove00(lua_State* tolua_S)
05691 {
05692 #ifndef TOLUA_RELEASE
05693  tolua_Error tolua_err;
05694  if (
05695      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface",0,&tolua_err) ||
05696      !tolua_isusertype(tolua_S,2,"Message",0,&tolua_err) ||
05697      !tolua_isnoobj(tolua_S,3,&tolua_err)
05698  )
05699   goto tolua_lerror;
05700  else
05701 #endif
05702  {
05703   fawkes::MotorInterface* self = (fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
05704   Message* message = ((Message*)  tolua_tousertype(tolua_S,2,0));
05705 #ifndef TOLUA_RELEASE
05706   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_remove'",NULL);
05707 #endif
05708   {
05709    self->msgq_remove(message);
05710   }
05711  }
05712  return 0;
05713 #ifndef TOLUA_RELEASE
05714  tolua_lerror:
05715  tolua_error(tolua_S,"#ferror in function 'msgq_remove'.",&tolua_err);
05716  return 0;
05717 #endif
05718 }
05719 #endif //#ifndef TOLUA_DISABLE
05720 
05721 /* method: msgq_remove of class  fawkes::MotorInterface */
05722 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_msgq_remove01
05723 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_msgq_remove01(lua_State* tolua_S)
05724 {
05725  tolua_Error tolua_err;
05726  if (
05727      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface",0,&tolua_err) ||
05728      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
05729      !tolua_isnoobj(tolua_S,3,&tolua_err)
05730  )
05731   goto tolua_lerror;
05732  else
05733  {
05734   fawkes::MotorInterface* self = (fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
05735   unsigned int message_id = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
05736 #ifndef TOLUA_RELEASE
05737   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_remove'",NULL);
05738 #endif
05739   {
05740    self->msgq_remove(message_id);
05741   }
05742  }
05743  return 0;
05744 tolua_lerror:
05745  return tolua_interfaces_MotorInterface_fawkes_MotorInterface_msgq_remove00(tolua_S);
05746 }
05747 #endif //#ifndef TOLUA_DISABLE
05748 
05749 /* method: msgq_size of class  fawkes::MotorInterface */
05750 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_msgq_size00
05751 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_msgq_size00(lua_State* tolua_S)
05752 {
05753 #ifndef TOLUA_RELEASE
05754  tolua_Error tolua_err;
05755  if (
05756      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface",0,&tolua_err) ||
05757      !tolua_isnoobj(tolua_S,2,&tolua_err)
05758  )
05759   goto tolua_lerror;
05760  else
05761 #endif
05762  {
05763   fawkes::MotorInterface* self = (fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
05764 #ifndef TOLUA_RELEASE
05765   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_size'",NULL);
05766 #endif
05767   {
05768    unsigned int tolua_ret = (unsigned int)  self->msgq_size();
05769    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
05770   }
05771  }
05772  return 1;
05773 #ifndef TOLUA_RELEASE
05774  tolua_lerror:
05775  tolua_error(tolua_S,"#ferror in function 'msgq_size'.",&tolua_err);
05776  return 0;
05777 #endif
05778 }
05779 #endif //#ifndef TOLUA_DISABLE
05780 
05781 /* method: msgq_flush of class  fawkes::MotorInterface */
05782 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_msgq_flush00
05783 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_msgq_flush00(lua_State* tolua_S)
05784 {
05785 #ifndef TOLUA_RELEASE
05786  tolua_Error tolua_err;
05787  if (
05788      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface",0,&tolua_err) ||
05789      !tolua_isnoobj(tolua_S,2,&tolua_err)
05790  )
05791   goto tolua_lerror;
05792  else
05793 #endif
05794  {
05795   fawkes::MotorInterface* self = (fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
05796 #ifndef TOLUA_RELEASE
05797   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_flush'",NULL);
05798 #endif
05799   {
05800    self->msgq_flush();
05801   }
05802  }
05803  return 0;
05804 #ifndef TOLUA_RELEASE
05805  tolua_lerror:
05806  tolua_error(tolua_S,"#ferror in function 'msgq_flush'.",&tolua_err);
05807  return 0;
05808 #endif
05809 }
05810 #endif //#ifndef TOLUA_DISABLE
05811 
05812 /* method: msgq_lock of class  fawkes::MotorInterface */
05813 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_msgq_lock00
05814 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_msgq_lock00(lua_State* tolua_S)
05815 {
05816 #ifndef TOLUA_RELEASE
05817  tolua_Error tolua_err;
05818  if (
05819      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface",0,&tolua_err) ||
05820      !tolua_isnoobj(tolua_S,2,&tolua_err)
05821  )
05822   goto tolua_lerror;
05823  else
05824 #endif
05825  {
05826   fawkes::MotorInterface* self = (fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
05827 #ifndef TOLUA_RELEASE
05828   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_lock'",NULL);
05829 #endif
05830   {
05831    self->msgq_lock();
05832   }
05833  }
05834  return 0;
05835 #ifndef TOLUA_RELEASE
05836  tolua_lerror:
05837  tolua_error(tolua_S,"#ferror in function 'msgq_lock'.",&tolua_err);
05838  return 0;
05839 #endif
05840 }
05841 #endif //#ifndef TOLUA_DISABLE
05842 
05843 /* method: msgq_try_lock of class  fawkes::MotorInterface */
05844 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_msgq_try_lock00
05845 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_msgq_try_lock00(lua_State* tolua_S)
05846 {
05847 #ifndef TOLUA_RELEASE
05848  tolua_Error tolua_err;
05849  if (
05850      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface",0,&tolua_err) ||
05851      !tolua_isnoobj(tolua_S,2,&tolua_err)
05852  )
05853   goto tolua_lerror;
05854  else
05855 #endif
05856  {
05857   fawkes::MotorInterface* self = (fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
05858 #ifndef TOLUA_RELEASE
05859   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_try_lock'",NULL);
05860 #endif
05861   {
05862    bool tolua_ret = (bool)  self->msgq_try_lock();
05863    tolua_pushboolean(tolua_S,(bool)tolua_ret);
05864   }
05865  }
05866  return 1;
05867 #ifndef TOLUA_RELEASE
05868  tolua_lerror:
05869  tolua_error(tolua_S,"#ferror in function 'msgq_try_lock'.",&tolua_err);
05870  return 0;
05871 #endif
05872 }
05873 #endif //#ifndef TOLUA_DISABLE
05874 
05875 /* method: msgq_unlock of class  fawkes::MotorInterface */
05876 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_msgq_unlock00
05877 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_msgq_unlock00(lua_State* tolua_S)
05878 {
05879 #ifndef TOLUA_RELEASE
05880  tolua_Error tolua_err;
05881  if (
05882      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface",0,&tolua_err) ||
05883      !tolua_isnoobj(tolua_S,2,&tolua_err)
05884  )
05885   goto tolua_lerror;
05886  else
05887 #endif
05888  {
05889   fawkes::MotorInterface* self = (fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
05890 #ifndef TOLUA_RELEASE
05891   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_unlock'",NULL);
05892 #endif
05893   {
05894    self->msgq_unlock();
05895   }
05896  }
05897  return 0;
05898 #ifndef TOLUA_RELEASE
05899  tolua_lerror:
05900  tolua_error(tolua_S,"#ferror in function 'msgq_unlock'.",&tolua_err);
05901  return 0;
05902 #endif
05903 }
05904 #endif //#ifndef TOLUA_DISABLE
05905 
05906 /* method: msgq_pop of class  fawkes::MotorInterface */
05907 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_msgq_pop00
05908 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_msgq_pop00(lua_State* tolua_S)
05909 {
05910 #ifndef TOLUA_RELEASE
05911  tolua_Error tolua_err;
05912  if (
05913      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface",0,&tolua_err) ||
05914      !tolua_isnoobj(tolua_S,2,&tolua_err)
05915  )
05916   goto tolua_lerror;
05917  else
05918 #endif
05919  {
05920   fawkes::MotorInterface* self = (fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
05921 #ifndef TOLUA_RELEASE
05922   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_pop'",NULL);
05923 #endif
05924   {
05925    self->msgq_pop();
05926   }
05927  }
05928  return 0;
05929 #ifndef TOLUA_RELEASE
05930  tolua_lerror:
05931  tolua_error(tolua_S,"#ferror in function 'msgq_pop'.",&tolua_err);
05932  return 0;
05933 #endif
05934 }
05935 #endif //#ifndef TOLUA_DISABLE
05936 
05937 /* method: msgq_first of class  fawkes::MotorInterface */
05938 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_msgq_first00
05939 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_msgq_first00(lua_State* tolua_S)
05940 {
05941 #ifndef TOLUA_RELEASE
05942  tolua_Error tolua_err;
05943  if (
05944      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface",0,&tolua_err) ||
05945      !tolua_isnoobj(tolua_S,2,&tolua_err)
05946  )
05947   goto tolua_lerror;
05948  else
05949 #endif
05950  {
05951   fawkes::MotorInterface* self = (fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
05952 #ifndef TOLUA_RELEASE
05953   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_first'",NULL);
05954 #endif
05955   {
05956    Message* tolua_ret = (Message*)  self->msgq_first();
05957    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Message");
05958   }
05959  }
05960  return 1;
05961 #ifndef TOLUA_RELEASE
05962  tolua_lerror:
05963  tolua_error(tolua_S,"#ferror in function 'msgq_first'.",&tolua_err);
05964  return 0;
05965 #endif
05966 }
05967 #endif //#ifndef TOLUA_DISABLE
05968 
05969 /* method: msgq_empty of class  fawkes::MotorInterface */
05970 #ifndef TOLUA_DISABLE_tolua_interfaces_MotorInterface_fawkes_MotorInterface_msgq_empty00
05971 static int tolua_interfaces_MotorInterface_fawkes_MotorInterface_msgq_empty00(lua_State* tolua_S)
05972 {
05973 #ifndef TOLUA_RELEASE
05974  tolua_Error tolua_err;
05975  if (
05976      !tolua_isusertype(tolua_S,1,"fawkes::MotorInterface",0,&tolua_err) ||
05977      !tolua_isnoobj(tolua_S,2,&tolua_err)
05978  )
05979   goto tolua_lerror;
05980  else
05981 #endif
05982  {
05983   fawkes::MotorInterface* self = (fawkes::MotorInterface*)  tolua_tousertype(tolua_S,1,0);
05984 #ifndef TOLUA_RELEASE
05985   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_empty'",NULL);
05986 #endif
05987   {
05988    bool tolua_ret = (bool)  self->msgq_empty();
05989    tolua_pushboolean(tolua_S,(bool)tolua_ret);
05990   }
05991  }
05992  return 1;
05993 #ifndef TOLUA_RELEASE
05994  tolua_lerror:
05995  tolua_error(tolua_S,"#ferror in function 'msgq_empty'.",&tolua_err);
05996  return 0;
05997 #endif
05998 }
05999 #endif //#ifndef TOLUA_DISABLE
06000 
06001 /* Open function */
06002 TOLUA_API int tolua_interfaces_MotorInterface_open (lua_State* tolua_S)
06003 {
06004  tolua_open(tolua_S);
06005  tolua_reg_types(tolua_S);
06006  tolua_module(tolua_S,NULL,0);
06007  tolua_beginmodule(tolua_S,NULL);
06008   tolua_module(tolua_S,"fawkes",0);
06009   tolua_beginmodule(tolua_S,"fawkes");
06010    tolua_cclass(tolua_S,"MotorInterface","fawkes::MotorInterface","Interface",NULL);
06011    tolua_beginmodule(tolua_S,"MotorInterface");
06012     tolua_variable(tolua_S,"MOTOR_ENABLED",tolua_get_fawkes__MotorInterface_unsigned_MOTOR_ENABLED,NULL);
06013     tolua_variable(tolua_S,"MOTOR_DISABLED",tolua_get_fawkes__MotorInterface_unsigned_MOTOR_DISABLED,NULL);
06014     tolua_variable(tolua_S,"DRIVE_MODE_RPM",tolua_get_fawkes__MotorInterface_unsigned_DRIVE_MODE_RPM,NULL);
06015     tolua_variable(tolua_S,"DRIVE_MODE_TRANS",tolua_get_fawkes__MotorInterface_unsigned_DRIVE_MODE_TRANS,NULL);
06016     tolua_variable(tolua_S,"DRIVE_MODE_ROT",tolua_get_fawkes__MotorInterface_unsigned_DRIVE_MODE_ROT,NULL);
06017     tolua_variable(tolua_S,"DRIVE_MODE_TRANS_ROT",tolua_get_fawkes__MotorInterface_unsigned_DRIVE_MODE_TRANS_ROT,NULL);
06018     tolua_variable(tolua_S,"DRIVE_MODE_ORBIT",tolua_get_fawkes__MotorInterface_unsigned_DRIVE_MODE_ORBIT,NULL);
06019     tolua_variable(tolua_S,"DRIVE_MODE_LINE_TRANS_ROT",tolua_get_fawkes__MotorInterface_unsigned_DRIVE_MODE_LINE_TRANS_ROT,NULL);
06020     #ifdef __cplusplus
06021     tolua_cclass(tolua_S,"SetMotorStateMessage","fawkes::MotorInterface::SetMotorStateMessage","Message",tolua_collect_fawkes__MotorInterface__SetMotorStateMessage);
06022     #else
06023     tolua_cclass(tolua_S,"SetMotorStateMessage","fawkes::MotorInterface::SetMotorStateMessage","Message",NULL);
06024     #endif
06025     tolua_beginmodule(tolua_S,"SetMotorStateMessage");
06026      tolua_function(tolua_S,"new",tolua_interfaces_MotorInterface_fawkes_MotorInterface_SetMotorStateMessage_new00);
06027      tolua_function(tolua_S,"new_local",tolua_interfaces_MotorInterface_fawkes_MotorInterface_SetMotorStateMessage_new00_local);
06028      tolua_function(tolua_S,".call",tolua_interfaces_MotorInterface_fawkes_MotorInterface_SetMotorStateMessage_new00_local);
06029      tolua_function(tolua_S,"new",tolua_interfaces_MotorInterface_fawkes_MotorInterface_SetMotorStateMessage_new01);
06030      tolua_function(tolua_S,"new_local",tolua_interfaces_MotorInterface_fawkes_MotorInterface_SetMotorStateMessage_new01_local);
06031      tolua_function(tolua_S,".call",tolua_interfaces_MotorInterface_fawkes_MotorInterface_SetMotorStateMessage_new01_local);
06032      tolua_function(tolua_S,"delete",tolua_interfaces_MotorInterface_fawkes_MotorInterface_SetMotorStateMessage_delete00);
06033      tolua_function(tolua_S,"motor_state",tolua_interfaces_MotorInterface_fawkes_MotorInterface_SetMotorStateMessage_motor_state00);
06034      tolua_function(tolua_S,"set_motor_state",tolua_interfaces_MotorInterface_fawkes_MotorInterface_SetMotorStateMessage_set_motor_state00);
06035      tolua_function(tolua_S,"maxlenof_motor_state",tolua_interfaces_MotorInterface_fawkes_MotorInterface_SetMotorStateMessage_maxlenof_motor_state00);
06036     tolua_endmodule(tolua_S);
06037     #ifdef __cplusplus
06038     tolua_cclass(tolua_S,"AcquireControlMessage","fawkes::MotorInterface::AcquireControlMessage","Message",tolua_collect_fawkes__MotorInterface__AcquireControlMessage);
06039     #else
06040     tolua_cclass(tolua_S,"AcquireControlMessage","fawkes::MotorInterface::AcquireControlMessage","Message",NULL);
06041     #endif
06042     tolua_beginmodule(tolua_S,"AcquireControlMessage");
06043      tolua_function(tolua_S,"new",tolua_interfaces_MotorInterface_fawkes_MotorInterface_AcquireControlMessage_new00);
06044      tolua_function(tolua_S,"new_local",tolua_interfaces_MotorInterface_fawkes_MotorInterface_AcquireControlMessage_new00_local);
06045      tolua_function(tolua_S,".call",tolua_interfaces_MotorInterface_fawkes_MotorInterface_AcquireControlMessage_new00_local);
06046      tolua_function(tolua_S,"new",tolua_interfaces_MotorInterface_fawkes_MotorInterface_AcquireControlMessage_new01);
06047      tolua_function(tolua_S,"new_local",tolua_interfaces_MotorInterface_fawkes_MotorInterface_AcquireControlMessage_new01_local);
06048      tolua_function(tolua_S,".call",tolua_interfaces_MotorInterface_fawkes_MotorInterface_AcquireControlMessage_new01_local);
06049      tolua_function(tolua_S,"delete",tolua_interfaces_MotorInterface_fawkes_MotorInterface_AcquireControlMessage_delete00);
06050      tolua_function(tolua_S,"controller",tolua_interfaces_MotorInterface_fawkes_MotorInterface_AcquireControlMessage_controller00);
06051      tolua_function(tolua_S,"set_controller",tolua_interfaces_MotorInterface_fawkes_MotorInterface_AcquireControlMessage_set_controller00);
06052      tolua_function(tolua_S,"maxlenof_controller",tolua_interfaces_MotorInterface_fawkes_MotorInterface_AcquireControlMessage_maxlenof_controller00);
06053      tolua_function(tolua_S,"controller_thread_name",tolua_interfaces_MotorInterface_fawkes_MotorInterface_AcquireControlMessage_controller_thread_name00);
06054      tolua_function(tolua_S,"set_controller_thread_name",tolua_interfaces_MotorInterface_fawkes_MotorInterface_AcquireControlMessage_set_controller_thread_name00);
06055      tolua_function(tolua_S,"maxlenof_controller_thread_name",tolua_interfaces_MotorInterface_fawkes_MotorInterface_AcquireControlMessage_maxlenof_controller_thread_name00);
06056     tolua_endmodule(tolua_S);
06057     #ifdef __cplusplus
06058     tolua_cclass(tolua_S,"ResetOdometryMessage","fawkes::MotorInterface::ResetOdometryMessage","Message",tolua_collect_fawkes__MotorInterface__ResetOdometryMessage);
06059     #else
06060     tolua_cclass(tolua_S,"ResetOdometryMessage","fawkes::MotorInterface::ResetOdometryMessage","Message",NULL);
06061     #endif
06062     tolua_beginmodule(tolua_S,"ResetOdometryMessage");
06063      tolua_function(tolua_S,"new",tolua_interfaces_MotorInterface_fawkes_MotorInterface_ResetOdometryMessage_new00);
06064      tolua_function(tolua_S,"new_local",tolua_interfaces_MotorInterface_fawkes_MotorInterface_ResetOdometryMessage_new00_local);
06065      tolua_function(tolua_S,".call",tolua_interfaces_MotorInterface_fawkes_MotorInterface_ResetOdometryMessage_new00_local);
06066      tolua_function(tolua_S,"delete",tolua_interfaces_MotorInterface_fawkes_MotorInterface_ResetOdometryMessage_delete00);
06067     tolua_endmodule(tolua_S);
06068     #ifdef __cplusplus
06069     tolua_cclass(tolua_S,"DriveRPMMessage","fawkes::MotorInterface::DriveRPMMessage","Message",tolua_collect_fawkes__MotorInterface__DriveRPMMessage);
06070     #else
06071     tolua_cclass(tolua_S,"DriveRPMMessage","fawkes::MotorInterface::DriveRPMMessage","Message",NULL);
06072     #endif
06073     tolua_beginmodule(tolua_S,"DriveRPMMessage");
06074      tolua_function(tolua_S,"new",tolua_interfaces_MotorInterface_fawkes_MotorInterface_DriveRPMMessage_new00);
06075      tolua_function(tolua_S,"new_local",tolua_interfaces_MotorInterface_fawkes_MotorInterface_DriveRPMMessage_new00_local);
06076      tolua_function(tolua_S,".call",tolua_interfaces_MotorInterface_fawkes_MotorInterface_DriveRPMMessage_new00_local);
06077      tolua_function(tolua_S,"new",tolua_interfaces_MotorInterface_fawkes_MotorInterface_DriveRPMMessage_new01);
06078      tolua_function(tolua_S,"new_local",tolua_interfaces_MotorInterface_fawkes_MotorInterface_DriveRPMMessage_new01_local);
06079      tolua_function(tolua_S,".call",tolua_interfaces_MotorInterface_fawkes_MotorInterface_DriveRPMMessage_new01_local);
06080      tolua_function(tolua_S,"delete",tolua_interfaces_MotorInterface_fawkes_MotorInterface_DriveRPMMessage_delete00);
06081      tolua_function(tolua_S,"front_right",tolua_interfaces_MotorInterface_fawkes_MotorInterface_DriveRPMMessage_front_right00);
06082      tolua_function(tolua_S,"set_front_right",tolua_interfaces_MotorInterface_fawkes_MotorInterface_DriveRPMMessage_set_front_right00);
06083      tolua_function(tolua_S,"maxlenof_front_right",tolua_interfaces_MotorInterface_fawkes_MotorInterface_DriveRPMMessage_maxlenof_front_right00);
06084      tolua_function(tolua_S,"front_left",tolua_interfaces_MotorInterface_fawkes_MotorInterface_DriveRPMMessage_front_left00);
06085      tolua_function(tolua_S,"set_front_left",tolua_interfaces_MotorInterface_fawkes_MotorInterface_DriveRPMMessage_set_front_left00);
06086      tolua_function(tolua_S,"maxlenof_front_left",tolua_interfaces_MotorInterface_fawkes_MotorInterface_DriveRPMMessage_maxlenof_front_left00);
06087      tolua_function(tolua_S,"rear",tolua_interfaces_MotorInterface_fawkes_MotorInterface_DriveRPMMessage_rear00);
06088      tolua_function(tolua_S,"set_rear",tolua_interfaces_MotorInterface_fawkes_MotorInterface_DriveRPMMessage_set_rear00);
06089      tolua_function(tolua_S,"maxlenof_rear",tolua_interfaces_MotorInterface_fawkes_MotorInterface_DriveRPMMessage_maxlenof_rear00);
06090     tolua_endmodule(tolua_S);
06091     #ifdef __cplusplus
06092     tolua_cclass(tolua_S,"GotoMessage","fawkes::MotorInterface::GotoMessage","Message",tolua_collect_fawkes__MotorInterface__GotoMessage);
06093     #else
06094     tolua_cclass(tolua_S,"GotoMessage","fawkes::MotorInterface::GotoMessage","Message",NULL);
06095     #endif
06096     tolua_beginmodule(tolua_S,"GotoMessage");
06097      tolua_function(tolua_S,"new",tolua_interfaces_MotorInterface_fawkes_MotorInterface_GotoMessage_new00);
06098      tolua_function(tolua_S,"new_local",tolua_interfaces_MotorInterface_fawkes_MotorInterface_GotoMessage_new00_local);
06099      tolua_function(tolua_S,".call",tolua_interfaces_MotorInterface_fawkes_MotorInterface_GotoMessage_new00_local);
06100      tolua_function(tolua_S,"new",tolua_interfaces_MotorInterface_fawkes_MotorInterface_GotoMessage_new01);
06101      tolua_function(tolua_S,"new_local",tolua_interfaces_MotorInterface_fawkes_MotorInterface_GotoMessage_new01_local);
06102      tolua_function(tolua_S,".call",tolua_interfaces_MotorInterface_fawkes_MotorInterface_GotoMessage_new01_local);
06103      tolua_function(tolua_S,"delete",tolua_interfaces_MotorInterface_fawkes_MotorInterface_GotoMessage_delete00);
06104      tolua_function(tolua_S,"x",tolua_interfaces_MotorInterface_fawkes_MotorInterface_GotoMessage_x00);
06105      tolua_function(tolua_S,"set_x",tolua_interfaces_MotorInterface_fawkes_MotorInterface_GotoMessage_set_x00);
06106      tolua_function(tolua_S,"maxlenof_x",tolua_interfaces_MotorInterface_fawkes_MotorInterface_GotoMessage_maxlenof_x00);
06107      tolua_function(tolua_S,"y",tolua_interfaces_MotorInterface_fawkes_MotorInterface_GotoMessage_y00);
06108      tolua_function(tolua_S,"set_y",tolua_interfaces_MotorInterface_fawkes_MotorInterface_GotoMessage_set_y00);
06109      tolua_function(tolua_S,"maxlenof_y",tolua_interfaces_MotorInterface_fawkes_MotorInterface_GotoMessage_maxlenof_y00);
06110      tolua_function(tolua_S,"phi",tolua_interfaces_MotorInterface_fawkes_MotorInterface_GotoMessage_phi00);
06111      tolua_function(tolua_S,"set_phi",tolua_interfaces_MotorInterface_fawkes_MotorInterface_GotoMessage_set_phi00);
06112      tolua_function(tolua_S,"maxlenof_phi",tolua_interfaces_MotorInterface_fawkes_MotorInterface_GotoMessage_maxlenof_phi00);
06113      tolua_function(tolua_S,"time_sec",tolua_interfaces_MotorInterface_fawkes_MotorInterface_GotoMessage_time_sec00);
06114      tolua_function(tolua_S,"set_time_sec",tolua_interfaces_MotorInterface_fawkes_MotorInterface_GotoMessage_set_time_sec00);
06115      tolua_function(tolua_S,"maxlenof_time_sec",tolua_interfaces_MotorInterface_fawkes_MotorInterface_GotoMessage_maxlenof_time_sec00);
06116     tolua_endmodule(tolua_S);
06117     #ifdef __cplusplus
06118     tolua_cclass(tolua_S,"TransMessage","fawkes::MotorInterface::TransMessage","Message",tolua_collect_fawkes__MotorInterface__TransMessage);
06119     #else
06120     tolua_cclass(tolua_S,"TransMessage","fawkes::MotorInterface::TransMessage","Message",NULL);
06121     #endif
06122     tolua_beginmodule(tolua_S,"TransMessage");
06123      tolua_function(tolua_S,"new",tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransMessage_new00);
06124      tolua_function(tolua_S,"new_local",tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransMessage_new00_local);
06125      tolua_function(tolua_S,".call",tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransMessage_new00_local);
06126      tolua_function(tolua_S,"new",tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransMessage_new01);
06127      tolua_function(tolua_S,"new_local",tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransMessage_new01_local);
06128      tolua_function(tolua_S,".call",tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransMessage_new01_local);
06129      tolua_function(tolua_S,"delete",tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransMessage_delete00);
06130      tolua_function(tolua_S,"vx",tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransMessage_vx00);
06131      tolua_function(tolua_S,"set_vx",tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransMessage_set_vx00);
06132      tolua_function(tolua_S,"maxlenof_vx",tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransMessage_maxlenof_vx00);
06133      tolua_function(tolua_S,"vy",tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransMessage_vy00);
06134      tolua_function(tolua_S,"set_vy",tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransMessage_set_vy00);
06135      tolua_function(tolua_S,"maxlenof_vy",tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransMessage_maxlenof_vy00);
06136     tolua_endmodule(tolua_S);
06137     #ifdef __cplusplus
06138     tolua_cclass(tolua_S,"RotMessage","fawkes::MotorInterface::RotMessage","Message",tolua_collect_fawkes__MotorInterface__RotMessage);
06139     #else
06140     tolua_cclass(tolua_S,"RotMessage","fawkes::MotorInterface::RotMessage","Message",NULL);
06141     #endif
06142     tolua_beginmodule(tolua_S,"RotMessage");
06143      tolua_function(tolua_S,"new",tolua_interfaces_MotorInterface_fawkes_MotorInterface_RotMessage_new00);
06144      tolua_function(tolua_S,"new_local",tolua_interfaces_MotorInterface_fawkes_MotorInterface_RotMessage_new00_local);
06145      tolua_function(tolua_S,".call",tolua_interfaces_MotorInterface_fawkes_MotorInterface_RotMessage_new00_local);
06146      tolua_function(tolua_S,"new",tolua_interfaces_MotorInterface_fawkes_MotorInterface_RotMessage_new01);
06147      tolua_function(tolua_S,"new_local",tolua_interfaces_MotorInterface_fawkes_MotorInterface_RotMessage_new01_local);
06148      tolua_function(tolua_S,".call",tolua_interfaces_MotorInterface_fawkes_MotorInterface_RotMessage_new01_local);
06149      tolua_function(tolua_S,"delete",tolua_interfaces_MotorInterface_fawkes_MotorInterface_RotMessage_delete00);
06150      tolua_function(tolua_S,"omega",tolua_interfaces_MotorInterface_fawkes_MotorInterface_RotMessage_omega00);
06151      tolua_function(tolua_S,"set_omega",tolua_interfaces_MotorInterface_fawkes_MotorInterface_RotMessage_set_omega00);
06152      tolua_function(tolua_S,"maxlenof_omega",tolua_interfaces_MotorInterface_fawkes_MotorInterface_RotMessage_maxlenof_omega00);
06153     tolua_endmodule(tolua_S);
06154     #ifdef __cplusplus
06155     tolua_cclass(tolua_S,"TransRotMessage","fawkes::MotorInterface::TransRotMessage","Message",tolua_collect_fawkes__MotorInterface__TransRotMessage);
06156     #else
06157     tolua_cclass(tolua_S,"TransRotMessage","fawkes::MotorInterface::TransRotMessage","Message",NULL);
06158     #endif
06159     tolua_beginmodule(tolua_S,"TransRotMessage");
06160      tolua_function(tolua_S,"new",tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransRotMessage_new00);
06161      tolua_function(tolua_S,"new_local",tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransRotMessage_new00_local);
06162      tolua_function(tolua_S,".call",tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransRotMessage_new00_local);
06163      tolua_function(tolua_S,"new",tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransRotMessage_new01);
06164      tolua_function(tolua_S,"new_local",tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransRotMessage_new01_local);
06165      tolua_function(tolua_S,".call",tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransRotMessage_new01_local);
06166      tolua_function(tolua_S,"delete",tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransRotMessage_delete00);
06167      tolua_function(tolua_S,"vx",tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransRotMessage_vx00);
06168      tolua_function(tolua_S,"set_vx",tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransRotMessage_set_vx00);
06169      tolua_function(tolua_S,"maxlenof_vx",tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransRotMessage_maxlenof_vx00);
06170      tolua_function(tolua_S,"vy",tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransRotMessage_vy00);
06171      tolua_function(tolua_S,"set_vy",tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransRotMessage_set_vy00);
06172      tolua_function(tolua_S,"maxlenof_vy",tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransRotMessage_maxlenof_vy00);
06173      tolua_function(tolua_S,"omega",tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransRotMessage_omega00);
06174      tolua_function(tolua_S,"set_omega",tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransRotMessage_set_omega00);
06175      tolua_function(tolua_S,"maxlenof_omega",tolua_interfaces_MotorInterface_fawkes_MotorInterface_TransRotMessage_maxlenof_omega00);
06176     tolua_endmodule(tolua_S);
06177     #ifdef __cplusplus
06178     tolua_cclass(tolua_S,"OrbitMessage","fawkes::MotorInterface::OrbitMessage","Message",tolua_collect_fawkes__MotorInterface__OrbitMessage);
06179     #else
06180     tolua_cclass(tolua_S,"OrbitMessage","fawkes::MotorInterface::OrbitMessage","Message",NULL);
06181     #endif
06182     tolua_beginmodule(tolua_S,"OrbitMessage");
06183      tolua_function(tolua_S,"new",tolua_interfaces_MotorInterface_fawkes_MotorInterface_OrbitMessage_new00);
06184      tolua_function(tolua_S,"new_local",tolua_interfaces_MotorInterface_fawkes_MotorInterface_OrbitMessage_new00_local);
06185      tolua_function(tolua_S,".call",tolua_interfaces_MotorInterface_fawkes_MotorInterface_OrbitMessage_new00_local);
06186      tolua_function(tolua_S,"new",tolua_interfaces_MotorInterface_fawkes_MotorInterface_OrbitMessage_new01);
06187      tolua_function(tolua_S,"new_local",tolua_interfaces_MotorInterface_fawkes_MotorInterface_OrbitMessage_new01_local);
06188      tolua_function(tolua_S,".call",tolua_interfaces_MotorInterface_fawkes_MotorInterface_OrbitMessage_new01_local);
06189      tolua_function(tolua_S,"delete",tolua_interfaces_MotorInterface_fawkes_MotorInterface_OrbitMessage_delete00);
06190      tolua_function(tolua_S,"px",tolua_interfaces_MotorInterface_fawkes_MotorInterface_OrbitMessage_px00);
06191      tolua_function(tolua_S,"set_px",tolua_interfaces_MotorInterface_fawkes_MotorInterface_OrbitMessage_set_px00);
06192      tolua_function(tolua_S,"maxlenof_px",tolua_interfaces_MotorInterface_fawkes_MotorInterface_OrbitMessage_maxlenof_px00);
06193      tolua_function(tolua_S,"py",tolua_interfaces_MotorInterface_fawkes_MotorInterface_OrbitMessage_py00);
06194      tolua_function(tolua_S,"set_py",tolua_interfaces_MotorInterface_fawkes_MotorInterface_OrbitMessage_set_py00);
06195      tolua_function(tolua_S,"maxlenof_py",tolua_interfaces_MotorInterface_fawkes_MotorInterface_OrbitMessage_maxlenof_py00);
06196      tolua_function(tolua_S,"omega",tolua_interfaces_MotorInterface_fawkes_MotorInterface_OrbitMessage_omega00);
06197      tolua_function(tolua_S,"set_omega",tolua_interfaces_MotorInterface_fawkes_MotorInterface_OrbitMessage_set_omega00);
06198      tolua_function(tolua_S,"maxlenof_omega",tolua_interfaces_MotorInterface_fawkes_MotorInterface_OrbitMessage_maxlenof_omega00);
06199     tolua_endmodule(tolua_S);
06200     #ifdef __cplusplus
06201     tolua_cclass(tolua_S,"LinTransRotMessage","fawkes::MotorInterface::LinTransRotMessage","Message",tolua_collect_fawkes__MotorInterface__LinTransRotMessage);
06202     #else
06203     tolua_cclass(tolua_S,"LinTransRotMessage","fawkes::MotorInterface::LinTransRotMessage","Message",NULL);
06204     #endif
06205     tolua_beginmodule(tolua_S,"LinTransRotMessage");
06206      tolua_function(tolua_S,"new",tolua_interfaces_MotorInterface_fawkes_MotorInterface_LinTransRotMessage_new00);
06207      tolua_function(tolua_S,"new_local",tolua_interfaces_MotorInterface_fawkes_MotorInterface_LinTransRotMessage_new00_local);
06208      tolua_function(tolua_S,".call",tolua_interfaces_MotorInterface_fawkes_MotorInterface_LinTransRotMessage_new00_local);
06209      tolua_function(tolua_S,"new",tolua_interfaces_MotorInterface_fawkes_MotorInterface_LinTransRotMessage_new01);
06210      tolua_function(tolua_S,"new_local",tolua_interfaces_MotorInterface_fawkes_MotorInterface_LinTransRotMessage_new01_local);
06211      tolua_function(tolua_S,".call",tolua_interfaces_MotorInterface_fawkes_MotorInterface_LinTransRotMessage_new01_local);
06212      tolua_function(tolua_S,"delete",tolua_interfaces_MotorInterface_fawkes_MotorInterface_LinTransRotMessage_delete00);
06213      tolua_function(tolua_S,"vx",tolua_interfaces_MotorInterface_fawkes_MotorInterface_LinTransRotMessage_vx00);
06214      tolua_function(tolua_S,"set_vx",tolua_interfaces_MotorInterface_fawkes_MotorInterface_LinTransRotMessage_set_vx00);
06215      tolua_function(tolua_S,"maxlenof_vx",tolua_interfaces_MotorInterface_fawkes_MotorInterface_LinTransRotMessage_maxlenof_vx00);
06216      tolua_function(tolua_S,"vy",tolua_interfaces_MotorInterface_fawkes_MotorInterface_LinTransRotMessage_vy00);
06217      tolua_function(tolua_S,"set_vy",tolua_interfaces_MotorInterface_fawkes_MotorInterface_LinTransRotMessage_set_vy00);
06218      tolua_function(tolua_S,"maxlenof_vy",tolua_interfaces_MotorInterface_fawkes_MotorInterface_LinTransRotMessage_maxlenof_vy00);
06219      tolua_function(tolua_S,"omega",tolua_interfaces_MotorInterface_fawkes_MotorInterface_LinTransRotMessage_omega00);
06220      tolua_function(tolua_S,"set_omega",tolua_interfaces_MotorInterface_fawkes_MotorInterface_LinTransRotMessage_set_omega00);
06221      tolua_function(tolua_S,"maxlenof_omega",tolua_interfaces_MotorInterface_fawkes_MotorInterface_LinTransRotMessage_maxlenof_omega00);
06222     tolua_endmodule(tolua_S);
06223     tolua_function(tolua_S,"motor_state",tolua_interfaces_MotorInterface_fawkes_MotorInterface_motor_state00);
06224     tolua_function(tolua_S,"set_motor_state",tolua_interfaces_MotorInterface_fawkes_MotorInterface_set_motor_state00);
06225     tolua_function(tolua_S,"maxlenof_motor_state",tolua_interfaces_MotorInterface_fawkes_MotorInterface_maxlenof_motor_state00);
06226     tolua_function(tolua_S,"drive_mode",tolua_interfaces_MotorInterface_fawkes_MotorInterface_drive_mode00);
06227     tolua_function(tolua_S,"set_drive_mode",tolua_interfaces_MotorInterface_fawkes_MotorInterface_set_drive_mode00);
06228     tolua_function(tolua_S,"maxlenof_drive_mode",tolua_interfaces_MotorInterface_fawkes_MotorInterface_maxlenof_drive_mode00);
06229     tolua_function(tolua_S,"right_rpm",tolua_interfaces_MotorInterface_fawkes_MotorInterface_right_rpm00);
06230     tolua_function(tolua_S,"set_right_rpm",tolua_interfaces_MotorInterface_fawkes_MotorInterface_set_right_rpm00);
06231     tolua_function(tolua_S,"maxlenof_right_rpm",tolua_interfaces_MotorInterface_fawkes_MotorInterface_maxlenof_right_rpm00);
06232     tolua_function(tolua_S,"rear_rpm",tolua_interfaces_MotorInterface_fawkes_MotorInterface_rear_rpm00);
06233     tolua_function(tolua_S,"set_rear_rpm",tolua_interfaces_MotorInterface_fawkes_MotorInterface_set_rear_rpm00);
06234     tolua_function(tolua_S,"maxlenof_rear_rpm",tolua_interfaces_MotorInterface_fawkes_MotorInterface_maxlenof_rear_rpm00);
06235     tolua_function(tolua_S,"left_rpm",tolua_interfaces_MotorInterface_fawkes_MotorInterface_left_rpm00);
06236     tolua_function(tolua_S,"set_left_rpm",tolua_interfaces_MotorInterface_fawkes_MotorInterface_set_left_rpm00);
06237     tolua_function(tolua_S,"maxlenof_left_rpm",tolua_interfaces_MotorInterface_fawkes_MotorInterface_maxlenof_left_rpm00);
06238     tolua_function(tolua_S,"odometry_path_length",tolua_interfaces_MotorInterface_fawkes_MotorInterface_odometry_path_length00);
06239     tolua_function(tolua_S,"set_odometry_path_length",tolua_interfaces_MotorInterface_fawkes_MotorInterface_set_odometry_path_length00);
06240     tolua_function(tolua_S,"maxlenof_odometry_path_length",tolua_interfaces_MotorInterface_fawkes_MotorInterface_maxlenof_odometry_path_length00);
06241     tolua_function(tolua_S,"odometry_position_x",tolua_interfaces_MotorInterface_fawkes_MotorInterface_odometry_position_x00);
06242     tolua_function(tolua_S,"set_odometry_position_x",tolua_interfaces_MotorInterface_fawkes_MotorInterface_set_odometry_position_x00);
06243     tolua_function(tolua_S,"maxlenof_odometry_position_x",tolua_interfaces_MotorInterface_fawkes_MotorInterface_maxlenof_odometry_position_x00);
06244     tolua_function(tolua_S,"odometry_position_y",tolua_interfaces_MotorInterface_fawkes_MotorInterface_odometry_position_y00);
06245     tolua_function(tolua_S,"set_odometry_position_y",tolua_interfaces_MotorInterface_fawkes_MotorInterface_set_odometry_position_y00);
06246     tolua_function(tolua_S,"maxlenof_odometry_position_y",tolua_interfaces_MotorInterface_fawkes_MotorInterface_maxlenof_odometry_position_y00);
06247     tolua_function(tolua_S,"odometry_orientation",tolua_interfaces_MotorInterface_fawkes_MotorInterface_odometry_orientation00);
06248     tolua_function(tolua_S,"set_odometry_orientation",tolua_interfaces_MotorInterface_fawkes_MotorInterface_set_odometry_orientation00);
06249     tolua_function(tolua_S,"maxlenof_odometry_orientation",tolua_interfaces_MotorInterface_fawkes_MotorInterface_maxlenof_odometry_orientation00);
06250     tolua_function(tolua_S,"vx",tolua_interfaces_MotorInterface_fawkes_MotorInterface_vx00);
06251     tolua_function(tolua_S,"set_vx",tolua_interfaces_MotorInterface_fawkes_MotorInterface_set_vx00);
06252     tolua_function(tolua_S,"maxlenof_vx",tolua_interfaces_MotorInterface_fawkes_MotorInterface_maxlenof_vx00);
06253     tolua_function(tolua_S,"vy",tolua_interfaces_MotorInterface_fawkes_MotorInterface_vy00);
06254     tolua_function(tolua_S,"set_vy",tolua_interfaces_MotorInterface_fawkes_MotorInterface_set_vy00);
06255     tolua_function(tolua_S,"maxlenof_vy",tolua_interfaces_MotorInterface_fawkes_MotorInterface_maxlenof_vy00);
06256     tolua_function(tolua_S,"omega",tolua_interfaces_MotorInterface_fawkes_MotorInterface_omega00);
06257     tolua_function(tolua_S,"set_omega",tolua_interfaces_MotorInterface_fawkes_MotorInterface_set_omega00);
06258     tolua_function(tolua_S,"maxlenof_omega",tolua_interfaces_MotorInterface_fawkes_MotorInterface_maxlenof_omega00);
06259     tolua_function(tolua_S,"controller",tolua_interfaces_MotorInterface_fawkes_MotorInterface_controller00);
06260     tolua_function(tolua_S,"set_controller",tolua_interfaces_MotorInterface_fawkes_MotorInterface_set_controller00);
06261     tolua_function(tolua_S,"maxlenof_controller",tolua_interfaces_MotorInterface_fawkes_MotorInterface_maxlenof_controller00);
06262     tolua_function(tolua_S,"controller_thread_name",tolua_interfaces_MotorInterface_fawkes_MotorInterface_controller_thread_name00);
06263     tolua_function(tolua_S,"set_controller_thread_name",tolua_interfaces_MotorInterface_fawkes_MotorInterface_set_controller_thread_name00);
06264     tolua_function(tolua_S,"maxlenof_controller_thread_name",tolua_interfaces_MotorInterface_fawkes_MotorInterface_maxlenof_controller_thread_name00);
06265     tolua_function(tolua_S,"oftype",tolua_interfaces_MotorInterface_fawkes_MotorInterface_oftype00);
06266     tolua_function(tolua_S,"datachunk",tolua_interfaces_MotorInterface_fawkes_MotorInterface_datachunk00);
06267     tolua_function(tolua_S,"datasize",tolua_interfaces_MotorInterface_fawkes_MotorInterface_datasize00);
06268     tolua_function(tolua_S,"type",tolua_interfaces_MotorInterface_fawkes_MotorInterface_type00);
06269     tolua_function(tolua_S,"id",tolua_interfaces_MotorInterface_fawkes_MotorInterface_id00);
06270     tolua_function(tolua_S,"uid",tolua_interfaces_MotorInterface_fawkes_MotorInterface_uid00);
06271     tolua_function(tolua_S,"serial",tolua_interfaces_MotorInterface_fawkes_MotorInterface_serial00);
06272     tolua_function(tolua_S,"mem_serial",tolua_interfaces_MotorInterface_fawkes_MotorInterface_mem_serial00);
06273     tolua_function(tolua_S,".eq",tolua_interfaces_MotorInterface_fawkes_MotorInterface__eq00);
06274     tolua_function(tolua_S,"hash",tolua_interfaces_MotorInterface_fawkes_MotorInterface_hash00);
06275     tolua_function(tolua_S,"hash_size",tolua_interfaces_MotorInterface_fawkes_MotorInterface_hash_size00);
06276     tolua_function(tolua_S,"hash_printable",tolua_interfaces_MotorInterface_fawkes_MotorInterface_hash_printable00);
06277     tolua_function(tolua_S,"is_writer",tolua_interfaces_MotorInterface_fawkes_MotorInterface_is_writer00);
06278     tolua_function(tolua_S,"set_from_chunk",tolua_interfaces_MotorInterface_fawkes_MotorInterface_set_from_chunk00);
06279     tolua_function(tolua_S,"create_message",tolua_interfaces_MotorInterface_fawkes_MotorInterface_create_message00);
06280     tolua_function(tolua_S,"read",tolua_interfaces_MotorInterface_fawkes_MotorInterface_read00);
06281     tolua_function(tolua_S,"write",tolua_interfaces_MotorInterface_fawkes_MotorInterface_write00);
06282     tolua_function(tolua_S,"has_writer",tolua_interfaces_MotorInterface_fawkes_MotorInterface_has_writer00);
06283     tolua_function(tolua_S,"num_readers",tolua_interfaces_MotorInterface_fawkes_MotorInterface_num_readers00);
06284     tolua_function(tolua_S,"msgq_enqueue_copy",tolua_interfaces_MotorInterface_fawkes_MotorInterface_msgq_enqueue_copy00);
06285     tolua_function(tolua_S,"msgq_remove",tolua_interfaces_MotorInterface_fawkes_MotorInterface_msgq_remove00);
06286     tolua_function(tolua_S,"msgq_remove",tolua_interfaces_MotorInterface_fawkes_MotorInterface_msgq_remove01);
06287     tolua_function(tolua_S,"msgq_size",tolua_interfaces_MotorInterface_fawkes_MotorInterface_msgq_size00);
06288     tolua_function(tolua_S,"msgq_flush",tolua_interfaces_MotorInterface_fawkes_MotorInterface_msgq_flush00);
06289     tolua_function(tolua_S,"msgq_lock",tolua_interfaces_MotorInterface_fawkes_MotorInterface_msgq_lock00);
06290     tolua_function(tolua_S,"msgq_try_lock",tolua_interfaces_MotorInterface_fawkes_MotorInterface_msgq_try_lock00);
06291     tolua_function(tolua_S,"msgq_unlock",tolua_interfaces_MotorInterface_fawkes_MotorInterface_msgq_unlock00);
06292     tolua_function(tolua_S,"msgq_pop",tolua_interfaces_MotorInterface_fawkes_MotorInterface_msgq_pop00);
06293     tolua_function(tolua_S,"msgq_first",tolua_interfaces_MotorInterface_fawkes_MotorInterface_msgq_first00);
06294     tolua_function(tolua_S,"msgq_empty",tolua_interfaces_MotorInterface_fawkes_MotorInterface_msgq_empty00);
06295    tolua_endmodule(tolua_S);
06296   tolua_endmodule(tolua_S);
06297  tolua_endmodule(tolua_S);
06298  return 1;
06299 }
06300
06301
06302 extern "C" {
06303 #if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501
06304  TOLUA_API int luaopen_interfaces_MotorInterface (lua_State* tolua_S) {
06305  return tolua_interfaces_MotorInterface_open(tolua_S);
06306 };
06307 #endif
06308 }
06309
06310