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