00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019 #ifndef __cplusplus
00020 #include "stdlib.h"
00021 #endif
00022 #include "string.h"
00023
00024 #include "tolua++.h"
00025
00026
00027 TOLUA_API int tolua_interfaces_MotorInterface_open (lua_State* tolua_S);
00028
00029 #include <interfaces/MotorInterface.h>
00030 using namespace fawkes;
00031
00032
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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