Fawkes API
Fawkes Development Version
|
00001 /* 00002 ** Lua binding: interfaces_RobotinoSensorInterface 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_RobotinoSensorInterface_open (lua_State* tolua_S); 00028 00029 #include <interfaces/RobotinoSensorInterface.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,"fawkes::RobotinoSensorInterface"); 00036 tolua_usertype(tolua_S,"Message"); 00037 tolua_usertype(tolua_S,"Interface"); 00038 } 00039 00040 /* method: mot_velocity of class fawkes::RobotinoSensorInterface */ 00041 #ifndef TOLUA_DISABLE_tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_mot_velocity00 00042 static int tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_mot_velocity00(lua_State* tolua_S) 00043 { 00044 #ifndef TOLUA_RELEASE 00045 tolua_Error tolua_err; 00046 if ( 00047 !tolua_isusertype(tolua_S,1,"fawkes::RobotinoSensorInterface",0,&tolua_err) || 00048 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 00049 !tolua_isnoobj(tolua_S,3,&tolua_err) 00050 ) 00051 goto tolua_lerror; 00052 else 00053 #endif 00054 { 00055 fawkes::RobotinoSensorInterface* self = (fawkes::RobotinoSensorInterface*) tolua_tousertype(tolua_S,1,0); 00056 int index = ((int) tolua_tonumber(tolua_S,2,0)); 00057 #ifndef TOLUA_RELEASE 00058 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'mot_velocity'", NULL); 00059 #endif 00060 { 00061 float tolua_ret = (float) self->mot_velocity(index); 00062 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00063 } 00064 } 00065 return 1; 00066 #ifndef TOLUA_RELEASE 00067 tolua_lerror: 00068 tolua_error(tolua_S,"#ferror in function 'mot_velocity'.",&tolua_err); 00069 return 0; 00070 #endif 00071 } 00072 #endif //#ifndef TOLUA_DISABLE 00073 00074 /* method: set_mot_velocity of class fawkes::RobotinoSensorInterface */ 00075 #ifndef TOLUA_DISABLE_tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_set_mot_velocity00 00076 static int tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_set_mot_velocity00(lua_State* tolua_S) 00077 { 00078 #ifndef TOLUA_RELEASE 00079 tolua_Error tolua_err; 00080 if ( 00081 !tolua_isusertype(tolua_S,1,"fawkes::RobotinoSensorInterface",0,&tolua_err) || 00082 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 00083 !tolua_isnumber(tolua_S,3,0,&tolua_err) || 00084 !tolua_isnoobj(tolua_S,4,&tolua_err) 00085 ) 00086 goto tolua_lerror; 00087 else 00088 #endif 00089 { 00090 fawkes::RobotinoSensorInterface* self = (fawkes::RobotinoSensorInterface*) tolua_tousertype(tolua_S,1,0); 00091 unsigned int index = ((unsigned int) tolua_tonumber(tolua_S,2,0)); 00092 const float new_mot_velocity = ((const float) tolua_tonumber(tolua_S,3,0)); 00093 #ifndef TOLUA_RELEASE 00094 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_mot_velocity'", NULL); 00095 #endif 00096 { 00097 self->set_mot_velocity(index,new_mot_velocity); 00098 } 00099 } 00100 return 0; 00101 #ifndef TOLUA_RELEASE 00102 tolua_lerror: 00103 tolua_error(tolua_S,"#ferror in function 'set_mot_velocity'.",&tolua_err); 00104 return 0; 00105 #endif 00106 } 00107 #endif //#ifndef TOLUA_DISABLE 00108 00109 /* method: maxlenof_mot_velocity of class fawkes::RobotinoSensorInterface */ 00110 #ifndef TOLUA_DISABLE_tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_maxlenof_mot_velocity00 00111 static int tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_maxlenof_mot_velocity00(lua_State* tolua_S) 00112 { 00113 #ifndef TOLUA_RELEASE 00114 tolua_Error tolua_err; 00115 if ( 00116 !tolua_isusertype(tolua_S,1,"const fawkes::RobotinoSensorInterface",0,&tolua_err) || 00117 !tolua_isnoobj(tolua_S,2,&tolua_err) 00118 ) 00119 goto tolua_lerror; 00120 else 00121 #endif 00122 { 00123 const fawkes::RobotinoSensorInterface* self = (const fawkes::RobotinoSensorInterface*) tolua_tousertype(tolua_S,1,0); 00124 #ifndef TOLUA_RELEASE 00125 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_mot_velocity'", NULL); 00126 #endif 00127 { 00128 int tolua_ret = (int) self->maxlenof_mot_velocity(); 00129 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00130 } 00131 } 00132 return 1; 00133 #ifndef TOLUA_RELEASE 00134 tolua_lerror: 00135 tolua_error(tolua_S,"#ferror in function 'maxlenof_mot_velocity'.",&tolua_err); 00136 return 0; 00137 #endif 00138 } 00139 #endif //#ifndef TOLUA_DISABLE 00140 00141 /* method: mot_position of class fawkes::RobotinoSensorInterface */ 00142 #ifndef TOLUA_DISABLE_tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_mot_position00 00143 static int tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_mot_position00(lua_State* tolua_S) 00144 { 00145 #ifndef TOLUA_RELEASE 00146 tolua_Error tolua_err; 00147 if ( 00148 !tolua_isusertype(tolua_S,1,"fawkes::RobotinoSensorInterface",0,&tolua_err) || 00149 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 00150 !tolua_isnoobj(tolua_S,3,&tolua_err) 00151 ) 00152 goto tolua_lerror; 00153 else 00154 #endif 00155 { 00156 fawkes::RobotinoSensorInterface* self = (fawkes::RobotinoSensorInterface*) tolua_tousertype(tolua_S,1,0); 00157 int index = ((int) tolua_tonumber(tolua_S,2,0)); 00158 #ifndef TOLUA_RELEASE 00159 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'mot_position'", NULL); 00160 #endif 00161 { 00162 int tolua_ret = (int) self->mot_position(index); 00163 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00164 } 00165 } 00166 return 1; 00167 #ifndef TOLUA_RELEASE 00168 tolua_lerror: 00169 tolua_error(tolua_S,"#ferror in function 'mot_position'.",&tolua_err); 00170 return 0; 00171 #endif 00172 } 00173 #endif //#ifndef TOLUA_DISABLE 00174 00175 /* method: set_mot_position of class fawkes::RobotinoSensorInterface */ 00176 #ifndef TOLUA_DISABLE_tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_set_mot_position00 00177 static int tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_set_mot_position00(lua_State* tolua_S) 00178 { 00179 #ifndef TOLUA_RELEASE 00180 tolua_Error tolua_err; 00181 if ( 00182 !tolua_isusertype(tolua_S,1,"fawkes::RobotinoSensorInterface",0,&tolua_err) || 00183 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 00184 !tolua_isnumber(tolua_S,3,0,&tolua_err) || 00185 !tolua_isnoobj(tolua_S,4,&tolua_err) 00186 ) 00187 goto tolua_lerror; 00188 else 00189 #endif 00190 { 00191 fawkes::RobotinoSensorInterface* self = (fawkes::RobotinoSensorInterface*) tolua_tousertype(tolua_S,1,0); 00192 unsigned int index = ((unsigned int) tolua_tonumber(tolua_S,2,0)); 00193 const int new_mot_position = ((const int) tolua_tonumber(tolua_S,3,0)); 00194 #ifndef TOLUA_RELEASE 00195 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_mot_position'", NULL); 00196 #endif 00197 { 00198 self->set_mot_position(index,new_mot_position); 00199 } 00200 } 00201 return 0; 00202 #ifndef TOLUA_RELEASE 00203 tolua_lerror: 00204 tolua_error(tolua_S,"#ferror in function 'set_mot_position'.",&tolua_err); 00205 return 0; 00206 #endif 00207 } 00208 #endif //#ifndef TOLUA_DISABLE 00209 00210 /* method: maxlenof_mot_position of class fawkes::RobotinoSensorInterface */ 00211 #ifndef TOLUA_DISABLE_tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_maxlenof_mot_position00 00212 static int tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_maxlenof_mot_position00(lua_State* tolua_S) 00213 { 00214 #ifndef TOLUA_RELEASE 00215 tolua_Error tolua_err; 00216 if ( 00217 !tolua_isusertype(tolua_S,1,"const fawkes::RobotinoSensorInterface",0,&tolua_err) || 00218 !tolua_isnoobj(tolua_S,2,&tolua_err) 00219 ) 00220 goto tolua_lerror; 00221 else 00222 #endif 00223 { 00224 const fawkes::RobotinoSensorInterface* self = (const fawkes::RobotinoSensorInterface*) tolua_tousertype(tolua_S,1,0); 00225 #ifndef TOLUA_RELEASE 00226 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_mot_position'", NULL); 00227 #endif 00228 { 00229 int tolua_ret = (int) self->maxlenof_mot_position(); 00230 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00231 } 00232 } 00233 return 1; 00234 #ifndef TOLUA_RELEASE 00235 tolua_lerror: 00236 tolua_error(tolua_S,"#ferror in function 'maxlenof_mot_position'.",&tolua_err); 00237 return 0; 00238 #endif 00239 } 00240 #endif //#ifndef TOLUA_DISABLE 00241 00242 /* method: mot_current of class fawkes::RobotinoSensorInterface */ 00243 #ifndef TOLUA_DISABLE_tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_mot_current00 00244 static int tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_mot_current00(lua_State* tolua_S) 00245 { 00246 #ifndef TOLUA_RELEASE 00247 tolua_Error tolua_err; 00248 if ( 00249 !tolua_isusertype(tolua_S,1,"fawkes::RobotinoSensorInterface",0,&tolua_err) || 00250 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 00251 !tolua_isnoobj(tolua_S,3,&tolua_err) 00252 ) 00253 goto tolua_lerror; 00254 else 00255 #endif 00256 { 00257 fawkes::RobotinoSensorInterface* self = (fawkes::RobotinoSensorInterface*) tolua_tousertype(tolua_S,1,0); 00258 int index = ((int) tolua_tonumber(tolua_S,2,0)); 00259 #ifndef TOLUA_RELEASE 00260 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'mot_current'", NULL); 00261 #endif 00262 { 00263 float tolua_ret = (float) self->mot_current(index); 00264 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00265 } 00266 } 00267 return 1; 00268 #ifndef TOLUA_RELEASE 00269 tolua_lerror: 00270 tolua_error(tolua_S,"#ferror in function 'mot_current'.",&tolua_err); 00271 return 0; 00272 #endif 00273 } 00274 #endif //#ifndef TOLUA_DISABLE 00275 00276 /* method: set_mot_current of class fawkes::RobotinoSensorInterface */ 00277 #ifndef TOLUA_DISABLE_tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_set_mot_current00 00278 static int tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_set_mot_current00(lua_State* tolua_S) 00279 { 00280 #ifndef TOLUA_RELEASE 00281 tolua_Error tolua_err; 00282 if ( 00283 !tolua_isusertype(tolua_S,1,"fawkes::RobotinoSensorInterface",0,&tolua_err) || 00284 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 00285 !tolua_isnumber(tolua_S,3,0,&tolua_err) || 00286 !tolua_isnoobj(tolua_S,4,&tolua_err) 00287 ) 00288 goto tolua_lerror; 00289 else 00290 #endif 00291 { 00292 fawkes::RobotinoSensorInterface* self = (fawkes::RobotinoSensorInterface*) tolua_tousertype(tolua_S,1,0); 00293 unsigned int index = ((unsigned int) tolua_tonumber(tolua_S,2,0)); 00294 const float new_mot_current = ((const float) tolua_tonumber(tolua_S,3,0)); 00295 #ifndef TOLUA_RELEASE 00296 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_mot_current'", NULL); 00297 #endif 00298 { 00299 self->set_mot_current(index,new_mot_current); 00300 } 00301 } 00302 return 0; 00303 #ifndef TOLUA_RELEASE 00304 tolua_lerror: 00305 tolua_error(tolua_S,"#ferror in function 'set_mot_current'.",&tolua_err); 00306 return 0; 00307 #endif 00308 } 00309 #endif //#ifndef TOLUA_DISABLE 00310 00311 /* method: maxlenof_mot_current of class fawkes::RobotinoSensorInterface */ 00312 #ifndef TOLUA_DISABLE_tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_maxlenof_mot_current00 00313 static int tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_maxlenof_mot_current00(lua_State* tolua_S) 00314 { 00315 #ifndef TOLUA_RELEASE 00316 tolua_Error tolua_err; 00317 if ( 00318 !tolua_isusertype(tolua_S,1,"const fawkes::RobotinoSensorInterface",0,&tolua_err) || 00319 !tolua_isnoobj(tolua_S,2,&tolua_err) 00320 ) 00321 goto tolua_lerror; 00322 else 00323 #endif 00324 { 00325 const fawkes::RobotinoSensorInterface* self = (const fawkes::RobotinoSensorInterface*) tolua_tousertype(tolua_S,1,0); 00326 #ifndef TOLUA_RELEASE 00327 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_mot_current'", NULL); 00328 #endif 00329 { 00330 int tolua_ret = (int) self->maxlenof_mot_current(); 00331 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00332 } 00333 } 00334 return 1; 00335 #ifndef TOLUA_RELEASE 00336 tolua_lerror: 00337 tolua_error(tolua_S,"#ferror in function 'maxlenof_mot_current'.",&tolua_err); 00338 return 0; 00339 #endif 00340 } 00341 #endif //#ifndef TOLUA_DISABLE 00342 00343 /* method: is_bumper of class fawkes::RobotinoSensorInterface */ 00344 #ifndef TOLUA_DISABLE_tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_is_bumper00 00345 static int tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_is_bumper00(lua_State* tolua_S) 00346 { 00347 #ifndef TOLUA_RELEASE 00348 tolua_Error tolua_err; 00349 if ( 00350 !tolua_isusertype(tolua_S,1,"fawkes::RobotinoSensorInterface",0,&tolua_err) || 00351 !tolua_isnoobj(tolua_S,2,&tolua_err) 00352 ) 00353 goto tolua_lerror; 00354 else 00355 #endif 00356 { 00357 fawkes::RobotinoSensorInterface* self = (fawkes::RobotinoSensorInterface*) tolua_tousertype(tolua_S,1,0); 00358 #ifndef TOLUA_RELEASE 00359 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_bumper'", NULL); 00360 #endif 00361 { 00362 bool tolua_ret = (bool) self->is_bumper(); 00363 tolua_pushboolean(tolua_S,(bool)tolua_ret); 00364 } 00365 } 00366 return 1; 00367 #ifndef TOLUA_RELEASE 00368 tolua_lerror: 00369 tolua_error(tolua_S,"#ferror in function 'is_bumper'.",&tolua_err); 00370 return 0; 00371 #endif 00372 } 00373 #endif //#ifndef TOLUA_DISABLE 00374 00375 /* method: set_bumper of class fawkes::RobotinoSensorInterface */ 00376 #ifndef TOLUA_DISABLE_tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_set_bumper00 00377 static int tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_set_bumper00(lua_State* tolua_S) 00378 { 00379 #ifndef TOLUA_RELEASE 00380 tolua_Error tolua_err; 00381 if ( 00382 !tolua_isusertype(tolua_S,1,"fawkes::RobotinoSensorInterface",0,&tolua_err) || 00383 !tolua_isboolean(tolua_S,2,0,&tolua_err) || 00384 !tolua_isnoobj(tolua_S,3,&tolua_err) 00385 ) 00386 goto tolua_lerror; 00387 else 00388 #endif 00389 { 00390 fawkes::RobotinoSensorInterface* self = (fawkes::RobotinoSensorInterface*) tolua_tousertype(tolua_S,1,0); 00391 const bool new_bumper = ((const bool) tolua_toboolean(tolua_S,2,0)); 00392 #ifndef TOLUA_RELEASE 00393 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_bumper'", NULL); 00394 #endif 00395 { 00396 self->set_bumper(new_bumper); 00397 } 00398 } 00399 return 0; 00400 #ifndef TOLUA_RELEASE 00401 tolua_lerror: 00402 tolua_error(tolua_S,"#ferror in function 'set_bumper'.",&tolua_err); 00403 return 0; 00404 #endif 00405 } 00406 #endif //#ifndef TOLUA_DISABLE 00407 00408 /* method: maxlenof_bumper of class fawkes::RobotinoSensorInterface */ 00409 #ifndef TOLUA_DISABLE_tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_maxlenof_bumper00 00410 static int tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_maxlenof_bumper00(lua_State* tolua_S) 00411 { 00412 #ifndef TOLUA_RELEASE 00413 tolua_Error tolua_err; 00414 if ( 00415 !tolua_isusertype(tolua_S,1,"const fawkes::RobotinoSensorInterface",0,&tolua_err) || 00416 !tolua_isnoobj(tolua_S,2,&tolua_err) 00417 ) 00418 goto tolua_lerror; 00419 else 00420 #endif 00421 { 00422 const fawkes::RobotinoSensorInterface* self = (const fawkes::RobotinoSensorInterface*) tolua_tousertype(tolua_S,1,0); 00423 #ifndef TOLUA_RELEASE 00424 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_bumper'", NULL); 00425 #endif 00426 { 00427 int tolua_ret = (int) self->maxlenof_bumper(); 00428 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00429 } 00430 } 00431 return 1; 00432 #ifndef TOLUA_RELEASE 00433 tolua_lerror: 00434 tolua_error(tolua_S,"#ferror in function 'maxlenof_bumper'.",&tolua_err); 00435 return 0; 00436 #endif 00437 } 00438 #endif //#ifndef TOLUA_DISABLE 00439 00440 /* method: distance of class fawkes::RobotinoSensorInterface */ 00441 #ifndef TOLUA_DISABLE_tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_distance00 00442 static int tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_distance00(lua_State* tolua_S) 00443 { 00444 #ifndef TOLUA_RELEASE 00445 tolua_Error tolua_err; 00446 if ( 00447 !tolua_isusertype(tolua_S,1,"fawkes::RobotinoSensorInterface",0,&tolua_err) || 00448 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 00449 !tolua_isnoobj(tolua_S,3,&tolua_err) 00450 ) 00451 goto tolua_lerror; 00452 else 00453 #endif 00454 { 00455 fawkes::RobotinoSensorInterface* self = (fawkes::RobotinoSensorInterface*) tolua_tousertype(tolua_S,1,0); 00456 int index = ((int) tolua_tonumber(tolua_S,2,0)); 00457 #ifndef TOLUA_RELEASE 00458 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'distance'", NULL); 00459 #endif 00460 { 00461 float tolua_ret = (float) self->distance(index); 00462 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00463 } 00464 } 00465 return 1; 00466 #ifndef TOLUA_RELEASE 00467 tolua_lerror: 00468 tolua_error(tolua_S,"#ferror in function 'distance'.",&tolua_err); 00469 return 0; 00470 #endif 00471 } 00472 #endif //#ifndef TOLUA_DISABLE 00473 00474 /* method: set_distance of class fawkes::RobotinoSensorInterface */ 00475 #ifndef TOLUA_DISABLE_tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_set_distance00 00476 static int tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_set_distance00(lua_State* tolua_S) 00477 { 00478 #ifndef TOLUA_RELEASE 00479 tolua_Error tolua_err; 00480 if ( 00481 !tolua_isusertype(tolua_S,1,"fawkes::RobotinoSensorInterface",0,&tolua_err) || 00482 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 00483 !tolua_isnumber(tolua_S,3,0,&tolua_err) || 00484 !tolua_isnoobj(tolua_S,4,&tolua_err) 00485 ) 00486 goto tolua_lerror; 00487 else 00488 #endif 00489 { 00490 fawkes::RobotinoSensorInterface* self = (fawkes::RobotinoSensorInterface*) tolua_tousertype(tolua_S,1,0); 00491 unsigned int index = ((unsigned int) tolua_tonumber(tolua_S,2,0)); 00492 const float new_distance = ((const float) tolua_tonumber(tolua_S,3,0)); 00493 #ifndef TOLUA_RELEASE 00494 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_distance'", NULL); 00495 #endif 00496 { 00497 self->set_distance(index,new_distance); 00498 } 00499 } 00500 return 0; 00501 #ifndef TOLUA_RELEASE 00502 tolua_lerror: 00503 tolua_error(tolua_S,"#ferror in function 'set_distance'.",&tolua_err); 00504 return 0; 00505 #endif 00506 } 00507 #endif //#ifndef TOLUA_DISABLE 00508 00509 /* method: maxlenof_distance of class fawkes::RobotinoSensorInterface */ 00510 #ifndef TOLUA_DISABLE_tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_maxlenof_distance00 00511 static int tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_maxlenof_distance00(lua_State* tolua_S) 00512 { 00513 #ifndef TOLUA_RELEASE 00514 tolua_Error tolua_err; 00515 if ( 00516 !tolua_isusertype(tolua_S,1,"const fawkes::RobotinoSensorInterface",0,&tolua_err) || 00517 !tolua_isnoobj(tolua_S,2,&tolua_err) 00518 ) 00519 goto tolua_lerror; 00520 else 00521 #endif 00522 { 00523 const fawkes::RobotinoSensorInterface* self = (const fawkes::RobotinoSensorInterface*) tolua_tousertype(tolua_S,1,0); 00524 #ifndef TOLUA_RELEASE 00525 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_distance'", NULL); 00526 #endif 00527 { 00528 int tolua_ret = (int) self->maxlenof_distance(); 00529 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00530 } 00531 } 00532 return 1; 00533 #ifndef TOLUA_RELEASE 00534 tolua_lerror: 00535 tolua_error(tolua_S,"#ferror in function 'maxlenof_distance'.",&tolua_err); 00536 return 0; 00537 #endif 00538 } 00539 #endif //#ifndef TOLUA_DISABLE 00540 00541 /* method: is_digital_in of class fawkes::RobotinoSensorInterface */ 00542 #ifndef TOLUA_DISABLE_tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_is_digital_in00 00543 static int tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_is_digital_in00(lua_State* tolua_S) 00544 { 00545 #ifndef TOLUA_RELEASE 00546 tolua_Error tolua_err; 00547 if ( 00548 !tolua_isusertype(tolua_S,1,"fawkes::RobotinoSensorInterface",0,&tolua_err) || 00549 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 00550 !tolua_isnoobj(tolua_S,3,&tolua_err) 00551 ) 00552 goto tolua_lerror; 00553 else 00554 #endif 00555 { 00556 fawkes::RobotinoSensorInterface* self = (fawkes::RobotinoSensorInterface*) tolua_tousertype(tolua_S,1,0); 00557 int index = ((int) tolua_tonumber(tolua_S,2,0)); 00558 #ifndef TOLUA_RELEASE 00559 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_digital_in'", NULL); 00560 #endif 00561 { 00562 bool tolua_ret = (bool) self->is_digital_in(index); 00563 tolua_pushboolean(tolua_S,(bool)tolua_ret); 00564 } 00565 } 00566 return 1; 00567 #ifndef TOLUA_RELEASE 00568 tolua_lerror: 00569 tolua_error(tolua_S,"#ferror in function 'is_digital_in'.",&tolua_err); 00570 return 0; 00571 #endif 00572 } 00573 #endif //#ifndef TOLUA_DISABLE 00574 00575 /* method: set_digital_in of class fawkes::RobotinoSensorInterface */ 00576 #ifndef TOLUA_DISABLE_tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_set_digital_in00 00577 static int tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_set_digital_in00(lua_State* tolua_S) 00578 { 00579 #ifndef TOLUA_RELEASE 00580 tolua_Error tolua_err; 00581 if ( 00582 !tolua_isusertype(tolua_S,1,"fawkes::RobotinoSensorInterface",0,&tolua_err) || 00583 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 00584 !tolua_isboolean(tolua_S,3,0,&tolua_err) || 00585 !tolua_isnoobj(tolua_S,4,&tolua_err) 00586 ) 00587 goto tolua_lerror; 00588 else 00589 #endif 00590 { 00591 fawkes::RobotinoSensorInterface* self = (fawkes::RobotinoSensorInterface*) tolua_tousertype(tolua_S,1,0); 00592 unsigned int index = ((unsigned int) tolua_tonumber(tolua_S,2,0)); 00593 const bool new_digital_in = ((const bool) tolua_toboolean(tolua_S,3,0)); 00594 #ifndef TOLUA_RELEASE 00595 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_digital_in'", NULL); 00596 #endif 00597 { 00598 self->set_digital_in(index,new_digital_in); 00599 } 00600 } 00601 return 0; 00602 #ifndef TOLUA_RELEASE 00603 tolua_lerror: 00604 tolua_error(tolua_S,"#ferror in function 'set_digital_in'.",&tolua_err); 00605 return 0; 00606 #endif 00607 } 00608 #endif //#ifndef TOLUA_DISABLE 00609 00610 /* method: maxlenof_digital_in of class fawkes::RobotinoSensorInterface */ 00611 #ifndef TOLUA_DISABLE_tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_maxlenof_digital_in00 00612 static int tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_maxlenof_digital_in00(lua_State* tolua_S) 00613 { 00614 #ifndef TOLUA_RELEASE 00615 tolua_Error tolua_err; 00616 if ( 00617 !tolua_isusertype(tolua_S,1,"const fawkes::RobotinoSensorInterface",0,&tolua_err) || 00618 !tolua_isnoobj(tolua_S,2,&tolua_err) 00619 ) 00620 goto tolua_lerror; 00621 else 00622 #endif 00623 { 00624 const fawkes::RobotinoSensorInterface* self = (const fawkes::RobotinoSensorInterface*) tolua_tousertype(tolua_S,1,0); 00625 #ifndef TOLUA_RELEASE 00626 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_digital_in'", NULL); 00627 #endif 00628 { 00629 int tolua_ret = (int) self->maxlenof_digital_in(); 00630 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00631 } 00632 } 00633 return 1; 00634 #ifndef TOLUA_RELEASE 00635 tolua_lerror: 00636 tolua_error(tolua_S,"#ferror in function 'maxlenof_digital_in'.",&tolua_err); 00637 return 0; 00638 #endif 00639 } 00640 #endif //#ifndef TOLUA_DISABLE 00641 00642 /* method: analog_in of class fawkes::RobotinoSensorInterface */ 00643 #ifndef TOLUA_DISABLE_tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_analog_in00 00644 static int tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_analog_in00(lua_State* tolua_S) 00645 { 00646 #ifndef TOLUA_RELEASE 00647 tolua_Error tolua_err; 00648 if ( 00649 !tolua_isusertype(tolua_S,1,"fawkes::RobotinoSensorInterface",0,&tolua_err) || 00650 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 00651 !tolua_isnoobj(tolua_S,3,&tolua_err) 00652 ) 00653 goto tolua_lerror; 00654 else 00655 #endif 00656 { 00657 fawkes::RobotinoSensorInterface* self = (fawkes::RobotinoSensorInterface*) tolua_tousertype(tolua_S,1,0); 00658 int index = ((int) tolua_tonumber(tolua_S,2,0)); 00659 #ifndef TOLUA_RELEASE 00660 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'analog_in'", NULL); 00661 #endif 00662 { 00663 float tolua_ret = (float) self->analog_in(index); 00664 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00665 } 00666 } 00667 return 1; 00668 #ifndef TOLUA_RELEASE 00669 tolua_lerror: 00670 tolua_error(tolua_S,"#ferror in function 'analog_in'.",&tolua_err); 00671 return 0; 00672 #endif 00673 } 00674 #endif //#ifndef TOLUA_DISABLE 00675 00676 /* method: set_analog_in of class fawkes::RobotinoSensorInterface */ 00677 #ifndef TOLUA_DISABLE_tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_set_analog_in00 00678 static int tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_set_analog_in00(lua_State* tolua_S) 00679 { 00680 #ifndef TOLUA_RELEASE 00681 tolua_Error tolua_err; 00682 if ( 00683 !tolua_isusertype(tolua_S,1,"fawkes::RobotinoSensorInterface",0,&tolua_err) || 00684 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 00685 !tolua_isnumber(tolua_S,3,0,&tolua_err) || 00686 !tolua_isnoobj(tolua_S,4,&tolua_err) 00687 ) 00688 goto tolua_lerror; 00689 else 00690 #endif 00691 { 00692 fawkes::RobotinoSensorInterface* self = (fawkes::RobotinoSensorInterface*) tolua_tousertype(tolua_S,1,0); 00693 unsigned int index = ((unsigned int) tolua_tonumber(tolua_S,2,0)); 00694 const float new_analog_in = ((const float) tolua_tonumber(tolua_S,3,0)); 00695 #ifndef TOLUA_RELEASE 00696 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_analog_in'", NULL); 00697 #endif 00698 { 00699 self->set_analog_in(index,new_analog_in); 00700 } 00701 } 00702 return 0; 00703 #ifndef TOLUA_RELEASE 00704 tolua_lerror: 00705 tolua_error(tolua_S,"#ferror in function 'set_analog_in'.",&tolua_err); 00706 return 0; 00707 #endif 00708 } 00709 #endif //#ifndef TOLUA_DISABLE 00710 00711 /* method: maxlenof_analog_in of class fawkes::RobotinoSensorInterface */ 00712 #ifndef TOLUA_DISABLE_tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_maxlenof_analog_in00 00713 static int tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_maxlenof_analog_in00(lua_State* tolua_S) 00714 { 00715 #ifndef TOLUA_RELEASE 00716 tolua_Error tolua_err; 00717 if ( 00718 !tolua_isusertype(tolua_S,1,"const fawkes::RobotinoSensorInterface",0,&tolua_err) || 00719 !tolua_isnoobj(tolua_S,2,&tolua_err) 00720 ) 00721 goto tolua_lerror; 00722 else 00723 #endif 00724 { 00725 const fawkes::RobotinoSensorInterface* self = (const fawkes::RobotinoSensorInterface*) tolua_tousertype(tolua_S,1,0); 00726 #ifndef TOLUA_RELEASE 00727 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_analog_in'", NULL); 00728 #endif 00729 { 00730 int tolua_ret = (int) self->maxlenof_analog_in(); 00731 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00732 } 00733 } 00734 return 1; 00735 #ifndef TOLUA_RELEASE 00736 tolua_lerror: 00737 tolua_error(tolua_S,"#ferror in function 'maxlenof_analog_in'.",&tolua_err); 00738 return 0; 00739 #endif 00740 } 00741 #endif //#ifndef TOLUA_DISABLE 00742 00743 /* method: is_gyro_available of class fawkes::RobotinoSensorInterface */ 00744 #ifndef TOLUA_DISABLE_tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_is_gyro_available00 00745 static int tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_is_gyro_available00(lua_State* tolua_S) 00746 { 00747 #ifndef TOLUA_RELEASE 00748 tolua_Error tolua_err; 00749 if ( 00750 !tolua_isusertype(tolua_S,1,"fawkes::RobotinoSensorInterface",0,&tolua_err) || 00751 !tolua_isnoobj(tolua_S,2,&tolua_err) 00752 ) 00753 goto tolua_lerror; 00754 else 00755 #endif 00756 { 00757 fawkes::RobotinoSensorInterface* self = (fawkes::RobotinoSensorInterface*) tolua_tousertype(tolua_S,1,0); 00758 #ifndef TOLUA_RELEASE 00759 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_gyro_available'", NULL); 00760 #endif 00761 { 00762 bool tolua_ret = (bool) self->is_gyro_available(); 00763 tolua_pushboolean(tolua_S,(bool)tolua_ret); 00764 } 00765 } 00766 return 1; 00767 #ifndef TOLUA_RELEASE 00768 tolua_lerror: 00769 tolua_error(tolua_S,"#ferror in function 'is_gyro_available'.",&tolua_err); 00770 return 0; 00771 #endif 00772 } 00773 #endif //#ifndef TOLUA_DISABLE 00774 00775 /* method: set_gyro_available of class fawkes::RobotinoSensorInterface */ 00776 #ifndef TOLUA_DISABLE_tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_set_gyro_available00 00777 static int tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_set_gyro_available00(lua_State* tolua_S) 00778 { 00779 #ifndef TOLUA_RELEASE 00780 tolua_Error tolua_err; 00781 if ( 00782 !tolua_isusertype(tolua_S,1,"fawkes::RobotinoSensorInterface",0,&tolua_err) || 00783 !tolua_isboolean(tolua_S,2,0,&tolua_err) || 00784 !tolua_isnoobj(tolua_S,3,&tolua_err) 00785 ) 00786 goto tolua_lerror; 00787 else 00788 #endif 00789 { 00790 fawkes::RobotinoSensorInterface* self = (fawkes::RobotinoSensorInterface*) tolua_tousertype(tolua_S,1,0); 00791 const bool new_gyro_available = ((const bool) tolua_toboolean(tolua_S,2,0)); 00792 #ifndef TOLUA_RELEASE 00793 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_gyro_available'", NULL); 00794 #endif 00795 { 00796 self->set_gyro_available(new_gyro_available); 00797 } 00798 } 00799 return 0; 00800 #ifndef TOLUA_RELEASE 00801 tolua_lerror: 00802 tolua_error(tolua_S,"#ferror in function 'set_gyro_available'.",&tolua_err); 00803 return 0; 00804 #endif 00805 } 00806 #endif //#ifndef TOLUA_DISABLE 00807 00808 /* method: maxlenof_gyro_available of class fawkes::RobotinoSensorInterface */ 00809 #ifndef TOLUA_DISABLE_tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_maxlenof_gyro_available00 00810 static int tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_maxlenof_gyro_available00(lua_State* tolua_S) 00811 { 00812 #ifndef TOLUA_RELEASE 00813 tolua_Error tolua_err; 00814 if ( 00815 !tolua_isusertype(tolua_S,1,"const fawkes::RobotinoSensorInterface",0,&tolua_err) || 00816 !tolua_isnoobj(tolua_S,2,&tolua_err) 00817 ) 00818 goto tolua_lerror; 00819 else 00820 #endif 00821 { 00822 const fawkes::RobotinoSensorInterface* self = (const fawkes::RobotinoSensorInterface*) tolua_tousertype(tolua_S,1,0); 00823 #ifndef TOLUA_RELEASE 00824 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_gyro_available'", NULL); 00825 #endif 00826 { 00827 int tolua_ret = (int) self->maxlenof_gyro_available(); 00828 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00829 } 00830 } 00831 return 1; 00832 #ifndef TOLUA_RELEASE 00833 tolua_lerror: 00834 tolua_error(tolua_S,"#ferror in function 'maxlenof_gyro_available'.",&tolua_err); 00835 return 0; 00836 #endif 00837 } 00838 #endif //#ifndef TOLUA_DISABLE 00839 00840 /* method: gyro_angle of class fawkes::RobotinoSensorInterface */ 00841 #ifndef TOLUA_DISABLE_tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_gyro_angle00 00842 static int tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_gyro_angle00(lua_State* tolua_S) 00843 { 00844 #ifndef TOLUA_RELEASE 00845 tolua_Error tolua_err; 00846 if ( 00847 !tolua_isusertype(tolua_S,1,"fawkes::RobotinoSensorInterface",0,&tolua_err) || 00848 !tolua_isnoobj(tolua_S,2,&tolua_err) 00849 ) 00850 goto tolua_lerror; 00851 else 00852 #endif 00853 { 00854 fawkes::RobotinoSensorInterface* self = (fawkes::RobotinoSensorInterface*) tolua_tousertype(tolua_S,1,0); 00855 #ifndef TOLUA_RELEASE 00856 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'gyro_angle'", NULL); 00857 #endif 00858 { 00859 float tolua_ret = (float) self->gyro_angle(); 00860 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00861 } 00862 } 00863 return 1; 00864 #ifndef TOLUA_RELEASE 00865 tolua_lerror: 00866 tolua_error(tolua_S,"#ferror in function 'gyro_angle'.",&tolua_err); 00867 return 0; 00868 #endif 00869 } 00870 #endif //#ifndef TOLUA_DISABLE 00871 00872 /* method: set_gyro_angle of class fawkes::RobotinoSensorInterface */ 00873 #ifndef TOLUA_DISABLE_tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_set_gyro_angle00 00874 static int tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_set_gyro_angle00(lua_State* tolua_S) 00875 { 00876 #ifndef TOLUA_RELEASE 00877 tolua_Error tolua_err; 00878 if ( 00879 !tolua_isusertype(tolua_S,1,"fawkes::RobotinoSensorInterface",0,&tolua_err) || 00880 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 00881 !tolua_isnoobj(tolua_S,3,&tolua_err) 00882 ) 00883 goto tolua_lerror; 00884 else 00885 #endif 00886 { 00887 fawkes::RobotinoSensorInterface* self = (fawkes::RobotinoSensorInterface*) tolua_tousertype(tolua_S,1,0); 00888 const float new_gyro_angle = ((const float) tolua_tonumber(tolua_S,2,0)); 00889 #ifndef TOLUA_RELEASE 00890 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_gyro_angle'", NULL); 00891 #endif 00892 { 00893 self->set_gyro_angle(new_gyro_angle); 00894 } 00895 } 00896 return 0; 00897 #ifndef TOLUA_RELEASE 00898 tolua_lerror: 00899 tolua_error(tolua_S,"#ferror in function 'set_gyro_angle'.",&tolua_err); 00900 return 0; 00901 #endif 00902 } 00903 #endif //#ifndef TOLUA_DISABLE 00904 00905 /* method: maxlenof_gyro_angle of class fawkes::RobotinoSensorInterface */ 00906 #ifndef TOLUA_DISABLE_tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_maxlenof_gyro_angle00 00907 static int tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_maxlenof_gyro_angle00(lua_State* tolua_S) 00908 { 00909 #ifndef TOLUA_RELEASE 00910 tolua_Error tolua_err; 00911 if ( 00912 !tolua_isusertype(tolua_S,1,"const fawkes::RobotinoSensorInterface",0,&tolua_err) || 00913 !tolua_isnoobj(tolua_S,2,&tolua_err) 00914 ) 00915 goto tolua_lerror; 00916 else 00917 #endif 00918 { 00919 const fawkes::RobotinoSensorInterface* self = (const fawkes::RobotinoSensorInterface*) tolua_tousertype(tolua_S,1,0); 00920 #ifndef TOLUA_RELEASE 00921 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_gyro_angle'", NULL); 00922 #endif 00923 { 00924 int tolua_ret = (int) self->maxlenof_gyro_angle(); 00925 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00926 } 00927 } 00928 return 1; 00929 #ifndef TOLUA_RELEASE 00930 tolua_lerror: 00931 tolua_error(tolua_S,"#ferror in function 'maxlenof_gyro_angle'.",&tolua_err); 00932 return 0; 00933 #endif 00934 } 00935 #endif //#ifndef TOLUA_DISABLE 00936 00937 /* method: gyro_rate of class fawkes::RobotinoSensorInterface */ 00938 #ifndef TOLUA_DISABLE_tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_gyro_rate00 00939 static int tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_gyro_rate00(lua_State* tolua_S) 00940 { 00941 #ifndef TOLUA_RELEASE 00942 tolua_Error tolua_err; 00943 if ( 00944 !tolua_isusertype(tolua_S,1,"fawkes::RobotinoSensorInterface",0,&tolua_err) || 00945 !tolua_isnoobj(tolua_S,2,&tolua_err) 00946 ) 00947 goto tolua_lerror; 00948 else 00949 #endif 00950 { 00951 fawkes::RobotinoSensorInterface* self = (fawkes::RobotinoSensorInterface*) tolua_tousertype(tolua_S,1,0); 00952 #ifndef TOLUA_RELEASE 00953 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'gyro_rate'", NULL); 00954 #endif 00955 { 00956 float tolua_ret = (float) self->gyro_rate(); 00957 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00958 } 00959 } 00960 return 1; 00961 #ifndef TOLUA_RELEASE 00962 tolua_lerror: 00963 tolua_error(tolua_S,"#ferror in function 'gyro_rate'.",&tolua_err); 00964 return 0; 00965 #endif 00966 } 00967 #endif //#ifndef TOLUA_DISABLE 00968 00969 /* method: set_gyro_rate of class fawkes::RobotinoSensorInterface */ 00970 #ifndef TOLUA_DISABLE_tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_set_gyro_rate00 00971 static int tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_set_gyro_rate00(lua_State* tolua_S) 00972 { 00973 #ifndef TOLUA_RELEASE 00974 tolua_Error tolua_err; 00975 if ( 00976 !tolua_isusertype(tolua_S,1,"fawkes::RobotinoSensorInterface",0,&tolua_err) || 00977 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 00978 !tolua_isnoobj(tolua_S,3,&tolua_err) 00979 ) 00980 goto tolua_lerror; 00981 else 00982 #endif 00983 { 00984 fawkes::RobotinoSensorInterface* self = (fawkes::RobotinoSensorInterface*) tolua_tousertype(tolua_S,1,0); 00985 const float new_gyro_rate = ((const float) tolua_tonumber(tolua_S,2,0)); 00986 #ifndef TOLUA_RELEASE 00987 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_gyro_rate'", NULL); 00988 #endif 00989 { 00990 self->set_gyro_rate(new_gyro_rate); 00991 } 00992 } 00993 return 0; 00994 #ifndef TOLUA_RELEASE 00995 tolua_lerror: 00996 tolua_error(tolua_S,"#ferror in function 'set_gyro_rate'.",&tolua_err); 00997 return 0; 00998 #endif 00999 } 01000 #endif //#ifndef TOLUA_DISABLE 01001 01002 /* method: maxlenof_gyro_rate of class fawkes::RobotinoSensorInterface */ 01003 #ifndef TOLUA_DISABLE_tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_maxlenof_gyro_rate00 01004 static int tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_maxlenof_gyro_rate00(lua_State* tolua_S) 01005 { 01006 #ifndef TOLUA_RELEASE 01007 tolua_Error tolua_err; 01008 if ( 01009 !tolua_isusertype(tolua_S,1,"const fawkes::RobotinoSensorInterface",0,&tolua_err) || 01010 !tolua_isnoobj(tolua_S,2,&tolua_err) 01011 ) 01012 goto tolua_lerror; 01013 else 01014 #endif 01015 { 01016 const fawkes::RobotinoSensorInterface* self = (const fawkes::RobotinoSensorInterface*) tolua_tousertype(tolua_S,1,0); 01017 #ifndef TOLUA_RELEASE 01018 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_gyro_rate'", NULL); 01019 #endif 01020 { 01021 int tolua_ret = (int) self->maxlenof_gyro_rate(); 01022 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01023 } 01024 } 01025 return 1; 01026 #ifndef TOLUA_RELEASE 01027 tolua_lerror: 01028 tolua_error(tolua_S,"#ferror in function 'maxlenof_gyro_rate'.",&tolua_err); 01029 return 0; 01030 #endif 01031 } 01032 #endif //#ifndef TOLUA_DISABLE 01033 01034 /* method: oftype of class fawkes::RobotinoSensorInterface */ 01035 #ifndef TOLUA_DISABLE_tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_oftype00 01036 static int tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_oftype00(lua_State* tolua_S) 01037 { 01038 #ifndef TOLUA_RELEASE 01039 tolua_Error tolua_err; 01040 if ( 01041 !tolua_isusertype(tolua_S,1,"const fawkes::RobotinoSensorInterface",0,&tolua_err) || 01042 !tolua_isstring(tolua_S,2,0,&tolua_err) || 01043 !tolua_isnoobj(tolua_S,3,&tolua_err) 01044 ) 01045 goto tolua_lerror; 01046 else 01047 #endif 01048 { 01049 const fawkes::RobotinoSensorInterface* self = (const fawkes::RobotinoSensorInterface*) tolua_tousertype(tolua_S,1,0); 01050 const char* interface_type = ((const char*) tolua_tostring(tolua_S,2,0)); 01051 #ifndef TOLUA_RELEASE 01052 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'oftype'", NULL); 01053 #endif 01054 { 01055 bool tolua_ret = (bool) self->oftype(interface_type); 01056 tolua_pushboolean(tolua_S,(bool)tolua_ret); 01057 } 01058 } 01059 return 1; 01060 #ifndef TOLUA_RELEASE 01061 tolua_lerror: 01062 tolua_error(tolua_S,"#ferror in function 'oftype'.",&tolua_err); 01063 return 0; 01064 #endif 01065 } 01066 #endif //#ifndef TOLUA_DISABLE 01067 01068 /* method: datachunk of class fawkes::RobotinoSensorInterface */ 01069 #ifndef TOLUA_DISABLE_tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_datachunk00 01070 static int tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_datachunk00(lua_State* tolua_S) 01071 { 01072 #ifndef TOLUA_RELEASE 01073 tolua_Error tolua_err; 01074 if ( 01075 !tolua_isusertype(tolua_S,1,"const fawkes::RobotinoSensorInterface",0,&tolua_err) || 01076 !tolua_isnoobj(tolua_S,2,&tolua_err) 01077 ) 01078 goto tolua_lerror; 01079 else 01080 #endif 01081 { 01082 const fawkes::RobotinoSensorInterface* self = (const fawkes::RobotinoSensorInterface*) tolua_tousertype(tolua_S,1,0); 01083 #ifndef TOLUA_RELEASE 01084 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datachunk'", NULL); 01085 #endif 01086 { 01087 const void* tolua_ret = (const void*) self->datachunk(); 01088 tolua_pushuserdata(tolua_S,(void*)tolua_ret); 01089 } 01090 } 01091 return 1; 01092 #ifndef TOLUA_RELEASE 01093 tolua_lerror: 01094 tolua_error(tolua_S,"#ferror in function 'datachunk'.",&tolua_err); 01095 return 0; 01096 #endif 01097 } 01098 #endif //#ifndef TOLUA_DISABLE 01099 01100 /* method: datasize of class fawkes::RobotinoSensorInterface */ 01101 #ifndef TOLUA_DISABLE_tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_datasize00 01102 static int tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_datasize00(lua_State* tolua_S) 01103 { 01104 #ifndef TOLUA_RELEASE 01105 tolua_Error tolua_err; 01106 if ( 01107 !tolua_isusertype(tolua_S,1,"const fawkes::RobotinoSensorInterface",0,&tolua_err) || 01108 !tolua_isnoobj(tolua_S,2,&tolua_err) 01109 ) 01110 goto tolua_lerror; 01111 else 01112 #endif 01113 { 01114 const fawkes::RobotinoSensorInterface* self = (const fawkes::RobotinoSensorInterface*) tolua_tousertype(tolua_S,1,0); 01115 #ifndef TOLUA_RELEASE 01116 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datasize'", NULL); 01117 #endif 01118 { 01119 unsigned int tolua_ret = (unsigned int) self->datasize(); 01120 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01121 } 01122 } 01123 return 1; 01124 #ifndef TOLUA_RELEASE 01125 tolua_lerror: 01126 tolua_error(tolua_S,"#ferror in function 'datasize'.",&tolua_err); 01127 return 0; 01128 #endif 01129 } 01130 #endif //#ifndef TOLUA_DISABLE 01131 01132 /* method: type of class fawkes::RobotinoSensorInterface */ 01133 #ifndef TOLUA_DISABLE_tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_type00 01134 static int tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_type00(lua_State* tolua_S) 01135 { 01136 #ifndef TOLUA_RELEASE 01137 tolua_Error tolua_err; 01138 if ( 01139 !tolua_isusertype(tolua_S,1,"const fawkes::RobotinoSensorInterface",0,&tolua_err) || 01140 !tolua_isnoobj(tolua_S,2,&tolua_err) 01141 ) 01142 goto tolua_lerror; 01143 else 01144 #endif 01145 { 01146 const fawkes::RobotinoSensorInterface* self = (const fawkes::RobotinoSensorInterface*) tolua_tousertype(tolua_S,1,0); 01147 #ifndef TOLUA_RELEASE 01148 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'type'", NULL); 01149 #endif 01150 { 01151 const char* tolua_ret = (const char*) self->type(); 01152 tolua_pushstring(tolua_S,(const char*)tolua_ret); 01153 } 01154 } 01155 return 1; 01156 #ifndef TOLUA_RELEASE 01157 tolua_lerror: 01158 tolua_error(tolua_S,"#ferror in function 'type'.",&tolua_err); 01159 return 0; 01160 #endif 01161 } 01162 #endif //#ifndef TOLUA_DISABLE 01163 01164 /* method: id of class fawkes::RobotinoSensorInterface */ 01165 #ifndef TOLUA_DISABLE_tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_id00 01166 static int tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_id00(lua_State* tolua_S) 01167 { 01168 #ifndef TOLUA_RELEASE 01169 tolua_Error tolua_err; 01170 if ( 01171 !tolua_isusertype(tolua_S,1,"const fawkes::RobotinoSensorInterface",0,&tolua_err) || 01172 !tolua_isnoobj(tolua_S,2,&tolua_err) 01173 ) 01174 goto tolua_lerror; 01175 else 01176 #endif 01177 { 01178 const fawkes::RobotinoSensorInterface* self = (const fawkes::RobotinoSensorInterface*) tolua_tousertype(tolua_S,1,0); 01179 #ifndef TOLUA_RELEASE 01180 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'id'", NULL); 01181 #endif 01182 { 01183 const char* tolua_ret = (const char*) self->id(); 01184 tolua_pushstring(tolua_S,(const char*)tolua_ret); 01185 } 01186 } 01187 return 1; 01188 #ifndef TOLUA_RELEASE 01189 tolua_lerror: 01190 tolua_error(tolua_S,"#ferror in function 'id'.",&tolua_err); 01191 return 0; 01192 #endif 01193 } 01194 #endif //#ifndef TOLUA_DISABLE 01195 01196 /* method: uid of class fawkes::RobotinoSensorInterface */ 01197 #ifndef TOLUA_DISABLE_tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_uid00 01198 static int tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_uid00(lua_State* tolua_S) 01199 { 01200 #ifndef TOLUA_RELEASE 01201 tolua_Error tolua_err; 01202 if ( 01203 !tolua_isusertype(tolua_S,1,"const fawkes::RobotinoSensorInterface",0,&tolua_err) || 01204 !tolua_isnoobj(tolua_S,2,&tolua_err) 01205 ) 01206 goto tolua_lerror; 01207 else 01208 #endif 01209 { 01210 const fawkes::RobotinoSensorInterface* self = (const fawkes::RobotinoSensorInterface*) tolua_tousertype(tolua_S,1,0); 01211 #ifndef TOLUA_RELEASE 01212 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'uid'", NULL); 01213 #endif 01214 { 01215 const char* tolua_ret = (const char*) self->uid(); 01216 tolua_pushstring(tolua_S,(const char*)tolua_ret); 01217 } 01218 } 01219 return 1; 01220 #ifndef TOLUA_RELEASE 01221 tolua_lerror: 01222 tolua_error(tolua_S,"#ferror in function 'uid'.",&tolua_err); 01223 return 0; 01224 #endif 01225 } 01226 #endif //#ifndef TOLUA_DISABLE 01227 01228 /* method: serial of class fawkes::RobotinoSensorInterface */ 01229 #ifndef TOLUA_DISABLE_tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_serial00 01230 static int tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_serial00(lua_State* tolua_S) 01231 { 01232 #ifndef TOLUA_RELEASE 01233 tolua_Error tolua_err; 01234 if ( 01235 !tolua_isusertype(tolua_S,1,"const fawkes::RobotinoSensorInterface",0,&tolua_err) || 01236 !tolua_isnoobj(tolua_S,2,&tolua_err) 01237 ) 01238 goto tolua_lerror; 01239 else 01240 #endif 01241 { 01242 const fawkes::RobotinoSensorInterface* self = (const fawkes::RobotinoSensorInterface*) tolua_tousertype(tolua_S,1,0); 01243 #ifndef TOLUA_RELEASE 01244 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'serial'", NULL); 01245 #endif 01246 { 01247 unsigned int tolua_ret = (unsigned int) self->serial(); 01248 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01249 } 01250 } 01251 return 1; 01252 #ifndef TOLUA_RELEASE 01253 tolua_lerror: 01254 tolua_error(tolua_S,"#ferror in function 'serial'.",&tolua_err); 01255 return 0; 01256 #endif 01257 } 01258 #endif //#ifndef TOLUA_DISABLE 01259 01260 /* method: mem_serial of class fawkes::RobotinoSensorInterface */ 01261 #ifndef TOLUA_DISABLE_tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_mem_serial00 01262 static int tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_mem_serial00(lua_State* tolua_S) 01263 { 01264 #ifndef TOLUA_RELEASE 01265 tolua_Error tolua_err; 01266 if ( 01267 !tolua_isusertype(tolua_S,1,"const fawkes::RobotinoSensorInterface",0,&tolua_err) || 01268 !tolua_isnoobj(tolua_S,2,&tolua_err) 01269 ) 01270 goto tolua_lerror; 01271 else 01272 #endif 01273 { 01274 const fawkes::RobotinoSensorInterface* self = (const fawkes::RobotinoSensorInterface*) tolua_tousertype(tolua_S,1,0); 01275 #ifndef TOLUA_RELEASE 01276 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'mem_serial'", NULL); 01277 #endif 01278 { 01279 unsigned int tolua_ret = (unsigned int) self->mem_serial(); 01280 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01281 } 01282 } 01283 return 1; 01284 #ifndef TOLUA_RELEASE 01285 tolua_lerror: 01286 tolua_error(tolua_S,"#ferror in function 'mem_serial'.",&tolua_err); 01287 return 0; 01288 #endif 01289 } 01290 #endif //#ifndef TOLUA_DISABLE 01291 01292 /* method: operator== of class fawkes::RobotinoSensorInterface */ 01293 #ifndef TOLUA_DISABLE_tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface__eq00 01294 static int tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface__eq00(lua_State* tolua_S) 01295 { 01296 #ifndef TOLUA_RELEASE 01297 tolua_Error tolua_err; 01298 if ( 01299 !tolua_isusertype(tolua_S,1,"const fawkes::RobotinoSensorInterface",0,&tolua_err) || 01300 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Interface",0,&tolua_err)) || 01301 !tolua_isnoobj(tolua_S,3,&tolua_err) 01302 ) 01303 goto tolua_lerror; 01304 else 01305 #endif 01306 { 01307 const fawkes::RobotinoSensorInterface* self = (const fawkes::RobotinoSensorInterface*) tolua_tousertype(tolua_S,1,0); 01308 Interface* comp = ((Interface*) tolua_tousertype(tolua_S,2,0)); 01309 #ifndef TOLUA_RELEASE 01310 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='", NULL); 01311 #endif 01312 { 01313 bool tolua_ret = (bool) self->operator==(*comp); 01314 tolua_pushboolean(tolua_S,(bool)tolua_ret); 01315 } 01316 } 01317 return 1; 01318 #ifndef TOLUA_RELEASE 01319 tolua_lerror: 01320 tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err); 01321 return 0; 01322 #endif 01323 } 01324 #endif //#ifndef TOLUA_DISABLE 01325 01326 /* method: hash of class fawkes::RobotinoSensorInterface */ 01327 #ifndef TOLUA_DISABLE_tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_hash00 01328 static int tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_hash00(lua_State* tolua_S) 01329 { 01330 #ifndef TOLUA_RELEASE 01331 tolua_Error tolua_err; 01332 if ( 01333 !tolua_isusertype(tolua_S,1,"const fawkes::RobotinoSensorInterface",0,&tolua_err) || 01334 !tolua_isnoobj(tolua_S,2,&tolua_err) 01335 ) 01336 goto tolua_lerror; 01337 else 01338 #endif 01339 { 01340 const fawkes::RobotinoSensorInterface* self = (const fawkes::RobotinoSensorInterface*) tolua_tousertype(tolua_S,1,0); 01341 #ifndef TOLUA_RELEASE 01342 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash'", NULL); 01343 #endif 01344 { 01345 unsigned const char* tolua_ret = ( unsigned const char*) self->hash(); 01346 tolua_pushstring(tolua_S,(const char*)tolua_ret); 01347 } 01348 } 01349 return 1; 01350 #ifndef TOLUA_RELEASE 01351 tolua_lerror: 01352 tolua_error(tolua_S,"#ferror in function 'hash'.",&tolua_err); 01353 return 0; 01354 #endif 01355 } 01356 #endif //#ifndef TOLUA_DISABLE 01357 01358 /* method: hash_size of class fawkes::RobotinoSensorInterface */ 01359 #ifndef TOLUA_DISABLE_tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_hash_size00 01360 static int tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_hash_size00(lua_State* tolua_S) 01361 { 01362 #ifndef TOLUA_RELEASE 01363 tolua_Error tolua_err; 01364 if ( 01365 !tolua_isusertype(tolua_S,1,"const fawkes::RobotinoSensorInterface",0,&tolua_err) || 01366 !tolua_isnoobj(tolua_S,2,&tolua_err) 01367 ) 01368 goto tolua_lerror; 01369 else 01370 #endif 01371 { 01372 const fawkes::RobotinoSensorInterface* self = (const fawkes::RobotinoSensorInterface*) tolua_tousertype(tolua_S,1,0); 01373 #ifndef TOLUA_RELEASE 01374 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash_size'", NULL); 01375 #endif 01376 { 01377 int tolua_ret = (int) self->hash_size(); 01378 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01379 } 01380 } 01381 return 1; 01382 #ifndef TOLUA_RELEASE 01383 tolua_lerror: 01384 tolua_error(tolua_S,"#ferror in function 'hash_size'.",&tolua_err); 01385 return 0; 01386 #endif 01387 } 01388 #endif //#ifndef TOLUA_DISABLE 01389 01390 /* method: hash_printable of class fawkes::RobotinoSensorInterface */ 01391 #ifndef TOLUA_DISABLE_tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_hash_printable00 01392 static int tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_hash_printable00(lua_State* tolua_S) 01393 { 01394 #ifndef TOLUA_RELEASE 01395 tolua_Error tolua_err; 01396 if ( 01397 !tolua_isusertype(tolua_S,1,"const fawkes::RobotinoSensorInterface",0,&tolua_err) || 01398 !tolua_isnoobj(tolua_S,2,&tolua_err) 01399 ) 01400 goto tolua_lerror; 01401 else 01402 #endif 01403 { 01404 const fawkes::RobotinoSensorInterface* self = (const fawkes::RobotinoSensorInterface*) tolua_tousertype(tolua_S,1,0); 01405 #ifndef TOLUA_RELEASE 01406 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash_printable'", NULL); 01407 #endif 01408 { 01409 const char* tolua_ret = (const char*) self->hash_printable(); 01410 tolua_pushstring(tolua_S,(const char*)tolua_ret); 01411 } 01412 } 01413 return 1; 01414 #ifndef TOLUA_RELEASE 01415 tolua_lerror: 01416 tolua_error(tolua_S,"#ferror in function 'hash_printable'.",&tolua_err); 01417 return 0; 01418 #endif 01419 } 01420 #endif //#ifndef TOLUA_DISABLE 01421 01422 /* method: is_writer of class fawkes::RobotinoSensorInterface */ 01423 #ifndef TOLUA_DISABLE_tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_is_writer00 01424 static int tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_is_writer00(lua_State* tolua_S) 01425 { 01426 #ifndef TOLUA_RELEASE 01427 tolua_Error tolua_err; 01428 if ( 01429 !tolua_isusertype(tolua_S,1,"const fawkes::RobotinoSensorInterface",0,&tolua_err) || 01430 !tolua_isnoobj(tolua_S,2,&tolua_err) 01431 ) 01432 goto tolua_lerror; 01433 else 01434 #endif 01435 { 01436 const fawkes::RobotinoSensorInterface* self = (const fawkes::RobotinoSensorInterface*) tolua_tousertype(tolua_S,1,0); 01437 #ifndef TOLUA_RELEASE 01438 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_writer'", NULL); 01439 #endif 01440 { 01441 bool tolua_ret = (bool) self->is_writer(); 01442 tolua_pushboolean(tolua_S,(bool)tolua_ret); 01443 } 01444 } 01445 return 1; 01446 #ifndef TOLUA_RELEASE 01447 tolua_lerror: 01448 tolua_error(tolua_S,"#ferror in function 'is_writer'.",&tolua_err); 01449 return 0; 01450 #endif 01451 } 01452 #endif //#ifndef TOLUA_DISABLE 01453 01454 /* method: set_from_chunk of class fawkes::RobotinoSensorInterface */ 01455 #ifndef TOLUA_DISABLE_tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_set_from_chunk00 01456 static int tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_set_from_chunk00(lua_State* tolua_S) 01457 { 01458 #ifndef TOLUA_RELEASE 01459 tolua_Error tolua_err; 01460 if ( 01461 !tolua_isusertype(tolua_S,1,"fawkes::RobotinoSensorInterface",0,&tolua_err) || 01462 !tolua_isuserdata(tolua_S,2,0,&tolua_err) || 01463 !tolua_isnoobj(tolua_S,3,&tolua_err) 01464 ) 01465 goto tolua_lerror; 01466 else 01467 #endif 01468 { 01469 fawkes::RobotinoSensorInterface* self = (fawkes::RobotinoSensorInterface*) tolua_tousertype(tolua_S,1,0); 01470 void* chunk = ((void*) tolua_touserdata(tolua_S,2,0)); 01471 #ifndef TOLUA_RELEASE 01472 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_from_chunk'", NULL); 01473 #endif 01474 { 01475 self->set_from_chunk(chunk); 01476 } 01477 } 01478 return 0; 01479 #ifndef TOLUA_RELEASE 01480 tolua_lerror: 01481 tolua_error(tolua_S,"#ferror in function 'set_from_chunk'.",&tolua_err); 01482 return 0; 01483 #endif 01484 } 01485 #endif //#ifndef TOLUA_DISABLE 01486 01487 /* method: create_message of class fawkes::RobotinoSensorInterface */ 01488 #ifndef TOLUA_DISABLE_tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_create_message00 01489 static int tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_create_message00(lua_State* tolua_S) 01490 { 01491 #ifndef TOLUA_RELEASE 01492 tolua_Error tolua_err; 01493 if ( 01494 !tolua_isusertype(tolua_S,1,"const fawkes::RobotinoSensorInterface",0,&tolua_err) || 01495 !tolua_isstring(tolua_S,2,0,&tolua_err) || 01496 !tolua_isnoobj(tolua_S,3,&tolua_err) 01497 ) 01498 goto tolua_lerror; 01499 else 01500 #endif 01501 { 01502 const fawkes::RobotinoSensorInterface* self = (const fawkes::RobotinoSensorInterface*) tolua_tousertype(tolua_S,1,0); 01503 const char* type = ((const char*) tolua_tostring(tolua_S,2,0)); 01504 #ifndef TOLUA_RELEASE 01505 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'create_message'", NULL); 01506 #endif 01507 { 01508 Message* tolua_ret = (Message*) self->create_message(type); 01509 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Message"); 01510 } 01511 } 01512 return 1; 01513 #ifndef TOLUA_RELEASE 01514 tolua_lerror: 01515 tolua_error(tolua_S,"#ferror in function 'create_message'.",&tolua_err); 01516 return 0; 01517 #endif 01518 } 01519 #endif //#ifndef TOLUA_DISABLE 01520 01521 /* method: read of class fawkes::RobotinoSensorInterface */ 01522 #ifndef TOLUA_DISABLE_tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_read00 01523 static int tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_read00(lua_State* tolua_S) 01524 { 01525 #ifndef TOLUA_RELEASE 01526 tolua_Error tolua_err; 01527 if ( 01528 !tolua_isusertype(tolua_S,1,"fawkes::RobotinoSensorInterface",0,&tolua_err) || 01529 !tolua_isnoobj(tolua_S,2,&tolua_err) 01530 ) 01531 goto tolua_lerror; 01532 else 01533 #endif 01534 { 01535 fawkes::RobotinoSensorInterface* self = (fawkes::RobotinoSensorInterface*) tolua_tousertype(tolua_S,1,0); 01536 #ifndef TOLUA_RELEASE 01537 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'read'", NULL); 01538 #endif 01539 { 01540 self->read(); 01541 } 01542 } 01543 return 0; 01544 #ifndef TOLUA_RELEASE 01545 tolua_lerror: 01546 tolua_error(tolua_S,"#ferror in function 'read'.",&tolua_err); 01547 return 0; 01548 #endif 01549 } 01550 #endif //#ifndef TOLUA_DISABLE 01551 01552 /* method: write of class fawkes::RobotinoSensorInterface */ 01553 #ifndef TOLUA_DISABLE_tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_write00 01554 static int tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_write00(lua_State* tolua_S) 01555 { 01556 #ifndef TOLUA_RELEASE 01557 tolua_Error tolua_err; 01558 if ( 01559 !tolua_isusertype(tolua_S,1,"fawkes::RobotinoSensorInterface",0,&tolua_err) || 01560 !tolua_isnoobj(tolua_S,2,&tolua_err) 01561 ) 01562 goto tolua_lerror; 01563 else 01564 #endif 01565 { 01566 fawkes::RobotinoSensorInterface* self = (fawkes::RobotinoSensorInterface*) tolua_tousertype(tolua_S,1,0); 01567 #ifndef TOLUA_RELEASE 01568 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'write'", NULL); 01569 #endif 01570 { 01571 self->write(); 01572 } 01573 } 01574 return 0; 01575 #ifndef TOLUA_RELEASE 01576 tolua_lerror: 01577 tolua_error(tolua_S,"#ferror in function 'write'.",&tolua_err); 01578 return 0; 01579 #endif 01580 } 01581 #endif //#ifndef TOLUA_DISABLE 01582 01583 /* method: has_writer of class fawkes::RobotinoSensorInterface */ 01584 #ifndef TOLUA_DISABLE_tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_has_writer00 01585 static int tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_has_writer00(lua_State* tolua_S) 01586 { 01587 #ifndef TOLUA_RELEASE 01588 tolua_Error tolua_err; 01589 if ( 01590 !tolua_isusertype(tolua_S,1,"const fawkes::RobotinoSensorInterface",0,&tolua_err) || 01591 !tolua_isnoobj(tolua_S,2,&tolua_err) 01592 ) 01593 goto tolua_lerror; 01594 else 01595 #endif 01596 { 01597 const fawkes::RobotinoSensorInterface* self = (const fawkes::RobotinoSensorInterface*) tolua_tousertype(tolua_S,1,0); 01598 #ifndef TOLUA_RELEASE 01599 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'has_writer'", NULL); 01600 #endif 01601 { 01602 bool tolua_ret = (bool) self->has_writer(); 01603 tolua_pushboolean(tolua_S,(bool)tolua_ret); 01604 } 01605 } 01606 return 1; 01607 #ifndef TOLUA_RELEASE 01608 tolua_lerror: 01609 tolua_error(tolua_S,"#ferror in function 'has_writer'.",&tolua_err); 01610 return 0; 01611 #endif 01612 } 01613 #endif //#ifndef TOLUA_DISABLE 01614 01615 /* method: num_readers of class fawkes::RobotinoSensorInterface */ 01616 #ifndef TOLUA_DISABLE_tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_num_readers00 01617 static int tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_num_readers00(lua_State* tolua_S) 01618 { 01619 #ifndef TOLUA_RELEASE 01620 tolua_Error tolua_err; 01621 if ( 01622 !tolua_isusertype(tolua_S,1,"const fawkes::RobotinoSensorInterface",0,&tolua_err) || 01623 !tolua_isnoobj(tolua_S,2,&tolua_err) 01624 ) 01625 goto tolua_lerror; 01626 else 01627 #endif 01628 { 01629 const fawkes::RobotinoSensorInterface* self = (const fawkes::RobotinoSensorInterface*) tolua_tousertype(tolua_S,1,0); 01630 #ifndef TOLUA_RELEASE 01631 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'num_readers'", NULL); 01632 #endif 01633 { 01634 unsigned int tolua_ret = (unsigned int) self->num_readers(); 01635 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01636 } 01637 } 01638 return 1; 01639 #ifndef TOLUA_RELEASE 01640 tolua_lerror: 01641 tolua_error(tolua_S,"#ferror in function 'num_readers'.",&tolua_err); 01642 return 0; 01643 #endif 01644 } 01645 #endif //#ifndef TOLUA_DISABLE 01646 01647 /* method: msgq_enqueue_copy of class fawkes::RobotinoSensorInterface */ 01648 #ifndef TOLUA_DISABLE_tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_msgq_enqueue_copy00 01649 static int tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_msgq_enqueue_copy00(lua_State* tolua_S) 01650 { 01651 #ifndef TOLUA_RELEASE 01652 tolua_Error tolua_err; 01653 if ( 01654 !tolua_isusertype(tolua_S,1,"fawkes::RobotinoSensorInterface",0,&tolua_err) || 01655 !tolua_isusertype(tolua_S,2,"Message",0,&tolua_err) || 01656 !tolua_isnoobj(tolua_S,3,&tolua_err) 01657 ) 01658 goto tolua_lerror; 01659 else 01660 #endif 01661 { 01662 fawkes::RobotinoSensorInterface* self = (fawkes::RobotinoSensorInterface*) tolua_tousertype(tolua_S,1,0); 01663 Message* message = ((Message*) tolua_tousertype(tolua_S,2,0)); 01664 #ifndef TOLUA_RELEASE 01665 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_enqueue_copy'", NULL); 01666 #endif 01667 { 01668 unsigned int tolua_ret = (unsigned int) self->msgq_enqueue_copy(message); 01669 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01670 } 01671 } 01672 return 1; 01673 #ifndef TOLUA_RELEASE 01674 tolua_lerror: 01675 tolua_error(tolua_S,"#ferror in function 'msgq_enqueue_copy'.",&tolua_err); 01676 return 0; 01677 #endif 01678 } 01679 #endif //#ifndef TOLUA_DISABLE 01680 01681 /* method: msgq_remove of class fawkes::RobotinoSensorInterface */ 01682 #ifndef TOLUA_DISABLE_tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_msgq_remove00 01683 static int tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_msgq_remove00(lua_State* tolua_S) 01684 { 01685 #ifndef TOLUA_RELEASE 01686 tolua_Error tolua_err; 01687 if ( 01688 !tolua_isusertype(tolua_S,1,"fawkes::RobotinoSensorInterface",0,&tolua_err) || 01689 !tolua_isusertype(tolua_S,2,"Message",0,&tolua_err) || 01690 !tolua_isnoobj(tolua_S,3,&tolua_err) 01691 ) 01692 goto tolua_lerror; 01693 else 01694 #endif 01695 { 01696 fawkes::RobotinoSensorInterface* self = (fawkes::RobotinoSensorInterface*) tolua_tousertype(tolua_S,1,0); 01697 Message* message = ((Message*) tolua_tousertype(tolua_S,2,0)); 01698 #ifndef TOLUA_RELEASE 01699 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_remove'", NULL); 01700 #endif 01701 { 01702 self->msgq_remove(message); 01703 } 01704 } 01705 return 0; 01706 #ifndef TOLUA_RELEASE 01707 tolua_lerror: 01708 tolua_error(tolua_S,"#ferror in function 'msgq_remove'.",&tolua_err); 01709 return 0; 01710 #endif 01711 } 01712 #endif //#ifndef TOLUA_DISABLE 01713 01714 /* method: msgq_remove of class fawkes::RobotinoSensorInterface */ 01715 #ifndef TOLUA_DISABLE_tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_msgq_remove01 01716 static int tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_msgq_remove01(lua_State* tolua_S) 01717 { 01718 tolua_Error tolua_err; 01719 if ( 01720 !tolua_isusertype(tolua_S,1,"fawkes::RobotinoSensorInterface",0,&tolua_err) || 01721 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 01722 !tolua_isnoobj(tolua_S,3,&tolua_err) 01723 ) 01724 goto tolua_lerror; 01725 else 01726 { 01727 fawkes::RobotinoSensorInterface* self = (fawkes::RobotinoSensorInterface*) tolua_tousertype(tolua_S,1,0); 01728 unsigned int message_id = ((unsigned int) tolua_tonumber(tolua_S,2,0)); 01729 #ifndef TOLUA_RELEASE 01730 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_remove'", NULL); 01731 #endif 01732 { 01733 self->msgq_remove(message_id); 01734 } 01735 } 01736 return 0; 01737 tolua_lerror: 01738 return tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_msgq_remove00(tolua_S); 01739 } 01740 #endif //#ifndef TOLUA_DISABLE 01741 01742 /* method: msgq_size of class fawkes::RobotinoSensorInterface */ 01743 #ifndef TOLUA_DISABLE_tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_msgq_size00 01744 static int tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_msgq_size00(lua_State* tolua_S) 01745 { 01746 #ifndef TOLUA_RELEASE 01747 tolua_Error tolua_err; 01748 if ( 01749 !tolua_isusertype(tolua_S,1,"fawkes::RobotinoSensorInterface",0,&tolua_err) || 01750 !tolua_isnoobj(tolua_S,2,&tolua_err) 01751 ) 01752 goto tolua_lerror; 01753 else 01754 #endif 01755 { 01756 fawkes::RobotinoSensorInterface* self = (fawkes::RobotinoSensorInterface*) tolua_tousertype(tolua_S,1,0); 01757 #ifndef TOLUA_RELEASE 01758 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_size'", NULL); 01759 #endif 01760 { 01761 unsigned int tolua_ret = (unsigned int) self->msgq_size(); 01762 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01763 } 01764 } 01765 return 1; 01766 #ifndef TOLUA_RELEASE 01767 tolua_lerror: 01768 tolua_error(tolua_S,"#ferror in function 'msgq_size'.",&tolua_err); 01769 return 0; 01770 #endif 01771 } 01772 #endif //#ifndef TOLUA_DISABLE 01773 01774 /* method: msgq_flush of class fawkes::RobotinoSensorInterface */ 01775 #ifndef TOLUA_DISABLE_tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_msgq_flush00 01776 static int tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_msgq_flush00(lua_State* tolua_S) 01777 { 01778 #ifndef TOLUA_RELEASE 01779 tolua_Error tolua_err; 01780 if ( 01781 !tolua_isusertype(tolua_S,1,"fawkes::RobotinoSensorInterface",0,&tolua_err) || 01782 !tolua_isnoobj(tolua_S,2,&tolua_err) 01783 ) 01784 goto tolua_lerror; 01785 else 01786 #endif 01787 { 01788 fawkes::RobotinoSensorInterface* self = (fawkes::RobotinoSensorInterface*) tolua_tousertype(tolua_S,1,0); 01789 #ifndef TOLUA_RELEASE 01790 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_flush'", NULL); 01791 #endif 01792 { 01793 self->msgq_flush(); 01794 } 01795 } 01796 return 0; 01797 #ifndef TOLUA_RELEASE 01798 tolua_lerror: 01799 tolua_error(tolua_S,"#ferror in function 'msgq_flush'.",&tolua_err); 01800 return 0; 01801 #endif 01802 } 01803 #endif //#ifndef TOLUA_DISABLE 01804 01805 /* method: msgq_lock of class fawkes::RobotinoSensorInterface */ 01806 #ifndef TOLUA_DISABLE_tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_msgq_lock00 01807 static int tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_msgq_lock00(lua_State* tolua_S) 01808 { 01809 #ifndef TOLUA_RELEASE 01810 tolua_Error tolua_err; 01811 if ( 01812 !tolua_isusertype(tolua_S,1,"fawkes::RobotinoSensorInterface",0,&tolua_err) || 01813 !tolua_isnoobj(tolua_S,2,&tolua_err) 01814 ) 01815 goto tolua_lerror; 01816 else 01817 #endif 01818 { 01819 fawkes::RobotinoSensorInterface* self = (fawkes::RobotinoSensorInterface*) tolua_tousertype(tolua_S,1,0); 01820 #ifndef TOLUA_RELEASE 01821 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_lock'", NULL); 01822 #endif 01823 { 01824 self->msgq_lock(); 01825 } 01826 } 01827 return 0; 01828 #ifndef TOLUA_RELEASE 01829 tolua_lerror: 01830 tolua_error(tolua_S,"#ferror in function 'msgq_lock'.",&tolua_err); 01831 return 0; 01832 #endif 01833 } 01834 #endif //#ifndef TOLUA_DISABLE 01835 01836 /* method: msgq_try_lock of class fawkes::RobotinoSensorInterface */ 01837 #ifndef TOLUA_DISABLE_tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_msgq_try_lock00 01838 static int tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_msgq_try_lock00(lua_State* tolua_S) 01839 { 01840 #ifndef TOLUA_RELEASE 01841 tolua_Error tolua_err; 01842 if ( 01843 !tolua_isusertype(tolua_S,1,"fawkes::RobotinoSensorInterface",0,&tolua_err) || 01844 !tolua_isnoobj(tolua_S,2,&tolua_err) 01845 ) 01846 goto tolua_lerror; 01847 else 01848 #endif 01849 { 01850 fawkes::RobotinoSensorInterface* self = (fawkes::RobotinoSensorInterface*) tolua_tousertype(tolua_S,1,0); 01851 #ifndef TOLUA_RELEASE 01852 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_try_lock'", NULL); 01853 #endif 01854 { 01855 bool tolua_ret = (bool) self->msgq_try_lock(); 01856 tolua_pushboolean(tolua_S,(bool)tolua_ret); 01857 } 01858 } 01859 return 1; 01860 #ifndef TOLUA_RELEASE 01861 tolua_lerror: 01862 tolua_error(tolua_S,"#ferror in function 'msgq_try_lock'.",&tolua_err); 01863 return 0; 01864 #endif 01865 } 01866 #endif //#ifndef TOLUA_DISABLE 01867 01868 /* method: msgq_unlock of class fawkes::RobotinoSensorInterface */ 01869 #ifndef TOLUA_DISABLE_tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_msgq_unlock00 01870 static int tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_msgq_unlock00(lua_State* tolua_S) 01871 { 01872 #ifndef TOLUA_RELEASE 01873 tolua_Error tolua_err; 01874 if ( 01875 !tolua_isusertype(tolua_S,1,"fawkes::RobotinoSensorInterface",0,&tolua_err) || 01876 !tolua_isnoobj(tolua_S,2,&tolua_err) 01877 ) 01878 goto tolua_lerror; 01879 else 01880 #endif 01881 { 01882 fawkes::RobotinoSensorInterface* self = (fawkes::RobotinoSensorInterface*) tolua_tousertype(tolua_S,1,0); 01883 #ifndef TOLUA_RELEASE 01884 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_unlock'", NULL); 01885 #endif 01886 { 01887 self->msgq_unlock(); 01888 } 01889 } 01890 return 0; 01891 #ifndef TOLUA_RELEASE 01892 tolua_lerror: 01893 tolua_error(tolua_S,"#ferror in function 'msgq_unlock'.",&tolua_err); 01894 return 0; 01895 #endif 01896 } 01897 #endif //#ifndef TOLUA_DISABLE 01898 01899 /* method: msgq_pop of class fawkes::RobotinoSensorInterface */ 01900 #ifndef TOLUA_DISABLE_tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_msgq_pop00 01901 static int tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_msgq_pop00(lua_State* tolua_S) 01902 { 01903 #ifndef TOLUA_RELEASE 01904 tolua_Error tolua_err; 01905 if ( 01906 !tolua_isusertype(tolua_S,1,"fawkes::RobotinoSensorInterface",0,&tolua_err) || 01907 !tolua_isnoobj(tolua_S,2,&tolua_err) 01908 ) 01909 goto tolua_lerror; 01910 else 01911 #endif 01912 { 01913 fawkes::RobotinoSensorInterface* self = (fawkes::RobotinoSensorInterface*) tolua_tousertype(tolua_S,1,0); 01914 #ifndef TOLUA_RELEASE 01915 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_pop'", NULL); 01916 #endif 01917 { 01918 self->msgq_pop(); 01919 } 01920 } 01921 return 0; 01922 #ifndef TOLUA_RELEASE 01923 tolua_lerror: 01924 tolua_error(tolua_S,"#ferror in function 'msgq_pop'.",&tolua_err); 01925 return 0; 01926 #endif 01927 } 01928 #endif //#ifndef TOLUA_DISABLE 01929 01930 /* method: msgq_first of class fawkes::RobotinoSensorInterface */ 01931 #ifndef TOLUA_DISABLE_tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_msgq_first00 01932 static int tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_msgq_first00(lua_State* tolua_S) 01933 { 01934 #ifndef TOLUA_RELEASE 01935 tolua_Error tolua_err; 01936 if ( 01937 !tolua_isusertype(tolua_S,1,"fawkes::RobotinoSensorInterface",0,&tolua_err) || 01938 !tolua_isnoobj(tolua_S,2,&tolua_err) 01939 ) 01940 goto tolua_lerror; 01941 else 01942 #endif 01943 { 01944 fawkes::RobotinoSensorInterface* self = (fawkes::RobotinoSensorInterface*) tolua_tousertype(tolua_S,1,0); 01945 #ifndef TOLUA_RELEASE 01946 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_first'", NULL); 01947 #endif 01948 { 01949 Message* tolua_ret = (Message*) self->msgq_first(); 01950 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Message"); 01951 } 01952 } 01953 return 1; 01954 #ifndef TOLUA_RELEASE 01955 tolua_lerror: 01956 tolua_error(tolua_S,"#ferror in function 'msgq_first'.",&tolua_err); 01957 return 0; 01958 #endif 01959 } 01960 #endif //#ifndef TOLUA_DISABLE 01961 01962 /* method: msgq_empty of class fawkes::RobotinoSensorInterface */ 01963 #ifndef TOLUA_DISABLE_tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_msgq_empty00 01964 static int tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_msgq_empty00(lua_State* tolua_S) 01965 { 01966 #ifndef TOLUA_RELEASE 01967 tolua_Error tolua_err; 01968 if ( 01969 !tolua_isusertype(tolua_S,1,"fawkes::RobotinoSensorInterface",0,&tolua_err) || 01970 !tolua_isnoobj(tolua_S,2,&tolua_err) 01971 ) 01972 goto tolua_lerror; 01973 else 01974 #endif 01975 { 01976 fawkes::RobotinoSensorInterface* self = (fawkes::RobotinoSensorInterface*) tolua_tousertype(tolua_S,1,0); 01977 #ifndef TOLUA_RELEASE 01978 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_empty'", NULL); 01979 #endif 01980 { 01981 bool tolua_ret = (bool) self->msgq_empty(); 01982 tolua_pushboolean(tolua_S,(bool)tolua_ret); 01983 } 01984 } 01985 return 1; 01986 #ifndef TOLUA_RELEASE 01987 tolua_lerror: 01988 tolua_error(tolua_S,"#ferror in function 'msgq_empty'.",&tolua_err); 01989 return 0; 01990 #endif 01991 } 01992 #endif //#ifndef TOLUA_DISABLE 01993 01994 /* Open function */ 01995 TOLUA_API int tolua_interfaces_RobotinoSensorInterface_open (lua_State* tolua_S) 01996 { 01997 tolua_open(tolua_S); 01998 tolua_reg_types(tolua_S); 01999 tolua_module(tolua_S,NULL,0); 02000 tolua_beginmodule(tolua_S,NULL); 02001 tolua_module(tolua_S,"fawkes",0); 02002 tolua_beginmodule(tolua_S,"fawkes"); 02003 tolua_cclass(tolua_S,"RobotinoSensorInterface","fawkes::RobotinoSensorInterface","Interface",NULL); 02004 tolua_beginmodule(tolua_S,"RobotinoSensorInterface"); 02005 tolua_function(tolua_S,"mot_velocity",tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_mot_velocity00); 02006 tolua_function(tolua_S,"set_mot_velocity",tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_set_mot_velocity00); 02007 tolua_function(tolua_S,"maxlenof_mot_velocity",tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_maxlenof_mot_velocity00); 02008 tolua_function(tolua_S,"mot_position",tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_mot_position00); 02009 tolua_function(tolua_S,"set_mot_position",tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_set_mot_position00); 02010 tolua_function(tolua_S,"maxlenof_mot_position",tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_maxlenof_mot_position00); 02011 tolua_function(tolua_S,"mot_current",tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_mot_current00); 02012 tolua_function(tolua_S,"set_mot_current",tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_set_mot_current00); 02013 tolua_function(tolua_S,"maxlenof_mot_current",tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_maxlenof_mot_current00); 02014 tolua_function(tolua_S,"is_bumper",tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_is_bumper00); 02015 tolua_function(tolua_S,"set_bumper",tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_set_bumper00); 02016 tolua_function(tolua_S,"maxlenof_bumper",tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_maxlenof_bumper00); 02017 tolua_function(tolua_S,"distance",tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_distance00); 02018 tolua_function(tolua_S,"set_distance",tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_set_distance00); 02019 tolua_function(tolua_S,"maxlenof_distance",tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_maxlenof_distance00); 02020 tolua_function(tolua_S,"is_digital_in",tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_is_digital_in00); 02021 tolua_function(tolua_S,"set_digital_in",tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_set_digital_in00); 02022 tolua_function(tolua_S,"maxlenof_digital_in",tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_maxlenof_digital_in00); 02023 tolua_function(tolua_S,"analog_in",tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_analog_in00); 02024 tolua_function(tolua_S,"set_analog_in",tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_set_analog_in00); 02025 tolua_function(tolua_S,"maxlenof_analog_in",tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_maxlenof_analog_in00); 02026 tolua_function(tolua_S,"is_gyro_available",tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_is_gyro_available00); 02027 tolua_function(tolua_S,"set_gyro_available",tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_set_gyro_available00); 02028 tolua_function(tolua_S,"maxlenof_gyro_available",tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_maxlenof_gyro_available00); 02029 tolua_function(tolua_S,"gyro_angle",tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_gyro_angle00); 02030 tolua_function(tolua_S,"set_gyro_angle",tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_set_gyro_angle00); 02031 tolua_function(tolua_S,"maxlenof_gyro_angle",tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_maxlenof_gyro_angle00); 02032 tolua_function(tolua_S,"gyro_rate",tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_gyro_rate00); 02033 tolua_function(tolua_S,"set_gyro_rate",tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_set_gyro_rate00); 02034 tolua_function(tolua_S,"maxlenof_gyro_rate",tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_maxlenof_gyro_rate00); 02035 tolua_function(tolua_S,"oftype",tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_oftype00); 02036 tolua_function(tolua_S,"datachunk",tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_datachunk00); 02037 tolua_function(tolua_S,"datasize",tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_datasize00); 02038 tolua_function(tolua_S,"type",tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_type00); 02039 tolua_function(tolua_S,"id",tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_id00); 02040 tolua_function(tolua_S,"uid",tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_uid00); 02041 tolua_function(tolua_S,"serial",tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_serial00); 02042 tolua_function(tolua_S,"mem_serial",tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_mem_serial00); 02043 tolua_function(tolua_S,".eq",tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface__eq00); 02044 tolua_function(tolua_S,"hash",tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_hash00); 02045 tolua_function(tolua_S,"hash_size",tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_hash_size00); 02046 tolua_function(tolua_S,"hash_printable",tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_hash_printable00); 02047 tolua_function(tolua_S,"is_writer",tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_is_writer00); 02048 tolua_function(tolua_S,"set_from_chunk",tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_set_from_chunk00); 02049 tolua_function(tolua_S,"create_message",tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_create_message00); 02050 tolua_function(tolua_S,"read",tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_read00); 02051 tolua_function(tolua_S,"write",tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_write00); 02052 tolua_function(tolua_S,"has_writer",tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_has_writer00); 02053 tolua_function(tolua_S,"num_readers",tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_num_readers00); 02054 tolua_function(tolua_S,"msgq_enqueue_copy",tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_msgq_enqueue_copy00); 02055 tolua_function(tolua_S,"msgq_remove",tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_msgq_remove00); 02056 tolua_function(tolua_S,"msgq_remove",tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_msgq_remove01); 02057 tolua_function(tolua_S,"msgq_size",tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_msgq_size00); 02058 tolua_function(tolua_S,"msgq_flush",tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_msgq_flush00); 02059 tolua_function(tolua_S,"msgq_lock",tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_msgq_lock00); 02060 tolua_function(tolua_S,"msgq_try_lock",tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_msgq_try_lock00); 02061 tolua_function(tolua_S,"msgq_unlock",tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_msgq_unlock00); 02062 tolua_function(tolua_S,"msgq_pop",tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_msgq_pop00); 02063 tolua_function(tolua_S,"msgq_first",tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_msgq_first00); 02064 tolua_function(tolua_S,"msgq_empty",tolua_interfaces_RobotinoSensorInterface_fawkes_RobotinoSensorInterface_msgq_empty00); 02065 tolua_endmodule(tolua_S); 02066 tolua_endmodule(tolua_S); 02067 tolua_endmodule(tolua_S); 02068 return 1; 02069 } 02070 02071 02072 extern "C" { 02073 #if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501 02074 TOLUA_API int luaopen_interfaces_RobotinoSensorInterface (lua_State* tolua_S) { 02075 return tolua_interfaces_RobotinoSensorInterface_open(tolua_S); 02076 }; 02077 #endif 02078 } 02079 02080