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