Fawkes API  Fawkes Development Version
NaoSensorInterface_tolua.cpp
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