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