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