MotorInterface_tolua.cpp

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

Generated on 1 Mar 2011 for Fawkes API by  doxygen 1.6.1