Fawkes API
Fawkes Development Version
|
00001 /* 00002 ** Lua binding: interfaces_TransformInterface 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_TransformInterface_open (lua_State* tolua_S); 00028 00029 #include <interfaces/TransformInterface.h> 00030 using namespace fawkes; 00031 00032 /* function to register type */ 00033 static void tolua_reg_types (lua_State* tolua_S) 00034 { 00035 tolua_usertype(tolua_S,"Message"); 00036 tolua_usertype(tolua_S,"Interface"); 00037 tolua_usertype(tolua_S,"fawkes::TransformInterface"); 00038 } 00039 00040 /* method: frame of class fawkes::TransformInterface */ 00041 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_frame00 00042 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_frame00(lua_State* tolua_S) 00043 { 00044 #ifndef TOLUA_RELEASE 00045 tolua_Error tolua_err; 00046 if ( 00047 !tolua_isusertype(tolua_S,1,"fawkes::TransformInterface",0,&tolua_err) || 00048 !tolua_isnoobj(tolua_S,2,&tolua_err) 00049 ) 00050 goto tolua_lerror; 00051 else 00052 #endif 00053 { 00054 fawkes::TransformInterface* self = (fawkes::TransformInterface*) tolua_tousertype(tolua_S,1,0); 00055 #ifndef TOLUA_RELEASE 00056 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'frame'", NULL); 00057 #endif 00058 { 00059 char* tolua_ret = (char*) self->frame(); 00060 tolua_pushstring(tolua_S,(const char*)tolua_ret); 00061 } 00062 } 00063 return 1; 00064 #ifndef TOLUA_RELEASE 00065 tolua_lerror: 00066 tolua_error(tolua_S,"#ferror in function 'frame'.",&tolua_err); 00067 return 0; 00068 #endif 00069 } 00070 #endif //#ifndef TOLUA_DISABLE 00071 00072 /* method: set_frame of class fawkes::TransformInterface */ 00073 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_set_frame00 00074 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_set_frame00(lua_State* tolua_S) 00075 { 00076 #ifndef TOLUA_RELEASE 00077 tolua_Error tolua_err; 00078 if ( 00079 !tolua_isusertype(tolua_S,1,"fawkes::TransformInterface",0,&tolua_err) || 00080 !tolua_isstring(tolua_S,2,0,&tolua_err) || 00081 !tolua_isnoobj(tolua_S,3,&tolua_err) 00082 ) 00083 goto tolua_lerror; 00084 else 00085 #endif 00086 { 00087 fawkes::TransformInterface* self = (fawkes::TransformInterface*) tolua_tousertype(tolua_S,1,0); 00088 const char* new_frame = ((const char*) tolua_tostring(tolua_S,2,0)); 00089 #ifndef TOLUA_RELEASE 00090 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_frame'", NULL); 00091 #endif 00092 { 00093 self->set_frame(new_frame); 00094 } 00095 } 00096 return 0; 00097 #ifndef TOLUA_RELEASE 00098 tolua_lerror: 00099 tolua_error(tolua_S,"#ferror in function 'set_frame'.",&tolua_err); 00100 return 0; 00101 #endif 00102 } 00103 #endif //#ifndef TOLUA_DISABLE 00104 00105 /* method: maxlenof_frame of class fawkes::TransformInterface */ 00106 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_maxlenof_frame00 00107 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_maxlenof_frame00(lua_State* tolua_S) 00108 { 00109 #ifndef TOLUA_RELEASE 00110 tolua_Error tolua_err; 00111 if ( 00112 !tolua_isusertype(tolua_S,1,"const fawkes::TransformInterface",0,&tolua_err) || 00113 !tolua_isnoobj(tolua_S,2,&tolua_err) 00114 ) 00115 goto tolua_lerror; 00116 else 00117 #endif 00118 { 00119 const fawkes::TransformInterface* self = (const fawkes::TransformInterface*) tolua_tousertype(tolua_S,1,0); 00120 #ifndef TOLUA_RELEASE 00121 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_frame'", NULL); 00122 #endif 00123 { 00124 int tolua_ret = (int) self->maxlenof_frame(); 00125 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00126 } 00127 } 00128 return 1; 00129 #ifndef TOLUA_RELEASE 00130 tolua_lerror: 00131 tolua_error(tolua_S,"#ferror in function 'maxlenof_frame'.",&tolua_err); 00132 return 0; 00133 #endif 00134 } 00135 #endif //#ifndef TOLUA_DISABLE 00136 00137 /* method: child_frame of class fawkes::TransformInterface */ 00138 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_child_frame00 00139 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_child_frame00(lua_State* tolua_S) 00140 { 00141 #ifndef TOLUA_RELEASE 00142 tolua_Error tolua_err; 00143 if ( 00144 !tolua_isusertype(tolua_S,1,"fawkes::TransformInterface",0,&tolua_err) || 00145 !tolua_isnoobj(tolua_S,2,&tolua_err) 00146 ) 00147 goto tolua_lerror; 00148 else 00149 #endif 00150 { 00151 fawkes::TransformInterface* self = (fawkes::TransformInterface*) tolua_tousertype(tolua_S,1,0); 00152 #ifndef TOLUA_RELEASE 00153 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'child_frame'", NULL); 00154 #endif 00155 { 00156 char* tolua_ret = (char*) self->child_frame(); 00157 tolua_pushstring(tolua_S,(const char*)tolua_ret); 00158 } 00159 } 00160 return 1; 00161 #ifndef TOLUA_RELEASE 00162 tolua_lerror: 00163 tolua_error(tolua_S,"#ferror in function 'child_frame'.",&tolua_err); 00164 return 0; 00165 #endif 00166 } 00167 #endif //#ifndef TOLUA_DISABLE 00168 00169 /* method: set_child_frame of class fawkes::TransformInterface */ 00170 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_set_child_frame00 00171 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_set_child_frame00(lua_State* tolua_S) 00172 { 00173 #ifndef TOLUA_RELEASE 00174 tolua_Error tolua_err; 00175 if ( 00176 !tolua_isusertype(tolua_S,1,"fawkes::TransformInterface",0,&tolua_err) || 00177 !tolua_isstring(tolua_S,2,0,&tolua_err) || 00178 !tolua_isnoobj(tolua_S,3,&tolua_err) 00179 ) 00180 goto tolua_lerror; 00181 else 00182 #endif 00183 { 00184 fawkes::TransformInterface* self = (fawkes::TransformInterface*) tolua_tousertype(tolua_S,1,0); 00185 const char* new_child_frame = ((const char*) tolua_tostring(tolua_S,2,0)); 00186 #ifndef TOLUA_RELEASE 00187 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_child_frame'", NULL); 00188 #endif 00189 { 00190 self->set_child_frame(new_child_frame); 00191 } 00192 } 00193 return 0; 00194 #ifndef TOLUA_RELEASE 00195 tolua_lerror: 00196 tolua_error(tolua_S,"#ferror in function 'set_child_frame'.",&tolua_err); 00197 return 0; 00198 #endif 00199 } 00200 #endif //#ifndef TOLUA_DISABLE 00201 00202 /* method: maxlenof_child_frame of class fawkes::TransformInterface */ 00203 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_maxlenof_child_frame00 00204 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_maxlenof_child_frame00(lua_State* tolua_S) 00205 { 00206 #ifndef TOLUA_RELEASE 00207 tolua_Error tolua_err; 00208 if ( 00209 !tolua_isusertype(tolua_S,1,"const fawkes::TransformInterface",0,&tolua_err) || 00210 !tolua_isnoobj(tolua_S,2,&tolua_err) 00211 ) 00212 goto tolua_lerror; 00213 else 00214 #endif 00215 { 00216 const fawkes::TransformInterface* self = (const fawkes::TransformInterface*) tolua_tousertype(tolua_S,1,0); 00217 #ifndef TOLUA_RELEASE 00218 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_child_frame'", NULL); 00219 #endif 00220 { 00221 int tolua_ret = (int) self->maxlenof_child_frame(); 00222 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00223 } 00224 } 00225 return 1; 00226 #ifndef TOLUA_RELEASE 00227 tolua_lerror: 00228 tolua_error(tolua_S,"#ferror in function 'maxlenof_child_frame'.",&tolua_err); 00229 return 0; 00230 #endif 00231 } 00232 #endif //#ifndef TOLUA_DISABLE 00233 00234 /* method: translation of class fawkes::TransformInterface */ 00235 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_translation00 00236 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_translation00(lua_State* tolua_S) 00237 { 00238 #ifndef TOLUA_RELEASE 00239 tolua_Error tolua_err; 00240 if ( 00241 !tolua_isusertype(tolua_S,1,"fawkes::TransformInterface",0,&tolua_err) || 00242 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 00243 !tolua_isnoobj(tolua_S,3,&tolua_err) 00244 ) 00245 goto tolua_lerror; 00246 else 00247 #endif 00248 { 00249 fawkes::TransformInterface* self = (fawkes::TransformInterface*) tolua_tousertype(tolua_S,1,0); 00250 int index = ((int) tolua_tonumber(tolua_S,2,0)); 00251 #ifndef TOLUA_RELEASE 00252 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'translation'", NULL); 00253 #endif 00254 { 00255 double tolua_ret = (double) self->translation(index); 00256 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00257 } 00258 } 00259 return 1; 00260 #ifndef TOLUA_RELEASE 00261 tolua_lerror: 00262 tolua_error(tolua_S,"#ferror in function 'translation'.",&tolua_err); 00263 return 0; 00264 #endif 00265 } 00266 #endif //#ifndef TOLUA_DISABLE 00267 00268 /* method: set_translation of class fawkes::TransformInterface */ 00269 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_set_translation00 00270 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_set_translation00(lua_State* tolua_S) 00271 { 00272 #ifndef TOLUA_RELEASE 00273 tolua_Error tolua_err; 00274 if ( 00275 !tolua_isusertype(tolua_S,1,"fawkes::TransformInterface",0,&tolua_err) || 00276 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 00277 !tolua_isnumber(tolua_S,3,0,&tolua_err) || 00278 !tolua_isnoobj(tolua_S,4,&tolua_err) 00279 ) 00280 goto tolua_lerror; 00281 else 00282 #endif 00283 { 00284 fawkes::TransformInterface* self = (fawkes::TransformInterface*) tolua_tousertype(tolua_S,1,0); 00285 unsigned int index = ((unsigned int) tolua_tonumber(tolua_S,2,0)); 00286 const double new_translation = ((const double) tolua_tonumber(tolua_S,3,0)); 00287 #ifndef TOLUA_RELEASE 00288 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_translation'", NULL); 00289 #endif 00290 { 00291 self->set_translation(index,new_translation); 00292 } 00293 } 00294 return 0; 00295 #ifndef TOLUA_RELEASE 00296 tolua_lerror: 00297 tolua_error(tolua_S,"#ferror in function 'set_translation'.",&tolua_err); 00298 return 0; 00299 #endif 00300 } 00301 #endif //#ifndef TOLUA_DISABLE 00302 00303 /* method: maxlenof_translation of class fawkes::TransformInterface */ 00304 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_maxlenof_translation00 00305 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_maxlenof_translation00(lua_State* tolua_S) 00306 { 00307 #ifndef TOLUA_RELEASE 00308 tolua_Error tolua_err; 00309 if ( 00310 !tolua_isusertype(tolua_S,1,"const fawkes::TransformInterface",0,&tolua_err) || 00311 !tolua_isnoobj(tolua_S,2,&tolua_err) 00312 ) 00313 goto tolua_lerror; 00314 else 00315 #endif 00316 { 00317 const fawkes::TransformInterface* self = (const fawkes::TransformInterface*) tolua_tousertype(tolua_S,1,0); 00318 #ifndef TOLUA_RELEASE 00319 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_translation'", NULL); 00320 #endif 00321 { 00322 int tolua_ret = (int) self->maxlenof_translation(); 00323 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00324 } 00325 } 00326 return 1; 00327 #ifndef TOLUA_RELEASE 00328 tolua_lerror: 00329 tolua_error(tolua_S,"#ferror in function 'maxlenof_translation'.",&tolua_err); 00330 return 0; 00331 #endif 00332 } 00333 #endif //#ifndef TOLUA_DISABLE 00334 00335 /* method: rotation of class fawkes::TransformInterface */ 00336 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_rotation00 00337 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_rotation00(lua_State* tolua_S) 00338 { 00339 #ifndef TOLUA_RELEASE 00340 tolua_Error tolua_err; 00341 if ( 00342 !tolua_isusertype(tolua_S,1,"fawkes::TransformInterface",0,&tolua_err) || 00343 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 00344 !tolua_isnoobj(tolua_S,3,&tolua_err) 00345 ) 00346 goto tolua_lerror; 00347 else 00348 #endif 00349 { 00350 fawkes::TransformInterface* self = (fawkes::TransformInterface*) tolua_tousertype(tolua_S,1,0); 00351 int index = ((int) tolua_tonumber(tolua_S,2,0)); 00352 #ifndef TOLUA_RELEASE 00353 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'rotation'", NULL); 00354 #endif 00355 { 00356 double tolua_ret = (double) self->rotation(index); 00357 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00358 } 00359 } 00360 return 1; 00361 #ifndef TOLUA_RELEASE 00362 tolua_lerror: 00363 tolua_error(tolua_S,"#ferror in function 'rotation'.",&tolua_err); 00364 return 0; 00365 #endif 00366 } 00367 #endif //#ifndef TOLUA_DISABLE 00368 00369 /* method: set_rotation of class fawkes::TransformInterface */ 00370 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_set_rotation00 00371 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_set_rotation00(lua_State* tolua_S) 00372 { 00373 #ifndef TOLUA_RELEASE 00374 tolua_Error tolua_err; 00375 if ( 00376 !tolua_isusertype(tolua_S,1,"fawkes::TransformInterface",0,&tolua_err) || 00377 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 00378 !tolua_isnumber(tolua_S,3,0,&tolua_err) || 00379 !tolua_isnoobj(tolua_S,4,&tolua_err) 00380 ) 00381 goto tolua_lerror; 00382 else 00383 #endif 00384 { 00385 fawkes::TransformInterface* self = (fawkes::TransformInterface*) tolua_tousertype(tolua_S,1,0); 00386 unsigned int index = ((unsigned int) tolua_tonumber(tolua_S,2,0)); 00387 const double new_rotation = ((const double) tolua_tonumber(tolua_S,3,0)); 00388 #ifndef TOLUA_RELEASE 00389 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_rotation'", NULL); 00390 #endif 00391 { 00392 self->set_rotation(index,new_rotation); 00393 } 00394 } 00395 return 0; 00396 #ifndef TOLUA_RELEASE 00397 tolua_lerror: 00398 tolua_error(tolua_S,"#ferror in function 'set_rotation'.",&tolua_err); 00399 return 0; 00400 #endif 00401 } 00402 #endif //#ifndef TOLUA_DISABLE 00403 00404 /* method: maxlenof_rotation of class fawkes::TransformInterface */ 00405 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_maxlenof_rotation00 00406 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_maxlenof_rotation00(lua_State* tolua_S) 00407 { 00408 #ifndef TOLUA_RELEASE 00409 tolua_Error tolua_err; 00410 if ( 00411 !tolua_isusertype(tolua_S,1,"const fawkes::TransformInterface",0,&tolua_err) || 00412 !tolua_isnoobj(tolua_S,2,&tolua_err) 00413 ) 00414 goto tolua_lerror; 00415 else 00416 #endif 00417 { 00418 const fawkes::TransformInterface* self = (const fawkes::TransformInterface*) tolua_tousertype(tolua_S,1,0); 00419 #ifndef TOLUA_RELEASE 00420 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_rotation'", NULL); 00421 #endif 00422 { 00423 int tolua_ret = (int) self->maxlenof_rotation(); 00424 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00425 } 00426 } 00427 return 1; 00428 #ifndef TOLUA_RELEASE 00429 tolua_lerror: 00430 tolua_error(tolua_S,"#ferror in function 'maxlenof_rotation'.",&tolua_err); 00431 return 0; 00432 #endif 00433 } 00434 #endif //#ifndef TOLUA_DISABLE 00435 00436 /* method: oftype of class fawkes::TransformInterface */ 00437 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_oftype00 00438 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_oftype00(lua_State* tolua_S) 00439 { 00440 #ifndef TOLUA_RELEASE 00441 tolua_Error tolua_err; 00442 if ( 00443 !tolua_isusertype(tolua_S,1,"const fawkes::TransformInterface",0,&tolua_err) || 00444 !tolua_isstring(tolua_S,2,0,&tolua_err) || 00445 !tolua_isnoobj(tolua_S,3,&tolua_err) 00446 ) 00447 goto tolua_lerror; 00448 else 00449 #endif 00450 { 00451 const fawkes::TransformInterface* self = (const fawkes::TransformInterface*) tolua_tousertype(tolua_S,1,0); 00452 const char* interface_type = ((const char*) tolua_tostring(tolua_S,2,0)); 00453 #ifndef TOLUA_RELEASE 00454 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'oftype'", NULL); 00455 #endif 00456 { 00457 bool tolua_ret = (bool) self->oftype(interface_type); 00458 tolua_pushboolean(tolua_S,(bool)tolua_ret); 00459 } 00460 } 00461 return 1; 00462 #ifndef TOLUA_RELEASE 00463 tolua_lerror: 00464 tolua_error(tolua_S,"#ferror in function 'oftype'.",&tolua_err); 00465 return 0; 00466 #endif 00467 } 00468 #endif //#ifndef TOLUA_DISABLE 00469 00470 /* method: datachunk of class fawkes::TransformInterface */ 00471 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_datachunk00 00472 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_datachunk00(lua_State* tolua_S) 00473 { 00474 #ifndef TOLUA_RELEASE 00475 tolua_Error tolua_err; 00476 if ( 00477 !tolua_isusertype(tolua_S,1,"const fawkes::TransformInterface",0,&tolua_err) || 00478 !tolua_isnoobj(tolua_S,2,&tolua_err) 00479 ) 00480 goto tolua_lerror; 00481 else 00482 #endif 00483 { 00484 const fawkes::TransformInterface* self = (const fawkes::TransformInterface*) tolua_tousertype(tolua_S,1,0); 00485 #ifndef TOLUA_RELEASE 00486 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datachunk'", NULL); 00487 #endif 00488 { 00489 const void* tolua_ret = (const void*) self->datachunk(); 00490 tolua_pushuserdata(tolua_S,(void*)tolua_ret); 00491 } 00492 } 00493 return 1; 00494 #ifndef TOLUA_RELEASE 00495 tolua_lerror: 00496 tolua_error(tolua_S,"#ferror in function 'datachunk'.",&tolua_err); 00497 return 0; 00498 #endif 00499 } 00500 #endif //#ifndef TOLUA_DISABLE 00501 00502 /* method: datasize of class fawkes::TransformInterface */ 00503 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_datasize00 00504 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_datasize00(lua_State* tolua_S) 00505 { 00506 #ifndef TOLUA_RELEASE 00507 tolua_Error tolua_err; 00508 if ( 00509 !tolua_isusertype(tolua_S,1,"const fawkes::TransformInterface",0,&tolua_err) || 00510 !tolua_isnoobj(tolua_S,2,&tolua_err) 00511 ) 00512 goto tolua_lerror; 00513 else 00514 #endif 00515 { 00516 const fawkes::TransformInterface* self = (const fawkes::TransformInterface*) tolua_tousertype(tolua_S,1,0); 00517 #ifndef TOLUA_RELEASE 00518 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datasize'", NULL); 00519 #endif 00520 { 00521 unsigned int tolua_ret = (unsigned int) self->datasize(); 00522 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00523 } 00524 } 00525 return 1; 00526 #ifndef TOLUA_RELEASE 00527 tolua_lerror: 00528 tolua_error(tolua_S,"#ferror in function 'datasize'.",&tolua_err); 00529 return 0; 00530 #endif 00531 } 00532 #endif //#ifndef TOLUA_DISABLE 00533 00534 /* method: type of class fawkes::TransformInterface */ 00535 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_type00 00536 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_type00(lua_State* tolua_S) 00537 { 00538 #ifndef TOLUA_RELEASE 00539 tolua_Error tolua_err; 00540 if ( 00541 !tolua_isusertype(tolua_S,1,"const fawkes::TransformInterface",0,&tolua_err) || 00542 !tolua_isnoobj(tolua_S,2,&tolua_err) 00543 ) 00544 goto tolua_lerror; 00545 else 00546 #endif 00547 { 00548 const fawkes::TransformInterface* self = (const fawkes::TransformInterface*) tolua_tousertype(tolua_S,1,0); 00549 #ifndef TOLUA_RELEASE 00550 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'type'", NULL); 00551 #endif 00552 { 00553 const char* tolua_ret = (const char*) self->type(); 00554 tolua_pushstring(tolua_S,(const char*)tolua_ret); 00555 } 00556 } 00557 return 1; 00558 #ifndef TOLUA_RELEASE 00559 tolua_lerror: 00560 tolua_error(tolua_S,"#ferror in function 'type'.",&tolua_err); 00561 return 0; 00562 #endif 00563 } 00564 #endif //#ifndef TOLUA_DISABLE 00565 00566 /* method: id of class fawkes::TransformInterface */ 00567 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_id00 00568 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_id00(lua_State* tolua_S) 00569 { 00570 #ifndef TOLUA_RELEASE 00571 tolua_Error tolua_err; 00572 if ( 00573 !tolua_isusertype(tolua_S,1,"const fawkes::TransformInterface",0,&tolua_err) || 00574 !tolua_isnoobj(tolua_S,2,&tolua_err) 00575 ) 00576 goto tolua_lerror; 00577 else 00578 #endif 00579 { 00580 const fawkes::TransformInterface* self = (const fawkes::TransformInterface*) tolua_tousertype(tolua_S,1,0); 00581 #ifndef TOLUA_RELEASE 00582 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'id'", NULL); 00583 #endif 00584 { 00585 const char* tolua_ret = (const char*) self->id(); 00586 tolua_pushstring(tolua_S,(const char*)tolua_ret); 00587 } 00588 } 00589 return 1; 00590 #ifndef TOLUA_RELEASE 00591 tolua_lerror: 00592 tolua_error(tolua_S,"#ferror in function 'id'.",&tolua_err); 00593 return 0; 00594 #endif 00595 } 00596 #endif //#ifndef TOLUA_DISABLE 00597 00598 /* method: uid of class fawkes::TransformInterface */ 00599 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_uid00 00600 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_uid00(lua_State* tolua_S) 00601 { 00602 #ifndef TOLUA_RELEASE 00603 tolua_Error tolua_err; 00604 if ( 00605 !tolua_isusertype(tolua_S,1,"const fawkes::TransformInterface",0,&tolua_err) || 00606 !tolua_isnoobj(tolua_S,2,&tolua_err) 00607 ) 00608 goto tolua_lerror; 00609 else 00610 #endif 00611 { 00612 const fawkes::TransformInterface* self = (const fawkes::TransformInterface*) tolua_tousertype(tolua_S,1,0); 00613 #ifndef TOLUA_RELEASE 00614 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'uid'", NULL); 00615 #endif 00616 { 00617 const char* tolua_ret = (const char*) self->uid(); 00618 tolua_pushstring(tolua_S,(const char*)tolua_ret); 00619 } 00620 } 00621 return 1; 00622 #ifndef TOLUA_RELEASE 00623 tolua_lerror: 00624 tolua_error(tolua_S,"#ferror in function 'uid'.",&tolua_err); 00625 return 0; 00626 #endif 00627 } 00628 #endif //#ifndef TOLUA_DISABLE 00629 00630 /* method: serial of class fawkes::TransformInterface */ 00631 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_serial00 00632 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_serial00(lua_State* tolua_S) 00633 { 00634 #ifndef TOLUA_RELEASE 00635 tolua_Error tolua_err; 00636 if ( 00637 !tolua_isusertype(tolua_S,1,"const fawkes::TransformInterface",0,&tolua_err) || 00638 !tolua_isnoobj(tolua_S,2,&tolua_err) 00639 ) 00640 goto tolua_lerror; 00641 else 00642 #endif 00643 { 00644 const fawkes::TransformInterface* self = (const fawkes::TransformInterface*) tolua_tousertype(tolua_S,1,0); 00645 #ifndef TOLUA_RELEASE 00646 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'serial'", NULL); 00647 #endif 00648 { 00649 unsigned int tolua_ret = (unsigned int) self->serial(); 00650 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00651 } 00652 } 00653 return 1; 00654 #ifndef TOLUA_RELEASE 00655 tolua_lerror: 00656 tolua_error(tolua_S,"#ferror in function 'serial'.",&tolua_err); 00657 return 0; 00658 #endif 00659 } 00660 #endif //#ifndef TOLUA_DISABLE 00661 00662 /* method: mem_serial of class fawkes::TransformInterface */ 00663 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_mem_serial00 00664 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_mem_serial00(lua_State* tolua_S) 00665 { 00666 #ifndef TOLUA_RELEASE 00667 tolua_Error tolua_err; 00668 if ( 00669 !tolua_isusertype(tolua_S,1,"const fawkes::TransformInterface",0,&tolua_err) || 00670 !tolua_isnoobj(tolua_S,2,&tolua_err) 00671 ) 00672 goto tolua_lerror; 00673 else 00674 #endif 00675 { 00676 const fawkes::TransformInterface* self = (const fawkes::TransformInterface*) tolua_tousertype(tolua_S,1,0); 00677 #ifndef TOLUA_RELEASE 00678 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'mem_serial'", NULL); 00679 #endif 00680 { 00681 unsigned int tolua_ret = (unsigned int) self->mem_serial(); 00682 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00683 } 00684 } 00685 return 1; 00686 #ifndef TOLUA_RELEASE 00687 tolua_lerror: 00688 tolua_error(tolua_S,"#ferror in function 'mem_serial'.",&tolua_err); 00689 return 0; 00690 #endif 00691 } 00692 #endif //#ifndef TOLUA_DISABLE 00693 00694 /* method: operator== of class fawkes::TransformInterface */ 00695 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface__eq00 00696 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface__eq00(lua_State* tolua_S) 00697 { 00698 #ifndef TOLUA_RELEASE 00699 tolua_Error tolua_err; 00700 if ( 00701 !tolua_isusertype(tolua_S,1,"const fawkes::TransformInterface",0,&tolua_err) || 00702 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Interface",0,&tolua_err)) || 00703 !tolua_isnoobj(tolua_S,3,&tolua_err) 00704 ) 00705 goto tolua_lerror; 00706 else 00707 #endif 00708 { 00709 const fawkes::TransformInterface* self = (const fawkes::TransformInterface*) tolua_tousertype(tolua_S,1,0); 00710 Interface* comp = ((Interface*) tolua_tousertype(tolua_S,2,0)); 00711 #ifndef TOLUA_RELEASE 00712 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='", NULL); 00713 #endif 00714 { 00715 bool tolua_ret = (bool) self->operator==(*comp); 00716 tolua_pushboolean(tolua_S,(bool)tolua_ret); 00717 } 00718 } 00719 return 1; 00720 #ifndef TOLUA_RELEASE 00721 tolua_lerror: 00722 tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err); 00723 return 0; 00724 #endif 00725 } 00726 #endif //#ifndef TOLUA_DISABLE 00727 00728 /* method: hash of class fawkes::TransformInterface */ 00729 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_hash00 00730 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_hash00(lua_State* tolua_S) 00731 { 00732 #ifndef TOLUA_RELEASE 00733 tolua_Error tolua_err; 00734 if ( 00735 !tolua_isusertype(tolua_S,1,"const fawkes::TransformInterface",0,&tolua_err) || 00736 !tolua_isnoobj(tolua_S,2,&tolua_err) 00737 ) 00738 goto tolua_lerror; 00739 else 00740 #endif 00741 { 00742 const fawkes::TransformInterface* self = (const fawkes::TransformInterface*) tolua_tousertype(tolua_S,1,0); 00743 #ifndef TOLUA_RELEASE 00744 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash'", NULL); 00745 #endif 00746 { 00747 unsigned const char* tolua_ret = ( unsigned const char*) self->hash(); 00748 tolua_pushstring(tolua_S,(const char*)tolua_ret); 00749 } 00750 } 00751 return 1; 00752 #ifndef TOLUA_RELEASE 00753 tolua_lerror: 00754 tolua_error(tolua_S,"#ferror in function 'hash'.",&tolua_err); 00755 return 0; 00756 #endif 00757 } 00758 #endif //#ifndef TOLUA_DISABLE 00759 00760 /* method: hash_size of class fawkes::TransformInterface */ 00761 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_hash_size00 00762 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_hash_size00(lua_State* tolua_S) 00763 { 00764 #ifndef TOLUA_RELEASE 00765 tolua_Error tolua_err; 00766 if ( 00767 !tolua_isusertype(tolua_S,1,"const fawkes::TransformInterface",0,&tolua_err) || 00768 !tolua_isnoobj(tolua_S,2,&tolua_err) 00769 ) 00770 goto tolua_lerror; 00771 else 00772 #endif 00773 { 00774 const fawkes::TransformInterface* self = (const fawkes::TransformInterface*) tolua_tousertype(tolua_S,1,0); 00775 #ifndef TOLUA_RELEASE 00776 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash_size'", NULL); 00777 #endif 00778 { 00779 int tolua_ret = (int) self->hash_size(); 00780 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00781 } 00782 } 00783 return 1; 00784 #ifndef TOLUA_RELEASE 00785 tolua_lerror: 00786 tolua_error(tolua_S,"#ferror in function 'hash_size'.",&tolua_err); 00787 return 0; 00788 #endif 00789 } 00790 #endif //#ifndef TOLUA_DISABLE 00791 00792 /* method: hash_printable of class fawkes::TransformInterface */ 00793 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_hash_printable00 00794 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_hash_printable00(lua_State* tolua_S) 00795 { 00796 #ifndef TOLUA_RELEASE 00797 tolua_Error tolua_err; 00798 if ( 00799 !tolua_isusertype(tolua_S,1,"const fawkes::TransformInterface",0,&tolua_err) || 00800 !tolua_isnoobj(tolua_S,2,&tolua_err) 00801 ) 00802 goto tolua_lerror; 00803 else 00804 #endif 00805 { 00806 const fawkes::TransformInterface* self = (const fawkes::TransformInterface*) tolua_tousertype(tolua_S,1,0); 00807 #ifndef TOLUA_RELEASE 00808 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash_printable'", NULL); 00809 #endif 00810 { 00811 const char* tolua_ret = (const char*) self->hash_printable(); 00812 tolua_pushstring(tolua_S,(const char*)tolua_ret); 00813 } 00814 } 00815 return 1; 00816 #ifndef TOLUA_RELEASE 00817 tolua_lerror: 00818 tolua_error(tolua_S,"#ferror in function 'hash_printable'.",&tolua_err); 00819 return 0; 00820 #endif 00821 } 00822 #endif //#ifndef TOLUA_DISABLE 00823 00824 /* method: is_writer of class fawkes::TransformInterface */ 00825 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_is_writer00 00826 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_is_writer00(lua_State* tolua_S) 00827 { 00828 #ifndef TOLUA_RELEASE 00829 tolua_Error tolua_err; 00830 if ( 00831 !tolua_isusertype(tolua_S,1,"const fawkes::TransformInterface",0,&tolua_err) || 00832 !tolua_isnoobj(tolua_S,2,&tolua_err) 00833 ) 00834 goto tolua_lerror; 00835 else 00836 #endif 00837 { 00838 const fawkes::TransformInterface* self = (const fawkes::TransformInterface*) tolua_tousertype(tolua_S,1,0); 00839 #ifndef TOLUA_RELEASE 00840 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_writer'", NULL); 00841 #endif 00842 { 00843 bool tolua_ret = (bool) self->is_writer(); 00844 tolua_pushboolean(tolua_S,(bool)tolua_ret); 00845 } 00846 } 00847 return 1; 00848 #ifndef TOLUA_RELEASE 00849 tolua_lerror: 00850 tolua_error(tolua_S,"#ferror in function 'is_writer'.",&tolua_err); 00851 return 0; 00852 #endif 00853 } 00854 #endif //#ifndef TOLUA_DISABLE 00855 00856 /* method: set_from_chunk of class fawkes::TransformInterface */ 00857 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_set_from_chunk00 00858 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_set_from_chunk00(lua_State* tolua_S) 00859 { 00860 #ifndef TOLUA_RELEASE 00861 tolua_Error tolua_err; 00862 if ( 00863 !tolua_isusertype(tolua_S,1,"fawkes::TransformInterface",0,&tolua_err) || 00864 !tolua_isuserdata(tolua_S,2,0,&tolua_err) || 00865 !tolua_isnoobj(tolua_S,3,&tolua_err) 00866 ) 00867 goto tolua_lerror; 00868 else 00869 #endif 00870 { 00871 fawkes::TransformInterface* self = (fawkes::TransformInterface*) tolua_tousertype(tolua_S,1,0); 00872 void* chunk = ((void*) tolua_touserdata(tolua_S,2,0)); 00873 #ifndef TOLUA_RELEASE 00874 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_from_chunk'", NULL); 00875 #endif 00876 { 00877 self->set_from_chunk(chunk); 00878 } 00879 } 00880 return 0; 00881 #ifndef TOLUA_RELEASE 00882 tolua_lerror: 00883 tolua_error(tolua_S,"#ferror in function 'set_from_chunk'.",&tolua_err); 00884 return 0; 00885 #endif 00886 } 00887 #endif //#ifndef TOLUA_DISABLE 00888 00889 /* method: create_message of class fawkes::TransformInterface */ 00890 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_create_message00 00891 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_create_message00(lua_State* tolua_S) 00892 { 00893 #ifndef TOLUA_RELEASE 00894 tolua_Error tolua_err; 00895 if ( 00896 !tolua_isusertype(tolua_S,1,"const fawkes::TransformInterface",0,&tolua_err) || 00897 !tolua_isstring(tolua_S,2,0,&tolua_err) || 00898 !tolua_isnoobj(tolua_S,3,&tolua_err) 00899 ) 00900 goto tolua_lerror; 00901 else 00902 #endif 00903 { 00904 const fawkes::TransformInterface* self = (const fawkes::TransformInterface*) tolua_tousertype(tolua_S,1,0); 00905 const char* type = ((const char*) tolua_tostring(tolua_S,2,0)); 00906 #ifndef TOLUA_RELEASE 00907 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'create_message'", NULL); 00908 #endif 00909 { 00910 Message* tolua_ret = (Message*) self->create_message(type); 00911 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Message"); 00912 } 00913 } 00914 return 1; 00915 #ifndef TOLUA_RELEASE 00916 tolua_lerror: 00917 tolua_error(tolua_S,"#ferror in function 'create_message'.",&tolua_err); 00918 return 0; 00919 #endif 00920 } 00921 #endif //#ifndef TOLUA_DISABLE 00922 00923 /* method: read of class fawkes::TransformInterface */ 00924 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_read00 00925 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_read00(lua_State* tolua_S) 00926 { 00927 #ifndef TOLUA_RELEASE 00928 tolua_Error tolua_err; 00929 if ( 00930 !tolua_isusertype(tolua_S,1,"fawkes::TransformInterface",0,&tolua_err) || 00931 !tolua_isnoobj(tolua_S,2,&tolua_err) 00932 ) 00933 goto tolua_lerror; 00934 else 00935 #endif 00936 { 00937 fawkes::TransformInterface* self = (fawkes::TransformInterface*) tolua_tousertype(tolua_S,1,0); 00938 #ifndef TOLUA_RELEASE 00939 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'read'", NULL); 00940 #endif 00941 { 00942 self->read(); 00943 } 00944 } 00945 return 0; 00946 #ifndef TOLUA_RELEASE 00947 tolua_lerror: 00948 tolua_error(tolua_S,"#ferror in function 'read'.",&tolua_err); 00949 return 0; 00950 #endif 00951 } 00952 #endif //#ifndef TOLUA_DISABLE 00953 00954 /* method: write of class fawkes::TransformInterface */ 00955 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_write00 00956 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_write00(lua_State* tolua_S) 00957 { 00958 #ifndef TOLUA_RELEASE 00959 tolua_Error tolua_err; 00960 if ( 00961 !tolua_isusertype(tolua_S,1,"fawkes::TransformInterface",0,&tolua_err) || 00962 !tolua_isnoobj(tolua_S,2,&tolua_err) 00963 ) 00964 goto tolua_lerror; 00965 else 00966 #endif 00967 { 00968 fawkes::TransformInterface* self = (fawkes::TransformInterface*) tolua_tousertype(tolua_S,1,0); 00969 #ifndef TOLUA_RELEASE 00970 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'write'", NULL); 00971 #endif 00972 { 00973 self->write(); 00974 } 00975 } 00976 return 0; 00977 #ifndef TOLUA_RELEASE 00978 tolua_lerror: 00979 tolua_error(tolua_S,"#ferror in function 'write'.",&tolua_err); 00980 return 0; 00981 #endif 00982 } 00983 #endif //#ifndef TOLUA_DISABLE 00984 00985 /* method: has_writer of class fawkes::TransformInterface */ 00986 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_has_writer00 00987 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_has_writer00(lua_State* tolua_S) 00988 { 00989 #ifndef TOLUA_RELEASE 00990 tolua_Error tolua_err; 00991 if ( 00992 !tolua_isusertype(tolua_S,1,"const fawkes::TransformInterface",0,&tolua_err) || 00993 !tolua_isnoobj(tolua_S,2,&tolua_err) 00994 ) 00995 goto tolua_lerror; 00996 else 00997 #endif 00998 { 00999 const fawkes::TransformInterface* self = (const fawkes::TransformInterface*) tolua_tousertype(tolua_S,1,0); 01000 #ifndef TOLUA_RELEASE 01001 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'has_writer'", NULL); 01002 #endif 01003 { 01004 bool tolua_ret = (bool) self->has_writer(); 01005 tolua_pushboolean(tolua_S,(bool)tolua_ret); 01006 } 01007 } 01008 return 1; 01009 #ifndef TOLUA_RELEASE 01010 tolua_lerror: 01011 tolua_error(tolua_S,"#ferror in function 'has_writer'.",&tolua_err); 01012 return 0; 01013 #endif 01014 } 01015 #endif //#ifndef TOLUA_DISABLE 01016 01017 /* method: num_readers of class fawkes::TransformInterface */ 01018 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_num_readers00 01019 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_num_readers00(lua_State* tolua_S) 01020 { 01021 #ifndef TOLUA_RELEASE 01022 tolua_Error tolua_err; 01023 if ( 01024 !tolua_isusertype(tolua_S,1,"const fawkes::TransformInterface",0,&tolua_err) || 01025 !tolua_isnoobj(tolua_S,2,&tolua_err) 01026 ) 01027 goto tolua_lerror; 01028 else 01029 #endif 01030 { 01031 const fawkes::TransformInterface* self = (const fawkes::TransformInterface*) tolua_tousertype(tolua_S,1,0); 01032 #ifndef TOLUA_RELEASE 01033 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'num_readers'", NULL); 01034 #endif 01035 { 01036 unsigned int tolua_ret = (unsigned int) self->num_readers(); 01037 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01038 } 01039 } 01040 return 1; 01041 #ifndef TOLUA_RELEASE 01042 tolua_lerror: 01043 tolua_error(tolua_S,"#ferror in function 'num_readers'.",&tolua_err); 01044 return 0; 01045 #endif 01046 } 01047 #endif //#ifndef TOLUA_DISABLE 01048 01049 /* method: msgq_enqueue_copy of class fawkes::TransformInterface */ 01050 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_enqueue_copy00 01051 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_enqueue_copy00(lua_State* tolua_S) 01052 { 01053 #ifndef TOLUA_RELEASE 01054 tolua_Error tolua_err; 01055 if ( 01056 !tolua_isusertype(tolua_S,1,"fawkes::TransformInterface",0,&tolua_err) || 01057 !tolua_isusertype(tolua_S,2,"Message",0,&tolua_err) || 01058 !tolua_isnoobj(tolua_S,3,&tolua_err) 01059 ) 01060 goto tolua_lerror; 01061 else 01062 #endif 01063 { 01064 fawkes::TransformInterface* self = (fawkes::TransformInterface*) tolua_tousertype(tolua_S,1,0); 01065 Message* message = ((Message*) tolua_tousertype(tolua_S,2,0)); 01066 #ifndef TOLUA_RELEASE 01067 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_enqueue_copy'", NULL); 01068 #endif 01069 { 01070 unsigned int tolua_ret = (unsigned int) self->msgq_enqueue_copy(message); 01071 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01072 } 01073 } 01074 return 1; 01075 #ifndef TOLUA_RELEASE 01076 tolua_lerror: 01077 tolua_error(tolua_S,"#ferror in function 'msgq_enqueue_copy'.",&tolua_err); 01078 return 0; 01079 #endif 01080 } 01081 #endif //#ifndef TOLUA_DISABLE 01082 01083 /* method: msgq_remove of class fawkes::TransformInterface */ 01084 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_remove00 01085 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_remove00(lua_State* tolua_S) 01086 { 01087 #ifndef TOLUA_RELEASE 01088 tolua_Error tolua_err; 01089 if ( 01090 !tolua_isusertype(tolua_S,1,"fawkes::TransformInterface",0,&tolua_err) || 01091 !tolua_isusertype(tolua_S,2,"Message",0,&tolua_err) || 01092 !tolua_isnoobj(tolua_S,3,&tolua_err) 01093 ) 01094 goto tolua_lerror; 01095 else 01096 #endif 01097 { 01098 fawkes::TransformInterface* self = (fawkes::TransformInterface*) tolua_tousertype(tolua_S,1,0); 01099 Message* message = ((Message*) tolua_tousertype(tolua_S,2,0)); 01100 #ifndef TOLUA_RELEASE 01101 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_remove'", NULL); 01102 #endif 01103 { 01104 self->msgq_remove(message); 01105 } 01106 } 01107 return 0; 01108 #ifndef TOLUA_RELEASE 01109 tolua_lerror: 01110 tolua_error(tolua_S,"#ferror in function 'msgq_remove'.",&tolua_err); 01111 return 0; 01112 #endif 01113 } 01114 #endif //#ifndef TOLUA_DISABLE 01115 01116 /* method: msgq_remove of class fawkes::TransformInterface */ 01117 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_remove01 01118 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_remove01(lua_State* tolua_S) 01119 { 01120 tolua_Error tolua_err; 01121 if ( 01122 !tolua_isusertype(tolua_S,1,"fawkes::TransformInterface",0,&tolua_err) || 01123 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 01124 !tolua_isnoobj(tolua_S,3,&tolua_err) 01125 ) 01126 goto tolua_lerror; 01127 else 01128 { 01129 fawkes::TransformInterface* self = (fawkes::TransformInterface*) tolua_tousertype(tolua_S,1,0); 01130 unsigned int message_id = ((unsigned int) tolua_tonumber(tolua_S,2,0)); 01131 #ifndef TOLUA_RELEASE 01132 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_remove'", NULL); 01133 #endif 01134 { 01135 self->msgq_remove(message_id); 01136 } 01137 } 01138 return 0; 01139 tolua_lerror: 01140 return tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_remove00(tolua_S); 01141 } 01142 #endif //#ifndef TOLUA_DISABLE 01143 01144 /* method: msgq_size of class fawkes::TransformInterface */ 01145 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_size00 01146 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_size00(lua_State* tolua_S) 01147 { 01148 #ifndef TOLUA_RELEASE 01149 tolua_Error tolua_err; 01150 if ( 01151 !tolua_isusertype(tolua_S,1,"fawkes::TransformInterface",0,&tolua_err) || 01152 !tolua_isnoobj(tolua_S,2,&tolua_err) 01153 ) 01154 goto tolua_lerror; 01155 else 01156 #endif 01157 { 01158 fawkes::TransformInterface* self = (fawkes::TransformInterface*) tolua_tousertype(tolua_S,1,0); 01159 #ifndef TOLUA_RELEASE 01160 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_size'", NULL); 01161 #endif 01162 { 01163 unsigned int tolua_ret = (unsigned int) self->msgq_size(); 01164 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01165 } 01166 } 01167 return 1; 01168 #ifndef TOLUA_RELEASE 01169 tolua_lerror: 01170 tolua_error(tolua_S,"#ferror in function 'msgq_size'.",&tolua_err); 01171 return 0; 01172 #endif 01173 } 01174 #endif //#ifndef TOLUA_DISABLE 01175 01176 /* method: msgq_flush of class fawkes::TransformInterface */ 01177 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_flush00 01178 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_flush00(lua_State* tolua_S) 01179 { 01180 #ifndef TOLUA_RELEASE 01181 tolua_Error tolua_err; 01182 if ( 01183 !tolua_isusertype(tolua_S,1,"fawkes::TransformInterface",0,&tolua_err) || 01184 !tolua_isnoobj(tolua_S,2,&tolua_err) 01185 ) 01186 goto tolua_lerror; 01187 else 01188 #endif 01189 { 01190 fawkes::TransformInterface* self = (fawkes::TransformInterface*) tolua_tousertype(tolua_S,1,0); 01191 #ifndef TOLUA_RELEASE 01192 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_flush'", NULL); 01193 #endif 01194 { 01195 self->msgq_flush(); 01196 } 01197 } 01198 return 0; 01199 #ifndef TOLUA_RELEASE 01200 tolua_lerror: 01201 tolua_error(tolua_S,"#ferror in function 'msgq_flush'.",&tolua_err); 01202 return 0; 01203 #endif 01204 } 01205 #endif //#ifndef TOLUA_DISABLE 01206 01207 /* method: msgq_lock of class fawkes::TransformInterface */ 01208 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_lock00 01209 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_lock00(lua_State* tolua_S) 01210 { 01211 #ifndef TOLUA_RELEASE 01212 tolua_Error tolua_err; 01213 if ( 01214 !tolua_isusertype(tolua_S,1,"fawkes::TransformInterface",0,&tolua_err) || 01215 !tolua_isnoobj(tolua_S,2,&tolua_err) 01216 ) 01217 goto tolua_lerror; 01218 else 01219 #endif 01220 { 01221 fawkes::TransformInterface* self = (fawkes::TransformInterface*) tolua_tousertype(tolua_S,1,0); 01222 #ifndef TOLUA_RELEASE 01223 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_lock'", NULL); 01224 #endif 01225 { 01226 self->msgq_lock(); 01227 } 01228 } 01229 return 0; 01230 #ifndef TOLUA_RELEASE 01231 tolua_lerror: 01232 tolua_error(tolua_S,"#ferror in function 'msgq_lock'.",&tolua_err); 01233 return 0; 01234 #endif 01235 } 01236 #endif //#ifndef TOLUA_DISABLE 01237 01238 /* method: msgq_try_lock of class fawkes::TransformInterface */ 01239 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_try_lock00 01240 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_try_lock00(lua_State* tolua_S) 01241 { 01242 #ifndef TOLUA_RELEASE 01243 tolua_Error tolua_err; 01244 if ( 01245 !tolua_isusertype(tolua_S,1,"fawkes::TransformInterface",0,&tolua_err) || 01246 !tolua_isnoobj(tolua_S,2,&tolua_err) 01247 ) 01248 goto tolua_lerror; 01249 else 01250 #endif 01251 { 01252 fawkes::TransformInterface* self = (fawkes::TransformInterface*) tolua_tousertype(tolua_S,1,0); 01253 #ifndef TOLUA_RELEASE 01254 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_try_lock'", NULL); 01255 #endif 01256 { 01257 bool tolua_ret = (bool) self->msgq_try_lock(); 01258 tolua_pushboolean(tolua_S,(bool)tolua_ret); 01259 } 01260 } 01261 return 1; 01262 #ifndef TOLUA_RELEASE 01263 tolua_lerror: 01264 tolua_error(tolua_S,"#ferror in function 'msgq_try_lock'.",&tolua_err); 01265 return 0; 01266 #endif 01267 } 01268 #endif //#ifndef TOLUA_DISABLE 01269 01270 /* method: msgq_unlock of class fawkes::TransformInterface */ 01271 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_unlock00 01272 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_unlock00(lua_State* tolua_S) 01273 { 01274 #ifndef TOLUA_RELEASE 01275 tolua_Error tolua_err; 01276 if ( 01277 !tolua_isusertype(tolua_S,1,"fawkes::TransformInterface",0,&tolua_err) || 01278 !tolua_isnoobj(tolua_S,2,&tolua_err) 01279 ) 01280 goto tolua_lerror; 01281 else 01282 #endif 01283 { 01284 fawkes::TransformInterface* self = (fawkes::TransformInterface*) tolua_tousertype(tolua_S,1,0); 01285 #ifndef TOLUA_RELEASE 01286 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_unlock'", NULL); 01287 #endif 01288 { 01289 self->msgq_unlock(); 01290 } 01291 } 01292 return 0; 01293 #ifndef TOLUA_RELEASE 01294 tolua_lerror: 01295 tolua_error(tolua_S,"#ferror in function 'msgq_unlock'.",&tolua_err); 01296 return 0; 01297 #endif 01298 } 01299 #endif //#ifndef TOLUA_DISABLE 01300 01301 /* method: msgq_pop of class fawkes::TransformInterface */ 01302 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_pop00 01303 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_pop00(lua_State* tolua_S) 01304 { 01305 #ifndef TOLUA_RELEASE 01306 tolua_Error tolua_err; 01307 if ( 01308 !tolua_isusertype(tolua_S,1,"fawkes::TransformInterface",0,&tolua_err) || 01309 !tolua_isnoobj(tolua_S,2,&tolua_err) 01310 ) 01311 goto tolua_lerror; 01312 else 01313 #endif 01314 { 01315 fawkes::TransformInterface* self = (fawkes::TransformInterface*) tolua_tousertype(tolua_S,1,0); 01316 #ifndef TOLUA_RELEASE 01317 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_pop'", NULL); 01318 #endif 01319 { 01320 self->msgq_pop(); 01321 } 01322 } 01323 return 0; 01324 #ifndef TOLUA_RELEASE 01325 tolua_lerror: 01326 tolua_error(tolua_S,"#ferror in function 'msgq_pop'.",&tolua_err); 01327 return 0; 01328 #endif 01329 } 01330 #endif //#ifndef TOLUA_DISABLE 01331 01332 /* method: msgq_first of class fawkes::TransformInterface */ 01333 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_first00 01334 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_first00(lua_State* tolua_S) 01335 { 01336 #ifndef TOLUA_RELEASE 01337 tolua_Error tolua_err; 01338 if ( 01339 !tolua_isusertype(tolua_S,1,"fawkes::TransformInterface",0,&tolua_err) || 01340 !tolua_isnoobj(tolua_S,2,&tolua_err) 01341 ) 01342 goto tolua_lerror; 01343 else 01344 #endif 01345 { 01346 fawkes::TransformInterface* self = (fawkes::TransformInterface*) tolua_tousertype(tolua_S,1,0); 01347 #ifndef TOLUA_RELEASE 01348 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_first'", NULL); 01349 #endif 01350 { 01351 Message* tolua_ret = (Message*) self->msgq_first(); 01352 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Message"); 01353 } 01354 } 01355 return 1; 01356 #ifndef TOLUA_RELEASE 01357 tolua_lerror: 01358 tolua_error(tolua_S,"#ferror in function 'msgq_first'.",&tolua_err); 01359 return 0; 01360 #endif 01361 } 01362 #endif //#ifndef TOLUA_DISABLE 01363 01364 /* method: msgq_empty of class fawkes::TransformInterface */ 01365 #ifndef TOLUA_DISABLE_tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_empty00 01366 static int tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_empty00(lua_State* tolua_S) 01367 { 01368 #ifndef TOLUA_RELEASE 01369 tolua_Error tolua_err; 01370 if ( 01371 !tolua_isusertype(tolua_S,1,"fawkes::TransformInterface",0,&tolua_err) || 01372 !tolua_isnoobj(tolua_S,2,&tolua_err) 01373 ) 01374 goto tolua_lerror; 01375 else 01376 #endif 01377 { 01378 fawkes::TransformInterface* self = (fawkes::TransformInterface*) tolua_tousertype(tolua_S,1,0); 01379 #ifndef TOLUA_RELEASE 01380 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_empty'", NULL); 01381 #endif 01382 { 01383 bool tolua_ret = (bool) self->msgq_empty(); 01384 tolua_pushboolean(tolua_S,(bool)tolua_ret); 01385 } 01386 } 01387 return 1; 01388 #ifndef TOLUA_RELEASE 01389 tolua_lerror: 01390 tolua_error(tolua_S,"#ferror in function 'msgq_empty'.",&tolua_err); 01391 return 0; 01392 #endif 01393 } 01394 #endif //#ifndef TOLUA_DISABLE 01395 01396 /* Open function */ 01397 TOLUA_API int tolua_interfaces_TransformInterface_open (lua_State* tolua_S) 01398 { 01399 tolua_open(tolua_S); 01400 tolua_reg_types(tolua_S); 01401 tolua_module(tolua_S,NULL,0); 01402 tolua_beginmodule(tolua_S,NULL); 01403 tolua_module(tolua_S,"fawkes",0); 01404 tolua_beginmodule(tolua_S,"fawkes"); 01405 tolua_cclass(tolua_S,"TransformInterface","fawkes::TransformInterface","Interface",NULL); 01406 tolua_beginmodule(tolua_S,"TransformInterface"); 01407 tolua_function(tolua_S,"frame",tolua_interfaces_TransformInterface_fawkes_TransformInterface_frame00); 01408 tolua_function(tolua_S,"set_frame",tolua_interfaces_TransformInterface_fawkes_TransformInterface_set_frame00); 01409 tolua_function(tolua_S,"maxlenof_frame",tolua_interfaces_TransformInterface_fawkes_TransformInterface_maxlenof_frame00); 01410 tolua_function(tolua_S,"child_frame",tolua_interfaces_TransformInterface_fawkes_TransformInterface_child_frame00); 01411 tolua_function(tolua_S,"set_child_frame",tolua_interfaces_TransformInterface_fawkes_TransformInterface_set_child_frame00); 01412 tolua_function(tolua_S,"maxlenof_child_frame",tolua_interfaces_TransformInterface_fawkes_TransformInterface_maxlenof_child_frame00); 01413 tolua_function(tolua_S,"translation",tolua_interfaces_TransformInterface_fawkes_TransformInterface_translation00); 01414 tolua_function(tolua_S,"set_translation",tolua_interfaces_TransformInterface_fawkes_TransformInterface_set_translation00); 01415 tolua_function(tolua_S,"maxlenof_translation",tolua_interfaces_TransformInterface_fawkes_TransformInterface_maxlenof_translation00); 01416 tolua_function(tolua_S,"rotation",tolua_interfaces_TransformInterface_fawkes_TransformInterface_rotation00); 01417 tolua_function(tolua_S,"set_rotation",tolua_interfaces_TransformInterface_fawkes_TransformInterface_set_rotation00); 01418 tolua_function(tolua_S,"maxlenof_rotation",tolua_interfaces_TransformInterface_fawkes_TransformInterface_maxlenof_rotation00); 01419 tolua_function(tolua_S,"oftype",tolua_interfaces_TransformInterface_fawkes_TransformInterface_oftype00); 01420 tolua_function(tolua_S,"datachunk",tolua_interfaces_TransformInterface_fawkes_TransformInterface_datachunk00); 01421 tolua_function(tolua_S,"datasize",tolua_interfaces_TransformInterface_fawkes_TransformInterface_datasize00); 01422 tolua_function(tolua_S,"type",tolua_interfaces_TransformInterface_fawkes_TransformInterface_type00); 01423 tolua_function(tolua_S,"id",tolua_interfaces_TransformInterface_fawkes_TransformInterface_id00); 01424 tolua_function(tolua_S,"uid",tolua_interfaces_TransformInterface_fawkes_TransformInterface_uid00); 01425 tolua_function(tolua_S,"serial",tolua_interfaces_TransformInterface_fawkes_TransformInterface_serial00); 01426 tolua_function(tolua_S,"mem_serial",tolua_interfaces_TransformInterface_fawkes_TransformInterface_mem_serial00); 01427 tolua_function(tolua_S,".eq",tolua_interfaces_TransformInterface_fawkes_TransformInterface__eq00); 01428 tolua_function(tolua_S,"hash",tolua_interfaces_TransformInterface_fawkes_TransformInterface_hash00); 01429 tolua_function(tolua_S,"hash_size",tolua_interfaces_TransformInterface_fawkes_TransformInterface_hash_size00); 01430 tolua_function(tolua_S,"hash_printable",tolua_interfaces_TransformInterface_fawkes_TransformInterface_hash_printable00); 01431 tolua_function(tolua_S,"is_writer",tolua_interfaces_TransformInterface_fawkes_TransformInterface_is_writer00); 01432 tolua_function(tolua_S,"set_from_chunk",tolua_interfaces_TransformInterface_fawkes_TransformInterface_set_from_chunk00); 01433 tolua_function(tolua_S,"create_message",tolua_interfaces_TransformInterface_fawkes_TransformInterface_create_message00); 01434 tolua_function(tolua_S,"read",tolua_interfaces_TransformInterface_fawkes_TransformInterface_read00); 01435 tolua_function(tolua_S,"write",tolua_interfaces_TransformInterface_fawkes_TransformInterface_write00); 01436 tolua_function(tolua_S,"has_writer",tolua_interfaces_TransformInterface_fawkes_TransformInterface_has_writer00); 01437 tolua_function(tolua_S,"num_readers",tolua_interfaces_TransformInterface_fawkes_TransformInterface_num_readers00); 01438 tolua_function(tolua_S,"msgq_enqueue_copy",tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_enqueue_copy00); 01439 tolua_function(tolua_S,"msgq_remove",tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_remove00); 01440 tolua_function(tolua_S,"msgq_remove",tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_remove01); 01441 tolua_function(tolua_S,"msgq_size",tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_size00); 01442 tolua_function(tolua_S,"msgq_flush",tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_flush00); 01443 tolua_function(tolua_S,"msgq_lock",tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_lock00); 01444 tolua_function(tolua_S,"msgq_try_lock",tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_try_lock00); 01445 tolua_function(tolua_S,"msgq_unlock",tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_unlock00); 01446 tolua_function(tolua_S,"msgq_pop",tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_pop00); 01447 tolua_function(tolua_S,"msgq_first",tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_first00); 01448 tolua_function(tolua_S,"msgq_empty",tolua_interfaces_TransformInterface_fawkes_TransformInterface_msgq_empty00); 01449 tolua_endmodule(tolua_S); 01450 tolua_endmodule(tolua_S); 01451 tolua_endmodule(tolua_S); 01452 return 1; 01453 } 01454 01455 01456 extern "C" { 01457 #if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501 01458 TOLUA_API int luaopen_interfaces_TransformInterface (lua_State* tolua_S) { 01459 return tolua_interfaces_TransformInterface_open(tolua_S); 01460 }; 01461 #endif 01462 } 01463 01464