Fawkes API Fawkes Development Version
|
00001 /* 00002 ** Lua binding: interfaces_KatanaInterface 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_KatanaInterface_open (lua_State* tolua_S); 00028 00029 #include <interfaces/KatanaInterface.h> 00030 using namespace fawkes; 00031 00032 /* function to release collected object via destructor */ 00033 #ifdef __cplusplus 00034 00035 static int tolua_collect_fawkes__KatanaInterface__SetEnabledMessage (lua_State* tolua_S) 00036 { 00037 fawkes::KatanaInterface::SetEnabledMessage* self = (fawkes::KatanaInterface::SetEnabledMessage*) tolua_tousertype(tolua_S,1,0); 00038 Mtolua_delete(self); 00039 return 0; 00040 } 00041 00042 static int tolua_collect_fawkes__KatanaInterface__CloseGripperMessage (lua_State* tolua_S) 00043 { 00044 fawkes::KatanaInterface::CloseGripperMessage* self = (fawkes::KatanaInterface::CloseGripperMessage*) tolua_tousertype(tolua_S,1,0); 00045 Mtolua_delete(self); 00046 return 0; 00047 } 00048 00049 static int tolua_collect_fawkes__KatanaInterface__LinearGotoMessage (lua_State* tolua_S) 00050 { 00051 fawkes::KatanaInterface::LinearGotoMessage* self = (fawkes::KatanaInterface::LinearGotoMessage*) tolua_tousertype(tolua_S,1,0); 00052 Mtolua_delete(self); 00053 return 0; 00054 } 00055 00056 static int tolua_collect_fawkes__KatanaInterface__StopMessage (lua_State* tolua_S) 00057 { 00058 fawkes::KatanaInterface::StopMessage* self = (fawkes::KatanaInterface::StopMessage*) tolua_tousertype(tolua_S,1,0); 00059 Mtolua_delete(self); 00060 return 0; 00061 } 00062 00063 static int tolua_collect_fawkes__KatanaInterface__ParkMessage (lua_State* tolua_S) 00064 { 00065 fawkes::KatanaInterface::ParkMessage* self = (fawkes::KatanaInterface::ParkMessage*) tolua_tousertype(tolua_S,1,0); 00066 Mtolua_delete(self); 00067 return 0; 00068 } 00069 00070 static int tolua_collect_fawkes__KatanaInterface__OpenGripperMessage (lua_State* tolua_S) 00071 { 00072 fawkes::KatanaInterface::OpenGripperMessage* self = (fawkes::KatanaInterface::OpenGripperMessage*) tolua_tousertype(tolua_S,1,0); 00073 Mtolua_delete(self); 00074 return 0; 00075 } 00076 00077 static int tolua_collect_fawkes__KatanaInterface__CalibrateMessage (lua_State* tolua_S) 00078 { 00079 fawkes::KatanaInterface::CalibrateMessage* self = (fawkes::KatanaInterface::CalibrateMessage*) tolua_tousertype(tolua_S,1,0); 00080 Mtolua_delete(self); 00081 return 0; 00082 } 00083 00084 static int tolua_collect_fawkes__KatanaInterface__FlushMessage (lua_State* tolua_S) 00085 { 00086 fawkes::KatanaInterface::FlushMessage* self = (fawkes::KatanaInterface::FlushMessage*) tolua_tousertype(tolua_S,1,0); 00087 Mtolua_delete(self); 00088 return 0; 00089 } 00090 00091 static int tolua_collect_fawkes__KatanaInterface__SetMaxVelocityMessage (lua_State* tolua_S) 00092 { 00093 fawkes::KatanaInterface::SetMaxVelocityMessage* self = (fawkes::KatanaInterface::SetMaxVelocityMessage*) tolua_tousertype(tolua_S,1,0); 00094 Mtolua_delete(self); 00095 return 0; 00096 } 00097 #endif 00098 00099 00100 /* function to register type */ 00101 static void tolua_reg_types (lua_State* tolua_S) 00102 { 00103 tolua_usertype(tolua_S,"fawkes::KatanaInterface"); 00104 tolua_usertype(tolua_S,"fawkes::KatanaInterface::SetEnabledMessage"); 00105 tolua_usertype(tolua_S,"fawkes::KatanaInterface::CloseGripperMessage"); 00106 tolua_usertype(tolua_S,"fawkes::KatanaInterface::LinearGotoMessage"); 00107 tolua_usertype(tolua_S,"fawkes::KatanaInterface::StopMessage"); 00108 tolua_usertype(tolua_S,"fawkes::KatanaInterface::ParkMessage"); 00109 tolua_usertype(tolua_S,"fawkes::KatanaInterface::SetMaxVelocityMessage"); 00110 tolua_usertype(tolua_S,"fawkes::KatanaInterface::OpenGripperMessage"); 00111 tolua_usertype(tolua_S,"fawkes::KatanaInterface::CalibrateMessage"); 00112 tolua_usertype(tolua_S,"Message"); 00113 tolua_usertype(tolua_S,"fawkes::KatanaInterface::FlushMessage"); 00114 tolua_usertype(tolua_S,"Interface"); 00115 } 00116 00117 /* get function: SENSOR_IR_RIGHT_INNER_MIDDLE of class fawkes::KatanaInterface */ 00118 #ifndef TOLUA_DISABLE_tolua_get_fawkes__KatanaInterface_unsigned_SENSOR_IR_RIGHT_INNER_MIDDLE 00119 static int tolua_get_fawkes__KatanaInterface_unsigned_SENSOR_IR_RIGHT_INNER_MIDDLE(lua_State* tolua_S) 00120 { 00121 tolua_pushnumber(tolua_S,(lua_Number)fawkes::KatanaInterface::SENSOR_IR_RIGHT_INNER_MIDDLE); 00122 return 1; 00123 } 00124 #endif //#ifndef TOLUA_DISABLE 00125 00126 /* get function: SENSOR_IR_RIGHT_INNER_FRONT of class fawkes::KatanaInterface */ 00127 #ifndef TOLUA_DISABLE_tolua_get_fawkes__KatanaInterface_unsigned_SENSOR_IR_RIGHT_INNER_FRONT 00128 static int tolua_get_fawkes__KatanaInterface_unsigned_SENSOR_IR_RIGHT_INNER_FRONT(lua_State* tolua_S) 00129 { 00130 tolua_pushnumber(tolua_S,(lua_Number)fawkes::KatanaInterface::SENSOR_IR_RIGHT_INNER_FRONT); 00131 return 1; 00132 } 00133 #endif //#ifndef TOLUA_DISABLE 00134 00135 /* get function: SENSOR_RESERVED_2 of class fawkes::KatanaInterface */ 00136 #ifndef TOLUA_DISABLE_tolua_get_fawkes__KatanaInterface_unsigned_SENSOR_RESERVED_2 00137 static int tolua_get_fawkes__KatanaInterface_unsigned_SENSOR_RESERVED_2(lua_State* tolua_S) 00138 { 00139 tolua_pushnumber(tolua_S,(lua_Number)fawkes::KatanaInterface::SENSOR_RESERVED_2); 00140 return 1; 00141 } 00142 #endif //#ifndef TOLUA_DISABLE 00143 00144 /* get function: SENSOR_COND_BOTH of class fawkes::KatanaInterface */ 00145 #ifndef TOLUA_DISABLE_tolua_get_fawkes__KatanaInterface_unsigned_SENSOR_COND_BOTH 00146 static int tolua_get_fawkes__KatanaInterface_unsigned_SENSOR_COND_BOTH(lua_State* tolua_S) 00147 { 00148 tolua_pushnumber(tolua_S,(lua_Number)fawkes::KatanaInterface::SENSOR_COND_BOTH); 00149 return 1; 00150 } 00151 #endif //#ifndef TOLUA_DISABLE 00152 00153 /* get function: SENSOR_IR_RIGHT_OUTER_FRONT of class fawkes::KatanaInterface */ 00154 #ifndef TOLUA_DISABLE_tolua_get_fawkes__KatanaInterface_unsigned_SENSOR_IR_RIGHT_OUTER_FRONT 00155 static int tolua_get_fawkes__KatanaInterface_unsigned_SENSOR_IR_RIGHT_OUTER_FRONT(lua_State* tolua_S) 00156 { 00157 tolua_pushnumber(tolua_S,(lua_Number)fawkes::KatanaInterface::SENSOR_IR_RIGHT_OUTER_FRONT); 00158 return 1; 00159 } 00160 #endif //#ifndef TOLUA_DISABLE 00161 00162 /* get function: SENSOR_IR_RIGHT_BOTTOM_FRONT of class fawkes::KatanaInterface */ 00163 #ifndef TOLUA_DISABLE_tolua_get_fawkes__KatanaInterface_unsigned_SENSOR_IR_RIGHT_BOTTOM_FRONT 00164 static int tolua_get_fawkes__KatanaInterface_unsigned_SENSOR_IR_RIGHT_BOTTOM_FRONT(lua_State* tolua_S) 00165 { 00166 tolua_pushnumber(tolua_S,(lua_Number)fawkes::KatanaInterface::SENSOR_IR_RIGHT_BOTTOM_FRONT); 00167 return 1; 00168 } 00169 #endif //#ifndef TOLUA_DISABLE 00170 00171 /* get function: SENSOR_FORCE_RIGHT_REAR of class fawkes::KatanaInterface */ 00172 #ifndef TOLUA_DISABLE_tolua_get_fawkes__KatanaInterface_unsigned_SENSOR_FORCE_RIGHT_REAR 00173 static int tolua_get_fawkes__KatanaInterface_unsigned_SENSOR_FORCE_RIGHT_REAR(lua_State* tolua_S) 00174 { 00175 tolua_pushnumber(tolua_S,(lua_Number)fawkes::KatanaInterface::SENSOR_FORCE_RIGHT_REAR); 00176 return 1; 00177 } 00178 #endif //#ifndef TOLUA_DISABLE 00179 00180 /* get function: SENSOR_FORCE_RIGHT_FRONT of class fawkes::KatanaInterface */ 00181 #ifndef TOLUA_DISABLE_tolua_get_fawkes__KatanaInterface_unsigned_SENSOR_FORCE_RIGHT_FRONT 00182 static int tolua_get_fawkes__KatanaInterface_unsigned_SENSOR_FORCE_RIGHT_FRONT(lua_State* tolua_S) 00183 { 00184 tolua_pushnumber(tolua_S,(lua_Number)fawkes::KatanaInterface::SENSOR_FORCE_RIGHT_FRONT); 00185 return 1; 00186 } 00187 #endif //#ifndef TOLUA_DISABLE 00188 00189 /* get function: SENSOR_IR_LEFT_INNER_MIDDLE of class fawkes::KatanaInterface */ 00190 #ifndef TOLUA_DISABLE_tolua_get_fawkes__KatanaInterface_unsigned_SENSOR_IR_LEFT_INNER_MIDDLE 00191 static int tolua_get_fawkes__KatanaInterface_unsigned_SENSOR_IR_LEFT_INNER_MIDDLE(lua_State* tolua_S) 00192 { 00193 tolua_pushnumber(tolua_S,(lua_Number)fawkes::KatanaInterface::SENSOR_IR_LEFT_INNER_MIDDLE); 00194 return 1; 00195 } 00196 #endif //#ifndef TOLUA_DISABLE 00197 00198 /* get function: SENSOR_IR_LEFT_INNER_FRONT of class fawkes::KatanaInterface */ 00199 #ifndef TOLUA_DISABLE_tolua_get_fawkes__KatanaInterface_unsigned_SENSOR_IR_LEFT_INNER_FRONT 00200 static int tolua_get_fawkes__KatanaInterface_unsigned_SENSOR_IR_LEFT_INNER_FRONT(lua_State* tolua_S) 00201 { 00202 tolua_pushnumber(tolua_S,(lua_Number)fawkes::KatanaInterface::SENSOR_IR_LEFT_INNER_FRONT); 00203 return 1; 00204 } 00205 #endif //#ifndef TOLUA_DISABLE 00206 00207 /* get function: SENSOR_RESERVED_10 of class fawkes::KatanaInterface */ 00208 #ifndef TOLUA_DISABLE_tolua_get_fawkes__KatanaInterface_unsigned_SENSOR_RESERVED_10 00209 static int tolua_get_fawkes__KatanaInterface_unsigned_SENSOR_RESERVED_10(lua_State* tolua_S) 00210 { 00211 tolua_pushnumber(tolua_S,(lua_Number)fawkes::KatanaInterface::SENSOR_RESERVED_10); 00212 return 1; 00213 } 00214 #endif //#ifndef TOLUA_DISABLE 00215 00216 /* get function: SENSOR_IR_CENTER_GRIPPER of class fawkes::KatanaInterface */ 00217 #ifndef TOLUA_DISABLE_tolua_get_fawkes__KatanaInterface_unsigned_SENSOR_IR_CENTER_GRIPPER 00218 static int tolua_get_fawkes__KatanaInterface_unsigned_SENSOR_IR_CENTER_GRIPPER(lua_State* tolua_S) 00219 { 00220 tolua_pushnumber(tolua_S,(lua_Number)fawkes::KatanaInterface::SENSOR_IR_CENTER_GRIPPER); 00221 return 1; 00222 } 00223 #endif //#ifndef TOLUA_DISABLE 00224 00225 /* get function: SENSOR_IR_LEFT_OUTER_FRONT of class fawkes::KatanaInterface */ 00226 #ifndef TOLUA_DISABLE_tolua_get_fawkes__KatanaInterface_unsigned_SENSOR_IR_LEFT_OUTER_FRONT 00227 static int tolua_get_fawkes__KatanaInterface_unsigned_SENSOR_IR_LEFT_OUTER_FRONT(lua_State* tolua_S) 00228 { 00229 tolua_pushnumber(tolua_S,(lua_Number)fawkes::KatanaInterface::SENSOR_IR_LEFT_OUTER_FRONT); 00230 return 1; 00231 } 00232 #endif //#ifndef TOLUA_DISABLE 00233 00234 /* get function: SENSOR_IR_LEFT_BOTTOM_FRONT of class fawkes::KatanaInterface */ 00235 #ifndef TOLUA_DISABLE_tolua_get_fawkes__KatanaInterface_unsigned_SENSOR_IR_LEFT_BOTTOM_FRONT 00236 static int tolua_get_fawkes__KatanaInterface_unsigned_SENSOR_IR_LEFT_BOTTOM_FRONT(lua_State* tolua_S) 00237 { 00238 tolua_pushnumber(tolua_S,(lua_Number)fawkes::KatanaInterface::SENSOR_IR_LEFT_BOTTOM_FRONT); 00239 return 1; 00240 } 00241 #endif //#ifndef TOLUA_DISABLE 00242 00243 /* get function: SENSOR_FORCE_LEFT_REAR of class fawkes::KatanaInterface */ 00244 #ifndef TOLUA_DISABLE_tolua_get_fawkes__KatanaInterface_unsigned_SENSOR_FORCE_LEFT_REAR 00245 static int tolua_get_fawkes__KatanaInterface_unsigned_SENSOR_FORCE_LEFT_REAR(lua_State* tolua_S) 00246 { 00247 tolua_pushnumber(tolua_S,(lua_Number)fawkes::KatanaInterface::SENSOR_FORCE_LEFT_REAR); 00248 return 1; 00249 } 00250 #endif //#ifndef TOLUA_DISABLE 00251 00252 /* get function: SENSOR_FORCE_LEFT_FRONT of class fawkes::KatanaInterface */ 00253 #ifndef TOLUA_DISABLE_tolua_get_fawkes__KatanaInterface_unsigned_SENSOR_FORCE_LEFT_FRONT 00254 static int tolua_get_fawkes__KatanaInterface_unsigned_SENSOR_FORCE_LEFT_FRONT(lua_State* tolua_S) 00255 { 00256 tolua_pushnumber(tolua_S,(lua_Number)fawkes::KatanaInterface::SENSOR_FORCE_LEFT_FRONT); 00257 return 1; 00258 } 00259 #endif //#ifndef TOLUA_DISABLE 00260 00261 /* get function: ERROR_NONE of class fawkes::KatanaInterface */ 00262 #ifndef TOLUA_DISABLE_tolua_get_fawkes__KatanaInterface_unsigned_ERROR_NONE 00263 static int tolua_get_fawkes__KatanaInterface_unsigned_ERROR_NONE(lua_State* tolua_S) 00264 { 00265 tolua_pushnumber(tolua_S,(lua_Number)fawkes::KatanaInterface::ERROR_NONE); 00266 return 1; 00267 } 00268 #endif //#ifndef TOLUA_DISABLE 00269 00270 /* get function: ERROR_UNSPECIFIC of class fawkes::KatanaInterface */ 00271 #ifndef TOLUA_DISABLE_tolua_get_fawkes__KatanaInterface_unsigned_ERROR_UNSPECIFIC 00272 static int tolua_get_fawkes__KatanaInterface_unsigned_ERROR_UNSPECIFIC(lua_State* tolua_S) 00273 { 00274 tolua_pushnumber(tolua_S,(lua_Number)fawkes::KatanaInterface::ERROR_UNSPECIFIC); 00275 return 1; 00276 } 00277 #endif //#ifndef TOLUA_DISABLE 00278 00279 /* get function: ERROR_CMD_START_FAILED of class fawkes::KatanaInterface */ 00280 #ifndef TOLUA_DISABLE_tolua_get_fawkes__KatanaInterface_unsigned_ERROR_CMD_START_FAILED 00281 static int tolua_get_fawkes__KatanaInterface_unsigned_ERROR_CMD_START_FAILED(lua_State* tolua_S) 00282 { 00283 tolua_pushnumber(tolua_S,(lua_Number)fawkes::KatanaInterface::ERROR_CMD_START_FAILED); 00284 return 1; 00285 } 00286 #endif //#ifndef TOLUA_DISABLE 00287 00288 /* get function: ERROR_NO_SOLUTION of class fawkes::KatanaInterface */ 00289 #ifndef TOLUA_DISABLE_tolua_get_fawkes__KatanaInterface_unsigned_ERROR_NO_SOLUTION 00290 static int tolua_get_fawkes__KatanaInterface_unsigned_ERROR_NO_SOLUTION(lua_State* tolua_S) 00291 { 00292 tolua_pushnumber(tolua_S,(lua_Number)fawkes::KatanaInterface::ERROR_NO_SOLUTION); 00293 return 1; 00294 } 00295 #endif //#ifndef TOLUA_DISABLE 00296 00297 /* get function: ERROR_COMMUNICATION of class fawkes::KatanaInterface */ 00298 #ifndef TOLUA_DISABLE_tolua_get_fawkes__KatanaInterface_unsigned_ERROR_COMMUNICATION 00299 static int tolua_get_fawkes__KatanaInterface_unsigned_ERROR_COMMUNICATION(lua_State* tolua_S) 00300 { 00301 tolua_pushnumber(tolua_S,(lua_Number)fawkes::KatanaInterface::ERROR_COMMUNICATION); 00302 return 1; 00303 } 00304 #endif //#ifndef TOLUA_DISABLE 00305 00306 /* get function: ERROR_MOTOR_CRASHED of class fawkes::KatanaInterface */ 00307 #ifndef TOLUA_DISABLE_tolua_get_fawkes__KatanaInterface_unsigned_ERROR_MOTOR_CRASHED 00308 static int tolua_get_fawkes__KatanaInterface_unsigned_ERROR_MOTOR_CRASHED(lua_State* tolua_S) 00309 { 00310 tolua_pushnumber(tolua_S,(lua_Number)fawkes::KatanaInterface::ERROR_MOTOR_CRASHED); 00311 return 1; 00312 } 00313 #endif //#ifndef TOLUA_DISABLE 00314 00315 /* method: new of class StopMessage */ 00316 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_StopMessage_new00 00317 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_StopMessage_new00(lua_State* tolua_S) 00318 { 00319 #ifndef TOLUA_RELEASE 00320 tolua_Error tolua_err; 00321 if ( 00322 !tolua_isusertable(tolua_S,1,"fawkes::KatanaInterface::StopMessage",0,&tolua_err) || 00323 !tolua_isnoobj(tolua_S,2,&tolua_err) 00324 ) 00325 goto tolua_lerror; 00326 else 00327 #endif 00328 { 00329 { 00330 fawkes::KatanaInterface::StopMessage* tolua_ret = (fawkes::KatanaInterface::StopMessage*) Mtolua_new((fawkes::KatanaInterface::StopMessage)()); 00331 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::KatanaInterface::StopMessage"); 00332 } 00333 } 00334 return 1; 00335 #ifndef TOLUA_RELEASE 00336 tolua_lerror: 00337 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 00338 return 0; 00339 #endif 00340 } 00341 #endif //#ifndef TOLUA_DISABLE 00342 00343 /* method: new_local of class StopMessage */ 00344 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_StopMessage_new00_local 00345 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_StopMessage_new00_local(lua_State* tolua_S) 00346 { 00347 #ifndef TOLUA_RELEASE 00348 tolua_Error tolua_err; 00349 if ( 00350 !tolua_isusertable(tolua_S,1,"fawkes::KatanaInterface::StopMessage",0,&tolua_err) || 00351 !tolua_isnoobj(tolua_S,2,&tolua_err) 00352 ) 00353 goto tolua_lerror; 00354 else 00355 #endif 00356 { 00357 { 00358 fawkes::KatanaInterface::StopMessage* tolua_ret = (fawkes::KatanaInterface::StopMessage*) Mtolua_new((fawkes::KatanaInterface::StopMessage)()); 00359 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::KatanaInterface::StopMessage"); 00360 tolua_register_gc(tolua_S,lua_gettop(tolua_S)); 00361 } 00362 } 00363 return 1; 00364 #ifndef TOLUA_RELEASE 00365 tolua_lerror: 00366 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 00367 return 0; 00368 #endif 00369 } 00370 #endif //#ifndef TOLUA_DISABLE 00371 00372 /* method: delete of class StopMessage */ 00373 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_StopMessage_delete00 00374 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_StopMessage_delete00(lua_State* tolua_S) 00375 { 00376 #ifndef TOLUA_RELEASE 00377 tolua_Error tolua_err; 00378 if ( 00379 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface::StopMessage",0,&tolua_err) || 00380 !tolua_isnoobj(tolua_S,2,&tolua_err) 00381 ) 00382 goto tolua_lerror; 00383 else 00384 #endif 00385 { 00386 fawkes::KatanaInterface::StopMessage* self = (fawkes::KatanaInterface::StopMessage*) tolua_tousertype(tolua_S,1,0); 00387 #ifndef TOLUA_RELEASE 00388 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL); 00389 #endif 00390 Mtolua_delete(self); 00391 } 00392 return 0; 00393 #ifndef TOLUA_RELEASE 00394 tolua_lerror: 00395 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err); 00396 return 0; 00397 #endif 00398 } 00399 #endif //#ifndef TOLUA_DISABLE 00400 00401 /* method: new of class FlushMessage */ 00402 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_FlushMessage_new00 00403 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_FlushMessage_new00(lua_State* tolua_S) 00404 { 00405 #ifndef TOLUA_RELEASE 00406 tolua_Error tolua_err; 00407 if ( 00408 !tolua_isusertable(tolua_S,1,"fawkes::KatanaInterface::FlushMessage",0,&tolua_err) || 00409 !tolua_isnoobj(tolua_S,2,&tolua_err) 00410 ) 00411 goto tolua_lerror; 00412 else 00413 #endif 00414 { 00415 { 00416 fawkes::KatanaInterface::FlushMessage* tolua_ret = (fawkes::KatanaInterface::FlushMessage*) Mtolua_new((fawkes::KatanaInterface::FlushMessage)()); 00417 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::KatanaInterface::FlushMessage"); 00418 } 00419 } 00420 return 1; 00421 #ifndef TOLUA_RELEASE 00422 tolua_lerror: 00423 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 00424 return 0; 00425 #endif 00426 } 00427 #endif //#ifndef TOLUA_DISABLE 00428 00429 /* method: new_local of class FlushMessage */ 00430 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_FlushMessage_new00_local 00431 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_FlushMessage_new00_local(lua_State* tolua_S) 00432 { 00433 #ifndef TOLUA_RELEASE 00434 tolua_Error tolua_err; 00435 if ( 00436 !tolua_isusertable(tolua_S,1,"fawkes::KatanaInterface::FlushMessage",0,&tolua_err) || 00437 !tolua_isnoobj(tolua_S,2,&tolua_err) 00438 ) 00439 goto tolua_lerror; 00440 else 00441 #endif 00442 { 00443 { 00444 fawkes::KatanaInterface::FlushMessage* tolua_ret = (fawkes::KatanaInterface::FlushMessage*) Mtolua_new((fawkes::KatanaInterface::FlushMessage)()); 00445 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::KatanaInterface::FlushMessage"); 00446 tolua_register_gc(tolua_S,lua_gettop(tolua_S)); 00447 } 00448 } 00449 return 1; 00450 #ifndef TOLUA_RELEASE 00451 tolua_lerror: 00452 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 00453 return 0; 00454 #endif 00455 } 00456 #endif //#ifndef TOLUA_DISABLE 00457 00458 /* method: delete of class FlushMessage */ 00459 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_FlushMessage_delete00 00460 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_FlushMessage_delete00(lua_State* tolua_S) 00461 { 00462 #ifndef TOLUA_RELEASE 00463 tolua_Error tolua_err; 00464 if ( 00465 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface::FlushMessage",0,&tolua_err) || 00466 !tolua_isnoobj(tolua_S,2,&tolua_err) 00467 ) 00468 goto tolua_lerror; 00469 else 00470 #endif 00471 { 00472 fawkes::KatanaInterface::FlushMessage* self = (fawkes::KatanaInterface::FlushMessage*) tolua_tousertype(tolua_S,1,0); 00473 #ifndef TOLUA_RELEASE 00474 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL); 00475 #endif 00476 Mtolua_delete(self); 00477 } 00478 return 0; 00479 #ifndef TOLUA_RELEASE 00480 tolua_lerror: 00481 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err); 00482 return 0; 00483 #endif 00484 } 00485 #endif //#ifndef TOLUA_DISABLE 00486 00487 /* method: new of class ParkMessage */ 00488 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_ParkMessage_new00 00489 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_ParkMessage_new00(lua_State* tolua_S) 00490 { 00491 #ifndef TOLUA_RELEASE 00492 tolua_Error tolua_err; 00493 if ( 00494 !tolua_isusertable(tolua_S,1,"fawkes::KatanaInterface::ParkMessage",0,&tolua_err) || 00495 !tolua_isnoobj(tolua_S,2,&tolua_err) 00496 ) 00497 goto tolua_lerror; 00498 else 00499 #endif 00500 { 00501 { 00502 fawkes::KatanaInterface::ParkMessage* tolua_ret = (fawkes::KatanaInterface::ParkMessage*) Mtolua_new((fawkes::KatanaInterface::ParkMessage)()); 00503 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::KatanaInterface::ParkMessage"); 00504 } 00505 } 00506 return 1; 00507 #ifndef TOLUA_RELEASE 00508 tolua_lerror: 00509 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 00510 return 0; 00511 #endif 00512 } 00513 #endif //#ifndef TOLUA_DISABLE 00514 00515 /* method: new_local of class ParkMessage */ 00516 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_ParkMessage_new00_local 00517 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_ParkMessage_new00_local(lua_State* tolua_S) 00518 { 00519 #ifndef TOLUA_RELEASE 00520 tolua_Error tolua_err; 00521 if ( 00522 !tolua_isusertable(tolua_S,1,"fawkes::KatanaInterface::ParkMessage",0,&tolua_err) || 00523 !tolua_isnoobj(tolua_S,2,&tolua_err) 00524 ) 00525 goto tolua_lerror; 00526 else 00527 #endif 00528 { 00529 { 00530 fawkes::KatanaInterface::ParkMessage* tolua_ret = (fawkes::KatanaInterface::ParkMessage*) Mtolua_new((fawkes::KatanaInterface::ParkMessage)()); 00531 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::KatanaInterface::ParkMessage"); 00532 tolua_register_gc(tolua_S,lua_gettop(tolua_S)); 00533 } 00534 } 00535 return 1; 00536 #ifndef TOLUA_RELEASE 00537 tolua_lerror: 00538 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 00539 return 0; 00540 #endif 00541 } 00542 #endif //#ifndef TOLUA_DISABLE 00543 00544 /* method: delete of class ParkMessage */ 00545 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_ParkMessage_delete00 00546 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_ParkMessage_delete00(lua_State* tolua_S) 00547 { 00548 #ifndef TOLUA_RELEASE 00549 tolua_Error tolua_err; 00550 if ( 00551 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface::ParkMessage",0,&tolua_err) || 00552 !tolua_isnoobj(tolua_S,2,&tolua_err) 00553 ) 00554 goto tolua_lerror; 00555 else 00556 #endif 00557 { 00558 fawkes::KatanaInterface::ParkMessage* self = (fawkes::KatanaInterface::ParkMessage*) tolua_tousertype(tolua_S,1,0); 00559 #ifndef TOLUA_RELEASE 00560 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL); 00561 #endif 00562 Mtolua_delete(self); 00563 } 00564 return 0; 00565 #ifndef TOLUA_RELEASE 00566 tolua_lerror: 00567 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err); 00568 return 0; 00569 #endif 00570 } 00571 #endif //#ifndef TOLUA_DISABLE 00572 00573 /* method: new of class LinearGotoMessage */ 00574 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_new00 00575 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_new00(lua_State* tolua_S) 00576 { 00577 #ifndef TOLUA_RELEASE 00578 tolua_Error tolua_err; 00579 if ( 00580 !tolua_isusertable(tolua_S,1,"fawkes::KatanaInterface::LinearGotoMessage",0,&tolua_err) || 00581 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 00582 !tolua_isnumber(tolua_S,3,0,&tolua_err) || 00583 !tolua_isnumber(tolua_S,4,0,&tolua_err) || 00584 !tolua_isnumber(tolua_S,5,0,&tolua_err) || 00585 !tolua_isnumber(tolua_S,6,0,&tolua_err) || 00586 !tolua_isnumber(tolua_S,7,0,&tolua_err) || 00587 !tolua_isnoobj(tolua_S,8,&tolua_err) 00588 ) 00589 goto tolua_lerror; 00590 else 00591 #endif 00592 { 00593 float ini_x = ((float) tolua_tonumber(tolua_S,2,0)); 00594 float ini_y = ((float) tolua_tonumber(tolua_S,3,0)); 00595 float ini_z = ((float) tolua_tonumber(tolua_S,4,0)); 00596 float ini_phi = ((float) tolua_tonumber(tolua_S,5,0)); 00597 float ini_theta = ((float) tolua_tonumber(tolua_S,6,0)); 00598 float ini_psi = ((float) tolua_tonumber(tolua_S,7,0)); 00599 { 00600 fawkes::KatanaInterface::LinearGotoMessage* tolua_ret = (fawkes::KatanaInterface::LinearGotoMessage*) Mtolua_new((fawkes::KatanaInterface::LinearGotoMessage)(ini_x,ini_y,ini_z,ini_phi,ini_theta,ini_psi)); 00601 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::KatanaInterface::LinearGotoMessage"); 00602 } 00603 } 00604 return 1; 00605 #ifndef TOLUA_RELEASE 00606 tolua_lerror: 00607 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 00608 return 0; 00609 #endif 00610 } 00611 #endif //#ifndef TOLUA_DISABLE 00612 00613 /* method: new_local of class LinearGotoMessage */ 00614 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_new00_local 00615 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_new00_local(lua_State* tolua_S) 00616 { 00617 #ifndef TOLUA_RELEASE 00618 tolua_Error tolua_err; 00619 if ( 00620 !tolua_isusertable(tolua_S,1,"fawkes::KatanaInterface::LinearGotoMessage",0,&tolua_err) || 00621 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 00622 !tolua_isnumber(tolua_S,3,0,&tolua_err) || 00623 !tolua_isnumber(tolua_S,4,0,&tolua_err) || 00624 !tolua_isnumber(tolua_S,5,0,&tolua_err) || 00625 !tolua_isnumber(tolua_S,6,0,&tolua_err) || 00626 !tolua_isnumber(tolua_S,7,0,&tolua_err) || 00627 !tolua_isnoobj(tolua_S,8,&tolua_err) 00628 ) 00629 goto tolua_lerror; 00630 else 00631 #endif 00632 { 00633 float ini_x = ((float) tolua_tonumber(tolua_S,2,0)); 00634 float ini_y = ((float) tolua_tonumber(tolua_S,3,0)); 00635 float ini_z = ((float) tolua_tonumber(tolua_S,4,0)); 00636 float ini_phi = ((float) tolua_tonumber(tolua_S,5,0)); 00637 float ini_theta = ((float) tolua_tonumber(tolua_S,6,0)); 00638 float ini_psi = ((float) tolua_tonumber(tolua_S,7,0)); 00639 { 00640 fawkes::KatanaInterface::LinearGotoMessage* tolua_ret = (fawkes::KatanaInterface::LinearGotoMessage*) Mtolua_new((fawkes::KatanaInterface::LinearGotoMessage)(ini_x,ini_y,ini_z,ini_phi,ini_theta,ini_psi)); 00641 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::KatanaInterface::LinearGotoMessage"); 00642 tolua_register_gc(tolua_S,lua_gettop(tolua_S)); 00643 } 00644 } 00645 return 1; 00646 #ifndef TOLUA_RELEASE 00647 tolua_lerror: 00648 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 00649 return 0; 00650 #endif 00651 } 00652 #endif //#ifndef TOLUA_DISABLE 00653 00654 /* method: new of class LinearGotoMessage */ 00655 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_new01 00656 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_new01(lua_State* tolua_S) 00657 { 00658 tolua_Error tolua_err; 00659 if ( 00660 !tolua_isusertable(tolua_S,1,"fawkes::KatanaInterface::LinearGotoMessage",0,&tolua_err) || 00661 !tolua_isnoobj(tolua_S,2,&tolua_err) 00662 ) 00663 goto tolua_lerror; 00664 else 00665 { 00666 { 00667 fawkes::KatanaInterface::LinearGotoMessage* tolua_ret = (fawkes::KatanaInterface::LinearGotoMessage*) Mtolua_new((fawkes::KatanaInterface::LinearGotoMessage)()); 00668 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::KatanaInterface::LinearGotoMessage"); 00669 } 00670 } 00671 return 1; 00672 tolua_lerror: 00673 return tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_new00(tolua_S); 00674 } 00675 #endif //#ifndef TOLUA_DISABLE 00676 00677 /* method: new_local of class LinearGotoMessage */ 00678 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_new01_local 00679 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_new01_local(lua_State* tolua_S) 00680 { 00681 tolua_Error tolua_err; 00682 if ( 00683 !tolua_isusertable(tolua_S,1,"fawkes::KatanaInterface::LinearGotoMessage",0,&tolua_err) || 00684 !tolua_isnoobj(tolua_S,2,&tolua_err) 00685 ) 00686 goto tolua_lerror; 00687 else 00688 { 00689 { 00690 fawkes::KatanaInterface::LinearGotoMessage* tolua_ret = (fawkes::KatanaInterface::LinearGotoMessage*) Mtolua_new((fawkes::KatanaInterface::LinearGotoMessage)()); 00691 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::KatanaInterface::LinearGotoMessage"); 00692 tolua_register_gc(tolua_S,lua_gettop(tolua_S)); 00693 } 00694 } 00695 return 1; 00696 tolua_lerror: 00697 return tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_new00_local(tolua_S); 00698 } 00699 #endif //#ifndef TOLUA_DISABLE 00700 00701 /* method: delete of class LinearGotoMessage */ 00702 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_delete00 00703 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_delete00(lua_State* tolua_S) 00704 { 00705 #ifndef TOLUA_RELEASE 00706 tolua_Error tolua_err; 00707 if ( 00708 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface::LinearGotoMessage",0,&tolua_err) || 00709 !tolua_isnoobj(tolua_S,2,&tolua_err) 00710 ) 00711 goto tolua_lerror; 00712 else 00713 #endif 00714 { 00715 fawkes::KatanaInterface::LinearGotoMessage* self = (fawkes::KatanaInterface::LinearGotoMessage*) tolua_tousertype(tolua_S,1,0); 00716 #ifndef TOLUA_RELEASE 00717 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL); 00718 #endif 00719 Mtolua_delete(self); 00720 } 00721 return 0; 00722 #ifndef TOLUA_RELEASE 00723 tolua_lerror: 00724 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err); 00725 return 0; 00726 #endif 00727 } 00728 #endif //#ifndef TOLUA_DISABLE 00729 00730 /* method: x of class LinearGotoMessage */ 00731 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_x00 00732 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_x00(lua_State* tolua_S) 00733 { 00734 #ifndef TOLUA_RELEASE 00735 tolua_Error tolua_err; 00736 if ( 00737 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface::LinearGotoMessage",0,&tolua_err) || 00738 !tolua_isnoobj(tolua_S,2,&tolua_err) 00739 ) 00740 goto tolua_lerror; 00741 else 00742 #endif 00743 { 00744 fawkes::KatanaInterface::LinearGotoMessage* self = (fawkes::KatanaInterface::LinearGotoMessage*) tolua_tousertype(tolua_S,1,0); 00745 #ifndef TOLUA_RELEASE 00746 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'x'", NULL); 00747 #endif 00748 { 00749 float tolua_ret = (float) self->x(); 00750 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00751 } 00752 } 00753 return 1; 00754 #ifndef TOLUA_RELEASE 00755 tolua_lerror: 00756 tolua_error(tolua_S,"#ferror in function 'x'.",&tolua_err); 00757 return 0; 00758 #endif 00759 } 00760 #endif //#ifndef TOLUA_DISABLE 00761 00762 /* method: set_x of class LinearGotoMessage */ 00763 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_set_x00 00764 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_set_x00(lua_State* tolua_S) 00765 { 00766 #ifndef TOLUA_RELEASE 00767 tolua_Error tolua_err; 00768 if ( 00769 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface::LinearGotoMessage",0,&tolua_err) || 00770 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 00771 !tolua_isnoobj(tolua_S,3,&tolua_err) 00772 ) 00773 goto tolua_lerror; 00774 else 00775 #endif 00776 { 00777 fawkes::KatanaInterface::LinearGotoMessage* self = (fawkes::KatanaInterface::LinearGotoMessage*) tolua_tousertype(tolua_S,1,0); 00778 const float new_x = ((const float) tolua_tonumber(tolua_S,2,0)); 00779 #ifndef TOLUA_RELEASE 00780 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_x'", NULL); 00781 #endif 00782 { 00783 self->set_x(new_x); 00784 } 00785 } 00786 return 0; 00787 #ifndef TOLUA_RELEASE 00788 tolua_lerror: 00789 tolua_error(tolua_S,"#ferror in function 'set_x'.",&tolua_err); 00790 return 0; 00791 #endif 00792 } 00793 #endif //#ifndef TOLUA_DISABLE 00794 00795 /* method: maxlenof_x of class LinearGotoMessage */ 00796 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_maxlenof_x00 00797 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_maxlenof_x00(lua_State* tolua_S) 00798 { 00799 #ifndef TOLUA_RELEASE 00800 tolua_Error tolua_err; 00801 if ( 00802 !tolua_isusertype(tolua_S,1,"const fawkes::KatanaInterface::LinearGotoMessage",0,&tolua_err) || 00803 !tolua_isnoobj(tolua_S,2,&tolua_err) 00804 ) 00805 goto tolua_lerror; 00806 else 00807 #endif 00808 { 00809 const fawkes::KatanaInterface::LinearGotoMessage* self = (const fawkes::KatanaInterface::LinearGotoMessage*) tolua_tousertype(tolua_S,1,0); 00810 #ifndef TOLUA_RELEASE 00811 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_x'", NULL); 00812 #endif 00813 { 00814 int tolua_ret = (int) self->maxlenof_x(); 00815 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00816 } 00817 } 00818 return 1; 00819 #ifndef TOLUA_RELEASE 00820 tolua_lerror: 00821 tolua_error(tolua_S,"#ferror in function 'maxlenof_x'.",&tolua_err); 00822 return 0; 00823 #endif 00824 } 00825 #endif //#ifndef TOLUA_DISABLE 00826 00827 /* method: y of class LinearGotoMessage */ 00828 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_y00 00829 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_y00(lua_State* tolua_S) 00830 { 00831 #ifndef TOLUA_RELEASE 00832 tolua_Error tolua_err; 00833 if ( 00834 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface::LinearGotoMessage",0,&tolua_err) || 00835 !tolua_isnoobj(tolua_S,2,&tolua_err) 00836 ) 00837 goto tolua_lerror; 00838 else 00839 #endif 00840 { 00841 fawkes::KatanaInterface::LinearGotoMessage* self = (fawkes::KatanaInterface::LinearGotoMessage*) tolua_tousertype(tolua_S,1,0); 00842 #ifndef TOLUA_RELEASE 00843 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'y'", NULL); 00844 #endif 00845 { 00846 float tolua_ret = (float) self->y(); 00847 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00848 } 00849 } 00850 return 1; 00851 #ifndef TOLUA_RELEASE 00852 tolua_lerror: 00853 tolua_error(tolua_S,"#ferror in function 'y'.",&tolua_err); 00854 return 0; 00855 #endif 00856 } 00857 #endif //#ifndef TOLUA_DISABLE 00858 00859 /* method: set_y of class LinearGotoMessage */ 00860 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_set_y00 00861 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_set_y00(lua_State* tolua_S) 00862 { 00863 #ifndef TOLUA_RELEASE 00864 tolua_Error tolua_err; 00865 if ( 00866 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface::LinearGotoMessage",0,&tolua_err) || 00867 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 00868 !tolua_isnoobj(tolua_S,3,&tolua_err) 00869 ) 00870 goto tolua_lerror; 00871 else 00872 #endif 00873 { 00874 fawkes::KatanaInterface::LinearGotoMessage* self = (fawkes::KatanaInterface::LinearGotoMessage*) tolua_tousertype(tolua_S,1,0); 00875 const float new_y = ((const float) tolua_tonumber(tolua_S,2,0)); 00876 #ifndef TOLUA_RELEASE 00877 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_y'", NULL); 00878 #endif 00879 { 00880 self->set_y(new_y); 00881 } 00882 } 00883 return 0; 00884 #ifndef TOLUA_RELEASE 00885 tolua_lerror: 00886 tolua_error(tolua_S,"#ferror in function 'set_y'.",&tolua_err); 00887 return 0; 00888 #endif 00889 } 00890 #endif //#ifndef TOLUA_DISABLE 00891 00892 /* method: maxlenof_y of class LinearGotoMessage */ 00893 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_maxlenof_y00 00894 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_maxlenof_y00(lua_State* tolua_S) 00895 { 00896 #ifndef TOLUA_RELEASE 00897 tolua_Error tolua_err; 00898 if ( 00899 !tolua_isusertype(tolua_S,1,"const fawkes::KatanaInterface::LinearGotoMessage",0,&tolua_err) || 00900 !tolua_isnoobj(tolua_S,2,&tolua_err) 00901 ) 00902 goto tolua_lerror; 00903 else 00904 #endif 00905 { 00906 const fawkes::KatanaInterface::LinearGotoMessage* self = (const fawkes::KatanaInterface::LinearGotoMessage*) tolua_tousertype(tolua_S,1,0); 00907 #ifndef TOLUA_RELEASE 00908 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_y'", NULL); 00909 #endif 00910 { 00911 int tolua_ret = (int) self->maxlenof_y(); 00912 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00913 } 00914 } 00915 return 1; 00916 #ifndef TOLUA_RELEASE 00917 tolua_lerror: 00918 tolua_error(tolua_S,"#ferror in function 'maxlenof_y'.",&tolua_err); 00919 return 0; 00920 #endif 00921 } 00922 #endif //#ifndef TOLUA_DISABLE 00923 00924 /* method: z of class LinearGotoMessage */ 00925 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_z00 00926 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_z00(lua_State* tolua_S) 00927 { 00928 #ifndef TOLUA_RELEASE 00929 tolua_Error tolua_err; 00930 if ( 00931 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface::LinearGotoMessage",0,&tolua_err) || 00932 !tolua_isnoobj(tolua_S,2,&tolua_err) 00933 ) 00934 goto tolua_lerror; 00935 else 00936 #endif 00937 { 00938 fawkes::KatanaInterface::LinearGotoMessage* self = (fawkes::KatanaInterface::LinearGotoMessage*) tolua_tousertype(tolua_S,1,0); 00939 #ifndef TOLUA_RELEASE 00940 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'z'", NULL); 00941 #endif 00942 { 00943 float tolua_ret = (float) self->z(); 00944 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00945 } 00946 } 00947 return 1; 00948 #ifndef TOLUA_RELEASE 00949 tolua_lerror: 00950 tolua_error(tolua_S,"#ferror in function 'z'.",&tolua_err); 00951 return 0; 00952 #endif 00953 } 00954 #endif //#ifndef TOLUA_DISABLE 00955 00956 /* method: set_z of class LinearGotoMessage */ 00957 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_set_z00 00958 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_set_z00(lua_State* tolua_S) 00959 { 00960 #ifndef TOLUA_RELEASE 00961 tolua_Error tolua_err; 00962 if ( 00963 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface::LinearGotoMessage",0,&tolua_err) || 00964 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 00965 !tolua_isnoobj(tolua_S,3,&tolua_err) 00966 ) 00967 goto tolua_lerror; 00968 else 00969 #endif 00970 { 00971 fawkes::KatanaInterface::LinearGotoMessage* self = (fawkes::KatanaInterface::LinearGotoMessage*) tolua_tousertype(tolua_S,1,0); 00972 const float new_z = ((const float) tolua_tonumber(tolua_S,2,0)); 00973 #ifndef TOLUA_RELEASE 00974 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_z'", NULL); 00975 #endif 00976 { 00977 self->set_z(new_z); 00978 } 00979 } 00980 return 0; 00981 #ifndef TOLUA_RELEASE 00982 tolua_lerror: 00983 tolua_error(tolua_S,"#ferror in function 'set_z'.",&tolua_err); 00984 return 0; 00985 #endif 00986 } 00987 #endif //#ifndef TOLUA_DISABLE 00988 00989 /* method: maxlenof_z of class LinearGotoMessage */ 00990 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_maxlenof_z00 00991 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_maxlenof_z00(lua_State* tolua_S) 00992 { 00993 #ifndef TOLUA_RELEASE 00994 tolua_Error tolua_err; 00995 if ( 00996 !tolua_isusertype(tolua_S,1,"const fawkes::KatanaInterface::LinearGotoMessage",0,&tolua_err) || 00997 !tolua_isnoobj(tolua_S,2,&tolua_err) 00998 ) 00999 goto tolua_lerror; 01000 else 01001 #endif 01002 { 01003 const fawkes::KatanaInterface::LinearGotoMessage* self = (const fawkes::KatanaInterface::LinearGotoMessage*) tolua_tousertype(tolua_S,1,0); 01004 #ifndef TOLUA_RELEASE 01005 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_z'", NULL); 01006 #endif 01007 { 01008 int tolua_ret = (int) self->maxlenof_z(); 01009 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01010 } 01011 } 01012 return 1; 01013 #ifndef TOLUA_RELEASE 01014 tolua_lerror: 01015 tolua_error(tolua_S,"#ferror in function 'maxlenof_z'.",&tolua_err); 01016 return 0; 01017 #endif 01018 } 01019 #endif //#ifndef TOLUA_DISABLE 01020 01021 /* method: phi of class LinearGotoMessage */ 01022 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_phi00 01023 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_phi00(lua_State* tolua_S) 01024 { 01025 #ifndef TOLUA_RELEASE 01026 tolua_Error tolua_err; 01027 if ( 01028 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface::LinearGotoMessage",0,&tolua_err) || 01029 !tolua_isnoobj(tolua_S,2,&tolua_err) 01030 ) 01031 goto tolua_lerror; 01032 else 01033 #endif 01034 { 01035 fawkes::KatanaInterface::LinearGotoMessage* self = (fawkes::KatanaInterface::LinearGotoMessage*) tolua_tousertype(tolua_S,1,0); 01036 #ifndef TOLUA_RELEASE 01037 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'phi'", NULL); 01038 #endif 01039 { 01040 float tolua_ret = (float) self->phi(); 01041 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01042 } 01043 } 01044 return 1; 01045 #ifndef TOLUA_RELEASE 01046 tolua_lerror: 01047 tolua_error(tolua_S,"#ferror in function 'phi'.",&tolua_err); 01048 return 0; 01049 #endif 01050 } 01051 #endif //#ifndef TOLUA_DISABLE 01052 01053 /* method: set_phi of class LinearGotoMessage */ 01054 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_set_phi00 01055 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_set_phi00(lua_State* tolua_S) 01056 { 01057 #ifndef TOLUA_RELEASE 01058 tolua_Error tolua_err; 01059 if ( 01060 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface::LinearGotoMessage",0,&tolua_err) || 01061 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 01062 !tolua_isnoobj(tolua_S,3,&tolua_err) 01063 ) 01064 goto tolua_lerror; 01065 else 01066 #endif 01067 { 01068 fawkes::KatanaInterface::LinearGotoMessage* self = (fawkes::KatanaInterface::LinearGotoMessage*) tolua_tousertype(tolua_S,1,0); 01069 const float new_phi = ((const float) tolua_tonumber(tolua_S,2,0)); 01070 #ifndef TOLUA_RELEASE 01071 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_phi'", NULL); 01072 #endif 01073 { 01074 self->set_phi(new_phi); 01075 } 01076 } 01077 return 0; 01078 #ifndef TOLUA_RELEASE 01079 tolua_lerror: 01080 tolua_error(tolua_S,"#ferror in function 'set_phi'.",&tolua_err); 01081 return 0; 01082 #endif 01083 } 01084 #endif //#ifndef TOLUA_DISABLE 01085 01086 /* method: maxlenof_phi of class LinearGotoMessage */ 01087 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_maxlenof_phi00 01088 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_maxlenof_phi00(lua_State* tolua_S) 01089 { 01090 #ifndef TOLUA_RELEASE 01091 tolua_Error tolua_err; 01092 if ( 01093 !tolua_isusertype(tolua_S,1,"const fawkes::KatanaInterface::LinearGotoMessage",0,&tolua_err) || 01094 !tolua_isnoobj(tolua_S,2,&tolua_err) 01095 ) 01096 goto tolua_lerror; 01097 else 01098 #endif 01099 { 01100 const fawkes::KatanaInterface::LinearGotoMessage* self = (const fawkes::KatanaInterface::LinearGotoMessage*) tolua_tousertype(tolua_S,1,0); 01101 #ifndef TOLUA_RELEASE 01102 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_phi'", NULL); 01103 #endif 01104 { 01105 int tolua_ret = (int) self->maxlenof_phi(); 01106 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01107 } 01108 } 01109 return 1; 01110 #ifndef TOLUA_RELEASE 01111 tolua_lerror: 01112 tolua_error(tolua_S,"#ferror in function 'maxlenof_phi'.",&tolua_err); 01113 return 0; 01114 #endif 01115 } 01116 #endif //#ifndef TOLUA_DISABLE 01117 01118 /* method: theta of class LinearGotoMessage */ 01119 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_theta00 01120 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_theta00(lua_State* tolua_S) 01121 { 01122 #ifndef TOLUA_RELEASE 01123 tolua_Error tolua_err; 01124 if ( 01125 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface::LinearGotoMessage",0,&tolua_err) || 01126 !tolua_isnoobj(tolua_S,2,&tolua_err) 01127 ) 01128 goto tolua_lerror; 01129 else 01130 #endif 01131 { 01132 fawkes::KatanaInterface::LinearGotoMessage* self = (fawkes::KatanaInterface::LinearGotoMessage*) tolua_tousertype(tolua_S,1,0); 01133 #ifndef TOLUA_RELEASE 01134 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'theta'", NULL); 01135 #endif 01136 { 01137 float tolua_ret = (float) self->theta(); 01138 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01139 } 01140 } 01141 return 1; 01142 #ifndef TOLUA_RELEASE 01143 tolua_lerror: 01144 tolua_error(tolua_S,"#ferror in function 'theta'.",&tolua_err); 01145 return 0; 01146 #endif 01147 } 01148 #endif //#ifndef TOLUA_DISABLE 01149 01150 /* method: set_theta of class LinearGotoMessage */ 01151 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_set_theta00 01152 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_set_theta00(lua_State* tolua_S) 01153 { 01154 #ifndef TOLUA_RELEASE 01155 tolua_Error tolua_err; 01156 if ( 01157 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface::LinearGotoMessage",0,&tolua_err) || 01158 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 01159 !tolua_isnoobj(tolua_S,3,&tolua_err) 01160 ) 01161 goto tolua_lerror; 01162 else 01163 #endif 01164 { 01165 fawkes::KatanaInterface::LinearGotoMessage* self = (fawkes::KatanaInterface::LinearGotoMessage*) tolua_tousertype(tolua_S,1,0); 01166 const float new_theta = ((const float) tolua_tonumber(tolua_S,2,0)); 01167 #ifndef TOLUA_RELEASE 01168 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_theta'", NULL); 01169 #endif 01170 { 01171 self->set_theta(new_theta); 01172 } 01173 } 01174 return 0; 01175 #ifndef TOLUA_RELEASE 01176 tolua_lerror: 01177 tolua_error(tolua_S,"#ferror in function 'set_theta'.",&tolua_err); 01178 return 0; 01179 #endif 01180 } 01181 #endif //#ifndef TOLUA_DISABLE 01182 01183 /* method: maxlenof_theta of class LinearGotoMessage */ 01184 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_maxlenof_theta00 01185 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_maxlenof_theta00(lua_State* tolua_S) 01186 { 01187 #ifndef TOLUA_RELEASE 01188 tolua_Error tolua_err; 01189 if ( 01190 !tolua_isusertype(tolua_S,1,"const fawkes::KatanaInterface::LinearGotoMessage",0,&tolua_err) || 01191 !tolua_isnoobj(tolua_S,2,&tolua_err) 01192 ) 01193 goto tolua_lerror; 01194 else 01195 #endif 01196 { 01197 const fawkes::KatanaInterface::LinearGotoMessage* self = (const fawkes::KatanaInterface::LinearGotoMessage*) tolua_tousertype(tolua_S,1,0); 01198 #ifndef TOLUA_RELEASE 01199 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_theta'", NULL); 01200 #endif 01201 { 01202 int tolua_ret = (int) self->maxlenof_theta(); 01203 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01204 } 01205 } 01206 return 1; 01207 #ifndef TOLUA_RELEASE 01208 tolua_lerror: 01209 tolua_error(tolua_S,"#ferror in function 'maxlenof_theta'.",&tolua_err); 01210 return 0; 01211 #endif 01212 } 01213 #endif //#ifndef TOLUA_DISABLE 01214 01215 /* method: psi of class LinearGotoMessage */ 01216 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_psi00 01217 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_psi00(lua_State* tolua_S) 01218 { 01219 #ifndef TOLUA_RELEASE 01220 tolua_Error tolua_err; 01221 if ( 01222 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface::LinearGotoMessage",0,&tolua_err) || 01223 !tolua_isnoobj(tolua_S,2,&tolua_err) 01224 ) 01225 goto tolua_lerror; 01226 else 01227 #endif 01228 { 01229 fawkes::KatanaInterface::LinearGotoMessage* self = (fawkes::KatanaInterface::LinearGotoMessage*) tolua_tousertype(tolua_S,1,0); 01230 #ifndef TOLUA_RELEASE 01231 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'psi'", NULL); 01232 #endif 01233 { 01234 float tolua_ret = (float) self->psi(); 01235 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01236 } 01237 } 01238 return 1; 01239 #ifndef TOLUA_RELEASE 01240 tolua_lerror: 01241 tolua_error(tolua_S,"#ferror in function 'psi'.",&tolua_err); 01242 return 0; 01243 #endif 01244 } 01245 #endif //#ifndef TOLUA_DISABLE 01246 01247 /* method: set_psi of class LinearGotoMessage */ 01248 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_set_psi00 01249 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_set_psi00(lua_State* tolua_S) 01250 { 01251 #ifndef TOLUA_RELEASE 01252 tolua_Error tolua_err; 01253 if ( 01254 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface::LinearGotoMessage",0,&tolua_err) || 01255 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 01256 !tolua_isnoobj(tolua_S,3,&tolua_err) 01257 ) 01258 goto tolua_lerror; 01259 else 01260 #endif 01261 { 01262 fawkes::KatanaInterface::LinearGotoMessage* self = (fawkes::KatanaInterface::LinearGotoMessage*) tolua_tousertype(tolua_S,1,0); 01263 const float new_psi = ((const float) tolua_tonumber(tolua_S,2,0)); 01264 #ifndef TOLUA_RELEASE 01265 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_psi'", NULL); 01266 #endif 01267 { 01268 self->set_psi(new_psi); 01269 } 01270 } 01271 return 0; 01272 #ifndef TOLUA_RELEASE 01273 tolua_lerror: 01274 tolua_error(tolua_S,"#ferror in function 'set_psi'.",&tolua_err); 01275 return 0; 01276 #endif 01277 } 01278 #endif //#ifndef TOLUA_DISABLE 01279 01280 /* method: maxlenof_psi of class LinearGotoMessage */ 01281 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_maxlenof_psi00 01282 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_maxlenof_psi00(lua_State* tolua_S) 01283 { 01284 #ifndef TOLUA_RELEASE 01285 tolua_Error tolua_err; 01286 if ( 01287 !tolua_isusertype(tolua_S,1,"const fawkes::KatanaInterface::LinearGotoMessage",0,&tolua_err) || 01288 !tolua_isnoobj(tolua_S,2,&tolua_err) 01289 ) 01290 goto tolua_lerror; 01291 else 01292 #endif 01293 { 01294 const fawkes::KatanaInterface::LinearGotoMessage* self = (const fawkes::KatanaInterface::LinearGotoMessage*) tolua_tousertype(tolua_S,1,0); 01295 #ifndef TOLUA_RELEASE 01296 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_psi'", NULL); 01297 #endif 01298 { 01299 int tolua_ret = (int) self->maxlenof_psi(); 01300 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01301 } 01302 } 01303 return 1; 01304 #ifndef TOLUA_RELEASE 01305 tolua_lerror: 01306 tolua_error(tolua_S,"#ferror in function 'maxlenof_psi'.",&tolua_err); 01307 return 0; 01308 #endif 01309 } 01310 #endif //#ifndef TOLUA_DISABLE 01311 01312 /* method: new of class CalibrateMessage */ 01313 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_CalibrateMessage_new00 01314 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_CalibrateMessage_new00(lua_State* tolua_S) 01315 { 01316 #ifndef TOLUA_RELEASE 01317 tolua_Error tolua_err; 01318 if ( 01319 !tolua_isusertable(tolua_S,1,"fawkes::KatanaInterface::CalibrateMessage",0,&tolua_err) || 01320 !tolua_isnoobj(tolua_S,2,&tolua_err) 01321 ) 01322 goto tolua_lerror; 01323 else 01324 #endif 01325 { 01326 { 01327 fawkes::KatanaInterface::CalibrateMessage* tolua_ret = (fawkes::KatanaInterface::CalibrateMessage*) Mtolua_new((fawkes::KatanaInterface::CalibrateMessage)()); 01328 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::KatanaInterface::CalibrateMessage"); 01329 } 01330 } 01331 return 1; 01332 #ifndef TOLUA_RELEASE 01333 tolua_lerror: 01334 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 01335 return 0; 01336 #endif 01337 } 01338 #endif //#ifndef TOLUA_DISABLE 01339 01340 /* method: new_local of class CalibrateMessage */ 01341 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_CalibrateMessage_new00_local 01342 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_CalibrateMessage_new00_local(lua_State* tolua_S) 01343 { 01344 #ifndef TOLUA_RELEASE 01345 tolua_Error tolua_err; 01346 if ( 01347 !tolua_isusertable(tolua_S,1,"fawkes::KatanaInterface::CalibrateMessage",0,&tolua_err) || 01348 !tolua_isnoobj(tolua_S,2,&tolua_err) 01349 ) 01350 goto tolua_lerror; 01351 else 01352 #endif 01353 { 01354 { 01355 fawkes::KatanaInterface::CalibrateMessage* tolua_ret = (fawkes::KatanaInterface::CalibrateMessage*) Mtolua_new((fawkes::KatanaInterface::CalibrateMessage)()); 01356 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::KatanaInterface::CalibrateMessage"); 01357 tolua_register_gc(tolua_S,lua_gettop(tolua_S)); 01358 } 01359 } 01360 return 1; 01361 #ifndef TOLUA_RELEASE 01362 tolua_lerror: 01363 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 01364 return 0; 01365 #endif 01366 } 01367 #endif //#ifndef TOLUA_DISABLE 01368 01369 /* method: delete of class CalibrateMessage */ 01370 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_CalibrateMessage_delete00 01371 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_CalibrateMessage_delete00(lua_State* tolua_S) 01372 { 01373 #ifndef TOLUA_RELEASE 01374 tolua_Error tolua_err; 01375 if ( 01376 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface::CalibrateMessage",0,&tolua_err) || 01377 !tolua_isnoobj(tolua_S,2,&tolua_err) 01378 ) 01379 goto tolua_lerror; 01380 else 01381 #endif 01382 { 01383 fawkes::KatanaInterface::CalibrateMessage* self = (fawkes::KatanaInterface::CalibrateMessage*) tolua_tousertype(tolua_S,1,0); 01384 #ifndef TOLUA_RELEASE 01385 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL); 01386 #endif 01387 Mtolua_delete(self); 01388 } 01389 return 0; 01390 #ifndef TOLUA_RELEASE 01391 tolua_lerror: 01392 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err); 01393 return 0; 01394 #endif 01395 } 01396 #endif //#ifndef TOLUA_DISABLE 01397 01398 /* method: new of class OpenGripperMessage */ 01399 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_OpenGripperMessage_new00 01400 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_OpenGripperMessage_new00(lua_State* tolua_S) 01401 { 01402 #ifndef TOLUA_RELEASE 01403 tolua_Error tolua_err; 01404 if ( 01405 !tolua_isusertable(tolua_S,1,"fawkes::KatanaInterface::OpenGripperMessage",0,&tolua_err) || 01406 !tolua_isnoobj(tolua_S,2,&tolua_err) 01407 ) 01408 goto tolua_lerror; 01409 else 01410 #endif 01411 { 01412 { 01413 fawkes::KatanaInterface::OpenGripperMessage* tolua_ret = (fawkes::KatanaInterface::OpenGripperMessage*) Mtolua_new((fawkes::KatanaInterface::OpenGripperMessage)()); 01414 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::KatanaInterface::OpenGripperMessage"); 01415 } 01416 } 01417 return 1; 01418 #ifndef TOLUA_RELEASE 01419 tolua_lerror: 01420 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 01421 return 0; 01422 #endif 01423 } 01424 #endif //#ifndef TOLUA_DISABLE 01425 01426 /* method: new_local of class OpenGripperMessage */ 01427 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_OpenGripperMessage_new00_local 01428 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_OpenGripperMessage_new00_local(lua_State* tolua_S) 01429 { 01430 #ifndef TOLUA_RELEASE 01431 tolua_Error tolua_err; 01432 if ( 01433 !tolua_isusertable(tolua_S,1,"fawkes::KatanaInterface::OpenGripperMessage",0,&tolua_err) || 01434 !tolua_isnoobj(tolua_S,2,&tolua_err) 01435 ) 01436 goto tolua_lerror; 01437 else 01438 #endif 01439 { 01440 { 01441 fawkes::KatanaInterface::OpenGripperMessage* tolua_ret = (fawkes::KatanaInterface::OpenGripperMessage*) Mtolua_new((fawkes::KatanaInterface::OpenGripperMessage)()); 01442 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::KatanaInterface::OpenGripperMessage"); 01443 tolua_register_gc(tolua_S,lua_gettop(tolua_S)); 01444 } 01445 } 01446 return 1; 01447 #ifndef TOLUA_RELEASE 01448 tolua_lerror: 01449 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 01450 return 0; 01451 #endif 01452 } 01453 #endif //#ifndef TOLUA_DISABLE 01454 01455 /* method: delete of class OpenGripperMessage */ 01456 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_OpenGripperMessage_delete00 01457 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_OpenGripperMessage_delete00(lua_State* tolua_S) 01458 { 01459 #ifndef TOLUA_RELEASE 01460 tolua_Error tolua_err; 01461 if ( 01462 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface::OpenGripperMessage",0,&tolua_err) || 01463 !tolua_isnoobj(tolua_S,2,&tolua_err) 01464 ) 01465 goto tolua_lerror; 01466 else 01467 #endif 01468 { 01469 fawkes::KatanaInterface::OpenGripperMessage* self = (fawkes::KatanaInterface::OpenGripperMessage*) tolua_tousertype(tolua_S,1,0); 01470 #ifndef TOLUA_RELEASE 01471 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL); 01472 #endif 01473 Mtolua_delete(self); 01474 } 01475 return 0; 01476 #ifndef TOLUA_RELEASE 01477 tolua_lerror: 01478 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err); 01479 return 0; 01480 #endif 01481 } 01482 #endif //#ifndef TOLUA_DISABLE 01483 01484 /* method: new of class CloseGripperMessage */ 01485 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_CloseGripperMessage_new00 01486 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_CloseGripperMessage_new00(lua_State* tolua_S) 01487 { 01488 #ifndef TOLUA_RELEASE 01489 tolua_Error tolua_err; 01490 if ( 01491 !tolua_isusertable(tolua_S,1,"fawkes::KatanaInterface::CloseGripperMessage",0,&tolua_err) || 01492 !tolua_isnoobj(tolua_S,2,&tolua_err) 01493 ) 01494 goto tolua_lerror; 01495 else 01496 #endif 01497 { 01498 { 01499 fawkes::KatanaInterface::CloseGripperMessage* tolua_ret = (fawkes::KatanaInterface::CloseGripperMessage*) Mtolua_new((fawkes::KatanaInterface::CloseGripperMessage)()); 01500 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::KatanaInterface::CloseGripperMessage"); 01501 } 01502 } 01503 return 1; 01504 #ifndef TOLUA_RELEASE 01505 tolua_lerror: 01506 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 01507 return 0; 01508 #endif 01509 } 01510 #endif //#ifndef TOLUA_DISABLE 01511 01512 /* method: new_local of class CloseGripperMessage */ 01513 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_CloseGripperMessage_new00_local 01514 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_CloseGripperMessage_new00_local(lua_State* tolua_S) 01515 { 01516 #ifndef TOLUA_RELEASE 01517 tolua_Error tolua_err; 01518 if ( 01519 !tolua_isusertable(tolua_S,1,"fawkes::KatanaInterface::CloseGripperMessage",0,&tolua_err) || 01520 !tolua_isnoobj(tolua_S,2,&tolua_err) 01521 ) 01522 goto tolua_lerror; 01523 else 01524 #endif 01525 { 01526 { 01527 fawkes::KatanaInterface::CloseGripperMessage* tolua_ret = (fawkes::KatanaInterface::CloseGripperMessage*) Mtolua_new((fawkes::KatanaInterface::CloseGripperMessage)()); 01528 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::KatanaInterface::CloseGripperMessage"); 01529 tolua_register_gc(tolua_S,lua_gettop(tolua_S)); 01530 } 01531 } 01532 return 1; 01533 #ifndef TOLUA_RELEASE 01534 tolua_lerror: 01535 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 01536 return 0; 01537 #endif 01538 } 01539 #endif //#ifndef TOLUA_DISABLE 01540 01541 /* method: delete of class CloseGripperMessage */ 01542 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_CloseGripperMessage_delete00 01543 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_CloseGripperMessage_delete00(lua_State* tolua_S) 01544 { 01545 #ifndef TOLUA_RELEASE 01546 tolua_Error tolua_err; 01547 if ( 01548 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface::CloseGripperMessage",0,&tolua_err) || 01549 !tolua_isnoobj(tolua_S,2,&tolua_err) 01550 ) 01551 goto tolua_lerror; 01552 else 01553 #endif 01554 { 01555 fawkes::KatanaInterface::CloseGripperMessage* self = (fawkes::KatanaInterface::CloseGripperMessage*) tolua_tousertype(tolua_S,1,0); 01556 #ifndef TOLUA_RELEASE 01557 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL); 01558 #endif 01559 Mtolua_delete(self); 01560 } 01561 return 0; 01562 #ifndef TOLUA_RELEASE 01563 tolua_lerror: 01564 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err); 01565 return 0; 01566 #endif 01567 } 01568 #endif //#ifndef TOLUA_DISABLE 01569 01570 /* method: new of class SetEnabledMessage */ 01571 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_SetEnabledMessage_new00 01572 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_SetEnabledMessage_new00(lua_State* tolua_S) 01573 { 01574 #ifndef TOLUA_RELEASE 01575 tolua_Error tolua_err; 01576 if ( 01577 !tolua_isusertable(tolua_S,1,"fawkes::KatanaInterface::SetEnabledMessage",0,&tolua_err) || 01578 !tolua_isboolean(tolua_S,2,0,&tolua_err) || 01579 !tolua_isnoobj(tolua_S,3,&tolua_err) 01580 ) 01581 goto tolua_lerror; 01582 else 01583 #endif 01584 { 01585 bool ini_enabled = ((bool) tolua_toboolean(tolua_S,2,0)); 01586 { 01587 fawkes::KatanaInterface::SetEnabledMessage* tolua_ret = (fawkes::KatanaInterface::SetEnabledMessage*) Mtolua_new((fawkes::KatanaInterface::SetEnabledMessage)(ini_enabled)); 01588 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::KatanaInterface::SetEnabledMessage"); 01589 } 01590 } 01591 return 1; 01592 #ifndef TOLUA_RELEASE 01593 tolua_lerror: 01594 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 01595 return 0; 01596 #endif 01597 } 01598 #endif //#ifndef TOLUA_DISABLE 01599 01600 /* method: new_local of class SetEnabledMessage */ 01601 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_SetEnabledMessage_new00_local 01602 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_SetEnabledMessage_new00_local(lua_State* tolua_S) 01603 { 01604 #ifndef TOLUA_RELEASE 01605 tolua_Error tolua_err; 01606 if ( 01607 !tolua_isusertable(tolua_S,1,"fawkes::KatanaInterface::SetEnabledMessage",0,&tolua_err) || 01608 !tolua_isboolean(tolua_S,2,0,&tolua_err) || 01609 !tolua_isnoobj(tolua_S,3,&tolua_err) 01610 ) 01611 goto tolua_lerror; 01612 else 01613 #endif 01614 { 01615 bool ini_enabled = ((bool) tolua_toboolean(tolua_S,2,0)); 01616 { 01617 fawkes::KatanaInterface::SetEnabledMessage* tolua_ret = (fawkes::KatanaInterface::SetEnabledMessage*) Mtolua_new((fawkes::KatanaInterface::SetEnabledMessage)(ini_enabled)); 01618 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::KatanaInterface::SetEnabledMessage"); 01619 tolua_register_gc(tolua_S,lua_gettop(tolua_S)); 01620 } 01621 } 01622 return 1; 01623 #ifndef TOLUA_RELEASE 01624 tolua_lerror: 01625 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 01626 return 0; 01627 #endif 01628 } 01629 #endif //#ifndef TOLUA_DISABLE 01630 01631 /* method: new of class SetEnabledMessage */ 01632 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_SetEnabledMessage_new01 01633 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_SetEnabledMessage_new01(lua_State* tolua_S) 01634 { 01635 tolua_Error tolua_err; 01636 if ( 01637 !tolua_isusertable(tolua_S,1,"fawkes::KatanaInterface::SetEnabledMessage",0,&tolua_err) || 01638 !tolua_isnoobj(tolua_S,2,&tolua_err) 01639 ) 01640 goto tolua_lerror; 01641 else 01642 { 01643 { 01644 fawkes::KatanaInterface::SetEnabledMessage* tolua_ret = (fawkes::KatanaInterface::SetEnabledMessage*) Mtolua_new((fawkes::KatanaInterface::SetEnabledMessage)()); 01645 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::KatanaInterface::SetEnabledMessage"); 01646 } 01647 } 01648 return 1; 01649 tolua_lerror: 01650 return tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_SetEnabledMessage_new00(tolua_S); 01651 } 01652 #endif //#ifndef TOLUA_DISABLE 01653 01654 /* method: new_local of class SetEnabledMessage */ 01655 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_SetEnabledMessage_new01_local 01656 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_SetEnabledMessage_new01_local(lua_State* tolua_S) 01657 { 01658 tolua_Error tolua_err; 01659 if ( 01660 !tolua_isusertable(tolua_S,1,"fawkes::KatanaInterface::SetEnabledMessage",0,&tolua_err) || 01661 !tolua_isnoobj(tolua_S,2,&tolua_err) 01662 ) 01663 goto tolua_lerror; 01664 else 01665 { 01666 { 01667 fawkes::KatanaInterface::SetEnabledMessage* tolua_ret = (fawkes::KatanaInterface::SetEnabledMessage*) Mtolua_new((fawkes::KatanaInterface::SetEnabledMessage)()); 01668 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::KatanaInterface::SetEnabledMessage"); 01669 tolua_register_gc(tolua_S,lua_gettop(tolua_S)); 01670 } 01671 } 01672 return 1; 01673 tolua_lerror: 01674 return tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_SetEnabledMessage_new00_local(tolua_S); 01675 } 01676 #endif //#ifndef TOLUA_DISABLE 01677 01678 /* method: delete of class SetEnabledMessage */ 01679 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_SetEnabledMessage_delete00 01680 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_SetEnabledMessage_delete00(lua_State* tolua_S) 01681 { 01682 #ifndef TOLUA_RELEASE 01683 tolua_Error tolua_err; 01684 if ( 01685 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface::SetEnabledMessage",0,&tolua_err) || 01686 !tolua_isnoobj(tolua_S,2,&tolua_err) 01687 ) 01688 goto tolua_lerror; 01689 else 01690 #endif 01691 { 01692 fawkes::KatanaInterface::SetEnabledMessage* self = (fawkes::KatanaInterface::SetEnabledMessage*) tolua_tousertype(tolua_S,1,0); 01693 #ifndef TOLUA_RELEASE 01694 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL); 01695 #endif 01696 Mtolua_delete(self); 01697 } 01698 return 0; 01699 #ifndef TOLUA_RELEASE 01700 tolua_lerror: 01701 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err); 01702 return 0; 01703 #endif 01704 } 01705 #endif //#ifndef TOLUA_DISABLE 01706 01707 /* method: is_enabled of class SetEnabledMessage */ 01708 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_SetEnabledMessage_is_enabled00 01709 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_SetEnabledMessage_is_enabled00(lua_State* tolua_S) 01710 { 01711 #ifndef TOLUA_RELEASE 01712 tolua_Error tolua_err; 01713 if ( 01714 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface::SetEnabledMessage",0,&tolua_err) || 01715 !tolua_isnoobj(tolua_S,2,&tolua_err) 01716 ) 01717 goto tolua_lerror; 01718 else 01719 #endif 01720 { 01721 fawkes::KatanaInterface::SetEnabledMessage* self = (fawkes::KatanaInterface::SetEnabledMessage*) tolua_tousertype(tolua_S,1,0); 01722 #ifndef TOLUA_RELEASE 01723 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_enabled'", NULL); 01724 #endif 01725 { 01726 bool tolua_ret = (bool) self->is_enabled(); 01727 tolua_pushboolean(tolua_S,(bool)tolua_ret); 01728 } 01729 } 01730 return 1; 01731 #ifndef TOLUA_RELEASE 01732 tolua_lerror: 01733 tolua_error(tolua_S,"#ferror in function 'is_enabled'.",&tolua_err); 01734 return 0; 01735 #endif 01736 } 01737 #endif //#ifndef TOLUA_DISABLE 01738 01739 /* method: set_enabled of class SetEnabledMessage */ 01740 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_SetEnabledMessage_set_enabled00 01741 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_SetEnabledMessage_set_enabled00(lua_State* tolua_S) 01742 { 01743 #ifndef TOLUA_RELEASE 01744 tolua_Error tolua_err; 01745 if ( 01746 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface::SetEnabledMessage",0,&tolua_err) || 01747 !tolua_isboolean(tolua_S,2,0,&tolua_err) || 01748 !tolua_isnoobj(tolua_S,3,&tolua_err) 01749 ) 01750 goto tolua_lerror; 01751 else 01752 #endif 01753 { 01754 fawkes::KatanaInterface::SetEnabledMessage* self = (fawkes::KatanaInterface::SetEnabledMessage*) tolua_tousertype(tolua_S,1,0); 01755 const bool new_enabled = ((const bool) tolua_toboolean(tolua_S,2,0)); 01756 #ifndef TOLUA_RELEASE 01757 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_enabled'", NULL); 01758 #endif 01759 { 01760 self->set_enabled(new_enabled); 01761 } 01762 } 01763 return 0; 01764 #ifndef TOLUA_RELEASE 01765 tolua_lerror: 01766 tolua_error(tolua_S,"#ferror in function 'set_enabled'.",&tolua_err); 01767 return 0; 01768 #endif 01769 } 01770 #endif //#ifndef TOLUA_DISABLE 01771 01772 /* method: maxlenof_enabled of class SetEnabledMessage */ 01773 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_SetEnabledMessage_maxlenof_enabled00 01774 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_SetEnabledMessage_maxlenof_enabled00(lua_State* tolua_S) 01775 { 01776 #ifndef TOLUA_RELEASE 01777 tolua_Error tolua_err; 01778 if ( 01779 !tolua_isusertype(tolua_S,1,"const fawkes::KatanaInterface::SetEnabledMessage",0,&tolua_err) || 01780 !tolua_isnoobj(tolua_S,2,&tolua_err) 01781 ) 01782 goto tolua_lerror; 01783 else 01784 #endif 01785 { 01786 const fawkes::KatanaInterface::SetEnabledMessage* self = (const fawkes::KatanaInterface::SetEnabledMessage*) tolua_tousertype(tolua_S,1,0); 01787 #ifndef TOLUA_RELEASE 01788 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_enabled'", NULL); 01789 #endif 01790 { 01791 int tolua_ret = (int) self->maxlenof_enabled(); 01792 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01793 } 01794 } 01795 return 1; 01796 #ifndef TOLUA_RELEASE 01797 tolua_lerror: 01798 tolua_error(tolua_S,"#ferror in function 'maxlenof_enabled'.",&tolua_err); 01799 return 0; 01800 #endif 01801 } 01802 #endif //#ifndef TOLUA_DISABLE 01803 01804 /* method: new of class SetMaxVelocityMessage */ 01805 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_SetMaxVelocityMessage_new00 01806 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_SetMaxVelocityMessage_new00(lua_State* tolua_S) 01807 { 01808 #ifndef TOLUA_RELEASE 01809 tolua_Error tolua_err; 01810 if ( 01811 !tolua_isusertable(tolua_S,1,"fawkes::KatanaInterface::SetMaxVelocityMessage",0,&tolua_err) || 01812 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 01813 !tolua_isnoobj(tolua_S,3,&tolua_err) 01814 ) 01815 goto tolua_lerror; 01816 else 01817 #endif 01818 { 01819 unsigned char ini_max_velocity = ((unsigned char) tolua_tonumber(tolua_S,2,0)); 01820 { 01821 fawkes::KatanaInterface::SetMaxVelocityMessage* tolua_ret = (fawkes::KatanaInterface::SetMaxVelocityMessage*) Mtolua_new((fawkes::KatanaInterface::SetMaxVelocityMessage)(ini_max_velocity)); 01822 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::KatanaInterface::SetMaxVelocityMessage"); 01823 } 01824 } 01825 return 1; 01826 #ifndef TOLUA_RELEASE 01827 tolua_lerror: 01828 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 01829 return 0; 01830 #endif 01831 } 01832 #endif //#ifndef TOLUA_DISABLE 01833 01834 /* method: new_local of class SetMaxVelocityMessage */ 01835 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_SetMaxVelocityMessage_new00_local 01836 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_SetMaxVelocityMessage_new00_local(lua_State* tolua_S) 01837 { 01838 #ifndef TOLUA_RELEASE 01839 tolua_Error tolua_err; 01840 if ( 01841 !tolua_isusertable(tolua_S,1,"fawkes::KatanaInterface::SetMaxVelocityMessage",0,&tolua_err) || 01842 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 01843 !tolua_isnoobj(tolua_S,3,&tolua_err) 01844 ) 01845 goto tolua_lerror; 01846 else 01847 #endif 01848 { 01849 unsigned char ini_max_velocity = ((unsigned char) tolua_tonumber(tolua_S,2,0)); 01850 { 01851 fawkes::KatanaInterface::SetMaxVelocityMessage* tolua_ret = (fawkes::KatanaInterface::SetMaxVelocityMessage*) Mtolua_new((fawkes::KatanaInterface::SetMaxVelocityMessage)(ini_max_velocity)); 01852 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::KatanaInterface::SetMaxVelocityMessage"); 01853 tolua_register_gc(tolua_S,lua_gettop(tolua_S)); 01854 } 01855 } 01856 return 1; 01857 #ifndef TOLUA_RELEASE 01858 tolua_lerror: 01859 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 01860 return 0; 01861 #endif 01862 } 01863 #endif //#ifndef TOLUA_DISABLE 01864 01865 /* method: new of class SetMaxVelocityMessage */ 01866 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_SetMaxVelocityMessage_new01 01867 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_SetMaxVelocityMessage_new01(lua_State* tolua_S) 01868 { 01869 tolua_Error tolua_err; 01870 if ( 01871 !tolua_isusertable(tolua_S,1,"fawkes::KatanaInterface::SetMaxVelocityMessage",0,&tolua_err) || 01872 !tolua_isnoobj(tolua_S,2,&tolua_err) 01873 ) 01874 goto tolua_lerror; 01875 else 01876 { 01877 { 01878 fawkes::KatanaInterface::SetMaxVelocityMessage* tolua_ret = (fawkes::KatanaInterface::SetMaxVelocityMessage*) Mtolua_new((fawkes::KatanaInterface::SetMaxVelocityMessage)()); 01879 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::KatanaInterface::SetMaxVelocityMessage"); 01880 } 01881 } 01882 return 1; 01883 tolua_lerror: 01884 return tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_SetMaxVelocityMessage_new00(tolua_S); 01885 } 01886 #endif //#ifndef TOLUA_DISABLE 01887 01888 /* method: new_local of class SetMaxVelocityMessage */ 01889 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_SetMaxVelocityMessage_new01_local 01890 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_SetMaxVelocityMessage_new01_local(lua_State* tolua_S) 01891 { 01892 tolua_Error tolua_err; 01893 if ( 01894 !tolua_isusertable(tolua_S,1,"fawkes::KatanaInterface::SetMaxVelocityMessage",0,&tolua_err) || 01895 !tolua_isnoobj(tolua_S,2,&tolua_err) 01896 ) 01897 goto tolua_lerror; 01898 else 01899 { 01900 { 01901 fawkes::KatanaInterface::SetMaxVelocityMessage* tolua_ret = (fawkes::KatanaInterface::SetMaxVelocityMessage*) Mtolua_new((fawkes::KatanaInterface::SetMaxVelocityMessage)()); 01902 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::KatanaInterface::SetMaxVelocityMessage"); 01903 tolua_register_gc(tolua_S,lua_gettop(tolua_S)); 01904 } 01905 } 01906 return 1; 01907 tolua_lerror: 01908 return tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_SetMaxVelocityMessage_new00_local(tolua_S); 01909 } 01910 #endif //#ifndef TOLUA_DISABLE 01911 01912 /* method: delete of class SetMaxVelocityMessage */ 01913 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_SetMaxVelocityMessage_delete00 01914 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_SetMaxVelocityMessage_delete00(lua_State* tolua_S) 01915 { 01916 #ifndef TOLUA_RELEASE 01917 tolua_Error tolua_err; 01918 if ( 01919 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface::SetMaxVelocityMessage",0,&tolua_err) || 01920 !tolua_isnoobj(tolua_S,2,&tolua_err) 01921 ) 01922 goto tolua_lerror; 01923 else 01924 #endif 01925 { 01926 fawkes::KatanaInterface::SetMaxVelocityMessage* self = (fawkes::KatanaInterface::SetMaxVelocityMessage*) tolua_tousertype(tolua_S,1,0); 01927 #ifndef TOLUA_RELEASE 01928 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL); 01929 #endif 01930 Mtolua_delete(self); 01931 } 01932 return 0; 01933 #ifndef TOLUA_RELEASE 01934 tolua_lerror: 01935 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err); 01936 return 0; 01937 #endif 01938 } 01939 #endif //#ifndef TOLUA_DISABLE 01940 01941 /* method: max_velocity of class SetMaxVelocityMessage */ 01942 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_SetMaxVelocityMessage_max_velocity00 01943 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_SetMaxVelocityMessage_max_velocity00(lua_State* tolua_S) 01944 { 01945 #ifndef TOLUA_RELEASE 01946 tolua_Error tolua_err; 01947 if ( 01948 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface::SetMaxVelocityMessage",0,&tolua_err) || 01949 !tolua_isnoobj(tolua_S,2,&tolua_err) 01950 ) 01951 goto tolua_lerror; 01952 else 01953 #endif 01954 { 01955 fawkes::KatanaInterface::SetMaxVelocityMessage* self = (fawkes::KatanaInterface::SetMaxVelocityMessage*) tolua_tousertype(tolua_S,1,0); 01956 #ifndef TOLUA_RELEASE 01957 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'max_velocity'", NULL); 01958 #endif 01959 { 01960 unsigned char tolua_ret = (unsigned char) self->max_velocity(); 01961 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01962 } 01963 } 01964 return 1; 01965 #ifndef TOLUA_RELEASE 01966 tolua_lerror: 01967 tolua_error(tolua_S,"#ferror in function 'max_velocity'.",&tolua_err); 01968 return 0; 01969 #endif 01970 } 01971 #endif //#ifndef TOLUA_DISABLE 01972 01973 /* method: set_max_velocity of class SetMaxVelocityMessage */ 01974 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_SetMaxVelocityMessage_set_max_velocity00 01975 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_SetMaxVelocityMessage_set_max_velocity00(lua_State* tolua_S) 01976 { 01977 #ifndef TOLUA_RELEASE 01978 tolua_Error tolua_err; 01979 if ( 01980 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface::SetMaxVelocityMessage",0,&tolua_err) || 01981 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 01982 !tolua_isnoobj(tolua_S,3,&tolua_err) 01983 ) 01984 goto tolua_lerror; 01985 else 01986 #endif 01987 { 01988 fawkes::KatanaInterface::SetMaxVelocityMessage* self = (fawkes::KatanaInterface::SetMaxVelocityMessage*) tolua_tousertype(tolua_S,1,0); 01989 unsigned const char new_max_velocity = ((unsigned const char) tolua_tonumber(tolua_S,2,0)); 01990 #ifndef TOLUA_RELEASE 01991 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_max_velocity'", NULL); 01992 #endif 01993 { 01994 self->set_max_velocity(new_max_velocity); 01995 } 01996 } 01997 return 0; 01998 #ifndef TOLUA_RELEASE 01999 tolua_lerror: 02000 tolua_error(tolua_S,"#ferror in function 'set_max_velocity'.",&tolua_err); 02001 return 0; 02002 #endif 02003 } 02004 #endif //#ifndef TOLUA_DISABLE 02005 02006 /* method: maxlenof_max_velocity of class SetMaxVelocityMessage */ 02007 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_SetMaxVelocityMessage_maxlenof_max_velocity00 02008 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_SetMaxVelocityMessage_maxlenof_max_velocity00(lua_State* tolua_S) 02009 { 02010 #ifndef TOLUA_RELEASE 02011 tolua_Error tolua_err; 02012 if ( 02013 !tolua_isusertype(tolua_S,1,"const fawkes::KatanaInterface::SetMaxVelocityMessage",0,&tolua_err) || 02014 !tolua_isnoobj(tolua_S,2,&tolua_err) 02015 ) 02016 goto tolua_lerror; 02017 else 02018 #endif 02019 { 02020 const fawkes::KatanaInterface::SetMaxVelocityMessage* self = (const fawkes::KatanaInterface::SetMaxVelocityMessage*) tolua_tousertype(tolua_S,1,0); 02021 #ifndef TOLUA_RELEASE 02022 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_max_velocity'", NULL); 02023 #endif 02024 { 02025 int tolua_ret = (int) self->maxlenof_max_velocity(); 02026 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 02027 } 02028 } 02029 return 1; 02030 #ifndef TOLUA_RELEASE 02031 tolua_lerror: 02032 tolua_error(tolua_S,"#ferror in function 'maxlenof_max_velocity'.",&tolua_err); 02033 return 0; 02034 #endif 02035 } 02036 #endif //#ifndef TOLUA_DISABLE 02037 02038 /* method: sensor_value of class fawkes::KatanaInterface */ 02039 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_sensor_value00 02040 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_sensor_value00(lua_State* tolua_S) 02041 { 02042 #ifndef TOLUA_RELEASE 02043 tolua_Error tolua_err; 02044 if ( 02045 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface",0,&tolua_err) || 02046 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 02047 !tolua_isnoobj(tolua_S,3,&tolua_err) 02048 ) 02049 goto tolua_lerror; 02050 else 02051 #endif 02052 { 02053 fawkes::KatanaInterface* self = (fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 02054 int index = ((int) tolua_tonumber(tolua_S,2,0)); 02055 #ifndef TOLUA_RELEASE 02056 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'sensor_value'", NULL); 02057 #endif 02058 { 02059 unsigned int tolua_ret = (unsigned int) self->sensor_value(index); 02060 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 02061 } 02062 } 02063 return 1; 02064 #ifndef TOLUA_RELEASE 02065 tolua_lerror: 02066 tolua_error(tolua_S,"#ferror in function 'sensor_value'.",&tolua_err); 02067 return 0; 02068 #endif 02069 } 02070 #endif //#ifndef TOLUA_DISABLE 02071 02072 /* method: set_sensor_value of class fawkes::KatanaInterface */ 02073 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_set_sensor_value00 02074 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_set_sensor_value00(lua_State* tolua_S) 02075 { 02076 #ifndef TOLUA_RELEASE 02077 tolua_Error tolua_err; 02078 if ( 02079 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface",0,&tolua_err) || 02080 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 02081 !tolua_isnumber(tolua_S,3,0,&tolua_err) || 02082 !tolua_isnoobj(tolua_S,4,&tolua_err) 02083 ) 02084 goto tolua_lerror; 02085 else 02086 #endif 02087 { 02088 fawkes::KatanaInterface* self = (fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 02089 unsigned int index = ((unsigned int) tolua_tonumber(tolua_S,2,0)); 02090 unsigned const char new_sensor_value = ((unsigned const char) tolua_tonumber(tolua_S,3,0)); 02091 #ifndef TOLUA_RELEASE 02092 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_sensor_value'", NULL); 02093 #endif 02094 { 02095 self->set_sensor_value(index,new_sensor_value); 02096 } 02097 } 02098 return 0; 02099 #ifndef TOLUA_RELEASE 02100 tolua_lerror: 02101 tolua_error(tolua_S,"#ferror in function 'set_sensor_value'.",&tolua_err); 02102 return 0; 02103 #endif 02104 } 02105 #endif //#ifndef TOLUA_DISABLE 02106 02107 /* method: maxlenof_sensor_value of class fawkes::KatanaInterface */ 02108 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_maxlenof_sensor_value00 02109 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_maxlenof_sensor_value00(lua_State* tolua_S) 02110 { 02111 #ifndef TOLUA_RELEASE 02112 tolua_Error tolua_err; 02113 if ( 02114 !tolua_isusertype(tolua_S,1,"const fawkes::KatanaInterface",0,&tolua_err) || 02115 !tolua_isnoobj(tolua_S,2,&tolua_err) 02116 ) 02117 goto tolua_lerror; 02118 else 02119 #endif 02120 { 02121 const fawkes::KatanaInterface* self = (const fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 02122 #ifndef TOLUA_RELEASE 02123 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_sensor_value'", NULL); 02124 #endif 02125 { 02126 int tolua_ret = (int) self->maxlenof_sensor_value(); 02127 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 02128 } 02129 } 02130 return 1; 02131 #ifndef TOLUA_RELEASE 02132 tolua_lerror: 02133 tolua_error(tolua_S,"#ferror in function 'maxlenof_sensor_value'.",&tolua_err); 02134 return 0; 02135 #endif 02136 } 02137 #endif //#ifndef TOLUA_DISABLE 02138 02139 /* method: x of class fawkes::KatanaInterface */ 02140 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_x00 02141 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_x00(lua_State* tolua_S) 02142 { 02143 #ifndef TOLUA_RELEASE 02144 tolua_Error tolua_err; 02145 if ( 02146 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface",0,&tolua_err) || 02147 !tolua_isnoobj(tolua_S,2,&tolua_err) 02148 ) 02149 goto tolua_lerror; 02150 else 02151 #endif 02152 { 02153 fawkes::KatanaInterface* self = (fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 02154 #ifndef TOLUA_RELEASE 02155 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'x'", NULL); 02156 #endif 02157 { 02158 float tolua_ret = (float) self->x(); 02159 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 02160 } 02161 } 02162 return 1; 02163 #ifndef TOLUA_RELEASE 02164 tolua_lerror: 02165 tolua_error(tolua_S,"#ferror in function 'x'.",&tolua_err); 02166 return 0; 02167 #endif 02168 } 02169 #endif //#ifndef TOLUA_DISABLE 02170 02171 /* method: set_x of class fawkes::KatanaInterface */ 02172 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_set_x00 02173 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_set_x00(lua_State* tolua_S) 02174 { 02175 #ifndef TOLUA_RELEASE 02176 tolua_Error tolua_err; 02177 if ( 02178 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface",0,&tolua_err) || 02179 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 02180 !tolua_isnoobj(tolua_S,3,&tolua_err) 02181 ) 02182 goto tolua_lerror; 02183 else 02184 #endif 02185 { 02186 fawkes::KatanaInterface* self = (fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 02187 const float new_x = ((const float) tolua_tonumber(tolua_S,2,0)); 02188 #ifndef TOLUA_RELEASE 02189 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_x'", NULL); 02190 #endif 02191 { 02192 self->set_x(new_x); 02193 } 02194 } 02195 return 0; 02196 #ifndef TOLUA_RELEASE 02197 tolua_lerror: 02198 tolua_error(tolua_S,"#ferror in function 'set_x'.",&tolua_err); 02199 return 0; 02200 #endif 02201 } 02202 #endif //#ifndef TOLUA_DISABLE 02203 02204 /* method: maxlenof_x of class fawkes::KatanaInterface */ 02205 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_maxlenof_x00 02206 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_maxlenof_x00(lua_State* tolua_S) 02207 { 02208 #ifndef TOLUA_RELEASE 02209 tolua_Error tolua_err; 02210 if ( 02211 !tolua_isusertype(tolua_S,1,"const fawkes::KatanaInterface",0,&tolua_err) || 02212 !tolua_isnoobj(tolua_S,2,&tolua_err) 02213 ) 02214 goto tolua_lerror; 02215 else 02216 #endif 02217 { 02218 const fawkes::KatanaInterface* self = (const fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 02219 #ifndef TOLUA_RELEASE 02220 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_x'", NULL); 02221 #endif 02222 { 02223 int tolua_ret = (int) self->maxlenof_x(); 02224 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 02225 } 02226 } 02227 return 1; 02228 #ifndef TOLUA_RELEASE 02229 tolua_lerror: 02230 tolua_error(tolua_S,"#ferror in function 'maxlenof_x'.",&tolua_err); 02231 return 0; 02232 #endif 02233 } 02234 #endif //#ifndef TOLUA_DISABLE 02235 02236 /* method: y of class fawkes::KatanaInterface */ 02237 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_y00 02238 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_y00(lua_State* tolua_S) 02239 { 02240 #ifndef TOLUA_RELEASE 02241 tolua_Error tolua_err; 02242 if ( 02243 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface",0,&tolua_err) || 02244 !tolua_isnoobj(tolua_S,2,&tolua_err) 02245 ) 02246 goto tolua_lerror; 02247 else 02248 #endif 02249 { 02250 fawkes::KatanaInterface* self = (fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 02251 #ifndef TOLUA_RELEASE 02252 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'y'", NULL); 02253 #endif 02254 { 02255 float tolua_ret = (float) self->y(); 02256 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 02257 } 02258 } 02259 return 1; 02260 #ifndef TOLUA_RELEASE 02261 tolua_lerror: 02262 tolua_error(tolua_S,"#ferror in function 'y'.",&tolua_err); 02263 return 0; 02264 #endif 02265 } 02266 #endif //#ifndef TOLUA_DISABLE 02267 02268 /* method: set_y of class fawkes::KatanaInterface */ 02269 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_set_y00 02270 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_set_y00(lua_State* tolua_S) 02271 { 02272 #ifndef TOLUA_RELEASE 02273 tolua_Error tolua_err; 02274 if ( 02275 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface",0,&tolua_err) || 02276 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 02277 !tolua_isnoobj(tolua_S,3,&tolua_err) 02278 ) 02279 goto tolua_lerror; 02280 else 02281 #endif 02282 { 02283 fawkes::KatanaInterface* self = (fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 02284 const float new_y = ((const float) tolua_tonumber(tolua_S,2,0)); 02285 #ifndef TOLUA_RELEASE 02286 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_y'", NULL); 02287 #endif 02288 { 02289 self->set_y(new_y); 02290 } 02291 } 02292 return 0; 02293 #ifndef TOLUA_RELEASE 02294 tolua_lerror: 02295 tolua_error(tolua_S,"#ferror in function 'set_y'.",&tolua_err); 02296 return 0; 02297 #endif 02298 } 02299 #endif //#ifndef TOLUA_DISABLE 02300 02301 /* method: maxlenof_y of class fawkes::KatanaInterface */ 02302 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_maxlenof_y00 02303 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_maxlenof_y00(lua_State* tolua_S) 02304 { 02305 #ifndef TOLUA_RELEASE 02306 tolua_Error tolua_err; 02307 if ( 02308 !tolua_isusertype(tolua_S,1,"const fawkes::KatanaInterface",0,&tolua_err) || 02309 !tolua_isnoobj(tolua_S,2,&tolua_err) 02310 ) 02311 goto tolua_lerror; 02312 else 02313 #endif 02314 { 02315 const fawkes::KatanaInterface* self = (const fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 02316 #ifndef TOLUA_RELEASE 02317 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_y'", NULL); 02318 #endif 02319 { 02320 int tolua_ret = (int) self->maxlenof_y(); 02321 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 02322 } 02323 } 02324 return 1; 02325 #ifndef TOLUA_RELEASE 02326 tolua_lerror: 02327 tolua_error(tolua_S,"#ferror in function 'maxlenof_y'.",&tolua_err); 02328 return 0; 02329 #endif 02330 } 02331 #endif //#ifndef TOLUA_DISABLE 02332 02333 /* method: z of class fawkes::KatanaInterface */ 02334 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_z00 02335 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_z00(lua_State* tolua_S) 02336 { 02337 #ifndef TOLUA_RELEASE 02338 tolua_Error tolua_err; 02339 if ( 02340 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface",0,&tolua_err) || 02341 !tolua_isnoobj(tolua_S,2,&tolua_err) 02342 ) 02343 goto tolua_lerror; 02344 else 02345 #endif 02346 { 02347 fawkes::KatanaInterface* self = (fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 02348 #ifndef TOLUA_RELEASE 02349 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'z'", NULL); 02350 #endif 02351 { 02352 float tolua_ret = (float) self->z(); 02353 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 02354 } 02355 } 02356 return 1; 02357 #ifndef TOLUA_RELEASE 02358 tolua_lerror: 02359 tolua_error(tolua_S,"#ferror in function 'z'.",&tolua_err); 02360 return 0; 02361 #endif 02362 } 02363 #endif //#ifndef TOLUA_DISABLE 02364 02365 /* method: set_z of class fawkes::KatanaInterface */ 02366 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_set_z00 02367 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_set_z00(lua_State* tolua_S) 02368 { 02369 #ifndef TOLUA_RELEASE 02370 tolua_Error tolua_err; 02371 if ( 02372 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface",0,&tolua_err) || 02373 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 02374 !tolua_isnoobj(tolua_S,3,&tolua_err) 02375 ) 02376 goto tolua_lerror; 02377 else 02378 #endif 02379 { 02380 fawkes::KatanaInterface* self = (fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 02381 const float new_z = ((const float) tolua_tonumber(tolua_S,2,0)); 02382 #ifndef TOLUA_RELEASE 02383 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_z'", NULL); 02384 #endif 02385 { 02386 self->set_z(new_z); 02387 } 02388 } 02389 return 0; 02390 #ifndef TOLUA_RELEASE 02391 tolua_lerror: 02392 tolua_error(tolua_S,"#ferror in function 'set_z'.",&tolua_err); 02393 return 0; 02394 #endif 02395 } 02396 #endif //#ifndef TOLUA_DISABLE 02397 02398 /* method: maxlenof_z of class fawkes::KatanaInterface */ 02399 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_maxlenof_z00 02400 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_maxlenof_z00(lua_State* tolua_S) 02401 { 02402 #ifndef TOLUA_RELEASE 02403 tolua_Error tolua_err; 02404 if ( 02405 !tolua_isusertype(tolua_S,1,"const fawkes::KatanaInterface",0,&tolua_err) || 02406 !tolua_isnoobj(tolua_S,2,&tolua_err) 02407 ) 02408 goto tolua_lerror; 02409 else 02410 #endif 02411 { 02412 const fawkes::KatanaInterface* self = (const fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 02413 #ifndef TOLUA_RELEASE 02414 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_z'", NULL); 02415 #endif 02416 { 02417 int tolua_ret = (int) self->maxlenof_z(); 02418 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 02419 } 02420 } 02421 return 1; 02422 #ifndef TOLUA_RELEASE 02423 tolua_lerror: 02424 tolua_error(tolua_S,"#ferror in function 'maxlenof_z'.",&tolua_err); 02425 return 0; 02426 #endif 02427 } 02428 #endif //#ifndef TOLUA_DISABLE 02429 02430 /* method: phi of class fawkes::KatanaInterface */ 02431 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_phi00 02432 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_phi00(lua_State* tolua_S) 02433 { 02434 #ifndef TOLUA_RELEASE 02435 tolua_Error tolua_err; 02436 if ( 02437 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface",0,&tolua_err) || 02438 !tolua_isnoobj(tolua_S,2,&tolua_err) 02439 ) 02440 goto tolua_lerror; 02441 else 02442 #endif 02443 { 02444 fawkes::KatanaInterface* self = (fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 02445 #ifndef TOLUA_RELEASE 02446 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'phi'", NULL); 02447 #endif 02448 { 02449 float tolua_ret = (float) self->phi(); 02450 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 02451 } 02452 } 02453 return 1; 02454 #ifndef TOLUA_RELEASE 02455 tolua_lerror: 02456 tolua_error(tolua_S,"#ferror in function 'phi'.",&tolua_err); 02457 return 0; 02458 #endif 02459 } 02460 #endif //#ifndef TOLUA_DISABLE 02461 02462 /* method: set_phi of class fawkes::KatanaInterface */ 02463 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_set_phi00 02464 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_set_phi00(lua_State* tolua_S) 02465 { 02466 #ifndef TOLUA_RELEASE 02467 tolua_Error tolua_err; 02468 if ( 02469 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface",0,&tolua_err) || 02470 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 02471 !tolua_isnoobj(tolua_S,3,&tolua_err) 02472 ) 02473 goto tolua_lerror; 02474 else 02475 #endif 02476 { 02477 fawkes::KatanaInterface* self = (fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 02478 const float new_phi = ((const float) tolua_tonumber(tolua_S,2,0)); 02479 #ifndef TOLUA_RELEASE 02480 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_phi'", NULL); 02481 #endif 02482 { 02483 self->set_phi(new_phi); 02484 } 02485 } 02486 return 0; 02487 #ifndef TOLUA_RELEASE 02488 tolua_lerror: 02489 tolua_error(tolua_S,"#ferror in function 'set_phi'.",&tolua_err); 02490 return 0; 02491 #endif 02492 } 02493 #endif //#ifndef TOLUA_DISABLE 02494 02495 /* method: maxlenof_phi of class fawkes::KatanaInterface */ 02496 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_maxlenof_phi00 02497 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_maxlenof_phi00(lua_State* tolua_S) 02498 { 02499 #ifndef TOLUA_RELEASE 02500 tolua_Error tolua_err; 02501 if ( 02502 !tolua_isusertype(tolua_S,1,"const fawkes::KatanaInterface",0,&tolua_err) || 02503 !tolua_isnoobj(tolua_S,2,&tolua_err) 02504 ) 02505 goto tolua_lerror; 02506 else 02507 #endif 02508 { 02509 const fawkes::KatanaInterface* self = (const fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 02510 #ifndef TOLUA_RELEASE 02511 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_phi'", NULL); 02512 #endif 02513 { 02514 int tolua_ret = (int) self->maxlenof_phi(); 02515 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 02516 } 02517 } 02518 return 1; 02519 #ifndef TOLUA_RELEASE 02520 tolua_lerror: 02521 tolua_error(tolua_S,"#ferror in function 'maxlenof_phi'.",&tolua_err); 02522 return 0; 02523 #endif 02524 } 02525 #endif //#ifndef TOLUA_DISABLE 02526 02527 /* method: theta of class fawkes::KatanaInterface */ 02528 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_theta00 02529 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_theta00(lua_State* tolua_S) 02530 { 02531 #ifndef TOLUA_RELEASE 02532 tolua_Error tolua_err; 02533 if ( 02534 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface",0,&tolua_err) || 02535 !tolua_isnoobj(tolua_S,2,&tolua_err) 02536 ) 02537 goto tolua_lerror; 02538 else 02539 #endif 02540 { 02541 fawkes::KatanaInterface* self = (fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 02542 #ifndef TOLUA_RELEASE 02543 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'theta'", NULL); 02544 #endif 02545 { 02546 float tolua_ret = (float) self->theta(); 02547 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 02548 } 02549 } 02550 return 1; 02551 #ifndef TOLUA_RELEASE 02552 tolua_lerror: 02553 tolua_error(tolua_S,"#ferror in function 'theta'.",&tolua_err); 02554 return 0; 02555 #endif 02556 } 02557 #endif //#ifndef TOLUA_DISABLE 02558 02559 /* method: set_theta of class fawkes::KatanaInterface */ 02560 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_set_theta00 02561 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_set_theta00(lua_State* tolua_S) 02562 { 02563 #ifndef TOLUA_RELEASE 02564 tolua_Error tolua_err; 02565 if ( 02566 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface",0,&tolua_err) || 02567 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 02568 !tolua_isnoobj(tolua_S,3,&tolua_err) 02569 ) 02570 goto tolua_lerror; 02571 else 02572 #endif 02573 { 02574 fawkes::KatanaInterface* self = (fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 02575 const float new_theta = ((const float) tolua_tonumber(tolua_S,2,0)); 02576 #ifndef TOLUA_RELEASE 02577 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_theta'", NULL); 02578 #endif 02579 { 02580 self->set_theta(new_theta); 02581 } 02582 } 02583 return 0; 02584 #ifndef TOLUA_RELEASE 02585 tolua_lerror: 02586 tolua_error(tolua_S,"#ferror in function 'set_theta'.",&tolua_err); 02587 return 0; 02588 #endif 02589 } 02590 #endif //#ifndef TOLUA_DISABLE 02591 02592 /* method: maxlenof_theta of class fawkes::KatanaInterface */ 02593 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_maxlenof_theta00 02594 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_maxlenof_theta00(lua_State* tolua_S) 02595 { 02596 #ifndef TOLUA_RELEASE 02597 tolua_Error tolua_err; 02598 if ( 02599 !tolua_isusertype(tolua_S,1,"const fawkes::KatanaInterface",0,&tolua_err) || 02600 !tolua_isnoobj(tolua_S,2,&tolua_err) 02601 ) 02602 goto tolua_lerror; 02603 else 02604 #endif 02605 { 02606 const fawkes::KatanaInterface* self = (const fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 02607 #ifndef TOLUA_RELEASE 02608 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_theta'", NULL); 02609 #endif 02610 { 02611 int tolua_ret = (int) self->maxlenof_theta(); 02612 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 02613 } 02614 } 02615 return 1; 02616 #ifndef TOLUA_RELEASE 02617 tolua_lerror: 02618 tolua_error(tolua_S,"#ferror in function 'maxlenof_theta'.",&tolua_err); 02619 return 0; 02620 #endif 02621 } 02622 #endif //#ifndef TOLUA_DISABLE 02623 02624 /* method: psi of class fawkes::KatanaInterface */ 02625 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_psi00 02626 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_psi00(lua_State* tolua_S) 02627 { 02628 #ifndef TOLUA_RELEASE 02629 tolua_Error tolua_err; 02630 if ( 02631 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface",0,&tolua_err) || 02632 !tolua_isnoobj(tolua_S,2,&tolua_err) 02633 ) 02634 goto tolua_lerror; 02635 else 02636 #endif 02637 { 02638 fawkes::KatanaInterface* self = (fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 02639 #ifndef TOLUA_RELEASE 02640 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'psi'", NULL); 02641 #endif 02642 { 02643 float tolua_ret = (float) self->psi(); 02644 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 02645 } 02646 } 02647 return 1; 02648 #ifndef TOLUA_RELEASE 02649 tolua_lerror: 02650 tolua_error(tolua_S,"#ferror in function 'psi'.",&tolua_err); 02651 return 0; 02652 #endif 02653 } 02654 #endif //#ifndef TOLUA_DISABLE 02655 02656 /* method: set_psi of class fawkes::KatanaInterface */ 02657 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_set_psi00 02658 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_set_psi00(lua_State* tolua_S) 02659 { 02660 #ifndef TOLUA_RELEASE 02661 tolua_Error tolua_err; 02662 if ( 02663 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface",0,&tolua_err) || 02664 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 02665 !tolua_isnoobj(tolua_S,3,&tolua_err) 02666 ) 02667 goto tolua_lerror; 02668 else 02669 #endif 02670 { 02671 fawkes::KatanaInterface* self = (fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 02672 const float new_psi = ((const float) tolua_tonumber(tolua_S,2,0)); 02673 #ifndef TOLUA_RELEASE 02674 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_psi'", NULL); 02675 #endif 02676 { 02677 self->set_psi(new_psi); 02678 } 02679 } 02680 return 0; 02681 #ifndef TOLUA_RELEASE 02682 tolua_lerror: 02683 tolua_error(tolua_S,"#ferror in function 'set_psi'.",&tolua_err); 02684 return 0; 02685 #endif 02686 } 02687 #endif //#ifndef TOLUA_DISABLE 02688 02689 /* method: maxlenof_psi of class fawkes::KatanaInterface */ 02690 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_maxlenof_psi00 02691 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_maxlenof_psi00(lua_State* tolua_S) 02692 { 02693 #ifndef TOLUA_RELEASE 02694 tolua_Error tolua_err; 02695 if ( 02696 !tolua_isusertype(tolua_S,1,"const fawkes::KatanaInterface",0,&tolua_err) || 02697 !tolua_isnoobj(tolua_S,2,&tolua_err) 02698 ) 02699 goto tolua_lerror; 02700 else 02701 #endif 02702 { 02703 const fawkes::KatanaInterface* self = (const fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 02704 #ifndef TOLUA_RELEASE 02705 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_psi'", NULL); 02706 #endif 02707 { 02708 int tolua_ret = (int) self->maxlenof_psi(); 02709 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 02710 } 02711 } 02712 return 1; 02713 #ifndef TOLUA_RELEASE 02714 tolua_lerror: 02715 tolua_error(tolua_S,"#ferror in function 'maxlenof_psi'.",&tolua_err); 02716 return 0; 02717 #endif 02718 } 02719 #endif //#ifndef TOLUA_DISABLE 02720 02721 /* method: msgid of class fawkes::KatanaInterface */ 02722 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_msgid00 02723 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_msgid00(lua_State* tolua_S) 02724 { 02725 #ifndef TOLUA_RELEASE 02726 tolua_Error tolua_err; 02727 if ( 02728 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface",0,&tolua_err) || 02729 !tolua_isnoobj(tolua_S,2,&tolua_err) 02730 ) 02731 goto tolua_lerror; 02732 else 02733 #endif 02734 { 02735 fawkes::KatanaInterface* self = (fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 02736 #ifndef TOLUA_RELEASE 02737 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgid'", NULL); 02738 #endif 02739 { 02740 unsigned int tolua_ret = (unsigned int) self->msgid(); 02741 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 02742 } 02743 } 02744 return 1; 02745 #ifndef TOLUA_RELEASE 02746 tolua_lerror: 02747 tolua_error(tolua_S,"#ferror in function 'msgid'.",&tolua_err); 02748 return 0; 02749 #endif 02750 } 02751 #endif //#ifndef TOLUA_DISABLE 02752 02753 /* method: set_msgid of class fawkes::KatanaInterface */ 02754 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_set_msgid00 02755 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_set_msgid00(lua_State* tolua_S) 02756 { 02757 #ifndef TOLUA_RELEASE 02758 tolua_Error tolua_err; 02759 if ( 02760 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface",0,&tolua_err) || 02761 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 02762 !tolua_isnoobj(tolua_S,3,&tolua_err) 02763 ) 02764 goto tolua_lerror; 02765 else 02766 #endif 02767 { 02768 fawkes::KatanaInterface* self = (fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 02769 unsigned const int new_msgid = ((unsigned const int) tolua_tonumber(tolua_S,2,0)); 02770 #ifndef TOLUA_RELEASE 02771 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_msgid'", NULL); 02772 #endif 02773 { 02774 self->set_msgid(new_msgid); 02775 } 02776 } 02777 return 0; 02778 #ifndef TOLUA_RELEASE 02779 tolua_lerror: 02780 tolua_error(tolua_S,"#ferror in function 'set_msgid'.",&tolua_err); 02781 return 0; 02782 #endif 02783 } 02784 #endif //#ifndef TOLUA_DISABLE 02785 02786 /* method: maxlenof_msgid of class fawkes::KatanaInterface */ 02787 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_maxlenof_msgid00 02788 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_maxlenof_msgid00(lua_State* tolua_S) 02789 { 02790 #ifndef TOLUA_RELEASE 02791 tolua_Error tolua_err; 02792 if ( 02793 !tolua_isusertype(tolua_S,1,"const fawkes::KatanaInterface",0,&tolua_err) || 02794 !tolua_isnoobj(tolua_S,2,&tolua_err) 02795 ) 02796 goto tolua_lerror; 02797 else 02798 #endif 02799 { 02800 const fawkes::KatanaInterface* self = (const fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 02801 #ifndef TOLUA_RELEASE 02802 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_msgid'", NULL); 02803 #endif 02804 { 02805 int tolua_ret = (int) self->maxlenof_msgid(); 02806 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 02807 } 02808 } 02809 return 1; 02810 #ifndef TOLUA_RELEASE 02811 tolua_lerror: 02812 tolua_error(tolua_S,"#ferror in function 'maxlenof_msgid'.",&tolua_err); 02813 return 0; 02814 #endif 02815 } 02816 #endif //#ifndef TOLUA_DISABLE 02817 02818 /* method: is_final of class fawkes::KatanaInterface */ 02819 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_is_final00 02820 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_is_final00(lua_State* tolua_S) 02821 { 02822 #ifndef TOLUA_RELEASE 02823 tolua_Error tolua_err; 02824 if ( 02825 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface",0,&tolua_err) || 02826 !tolua_isnoobj(tolua_S,2,&tolua_err) 02827 ) 02828 goto tolua_lerror; 02829 else 02830 #endif 02831 { 02832 fawkes::KatanaInterface* self = (fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 02833 #ifndef TOLUA_RELEASE 02834 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_final'", NULL); 02835 #endif 02836 { 02837 bool tolua_ret = (bool) self->is_final(); 02838 tolua_pushboolean(tolua_S,(bool)tolua_ret); 02839 } 02840 } 02841 return 1; 02842 #ifndef TOLUA_RELEASE 02843 tolua_lerror: 02844 tolua_error(tolua_S,"#ferror in function 'is_final'.",&tolua_err); 02845 return 0; 02846 #endif 02847 } 02848 #endif //#ifndef TOLUA_DISABLE 02849 02850 /* method: set_final of class fawkes::KatanaInterface */ 02851 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_set_final00 02852 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_set_final00(lua_State* tolua_S) 02853 { 02854 #ifndef TOLUA_RELEASE 02855 tolua_Error tolua_err; 02856 if ( 02857 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface",0,&tolua_err) || 02858 !tolua_isboolean(tolua_S,2,0,&tolua_err) || 02859 !tolua_isnoobj(tolua_S,3,&tolua_err) 02860 ) 02861 goto tolua_lerror; 02862 else 02863 #endif 02864 { 02865 fawkes::KatanaInterface* self = (fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 02866 const bool new_final = ((const bool) tolua_toboolean(tolua_S,2,0)); 02867 #ifndef TOLUA_RELEASE 02868 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_final'", NULL); 02869 #endif 02870 { 02871 self->set_final(new_final); 02872 } 02873 } 02874 return 0; 02875 #ifndef TOLUA_RELEASE 02876 tolua_lerror: 02877 tolua_error(tolua_S,"#ferror in function 'set_final'.",&tolua_err); 02878 return 0; 02879 #endif 02880 } 02881 #endif //#ifndef TOLUA_DISABLE 02882 02883 /* method: maxlenof_final of class fawkes::KatanaInterface */ 02884 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_maxlenof_final00 02885 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_maxlenof_final00(lua_State* tolua_S) 02886 { 02887 #ifndef TOLUA_RELEASE 02888 tolua_Error tolua_err; 02889 if ( 02890 !tolua_isusertype(tolua_S,1,"const fawkes::KatanaInterface",0,&tolua_err) || 02891 !tolua_isnoobj(tolua_S,2,&tolua_err) 02892 ) 02893 goto tolua_lerror; 02894 else 02895 #endif 02896 { 02897 const fawkes::KatanaInterface* self = (const fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 02898 #ifndef TOLUA_RELEASE 02899 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_final'", NULL); 02900 #endif 02901 { 02902 int tolua_ret = (int) self->maxlenof_final(); 02903 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 02904 } 02905 } 02906 return 1; 02907 #ifndef TOLUA_RELEASE 02908 tolua_lerror: 02909 tolua_error(tolua_S,"#ferror in function 'maxlenof_final'.",&tolua_err); 02910 return 0; 02911 #endif 02912 } 02913 #endif //#ifndef TOLUA_DISABLE 02914 02915 /* method: error_code of class fawkes::KatanaInterface */ 02916 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_error_code00 02917 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_error_code00(lua_State* tolua_S) 02918 { 02919 #ifndef TOLUA_RELEASE 02920 tolua_Error tolua_err; 02921 if ( 02922 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface",0,&tolua_err) || 02923 !tolua_isnoobj(tolua_S,2,&tolua_err) 02924 ) 02925 goto tolua_lerror; 02926 else 02927 #endif 02928 { 02929 fawkes::KatanaInterface* self = (fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 02930 #ifndef TOLUA_RELEASE 02931 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'error_code'", NULL); 02932 #endif 02933 { 02934 unsigned int tolua_ret = (unsigned int) self->error_code(); 02935 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 02936 } 02937 } 02938 return 1; 02939 #ifndef TOLUA_RELEASE 02940 tolua_lerror: 02941 tolua_error(tolua_S,"#ferror in function 'error_code'.",&tolua_err); 02942 return 0; 02943 #endif 02944 } 02945 #endif //#ifndef TOLUA_DISABLE 02946 02947 /* method: set_error_code of class fawkes::KatanaInterface */ 02948 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_set_error_code00 02949 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_set_error_code00(lua_State* tolua_S) 02950 { 02951 #ifndef TOLUA_RELEASE 02952 tolua_Error tolua_err; 02953 if ( 02954 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface",0,&tolua_err) || 02955 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 02956 !tolua_isnoobj(tolua_S,3,&tolua_err) 02957 ) 02958 goto tolua_lerror; 02959 else 02960 #endif 02961 { 02962 fawkes::KatanaInterface* self = (fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 02963 unsigned const int new_error_code = ((unsigned const int) tolua_tonumber(tolua_S,2,0)); 02964 #ifndef TOLUA_RELEASE 02965 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_error_code'", NULL); 02966 #endif 02967 { 02968 self->set_error_code(new_error_code); 02969 } 02970 } 02971 return 0; 02972 #ifndef TOLUA_RELEASE 02973 tolua_lerror: 02974 tolua_error(tolua_S,"#ferror in function 'set_error_code'.",&tolua_err); 02975 return 0; 02976 #endif 02977 } 02978 #endif //#ifndef TOLUA_DISABLE 02979 02980 /* method: maxlenof_error_code of class fawkes::KatanaInterface */ 02981 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_maxlenof_error_code00 02982 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_maxlenof_error_code00(lua_State* tolua_S) 02983 { 02984 #ifndef TOLUA_RELEASE 02985 tolua_Error tolua_err; 02986 if ( 02987 !tolua_isusertype(tolua_S,1,"const fawkes::KatanaInterface",0,&tolua_err) || 02988 !tolua_isnoobj(tolua_S,2,&tolua_err) 02989 ) 02990 goto tolua_lerror; 02991 else 02992 #endif 02993 { 02994 const fawkes::KatanaInterface* self = (const fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 02995 #ifndef TOLUA_RELEASE 02996 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_error_code'", NULL); 02997 #endif 02998 { 02999 int tolua_ret = (int) self->maxlenof_error_code(); 03000 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 03001 } 03002 } 03003 return 1; 03004 #ifndef TOLUA_RELEASE 03005 tolua_lerror: 03006 tolua_error(tolua_S,"#ferror in function 'maxlenof_error_code'.",&tolua_err); 03007 return 0; 03008 #endif 03009 } 03010 #endif //#ifndef TOLUA_DISABLE 03011 03012 /* method: is_enabled of class fawkes::KatanaInterface */ 03013 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_is_enabled00 03014 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_is_enabled00(lua_State* tolua_S) 03015 { 03016 #ifndef TOLUA_RELEASE 03017 tolua_Error tolua_err; 03018 if ( 03019 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface",0,&tolua_err) || 03020 !tolua_isnoobj(tolua_S,2,&tolua_err) 03021 ) 03022 goto tolua_lerror; 03023 else 03024 #endif 03025 { 03026 fawkes::KatanaInterface* self = (fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 03027 #ifndef TOLUA_RELEASE 03028 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_enabled'", NULL); 03029 #endif 03030 { 03031 bool tolua_ret = (bool) self->is_enabled(); 03032 tolua_pushboolean(tolua_S,(bool)tolua_ret); 03033 } 03034 } 03035 return 1; 03036 #ifndef TOLUA_RELEASE 03037 tolua_lerror: 03038 tolua_error(tolua_S,"#ferror in function 'is_enabled'.",&tolua_err); 03039 return 0; 03040 #endif 03041 } 03042 #endif //#ifndef TOLUA_DISABLE 03043 03044 /* method: set_enabled of class fawkes::KatanaInterface */ 03045 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_set_enabled00 03046 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_set_enabled00(lua_State* tolua_S) 03047 { 03048 #ifndef TOLUA_RELEASE 03049 tolua_Error tolua_err; 03050 if ( 03051 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface",0,&tolua_err) || 03052 !tolua_isboolean(tolua_S,2,0,&tolua_err) || 03053 !tolua_isnoobj(tolua_S,3,&tolua_err) 03054 ) 03055 goto tolua_lerror; 03056 else 03057 #endif 03058 { 03059 fawkes::KatanaInterface* self = (fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 03060 const bool new_enabled = ((const bool) tolua_toboolean(tolua_S,2,0)); 03061 #ifndef TOLUA_RELEASE 03062 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_enabled'", NULL); 03063 #endif 03064 { 03065 self->set_enabled(new_enabled); 03066 } 03067 } 03068 return 0; 03069 #ifndef TOLUA_RELEASE 03070 tolua_lerror: 03071 tolua_error(tolua_S,"#ferror in function 'set_enabled'.",&tolua_err); 03072 return 0; 03073 #endif 03074 } 03075 #endif //#ifndef TOLUA_DISABLE 03076 03077 /* method: maxlenof_enabled of class fawkes::KatanaInterface */ 03078 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_maxlenof_enabled00 03079 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_maxlenof_enabled00(lua_State* tolua_S) 03080 { 03081 #ifndef TOLUA_RELEASE 03082 tolua_Error tolua_err; 03083 if ( 03084 !tolua_isusertype(tolua_S,1,"const fawkes::KatanaInterface",0,&tolua_err) || 03085 !tolua_isnoobj(tolua_S,2,&tolua_err) 03086 ) 03087 goto tolua_lerror; 03088 else 03089 #endif 03090 { 03091 const fawkes::KatanaInterface* self = (const fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 03092 #ifndef TOLUA_RELEASE 03093 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_enabled'", NULL); 03094 #endif 03095 { 03096 int tolua_ret = (int) self->maxlenof_enabled(); 03097 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 03098 } 03099 } 03100 return 1; 03101 #ifndef TOLUA_RELEASE 03102 tolua_lerror: 03103 tolua_error(tolua_S,"#ferror in function 'maxlenof_enabled'.",&tolua_err); 03104 return 0; 03105 #endif 03106 } 03107 #endif //#ifndef TOLUA_DISABLE 03108 03109 /* method: is_calibrated of class fawkes::KatanaInterface */ 03110 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_is_calibrated00 03111 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_is_calibrated00(lua_State* tolua_S) 03112 { 03113 #ifndef TOLUA_RELEASE 03114 tolua_Error tolua_err; 03115 if ( 03116 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface",0,&tolua_err) || 03117 !tolua_isnoobj(tolua_S,2,&tolua_err) 03118 ) 03119 goto tolua_lerror; 03120 else 03121 #endif 03122 { 03123 fawkes::KatanaInterface* self = (fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 03124 #ifndef TOLUA_RELEASE 03125 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_calibrated'", NULL); 03126 #endif 03127 { 03128 bool tolua_ret = (bool) self->is_calibrated(); 03129 tolua_pushboolean(tolua_S,(bool)tolua_ret); 03130 } 03131 } 03132 return 1; 03133 #ifndef TOLUA_RELEASE 03134 tolua_lerror: 03135 tolua_error(tolua_S,"#ferror in function 'is_calibrated'.",&tolua_err); 03136 return 0; 03137 #endif 03138 } 03139 #endif //#ifndef TOLUA_DISABLE 03140 03141 /* method: set_calibrated of class fawkes::KatanaInterface */ 03142 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_set_calibrated00 03143 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_set_calibrated00(lua_State* tolua_S) 03144 { 03145 #ifndef TOLUA_RELEASE 03146 tolua_Error tolua_err; 03147 if ( 03148 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface",0,&tolua_err) || 03149 !tolua_isboolean(tolua_S,2,0,&tolua_err) || 03150 !tolua_isnoobj(tolua_S,3,&tolua_err) 03151 ) 03152 goto tolua_lerror; 03153 else 03154 #endif 03155 { 03156 fawkes::KatanaInterface* self = (fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 03157 const bool new_calibrated = ((const bool) tolua_toboolean(tolua_S,2,0)); 03158 #ifndef TOLUA_RELEASE 03159 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_calibrated'", NULL); 03160 #endif 03161 { 03162 self->set_calibrated(new_calibrated); 03163 } 03164 } 03165 return 0; 03166 #ifndef TOLUA_RELEASE 03167 tolua_lerror: 03168 tolua_error(tolua_S,"#ferror in function 'set_calibrated'.",&tolua_err); 03169 return 0; 03170 #endif 03171 } 03172 #endif //#ifndef TOLUA_DISABLE 03173 03174 /* method: maxlenof_calibrated of class fawkes::KatanaInterface */ 03175 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_maxlenof_calibrated00 03176 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_maxlenof_calibrated00(lua_State* tolua_S) 03177 { 03178 #ifndef TOLUA_RELEASE 03179 tolua_Error tolua_err; 03180 if ( 03181 !tolua_isusertype(tolua_S,1,"const fawkes::KatanaInterface",0,&tolua_err) || 03182 !tolua_isnoobj(tolua_S,2,&tolua_err) 03183 ) 03184 goto tolua_lerror; 03185 else 03186 #endif 03187 { 03188 const fawkes::KatanaInterface* self = (const fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 03189 #ifndef TOLUA_RELEASE 03190 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_calibrated'", NULL); 03191 #endif 03192 { 03193 int tolua_ret = (int) self->maxlenof_calibrated(); 03194 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 03195 } 03196 } 03197 return 1; 03198 #ifndef TOLUA_RELEASE 03199 tolua_lerror: 03200 tolua_error(tolua_S,"#ferror in function 'maxlenof_calibrated'.",&tolua_err); 03201 return 0; 03202 #endif 03203 } 03204 #endif //#ifndef TOLUA_DISABLE 03205 03206 /* method: max_velocity of class fawkes::KatanaInterface */ 03207 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_max_velocity00 03208 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_max_velocity00(lua_State* tolua_S) 03209 { 03210 #ifndef TOLUA_RELEASE 03211 tolua_Error tolua_err; 03212 if ( 03213 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface",0,&tolua_err) || 03214 !tolua_isnoobj(tolua_S,2,&tolua_err) 03215 ) 03216 goto tolua_lerror; 03217 else 03218 #endif 03219 { 03220 fawkes::KatanaInterface* self = (fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 03221 #ifndef TOLUA_RELEASE 03222 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'max_velocity'", NULL); 03223 #endif 03224 { 03225 unsigned char tolua_ret = (unsigned char) self->max_velocity(); 03226 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 03227 } 03228 } 03229 return 1; 03230 #ifndef TOLUA_RELEASE 03231 tolua_lerror: 03232 tolua_error(tolua_S,"#ferror in function 'max_velocity'.",&tolua_err); 03233 return 0; 03234 #endif 03235 } 03236 #endif //#ifndef TOLUA_DISABLE 03237 03238 /* method: set_max_velocity of class fawkes::KatanaInterface */ 03239 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_set_max_velocity00 03240 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_set_max_velocity00(lua_State* tolua_S) 03241 { 03242 #ifndef TOLUA_RELEASE 03243 tolua_Error tolua_err; 03244 if ( 03245 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface",0,&tolua_err) || 03246 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 03247 !tolua_isnoobj(tolua_S,3,&tolua_err) 03248 ) 03249 goto tolua_lerror; 03250 else 03251 #endif 03252 { 03253 fawkes::KatanaInterface* self = (fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 03254 unsigned const char new_max_velocity = ((unsigned const char) tolua_tonumber(tolua_S,2,0)); 03255 #ifndef TOLUA_RELEASE 03256 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_max_velocity'", NULL); 03257 #endif 03258 { 03259 self->set_max_velocity(new_max_velocity); 03260 } 03261 } 03262 return 0; 03263 #ifndef TOLUA_RELEASE 03264 tolua_lerror: 03265 tolua_error(tolua_S,"#ferror in function 'set_max_velocity'.",&tolua_err); 03266 return 0; 03267 #endif 03268 } 03269 #endif //#ifndef TOLUA_DISABLE 03270 03271 /* method: maxlenof_max_velocity of class fawkes::KatanaInterface */ 03272 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_maxlenof_max_velocity00 03273 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_maxlenof_max_velocity00(lua_State* tolua_S) 03274 { 03275 #ifndef TOLUA_RELEASE 03276 tolua_Error tolua_err; 03277 if ( 03278 !tolua_isusertype(tolua_S,1,"const fawkes::KatanaInterface",0,&tolua_err) || 03279 !tolua_isnoobj(tolua_S,2,&tolua_err) 03280 ) 03281 goto tolua_lerror; 03282 else 03283 #endif 03284 { 03285 const fawkes::KatanaInterface* self = (const fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 03286 #ifndef TOLUA_RELEASE 03287 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_max_velocity'", NULL); 03288 #endif 03289 { 03290 int tolua_ret = (int) self->maxlenof_max_velocity(); 03291 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 03292 } 03293 } 03294 return 1; 03295 #ifndef TOLUA_RELEASE 03296 tolua_lerror: 03297 tolua_error(tolua_S,"#ferror in function 'maxlenof_max_velocity'.",&tolua_err); 03298 return 0; 03299 #endif 03300 } 03301 #endif //#ifndef TOLUA_DISABLE 03302 03303 /* method: num_motors of class fawkes::KatanaInterface */ 03304 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_num_motors00 03305 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_num_motors00(lua_State* tolua_S) 03306 { 03307 #ifndef TOLUA_RELEASE 03308 tolua_Error tolua_err; 03309 if ( 03310 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface",0,&tolua_err) || 03311 !tolua_isnoobj(tolua_S,2,&tolua_err) 03312 ) 03313 goto tolua_lerror; 03314 else 03315 #endif 03316 { 03317 fawkes::KatanaInterface* self = (fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 03318 #ifndef TOLUA_RELEASE 03319 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'num_motors'", NULL); 03320 #endif 03321 { 03322 unsigned char tolua_ret = (unsigned char) self->num_motors(); 03323 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 03324 } 03325 } 03326 return 1; 03327 #ifndef TOLUA_RELEASE 03328 tolua_lerror: 03329 tolua_error(tolua_S,"#ferror in function 'num_motors'.",&tolua_err); 03330 return 0; 03331 #endif 03332 } 03333 #endif //#ifndef TOLUA_DISABLE 03334 03335 /* method: set_num_motors of class fawkes::KatanaInterface */ 03336 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_set_num_motors00 03337 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_set_num_motors00(lua_State* tolua_S) 03338 { 03339 #ifndef TOLUA_RELEASE 03340 tolua_Error tolua_err; 03341 if ( 03342 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface",0,&tolua_err) || 03343 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 03344 !tolua_isnoobj(tolua_S,3,&tolua_err) 03345 ) 03346 goto tolua_lerror; 03347 else 03348 #endif 03349 { 03350 fawkes::KatanaInterface* self = (fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 03351 unsigned const char new_num_motors = ((unsigned const char) tolua_tonumber(tolua_S,2,0)); 03352 #ifndef TOLUA_RELEASE 03353 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_num_motors'", NULL); 03354 #endif 03355 { 03356 self->set_num_motors(new_num_motors); 03357 } 03358 } 03359 return 0; 03360 #ifndef TOLUA_RELEASE 03361 tolua_lerror: 03362 tolua_error(tolua_S,"#ferror in function 'set_num_motors'.",&tolua_err); 03363 return 0; 03364 #endif 03365 } 03366 #endif //#ifndef TOLUA_DISABLE 03367 03368 /* method: maxlenof_num_motors of class fawkes::KatanaInterface */ 03369 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_maxlenof_num_motors00 03370 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_maxlenof_num_motors00(lua_State* tolua_S) 03371 { 03372 #ifndef TOLUA_RELEASE 03373 tolua_Error tolua_err; 03374 if ( 03375 !tolua_isusertype(tolua_S,1,"const fawkes::KatanaInterface",0,&tolua_err) || 03376 !tolua_isnoobj(tolua_S,2,&tolua_err) 03377 ) 03378 goto tolua_lerror; 03379 else 03380 #endif 03381 { 03382 const fawkes::KatanaInterface* self = (const fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 03383 #ifndef TOLUA_RELEASE 03384 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_num_motors'", NULL); 03385 #endif 03386 { 03387 int tolua_ret = (int) self->maxlenof_num_motors(); 03388 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 03389 } 03390 } 03391 return 1; 03392 #ifndef TOLUA_RELEASE 03393 tolua_lerror: 03394 tolua_error(tolua_S,"#ferror in function 'maxlenof_num_motors'.",&tolua_err); 03395 return 0; 03396 #endif 03397 } 03398 #endif //#ifndef TOLUA_DISABLE 03399 03400 /* method: oftype of class fawkes::KatanaInterface */ 03401 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_oftype00 03402 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_oftype00(lua_State* tolua_S) 03403 { 03404 #ifndef TOLUA_RELEASE 03405 tolua_Error tolua_err; 03406 if ( 03407 !tolua_isusertype(tolua_S,1,"const fawkes::KatanaInterface",0,&tolua_err) || 03408 !tolua_isstring(tolua_S,2,0,&tolua_err) || 03409 !tolua_isnoobj(tolua_S,3,&tolua_err) 03410 ) 03411 goto tolua_lerror; 03412 else 03413 #endif 03414 { 03415 const fawkes::KatanaInterface* self = (const fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 03416 const char* interface_type = ((const char*) tolua_tostring(tolua_S,2,0)); 03417 #ifndef TOLUA_RELEASE 03418 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'oftype'", NULL); 03419 #endif 03420 { 03421 bool tolua_ret = (bool) self->oftype(interface_type); 03422 tolua_pushboolean(tolua_S,(bool)tolua_ret); 03423 } 03424 } 03425 return 1; 03426 #ifndef TOLUA_RELEASE 03427 tolua_lerror: 03428 tolua_error(tolua_S,"#ferror in function 'oftype'.",&tolua_err); 03429 return 0; 03430 #endif 03431 } 03432 #endif //#ifndef TOLUA_DISABLE 03433 03434 /* method: datachunk of class fawkes::KatanaInterface */ 03435 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_datachunk00 03436 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_datachunk00(lua_State* tolua_S) 03437 { 03438 #ifndef TOLUA_RELEASE 03439 tolua_Error tolua_err; 03440 if ( 03441 !tolua_isusertype(tolua_S,1,"const fawkes::KatanaInterface",0,&tolua_err) || 03442 !tolua_isnoobj(tolua_S,2,&tolua_err) 03443 ) 03444 goto tolua_lerror; 03445 else 03446 #endif 03447 { 03448 const fawkes::KatanaInterface* self = (const fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 03449 #ifndef TOLUA_RELEASE 03450 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datachunk'", NULL); 03451 #endif 03452 { 03453 const void* tolua_ret = (const void*) self->datachunk(); 03454 tolua_pushuserdata(tolua_S,(void*)tolua_ret); 03455 } 03456 } 03457 return 1; 03458 #ifndef TOLUA_RELEASE 03459 tolua_lerror: 03460 tolua_error(tolua_S,"#ferror in function 'datachunk'.",&tolua_err); 03461 return 0; 03462 #endif 03463 } 03464 #endif //#ifndef TOLUA_DISABLE 03465 03466 /* method: datasize of class fawkes::KatanaInterface */ 03467 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_datasize00 03468 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_datasize00(lua_State* tolua_S) 03469 { 03470 #ifndef TOLUA_RELEASE 03471 tolua_Error tolua_err; 03472 if ( 03473 !tolua_isusertype(tolua_S,1,"const fawkes::KatanaInterface",0,&tolua_err) || 03474 !tolua_isnoobj(tolua_S,2,&tolua_err) 03475 ) 03476 goto tolua_lerror; 03477 else 03478 #endif 03479 { 03480 const fawkes::KatanaInterface* self = (const fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 03481 #ifndef TOLUA_RELEASE 03482 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datasize'", NULL); 03483 #endif 03484 { 03485 unsigned int tolua_ret = (unsigned int) self->datasize(); 03486 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 03487 } 03488 } 03489 return 1; 03490 #ifndef TOLUA_RELEASE 03491 tolua_lerror: 03492 tolua_error(tolua_S,"#ferror in function 'datasize'.",&tolua_err); 03493 return 0; 03494 #endif 03495 } 03496 #endif //#ifndef TOLUA_DISABLE 03497 03498 /* method: type of class fawkes::KatanaInterface */ 03499 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_type00 03500 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_type00(lua_State* tolua_S) 03501 { 03502 #ifndef TOLUA_RELEASE 03503 tolua_Error tolua_err; 03504 if ( 03505 !tolua_isusertype(tolua_S,1,"const fawkes::KatanaInterface",0,&tolua_err) || 03506 !tolua_isnoobj(tolua_S,2,&tolua_err) 03507 ) 03508 goto tolua_lerror; 03509 else 03510 #endif 03511 { 03512 const fawkes::KatanaInterface* self = (const fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 03513 #ifndef TOLUA_RELEASE 03514 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'type'", NULL); 03515 #endif 03516 { 03517 const char* tolua_ret = (const char*) self->type(); 03518 tolua_pushstring(tolua_S,(const char*)tolua_ret); 03519 } 03520 } 03521 return 1; 03522 #ifndef TOLUA_RELEASE 03523 tolua_lerror: 03524 tolua_error(tolua_S,"#ferror in function 'type'.",&tolua_err); 03525 return 0; 03526 #endif 03527 } 03528 #endif //#ifndef TOLUA_DISABLE 03529 03530 /* method: id of class fawkes::KatanaInterface */ 03531 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_id00 03532 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_id00(lua_State* tolua_S) 03533 { 03534 #ifndef TOLUA_RELEASE 03535 tolua_Error tolua_err; 03536 if ( 03537 !tolua_isusertype(tolua_S,1,"const fawkes::KatanaInterface",0,&tolua_err) || 03538 !tolua_isnoobj(tolua_S,2,&tolua_err) 03539 ) 03540 goto tolua_lerror; 03541 else 03542 #endif 03543 { 03544 const fawkes::KatanaInterface* self = (const fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 03545 #ifndef TOLUA_RELEASE 03546 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'id'", NULL); 03547 #endif 03548 { 03549 const char* tolua_ret = (const char*) self->id(); 03550 tolua_pushstring(tolua_S,(const char*)tolua_ret); 03551 } 03552 } 03553 return 1; 03554 #ifndef TOLUA_RELEASE 03555 tolua_lerror: 03556 tolua_error(tolua_S,"#ferror in function 'id'.",&tolua_err); 03557 return 0; 03558 #endif 03559 } 03560 #endif //#ifndef TOLUA_DISABLE 03561 03562 /* method: uid of class fawkes::KatanaInterface */ 03563 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_uid00 03564 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_uid00(lua_State* tolua_S) 03565 { 03566 #ifndef TOLUA_RELEASE 03567 tolua_Error tolua_err; 03568 if ( 03569 !tolua_isusertype(tolua_S,1,"const fawkes::KatanaInterface",0,&tolua_err) || 03570 !tolua_isnoobj(tolua_S,2,&tolua_err) 03571 ) 03572 goto tolua_lerror; 03573 else 03574 #endif 03575 { 03576 const fawkes::KatanaInterface* self = (const fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 03577 #ifndef TOLUA_RELEASE 03578 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'uid'", NULL); 03579 #endif 03580 { 03581 const char* tolua_ret = (const char*) self->uid(); 03582 tolua_pushstring(tolua_S,(const char*)tolua_ret); 03583 } 03584 } 03585 return 1; 03586 #ifndef TOLUA_RELEASE 03587 tolua_lerror: 03588 tolua_error(tolua_S,"#ferror in function 'uid'.",&tolua_err); 03589 return 0; 03590 #endif 03591 } 03592 #endif //#ifndef TOLUA_DISABLE 03593 03594 /* method: serial of class fawkes::KatanaInterface */ 03595 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_serial00 03596 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_serial00(lua_State* tolua_S) 03597 { 03598 #ifndef TOLUA_RELEASE 03599 tolua_Error tolua_err; 03600 if ( 03601 !tolua_isusertype(tolua_S,1,"const fawkes::KatanaInterface",0,&tolua_err) || 03602 !tolua_isnoobj(tolua_S,2,&tolua_err) 03603 ) 03604 goto tolua_lerror; 03605 else 03606 #endif 03607 { 03608 const fawkes::KatanaInterface* self = (const fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 03609 #ifndef TOLUA_RELEASE 03610 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'serial'", NULL); 03611 #endif 03612 { 03613 unsigned int tolua_ret = (unsigned int) self->serial(); 03614 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 03615 } 03616 } 03617 return 1; 03618 #ifndef TOLUA_RELEASE 03619 tolua_lerror: 03620 tolua_error(tolua_S,"#ferror in function 'serial'.",&tolua_err); 03621 return 0; 03622 #endif 03623 } 03624 #endif //#ifndef TOLUA_DISABLE 03625 03626 /* method: mem_serial of class fawkes::KatanaInterface */ 03627 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_mem_serial00 03628 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_mem_serial00(lua_State* tolua_S) 03629 { 03630 #ifndef TOLUA_RELEASE 03631 tolua_Error tolua_err; 03632 if ( 03633 !tolua_isusertype(tolua_S,1,"const fawkes::KatanaInterface",0,&tolua_err) || 03634 !tolua_isnoobj(tolua_S,2,&tolua_err) 03635 ) 03636 goto tolua_lerror; 03637 else 03638 #endif 03639 { 03640 const fawkes::KatanaInterface* self = (const fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 03641 #ifndef TOLUA_RELEASE 03642 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'mem_serial'", NULL); 03643 #endif 03644 { 03645 unsigned int tolua_ret = (unsigned int) self->mem_serial(); 03646 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 03647 } 03648 } 03649 return 1; 03650 #ifndef TOLUA_RELEASE 03651 tolua_lerror: 03652 tolua_error(tolua_S,"#ferror in function 'mem_serial'.",&tolua_err); 03653 return 0; 03654 #endif 03655 } 03656 #endif //#ifndef TOLUA_DISABLE 03657 03658 /* method: operator== of class fawkes::KatanaInterface */ 03659 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface__eq00 03660 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface__eq00(lua_State* tolua_S) 03661 { 03662 #ifndef TOLUA_RELEASE 03663 tolua_Error tolua_err; 03664 if ( 03665 !tolua_isusertype(tolua_S,1,"const fawkes::KatanaInterface",0,&tolua_err) || 03666 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Interface",0,&tolua_err)) || 03667 !tolua_isnoobj(tolua_S,3,&tolua_err) 03668 ) 03669 goto tolua_lerror; 03670 else 03671 #endif 03672 { 03673 const fawkes::KatanaInterface* self = (const fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 03674 Interface* comp = ((Interface*) tolua_tousertype(tolua_S,2,0)); 03675 #ifndef TOLUA_RELEASE 03676 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='", NULL); 03677 #endif 03678 { 03679 bool tolua_ret = (bool) self->operator==(*comp); 03680 tolua_pushboolean(tolua_S,(bool)tolua_ret); 03681 } 03682 } 03683 return 1; 03684 #ifndef TOLUA_RELEASE 03685 tolua_lerror: 03686 tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err); 03687 return 0; 03688 #endif 03689 } 03690 #endif //#ifndef TOLUA_DISABLE 03691 03692 /* method: hash of class fawkes::KatanaInterface */ 03693 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_hash00 03694 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_hash00(lua_State* tolua_S) 03695 { 03696 #ifndef TOLUA_RELEASE 03697 tolua_Error tolua_err; 03698 if ( 03699 !tolua_isusertype(tolua_S,1,"const fawkes::KatanaInterface",0,&tolua_err) || 03700 !tolua_isnoobj(tolua_S,2,&tolua_err) 03701 ) 03702 goto tolua_lerror; 03703 else 03704 #endif 03705 { 03706 const fawkes::KatanaInterface* self = (const fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 03707 #ifndef TOLUA_RELEASE 03708 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash'", NULL); 03709 #endif 03710 { 03711 unsigned const char* tolua_ret = ( unsigned const char*) self->hash(); 03712 tolua_pushstring(tolua_S,(const char*)tolua_ret); 03713 } 03714 } 03715 return 1; 03716 #ifndef TOLUA_RELEASE 03717 tolua_lerror: 03718 tolua_error(tolua_S,"#ferror in function 'hash'.",&tolua_err); 03719 return 0; 03720 #endif 03721 } 03722 #endif //#ifndef TOLUA_DISABLE 03723 03724 /* method: hash_size of class fawkes::KatanaInterface */ 03725 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_hash_size00 03726 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_hash_size00(lua_State* tolua_S) 03727 { 03728 #ifndef TOLUA_RELEASE 03729 tolua_Error tolua_err; 03730 if ( 03731 !tolua_isusertype(tolua_S,1,"const fawkes::KatanaInterface",0,&tolua_err) || 03732 !tolua_isnoobj(tolua_S,2,&tolua_err) 03733 ) 03734 goto tolua_lerror; 03735 else 03736 #endif 03737 { 03738 const fawkes::KatanaInterface* self = (const fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 03739 #ifndef TOLUA_RELEASE 03740 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash_size'", NULL); 03741 #endif 03742 { 03743 int tolua_ret = (int) self->hash_size(); 03744 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 03745 } 03746 } 03747 return 1; 03748 #ifndef TOLUA_RELEASE 03749 tolua_lerror: 03750 tolua_error(tolua_S,"#ferror in function 'hash_size'.",&tolua_err); 03751 return 0; 03752 #endif 03753 } 03754 #endif //#ifndef TOLUA_DISABLE 03755 03756 /* method: hash_printable of class fawkes::KatanaInterface */ 03757 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_hash_printable00 03758 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_hash_printable00(lua_State* tolua_S) 03759 { 03760 #ifndef TOLUA_RELEASE 03761 tolua_Error tolua_err; 03762 if ( 03763 !tolua_isusertype(tolua_S,1,"const fawkes::KatanaInterface",0,&tolua_err) || 03764 !tolua_isnoobj(tolua_S,2,&tolua_err) 03765 ) 03766 goto tolua_lerror; 03767 else 03768 #endif 03769 { 03770 const fawkes::KatanaInterface* self = (const fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 03771 #ifndef TOLUA_RELEASE 03772 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash_printable'", NULL); 03773 #endif 03774 { 03775 const char* tolua_ret = (const char*) self->hash_printable(); 03776 tolua_pushstring(tolua_S,(const char*)tolua_ret); 03777 } 03778 } 03779 return 1; 03780 #ifndef TOLUA_RELEASE 03781 tolua_lerror: 03782 tolua_error(tolua_S,"#ferror in function 'hash_printable'.",&tolua_err); 03783 return 0; 03784 #endif 03785 } 03786 #endif //#ifndef TOLUA_DISABLE 03787 03788 /* method: is_writer of class fawkes::KatanaInterface */ 03789 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_is_writer00 03790 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_is_writer00(lua_State* tolua_S) 03791 { 03792 #ifndef TOLUA_RELEASE 03793 tolua_Error tolua_err; 03794 if ( 03795 !tolua_isusertype(tolua_S,1,"const fawkes::KatanaInterface",0,&tolua_err) || 03796 !tolua_isnoobj(tolua_S,2,&tolua_err) 03797 ) 03798 goto tolua_lerror; 03799 else 03800 #endif 03801 { 03802 const fawkes::KatanaInterface* self = (const fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 03803 #ifndef TOLUA_RELEASE 03804 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_writer'", NULL); 03805 #endif 03806 { 03807 bool tolua_ret = (bool) self->is_writer(); 03808 tolua_pushboolean(tolua_S,(bool)tolua_ret); 03809 } 03810 } 03811 return 1; 03812 #ifndef TOLUA_RELEASE 03813 tolua_lerror: 03814 tolua_error(tolua_S,"#ferror in function 'is_writer'.",&tolua_err); 03815 return 0; 03816 #endif 03817 } 03818 #endif //#ifndef TOLUA_DISABLE 03819 03820 /* method: set_from_chunk of class fawkes::KatanaInterface */ 03821 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_set_from_chunk00 03822 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_set_from_chunk00(lua_State* tolua_S) 03823 { 03824 #ifndef TOLUA_RELEASE 03825 tolua_Error tolua_err; 03826 if ( 03827 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface",0,&tolua_err) || 03828 !tolua_isuserdata(tolua_S,2,0,&tolua_err) || 03829 !tolua_isnoobj(tolua_S,3,&tolua_err) 03830 ) 03831 goto tolua_lerror; 03832 else 03833 #endif 03834 { 03835 fawkes::KatanaInterface* self = (fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 03836 void* chunk = ((void*) tolua_touserdata(tolua_S,2,0)); 03837 #ifndef TOLUA_RELEASE 03838 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_from_chunk'", NULL); 03839 #endif 03840 { 03841 self->set_from_chunk(chunk); 03842 } 03843 } 03844 return 0; 03845 #ifndef TOLUA_RELEASE 03846 tolua_lerror: 03847 tolua_error(tolua_S,"#ferror in function 'set_from_chunk'.",&tolua_err); 03848 return 0; 03849 #endif 03850 } 03851 #endif //#ifndef TOLUA_DISABLE 03852 03853 /* method: create_message of class fawkes::KatanaInterface */ 03854 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_create_message00 03855 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_create_message00(lua_State* tolua_S) 03856 { 03857 #ifndef TOLUA_RELEASE 03858 tolua_Error tolua_err; 03859 if ( 03860 !tolua_isusertype(tolua_S,1,"const fawkes::KatanaInterface",0,&tolua_err) || 03861 !tolua_isstring(tolua_S,2,0,&tolua_err) || 03862 !tolua_isnoobj(tolua_S,3,&tolua_err) 03863 ) 03864 goto tolua_lerror; 03865 else 03866 #endif 03867 { 03868 const fawkes::KatanaInterface* self = (const fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 03869 const char* type = ((const char*) tolua_tostring(tolua_S,2,0)); 03870 #ifndef TOLUA_RELEASE 03871 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'create_message'", NULL); 03872 #endif 03873 { 03874 Message* tolua_ret = (Message*) self->create_message(type); 03875 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Message"); 03876 } 03877 } 03878 return 1; 03879 #ifndef TOLUA_RELEASE 03880 tolua_lerror: 03881 tolua_error(tolua_S,"#ferror in function 'create_message'.",&tolua_err); 03882 return 0; 03883 #endif 03884 } 03885 #endif //#ifndef TOLUA_DISABLE 03886 03887 /* method: read of class fawkes::KatanaInterface */ 03888 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_read00 03889 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_read00(lua_State* tolua_S) 03890 { 03891 #ifndef TOLUA_RELEASE 03892 tolua_Error tolua_err; 03893 if ( 03894 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface",0,&tolua_err) || 03895 !tolua_isnoobj(tolua_S,2,&tolua_err) 03896 ) 03897 goto tolua_lerror; 03898 else 03899 #endif 03900 { 03901 fawkes::KatanaInterface* self = (fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 03902 #ifndef TOLUA_RELEASE 03903 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'read'", NULL); 03904 #endif 03905 { 03906 self->read(); 03907 } 03908 } 03909 return 0; 03910 #ifndef TOLUA_RELEASE 03911 tolua_lerror: 03912 tolua_error(tolua_S,"#ferror in function 'read'.",&tolua_err); 03913 return 0; 03914 #endif 03915 } 03916 #endif //#ifndef TOLUA_DISABLE 03917 03918 /* method: write of class fawkes::KatanaInterface */ 03919 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_write00 03920 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_write00(lua_State* tolua_S) 03921 { 03922 #ifndef TOLUA_RELEASE 03923 tolua_Error tolua_err; 03924 if ( 03925 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface",0,&tolua_err) || 03926 !tolua_isnoobj(tolua_S,2,&tolua_err) 03927 ) 03928 goto tolua_lerror; 03929 else 03930 #endif 03931 { 03932 fawkes::KatanaInterface* self = (fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 03933 #ifndef TOLUA_RELEASE 03934 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'write'", NULL); 03935 #endif 03936 { 03937 self->write(); 03938 } 03939 } 03940 return 0; 03941 #ifndef TOLUA_RELEASE 03942 tolua_lerror: 03943 tolua_error(tolua_S,"#ferror in function 'write'.",&tolua_err); 03944 return 0; 03945 #endif 03946 } 03947 #endif //#ifndef TOLUA_DISABLE 03948 03949 /* method: has_writer of class fawkes::KatanaInterface */ 03950 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_has_writer00 03951 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_has_writer00(lua_State* tolua_S) 03952 { 03953 #ifndef TOLUA_RELEASE 03954 tolua_Error tolua_err; 03955 if ( 03956 !tolua_isusertype(tolua_S,1,"const fawkes::KatanaInterface",0,&tolua_err) || 03957 !tolua_isnoobj(tolua_S,2,&tolua_err) 03958 ) 03959 goto tolua_lerror; 03960 else 03961 #endif 03962 { 03963 const fawkes::KatanaInterface* self = (const fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 03964 #ifndef TOLUA_RELEASE 03965 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'has_writer'", NULL); 03966 #endif 03967 { 03968 bool tolua_ret = (bool) self->has_writer(); 03969 tolua_pushboolean(tolua_S,(bool)tolua_ret); 03970 } 03971 } 03972 return 1; 03973 #ifndef TOLUA_RELEASE 03974 tolua_lerror: 03975 tolua_error(tolua_S,"#ferror in function 'has_writer'.",&tolua_err); 03976 return 0; 03977 #endif 03978 } 03979 #endif //#ifndef TOLUA_DISABLE 03980 03981 /* method: num_readers of class fawkes::KatanaInterface */ 03982 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_num_readers00 03983 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_num_readers00(lua_State* tolua_S) 03984 { 03985 #ifndef TOLUA_RELEASE 03986 tolua_Error tolua_err; 03987 if ( 03988 !tolua_isusertype(tolua_S,1,"const fawkes::KatanaInterface",0,&tolua_err) || 03989 !tolua_isnoobj(tolua_S,2,&tolua_err) 03990 ) 03991 goto tolua_lerror; 03992 else 03993 #endif 03994 { 03995 const fawkes::KatanaInterface* self = (const fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 03996 #ifndef TOLUA_RELEASE 03997 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'num_readers'", NULL); 03998 #endif 03999 { 04000 unsigned int tolua_ret = (unsigned int) self->num_readers(); 04001 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 04002 } 04003 } 04004 return 1; 04005 #ifndef TOLUA_RELEASE 04006 tolua_lerror: 04007 tolua_error(tolua_S,"#ferror in function 'num_readers'.",&tolua_err); 04008 return 0; 04009 #endif 04010 } 04011 #endif //#ifndef TOLUA_DISABLE 04012 04013 /* method: msgq_enqueue_copy of class fawkes::KatanaInterface */ 04014 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_msgq_enqueue_copy00 04015 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_msgq_enqueue_copy00(lua_State* tolua_S) 04016 { 04017 #ifndef TOLUA_RELEASE 04018 tolua_Error tolua_err; 04019 if ( 04020 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface",0,&tolua_err) || 04021 !tolua_isusertype(tolua_S,2,"Message",0,&tolua_err) || 04022 !tolua_isnoobj(tolua_S,3,&tolua_err) 04023 ) 04024 goto tolua_lerror; 04025 else 04026 #endif 04027 { 04028 fawkes::KatanaInterface* self = (fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 04029 Message* message = ((Message*) tolua_tousertype(tolua_S,2,0)); 04030 #ifndef TOLUA_RELEASE 04031 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_enqueue_copy'", NULL); 04032 #endif 04033 { 04034 unsigned int tolua_ret = (unsigned int) self->msgq_enqueue_copy(message); 04035 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 04036 } 04037 } 04038 return 1; 04039 #ifndef TOLUA_RELEASE 04040 tolua_lerror: 04041 tolua_error(tolua_S,"#ferror in function 'msgq_enqueue_copy'.",&tolua_err); 04042 return 0; 04043 #endif 04044 } 04045 #endif //#ifndef TOLUA_DISABLE 04046 04047 /* method: msgq_remove of class fawkes::KatanaInterface */ 04048 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_msgq_remove00 04049 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_msgq_remove00(lua_State* tolua_S) 04050 { 04051 #ifndef TOLUA_RELEASE 04052 tolua_Error tolua_err; 04053 if ( 04054 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface",0,&tolua_err) || 04055 !tolua_isusertype(tolua_S,2,"Message",0,&tolua_err) || 04056 !tolua_isnoobj(tolua_S,3,&tolua_err) 04057 ) 04058 goto tolua_lerror; 04059 else 04060 #endif 04061 { 04062 fawkes::KatanaInterface* self = (fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 04063 Message* message = ((Message*) tolua_tousertype(tolua_S,2,0)); 04064 #ifndef TOLUA_RELEASE 04065 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_remove'", NULL); 04066 #endif 04067 { 04068 self->msgq_remove(message); 04069 } 04070 } 04071 return 0; 04072 #ifndef TOLUA_RELEASE 04073 tolua_lerror: 04074 tolua_error(tolua_S,"#ferror in function 'msgq_remove'.",&tolua_err); 04075 return 0; 04076 #endif 04077 } 04078 #endif //#ifndef TOLUA_DISABLE 04079 04080 /* method: msgq_remove of class fawkes::KatanaInterface */ 04081 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_msgq_remove01 04082 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_msgq_remove01(lua_State* tolua_S) 04083 { 04084 tolua_Error tolua_err; 04085 if ( 04086 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface",0,&tolua_err) || 04087 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 04088 !tolua_isnoobj(tolua_S,3,&tolua_err) 04089 ) 04090 goto tolua_lerror; 04091 else 04092 { 04093 fawkes::KatanaInterface* self = (fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 04094 unsigned int message_id = ((unsigned int) tolua_tonumber(tolua_S,2,0)); 04095 #ifndef TOLUA_RELEASE 04096 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_remove'", NULL); 04097 #endif 04098 { 04099 self->msgq_remove(message_id); 04100 } 04101 } 04102 return 0; 04103 tolua_lerror: 04104 return tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_msgq_remove00(tolua_S); 04105 } 04106 #endif //#ifndef TOLUA_DISABLE 04107 04108 /* method: msgq_size of class fawkes::KatanaInterface */ 04109 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_msgq_size00 04110 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_msgq_size00(lua_State* tolua_S) 04111 { 04112 #ifndef TOLUA_RELEASE 04113 tolua_Error tolua_err; 04114 if ( 04115 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface",0,&tolua_err) || 04116 !tolua_isnoobj(tolua_S,2,&tolua_err) 04117 ) 04118 goto tolua_lerror; 04119 else 04120 #endif 04121 { 04122 fawkes::KatanaInterface* self = (fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 04123 #ifndef TOLUA_RELEASE 04124 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_size'", NULL); 04125 #endif 04126 { 04127 unsigned int tolua_ret = (unsigned int) self->msgq_size(); 04128 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 04129 } 04130 } 04131 return 1; 04132 #ifndef TOLUA_RELEASE 04133 tolua_lerror: 04134 tolua_error(tolua_S,"#ferror in function 'msgq_size'.",&tolua_err); 04135 return 0; 04136 #endif 04137 } 04138 #endif //#ifndef TOLUA_DISABLE 04139 04140 /* method: msgq_flush of class fawkes::KatanaInterface */ 04141 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_msgq_flush00 04142 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_msgq_flush00(lua_State* tolua_S) 04143 { 04144 #ifndef TOLUA_RELEASE 04145 tolua_Error tolua_err; 04146 if ( 04147 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface",0,&tolua_err) || 04148 !tolua_isnoobj(tolua_S,2,&tolua_err) 04149 ) 04150 goto tolua_lerror; 04151 else 04152 #endif 04153 { 04154 fawkes::KatanaInterface* self = (fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 04155 #ifndef TOLUA_RELEASE 04156 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_flush'", NULL); 04157 #endif 04158 { 04159 self->msgq_flush(); 04160 } 04161 } 04162 return 0; 04163 #ifndef TOLUA_RELEASE 04164 tolua_lerror: 04165 tolua_error(tolua_S,"#ferror in function 'msgq_flush'.",&tolua_err); 04166 return 0; 04167 #endif 04168 } 04169 #endif //#ifndef TOLUA_DISABLE 04170 04171 /* method: msgq_lock of class fawkes::KatanaInterface */ 04172 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_msgq_lock00 04173 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_msgq_lock00(lua_State* tolua_S) 04174 { 04175 #ifndef TOLUA_RELEASE 04176 tolua_Error tolua_err; 04177 if ( 04178 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface",0,&tolua_err) || 04179 !tolua_isnoobj(tolua_S,2,&tolua_err) 04180 ) 04181 goto tolua_lerror; 04182 else 04183 #endif 04184 { 04185 fawkes::KatanaInterface* self = (fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 04186 #ifndef TOLUA_RELEASE 04187 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_lock'", NULL); 04188 #endif 04189 { 04190 self->msgq_lock(); 04191 } 04192 } 04193 return 0; 04194 #ifndef TOLUA_RELEASE 04195 tolua_lerror: 04196 tolua_error(tolua_S,"#ferror in function 'msgq_lock'.",&tolua_err); 04197 return 0; 04198 #endif 04199 } 04200 #endif //#ifndef TOLUA_DISABLE 04201 04202 /* method: msgq_try_lock of class fawkes::KatanaInterface */ 04203 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_msgq_try_lock00 04204 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_msgq_try_lock00(lua_State* tolua_S) 04205 { 04206 #ifndef TOLUA_RELEASE 04207 tolua_Error tolua_err; 04208 if ( 04209 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface",0,&tolua_err) || 04210 !tolua_isnoobj(tolua_S,2,&tolua_err) 04211 ) 04212 goto tolua_lerror; 04213 else 04214 #endif 04215 { 04216 fawkes::KatanaInterface* self = (fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 04217 #ifndef TOLUA_RELEASE 04218 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_try_lock'", NULL); 04219 #endif 04220 { 04221 bool tolua_ret = (bool) self->msgq_try_lock(); 04222 tolua_pushboolean(tolua_S,(bool)tolua_ret); 04223 } 04224 } 04225 return 1; 04226 #ifndef TOLUA_RELEASE 04227 tolua_lerror: 04228 tolua_error(tolua_S,"#ferror in function 'msgq_try_lock'.",&tolua_err); 04229 return 0; 04230 #endif 04231 } 04232 #endif //#ifndef TOLUA_DISABLE 04233 04234 /* method: msgq_unlock of class fawkes::KatanaInterface */ 04235 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_msgq_unlock00 04236 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_msgq_unlock00(lua_State* tolua_S) 04237 { 04238 #ifndef TOLUA_RELEASE 04239 tolua_Error tolua_err; 04240 if ( 04241 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface",0,&tolua_err) || 04242 !tolua_isnoobj(tolua_S,2,&tolua_err) 04243 ) 04244 goto tolua_lerror; 04245 else 04246 #endif 04247 { 04248 fawkes::KatanaInterface* self = (fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 04249 #ifndef TOLUA_RELEASE 04250 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_unlock'", NULL); 04251 #endif 04252 { 04253 self->msgq_unlock(); 04254 } 04255 } 04256 return 0; 04257 #ifndef TOLUA_RELEASE 04258 tolua_lerror: 04259 tolua_error(tolua_S,"#ferror in function 'msgq_unlock'.",&tolua_err); 04260 return 0; 04261 #endif 04262 } 04263 #endif //#ifndef TOLUA_DISABLE 04264 04265 /* method: msgq_pop of class fawkes::KatanaInterface */ 04266 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_msgq_pop00 04267 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_msgq_pop00(lua_State* tolua_S) 04268 { 04269 #ifndef TOLUA_RELEASE 04270 tolua_Error tolua_err; 04271 if ( 04272 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface",0,&tolua_err) || 04273 !tolua_isnoobj(tolua_S,2,&tolua_err) 04274 ) 04275 goto tolua_lerror; 04276 else 04277 #endif 04278 { 04279 fawkes::KatanaInterface* self = (fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 04280 #ifndef TOLUA_RELEASE 04281 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_pop'", NULL); 04282 #endif 04283 { 04284 self->msgq_pop(); 04285 } 04286 } 04287 return 0; 04288 #ifndef TOLUA_RELEASE 04289 tolua_lerror: 04290 tolua_error(tolua_S,"#ferror in function 'msgq_pop'.",&tolua_err); 04291 return 0; 04292 #endif 04293 } 04294 #endif //#ifndef TOLUA_DISABLE 04295 04296 /* method: msgq_first of class fawkes::KatanaInterface */ 04297 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_msgq_first00 04298 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_msgq_first00(lua_State* tolua_S) 04299 { 04300 #ifndef TOLUA_RELEASE 04301 tolua_Error tolua_err; 04302 if ( 04303 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface",0,&tolua_err) || 04304 !tolua_isnoobj(tolua_S,2,&tolua_err) 04305 ) 04306 goto tolua_lerror; 04307 else 04308 #endif 04309 { 04310 fawkes::KatanaInterface* self = (fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 04311 #ifndef TOLUA_RELEASE 04312 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_first'", NULL); 04313 #endif 04314 { 04315 Message* tolua_ret = (Message*) self->msgq_first(); 04316 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Message"); 04317 } 04318 } 04319 return 1; 04320 #ifndef TOLUA_RELEASE 04321 tolua_lerror: 04322 tolua_error(tolua_S,"#ferror in function 'msgq_first'.",&tolua_err); 04323 return 0; 04324 #endif 04325 } 04326 #endif //#ifndef TOLUA_DISABLE 04327 04328 /* method: msgq_empty of class fawkes::KatanaInterface */ 04329 #ifndef TOLUA_DISABLE_tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_msgq_empty00 04330 static int tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_msgq_empty00(lua_State* tolua_S) 04331 { 04332 #ifndef TOLUA_RELEASE 04333 tolua_Error tolua_err; 04334 if ( 04335 !tolua_isusertype(tolua_S,1,"fawkes::KatanaInterface",0,&tolua_err) || 04336 !tolua_isnoobj(tolua_S,2,&tolua_err) 04337 ) 04338 goto tolua_lerror; 04339 else 04340 #endif 04341 { 04342 fawkes::KatanaInterface* self = (fawkes::KatanaInterface*) tolua_tousertype(tolua_S,1,0); 04343 #ifndef TOLUA_RELEASE 04344 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_empty'", NULL); 04345 #endif 04346 { 04347 bool tolua_ret = (bool) self->msgq_empty(); 04348 tolua_pushboolean(tolua_S,(bool)tolua_ret); 04349 } 04350 } 04351 return 1; 04352 #ifndef TOLUA_RELEASE 04353 tolua_lerror: 04354 tolua_error(tolua_S,"#ferror in function 'msgq_empty'.",&tolua_err); 04355 return 0; 04356 #endif 04357 } 04358 #endif //#ifndef TOLUA_DISABLE 04359 04360 /* Open function */ 04361 TOLUA_API int tolua_interfaces_KatanaInterface_open (lua_State* tolua_S) 04362 { 04363 tolua_open(tolua_S); 04364 tolua_reg_types(tolua_S); 04365 tolua_module(tolua_S,NULL,0); 04366 tolua_beginmodule(tolua_S,NULL); 04367 tolua_module(tolua_S,"fawkes",0); 04368 tolua_beginmodule(tolua_S,"fawkes"); 04369 tolua_cclass(tolua_S,"KatanaInterface","fawkes::KatanaInterface","Interface",NULL); 04370 tolua_beginmodule(tolua_S,"KatanaInterface"); 04371 tolua_variable(tolua_S,"SENSOR_IR_RIGHT_INNER_MIDDLE",tolua_get_fawkes__KatanaInterface_unsigned_SENSOR_IR_RIGHT_INNER_MIDDLE,NULL); 04372 tolua_variable(tolua_S,"SENSOR_IR_RIGHT_INNER_FRONT",tolua_get_fawkes__KatanaInterface_unsigned_SENSOR_IR_RIGHT_INNER_FRONT,NULL); 04373 tolua_variable(tolua_S,"SENSOR_RESERVED_2",tolua_get_fawkes__KatanaInterface_unsigned_SENSOR_RESERVED_2,NULL); 04374 tolua_variable(tolua_S,"SENSOR_COND_BOTH",tolua_get_fawkes__KatanaInterface_unsigned_SENSOR_COND_BOTH,NULL); 04375 tolua_variable(tolua_S,"SENSOR_IR_RIGHT_OUTER_FRONT",tolua_get_fawkes__KatanaInterface_unsigned_SENSOR_IR_RIGHT_OUTER_FRONT,NULL); 04376 tolua_variable(tolua_S,"SENSOR_IR_RIGHT_BOTTOM_FRONT",tolua_get_fawkes__KatanaInterface_unsigned_SENSOR_IR_RIGHT_BOTTOM_FRONT,NULL); 04377 tolua_variable(tolua_S,"SENSOR_FORCE_RIGHT_REAR",tolua_get_fawkes__KatanaInterface_unsigned_SENSOR_FORCE_RIGHT_REAR,NULL); 04378 tolua_variable(tolua_S,"SENSOR_FORCE_RIGHT_FRONT",tolua_get_fawkes__KatanaInterface_unsigned_SENSOR_FORCE_RIGHT_FRONT,NULL); 04379 tolua_variable(tolua_S,"SENSOR_IR_LEFT_INNER_MIDDLE",tolua_get_fawkes__KatanaInterface_unsigned_SENSOR_IR_LEFT_INNER_MIDDLE,NULL); 04380 tolua_variable(tolua_S,"SENSOR_IR_LEFT_INNER_FRONT",tolua_get_fawkes__KatanaInterface_unsigned_SENSOR_IR_LEFT_INNER_FRONT,NULL); 04381 tolua_variable(tolua_S,"SENSOR_RESERVED_10",tolua_get_fawkes__KatanaInterface_unsigned_SENSOR_RESERVED_10,NULL); 04382 tolua_variable(tolua_S,"SENSOR_IR_CENTER_GRIPPER",tolua_get_fawkes__KatanaInterface_unsigned_SENSOR_IR_CENTER_GRIPPER,NULL); 04383 tolua_variable(tolua_S,"SENSOR_IR_LEFT_OUTER_FRONT",tolua_get_fawkes__KatanaInterface_unsigned_SENSOR_IR_LEFT_OUTER_FRONT,NULL); 04384 tolua_variable(tolua_S,"SENSOR_IR_LEFT_BOTTOM_FRONT",tolua_get_fawkes__KatanaInterface_unsigned_SENSOR_IR_LEFT_BOTTOM_FRONT,NULL); 04385 tolua_variable(tolua_S,"SENSOR_FORCE_LEFT_REAR",tolua_get_fawkes__KatanaInterface_unsigned_SENSOR_FORCE_LEFT_REAR,NULL); 04386 tolua_variable(tolua_S,"SENSOR_FORCE_LEFT_FRONT",tolua_get_fawkes__KatanaInterface_unsigned_SENSOR_FORCE_LEFT_FRONT,NULL); 04387 tolua_variable(tolua_S,"ERROR_NONE",tolua_get_fawkes__KatanaInterface_unsigned_ERROR_NONE,NULL); 04388 tolua_variable(tolua_S,"ERROR_UNSPECIFIC",tolua_get_fawkes__KatanaInterface_unsigned_ERROR_UNSPECIFIC,NULL); 04389 tolua_variable(tolua_S,"ERROR_CMD_START_FAILED",tolua_get_fawkes__KatanaInterface_unsigned_ERROR_CMD_START_FAILED,NULL); 04390 tolua_variable(tolua_S,"ERROR_NO_SOLUTION",tolua_get_fawkes__KatanaInterface_unsigned_ERROR_NO_SOLUTION,NULL); 04391 tolua_variable(tolua_S,"ERROR_COMMUNICATION",tolua_get_fawkes__KatanaInterface_unsigned_ERROR_COMMUNICATION,NULL); 04392 tolua_variable(tolua_S,"ERROR_MOTOR_CRASHED",tolua_get_fawkes__KatanaInterface_unsigned_ERROR_MOTOR_CRASHED,NULL); 04393 #ifdef __cplusplus 04394 tolua_cclass(tolua_S,"StopMessage","fawkes::KatanaInterface::StopMessage","Message",tolua_collect_fawkes__KatanaInterface__StopMessage); 04395 #else 04396 tolua_cclass(tolua_S,"StopMessage","fawkes::KatanaInterface::StopMessage","Message",NULL); 04397 #endif 04398 tolua_beginmodule(tolua_S,"StopMessage"); 04399 tolua_function(tolua_S,"new",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_StopMessage_new00); 04400 tolua_function(tolua_S,"new_local",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_StopMessage_new00_local); 04401 tolua_function(tolua_S,".call",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_StopMessage_new00_local); 04402 tolua_function(tolua_S,"delete",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_StopMessage_delete00); 04403 tolua_endmodule(tolua_S); 04404 #ifdef __cplusplus 04405 tolua_cclass(tolua_S,"FlushMessage","fawkes::KatanaInterface::FlushMessage","Message",tolua_collect_fawkes__KatanaInterface__FlushMessage); 04406 #else 04407 tolua_cclass(tolua_S,"FlushMessage","fawkes::KatanaInterface::FlushMessage","Message",NULL); 04408 #endif 04409 tolua_beginmodule(tolua_S,"FlushMessage"); 04410 tolua_function(tolua_S,"new",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_FlushMessage_new00); 04411 tolua_function(tolua_S,"new_local",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_FlushMessage_new00_local); 04412 tolua_function(tolua_S,".call",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_FlushMessage_new00_local); 04413 tolua_function(tolua_S,"delete",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_FlushMessage_delete00); 04414 tolua_endmodule(tolua_S); 04415 #ifdef __cplusplus 04416 tolua_cclass(tolua_S,"ParkMessage","fawkes::KatanaInterface::ParkMessage","Message",tolua_collect_fawkes__KatanaInterface__ParkMessage); 04417 #else 04418 tolua_cclass(tolua_S,"ParkMessage","fawkes::KatanaInterface::ParkMessage","Message",NULL); 04419 #endif 04420 tolua_beginmodule(tolua_S,"ParkMessage"); 04421 tolua_function(tolua_S,"new",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_ParkMessage_new00); 04422 tolua_function(tolua_S,"new_local",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_ParkMessage_new00_local); 04423 tolua_function(tolua_S,".call",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_ParkMessage_new00_local); 04424 tolua_function(tolua_S,"delete",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_ParkMessage_delete00); 04425 tolua_endmodule(tolua_S); 04426 #ifdef __cplusplus 04427 tolua_cclass(tolua_S,"LinearGotoMessage","fawkes::KatanaInterface::LinearGotoMessage","Message",tolua_collect_fawkes__KatanaInterface__LinearGotoMessage); 04428 #else 04429 tolua_cclass(tolua_S,"LinearGotoMessage","fawkes::KatanaInterface::LinearGotoMessage","Message",NULL); 04430 #endif 04431 tolua_beginmodule(tolua_S,"LinearGotoMessage"); 04432 tolua_function(tolua_S,"new",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_new00); 04433 tolua_function(tolua_S,"new_local",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_new00_local); 04434 tolua_function(tolua_S,".call",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_new00_local); 04435 tolua_function(tolua_S,"new",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_new01); 04436 tolua_function(tolua_S,"new_local",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_new01_local); 04437 tolua_function(tolua_S,".call",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_new01_local); 04438 tolua_function(tolua_S,"delete",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_delete00); 04439 tolua_function(tolua_S,"x",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_x00); 04440 tolua_function(tolua_S,"set_x",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_set_x00); 04441 tolua_function(tolua_S,"maxlenof_x",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_maxlenof_x00); 04442 tolua_function(tolua_S,"y",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_y00); 04443 tolua_function(tolua_S,"set_y",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_set_y00); 04444 tolua_function(tolua_S,"maxlenof_y",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_maxlenof_y00); 04445 tolua_function(tolua_S,"z",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_z00); 04446 tolua_function(tolua_S,"set_z",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_set_z00); 04447 tolua_function(tolua_S,"maxlenof_z",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_maxlenof_z00); 04448 tolua_function(tolua_S,"phi",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_phi00); 04449 tolua_function(tolua_S,"set_phi",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_set_phi00); 04450 tolua_function(tolua_S,"maxlenof_phi",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_maxlenof_phi00); 04451 tolua_function(tolua_S,"theta",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_theta00); 04452 tolua_function(tolua_S,"set_theta",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_set_theta00); 04453 tolua_function(tolua_S,"maxlenof_theta",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_maxlenof_theta00); 04454 tolua_function(tolua_S,"psi",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_psi00); 04455 tolua_function(tolua_S,"set_psi",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_set_psi00); 04456 tolua_function(tolua_S,"maxlenof_psi",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_LinearGotoMessage_maxlenof_psi00); 04457 tolua_endmodule(tolua_S); 04458 #ifdef __cplusplus 04459 tolua_cclass(tolua_S,"CalibrateMessage","fawkes::KatanaInterface::CalibrateMessage","Message",tolua_collect_fawkes__KatanaInterface__CalibrateMessage); 04460 #else 04461 tolua_cclass(tolua_S,"CalibrateMessage","fawkes::KatanaInterface::CalibrateMessage","Message",NULL); 04462 #endif 04463 tolua_beginmodule(tolua_S,"CalibrateMessage"); 04464 tolua_function(tolua_S,"new",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_CalibrateMessage_new00); 04465 tolua_function(tolua_S,"new_local",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_CalibrateMessage_new00_local); 04466 tolua_function(tolua_S,".call",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_CalibrateMessage_new00_local); 04467 tolua_function(tolua_S,"delete",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_CalibrateMessage_delete00); 04468 tolua_endmodule(tolua_S); 04469 #ifdef __cplusplus 04470 tolua_cclass(tolua_S,"OpenGripperMessage","fawkes::KatanaInterface::OpenGripperMessage","Message",tolua_collect_fawkes__KatanaInterface__OpenGripperMessage); 04471 #else 04472 tolua_cclass(tolua_S,"OpenGripperMessage","fawkes::KatanaInterface::OpenGripperMessage","Message",NULL); 04473 #endif 04474 tolua_beginmodule(tolua_S,"OpenGripperMessage"); 04475 tolua_function(tolua_S,"new",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_OpenGripperMessage_new00); 04476 tolua_function(tolua_S,"new_local",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_OpenGripperMessage_new00_local); 04477 tolua_function(tolua_S,".call",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_OpenGripperMessage_new00_local); 04478 tolua_function(tolua_S,"delete",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_OpenGripperMessage_delete00); 04479 tolua_endmodule(tolua_S); 04480 #ifdef __cplusplus 04481 tolua_cclass(tolua_S,"CloseGripperMessage","fawkes::KatanaInterface::CloseGripperMessage","Message",tolua_collect_fawkes__KatanaInterface__CloseGripperMessage); 04482 #else 04483 tolua_cclass(tolua_S,"CloseGripperMessage","fawkes::KatanaInterface::CloseGripperMessage","Message",NULL); 04484 #endif 04485 tolua_beginmodule(tolua_S,"CloseGripperMessage"); 04486 tolua_function(tolua_S,"new",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_CloseGripperMessage_new00); 04487 tolua_function(tolua_S,"new_local",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_CloseGripperMessage_new00_local); 04488 tolua_function(tolua_S,".call",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_CloseGripperMessage_new00_local); 04489 tolua_function(tolua_S,"delete",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_CloseGripperMessage_delete00); 04490 tolua_endmodule(tolua_S); 04491 #ifdef __cplusplus 04492 tolua_cclass(tolua_S,"SetEnabledMessage","fawkes::KatanaInterface::SetEnabledMessage","Message",tolua_collect_fawkes__KatanaInterface__SetEnabledMessage); 04493 #else 04494 tolua_cclass(tolua_S,"SetEnabledMessage","fawkes::KatanaInterface::SetEnabledMessage","Message",NULL); 04495 #endif 04496 tolua_beginmodule(tolua_S,"SetEnabledMessage"); 04497 tolua_function(tolua_S,"new",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_SetEnabledMessage_new00); 04498 tolua_function(tolua_S,"new_local",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_SetEnabledMessage_new00_local); 04499 tolua_function(tolua_S,".call",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_SetEnabledMessage_new00_local); 04500 tolua_function(tolua_S,"new",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_SetEnabledMessage_new01); 04501 tolua_function(tolua_S,"new_local",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_SetEnabledMessage_new01_local); 04502 tolua_function(tolua_S,".call",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_SetEnabledMessage_new01_local); 04503 tolua_function(tolua_S,"delete",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_SetEnabledMessage_delete00); 04504 tolua_function(tolua_S,"is_enabled",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_SetEnabledMessage_is_enabled00); 04505 tolua_function(tolua_S,"set_enabled",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_SetEnabledMessage_set_enabled00); 04506 tolua_function(tolua_S,"maxlenof_enabled",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_SetEnabledMessage_maxlenof_enabled00); 04507 tolua_endmodule(tolua_S); 04508 #ifdef __cplusplus 04509 tolua_cclass(tolua_S,"SetMaxVelocityMessage","fawkes::KatanaInterface::SetMaxVelocityMessage","Message",tolua_collect_fawkes__KatanaInterface__SetMaxVelocityMessage); 04510 #else 04511 tolua_cclass(tolua_S,"SetMaxVelocityMessage","fawkes::KatanaInterface::SetMaxVelocityMessage","Message",NULL); 04512 #endif 04513 tolua_beginmodule(tolua_S,"SetMaxVelocityMessage"); 04514 tolua_function(tolua_S,"new",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_SetMaxVelocityMessage_new00); 04515 tolua_function(tolua_S,"new_local",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_SetMaxVelocityMessage_new00_local); 04516 tolua_function(tolua_S,".call",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_SetMaxVelocityMessage_new00_local); 04517 tolua_function(tolua_S,"new",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_SetMaxVelocityMessage_new01); 04518 tolua_function(tolua_S,"new_local",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_SetMaxVelocityMessage_new01_local); 04519 tolua_function(tolua_S,".call",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_SetMaxVelocityMessage_new01_local); 04520 tolua_function(tolua_S,"delete",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_SetMaxVelocityMessage_delete00); 04521 tolua_function(tolua_S,"max_velocity",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_SetMaxVelocityMessage_max_velocity00); 04522 tolua_function(tolua_S,"set_max_velocity",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_SetMaxVelocityMessage_set_max_velocity00); 04523 tolua_function(tolua_S,"maxlenof_max_velocity",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_SetMaxVelocityMessage_maxlenof_max_velocity00); 04524 tolua_endmodule(tolua_S); 04525 tolua_function(tolua_S,"sensor_value",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_sensor_value00); 04526 tolua_function(tolua_S,"set_sensor_value",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_set_sensor_value00); 04527 tolua_function(tolua_S,"maxlenof_sensor_value",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_maxlenof_sensor_value00); 04528 tolua_function(tolua_S,"x",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_x00); 04529 tolua_function(tolua_S,"set_x",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_set_x00); 04530 tolua_function(tolua_S,"maxlenof_x",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_maxlenof_x00); 04531 tolua_function(tolua_S,"y",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_y00); 04532 tolua_function(tolua_S,"set_y",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_set_y00); 04533 tolua_function(tolua_S,"maxlenof_y",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_maxlenof_y00); 04534 tolua_function(tolua_S,"z",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_z00); 04535 tolua_function(tolua_S,"set_z",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_set_z00); 04536 tolua_function(tolua_S,"maxlenof_z",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_maxlenof_z00); 04537 tolua_function(tolua_S,"phi",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_phi00); 04538 tolua_function(tolua_S,"set_phi",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_set_phi00); 04539 tolua_function(tolua_S,"maxlenof_phi",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_maxlenof_phi00); 04540 tolua_function(tolua_S,"theta",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_theta00); 04541 tolua_function(tolua_S,"set_theta",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_set_theta00); 04542 tolua_function(tolua_S,"maxlenof_theta",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_maxlenof_theta00); 04543 tolua_function(tolua_S,"psi",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_psi00); 04544 tolua_function(tolua_S,"set_psi",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_set_psi00); 04545 tolua_function(tolua_S,"maxlenof_psi",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_maxlenof_psi00); 04546 tolua_function(tolua_S,"msgid",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_msgid00); 04547 tolua_function(tolua_S,"set_msgid",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_set_msgid00); 04548 tolua_function(tolua_S,"maxlenof_msgid",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_maxlenof_msgid00); 04549 tolua_function(tolua_S,"is_final",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_is_final00); 04550 tolua_function(tolua_S,"set_final",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_set_final00); 04551 tolua_function(tolua_S,"maxlenof_final",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_maxlenof_final00); 04552 tolua_function(tolua_S,"error_code",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_error_code00); 04553 tolua_function(tolua_S,"set_error_code",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_set_error_code00); 04554 tolua_function(tolua_S,"maxlenof_error_code",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_maxlenof_error_code00); 04555 tolua_function(tolua_S,"is_enabled",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_is_enabled00); 04556 tolua_function(tolua_S,"set_enabled",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_set_enabled00); 04557 tolua_function(tolua_S,"maxlenof_enabled",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_maxlenof_enabled00); 04558 tolua_function(tolua_S,"is_calibrated",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_is_calibrated00); 04559 tolua_function(tolua_S,"set_calibrated",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_set_calibrated00); 04560 tolua_function(tolua_S,"maxlenof_calibrated",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_maxlenof_calibrated00); 04561 tolua_function(tolua_S,"max_velocity",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_max_velocity00); 04562 tolua_function(tolua_S,"set_max_velocity",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_set_max_velocity00); 04563 tolua_function(tolua_S,"maxlenof_max_velocity",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_maxlenof_max_velocity00); 04564 tolua_function(tolua_S,"num_motors",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_num_motors00); 04565 tolua_function(tolua_S,"set_num_motors",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_set_num_motors00); 04566 tolua_function(tolua_S,"maxlenof_num_motors",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_maxlenof_num_motors00); 04567 tolua_function(tolua_S,"oftype",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_oftype00); 04568 tolua_function(tolua_S,"datachunk",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_datachunk00); 04569 tolua_function(tolua_S,"datasize",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_datasize00); 04570 tolua_function(tolua_S,"type",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_type00); 04571 tolua_function(tolua_S,"id",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_id00); 04572 tolua_function(tolua_S,"uid",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_uid00); 04573 tolua_function(tolua_S,"serial",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_serial00); 04574 tolua_function(tolua_S,"mem_serial",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_mem_serial00); 04575 tolua_function(tolua_S,".eq",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface__eq00); 04576 tolua_function(tolua_S,"hash",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_hash00); 04577 tolua_function(tolua_S,"hash_size",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_hash_size00); 04578 tolua_function(tolua_S,"hash_printable",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_hash_printable00); 04579 tolua_function(tolua_S,"is_writer",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_is_writer00); 04580 tolua_function(tolua_S,"set_from_chunk",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_set_from_chunk00); 04581 tolua_function(tolua_S,"create_message",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_create_message00); 04582 tolua_function(tolua_S,"read",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_read00); 04583 tolua_function(tolua_S,"write",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_write00); 04584 tolua_function(tolua_S,"has_writer",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_has_writer00); 04585 tolua_function(tolua_S,"num_readers",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_num_readers00); 04586 tolua_function(tolua_S,"msgq_enqueue_copy",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_msgq_enqueue_copy00); 04587 tolua_function(tolua_S,"msgq_remove",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_msgq_remove00); 04588 tolua_function(tolua_S,"msgq_remove",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_msgq_remove01); 04589 tolua_function(tolua_S,"msgq_size",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_msgq_size00); 04590 tolua_function(tolua_S,"msgq_flush",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_msgq_flush00); 04591 tolua_function(tolua_S,"msgq_lock",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_msgq_lock00); 04592 tolua_function(tolua_S,"msgq_try_lock",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_msgq_try_lock00); 04593 tolua_function(tolua_S,"msgq_unlock",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_msgq_unlock00); 04594 tolua_function(tolua_S,"msgq_pop",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_msgq_pop00); 04595 tolua_function(tolua_S,"msgq_first",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_msgq_first00); 04596 tolua_function(tolua_S,"msgq_empty",tolua_interfaces_KatanaInterface_fawkes_KatanaInterface_msgq_empty00); 04597 tolua_endmodule(tolua_S); 04598 tolua_endmodule(tolua_S); 04599 tolua_endmodule(tolua_S); 04600 return 1; 04601 } 04602 04603 04604 extern "C" { 04605 #if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501 04606 TOLUA_API int luaopen_interfaces_KatanaInterface (lua_State* tolua_S) { 04607 return tolua_interfaces_KatanaInterface_open(tolua_S); 04608 }; 04609 #endif 04610 } 04611 04612