00001 /*
00002 ** Lua binding: interfaces_NavigatorInterface
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_NavigatorInterface_open (lua_State* tolua_S);
00028
00029 #include <interfaces/NavigatorInterface.h>
00030 using namespace fawkes;
00031
00032 /* function to release collected object via destructor */
00033 #ifdef __cplusplus
00034 
00035 static int tolua_collect_fawkes__NavigatorInterface__ObstacleMessage (lua_State* tolua_S)
00036 {
00037  fawkes::NavigatorInterface::ObstacleMessage* self = (fawkes::NavigatorInterface::ObstacleMessage*) tolua_tousertype(tolua_S,1,0);
00038         delete self;
00039         return 0;
00040 }
00041
00042 static int tolua_collect_fawkes__NavigatorInterface__PlaceGotoMessage (lua_State* tolua_S)
00043 {
00044  fawkes::NavigatorInterface::PlaceGotoMessage* self = (fawkes::NavigatorInterface::PlaceGotoMessage*) tolua_tousertype(tolua_S,1,0);
00045         delete self;
00046         return 0;
00047 }
00048
00049 static int tolua_collect_fawkes__NavigatorInterface__CartesianGotoMessage (lua_State* tolua_S)
00050 {
00051  fawkes::NavigatorInterface::CartesianGotoMessage* self = (fawkes::NavigatorInterface::CartesianGotoMessage*) tolua_tousertype(tolua_S,1,0);
00052         delete self;
00053         return 0;
00054 }
00055
00056 static int tolua_collect_fawkes__NavigatorInterface__PolarGotoMessage (lua_State* tolua_S)
00057 {
00058  fawkes::NavigatorInterface::PolarGotoMessage* self = (fawkes::NavigatorInterface::PolarGotoMessage*) tolua_tousertype(tolua_S,1,0);
00059         delete self;
00060         return 0;
00061 }
00062
00063 static int tolua_collect_fawkes__NavigatorInterface__SetSecurityDistanceMessage (lua_State* tolua_S)
00064 {
00065  fawkes::NavigatorInterface::SetSecurityDistanceMessage* self = (fawkes::NavigatorInterface::SetSecurityDistanceMessage*) tolua_tousertype(tolua_S,1,0);
00066         delete self;
00067         return 0;
00068 }
00069
00070 static int tolua_collect_fawkes__NavigatorInterface__StopMessage (lua_State* tolua_S)
00071 {
00072  fawkes::NavigatorInterface::StopMessage* self = (fawkes::NavigatorInterface::StopMessage*) tolua_tousertype(tolua_S,1,0);
00073         delete self;
00074         return 0;
00075 }
00076
00077 static int tolua_collect_fawkes__NavigatorInterface__SetMaxVelocityMessage (lua_State* tolua_S)
00078 {
00079  fawkes::NavigatorInterface::SetMaxVelocityMessage* self = (fawkes::NavigatorInterface::SetMaxVelocityMessage*) tolua_tousertype(tolua_S,1,0);
00080         delete self;
00081         return 0;
00082 }
00083
00084 static int tolua_collect_fawkes__NavigatorInterface__SetEscapingMessage (lua_State* tolua_S)
00085 {
00086  fawkes::NavigatorInterface::SetEscapingMessage* self = (fawkes::NavigatorInterface::SetEscapingMessage*) tolua_tousertype(tolua_S,1,0);
00087         delete self;
00088         return 0;
00089 }
00090
00091 static int tolua_collect_fawkes__NavigatorInterface__TurnMessage (lua_State* tolua_S)
00092 {
00093  fawkes::NavigatorInterface::TurnMessage* self = (fawkes::NavigatorInterface::TurnMessage*) tolua_tousertype(tolua_S,1,0);
00094         delete self;
00095         return 0;
00096 }
00097
00098 static int tolua_collect_fawkes__NavigatorInterface__ResetOdometryMessage (lua_State* tolua_S)
00099 {
00100  fawkes::NavigatorInterface::ResetOdometryMessage* self = (fawkes::NavigatorInterface::ResetOdometryMessage*) tolua_tousertype(tolua_S,1,0);
00101         delete self;
00102         return 0;
00103 }
00104 #endif
00105 
00106
00107 /* function to register type */
00108 static void tolua_reg_types (lua_State* tolua_S)
00109 {
00110  tolua_usertype(tolua_S,"fawkes::NavigatorInterface");
00111  tolua_usertype(tolua_S,"fawkes::NavigatorInterface::ObstacleMessage");
00112  tolua_usertype(tolua_S,"fawkes::NavigatorInterface::PlaceGotoMessage");
00113  tolua_usertype(tolua_S,"fawkes::NavigatorInterface::CartesianGotoMessage");
00114  tolua_usertype(tolua_S,"fawkes::NavigatorInterface::PolarGotoMessage");
00115  tolua_usertype(tolua_S,"Message");
00116  tolua_usertype(tolua_S,"fawkes::NavigatorInterface::SetSecurityDistanceMessage");
00117  tolua_usertype(tolua_S,"fawkes::NavigatorInterface::TurnMessage");
00118  tolua_usertype(tolua_S,"fawkes::NavigatorInterface::SetMaxVelocityMessage");
00119  tolua_usertype(tolua_S,"fawkes::NavigatorInterface::ResetOdometryMessage");
00120  tolua_usertype(tolua_S,"fawkes::NavigatorInterface::SetEscapingMessage");
00121  tolua_usertype(tolua_S,"fawkes::NavigatorInterface::StopMessage");
00122  tolua_usertype(tolua_S,"Interface");
00123 }
00124
00125 /* get function: ERROR_NONE of class  fawkes::NavigatorInterface */
00126 #ifndef TOLUA_DISABLE_tolua_get_fawkes__NavigatorInterface_unsigned_ERROR_NONE
00127 static int tolua_get_fawkes__NavigatorInterface_unsigned_ERROR_NONE(lua_State* tolua_S)
00128 {
00129   tolua_pushnumber(tolua_S,(lua_Number)fawkes::NavigatorInterface::ERROR_NONE);
00130  return 1;
00131 }
00132 #endif //#ifndef TOLUA_DISABLE
00133 
00134 /* get function: ERROR_MOTOR of class  fawkes::NavigatorInterface */
00135 #ifndef TOLUA_DISABLE_tolua_get_fawkes__NavigatorInterface_unsigned_ERROR_MOTOR
00136 static int tolua_get_fawkes__NavigatorInterface_unsigned_ERROR_MOTOR(lua_State* tolua_S)
00137 {
00138   tolua_pushnumber(tolua_S,(lua_Number)fawkes::NavigatorInterface::ERROR_MOTOR);
00139  return 1;
00140 }
00141 #endif //#ifndef TOLUA_DISABLE
00142 
00143 /* get function: ERROR_OBSTRUCTION of class  fawkes::NavigatorInterface */
00144 #ifndef TOLUA_DISABLE_tolua_get_fawkes__NavigatorInterface_unsigned_ERROR_OBSTRUCTION
00145 static int tolua_get_fawkes__NavigatorInterface_unsigned_ERROR_OBSTRUCTION(lua_State* tolua_S)
00146 {
00147   tolua_pushnumber(tolua_S,(lua_Number)fawkes::NavigatorInterface::ERROR_OBSTRUCTION);
00148  return 1;
00149 }
00150 #endif //#ifndef TOLUA_DISABLE
00151 
00152 /* get function: ERROR_UNKNOWN_PLACE of class  fawkes::NavigatorInterface */
00153 #ifndef TOLUA_DISABLE_tolua_get_fawkes__NavigatorInterface_unsigned_ERROR_UNKNOWN_PLACE
00154 static int tolua_get_fawkes__NavigatorInterface_unsigned_ERROR_UNKNOWN_PLACE(lua_State* tolua_S)
00155 {
00156   tolua_pushnumber(tolua_S,(lua_Number)fawkes::NavigatorInterface::ERROR_UNKNOWN_PLACE);
00157  return 1;
00158 }
00159 #endif //#ifndef TOLUA_DISABLE
00160 
00161 /* get function: FLAG_NONE of class  fawkes::NavigatorInterface */
00162 #ifndef TOLUA_DISABLE_tolua_get_fawkes__NavigatorInterface_unsigned_FLAG_NONE
00163 static int tolua_get_fawkes__NavigatorInterface_unsigned_FLAG_NONE(lua_State* tolua_S)
00164 {
00165   tolua_pushnumber(tolua_S,(lua_Number)fawkes::NavigatorInterface::FLAG_NONE);
00166  return 1;
00167 }
00168 #endif //#ifndef TOLUA_DISABLE
00169 
00170 /* get function: FLAG_CART_GOTO of class  fawkes::NavigatorInterface */
00171 #ifndef TOLUA_DISABLE_tolua_get_fawkes__NavigatorInterface_unsigned_FLAG_CART_GOTO
00172 static int tolua_get_fawkes__NavigatorInterface_unsigned_FLAG_CART_GOTO(lua_State* tolua_S)
00173 {
00174   tolua_pushnumber(tolua_S,(lua_Number)fawkes::NavigatorInterface::FLAG_CART_GOTO);
00175  return 1;
00176 }
00177 #endif //#ifndef TOLUA_DISABLE
00178 
00179 /* get function: FLAG_POLAR_GOTO of class  fawkes::NavigatorInterface */
00180 #ifndef TOLUA_DISABLE_tolua_get_fawkes__NavigatorInterface_unsigned_FLAG_POLAR_GOTO
00181 static int tolua_get_fawkes__NavigatorInterface_unsigned_FLAG_POLAR_GOTO(lua_State* tolua_S)
00182 {
00183   tolua_pushnumber(tolua_S,(lua_Number)fawkes::NavigatorInterface::FLAG_POLAR_GOTO);
00184  return 1;
00185 }
00186 #endif //#ifndef TOLUA_DISABLE
00187 
00188 /* get function: FLAG_PLACE_GOTO of class  fawkes::NavigatorInterface */
00189 #ifndef TOLUA_DISABLE_tolua_get_fawkes__NavigatorInterface_unsigned_FLAG_PLACE_GOTO
00190 static int tolua_get_fawkes__NavigatorInterface_unsigned_FLAG_PLACE_GOTO(lua_State* tolua_S)
00191 {
00192   tolua_pushnumber(tolua_S,(lua_Number)fawkes::NavigatorInterface::FLAG_PLACE_GOTO);
00193  return 1;
00194 }
00195 #endif //#ifndef TOLUA_DISABLE
00196 
00197 /* get function: FLAG_UPDATES_DEST_DIST of class  fawkes::NavigatorInterface */
00198 #ifndef TOLUA_DISABLE_tolua_get_fawkes__NavigatorInterface_unsigned_FLAG_UPDATES_DEST_DIST
00199 static int tolua_get_fawkes__NavigatorInterface_unsigned_FLAG_UPDATES_DEST_DIST(lua_State* tolua_S)
00200 {
00201   tolua_pushnumber(tolua_S,(lua_Number)fawkes::NavigatorInterface::FLAG_UPDATES_DEST_DIST);
00202  return 1;
00203 }
00204 #endif //#ifndef TOLUA_DISABLE
00205 
00206 /* get function: FLAG_SECURITY_DISTANCE of class  fawkes::NavigatorInterface */
00207 #ifndef TOLUA_DISABLE_tolua_get_fawkes__NavigatorInterface_unsigned_FLAG_SECURITY_DISTANCE
00208 static int tolua_get_fawkes__NavigatorInterface_unsigned_FLAG_SECURITY_DISTANCE(lua_State* tolua_S)
00209 {
00210   tolua_pushnumber(tolua_S,(lua_Number)fawkes::NavigatorInterface::FLAG_SECURITY_DISTANCE);
00211  return 1;
00212 }
00213 #endif //#ifndef TOLUA_DISABLE
00214 
00215 /* get function: FLAG_ESCAPING of class  fawkes::NavigatorInterface */
00216 #ifndef TOLUA_DISABLE_tolua_get_fawkes__NavigatorInterface_unsigned_FLAG_ESCAPING
00217 static int tolua_get_fawkes__NavigatorInterface_unsigned_FLAG_ESCAPING(lua_State* tolua_S)
00218 {
00219   tolua_pushnumber(tolua_S,(lua_Number)fawkes::NavigatorInterface::FLAG_ESCAPING);
00220  return 1;
00221 }
00222 #endif //#ifndef TOLUA_DISABLE
00223 
00224 /* method: new of class  StopMessage */
00225 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_StopMessage_new00
00226 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_StopMessage_new00(lua_State* tolua_S)
00227 {
00228 #ifndef TOLUA_RELEASE
00229  tolua_Error tolua_err;
00230  if (
00231      !tolua_isusertable(tolua_S,1,"fawkes::NavigatorInterface::StopMessage",0,&tolua_err) ||
00232      !tolua_isnoobj(tolua_S,2,&tolua_err)
00233  )
00234   goto tolua_lerror;
00235  else
00236 #endif
00237  {
00238   {
00239    fawkes::NavigatorInterface::StopMessage* tolua_ret = (fawkes::NavigatorInterface::StopMessage*)  new fawkes::NavigatorInterface::StopMessage();
00240    tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::NavigatorInterface::StopMessage");
00241   }
00242  }
00243  return 1;
00244 #ifndef TOLUA_RELEASE
00245  tolua_lerror:
00246  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00247  return 0;
00248 #endif
00249 }
00250 #endif //#ifndef TOLUA_DISABLE
00251 
00252 /* method: new_local of class  StopMessage */
00253 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_StopMessage_new00_local
00254 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_StopMessage_new00_local(lua_State* tolua_S)
00255 {
00256 #ifndef TOLUA_RELEASE
00257  tolua_Error tolua_err;
00258  if (
00259      !tolua_isusertable(tolua_S,1,"fawkes::NavigatorInterface::StopMessage",0,&tolua_err) ||
00260      !tolua_isnoobj(tolua_S,2,&tolua_err)
00261  )
00262   goto tolua_lerror;
00263  else
00264 #endif
00265  {
00266   {
00267    fawkes::NavigatorInterface::StopMessage* tolua_ret = (fawkes::NavigatorInterface::StopMessage*)  new fawkes::NavigatorInterface::StopMessage();
00268    tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"fawkes::NavigatorInterface::StopMessage");
00269   }
00270  }
00271  return 1;
00272 #ifndef TOLUA_RELEASE
00273  tolua_lerror:
00274  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00275  return 0;
00276 #endif
00277 }
00278 #endif //#ifndef TOLUA_DISABLE
00279 
00280 /* method: delete of class  StopMessage */
00281 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_StopMessage_delete00
00282 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_StopMessage_delete00(lua_State* tolua_S)
00283 {
00284 #ifndef TOLUA_RELEASE
00285  tolua_Error tolua_err;
00286  if (
00287      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface::StopMessage",0,&tolua_err) ||
00288      !tolua_isnoobj(tolua_S,2,&tolua_err)
00289  )
00290   goto tolua_lerror;
00291  else
00292 #endif
00293  {
00294   fawkes::NavigatorInterface::StopMessage* self = (fawkes::NavigatorInterface::StopMessage*)  tolua_tousertype(tolua_S,1,0);
00295 #ifndef TOLUA_RELEASE
00296   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
00297 #endif
00298   delete self;
00299  }
00300  return 0;
00301 #ifndef TOLUA_RELEASE
00302  tolua_lerror:
00303  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
00304  return 0;
00305 #endif
00306 }
00307 #endif //#ifndef TOLUA_DISABLE
00308 
00309 /* method: new of class  TurnMessage */
00310 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_TurnMessage_new00
00311 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_TurnMessage_new00(lua_State* tolua_S)
00312 {
00313 #ifndef TOLUA_RELEASE
00314  tolua_Error tolua_err;
00315  if (
00316      !tolua_isusertable(tolua_S,1,"fawkes::NavigatorInterface::TurnMessage",0,&tolua_err) ||
00317      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00318      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
00319      !tolua_isnoobj(tolua_S,4,&tolua_err)
00320  )
00321   goto tolua_lerror;
00322  else
00323 #endif
00324  {
00325   float ini_angle = ((float)  tolua_tonumber(tolua_S,2,0));
00326   float ini_velocity = ((float)  tolua_tonumber(tolua_S,3,0));
00327   {
00328    fawkes::NavigatorInterface::TurnMessage* tolua_ret = (fawkes::NavigatorInterface::TurnMessage*)  new fawkes::NavigatorInterface::TurnMessage(ini_angle,ini_velocity);
00329    tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::NavigatorInterface::TurnMessage");
00330   }
00331  }
00332  return 1;
00333 #ifndef TOLUA_RELEASE
00334  tolua_lerror:
00335  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00336  return 0;
00337 #endif
00338 }
00339 #endif //#ifndef TOLUA_DISABLE
00340 
00341 /* method: new_local of class  TurnMessage */
00342 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_TurnMessage_new00_local
00343 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_TurnMessage_new00_local(lua_State* tolua_S)
00344 {
00345 #ifndef TOLUA_RELEASE
00346  tolua_Error tolua_err;
00347  if (
00348      !tolua_isusertable(tolua_S,1,"fawkes::NavigatorInterface::TurnMessage",0,&tolua_err) ||
00349      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00350      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
00351      !tolua_isnoobj(tolua_S,4,&tolua_err)
00352  )
00353   goto tolua_lerror;
00354  else
00355 #endif
00356  {
00357   float ini_angle = ((float)  tolua_tonumber(tolua_S,2,0));
00358   float ini_velocity = ((float)  tolua_tonumber(tolua_S,3,0));
00359   {
00360    fawkes::NavigatorInterface::TurnMessage* tolua_ret = (fawkes::NavigatorInterface::TurnMessage*)  new fawkes::NavigatorInterface::TurnMessage(ini_angle,ini_velocity);
00361    tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"fawkes::NavigatorInterface::TurnMessage");
00362   }
00363  }
00364  return 1;
00365 #ifndef TOLUA_RELEASE
00366  tolua_lerror:
00367  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00368  return 0;
00369 #endif
00370 }
00371 #endif //#ifndef TOLUA_DISABLE
00372 
00373 /* method: new of class  TurnMessage */
00374 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_TurnMessage_new01
00375 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_TurnMessage_new01(lua_State* tolua_S)
00376 {
00377  tolua_Error tolua_err;
00378  if (
00379      !tolua_isusertable(tolua_S,1,"fawkes::NavigatorInterface::TurnMessage",0,&tolua_err) ||
00380      !tolua_isnoobj(tolua_S,2,&tolua_err)
00381  )
00382   goto tolua_lerror;
00383  else
00384  {
00385   {
00386    fawkes::NavigatorInterface::TurnMessage* tolua_ret = (fawkes::NavigatorInterface::TurnMessage*)  new fawkes::NavigatorInterface::TurnMessage();
00387    tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::NavigatorInterface::TurnMessage");
00388   }
00389  }
00390  return 1;
00391 tolua_lerror:
00392  return tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_TurnMessage_new00(tolua_S);
00393 }
00394 #endif //#ifndef TOLUA_DISABLE
00395 
00396 /* method: new_local of class  TurnMessage */
00397 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_TurnMessage_new01_local
00398 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_TurnMessage_new01_local(lua_State* tolua_S)
00399 {
00400  tolua_Error tolua_err;
00401  if (
00402      !tolua_isusertable(tolua_S,1,"fawkes::NavigatorInterface::TurnMessage",0,&tolua_err) ||
00403      !tolua_isnoobj(tolua_S,2,&tolua_err)
00404  )
00405   goto tolua_lerror;
00406  else
00407  {
00408   {
00409    fawkes::NavigatorInterface::TurnMessage* tolua_ret = (fawkes::NavigatorInterface::TurnMessage*)  new fawkes::NavigatorInterface::TurnMessage();
00410    tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"fawkes::NavigatorInterface::TurnMessage");
00411   }
00412  }
00413  return 1;
00414 tolua_lerror:
00415  return tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_TurnMessage_new00_local(tolua_S);
00416 }
00417 #endif //#ifndef TOLUA_DISABLE
00418 
00419 /* method: delete of class  TurnMessage */
00420 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_TurnMessage_delete00
00421 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_TurnMessage_delete00(lua_State* tolua_S)
00422 {
00423 #ifndef TOLUA_RELEASE
00424  tolua_Error tolua_err;
00425  if (
00426      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface::TurnMessage",0,&tolua_err) ||
00427      !tolua_isnoobj(tolua_S,2,&tolua_err)
00428  )
00429   goto tolua_lerror;
00430  else
00431 #endif
00432  {
00433   fawkes::NavigatorInterface::TurnMessage* self = (fawkes::NavigatorInterface::TurnMessage*)  tolua_tousertype(tolua_S,1,0);
00434 #ifndef TOLUA_RELEASE
00435   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
00436 #endif
00437   delete self;
00438  }
00439  return 0;
00440 #ifndef TOLUA_RELEASE
00441  tolua_lerror:
00442  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
00443  return 0;
00444 #endif
00445 }
00446 #endif //#ifndef TOLUA_DISABLE
00447 
00448 /* method: angle of class  TurnMessage */
00449 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_TurnMessage_angle00
00450 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_TurnMessage_angle00(lua_State* tolua_S)
00451 {
00452 #ifndef TOLUA_RELEASE
00453  tolua_Error tolua_err;
00454  if (
00455      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface::TurnMessage",0,&tolua_err) ||
00456      !tolua_isnoobj(tolua_S,2,&tolua_err)
00457  )
00458   goto tolua_lerror;
00459  else
00460 #endif
00461  {
00462   fawkes::NavigatorInterface::TurnMessage* self = (fawkes::NavigatorInterface::TurnMessage*)  tolua_tousertype(tolua_S,1,0);
00463 #ifndef TOLUA_RELEASE
00464   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'angle'",NULL);
00465 #endif
00466   {
00467    float tolua_ret = (float)  self->angle();
00468    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00469   }
00470  }
00471  return 1;
00472 #ifndef TOLUA_RELEASE
00473  tolua_lerror:
00474  tolua_error(tolua_S,"#ferror in function 'angle'.",&tolua_err);
00475  return 0;
00476 #endif
00477 }
00478 #endif //#ifndef TOLUA_DISABLE
00479 
00480 /* method: set_angle of class  TurnMessage */
00481 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_TurnMessage_set_angle00
00482 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_TurnMessage_set_angle00(lua_State* tolua_S)
00483 {
00484 #ifndef TOLUA_RELEASE
00485  tolua_Error tolua_err;
00486  if (
00487      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface::TurnMessage",0,&tolua_err) ||
00488      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00489      !tolua_isnoobj(tolua_S,3,&tolua_err)
00490  )
00491   goto tolua_lerror;
00492  else
00493 #endif
00494  {
00495   fawkes::NavigatorInterface::TurnMessage* self = (fawkes::NavigatorInterface::TurnMessage*)  tolua_tousertype(tolua_S,1,0);
00496   const float new_angle = ((const float)  tolua_tonumber(tolua_S,2,0));
00497 #ifndef TOLUA_RELEASE
00498   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_angle'",NULL);
00499 #endif
00500   {
00501    self->set_angle(new_angle);
00502   }
00503  }
00504  return 0;
00505 #ifndef TOLUA_RELEASE
00506  tolua_lerror:
00507  tolua_error(tolua_S,"#ferror in function 'set_angle'.",&tolua_err);
00508  return 0;
00509 #endif
00510 }
00511 #endif //#ifndef TOLUA_DISABLE
00512 
00513 /* method: maxlenof_angle of class  TurnMessage */
00514 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_TurnMessage_maxlenof_angle00
00515 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_TurnMessage_maxlenof_angle00(lua_State* tolua_S)
00516 {
00517 #ifndef TOLUA_RELEASE
00518  tolua_Error tolua_err;
00519  if (
00520      !tolua_isusertype(tolua_S,1,"const fawkes::NavigatorInterface::TurnMessage",0,&tolua_err) ||
00521      !tolua_isnoobj(tolua_S,2,&tolua_err)
00522  )
00523   goto tolua_lerror;
00524  else
00525 #endif
00526  {
00527   const fawkes::NavigatorInterface::TurnMessage* self = (const fawkes::NavigatorInterface::TurnMessage*)  tolua_tousertype(tolua_S,1,0);
00528 #ifndef TOLUA_RELEASE
00529   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_angle'",NULL);
00530 #endif
00531   {
00532    int tolua_ret = (int)  self->maxlenof_angle();
00533    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00534   }
00535  }
00536  return 1;
00537 #ifndef TOLUA_RELEASE
00538  tolua_lerror:
00539  tolua_error(tolua_S,"#ferror in function 'maxlenof_angle'.",&tolua_err);
00540  return 0;
00541 #endif
00542 }
00543 #endif //#ifndef TOLUA_DISABLE
00544 
00545 /* method: velocity of class  TurnMessage */
00546 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_TurnMessage_velocity00
00547 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_TurnMessage_velocity00(lua_State* tolua_S)
00548 {
00549 #ifndef TOLUA_RELEASE
00550  tolua_Error tolua_err;
00551  if (
00552      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface::TurnMessage",0,&tolua_err) ||
00553      !tolua_isnoobj(tolua_S,2,&tolua_err)
00554  )
00555   goto tolua_lerror;
00556  else
00557 #endif
00558  {
00559   fawkes::NavigatorInterface::TurnMessage* self = (fawkes::NavigatorInterface::TurnMessage*)  tolua_tousertype(tolua_S,1,0);
00560 #ifndef TOLUA_RELEASE
00561   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'velocity'",NULL);
00562 #endif
00563   {
00564    float tolua_ret = (float)  self->velocity();
00565    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00566   }
00567  }
00568  return 1;
00569 #ifndef TOLUA_RELEASE
00570  tolua_lerror:
00571  tolua_error(tolua_S,"#ferror in function 'velocity'.",&tolua_err);
00572  return 0;
00573 #endif
00574 }
00575 #endif //#ifndef TOLUA_DISABLE
00576 
00577 /* method: set_velocity of class  TurnMessage */
00578 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_TurnMessage_set_velocity00
00579 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_TurnMessage_set_velocity00(lua_State* tolua_S)
00580 {
00581 #ifndef TOLUA_RELEASE
00582  tolua_Error tolua_err;
00583  if (
00584      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface::TurnMessage",0,&tolua_err) ||
00585      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00586      !tolua_isnoobj(tolua_S,3,&tolua_err)
00587  )
00588   goto tolua_lerror;
00589  else
00590 #endif
00591  {
00592   fawkes::NavigatorInterface::TurnMessage* self = (fawkes::NavigatorInterface::TurnMessage*)  tolua_tousertype(tolua_S,1,0);
00593   const float new_velocity = ((const float)  tolua_tonumber(tolua_S,2,0));
00594 #ifndef TOLUA_RELEASE
00595   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_velocity'",NULL);
00596 #endif
00597   {
00598    self->set_velocity(new_velocity);
00599   }
00600  }
00601  return 0;
00602 #ifndef TOLUA_RELEASE
00603  tolua_lerror:
00604  tolua_error(tolua_S,"#ferror in function 'set_velocity'.",&tolua_err);
00605  return 0;
00606 #endif
00607 }
00608 #endif //#ifndef TOLUA_DISABLE
00609 
00610 /* method: maxlenof_velocity of class  TurnMessage */
00611 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_TurnMessage_maxlenof_velocity00
00612 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_TurnMessage_maxlenof_velocity00(lua_State* tolua_S)
00613 {
00614 #ifndef TOLUA_RELEASE
00615  tolua_Error tolua_err;
00616  if (
00617      !tolua_isusertype(tolua_S,1,"const fawkes::NavigatorInterface::TurnMessage",0,&tolua_err) ||
00618      !tolua_isnoobj(tolua_S,2,&tolua_err)
00619  )
00620   goto tolua_lerror;
00621  else
00622 #endif
00623  {
00624   const fawkes::NavigatorInterface::TurnMessage* self = (const fawkes::NavigatorInterface::TurnMessage*)  tolua_tousertype(tolua_S,1,0);
00625 #ifndef TOLUA_RELEASE
00626   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_velocity'",NULL);
00627 #endif
00628   {
00629    int tolua_ret = (int)  self->maxlenof_velocity();
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_velocity'.",&tolua_err);
00637  return 0;
00638 #endif
00639 }
00640 #endif //#ifndef TOLUA_DISABLE
00641 
00642 /* method: new of class  CartesianGotoMessage */
00643 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_CartesianGotoMessage_new00
00644 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_CartesianGotoMessage_new00(lua_State* tolua_S)
00645 {
00646 #ifndef TOLUA_RELEASE
00647  tolua_Error tolua_err;
00648  if (
00649      !tolua_isusertable(tolua_S,1,"fawkes::NavigatorInterface::CartesianGotoMessage",0,&tolua_err) ||
00650      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00651      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
00652      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
00653      !tolua_isnoobj(tolua_S,5,&tolua_err)
00654  )
00655   goto tolua_lerror;
00656  else
00657 #endif
00658  {
00659   float ini_x = ((float)  tolua_tonumber(tolua_S,2,0));
00660   float ini_y = ((float)  tolua_tonumber(tolua_S,3,0));
00661   float ini_orientation = ((float)  tolua_tonumber(tolua_S,4,0));
00662   {
00663    fawkes::NavigatorInterface::CartesianGotoMessage* tolua_ret = (fawkes::NavigatorInterface::CartesianGotoMessage*)  new fawkes::NavigatorInterface::CartesianGotoMessage(ini_x,ini_y,ini_orientation);
00664    tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::NavigatorInterface::CartesianGotoMessage");
00665   }
00666  }
00667  return 1;
00668 #ifndef TOLUA_RELEASE
00669  tolua_lerror:
00670  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00671  return 0;
00672 #endif
00673 }
00674 #endif //#ifndef TOLUA_DISABLE
00675 
00676 /* method: new_local of class  CartesianGotoMessage */
00677 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_CartesianGotoMessage_new00_local
00678 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_CartesianGotoMessage_new00_local(lua_State* tolua_S)
00679 {
00680 #ifndef TOLUA_RELEASE
00681  tolua_Error tolua_err;
00682  if (
00683      !tolua_isusertable(tolua_S,1,"fawkes::NavigatorInterface::CartesianGotoMessage",0,&tolua_err) ||
00684      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00685      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
00686      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
00687      !tolua_isnoobj(tolua_S,5,&tolua_err)
00688  )
00689   goto tolua_lerror;
00690  else
00691 #endif
00692  {
00693   float ini_x = ((float)  tolua_tonumber(tolua_S,2,0));
00694   float ini_y = ((float)  tolua_tonumber(tolua_S,3,0));
00695   float ini_orientation = ((float)  tolua_tonumber(tolua_S,4,0));
00696   {
00697    fawkes::NavigatorInterface::CartesianGotoMessage* tolua_ret = (fawkes::NavigatorInterface::CartesianGotoMessage*)  new fawkes::NavigatorInterface::CartesianGotoMessage(ini_x,ini_y,ini_orientation);
00698    tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"fawkes::NavigatorInterface::CartesianGotoMessage");
00699   }
00700  }
00701  return 1;
00702 #ifndef TOLUA_RELEASE
00703  tolua_lerror:
00704  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00705  return 0;
00706 #endif
00707 }
00708 #endif //#ifndef TOLUA_DISABLE
00709 
00710 /* method: new of class  CartesianGotoMessage */
00711 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_CartesianGotoMessage_new01
00712 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_CartesianGotoMessage_new01(lua_State* tolua_S)
00713 {
00714  tolua_Error tolua_err;
00715  if (
00716      !tolua_isusertable(tolua_S,1,"fawkes::NavigatorInterface::CartesianGotoMessage",0,&tolua_err) ||
00717      !tolua_isnoobj(tolua_S,2,&tolua_err)
00718  )
00719   goto tolua_lerror;
00720  else
00721  {
00722   {
00723    fawkes::NavigatorInterface::CartesianGotoMessage* tolua_ret = (fawkes::NavigatorInterface::CartesianGotoMessage*)  new fawkes::NavigatorInterface::CartesianGotoMessage();
00724    tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::NavigatorInterface::CartesianGotoMessage");
00725   }
00726  }
00727  return 1;
00728 tolua_lerror:
00729  return tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_CartesianGotoMessage_new00(tolua_S);
00730 }
00731 #endif //#ifndef TOLUA_DISABLE
00732 
00733 /* method: new_local of class  CartesianGotoMessage */
00734 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_CartesianGotoMessage_new01_local
00735 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_CartesianGotoMessage_new01_local(lua_State* tolua_S)
00736 {
00737  tolua_Error tolua_err;
00738  if (
00739      !tolua_isusertable(tolua_S,1,"fawkes::NavigatorInterface::CartesianGotoMessage",0,&tolua_err) ||
00740      !tolua_isnoobj(tolua_S,2,&tolua_err)
00741  )
00742   goto tolua_lerror;
00743  else
00744  {
00745   {
00746    fawkes::NavigatorInterface::CartesianGotoMessage* tolua_ret = (fawkes::NavigatorInterface::CartesianGotoMessage*)  new fawkes::NavigatorInterface::CartesianGotoMessage();
00747    tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"fawkes::NavigatorInterface::CartesianGotoMessage");
00748   }
00749  }
00750  return 1;
00751 tolua_lerror:
00752  return tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_CartesianGotoMessage_new00_local(tolua_S);
00753 }
00754 #endif //#ifndef TOLUA_DISABLE
00755 
00756 /* method: delete of class  CartesianGotoMessage */
00757 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_CartesianGotoMessage_delete00
00758 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_CartesianGotoMessage_delete00(lua_State* tolua_S)
00759 {
00760 #ifndef TOLUA_RELEASE
00761  tolua_Error tolua_err;
00762  if (
00763      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface::CartesianGotoMessage",0,&tolua_err) ||
00764      !tolua_isnoobj(tolua_S,2,&tolua_err)
00765  )
00766   goto tolua_lerror;
00767  else
00768 #endif
00769  {
00770   fawkes::NavigatorInterface::CartesianGotoMessage* self = (fawkes::NavigatorInterface::CartesianGotoMessage*)  tolua_tousertype(tolua_S,1,0);
00771 #ifndef TOLUA_RELEASE
00772   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
00773 #endif
00774   delete self;
00775  }
00776  return 0;
00777 #ifndef TOLUA_RELEASE
00778  tolua_lerror:
00779  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
00780  return 0;
00781 #endif
00782 }
00783 #endif //#ifndef TOLUA_DISABLE
00784 
00785 /* method: x of class  CartesianGotoMessage */
00786 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_CartesianGotoMessage_x00
00787 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_CartesianGotoMessage_x00(lua_State* tolua_S)
00788 {
00789 #ifndef TOLUA_RELEASE
00790  tolua_Error tolua_err;
00791  if (
00792      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface::CartesianGotoMessage",0,&tolua_err) ||
00793      !tolua_isnoobj(tolua_S,2,&tolua_err)
00794  )
00795   goto tolua_lerror;
00796  else
00797 #endif
00798  {
00799   fawkes::NavigatorInterface::CartesianGotoMessage* self = (fawkes::NavigatorInterface::CartesianGotoMessage*)  tolua_tousertype(tolua_S,1,0);
00800 #ifndef TOLUA_RELEASE
00801   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'x'",NULL);
00802 #endif
00803   {
00804    float tolua_ret = (float)  self->x();
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 'x'.",&tolua_err);
00812  return 0;
00813 #endif
00814 }
00815 #endif //#ifndef TOLUA_DISABLE
00816 
00817 /* method: set_x of class  CartesianGotoMessage */
00818 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_CartesianGotoMessage_set_x00
00819 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_CartesianGotoMessage_set_x00(lua_State* tolua_S)
00820 {
00821 #ifndef TOLUA_RELEASE
00822  tolua_Error tolua_err;
00823  if (
00824      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface::CartesianGotoMessage",0,&tolua_err) ||
00825      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00826      !tolua_isnoobj(tolua_S,3,&tolua_err)
00827  )
00828   goto tolua_lerror;
00829  else
00830 #endif
00831  {
00832   fawkes::NavigatorInterface::CartesianGotoMessage* self = (fawkes::NavigatorInterface::CartesianGotoMessage*)  tolua_tousertype(tolua_S,1,0);
00833   const float new_x = ((const float)  tolua_tonumber(tolua_S,2,0));
00834 #ifndef TOLUA_RELEASE
00835   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_x'",NULL);
00836 #endif
00837   {
00838    self->set_x(new_x);
00839   }
00840  }
00841  return 0;
00842 #ifndef TOLUA_RELEASE
00843  tolua_lerror:
00844  tolua_error(tolua_S,"#ferror in function 'set_x'.",&tolua_err);
00845  return 0;
00846 #endif
00847 }
00848 #endif //#ifndef TOLUA_DISABLE
00849 
00850 /* method: maxlenof_x of class  CartesianGotoMessage */
00851 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_CartesianGotoMessage_maxlenof_x00
00852 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_CartesianGotoMessage_maxlenof_x00(lua_State* tolua_S)
00853 {
00854 #ifndef TOLUA_RELEASE
00855  tolua_Error tolua_err;
00856  if (
00857      !tolua_isusertype(tolua_S,1,"const fawkes::NavigatorInterface::CartesianGotoMessage",0,&tolua_err) ||
00858      !tolua_isnoobj(tolua_S,2,&tolua_err)
00859  )
00860   goto tolua_lerror;
00861  else
00862 #endif
00863  {
00864   const fawkes::NavigatorInterface::CartesianGotoMessage* self = (const fawkes::NavigatorInterface::CartesianGotoMessage*)  tolua_tousertype(tolua_S,1,0);
00865 #ifndef TOLUA_RELEASE
00866   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_x'",NULL);
00867 #endif
00868   {
00869    int tolua_ret = (int)  self->maxlenof_x();
00870    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00871   }
00872  }
00873  return 1;
00874 #ifndef TOLUA_RELEASE
00875  tolua_lerror:
00876  tolua_error(tolua_S,"#ferror in function 'maxlenof_x'.",&tolua_err);
00877  return 0;
00878 #endif
00879 }
00880 #endif //#ifndef TOLUA_DISABLE
00881 
00882 /* method: y of class  CartesianGotoMessage */
00883 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_CartesianGotoMessage_y00
00884 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_CartesianGotoMessage_y00(lua_State* tolua_S)
00885 {
00886 #ifndef TOLUA_RELEASE
00887  tolua_Error tolua_err;
00888  if (
00889      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface::CartesianGotoMessage",0,&tolua_err) ||
00890      !tolua_isnoobj(tolua_S,2,&tolua_err)
00891  )
00892   goto tolua_lerror;
00893  else
00894 #endif
00895  {
00896   fawkes::NavigatorInterface::CartesianGotoMessage* self = (fawkes::NavigatorInterface::CartesianGotoMessage*)  tolua_tousertype(tolua_S,1,0);
00897 #ifndef TOLUA_RELEASE
00898   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'y'",NULL);
00899 #endif
00900   {
00901    float tolua_ret = (float)  self->y();
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 'y'.",&tolua_err);
00909  return 0;
00910 #endif
00911 }
00912 #endif //#ifndef TOLUA_DISABLE
00913 
00914 /* method: set_y of class  CartesianGotoMessage */
00915 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_CartesianGotoMessage_set_y00
00916 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_CartesianGotoMessage_set_y00(lua_State* tolua_S)
00917 {
00918 #ifndef TOLUA_RELEASE
00919  tolua_Error tolua_err;
00920  if (
00921      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface::CartesianGotoMessage",0,&tolua_err) ||
00922      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00923      !tolua_isnoobj(tolua_S,3,&tolua_err)
00924  )
00925   goto tolua_lerror;
00926  else
00927 #endif
00928  {
00929   fawkes::NavigatorInterface::CartesianGotoMessage* self = (fawkes::NavigatorInterface::CartesianGotoMessage*)  tolua_tousertype(tolua_S,1,0);
00930   const float new_y = ((const float)  tolua_tonumber(tolua_S,2,0));
00931 #ifndef TOLUA_RELEASE
00932   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_y'",NULL);
00933 #endif
00934   {
00935    self->set_y(new_y);
00936   }
00937  }
00938  return 0;
00939 #ifndef TOLUA_RELEASE
00940  tolua_lerror:
00941  tolua_error(tolua_S,"#ferror in function 'set_y'.",&tolua_err);
00942  return 0;
00943 #endif
00944 }
00945 #endif //#ifndef TOLUA_DISABLE
00946 
00947 /* method: maxlenof_y of class  CartesianGotoMessage */
00948 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_CartesianGotoMessage_maxlenof_y00
00949 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_CartesianGotoMessage_maxlenof_y00(lua_State* tolua_S)
00950 {
00951 #ifndef TOLUA_RELEASE
00952  tolua_Error tolua_err;
00953  if (
00954      !tolua_isusertype(tolua_S,1,"const fawkes::NavigatorInterface::CartesianGotoMessage",0,&tolua_err) ||
00955      !tolua_isnoobj(tolua_S,2,&tolua_err)
00956  )
00957   goto tolua_lerror;
00958  else
00959 #endif
00960  {
00961   const fawkes::NavigatorInterface::CartesianGotoMessage* self = (const fawkes::NavigatorInterface::CartesianGotoMessage*)  tolua_tousertype(tolua_S,1,0);
00962 #ifndef TOLUA_RELEASE
00963   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_y'",NULL);
00964 #endif
00965   {
00966    int tolua_ret = (int)  self->maxlenof_y();
00967    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00968   }
00969  }
00970  return 1;
00971 #ifndef TOLUA_RELEASE
00972  tolua_lerror:
00973  tolua_error(tolua_S,"#ferror in function 'maxlenof_y'.",&tolua_err);
00974  return 0;
00975 #endif
00976 }
00977 #endif //#ifndef TOLUA_DISABLE
00978 
00979 /* method: orientation of class  CartesianGotoMessage */
00980 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_CartesianGotoMessage_orientation00
00981 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_CartesianGotoMessage_orientation00(lua_State* tolua_S)
00982 {
00983 #ifndef TOLUA_RELEASE
00984  tolua_Error tolua_err;
00985  if (
00986      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface::CartesianGotoMessage",0,&tolua_err) ||
00987      !tolua_isnoobj(tolua_S,2,&tolua_err)
00988  )
00989   goto tolua_lerror;
00990  else
00991 #endif
00992  {
00993   fawkes::NavigatorInterface::CartesianGotoMessage* self = (fawkes::NavigatorInterface::CartesianGotoMessage*)  tolua_tousertype(tolua_S,1,0);
00994 #ifndef TOLUA_RELEASE
00995   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'orientation'",NULL);
00996 #endif
00997   {
00998    float tolua_ret = (float)  self->orientation();
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 'orientation'.",&tolua_err);
01006  return 0;
01007 #endif
01008 }
01009 #endif //#ifndef TOLUA_DISABLE
01010 
01011 /* method: set_orientation of class  CartesianGotoMessage */
01012 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_CartesianGotoMessage_set_orientation00
01013 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_CartesianGotoMessage_set_orientation00(lua_State* tolua_S)
01014 {
01015 #ifndef TOLUA_RELEASE
01016  tolua_Error tolua_err;
01017  if (
01018      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface::CartesianGotoMessage",0,&tolua_err) ||
01019      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01020      !tolua_isnoobj(tolua_S,3,&tolua_err)
01021  )
01022   goto tolua_lerror;
01023  else
01024 #endif
01025  {
01026   fawkes::NavigatorInterface::CartesianGotoMessage* self = (fawkes::NavigatorInterface::CartesianGotoMessage*)  tolua_tousertype(tolua_S,1,0);
01027   const float new_orientation = ((const float)  tolua_tonumber(tolua_S,2,0));
01028 #ifndef TOLUA_RELEASE
01029   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_orientation'",NULL);
01030 #endif
01031   {
01032    self->set_orientation(new_orientation);
01033   }
01034  }
01035  return 0;
01036 #ifndef TOLUA_RELEASE
01037  tolua_lerror:
01038  tolua_error(tolua_S,"#ferror in function 'set_orientation'.",&tolua_err);
01039  return 0;
01040 #endif
01041 }
01042 #endif //#ifndef TOLUA_DISABLE
01043 
01044 /* method: maxlenof_orientation of class  CartesianGotoMessage */
01045 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_CartesianGotoMessage_maxlenof_orientation00
01046 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_CartesianGotoMessage_maxlenof_orientation00(lua_State* tolua_S)
01047 {
01048 #ifndef TOLUA_RELEASE
01049  tolua_Error tolua_err;
01050  if (
01051      !tolua_isusertype(tolua_S,1,"const fawkes::NavigatorInterface::CartesianGotoMessage",0,&tolua_err) ||
01052      !tolua_isnoobj(tolua_S,2,&tolua_err)
01053  )
01054   goto tolua_lerror;
01055  else
01056 #endif
01057  {
01058   const fawkes::NavigatorInterface::CartesianGotoMessage* self = (const fawkes::NavigatorInterface::CartesianGotoMessage*)  tolua_tousertype(tolua_S,1,0);
01059 #ifndef TOLUA_RELEASE
01060   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_orientation'",NULL);
01061 #endif
01062   {
01063    int tolua_ret = (int)  self->maxlenof_orientation();
01064    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01065   }
01066  }
01067  return 1;
01068 #ifndef TOLUA_RELEASE
01069  tolua_lerror:
01070  tolua_error(tolua_S,"#ferror in function 'maxlenof_orientation'.",&tolua_err);
01071  return 0;
01072 #endif
01073 }
01074 #endif //#ifndef TOLUA_DISABLE
01075 
01076 /* method: new of class  PolarGotoMessage */
01077 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PolarGotoMessage_new00
01078 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PolarGotoMessage_new00(lua_State* tolua_S)
01079 {
01080 #ifndef TOLUA_RELEASE
01081  tolua_Error tolua_err;
01082  if (
01083      !tolua_isusertable(tolua_S,1,"fawkes::NavigatorInterface::PolarGotoMessage",0,&tolua_err) ||
01084      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01085      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
01086      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
01087      !tolua_isnoobj(tolua_S,5,&tolua_err)
01088  )
01089   goto tolua_lerror;
01090  else
01091 #endif
01092  {
01093   float ini_phi = ((float)  tolua_tonumber(tolua_S,2,0));
01094   float ini_dist = ((float)  tolua_tonumber(tolua_S,3,0));
01095   float ini_orientation = ((float)  tolua_tonumber(tolua_S,4,0));
01096   {
01097    fawkes::NavigatorInterface::PolarGotoMessage* tolua_ret = (fawkes::NavigatorInterface::PolarGotoMessage*)  new fawkes::NavigatorInterface::PolarGotoMessage(ini_phi,ini_dist,ini_orientation);
01098    tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::NavigatorInterface::PolarGotoMessage");
01099   }
01100  }
01101  return 1;
01102 #ifndef TOLUA_RELEASE
01103  tolua_lerror:
01104  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
01105  return 0;
01106 #endif
01107 }
01108 #endif //#ifndef TOLUA_DISABLE
01109 
01110 /* method: new_local of class  PolarGotoMessage */
01111 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PolarGotoMessage_new00_local
01112 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PolarGotoMessage_new00_local(lua_State* tolua_S)
01113 {
01114 #ifndef TOLUA_RELEASE
01115  tolua_Error tolua_err;
01116  if (
01117      !tolua_isusertable(tolua_S,1,"fawkes::NavigatorInterface::PolarGotoMessage",0,&tolua_err) ||
01118      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01119      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
01120      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
01121      !tolua_isnoobj(tolua_S,5,&tolua_err)
01122  )
01123   goto tolua_lerror;
01124  else
01125 #endif
01126  {
01127   float ini_phi = ((float)  tolua_tonumber(tolua_S,2,0));
01128   float ini_dist = ((float)  tolua_tonumber(tolua_S,3,0));
01129   float ini_orientation = ((float)  tolua_tonumber(tolua_S,4,0));
01130   {
01131    fawkes::NavigatorInterface::PolarGotoMessage* tolua_ret = (fawkes::NavigatorInterface::PolarGotoMessage*)  new fawkes::NavigatorInterface::PolarGotoMessage(ini_phi,ini_dist,ini_orientation);
01132    tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"fawkes::NavigatorInterface::PolarGotoMessage");
01133   }
01134  }
01135  return 1;
01136 #ifndef TOLUA_RELEASE
01137  tolua_lerror:
01138  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
01139  return 0;
01140 #endif
01141 }
01142 #endif //#ifndef TOLUA_DISABLE
01143 
01144 /* method: new of class  PolarGotoMessage */
01145 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PolarGotoMessage_new01
01146 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PolarGotoMessage_new01(lua_State* tolua_S)
01147 {
01148  tolua_Error tolua_err;
01149  if (
01150      !tolua_isusertable(tolua_S,1,"fawkes::NavigatorInterface::PolarGotoMessage",0,&tolua_err) ||
01151      !tolua_isnoobj(tolua_S,2,&tolua_err)
01152  )
01153   goto tolua_lerror;
01154  else
01155  {
01156   {
01157    fawkes::NavigatorInterface::PolarGotoMessage* tolua_ret = (fawkes::NavigatorInterface::PolarGotoMessage*)  new fawkes::NavigatorInterface::PolarGotoMessage();
01158    tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::NavigatorInterface::PolarGotoMessage");
01159   }
01160  }
01161  return 1;
01162 tolua_lerror:
01163  return tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PolarGotoMessage_new00(tolua_S);
01164 }
01165 #endif //#ifndef TOLUA_DISABLE
01166 
01167 /* method: new_local of class  PolarGotoMessage */
01168 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PolarGotoMessage_new01_local
01169 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PolarGotoMessage_new01_local(lua_State* tolua_S)
01170 {
01171  tolua_Error tolua_err;
01172  if (
01173      !tolua_isusertable(tolua_S,1,"fawkes::NavigatorInterface::PolarGotoMessage",0,&tolua_err) ||
01174      !tolua_isnoobj(tolua_S,2,&tolua_err)
01175  )
01176   goto tolua_lerror;
01177  else
01178  {
01179   {
01180    fawkes::NavigatorInterface::PolarGotoMessage* tolua_ret = (fawkes::NavigatorInterface::PolarGotoMessage*)  new fawkes::NavigatorInterface::PolarGotoMessage();
01181    tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"fawkes::NavigatorInterface::PolarGotoMessage");
01182   }
01183  }
01184  return 1;
01185 tolua_lerror:
01186  return tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PolarGotoMessage_new00_local(tolua_S);
01187 }
01188 #endif //#ifndef TOLUA_DISABLE
01189 
01190 /* method: delete of class  PolarGotoMessage */
01191 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PolarGotoMessage_delete00
01192 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PolarGotoMessage_delete00(lua_State* tolua_S)
01193 {
01194 #ifndef TOLUA_RELEASE
01195  tolua_Error tolua_err;
01196  if (
01197      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface::PolarGotoMessage",0,&tolua_err) ||
01198      !tolua_isnoobj(tolua_S,2,&tolua_err)
01199  )
01200   goto tolua_lerror;
01201  else
01202 #endif
01203  {
01204   fawkes::NavigatorInterface::PolarGotoMessage* self = (fawkes::NavigatorInterface::PolarGotoMessage*)  tolua_tousertype(tolua_S,1,0);
01205 #ifndef TOLUA_RELEASE
01206   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
01207 #endif
01208   delete self;
01209  }
01210  return 0;
01211 #ifndef TOLUA_RELEASE
01212  tolua_lerror:
01213  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
01214  return 0;
01215 #endif
01216 }
01217 #endif //#ifndef TOLUA_DISABLE
01218 
01219 /* method: phi of class  PolarGotoMessage */
01220 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PolarGotoMessage_phi00
01221 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PolarGotoMessage_phi00(lua_State* tolua_S)
01222 {
01223 #ifndef TOLUA_RELEASE
01224  tolua_Error tolua_err;
01225  if (
01226      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface::PolarGotoMessage",0,&tolua_err) ||
01227      !tolua_isnoobj(tolua_S,2,&tolua_err)
01228  )
01229   goto tolua_lerror;
01230  else
01231 #endif
01232  {
01233   fawkes::NavigatorInterface::PolarGotoMessage* self = (fawkes::NavigatorInterface::PolarGotoMessage*)  tolua_tousertype(tolua_S,1,0);
01234 #ifndef TOLUA_RELEASE
01235   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'phi'",NULL);
01236 #endif
01237   {
01238    float tolua_ret = (float)  self->phi();
01239    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01240   }
01241  }
01242  return 1;
01243 #ifndef TOLUA_RELEASE
01244  tolua_lerror:
01245  tolua_error(tolua_S,"#ferror in function 'phi'.",&tolua_err);
01246  return 0;
01247 #endif
01248 }
01249 #endif //#ifndef TOLUA_DISABLE
01250 
01251 /* method: set_phi of class  PolarGotoMessage */
01252 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PolarGotoMessage_set_phi00
01253 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PolarGotoMessage_set_phi00(lua_State* tolua_S)
01254 {
01255 #ifndef TOLUA_RELEASE
01256  tolua_Error tolua_err;
01257  if (
01258      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface::PolarGotoMessage",0,&tolua_err) ||
01259      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01260      !tolua_isnoobj(tolua_S,3,&tolua_err)
01261  )
01262   goto tolua_lerror;
01263  else
01264 #endif
01265  {
01266   fawkes::NavigatorInterface::PolarGotoMessage* self = (fawkes::NavigatorInterface::PolarGotoMessage*)  tolua_tousertype(tolua_S,1,0);
01267   const float new_phi = ((const float)  tolua_tonumber(tolua_S,2,0));
01268 #ifndef TOLUA_RELEASE
01269   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_phi'",NULL);
01270 #endif
01271   {
01272    self->set_phi(new_phi);
01273   }
01274  }
01275  return 0;
01276 #ifndef TOLUA_RELEASE
01277  tolua_lerror:
01278  tolua_error(tolua_S,"#ferror in function 'set_phi'.",&tolua_err);
01279  return 0;
01280 #endif
01281 }
01282 #endif //#ifndef TOLUA_DISABLE
01283 
01284 /* method: maxlenof_phi of class  PolarGotoMessage */
01285 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PolarGotoMessage_maxlenof_phi00
01286 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PolarGotoMessage_maxlenof_phi00(lua_State* tolua_S)
01287 {
01288 #ifndef TOLUA_RELEASE
01289  tolua_Error tolua_err;
01290  if (
01291      !tolua_isusertype(tolua_S,1,"const fawkes::NavigatorInterface::PolarGotoMessage",0,&tolua_err) ||
01292      !tolua_isnoobj(tolua_S,2,&tolua_err)
01293  )
01294   goto tolua_lerror;
01295  else
01296 #endif
01297  {
01298   const fawkes::NavigatorInterface::PolarGotoMessage* self = (const fawkes::NavigatorInterface::PolarGotoMessage*)  tolua_tousertype(tolua_S,1,0);
01299 #ifndef TOLUA_RELEASE
01300   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_phi'",NULL);
01301 #endif
01302   {
01303    int tolua_ret = (int)  self->maxlenof_phi();
01304    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01305   }
01306  }
01307  return 1;
01308 #ifndef TOLUA_RELEASE
01309  tolua_lerror:
01310  tolua_error(tolua_S,"#ferror in function 'maxlenof_phi'.",&tolua_err);
01311  return 0;
01312 #endif
01313 }
01314 #endif //#ifndef TOLUA_DISABLE
01315 
01316 /* method: dist of class  PolarGotoMessage */
01317 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PolarGotoMessage_dist00
01318 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PolarGotoMessage_dist00(lua_State* tolua_S)
01319 {
01320 #ifndef TOLUA_RELEASE
01321  tolua_Error tolua_err;
01322  if (
01323      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface::PolarGotoMessage",0,&tolua_err) ||
01324      !tolua_isnoobj(tolua_S,2,&tolua_err)
01325  )
01326   goto tolua_lerror;
01327  else
01328 #endif
01329  {
01330   fawkes::NavigatorInterface::PolarGotoMessage* self = (fawkes::NavigatorInterface::PolarGotoMessage*)  tolua_tousertype(tolua_S,1,0);
01331 #ifndef TOLUA_RELEASE
01332   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'dist'",NULL);
01333 #endif
01334   {
01335    float tolua_ret = (float)  self->dist();
01336    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01337   }
01338  }
01339  return 1;
01340 #ifndef TOLUA_RELEASE
01341  tolua_lerror:
01342  tolua_error(tolua_S,"#ferror in function 'dist'.",&tolua_err);
01343  return 0;
01344 #endif
01345 }
01346 #endif //#ifndef TOLUA_DISABLE
01347 
01348 /* method: set_dist of class  PolarGotoMessage */
01349 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PolarGotoMessage_set_dist00
01350 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PolarGotoMessage_set_dist00(lua_State* tolua_S)
01351 {
01352 #ifndef TOLUA_RELEASE
01353  tolua_Error tolua_err;
01354  if (
01355      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface::PolarGotoMessage",0,&tolua_err) ||
01356      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01357      !tolua_isnoobj(tolua_S,3,&tolua_err)
01358  )
01359   goto tolua_lerror;
01360  else
01361 #endif
01362  {
01363   fawkes::NavigatorInterface::PolarGotoMessage* self = (fawkes::NavigatorInterface::PolarGotoMessage*)  tolua_tousertype(tolua_S,1,0);
01364   const float new_dist = ((const float)  tolua_tonumber(tolua_S,2,0));
01365 #ifndef TOLUA_RELEASE
01366   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_dist'",NULL);
01367 #endif
01368   {
01369    self->set_dist(new_dist);
01370   }
01371  }
01372  return 0;
01373 #ifndef TOLUA_RELEASE
01374  tolua_lerror:
01375  tolua_error(tolua_S,"#ferror in function 'set_dist'.",&tolua_err);
01376  return 0;
01377 #endif
01378 }
01379 #endif //#ifndef TOLUA_DISABLE
01380 
01381 /* method: maxlenof_dist of class  PolarGotoMessage */
01382 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PolarGotoMessage_maxlenof_dist00
01383 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PolarGotoMessage_maxlenof_dist00(lua_State* tolua_S)
01384 {
01385 #ifndef TOLUA_RELEASE
01386  tolua_Error tolua_err;
01387  if (
01388      !tolua_isusertype(tolua_S,1,"const fawkes::NavigatorInterface::PolarGotoMessage",0,&tolua_err) ||
01389      !tolua_isnoobj(tolua_S,2,&tolua_err)
01390  )
01391   goto tolua_lerror;
01392  else
01393 #endif
01394  {
01395   const fawkes::NavigatorInterface::PolarGotoMessage* self = (const fawkes::NavigatorInterface::PolarGotoMessage*)  tolua_tousertype(tolua_S,1,0);
01396 #ifndef TOLUA_RELEASE
01397   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_dist'",NULL);
01398 #endif
01399   {
01400    int tolua_ret = (int)  self->maxlenof_dist();
01401    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01402   }
01403  }
01404  return 1;
01405 #ifndef TOLUA_RELEASE
01406  tolua_lerror:
01407  tolua_error(tolua_S,"#ferror in function 'maxlenof_dist'.",&tolua_err);
01408  return 0;
01409 #endif
01410 }
01411 #endif //#ifndef TOLUA_DISABLE
01412 
01413 /* method: orientation of class  PolarGotoMessage */
01414 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PolarGotoMessage_orientation00
01415 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PolarGotoMessage_orientation00(lua_State* tolua_S)
01416 {
01417 #ifndef TOLUA_RELEASE
01418  tolua_Error tolua_err;
01419  if (
01420      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface::PolarGotoMessage",0,&tolua_err) ||
01421      !tolua_isnoobj(tolua_S,2,&tolua_err)
01422  )
01423   goto tolua_lerror;
01424  else
01425 #endif
01426  {
01427   fawkes::NavigatorInterface::PolarGotoMessage* self = (fawkes::NavigatorInterface::PolarGotoMessage*)  tolua_tousertype(tolua_S,1,0);
01428 #ifndef TOLUA_RELEASE
01429   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'orientation'",NULL);
01430 #endif
01431   {
01432    float tolua_ret = (float)  self->orientation();
01433    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01434   }
01435  }
01436  return 1;
01437 #ifndef TOLUA_RELEASE
01438  tolua_lerror:
01439  tolua_error(tolua_S,"#ferror in function 'orientation'.",&tolua_err);
01440  return 0;
01441 #endif
01442 }
01443 #endif //#ifndef TOLUA_DISABLE
01444 
01445 /* method: set_orientation of class  PolarGotoMessage */
01446 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PolarGotoMessage_set_orientation00
01447 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PolarGotoMessage_set_orientation00(lua_State* tolua_S)
01448 {
01449 #ifndef TOLUA_RELEASE
01450  tolua_Error tolua_err;
01451  if (
01452      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface::PolarGotoMessage",0,&tolua_err) ||
01453      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01454      !tolua_isnoobj(tolua_S,3,&tolua_err)
01455  )
01456   goto tolua_lerror;
01457  else
01458 #endif
01459  {
01460   fawkes::NavigatorInterface::PolarGotoMessage* self = (fawkes::NavigatorInterface::PolarGotoMessage*)  tolua_tousertype(tolua_S,1,0);
01461   const float new_orientation = ((const float)  tolua_tonumber(tolua_S,2,0));
01462 #ifndef TOLUA_RELEASE
01463   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_orientation'",NULL);
01464 #endif
01465   {
01466    self->set_orientation(new_orientation);
01467   }
01468  }
01469  return 0;
01470 #ifndef TOLUA_RELEASE
01471  tolua_lerror:
01472  tolua_error(tolua_S,"#ferror in function 'set_orientation'.",&tolua_err);
01473  return 0;
01474 #endif
01475 }
01476 #endif //#ifndef TOLUA_DISABLE
01477 
01478 /* method: maxlenof_orientation of class  PolarGotoMessage */
01479 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PolarGotoMessage_maxlenof_orientation00
01480 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PolarGotoMessage_maxlenof_orientation00(lua_State* tolua_S)
01481 {
01482 #ifndef TOLUA_RELEASE
01483  tolua_Error tolua_err;
01484  if (
01485      !tolua_isusertype(tolua_S,1,"const fawkes::NavigatorInterface::PolarGotoMessage",0,&tolua_err) ||
01486      !tolua_isnoobj(tolua_S,2,&tolua_err)
01487  )
01488   goto tolua_lerror;
01489  else
01490 #endif
01491  {
01492   const fawkes::NavigatorInterface::PolarGotoMessage* self = (const fawkes::NavigatorInterface::PolarGotoMessage*)  tolua_tousertype(tolua_S,1,0);
01493 #ifndef TOLUA_RELEASE
01494   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_orientation'",NULL);
01495 #endif
01496   {
01497    int tolua_ret = (int)  self->maxlenof_orientation();
01498    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01499   }
01500  }
01501  return 1;
01502 #ifndef TOLUA_RELEASE
01503  tolua_lerror:
01504  tolua_error(tolua_S,"#ferror in function 'maxlenof_orientation'.",&tolua_err);
01505  return 0;
01506 #endif
01507 }
01508 #endif //#ifndef TOLUA_DISABLE
01509 
01510 /* method: new of class  PlaceGotoMessage */
01511 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PlaceGotoMessage_new00
01512 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PlaceGotoMessage_new00(lua_State* tolua_S)
01513 {
01514 #ifndef TOLUA_RELEASE
01515  tolua_Error tolua_err;
01516  if (
01517      !tolua_isusertable(tolua_S,1,"fawkes::NavigatorInterface::PlaceGotoMessage",0,&tolua_err) ||
01518      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
01519      !tolua_isnoobj(tolua_S,3,&tolua_err)
01520  )
01521   goto tolua_lerror;
01522  else
01523 #endif
01524  {
01525   char* ini_place = ((char*)  tolua_tostring(tolua_S,2,0));
01526   {
01527    fawkes::NavigatorInterface::PlaceGotoMessage* tolua_ret = (fawkes::NavigatorInterface::PlaceGotoMessage*)  new fawkes::NavigatorInterface::PlaceGotoMessage(ini_place);
01528    tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::NavigatorInterface::PlaceGotoMessage");
01529   }
01530  }
01531  return 1;
01532 #ifndef TOLUA_RELEASE
01533  tolua_lerror:
01534  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
01535  return 0;
01536 #endif
01537 }
01538 #endif //#ifndef TOLUA_DISABLE
01539 
01540 /* method: new_local of class  PlaceGotoMessage */
01541 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PlaceGotoMessage_new00_local
01542 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PlaceGotoMessage_new00_local(lua_State* tolua_S)
01543 {
01544 #ifndef TOLUA_RELEASE
01545  tolua_Error tolua_err;
01546  if (
01547      !tolua_isusertable(tolua_S,1,"fawkes::NavigatorInterface::PlaceGotoMessage",0,&tolua_err) ||
01548      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
01549      !tolua_isnoobj(tolua_S,3,&tolua_err)
01550  )
01551   goto tolua_lerror;
01552  else
01553 #endif
01554  {
01555   char* ini_place = ((char*)  tolua_tostring(tolua_S,2,0));
01556   {
01557    fawkes::NavigatorInterface::PlaceGotoMessage* tolua_ret = (fawkes::NavigatorInterface::PlaceGotoMessage*)  new fawkes::NavigatorInterface::PlaceGotoMessage(ini_place);
01558    tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"fawkes::NavigatorInterface::PlaceGotoMessage");
01559   }
01560  }
01561  return 1;
01562 #ifndef TOLUA_RELEASE
01563  tolua_lerror:
01564  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
01565  return 0;
01566 #endif
01567 }
01568 #endif //#ifndef TOLUA_DISABLE
01569 
01570 /* method: new of class  PlaceGotoMessage */
01571 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PlaceGotoMessage_new01
01572 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PlaceGotoMessage_new01(lua_State* tolua_S)
01573 {
01574  tolua_Error tolua_err;
01575  if (
01576      !tolua_isusertable(tolua_S,1,"fawkes::NavigatorInterface::PlaceGotoMessage",0,&tolua_err) ||
01577      !tolua_isnoobj(tolua_S,2,&tolua_err)
01578  )
01579   goto tolua_lerror;
01580  else
01581  {
01582   {
01583    fawkes::NavigatorInterface::PlaceGotoMessage* tolua_ret = (fawkes::NavigatorInterface::PlaceGotoMessage*)  new fawkes::NavigatorInterface::PlaceGotoMessage();
01584    tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::NavigatorInterface::PlaceGotoMessage");
01585   }
01586  }
01587  return 1;
01588 tolua_lerror:
01589  return tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PlaceGotoMessage_new00(tolua_S);
01590 }
01591 #endif //#ifndef TOLUA_DISABLE
01592 
01593 /* method: new_local of class  PlaceGotoMessage */
01594 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PlaceGotoMessage_new01_local
01595 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PlaceGotoMessage_new01_local(lua_State* tolua_S)
01596 {
01597  tolua_Error tolua_err;
01598  if (
01599      !tolua_isusertable(tolua_S,1,"fawkes::NavigatorInterface::PlaceGotoMessage",0,&tolua_err) ||
01600      !tolua_isnoobj(tolua_S,2,&tolua_err)
01601  )
01602   goto tolua_lerror;
01603  else
01604  {
01605   {
01606    fawkes::NavigatorInterface::PlaceGotoMessage* tolua_ret = (fawkes::NavigatorInterface::PlaceGotoMessage*)  new fawkes::NavigatorInterface::PlaceGotoMessage();
01607    tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"fawkes::NavigatorInterface::PlaceGotoMessage");
01608   }
01609  }
01610  return 1;
01611 tolua_lerror:
01612  return tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PlaceGotoMessage_new00_local(tolua_S);
01613 }
01614 #endif //#ifndef TOLUA_DISABLE
01615 
01616 /* method: delete of class  PlaceGotoMessage */
01617 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PlaceGotoMessage_delete00
01618 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PlaceGotoMessage_delete00(lua_State* tolua_S)
01619 {
01620 #ifndef TOLUA_RELEASE
01621  tolua_Error tolua_err;
01622  if (
01623      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface::PlaceGotoMessage",0,&tolua_err) ||
01624      !tolua_isnoobj(tolua_S,2,&tolua_err)
01625  )
01626   goto tolua_lerror;
01627  else
01628 #endif
01629  {
01630   fawkes::NavigatorInterface::PlaceGotoMessage* self = (fawkes::NavigatorInterface::PlaceGotoMessage*)  tolua_tousertype(tolua_S,1,0);
01631 #ifndef TOLUA_RELEASE
01632   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
01633 #endif
01634   delete self;
01635  }
01636  return 0;
01637 #ifndef TOLUA_RELEASE
01638  tolua_lerror:
01639  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
01640  return 0;
01641 #endif
01642 }
01643 #endif //#ifndef TOLUA_DISABLE
01644 
01645 /* method: place of class  PlaceGotoMessage */
01646 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PlaceGotoMessage_place00
01647 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PlaceGotoMessage_place00(lua_State* tolua_S)
01648 {
01649 #ifndef TOLUA_RELEASE
01650  tolua_Error tolua_err;
01651  if (
01652      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface::PlaceGotoMessage",0,&tolua_err) ||
01653      !tolua_isnoobj(tolua_S,2,&tolua_err)
01654  )
01655   goto tolua_lerror;
01656  else
01657 #endif
01658  {
01659   fawkes::NavigatorInterface::PlaceGotoMessage* self = (fawkes::NavigatorInterface::PlaceGotoMessage*)  tolua_tousertype(tolua_S,1,0);
01660 #ifndef TOLUA_RELEASE
01661   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'place'",NULL);
01662 #endif
01663   {
01664    char* tolua_ret = (char*)  self->place();
01665    tolua_pushstring(tolua_S,(const char*)tolua_ret);
01666   }
01667  }
01668  return 1;
01669 #ifndef TOLUA_RELEASE
01670  tolua_lerror:
01671  tolua_error(tolua_S,"#ferror in function 'place'.",&tolua_err);
01672  return 0;
01673 #endif
01674 }
01675 #endif //#ifndef TOLUA_DISABLE
01676 
01677 /* method: set_place of class  PlaceGotoMessage */
01678 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PlaceGotoMessage_set_place00
01679 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PlaceGotoMessage_set_place00(lua_State* tolua_S)
01680 {
01681 #ifndef TOLUA_RELEASE
01682  tolua_Error tolua_err;
01683  if (
01684      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface::PlaceGotoMessage",0,&tolua_err) ||
01685      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
01686      !tolua_isnoobj(tolua_S,3,&tolua_err)
01687  )
01688   goto tolua_lerror;
01689  else
01690 #endif
01691  {
01692   fawkes::NavigatorInterface::PlaceGotoMessage* self = (fawkes::NavigatorInterface::PlaceGotoMessage*)  tolua_tousertype(tolua_S,1,0);
01693   const char* new_place = ((const char*)  tolua_tostring(tolua_S,2,0));
01694 #ifndef TOLUA_RELEASE
01695   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_place'",NULL);
01696 #endif
01697   {
01698    self->set_place(new_place);
01699   }
01700  }
01701  return 0;
01702 #ifndef TOLUA_RELEASE
01703  tolua_lerror:
01704  tolua_error(tolua_S,"#ferror in function 'set_place'.",&tolua_err);
01705  return 0;
01706 #endif
01707 }
01708 #endif //#ifndef TOLUA_DISABLE
01709 
01710 /* method: maxlenof_place of class  PlaceGotoMessage */
01711 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PlaceGotoMessage_maxlenof_place00
01712 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PlaceGotoMessage_maxlenof_place00(lua_State* tolua_S)
01713 {
01714 #ifndef TOLUA_RELEASE
01715  tolua_Error tolua_err;
01716  if (
01717      !tolua_isusertype(tolua_S,1,"const fawkes::NavigatorInterface::PlaceGotoMessage",0,&tolua_err) ||
01718      !tolua_isnoobj(tolua_S,2,&tolua_err)
01719  )
01720   goto tolua_lerror;
01721  else
01722 #endif
01723  {
01724   const fawkes::NavigatorInterface::PlaceGotoMessage* self = (const fawkes::NavigatorInterface::PlaceGotoMessage*)  tolua_tousertype(tolua_S,1,0);
01725 #ifndef TOLUA_RELEASE
01726   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_place'",NULL);
01727 #endif
01728   {
01729    int tolua_ret = (int)  self->maxlenof_place();
01730    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01731   }
01732  }
01733  return 1;
01734 #ifndef TOLUA_RELEASE
01735  tolua_lerror:
01736  tolua_error(tolua_S,"#ferror in function 'maxlenof_place'.",&tolua_err);
01737  return 0;
01738 #endif
01739 }
01740 #endif //#ifndef TOLUA_DISABLE
01741 
01742 /* method: new of class  ObstacleMessage */
01743 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_ObstacleMessage_new00
01744 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_ObstacleMessage_new00(lua_State* tolua_S)
01745 {
01746 #ifndef TOLUA_RELEASE
01747  tolua_Error tolua_err;
01748  if (
01749      !tolua_isusertable(tolua_S,1,"fawkes::NavigatorInterface::ObstacleMessage",0,&tolua_err) ||
01750      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01751      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
01752      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
01753      !tolua_isnoobj(tolua_S,5,&tolua_err)
01754  )
01755   goto tolua_lerror;
01756  else
01757 #endif
01758  {
01759   float ini_x = ((float)  tolua_tonumber(tolua_S,2,0));
01760   float ini_y = ((float)  tolua_tonumber(tolua_S,3,0));
01761   float ini_width = ((float)  tolua_tonumber(tolua_S,4,0));
01762   {
01763    fawkes::NavigatorInterface::ObstacleMessage* tolua_ret = (fawkes::NavigatorInterface::ObstacleMessage*)  new fawkes::NavigatorInterface::ObstacleMessage(ini_x,ini_y,ini_width);
01764    tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::NavigatorInterface::ObstacleMessage");
01765   }
01766  }
01767  return 1;
01768 #ifndef TOLUA_RELEASE
01769  tolua_lerror:
01770  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
01771  return 0;
01772 #endif
01773 }
01774 #endif //#ifndef TOLUA_DISABLE
01775 
01776 /* method: new_local of class  ObstacleMessage */
01777 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_ObstacleMessage_new00_local
01778 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_ObstacleMessage_new00_local(lua_State* tolua_S)
01779 {
01780 #ifndef TOLUA_RELEASE
01781  tolua_Error tolua_err;
01782  if (
01783      !tolua_isusertable(tolua_S,1,"fawkes::NavigatorInterface::ObstacleMessage",0,&tolua_err) ||
01784      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01785      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
01786      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
01787      !tolua_isnoobj(tolua_S,5,&tolua_err)
01788  )
01789   goto tolua_lerror;
01790  else
01791 #endif
01792  {
01793   float ini_x = ((float)  tolua_tonumber(tolua_S,2,0));
01794   float ini_y = ((float)  tolua_tonumber(tolua_S,3,0));
01795   float ini_width = ((float)  tolua_tonumber(tolua_S,4,0));
01796   {
01797    fawkes::NavigatorInterface::ObstacleMessage* tolua_ret = (fawkes::NavigatorInterface::ObstacleMessage*)  new fawkes::NavigatorInterface::ObstacleMessage(ini_x,ini_y,ini_width);
01798    tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"fawkes::NavigatorInterface::ObstacleMessage");
01799   }
01800  }
01801  return 1;
01802 #ifndef TOLUA_RELEASE
01803  tolua_lerror:
01804  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
01805  return 0;
01806 #endif
01807 }
01808 #endif //#ifndef TOLUA_DISABLE
01809 
01810 /* method: new of class  ObstacleMessage */
01811 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_ObstacleMessage_new01
01812 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_ObstacleMessage_new01(lua_State* tolua_S)
01813 {
01814  tolua_Error tolua_err;
01815  if (
01816      !tolua_isusertable(tolua_S,1,"fawkes::NavigatorInterface::ObstacleMessage",0,&tolua_err) ||
01817      !tolua_isnoobj(tolua_S,2,&tolua_err)
01818  )
01819   goto tolua_lerror;
01820  else
01821  {
01822   {
01823    fawkes::NavigatorInterface::ObstacleMessage* tolua_ret = (fawkes::NavigatorInterface::ObstacleMessage*)  new fawkes::NavigatorInterface::ObstacleMessage();
01824    tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::NavigatorInterface::ObstacleMessage");
01825   }
01826  }
01827  return 1;
01828 tolua_lerror:
01829  return tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_ObstacleMessage_new00(tolua_S);
01830 }
01831 #endif //#ifndef TOLUA_DISABLE
01832 
01833 /* method: new_local of class  ObstacleMessage */
01834 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_ObstacleMessage_new01_local
01835 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_ObstacleMessage_new01_local(lua_State* tolua_S)
01836 {
01837  tolua_Error tolua_err;
01838  if (
01839      !tolua_isusertable(tolua_S,1,"fawkes::NavigatorInterface::ObstacleMessage",0,&tolua_err) ||
01840      !tolua_isnoobj(tolua_S,2,&tolua_err)
01841  )
01842   goto tolua_lerror;
01843  else
01844  {
01845   {
01846    fawkes::NavigatorInterface::ObstacleMessage* tolua_ret = (fawkes::NavigatorInterface::ObstacleMessage*)  new fawkes::NavigatorInterface::ObstacleMessage();
01847    tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"fawkes::NavigatorInterface::ObstacleMessage");
01848   }
01849  }
01850  return 1;
01851 tolua_lerror:
01852  return tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_ObstacleMessage_new00_local(tolua_S);
01853 }
01854 #endif //#ifndef TOLUA_DISABLE
01855 
01856 /* method: delete of class  ObstacleMessage */
01857 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_ObstacleMessage_delete00
01858 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_ObstacleMessage_delete00(lua_State* tolua_S)
01859 {
01860 #ifndef TOLUA_RELEASE
01861  tolua_Error tolua_err;
01862  if (
01863      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface::ObstacleMessage",0,&tolua_err) ||
01864      !tolua_isnoobj(tolua_S,2,&tolua_err)
01865  )
01866   goto tolua_lerror;
01867  else
01868 #endif
01869  {
01870   fawkes::NavigatorInterface::ObstacleMessage* self = (fawkes::NavigatorInterface::ObstacleMessage*)  tolua_tousertype(tolua_S,1,0);
01871 #ifndef TOLUA_RELEASE
01872   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
01873 #endif
01874   delete self;
01875  }
01876  return 0;
01877 #ifndef TOLUA_RELEASE
01878  tolua_lerror:
01879  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
01880  return 0;
01881 #endif
01882 }
01883 #endif //#ifndef TOLUA_DISABLE
01884 
01885 /* method: x of class  ObstacleMessage */
01886 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_ObstacleMessage_x00
01887 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_ObstacleMessage_x00(lua_State* tolua_S)
01888 {
01889 #ifndef TOLUA_RELEASE
01890  tolua_Error tolua_err;
01891  if (
01892      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface::ObstacleMessage",0,&tolua_err) ||
01893      !tolua_isnoobj(tolua_S,2,&tolua_err)
01894  )
01895   goto tolua_lerror;
01896  else
01897 #endif
01898  {
01899   fawkes::NavigatorInterface::ObstacleMessage* self = (fawkes::NavigatorInterface::ObstacleMessage*)  tolua_tousertype(tolua_S,1,0);
01900 #ifndef TOLUA_RELEASE
01901   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'x'",NULL);
01902 #endif
01903   {
01904    float tolua_ret = (float)  self->x();
01905    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01906   }
01907  }
01908  return 1;
01909 #ifndef TOLUA_RELEASE
01910  tolua_lerror:
01911  tolua_error(tolua_S,"#ferror in function 'x'.",&tolua_err);
01912  return 0;
01913 #endif
01914 }
01915 #endif //#ifndef TOLUA_DISABLE
01916 
01917 /* method: set_x of class  ObstacleMessage */
01918 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_ObstacleMessage_set_x00
01919 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_ObstacleMessage_set_x00(lua_State* tolua_S)
01920 {
01921 #ifndef TOLUA_RELEASE
01922  tolua_Error tolua_err;
01923  if (
01924      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface::ObstacleMessage",0,&tolua_err) ||
01925      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01926      !tolua_isnoobj(tolua_S,3,&tolua_err)
01927  )
01928   goto tolua_lerror;
01929  else
01930 #endif
01931  {
01932   fawkes::NavigatorInterface::ObstacleMessage* self = (fawkes::NavigatorInterface::ObstacleMessage*)  tolua_tousertype(tolua_S,1,0);
01933   const float new_x = ((const float)  tolua_tonumber(tolua_S,2,0));
01934 #ifndef TOLUA_RELEASE
01935   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_x'",NULL);
01936 #endif
01937   {
01938    self->set_x(new_x);
01939   }
01940  }
01941  return 0;
01942 #ifndef TOLUA_RELEASE
01943  tolua_lerror:
01944  tolua_error(tolua_S,"#ferror in function 'set_x'.",&tolua_err);
01945  return 0;
01946 #endif
01947 }
01948 #endif //#ifndef TOLUA_DISABLE
01949 
01950 /* method: maxlenof_x of class  ObstacleMessage */
01951 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_ObstacleMessage_maxlenof_x00
01952 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_ObstacleMessage_maxlenof_x00(lua_State* tolua_S)
01953 {
01954 #ifndef TOLUA_RELEASE
01955  tolua_Error tolua_err;
01956  if (
01957      !tolua_isusertype(tolua_S,1,"const fawkes::NavigatorInterface::ObstacleMessage",0,&tolua_err) ||
01958      !tolua_isnoobj(tolua_S,2,&tolua_err)
01959  )
01960   goto tolua_lerror;
01961  else
01962 #endif
01963  {
01964   const fawkes::NavigatorInterface::ObstacleMessage* self = (const fawkes::NavigatorInterface::ObstacleMessage*)  tolua_tousertype(tolua_S,1,0);
01965 #ifndef TOLUA_RELEASE
01966   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_x'",NULL);
01967 #endif
01968   {
01969    int tolua_ret = (int)  self->maxlenof_x();
01970    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01971   }
01972  }
01973  return 1;
01974 #ifndef TOLUA_RELEASE
01975  tolua_lerror:
01976  tolua_error(tolua_S,"#ferror in function 'maxlenof_x'.",&tolua_err);
01977  return 0;
01978 #endif
01979 }
01980 #endif //#ifndef TOLUA_DISABLE
01981 
01982 /* method: y of class  ObstacleMessage */
01983 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_ObstacleMessage_y00
01984 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_ObstacleMessage_y00(lua_State* tolua_S)
01985 {
01986 #ifndef TOLUA_RELEASE
01987  tolua_Error tolua_err;
01988  if (
01989      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface::ObstacleMessage",0,&tolua_err) ||
01990      !tolua_isnoobj(tolua_S,2,&tolua_err)
01991  )
01992   goto tolua_lerror;
01993  else
01994 #endif
01995  {
01996   fawkes::NavigatorInterface::ObstacleMessage* self = (fawkes::NavigatorInterface::ObstacleMessage*)  tolua_tousertype(tolua_S,1,0);
01997 #ifndef TOLUA_RELEASE
01998   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'y'",NULL);
01999 #endif
02000   {
02001    float tolua_ret = (float)  self->y();
02002    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02003   }
02004  }
02005  return 1;
02006 #ifndef TOLUA_RELEASE
02007  tolua_lerror:
02008  tolua_error(tolua_S,"#ferror in function 'y'.",&tolua_err);
02009  return 0;
02010 #endif
02011 }
02012 #endif //#ifndef TOLUA_DISABLE
02013 
02014 /* method: set_y of class  ObstacleMessage */
02015 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_ObstacleMessage_set_y00
02016 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_ObstacleMessage_set_y00(lua_State* tolua_S)
02017 {
02018 #ifndef TOLUA_RELEASE
02019  tolua_Error tolua_err;
02020  if (
02021      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface::ObstacleMessage",0,&tolua_err) ||
02022      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02023      !tolua_isnoobj(tolua_S,3,&tolua_err)
02024  )
02025   goto tolua_lerror;
02026  else
02027 #endif
02028  {
02029   fawkes::NavigatorInterface::ObstacleMessage* self = (fawkes::NavigatorInterface::ObstacleMessage*)  tolua_tousertype(tolua_S,1,0);
02030   const float new_y = ((const float)  tolua_tonumber(tolua_S,2,0));
02031 #ifndef TOLUA_RELEASE
02032   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_y'",NULL);
02033 #endif
02034   {
02035    self->set_y(new_y);
02036   }
02037  }
02038  return 0;
02039 #ifndef TOLUA_RELEASE
02040  tolua_lerror:
02041  tolua_error(tolua_S,"#ferror in function 'set_y'.",&tolua_err);
02042  return 0;
02043 #endif
02044 }
02045 #endif //#ifndef TOLUA_DISABLE
02046 
02047 /* method: maxlenof_y of class  ObstacleMessage */
02048 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_ObstacleMessage_maxlenof_y00
02049 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_ObstacleMessage_maxlenof_y00(lua_State* tolua_S)
02050 {
02051 #ifndef TOLUA_RELEASE
02052  tolua_Error tolua_err;
02053  if (
02054      !tolua_isusertype(tolua_S,1,"const fawkes::NavigatorInterface::ObstacleMessage",0,&tolua_err) ||
02055      !tolua_isnoobj(tolua_S,2,&tolua_err)
02056  )
02057   goto tolua_lerror;
02058  else
02059 #endif
02060  {
02061   const fawkes::NavigatorInterface::ObstacleMessage* self = (const fawkes::NavigatorInterface::ObstacleMessage*)  tolua_tousertype(tolua_S,1,0);
02062 #ifndef TOLUA_RELEASE
02063   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_y'",NULL);
02064 #endif
02065   {
02066    int tolua_ret = (int)  self->maxlenof_y();
02067    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02068   }
02069  }
02070  return 1;
02071 #ifndef TOLUA_RELEASE
02072  tolua_lerror:
02073  tolua_error(tolua_S,"#ferror in function 'maxlenof_y'.",&tolua_err);
02074  return 0;
02075 #endif
02076 }
02077 #endif //#ifndef TOLUA_DISABLE
02078 
02079 /* method: width of class  ObstacleMessage */
02080 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_ObstacleMessage_width00
02081 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_ObstacleMessage_width00(lua_State* tolua_S)
02082 {
02083 #ifndef TOLUA_RELEASE
02084  tolua_Error tolua_err;
02085  if (
02086      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface::ObstacleMessage",0,&tolua_err) ||
02087      !tolua_isnoobj(tolua_S,2,&tolua_err)
02088  )
02089   goto tolua_lerror;
02090  else
02091 #endif
02092  {
02093   fawkes::NavigatorInterface::ObstacleMessage* self = (fawkes::NavigatorInterface::ObstacleMessage*)  tolua_tousertype(tolua_S,1,0);
02094 #ifndef TOLUA_RELEASE
02095   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'width'",NULL);
02096 #endif
02097   {
02098    float tolua_ret = (float)  self->width();
02099    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02100   }
02101  }
02102  return 1;
02103 #ifndef TOLUA_RELEASE
02104  tolua_lerror:
02105  tolua_error(tolua_S,"#ferror in function 'width'.",&tolua_err);
02106  return 0;
02107 #endif
02108 }
02109 #endif //#ifndef TOLUA_DISABLE
02110 
02111 /* method: set_width of class  ObstacleMessage */
02112 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_ObstacleMessage_set_width00
02113 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_ObstacleMessage_set_width00(lua_State* tolua_S)
02114 {
02115 #ifndef TOLUA_RELEASE
02116  tolua_Error tolua_err;
02117  if (
02118      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface::ObstacleMessage",0,&tolua_err) ||
02119      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02120      !tolua_isnoobj(tolua_S,3,&tolua_err)
02121  )
02122   goto tolua_lerror;
02123  else
02124 #endif
02125  {
02126   fawkes::NavigatorInterface::ObstacleMessage* self = (fawkes::NavigatorInterface::ObstacleMessage*)  tolua_tousertype(tolua_S,1,0);
02127   const float new_width = ((const float)  tolua_tonumber(tolua_S,2,0));
02128 #ifndef TOLUA_RELEASE
02129   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_width'",NULL);
02130 #endif
02131   {
02132    self->set_width(new_width);
02133   }
02134  }
02135  return 0;
02136 #ifndef TOLUA_RELEASE
02137  tolua_lerror:
02138  tolua_error(tolua_S,"#ferror in function 'set_width'.",&tolua_err);
02139  return 0;
02140 #endif
02141 }
02142 #endif //#ifndef TOLUA_DISABLE
02143 
02144 /* method: maxlenof_width of class  ObstacleMessage */
02145 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_ObstacleMessage_maxlenof_width00
02146 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_ObstacleMessage_maxlenof_width00(lua_State* tolua_S)
02147 {
02148 #ifndef TOLUA_RELEASE
02149  tolua_Error tolua_err;
02150  if (
02151      !tolua_isusertype(tolua_S,1,"const fawkes::NavigatorInterface::ObstacleMessage",0,&tolua_err) ||
02152      !tolua_isnoobj(tolua_S,2,&tolua_err)
02153  )
02154   goto tolua_lerror;
02155  else
02156 #endif
02157  {
02158   const fawkes::NavigatorInterface::ObstacleMessage* self = (const fawkes::NavigatorInterface::ObstacleMessage*)  tolua_tousertype(tolua_S,1,0);
02159 #ifndef TOLUA_RELEASE
02160   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_width'",NULL);
02161 #endif
02162   {
02163    int tolua_ret = (int)  self->maxlenof_width();
02164    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02165   }
02166  }
02167  return 1;
02168 #ifndef TOLUA_RELEASE
02169  tolua_lerror:
02170  tolua_error(tolua_S,"#ferror in function 'maxlenof_width'.",&tolua_err);
02171  return 0;
02172 #endif
02173 }
02174 #endif //#ifndef TOLUA_DISABLE
02175 
02176 /* method: new of class  ResetOdometryMessage */
02177 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_ResetOdometryMessage_new00
02178 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_ResetOdometryMessage_new00(lua_State* tolua_S)
02179 {
02180 #ifndef TOLUA_RELEASE
02181  tolua_Error tolua_err;
02182  if (
02183      !tolua_isusertable(tolua_S,1,"fawkes::NavigatorInterface::ResetOdometryMessage",0,&tolua_err) ||
02184      !tolua_isnoobj(tolua_S,2,&tolua_err)
02185  )
02186   goto tolua_lerror;
02187  else
02188 #endif
02189  {
02190   {
02191    fawkes::NavigatorInterface::ResetOdometryMessage* tolua_ret = (fawkes::NavigatorInterface::ResetOdometryMessage*)  new fawkes::NavigatorInterface::ResetOdometryMessage();
02192    tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::NavigatorInterface::ResetOdometryMessage");
02193   }
02194  }
02195  return 1;
02196 #ifndef TOLUA_RELEASE
02197  tolua_lerror:
02198  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
02199  return 0;
02200 #endif
02201 }
02202 #endif //#ifndef TOLUA_DISABLE
02203 
02204 /* method: new_local of class  ResetOdometryMessage */
02205 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_ResetOdometryMessage_new00_local
02206 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_ResetOdometryMessage_new00_local(lua_State* tolua_S)
02207 {
02208 #ifndef TOLUA_RELEASE
02209  tolua_Error tolua_err;
02210  if (
02211      !tolua_isusertable(tolua_S,1,"fawkes::NavigatorInterface::ResetOdometryMessage",0,&tolua_err) ||
02212      !tolua_isnoobj(tolua_S,2,&tolua_err)
02213  )
02214   goto tolua_lerror;
02215  else
02216 #endif
02217  {
02218   {
02219    fawkes::NavigatorInterface::ResetOdometryMessage* tolua_ret = (fawkes::NavigatorInterface::ResetOdometryMessage*)  new fawkes::NavigatorInterface::ResetOdometryMessage();
02220    tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"fawkes::NavigatorInterface::ResetOdometryMessage");
02221   }
02222  }
02223  return 1;
02224 #ifndef TOLUA_RELEASE
02225  tolua_lerror:
02226  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
02227  return 0;
02228 #endif
02229 }
02230 #endif //#ifndef TOLUA_DISABLE
02231 
02232 /* method: delete of class  ResetOdometryMessage */
02233 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_ResetOdometryMessage_delete00
02234 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_ResetOdometryMessage_delete00(lua_State* tolua_S)
02235 {
02236 #ifndef TOLUA_RELEASE
02237  tolua_Error tolua_err;
02238  if (
02239      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface::ResetOdometryMessage",0,&tolua_err) ||
02240      !tolua_isnoobj(tolua_S,2,&tolua_err)
02241  )
02242   goto tolua_lerror;
02243  else
02244 #endif
02245  {
02246   fawkes::NavigatorInterface::ResetOdometryMessage* self = (fawkes::NavigatorInterface::ResetOdometryMessage*)  tolua_tousertype(tolua_S,1,0);
02247 #ifndef TOLUA_RELEASE
02248   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
02249 #endif
02250   delete self;
02251  }
02252  return 0;
02253 #ifndef TOLUA_RELEASE
02254  tolua_lerror:
02255  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
02256  return 0;
02257 #endif
02258 }
02259 #endif //#ifndef TOLUA_DISABLE
02260 
02261 /* method: new of class  SetMaxVelocityMessage */
02262 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetMaxVelocityMessage_new00
02263 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetMaxVelocityMessage_new00(lua_State* tolua_S)
02264 {
02265 #ifndef TOLUA_RELEASE
02266  tolua_Error tolua_err;
02267  if (
02268      !tolua_isusertable(tolua_S,1,"fawkes::NavigatorInterface::SetMaxVelocityMessage",0,&tolua_err) ||
02269      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02270      !tolua_isnoobj(tolua_S,3,&tolua_err)
02271  )
02272   goto tolua_lerror;
02273  else
02274 #endif
02275  {
02276   float ini_max_velocity = ((float)  tolua_tonumber(tolua_S,2,0));
02277   {
02278    fawkes::NavigatorInterface::SetMaxVelocityMessage* tolua_ret = (fawkes::NavigatorInterface::SetMaxVelocityMessage*)  new fawkes::NavigatorInterface::SetMaxVelocityMessage(ini_max_velocity);
02279    tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::NavigatorInterface::SetMaxVelocityMessage");
02280   }
02281  }
02282  return 1;
02283 #ifndef TOLUA_RELEASE
02284  tolua_lerror:
02285  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
02286  return 0;
02287 #endif
02288 }
02289 #endif //#ifndef TOLUA_DISABLE
02290 
02291 /* method: new_local of class  SetMaxVelocityMessage */
02292 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetMaxVelocityMessage_new00_local
02293 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetMaxVelocityMessage_new00_local(lua_State* tolua_S)
02294 {
02295 #ifndef TOLUA_RELEASE
02296  tolua_Error tolua_err;
02297  if (
02298      !tolua_isusertable(tolua_S,1,"fawkes::NavigatorInterface::SetMaxVelocityMessage",0,&tolua_err) ||
02299      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02300      !tolua_isnoobj(tolua_S,3,&tolua_err)
02301  )
02302   goto tolua_lerror;
02303  else
02304 #endif
02305  {
02306   float ini_max_velocity = ((float)  tolua_tonumber(tolua_S,2,0));
02307   {
02308    fawkes::NavigatorInterface::SetMaxVelocityMessage* tolua_ret = (fawkes::NavigatorInterface::SetMaxVelocityMessage*)  new fawkes::NavigatorInterface::SetMaxVelocityMessage(ini_max_velocity);
02309    tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"fawkes::NavigatorInterface::SetMaxVelocityMessage");
02310   }
02311  }
02312  return 1;
02313 #ifndef TOLUA_RELEASE
02314  tolua_lerror:
02315  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
02316  return 0;
02317 #endif
02318 }
02319 #endif //#ifndef TOLUA_DISABLE
02320 
02321 /* method: new of class  SetMaxVelocityMessage */
02322 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetMaxVelocityMessage_new01
02323 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetMaxVelocityMessage_new01(lua_State* tolua_S)
02324 {
02325  tolua_Error tolua_err;
02326  if (
02327      !tolua_isusertable(tolua_S,1,"fawkes::NavigatorInterface::SetMaxVelocityMessage",0,&tolua_err) ||
02328      !tolua_isnoobj(tolua_S,2,&tolua_err)
02329  )
02330   goto tolua_lerror;
02331  else
02332  {
02333   {
02334    fawkes::NavigatorInterface::SetMaxVelocityMessage* tolua_ret = (fawkes::NavigatorInterface::SetMaxVelocityMessage*)  new fawkes::NavigatorInterface::SetMaxVelocityMessage();
02335    tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::NavigatorInterface::SetMaxVelocityMessage");
02336   }
02337  }
02338  return 1;
02339 tolua_lerror:
02340  return tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetMaxVelocityMessage_new00(tolua_S);
02341 }
02342 #endif //#ifndef TOLUA_DISABLE
02343 
02344 /* method: new_local of class  SetMaxVelocityMessage */
02345 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetMaxVelocityMessage_new01_local
02346 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetMaxVelocityMessage_new01_local(lua_State* tolua_S)
02347 {
02348  tolua_Error tolua_err;
02349  if (
02350      !tolua_isusertable(tolua_S,1,"fawkes::NavigatorInterface::SetMaxVelocityMessage",0,&tolua_err) ||
02351      !tolua_isnoobj(tolua_S,2,&tolua_err)
02352  )
02353   goto tolua_lerror;
02354  else
02355  {
02356   {
02357    fawkes::NavigatorInterface::SetMaxVelocityMessage* tolua_ret = (fawkes::NavigatorInterface::SetMaxVelocityMessage*)  new fawkes::NavigatorInterface::SetMaxVelocityMessage();
02358    tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"fawkes::NavigatorInterface::SetMaxVelocityMessage");
02359   }
02360  }
02361  return 1;
02362 tolua_lerror:
02363  return tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetMaxVelocityMessage_new00_local(tolua_S);
02364 }
02365 #endif //#ifndef TOLUA_DISABLE
02366 
02367 /* method: delete of class  SetMaxVelocityMessage */
02368 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetMaxVelocityMessage_delete00
02369 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetMaxVelocityMessage_delete00(lua_State* tolua_S)
02370 {
02371 #ifndef TOLUA_RELEASE
02372  tolua_Error tolua_err;
02373  if (
02374      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface::SetMaxVelocityMessage",0,&tolua_err) ||
02375      !tolua_isnoobj(tolua_S,2,&tolua_err)
02376  )
02377   goto tolua_lerror;
02378  else
02379 #endif
02380  {
02381   fawkes::NavigatorInterface::SetMaxVelocityMessage* self = (fawkes::NavigatorInterface::SetMaxVelocityMessage*)  tolua_tousertype(tolua_S,1,0);
02382 #ifndef TOLUA_RELEASE
02383   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
02384 #endif
02385   delete self;
02386  }
02387  return 0;
02388 #ifndef TOLUA_RELEASE
02389  tolua_lerror:
02390  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
02391  return 0;
02392 #endif
02393 }
02394 #endif //#ifndef TOLUA_DISABLE
02395 
02396 /* method: max_velocity of class  SetMaxVelocityMessage */
02397 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetMaxVelocityMessage_max_velocity00
02398 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetMaxVelocityMessage_max_velocity00(lua_State* tolua_S)
02399 {
02400 #ifndef TOLUA_RELEASE
02401  tolua_Error tolua_err;
02402  if (
02403      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface::SetMaxVelocityMessage",0,&tolua_err) ||
02404      !tolua_isnoobj(tolua_S,2,&tolua_err)
02405  )
02406   goto tolua_lerror;
02407  else
02408 #endif
02409  {
02410   fawkes::NavigatorInterface::SetMaxVelocityMessage* self = (fawkes::NavigatorInterface::SetMaxVelocityMessage*)  tolua_tousertype(tolua_S,1,0);
02411 #ifndef TOLUA_RELEASE
02412   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'max_velocity'",NULL);
02413 #endif
02414   {
02415    float tolua_ret = (float)  self->max_velocity();
02416    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02417   }
02418  }
02419  return 1;
02420 #ifndef TOLUA_RELEASE
02421  tolua_lerror:
02422  tolua_error(tolua_S,"#ferror in function 'max_velocity'.",&tolua_err);
02423  return 0;
02424 #endif
02425 }
02426 #endif //#ifndef TOLUA_DISABLE
02427 
02428 /* method: set_max_velocity of class  SetMaxVelocityMessage */
02429 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetMaxVelocityMessage_set_max_velocity00
02430 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetMaxVelocityMessage_set_max_velocity00(lua_State* tolua_S)
02431 {
02432 #ifndef TOLUA_RELEASE
02433  tolua_Error tolua_err;
02434  if (
02435      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface::SetMaxVelocityMessage",0,&tolua_err) ||
02436      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02437      !tolua_isnoobj(tolua_S,3,&tolua_err)
02438  )
02439   goto tolua_lerror;
02440  else
02441 #endif
02442  {
02443   fawkes::NavigatorInterface::SetMaxVelocityMessage* self = (fawkes::NavigatorInterface::SetMaxVelocityMessage*)  tolua_tousertype(tolua_S,1,0);
02444   const float new_max_velocity = ((const float)  tolua_tonumber(tolua_S,2,0));
02445 #ifndef TOLUA_RELEASE
02446   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_max_velocity'",NULL);
02447 #endif
02448   {
02449    self->set_max_velocity(new_max_velocity);
02450   }
02451  }
02452  return 0;
02453 #ifndef TOLUA_RELEASE
02454  tolua_lerror:
02455  tolua_error(tolua_S,"#ferror in function 'set_max_velocity'.",&tolua_err);
02456  return 0;
02457 #endif
02458 }
02459 #endif //#ifndef TOLUA_DISABLE
02460 
02461 /* method: maxlenof_max_velocity of class  SetMaxVelocityMessage */
02462 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetMaxVelocityMessage_maxlenof_max_velocity00
02463 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetMaxVelocityMessage_maxlenof_max_velocity00(lua_State* tolua_S)
02464 {
02465 #ifndef TOLUA_RELEASE
02466  tolua_Error tolua_err;
02467  if (
02468      !tolua_isusertype(tolua_S,1,"const fawkes::NavigatorInterface::SetMaxVelocityMessage",0,&tolua_err) ||
02469      !tolua_isnoobj(tolua_S,2,&tolua_err)
02470  )
02471   goto tolua_lerror;
02472  else
02473 #endif
02474  {
02475   const fawkes::NavigatorInterface::SetMaxVelocityMessage* self = (const fawkes::NavigatorInterface::SetMaxVelocityMessage*)  tolua_tousertype(tolua_S,1,0);
02476 #ifndef TOLUA_RELEASE
02477   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_max_velocity'",NULL);
02478 #endif
02479   {
02480    int tolua_ret = (int)  self->maxlenof_max_velocity();
02481    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02482   }
02483  }
02484  return 1;
02485 #ifndef TOLUA_RELEASE
02486  tolua_lerror:
02487  tolua_error(tolua_S,"#ferror in function 'maxlenof_max_velocity'.",&tolua_err);
02488  return 0;
02489 #endif
02490 }
02491 #endif //#ifndef TOLUA_DISABLE
02492 
02493 /* method: new of class  SetEscapingMessage */
02494 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetEscapingMessage_new00
02495 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetEscapingMessage_new00(lua_State* tolua_S)
02496 {
02497 #ifndef TOLUA_RELEASE
02498  tolua_Error tolua_err;
02499  if (
02500      !tolua_isusertable(tolua_S,1,"fawkes::NavigatorInterface::SetEscapingMessage",0,&tolua_err) ||
02501      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
02502      !tolua_isnoobj(tolua_S,3,&tolua_err)
02503  )
02504   goto tolua_lerror;
02505  else
02506 #endif
02507  {
02508   bool ini_escaping_enabled = ((bool)  tolua_toboolean(tolua_S,2,0));
02509   {
02510    fawkes::NavigatorInterface::SetEscapingMessage* tolua_ret = (fawkes::NavigatorInterface::SetEscapingMessage*)  new fawkes::NavigatorInterface::SetEscapingMessage(ini_escaping_enabled);
02511    tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::NavigatorInterface::SetEscapingMessage");
02512   }
02513  }
02514  return 1;
02515 #ifndef TOLUA_RELEASE
02516  tolua_lerror:
02517  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
02518  return 0;
02519 #endif
02520 }
02521 #endif //#ifndef TOLUA_DISABLE
02522 
02523 /* method: new_local of class  SetEscapingMessage */
02524 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetEscapingMessage_new00_local
02525 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetEscapingMessage_new00_local(lua_State* tolua_S)
02526 {
02527 #ifndef TOLUA_RELEASE
02528  tolua_Error tolua_err;
02529  if (
02530      !tolua_isusertable(tolua_S,1,"fawkes::NavigatorInterface::SetEscapingMessage",0,&tolua_err) ||
02531      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
02532      !tolua_isnoobj(tolua_S,3,&tolua_err)
02533  )
02534   goto tolua_lerror;
02535  else
02536 #endif
02537  {
02538   bool ini_escaping_enabled = ((bool)  tolua_toboolean(tolua_S,2,0));
02539   {
02540    fawkes::NavigatorInterface::SetEscapingMessage* tolua_ret = (fawkes::NavigatorInterface::SetEscapingMessage*)  new fawkes::NavigatorInterface::SetEscapingMessage(ini_escaping_enabled);
02541    tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"fawkes::NavigatorInterface::SetEscapingMessage");
02542   }
02543  }
02544  return 1;
02545 #ifndef TOLUA_RELEASE
02546  tolua_lerror:
02547  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
02548  return 0;
02549 #endif
02550 }
02551 #endif //#ifndef TOLUA_DISABLE
02552 
02553 /* method: new of class  SetEscapingMessage */
02554 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetEscapingMessage_new01
02555 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetEscapingMessage_new01(lua_State* tolua_S)
02556 {
02557  tolua_Error tolua_err;
02558  if (
02559      !tolua_isusertable(tolua_S,1,"fawkes::NavigatorInterface::SetEscapingMessage",0,&tolua_err) ||
02560      !tolua_isnoobj(tolua_S,2,&tolua_err)
02561  )
02562   goto tolua_lerror;
02563  else
02564  {
02565   {
02566    fawkes::NavigatorInterface::SetEscapingMessage* tolua_ret = (fawkes::NavigatorInterface::SetEscapingMessage*)  new fawkes::NavigatorInterface::SetEscapingMessage();
02567    tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::NavigatorInterface::SetEscapingMessage");
02568   }
02569  }
02570  return 1;
02571 tolua_lerror:
02572  return tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetEscapingMessage_new00(tolua_S);
02573 }
02574 #endif //#ifndef TOLUA_DISABLE
02575 
02576 /* method: new_local of class  SetEscapingMessage */
02577 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetEscapingMessage_new01_local
02578 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetEscapingMessage_new01_local(lua_State* tolua_S)
02579 {
02580  tolua_Error tolua_err;
02581  if (
02582      !tolua_isusertable(tolua_S,1,"fawkes::NavigatorInterface::SetEscapingMessage",0,&tolua_err) ||
02583      !tolua_isnoobj(tolua_S,2,&tolua_err)
02584  )
02585   goto tolua_lerror;
02586  else
02587  {
02588   {
02589    fawkes::NavigatorInterface::SetEscapingMessage* tolua_ret = (fawkes::NavigatorInterface::SetEscapingMessage*)  new fawkes::NavigatorInterface::SetEscapingMessage();
02590    tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"fawkes::NavigatorInterface::SetEscapingMessage");
02591   }
02592  }
02593  return 1;
02594 tolua_lerror:
02595  return tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetEscapingMessage_new00_local(tolua_S);
02596 }
02597 #endif //#ifndef TOLUA_DISABLE
02598 
02599 /* method: delete of class  SetEscapingMessage */
02600 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetEscapingMessage_delete00
02601 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetEscapingMessage_delete00(lua_State* tolua_S)
02602 {
02603 #ifndef TOLUA_RELEASE
02604  tolua_Error tolua_err;
02605  if (
02606      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface::SetEscapingMessage",0,&tolua_err) ||
02607      !tolua_isnoobj(tolua_S,2,&tolua_err)
02608  )
02609   goto tolua_lerror;
02610  else
02611 #endif
02612  {
02613   fawkes::NavigatorInterface::SetEscapingMessage* self = (fawkes::NavigatorInterface::SetEscapingMessage*)  tolua_tousertype(tolua_S,1,0);
02614 #ifndef TOLUA_RELEASE
02615   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
02616 #endif
02617   delete self;
02618  }
02619  return 0;
02620 #ifndef TOLUA_RELEASE
02621  tolua_lerror:
02622  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
02623  return 0;
02624 #endif
02625 }
02626 #endif //#ifndef TOLUA_DISABLE
02627 
02628 /* method: is_escaping_enabled of class  SetEscapingMessage */
02629 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetEscapingMessage_is_escaping_enabled00
02630 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetEscapingMessage_is_escaping_enabled00(lua_State* tolua_S)
02631 {
02632 #ifndef TOLUA_RELEASE
02633  tolua_Error tolua_err;
02634  if (
02635      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface::SetEscapingMessage",0,&tolua_err) ||
02636      !tolua_isnoobj(tolua_S,2,&tolua_err)
02637  )
02638   goto tolua_lerror;
02639  else
02640 #endif
02641  {
02642   fawkes::NavigatorInterface::SetEscapingMessage* self = (fawkes::NavigatorInterface::SetEscapingMessage*)  tolua_tousertype(tolua_S,1,0);
02643 #ifndef TOLUA_RELEASE
02644   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_escaping_enabled'",NULL);
02645 #endif
02646   {
02647    bool tolua_ret = (bool)  self->is_escaping_enabled();
02648    tolua_pushboolean(tolua_S,(bool)tolua_ret);
02649   }
02650  }
02651  return 1;
02652 #ifndef TOLUA_RELEASE
02653  tolua_lerror:
02654  tolua_error(tolua_S,"#ferror in function 'is_escaping_enabled'.",&tolua_err);
02655  return 0;
02656 #endif
02657 }
02658 #endif //#ifndef TOLUA_DISABLE
02659 
02660 /* method: set_escaping_enabled of class  SetEscapingMessage */
02661 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetEscapingMessage_set_escaping_enabled00
02662 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetEscapingMessage_set_escaping_enabled00(lua_State* tolua_S)
02663 {
02664 #ifndef TOLUA_RELEASE
02665  tolua_Error tolua_err;
02666  if (
02667      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface::SetEscapingMessage",0,&tolua_err) ||
02668      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
02669      !tolua_isnoobj(tolua_S,3,&tolua_err)
02670  )
02671   goto tolua_lerror;
02672  else
02673 #endif
02674  {
02675   fawkes::NavigatorInterface::SetEscapingMessage* self = (fawkes::NavigatorInterface::SetEscapingMessage*)  tolua_tousertype(tolua_S,1,0);
02676   const bool new_escaping_enabled = ((const bool)  tolua_toboolean(tolua_S,2,0));
02677 #ifndef TOLUA_RELEASE
02678   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_escaping_enabled'",NULL);
02679 #endif
02680   {
02681    self->set_escaping_enabled(new_escaping_enabled);
02682   }
02683  }
02684  return 0;
02685 #ifndef TOLUA_RELEASE
02686  tolua_lerror:
02687  tolua_error(tolua_S,"#ferror in function 'set_escaping_enabled'.",&tolua_err);
02688  return 0;
02689 #endif
02690 }
02691 #endif //#ifndef TOLUA_DISABLE
02692 
02693 /* method: maxlenof_escaping_enabled of class  SetEscapingMessage */
02694 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetEscapingMessage_maxlenof_escaping_enabled00
02695 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetEscapingMessage_maxlenof_escaping_enabled00(lua_State* tolua_S)
02696 {
02697 #ifndef TOLUA_RELEASE
02698  tolua_Error tolua_err;
02699  if (
02700      !tolua_isusertype(tolua_S,1,"const fawkes::NavigatorInterface::SetEscapingMessage",0,&tolua_err) ||
02701      !tolua_isnoobj(tolua_S,2,&tolua_err)
02702  )
02703   goto tolua_lerror;
02704  else
02705 #endif
02706  {
02707   const fawkes::NavigatorInterface::SetEscapingMessage* self = (const fawkes::NavigatorInterface::SetEscapingMessage*)  tolua_tousertype(tolua_S,1,0);
02708 #ifndef TOLUA_RELEASE
02709   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_escaping_enabled'",NULL);
02710 #endif
02711   {
02712    int tolua_ret = (int)  self->maxlenof_escaping_enabled();
02713    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02714   }
02715  }
02716  return 1;
02717 #ifndef TOLUA_RELEASE
02718  tolua_lerror:
02719  tolua_error(tolua_S,"#ferror in function 'maxlenof_escaping_enabled'.",&tolua_err);
02720  return 0;
02721 #endif
02722 }
02723 #endif //#ifndef TOLUA_DISABLE
02724 
02725 /* method: new of class  SetSecurityDistanceMessage */
02726 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetSecurityDistanceMessage_new00
02727 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetSecurityDistanceMessage_new00(lua_State* tolua_S)
02728 {
02729 #ifndef TOLUA_RELEASE
02730  tolua_Error tolua_err;
02731  if (
02732      !tolua_isusertable(tolua_S,1,"fawkes::NavigatorInterface::SetSecurityDistanceMessage",0,&tolua_err) ||
02733      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02734      !tolua_isnoobj(tolua_S,3,&tolua_err)
02735  )
02736   goto tolua_lerror;
02737  else
02738 #endif
02739  {
02740   float ini_security_distance = ((float)  tolua_tonumber(tolua_S,2,0));
02741   {
02742    fawkes::NavigatorInterface::SetSecurityDistanceMessage* tolua_ret = (fawkes::NavigatorInterface::SetSecurityDistanceMessage*)  new fawkes::NavigatorInterface::SetSecurityDistanceMessage(ini_security_distance);
02743    tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::NavigatorInterface::SetSecurityDistanceMessage");
02744   }
02745  }
02746  return 1;
02747 #ifndef TOLUA_RELEASE
02748  tolua_lerror:
02749  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
02750  return 0;
02751 #endif
02752 }
02753 #endif //#ifndef TOLUA_DISABLE
02754 
02755 /* method: new_local of class  SetSecurityDistanceMessage */
02756 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetSecurityDistanceMessage_new00_local
02757 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetSecurityDistanceMessage_new00_local(lua_State* tolua_S)
02758 {
02759 #ifndef TOLUA_RELEASE
02760  tolua_Error tolua_err;
02761  if (
02762      !tolua_isusertable(tolua_S,1,"fawkes::NavigatorInterface::SetSecurityDistanceMessage",0,&tolua_err) ||
02763      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02764      !tolua_isnoobj(tolua_S,3,&tolua_err)
02765  )
02766   goto tolua_lerror;
02767  else
02768 #endif
02769  {
02770   float ini_security_distance = ((float)  tolua_tonumber(tolua_S,2,0));
02771   {
02772    fawkes::NavigatorInterface::SetSecurityDistanceMessage* tolua_ret = (fawkes::NavigatorInterface::SetSecurityDistanceMessage*)  new fawkes::NavigatorInterface::SetSecurityDistanceMessage(ini_security_distance);
02773    tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"fawkes::NavigatorInterface::SetSecurityDistanceMessage");
02774   }
02775  }
02776  return 1;
02777 #ifndef TOLUA_RELEASE
02778  tolua_lerror:
02779  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
02780  return 0;
02781 #endif
02782 }
02783 #endif //#ifndef TOLUA_DISABLE
02784 
02785 /* method: new of class  SetSecurityDistanceMessage */
02786 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetSecurityDistanceMessage_new01
02787 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetSecurityDistanceMessage_new01(lua_State* tolua_S)
02788 {
02789  tolua_Error tolua_err;
02790  if (
02791      !tolua_isusertable(tolua_S,1,"fawkes::NavigatorInterface::SetSecurityDistanceMessage",0,&tolua_err) ||
02792      !tolua_isnoobj(tolua_S,2,&tolua_err)
02793  )
02794   goto tolua_lerror;
02795  else
02796  {
02797   {
02798    fawkes::NavigatorInterface::SetSecurityDistanceMessage* tolua_ret = (fawkes::NavigatorInterface::SetSecurityDistanceMessage*)  new fawkes::NavigatorInterface::SetSecurityDistanceMessage();
02799    tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::NavigatorInterface::SetSecurityDistanceMessage");
02800   }
02801  }
02802  return 1;
02803 tolua_lerror:
02804  return tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetSecurityDistanceMessage_new00(tolua_S);
02805 }
02806 #endif //#ifndef TOLUA_DISABLE
02807 
02808 /* method: new_local of class  SetSecurityDistanceMessage */
02809 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetSecurityDistanceMessage_new01_local
02810 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetSecurityDistanceMessage_new01_local(lua_State* tolua_S)
02811 {
02812  tolua_Error tolua_err;
02813  if (
02814      !tolua_isusertable(tolua_S,1,"fawkes::NavigatorInterface::SetSecurityDistanceMessage",0,&tolua_err) ||
02815      !tolua_isnoobj(tolua_S,2,&tolua_err)
02816  )
02817   goto tolua_lerror;
02818  else
02819  {
02820   {
02821    fawkes::NavigatorInterface::SetSecurityDistanceMessage* tolua_ret = (fawkes::NavigatorInterface::SetSecurityDistanceMessage*)  new fawkes::NavigatorInterface::SetSecurityDistanceMessage();
02822    tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"fawkes::NavigatorInterface::SetSecurityDistanceMessage");
02823   }
02824  }
02825  return 1;
02826 tolua_lerror:
02827  return tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetSecurityDistanceMessage_new00_local(tolua_S);
02828 }
02829 #endif //#ifndef TOLUA_DISABLE
02830 
02831 /* method: delete of class  SetSecurityDistanceMessage */
02832 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetSecurityDistanceMessage_delete00
02833 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetSecurityDistanceMessage_delete00(lua_State* tolua_S)
02834 {
02835 #ifndef TOLUA_RELEASE
02836  tolua_Error tolua_err;
02837  if (
02838      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface::SetSecurityDistanceMessage",0,&tolua_err) ||
02839      !tolua_isnoobj(tolua_S,2,&tolua_err)
02840  )
02841   goto tolua_lerror;
02842  else
02843 #endif
02844  {
02845   fawkes::NavigatorInterface::SetSecurityDistanceMessage* self = (fawkes::NavigatorInterface::SetSecurityDistanceMessage*)  tolua_tousertype(tolua_S,1,0);
02846 #ifndef TOLUA_RELEASE
02847   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
02848 #endif
02849   delete self;
02850  }
02851  return 0;
02852 #ifndef TOLUA_RELEASE
02853  tolua_lerror:
02854  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
02855  return 0;
02856 #endif
02857 }
02858 #endif //#ifndef TOLUA_DISABLE
02859 
02860 /* method: security_distance of class  SetSecurityDistanceMessage */
02861 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetSecurityDistanceMessage_security_distance00
02862 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetSecurityDistanceMessage_security_distance00(lua_State* tolua_S)
02863 {
02864 #ifndef TOLUA_RELEASE
02865  tolua_Error tolua_err;
02866  if (
02867      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface::SetSecurityDistanceMessage",0,&tolua_err) ||
02868      !tolua_isnoobj(tolua_S,2,&tolua_err)
02869  )
02870   goto tolua_lerror;
02871  else
02872 #endif
02873  {
02874   fawkes::NavigatorInterface::SetSecurityDistanceMessage* self = (fawkes::NavigatorInterface::SetSecurityDistanceMessage*)  tolua_tousertype(tolua_S,1,0);
02875 #ifndef TOLUA_RELEASE
02876   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'security_distance'",NULL);
02877 #endif
02878   {
02879    float tolua_ret = (float)  self->security_distance();
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 'security_distance'.",&tolua_err);
02887  return 0;
02888 #endif
02889 }
02890 #endif //#ifndef TOLUA_DISABLE
02891 
02892 /* method: set_security_distance of class  SetSecurityDistanceMessage */
02893 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetSecurityDistanceMessage_set_security_distance00
02894 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetSecurityDistanceMessage_set_security_distance00(lua_State* tolua_S)
02895 {
02896 #ifndef TOLUA_RELEASE
02897  tolua_Error tolua_err;
02898  if (
02899      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface::SetSecurityDistanceMessage",0,&tolua_err) ||
02900      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02901      !tolua_isnoobj(tolua_S,3,&tolua_err)
02902  )
02903   goto tolua_lerror;
02904  else
02905 #endif
02906  {
02907   fawkes::NavigatorInterface::SetSecurityDistanceMessage* self = (fawkes::NavigatorInterface::SetSecurityDistanceMessage*)  tolua_tousertype(tolua_S,1,0);
02908   const float new_security_distance = ((const float)  tolua_tonumber(tolua_S,2,0));
02909 #ifndef TOLUA_RELEASE
02910   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_security_distance'",NULL);
02911 #endif
02912   {
02913    self->set_security_distance(new_security_distance);
02914   }
02915  }
02916  return 0;
02917 #ifndef TOLUA_RELEASE
02918  tolua_lerror:
02919  tolua_error(tolua_S,"#ferror in function 'set_security_distance'.",&tolua_err);
02920  return 0;
02921 #endif
02922 }
02923 #endif //#ifndef TOLUA_DISABLE
02924 
02925 /* method: maxlenof_security_distance of class  SetSecurityDistanceMessage */
02926 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetSecurityDistanceMessage_maxlenof_security_distance00
02927 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetSecurityDistanceMessage_maxlenof_security_distance00(lua_State* tolua_S)
02928 {
02929 #ifndef TOLUA_RELEASE
02930  tolua_Error tolua_err;
02931  if (
02932      !tolua_isusertype(tolua_S,1,"const fawkes::NavigatorInterface::SetSecurityDistanceMessage",0,&tolua_err) ||
02933      !tolua_isnoobj(tolua_S,2,&tolua_err)
02934  )
02935   goto tolua_lerror;
02936  else
02937 #endif
02938  {
02939   const fawkes::NavigatorInterface::SetSecurityDistanceMessage* self = (const fawkes::NavigatorInterface::SetSecurityDistanceMessage*)  tolua_tousertype(tolua_S,1,0);
02940 #ifndef TOLUA_RELEASE
02941   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_security_distance'",NULL);
02942 #endif
02943   {
02944    int tolua_ret = (int)  self->maxlenof_security_distance();
02945    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02946   }
02947  }
02948  return 1;
02949 #ifndef TOLUA_RELEASE
02950  tolua_lerror:
02951  tolua_error(tolua_S,"#ferror in function 'maxlenof_security_distance'.",&tolua_err);
02952  return 0;
02953 #endif
02954 }
02955 #endif //#ifndef TOLUA_DISABLE
02956 
02957 /* method: flags of class  fawkes::NavigatorInterface */
02958 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_flags00
02959 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_flags00(lua_State* tolua_S)
02960 {
02961 #ifndef TOLUA_RELEASE
02962  tolua_Error tolua_err;
02963  if (
02964      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface",0,&tolua_err) ||
02965      !tolua_isnoobj(tolua_S,2,&tolua_err)
02966  )
02967   goto tolua_lerror;
02968  else
02969 #endif
02970  {
02971   fawkes::NavigatorInterface* self = (fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
02972 #ifndef TOLUA_RELEASE
02973   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'flags'",NULL);
02974 #endif
02975   {
02976    unsigned int tolua_ret = (unsigned int)  self->flags();
02977    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02978   }
02979  }
02980  return 1;
02981 #ifndef TOLUA_RELEASE
02982  tolua_lerror:
02983  tolua_error(tolua_S,"#ferror in function 'flags'.",&tolua_err);
02984  return 0;
02985 #endif
02986 }
02987 #endif //#ifndef TOLUA_DISABLE
02988 
02989 /* method: set_flags of class  fawkes::NavigatorInterface */
02990 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_set_flags00
02991 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_set_flags00(lua_State* tolua_S)
02992 {
02993 #ifndef TOLUA_RELEASE
02994  tolua_Error tolua_err;
02995  if (
02996      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface",0,&tolua_err) ||
02997      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02998      !tolua_isnoobj(tolua_S,3,&tolua_err)
02999  )
03000   goto tolua_lerror;
03001  else
03002 #endif
03003  {
03004   fawkes::NavigatorInterface* self = (fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
03005   unsigned const int new_flags = ((unsigned const int)  tolua_tonumber(tolua_S,2,0));
03006 #ifndef TOLUA_RELEASE
03007   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_flags'",NULL);
03008 #endif
03009   {
03010    self->set_flags(new_flags);
03011   }
03012  }
03013  return 0;
03014 #ifndef TOLUA_RELEASE
03015  tolua_lerror:
03016  tolua_error(tolua_S,"#ferror in function 'set_flags'.",&tolua_err);
03017  return 0;
03018 #endif
03019 }
03020 #endif //#ifndef TOLUA_DISABLE
03021 
03022 /* method: maxlenof_flags of class  fawkes::NavigatorInterface */
03023 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_maxlenof_flags00
03024 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_maxlenof_flags00(lua_State* tolua_S)
03025 {
03026 #ifndef TOLUA_RELEASE
03027  tolua_Error tolua_err;
03028  if (
03029      !tolua_isusertype(tolua_S,1,"const fawkes::NavigatorInterface",0,&tolua_err) ||
03030      !tolua_isnoobj(tolua_S,2,&tolua_err)
03031  )
03032   goto tolua_lerror;
03033  else
03034 #endif
03035  {
03036   const fawkes::NavigatorInterface* self = (const fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
03037 #ifndef TOLUA_RELEASE
03038   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_flags'",NULL);
03039 #endif
03040   {
03041    int tolua_ret = (int)  self->maxlenof_flags();
03042    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03043   }
03044  }
03045  return 1;
03046 #ifndef TOLUA_RELEASE
03047  tolua_lerror:
03048  tolua_error(tolua_S,"#ferror in function 'maxlenof_flags'.",&tolua_err);
03049  return 0;
03050 #endif
03051 }
03052 #endif //#ifndef TOLUA_DISABLE
03053 
03054 /* method: x of class  fawkes::NavigatorInterface */
03055 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_x00
03056 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_x00(lua_State* tolua_S)
03057 {
03058 #ifndef TOLUA_RELEASE
03059  tolua_Error tolua_err;
03060  if (
03061      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface",0,&tolua_err) ||
03062      !tolua_isnoobj(tolua_S,2,&tolua_err)
03063  )
03064   goto tolua_lerror;
03065  else
03066 #endif
03067  {
03068   fawkes::NavigatorInterface* self = (fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
03069 #ifndef TOLUA_RELEASE
03070   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'x'",NULL);
03071 #endif
03072   {
03073    float tolua_ret = (float)  self->x();
03074    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03075   }
03076  }
03077  return 1;
03078 #ifndef TOLUA_RELEASE
03079  tolua_lerror:
03080  tolua_error(tolua_S,"#ferror in function 'x'.",&tolua_err);
03081  return 0;
03082 #endif
03083 }
03084 #endif //#ifndef TOLUA_DISABLE
03085 
03086 /* method: set_x of class  fawkes::NavigatorInterface */
03087 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_set_x00
03088 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_set_x00(lua_State* tolua_S)
03089 {
03090 #ifndef TOLUA_RELEASE
03091  tolua_Error tolua_err;
03092  if (
03093      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface",0,&tolua_err) ||
03094      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
03095      !tolua_isnoobj(tolua_S,3,&tolua_err)
03096  )
03097   goto tolua_lerror;
03098  else
03099 #endif
03100  {
03101   fawkes::NavigatorInterface* self = (fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
03102   const float new_x = ((const float)  tolua_tonumber(tolua_S,2,0));
03103 #ifndef TOLUA_RELEASE
03104   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_x'",NULL);
03105 #endif
03106   {
03107    self->set_x(new_x);
03108   }
03109  }
03110  return 0;
03111 #ifndef TOLUA_RELEASE
03112  tolua_lerror:
03113  tolua_error(tolua_S,"#ferror in function 'set_x'.",&tolua_err);
03114  return 0;
03115 #endif
03116 }
03117 #endif //#ifndef TOLUA_DISABLE
03118 
03119 /* method: maxlenof_x of class  fawkes::NavigatorInterface */
03120 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_maxlenof_x00
03121 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_maxlenof_x00(lua_State* tolua_S)
03122 {
03123 #ifndef TOLUA_RELEASE
03124  tolua_Error tolua_err;
03125  if (
03126      !tolua_isusertype(tolua_S,1,"const fawkes::NavigatorInterface",0,&tolua_err) ||
03127      !tolua_isnoobj(tolua_S,2,&tolua_err)
03128  )
03129   goto tolua_lerror;
03130  else
03131 #endif
03132  {
03133   const fawkes::NavigatorInterface* self = (const fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
03134 #ifndef TOLUA_RELEASE
03135   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_x'",NULL);
03136 #endif
03137   {
03138    int tolua_ret = (int)  self->maxlenof_x();
03139    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03140   }
03141  }
03142  return 1;
03143 #ifndef TOLUA_RELEASE
03144  tolua_lerror:
03145  tolua_error(tolua_S,"#ferror in function 'maxlenof_x'.",&tolua_err);
03146  return 0;
03147 #endif
03148 }
03149 #endif //#ifndef TOLUA_DISABLE
03150 
03151 /* method: y of class  fawkes::NavigatorInterface */
03152 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_y00
03153 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_y00(lua_State* tolua_S)
03154 {
03155 #ifndef TOLUA_RELEASE
03156  tolua_Error tolua_err;
03157  if (
03158      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface",0,&tolua_err) ||
03159      !tolua_isnoobj(tolua_S,2,&tolua_err)
03160  )
03161   goto tolua_lerror;
03162  else
03163 #endif
03164  {
03165   fawkes::NavigatorInterface* self = (fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
03166 #ifndef TOLUA_RELEASE
03167   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'y'",NULL);
03168 #endif
03169   {
03170    float tolua_ret = (float)  self->y();
03171    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03172   }
03173  }
03174  return 1;
03175 #ifndef TOLUA_RELEASE
03176  tolua_lerror:
03177  tolua_error(tolua_S,"#ferror in function 'y'.",&tolua_err);
03178  return 0;
03179 #endif
03180 }
03181 #endif //#ifndef TOLUA_DISABLE
03182 
03183 /* method: set_y of class  fawkes::NavigatorInterface */
03184 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_set_y00
03185 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_set_y00(lua_State* tolua_S)
03186 {
03187 #ifndef TOLUA_RELEASE
03188  tolua_Error tolua_err;
03189  if (
03190      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface",0,&tolua_err) ||
03191      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
03192      !tolua_isnoobj(tolua_S,3,&tolua_err)
03193  )
03194   goto tolua_lerror;
03195  else
03196 #endif
03197  {
03198   fawkes::NavigatorInterface* self = (fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
03199   const float new_y = ((const float)  tolua_tonumber(tolua_S,2,0));
03200 #ifndef TOLUA_RELEASE
03201   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_y'",NULL);
03202 #endif
03203   {
03204    self->set_y(new_y);
03205   }
03206  }
03207  return 0;
03208 #ifndef TOLUA_RELEASE
03209  tolua_lerror:
03210  tolua_error(tolua_S,"#ferror in function 'set_y'.",&tolua_err);
03211  return 0;
03212 #endif
03213 }
03214 #endif //#ifndef TOLUA_DISABLE
03215 
03216 /* method: maxlenof_y of class  fawkes::NavigatorInterface */
03217 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_maxlenof_y00
03218 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_maxlenof_y00(lua_State* tolua_S)
03219 {
03220 #ifndef TOLUA_RELEASE
03221  tolua_Error tolua_err;
03222  if (
03223      !tolua_isusertype(tolua_S,1,"const fawkes::NavigatorInterface",0,&tolua_err) ||
03224      !tolua_isnoobj(tolua_S,2,&tolua_err)
03225  )
03226   goto tolua_lerror;
03227  else
03228 #endif
03229  {
03230   const fawkes::NavigatorInterface* self = (const fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
03231 #ifndef TOLUA_RELEASE
03232   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_y'",NULL);
03233 #endif
03234   {
03235    int tolua_ret = (int)  self->maxlenof_y();
03236    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03237   }
03238  }
03239  return 1;
03240 #ifndef TOLUA_RELEASE
03241  tolua_lerror:
03242  tolua_error(tolua_S,"#ferror in function 'maxlenof_y'.",&tolua_err);
03243  return 0;
03244 #endif
03245 }
03246 #endif //#ifndef TOLUA_DISABLE
03247 
03248 /* method: dest_x of class  fawkes::NavigatorInterface */
03249 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_dest_x00
03250 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_dest_x00(lua_State* tolua_S)
03251 {
03252 #ifndef TOLUA_RELEASE
03253  tolua_Error tolua_err;
03254  if (
03255      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface",0,&tolua_err) ||
03256      !tolua_isnoobj(tolua_S,2,&tolua_err)
03257  )
03258   goto tolua_lerror;
03259  else
03260 #endif
03261  {
03262   fawkes::NavigatorInterface* self = (fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
03263 #ifndef TOLUA_RELEASE
03264   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'dest_x'",NULL);
03265 #endif
03266   {
03267    float tolua_ret = (float)  self->dest_x();
03268    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03269   }
03270  }
03271  return 1;
03272 #ifndef TOLUA_RELEASE
03273  tolua_lerror:
03274  tolua_error(tolua_S,"#ferror in function 'dest_x'.",&tolua_err);
03275  return 0;
03276 #endif
03277 }
03278 #endif //#ifndef TOLUA_DISABLE
03279 
03280 /* method: set_dest_x of class  fawkes::NavigatorInterface */
03281 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_set_dest_x00
03282 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_set_dest_x00(lua_State* tolua_S)
03283 {
03284 #ifndef TOLUA_RELEASE
03285  tolua_Error tolua_err;
03286  if (
03287      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface",0,&tolua_err) ||
03288      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
03289      !tolua_isnoobj(tolua_S,3,&tolua_err)
03290  )
03291   goto tolua_lerror;
03292  else
03293 #endif
03294  {
03295   fawkes::NavigatorInterface* self = (fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
03296   const float new_dest_x = ((const float)  tolua_tonumber(tolua_S,2,0));
03297 #ifndef TOLUA_RELEASE
03298   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_dest_x'",NULL);
03299 #endif
03300   {
03301    self->set_dest_x(new_dest_x);
03302   }
03303  }
03304  return 0;
03305 #ifndef TOLUA_RELEASE
03306  tolua_lerror:
03307  tolua_error(tolua_S,"#ferror in function 'set_dest_x'.",&tolua_err);
03308  return 0;
03309 #endif
03310 }
03311 #endif //#ifndef TOLUA_DISABLE
03312 
03313 /* method: maxlenof_dest_x of class  fawkes::NavigatorInterface */
03314 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_maxlenof_dest_x00
03315 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_maxlenof_dest_x00(lua_State* tolua_S)
03316 {
03317 #ifndef TOLUA_RELEASE
03318  tolua_Error tolua_err;
03319  if (
03320      !tolua_isusertype(tolua_S,1,"const fawkes::NavigatorInterface",0,&tolua_err) ||
03321      !tolua_isnoobj(tolua_S,2,&tolua_err)
03322  )
03323   goto tolua_lerror;
03324  else
03325 #endif
03326  {
03327   const fawkes::NavigatorInterface* self = (const fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
03328 #ifndef TOLUA_RELEASE
03329   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_dest_x'",NULL);
03330 #endif
03331   {
03332    int tolua_ret = (int)  self->maxlenof_dest_x();
03333    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03334   }
03335  }
03336  return 1;
03337 #ifndef TOLUA_RELEASE
03338  tolua_lerror:
03339  tolua_error(tolua_S,"#ferror in function 'maxlenof_dest_x'.",&tolua_err);
03340  return 0;
03341 #endif
03342 }
03343 #endif //#ifndef TOLUA_DISABLE
03344 
03345 /* method: dest_y of class  fawkes::NavigatorInterface */
03346 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_dest_y00
03347 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_dest_y00(lua_State* tolua_S)
03348 {
03349 #ifndef TOLUA_RELEASE
03350  tolua_Error tolua_err;
03351  if (
03352      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface",0,&tolua_err) ||
03353      !tolua_isnoobj(tolua_S,2,&tolua_err)
03354  )
03355   goto tolua_lerror;
03356  else
03357 #endif
03358  {
03359   fawkes::NavigatorInterface* self = (fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
03360 #ifndef TOLUA_RELEASE
03361   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'dest_y'",NULL);
03362 #endif
03363   {
03364    float tolua_ret = (float)  self->dest_y();
03365    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03366   }
03367  }
03368  return 1;
03369 #ifndef TOLUA_RELEASE
03370  tolua_lerror:
03371  tolua_error(tolua_S,"#ferror in function 'dest_y'.",&tolua_err);
03372  return 0;
03373 #endif
03374 }
03375 #endif //#ifndef TOLUA_DISABLE
03376 
03377 /* method: set_dest_y of class  fawkes::NavigatorInterface */
03378 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_set_dest_y00
03379 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_set_dest_y00(lua_State* tolua_S)
03380 {
03381 #ifndef TOLUA_RELEASE
03382  tolua_Error tolua_err;
03383  if (
03384      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface",0,&tolua_err) ||
03385      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
03386      !tolua_isnoobj(tolua_S,3,&tolua_err)
03387  )
03388   goto tolua_lerror;
03389  else
03390 #endif
03391  {
03392   fawkes::NavigatorInterface* self = (fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
03393   const float new_dest_y = ((const float)  tolua_tonumber(tolua_S,2,0));
03394 #ifndef TOLUA_RELEASE
03395   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_dest_y'",NULL);
03396 #endif
03397   {
03398    self->set_dest_y(new_dest_y);
03399   }
03400  }
03401  return 0;
03402 #ifndef TOLUA_RELEASE
03403  tolua_lerror:
03404  tolua_error(tolua_S,"#ferror in function 'set_dest_y'.",&tolua_err);
03405  return 0;
03406 #endif
03407 }
03408 #endif //#ifndef TOLUA_DISABLE
03409 
03410 /* method: maxlenof_dest_y of class  fawkes::NavigatorInterface */
03411 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_maxlenof_dest_y00
03412 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_maxlenof_dest_y00(lua_State* tolua_S)
03413 {
03414 #ifndef TOLUA_RELEASE
03415  tolua_Error tolua_err;
03416  if (
03417      !tolua_isusertype(tolua_S,1,"const fawkes::NavigatorInterface",0,&tolua_err) ||
03418      !tolua_isnoobj(tolua_S,2,&tolua_err)
03419  )
03420   goto tolua_lerror;
03421  else
03422 #endif
03423  {
03424   const fawkes::NavigatorInterface* self = (const fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
03425 #ifndef TOLUA_RELEASE
03426   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_dest_y'",NULL);
03427 #endif
03428   {
03429    int tolua_ret = (int)  self->maxlenof_dest_y();
03430    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03431   }
03432  }
03433  return 1;
03434 #ifndef TOLUA_RELEASE
03435  tolua_lerror:
03436  tolua_error(tolua_S,"#ferror in function 'maxlenof_dest_y'.",&tolua_err);
03437  return 0;
03438 #endif
03439 }
03440 #endif //#ifndef TOLUA_DISABLE
03441 
03442 /* method: dest_ori of class  fawkes::NavigatorInterface */
03443 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_dest_ori00
03444 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_dest_ori00(lua_State* tolua_S)
03445 {
03446 #ifndef TOLUA_RELEASE
03447  tolua_Error tolua_err;
03448  if (
03449      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface",0,&tolua_err) ||
03450      !tolua_isnoobj(tolua_S,2,&tolua_err)
03451  )
03452   goto tolua_lerror;
03453  else
03454 #endif
03455  {
03456   fawkes::NavigatorInterface* self = (fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
03457 #ifndef TOLUA_RELEASE
03458   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'dest_ori'",NULL);
03459 #endif
03460   {
03461    float tolua_ret = (float)  self->dest_ori();
03462    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03463   }
03464  }
03465  return 1;
03466 #ifndef TOLUA_RELEASE
03467  tolua_lerror:
03468  tolua_error(tolua_S,"#ferror in function 'dest_ori'.",&tolua_err);
03469  return 0;
03470 #endif
03471 }
03472 #endif //#ifndef TOLUA_DISABLE
03473 
03474 /* method: set_dest_ori of class  fawkes::NavigatorInterface */
03475 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_set_dest_ori00
03476 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_set_dest_ori00(lua_State* tolua_S)
03477 {
03478 #ifndef TOLUA_RELEASE
03479  tolua_Error tolua_err;
03480  if (
03481      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface",0,&tolua_err) ||
03482      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
03483      !tolua_isnoobj(tolua_S,3,&tolua_err)
03484  )
03485   goto tolua_lerror;
03486  else
03487 #endif
03488  {
03489   fawkes::NavigatorInterface* self = (fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
03490   const float new_dest_ori = ((const float)  tolua_tonumber(tolua_S,2,0));
03491 #ifndef TOLUA_RELEASE
03492   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_dest_ori'",NULL);
03493 #endif
03494   {
03495    self->set_dest_ori(new_dest_ori);
03496   }
03497  }
03498  return 0;
03499 #ifndef TOLUA_RELEASE
03500  tolua_lerror:
03501  tolua_error(tolua_S,"#ferror in function 'set_dest_ori'.",&tolua_err);
03502  return 0;
03503 #endif
03504 }
03505 #endif //#ifndef TOLUA_DISABLE
03506 
03507 /* method: maxlenof_dest_ori of class  fawkes::NavigatorInterface */
03508 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_maxlenof_dest_ori00
03509 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_maxlenof_dest_ori00(lua_State* tolua_S)
03510 {
03511 #ifndef TOLUA_RELEASE
03512  tolua_Error tolua_err;
03513  if (
03514      !tolua_isusertype(tolua_S,1,"const fawkes::NavigatorInterface",0,&tolua_err) ||
03515      !tolua_isnoobj(tolua_S,2,&tolua_err)
03516  )
03517   goto tolua_lerror;
03518  else
03519 #endif
03520  {
03521   const fawkes::NavigatorInterface* self = (const fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
03522 #ifndef TOLUA_RELEASE
03523   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_dest_ori'",NULL);
03524 #endif
03525   {
03526    int tolua_ret = (int)  self->maxlenof_dest_ori();
03527    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03528   }
03529  }
03530  return 1;
03531 #ifndef TOLUA_RELEASE
03532  tolua_lerror:
03533  tolua_error(tolua_S,"#ferror in function 'maxlenof_dest_ori'.",&tolua_err);
03534  return 0;
03535 #endif
03536 }
03537 #endif //#ifndef TOLUA_DISABLE
03538 
03539 /* method: dest_dist of class  fawkes::NavigatorInterface */
03540 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_dest_dist00
03541 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_dest_dist00(lua_State* tolua_S)
03542 {
03543 #ifndef TOLUA_RELEASE
03544  tolua_Error tolua_err;
03545  if (
03546      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface",0,&tolua_err) ||
03547      !tolua_isnoobj(tolua_S,2,&tolua_err)
03548  )
03549   goto tolua_lerror;
03550  else
03551 #endif
03552  {
03553   fawkes::NavigatorInterface* self = (fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
03554 #ifndef TOLUA_RELEASE
03555   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'dest_dist'",NULL);
03556 #endif
03557   {
03558    float tolua_ret = (float)  self->dest_dist();
03559    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03560   }
03561  }
03562  return 1;
03563 #ifndef TOLUA_RELEASE
03564  tolua_lerror:
03565  tolua_error(tolua_S,"#ferror in function 'dest_dist'.",&tolua_err);
03566  return 0;
03567 #endif
03568 }
03569 #endif //#ifndef TOLUA_DISABLE
03570 
03571 /* method: set_dest_dist of class  fawkes::NavigatorInterface */
03572 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_set_dest_dist00
03573 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_set_dest_dist00(lua_State* tolua_S)
03574 {
03575 #ifndef TOLUA_RELEASE
03576  tolua_Error tolua_err;
03577  if (
03578      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface",0,&tolua_err) ||
03579      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
03580      !tolua_isnoobj(tolua_S,3,&tolua_err)
03581  )
03582   goto tolua_lerror;
03583  else
03584 #endif
03585  {
03586   fawkes::NavigatorInterface* self = (fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
03587   const float new_dest_dist = ((const float)  tolua_tonumber(tolua_S,2,0));
03588 #ifndef TOLUA_RELEASE
03589   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_dest_dist'",NULL);
03590 #endif
03591   {
03592    self->set_dest_dist(new_dest_dist);
03593   }
03594  }
03595  return 0;
03596 #ifndef TOLUA_RELEASE
03597  tolua_lerror:
03598  tolua_error(tolua_S,"#ferror in function 'set_dest_dist'.",&tolua_err);
03599  return 0;
03600 #endif
03601 }
03602 #endif //#ifndef TOLUA_DISABLE
03603 
03604 /* method: maxlenof_dest_dist of class  fawkes::NavigatorInterface */
03605 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_maxlenof_dest_dist00
03606 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_maxlenof_dest_dist00(lua_State* tolua_S)
03607 {
03608 #ifndef TOLUA_RELEASE
03609  tolua_Error tolua_err;
03610  if (
03611      !tolua_isusertype(tolua_S,1,"const fawkes::NavigatorInterface",0,&tolua_err) ||
03612      !tolua_isnoobj(tolua_S,2,&tolua_err)
03613  )
03614   goto tolua_lerror;
03615  else
03616 #endif
03617  {
03618   const fawkes::NavigatorInterface* self = (const fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
03619 #ifndef TOLUA_RELEASE
03620   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_dest_dist'",NULL);
03621 #endif
03622   {
03623    int tolua_ret = (int)  self->maxlenof_dest_dist();
03624    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03625   }
03626  }
03627  return 1;
03628 #ifndef TOLUA_RELEASE
03629  tolua_lerror:
03630  tolua_error(tolua_S,"#ferror in function 'maxlenof_dest_dist'.",&tolua_err);
03631  return 0;
03632 #endif
03633 }
03634 #endif //#ifndef TOLUA_DISABLE
03635 
03636 /* method: msgid of class  fawkes::NavigatorInterface */
03637 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_msgid00
03638 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_msgid00(lua_State* tolua_S)
03639 {
03640 #ifndef TOLUA_RELEASE
03641  tolua_Error tolua_err;
03642  if (
03643      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface",0,&tolua_err) ||
03644      !tolua_isnoobj(tolua_S,2,&tolua_err)
03645  )
03646   goto tolua_lerror;
03647  else
03648 #endif
03649  {
03650   fawkes::NavigatorInterface* self = (fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
03651 #ifndef TOLUA_RELEASE
03652   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgid'",NULL);
03653 #endif
03654   {
03655    unsigned int tolua_ret = (unsigned int)  self->msgid();
03656    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03657   }
03658  }
03659  return 1;
03660 #ifndef TOLUA_RELEASE
03661  tolua_lerror:
03662  tolua_error(tolua_S,"#ferror in function 'msgid'.",&tolua_err);
03663  return 0;
03664 #endif
03665 }
03666 #endif //#ifndef TOLUA_DISABLE
03667 
03668 /* method: set_msgid of class  fawkes::NavigatorInterface */
03669 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_set_msgid00
03670 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_set_msgid00(lua_State* tolua_S)
03671 {
03672 #ifndef TOLUA_RELEASE
03673  tolua_Error tolua_err;
03674  if (
03675      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface",0,&tolua_err) ||
03676      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
03677      !tolua_isnoobj(tolua_S,3,&tolua_err)
03678  )
03679   goto tolua_lerror;
03680  else
03681 #endif
03682  {
03683   fawkes::NavigatorInterface* self = (fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
03684   unsigned const int new_msgid = ((unsigned const int)  tolua_tonumber(tolua_S,2,0));
03685 #ifndef TOLUA_RELEASE
03686   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_msgid'",NULL);
03687 #endif
03688   {
03689    self->set_msgid(new_msgid);
03690   }
03691  }
03692  return 0;
03693 #ifndef TOLUA_RELEASE
03694  tolua_lerror:
03695  tolua_error(tolua_S,"#ferror in function 'set_msgid'.",&tolua_err);
03696  return 0;
03697 #endif
03698 }
03699 #endif //#ifndef TOLUA_DISABLE
03700 
03701 /* method: maxlenof_msgid of class  fawkes::NavigatorInterface */
03702 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_maxlenof_msgid00
03703 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_maxlenof_msgid00(lua_State* tolua_S)
03704 {
03705 #ifndef TOLUA_RELEASE
03706  tolua_Error tolua_err;
03707  if (
03708      !tolua_isusertype(tolua_S,1,"const fawkes::NavigatorInterface",0,&tolua_err) ||
03709      !tolua_isnoobj(tolua_S,2,&tolua_err)
03710  )
03711   goto tolua_lerror;
03712  else
03713 #endif
03714  {
03715   const fawkes::NavigatorInterface* self = (const fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
03716 #ifndef TOLUA_RELEASE
03717   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_msgid'",NULL);
03718 #endif
03719   {
03720    int tolua_ret = (int)  self->maxlenof_msgid();
03721    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03722   }
03723  }
03724  return 1;
03725 #ifndef TOLUA_RELEASE
03726  tolua_lerror:
03727  tolua_error(tolua_S,"#ferror in function 'maxlenof_msgid'.",&tolua_err);
03728  return 0;
03729 #endif
03730 }
03731 #endif //#ifndef TOLUA_DISABLE
03732 
03733 /* method: is_final of class  fawkes::NavigatorInterface */
03734 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_is_final00
03735 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_is_final00(lua_State* tolua_S)
03736 {
03737 #ifndef TOLUA_RELEASE
03738  tolua_Error tolua_err;
03739  if (
03740      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface",0,&tolua_err) ||
03741      !tolua_isnoobj(tolua_S,2,&tolua_err)
03742  )
03743   goto tolua_lerror;
03744  else
03745 #endif
03746  {
03747   fawkes::NavigatorInterface* self = (fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
03748 #ifndef TOLUA_RELEASE
03749   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_final'",NULL);
03750 #endif
03751   {
03752    bool tolua_ret = (bool)  self->is_final();
03753    tolua_pushboolean(tolua_S,(bool)tolua_ret);
03754   }
03755  }
03756  return 1;
03757 #ifndef TOLUA_RELEASE
03758  tolua_lerror:
03759  tolua_error(tolua_S,"#ferror in function 'is_final'.",&tolua_err);
03760  return 0;
03761 #endif
03762 }
03763 #endif //#ifndef TOLUA_DISABLE
03764 
03765 /* method: set_final of class  fawkes::NavigatorInterface */
03766 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_set_final00
03767 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_set_final00(lua_State* tolua_S)
03768 {
03769 #ifndef TOLUA_RELEASE
03770  tolua_Error tolua_err;
03771  if (
03772      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface",0,&tolua_err) ||
03773      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
03774      !tolua_isnoobj(tolua_S,3,&tolua_err)
03775  )
03776   goto tolua_lerror;
03777  else
03778 #endif
03779  {
03780   fawkes::NavigatorInterface* self = (fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
03781   const bool new_final = ((const bool)  tolua_toboolean(tolua_S,2,0));
03782 #ifndef TOLUA_RELEASE
03783   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_final'",NULL);
03784 #endif
03785   {
03786    self->set_final(new_final);
03787   }
03788  }
03789  return 0;
03790 #ifndef TOLUA_RELEASE
03791  tolua_lerror:
03792  tolua_error(tolua_S,"#ferror in function 'set_final'.",&tolua_err);
03793  return 0;
03794 #endif
03795 }
03796 #endif //#ifndef TOLUA_DISABLE
03797 
03798 /* method: maxlenof_final of class  fawkes::NavigatorInterface */
03799 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_maxlenof_final00
03800 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_maxlenof_final00(lua_State* tolua_S)
03801 {
03802 #ifndef TOLUA_RELEASE
03803  tolua_Error tolua_err;
03804  if (
03805      !tolua_isusertype(tolua_S,1,"const fawkes::NavigatorInterface",0,&tolua_err) ||
03806      !tolua_isnoobj(tolua_S,2,&tolua_err)
03807  )
03808   goto tolua_lerror;
03809  else
03810 #endif
03811  {
03812   const fawkes::NavigatorInterface* self = (const fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
03813 #ifndef TOLUA_RELEASE
03814   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_final'",NULL);
03815 #endif
03816   {
03817    int tolua_ret = (int)  self->maxlenof_final();
03818    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03819   }
03820  }
03821  return 1;
03822 #ifndef TOLUA_RELEASE
03823  tolua_lerror:
03824  tolua_error(tolua_S,"#ferror in function 'maxlenof_final'.",&tolua_err);
03825  return 0;
03826 #endif
03827 }
03828 #endif //#ifndef TOLUA_DISABLE
03829 
03830 /* method: error_code of class  fawkes::NavigatorInterface */
03831 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_error_code00
03832 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_error_code00(lua_State* tolua_S)
03833 {
03834 #ifndef TOLUA_RELEASE
03835  tolua_Error tolua_err;
03836  if (
03837      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface",0,&tolua_err) ||
03838      !tolua_isnoobj(tolua_S,2,&tolua_err)
03839  )
03840   goto tolua_lerror;
03841  else
03842 #endif
03843  {
03844   fawkes::NavigatorInterface* self = (fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
03845 #ifndef TOLUA_RELEASE
03846   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'error_code'",NULL);
03847 #endif
03848   {
03849    unsigned int tolua_ret = (unsigned int)  self->error_code();
03850    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03851   }
03852  }
03853  return 1;
03854 #ifndef TOLUA_RELEASE
03855  tolua_lerror:
03856  tolua_error(tolua_S,"#ferror in function 'error_code'.",&tolua_err);
03857  return 0;
03858 #endif
03859 }
03860 #endif //#ifndef TOLUA_DISABLE
03861 
03862 /* method: set_error_code of class  fawkes::NavigatorInterface */
03863 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_set_error_code00
03864 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_set_error_code00(lua_State* tolua_S)
03865 {
03866 #ifndef TOLUA_RELEASE
03867  tolua_Error tolua_err;
03868  if (
03869      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface",0,&tolua_err) ||
03870      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
03871      !tolua_isnoobj(tolua_S,3,&tolua_err)
03872  )
03873   goto tolua_lerror;
03874  else
03875 #endif
03876  {
03877   fawkes::NavigatorInterface* self = (fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
03878   unsigned const int new_error_code = ((unsigned const int)  tolua_tonumber(tolua_S,2,0));
03879 #ifndef TOLUA_RELEASE
03880   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_error_code'",NULL);
03881 #endif
03882   {
03883    self->set_error_code(new_error_code);
03884   }
03885  }
03886  return 0;
03887 #ifndef TOLUA_RELEASE
03888  tolua_lerror:
03889  tolua_error(tolua_S,"#ferror in function 'set_error_code'.",&tolua_err);
03890  return 0;
03891 #endif
03892 }
03893 #endif //#ifndef TOLUA_DISABLE
03894 
03895 /* method: maxlenof_error_code of class  fawkes::NavigatorInterface */
03896 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_maxlenof_error_code00
03897 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_maxlenof_error_code00(lua_State* tolua_S)
03898 {
03899 #ifndef TOLUA_RELEASE
03900  tolua_Error tolua_err;
03901  if (
03902      !tolua_isusertype(tolua_S,1,"const fawkes::NavigatorInterface",0,&tolua_err) ||
03903      !tolua_isnoobj(tolua_S,2,&tolua_err)
03904  )
03905   goto tolua_lerror;
03906  else
03907 #endif
03908  {
03909   const fawkes::NavigatorInterface* self = (const fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
03910 #ifndef TOLUA_RELEASE
03911   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_error_code'",NULL);
03912 #endif
03913   {
03914    int tolua_ret = (int)  self->maxlenof_error_code();
03915    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03916   }
03917  }
03918  return 1;
03919 #ifndef TOLUA_RELEASE
03920  tolua_lerror:
03921  tolua_error(tolua_S,"#ferror in function 'maxlenof_error_code'.",&tolua_err);
03922  return 0;
03923 #endif
03924 }
03925 #endif //#ifndef TOLUA_DISABLE
03926 
03927 /* method: max_velocity of class  fawkes::NavigatorInterface */
03928 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_max_velocity00
03929 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_max_velocity00(lua_State* tolua_S)
03930 {
03931 #ifndef TOLUA_RELEASE
03932  tolua_Error tolua_err;
03933  if (
03934      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface",0,&tolua_err) ||
03935      !tolua_isnoobj(tolua_S,2,&tolua_err)
03936  )
03937   goto tolua_lerror;
03938  else
03939 #endif
03940  {
03941   fawkes::NavigatorInterface* self = (fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
03942 #ifndef TOLUA_RELEASE
03943   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'max_velocity'",NULL);
03944 #endif
03945   {
03946    float tolua_ret = (float)  self->max_velocity();
03947    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03948   }
03949  }
03950  return 1;
03951 #ifndef TOLUA_RELEASE
03952  tolua_lerror:
03953  tolua_error(tolua_S,"#ferror in function 'max_velocity'.",&tolua_err);
03954  return 0;
03955 #endif
03956 }
03957 #endif //#ifndef TOLUA_DISABLE
03958 
03959 /* method: set_max_velocity of class  fawkes::NavigatorInterface */
03960 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_set_max_velocity00
03961 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_set_max_velocity00(lua_State* tolua_S)
03962 {
03963 #ifndef TOLUA_RELEASE
03964  tolua_Error tolua_err;
03965  if (
03966      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface",0,&tolua_err) ||
03967      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
03968      !tolua_isnoobj(tolua_S,3,&tolua_err)
03969  )
03970   goto tolua_lerror;
03971  else
03972 #endif
03973  {
03974   fawkes::NavigatorInterface* self = (fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
03975   const float new_max_velocity = ((const float)  tolua_tonumber(tolua_S,2,0));
03976 #ifndef TOLUA_RELEASE
03977   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_max_velocity'",NULL);
03978 #endif
03979   {
03980    self->set_max_velocity(new_max_velocity);
03981   }
03982  }
03983  return 0;
03984 #ifndef TOLUA_RELEASE
03985  tolua_lerror:
03986  tolua_error(tolua_S,"#ferror in function 'set_max_velocity'.",&tolua_err);
03987  return 0;
03988 #endif
03989 }
03990 #endif //#ifndef TOLUA_DISABLE
03991 
03992 /* method: maxlenof_max_velocity of class  fawkes::NavigatorInterface */
03993 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_maxlenof_max_velocity00
03994 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_maxlenof_max_velocity00(lua_State* tolua_S)
03995 {
03996 #ifndef TOLUA_RELEASE
03997  tolua_Error tolua_err;
03998  if (
03999      !tolua_isusertype(tolua_S,1,"const fawkes::NavigatorInterface",0,&tolua_err) ||
04000      !tolua_isnoobj(tolua_S,2,&tolua_err)
04001  )
04002   goto tolua_lerror;
04003  else
04004 #endif
04005  {
04006   const fawkes::NavigatorInterface* self = (const fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
04007 #ifndef TOLUA_RELEASE
04008   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_max_velocity'",NULL);
04009 #endif
04010   {
04011    int tolua_ret = (int)  self->maxlenof_max_velocity();
04012    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04013   }
04014  }
04015  return 1;
04016 #ifndef TOLUA_RELEASE
04017  tolua_lerror:
04018  tolua_error(tolua_S,"#ferror in function 'maxlenof_max_velocity'.",&tolua_err);
04019  return 0;
04020 #endif
04021 }
04022 #endif //#ifndef TOLUA_DISABLE
04023 
04024 /* method: security_distance of class  fawkes::NavigatorInterface */
04025 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_security_distance00
04026 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_security_distance00(lua_State* tolua_S)
04027 {
04028 #ifndef TOLUA_RELEASE
04029  tolua_Error tolua_err;
04030  if (
04031      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface",0,&tolua_err) ||
04032      !tolua_isnoobj(tolua_S,2,&tolua_err)
04033  )
04034   goto tolua_lerror;
04035  else
04036 #endif
04037  {
04038   fawkes::NavigatorInterface* self = (fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
04039 #ifndef TOLUA_RELEASE
04040   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'security_distance'",NULL);
04041 #endif
04042   {
04043    float tolua_ret = (float)  self->security_distance();
04044    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04045   }
04046  }
04047  return 1;
04048 #ifndef TOLUA_RELEASE
04049  tolua_lerror:
04050  tolua_error(tolua_S,"#ferror in function 'security_distance'.",&tolua_err);
04051  return 0;
04052 #endif
04053 }
04054 #endif //#ifndef TOLUA_DISABLE
04055 
04056 /* method: set_security_distance of class  fawkes::NavigatorInterface */
04057 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_set_security_distance00
04058 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_set_security_distance00(lua_State* tolua_S)
04059 {
04060 #ifndef TOLUA_RELEASE
04061  tolua_Error tolua_err;
04062  if (
04063      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface",0,&tolua_err) ||
04064      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
04065      !tolua_isnoobj(tolua_S,3,&tolua_err)
04066  )
04067   goto tolua_lerror;
04068  else
04069 #endif
04070  {
04071   fawkes::NavigatorInterface* self = (fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
04072   const float new_security_distance = ((const float)  tolua_tonumber(tolua_S,2,0));
04073 #ifndef TOLUA_RELEASE
04074   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_security_distance'",NULL);
04075 #endif
04076   {
04077    self->set_security_distance(new_security_distance);
04078   }
04079  }
04080  return 0;
04081 #ifndef TOLUA_RELEASE
04082  tolua_lerror:
04083  tolua_error(tolua_S,"#ferror in function 'set_security_distance'.",&tolua_err);
04084  return 0;
04085 #endif
04086 }
04087 #endif //#ifndef TOLUA_DISABLE
04088 
04089 /* method: maxlenof_security_distance of class  fawkes::NavigatorInterface */
04090 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_maxlenof_security_distance00
04091 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_maxlenof_security_distance00(lua_State* tolua_S)
04092 {
04093 #ifndef TOLUA_RELEASE
04094  tolua_Error tolua_err;
04095  if (
04096      !tolua_isusertype(tolua_S,1,"const fawkes::NavigatorInterface",0,&tolua_err) ||
04097      !tolua_isnoobj(tolua_S,2,&tolua_err)
04098  )
04099   goto tolua_lerror;
04100  else
04101 #endif
04102  {
04103   const fawkes::NavigatorInterface* self = (const fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
04104 #ifndef TOLUA_RELEASE
04105   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_security_distance'",NULL);
04106 #endif
04107   {
04108    int tolua_ret = (int)  self->maxlenof_security_distance();
04109    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04110   }
04111  }
04112  return 1;
04113 #ifndef TOLUA_RELEASE
04114  tolua_lerror:
04115  tolua_error(tolua_S,"#ferror in function 'maxlenof_security_distance'.",&tolua_err);
04116  return 0;
04117 #endif
04118 }
04119 #endif //#ifndef TOLUA_DISABLE
04120 
04121 /* method: is_escaping_enabled of class  fawkes::NavigatorInterface */
04122 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_is_escaping_enabled00
04123 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_is_escaping_enabled00(lua_State* tolua_S)
04124 {
04125 #ifndef TOLUA_RELEASE
04126  tolua_Error tolua_err;
04127  if (
04128      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface",0,&tolua_err) ||
04129      !tolua_isnoobj(tolua_S,2,&tolua_err)
04130  )
04131   goto tolua_lerror;
04132  else
04133 #endif
04134  {
04135   fawkes::NavigatorInterface* self = (fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
04136 #ifndef TOLUA_RELEASE
04137   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_escaping_enabled'",NULL);
04138 #endif
04139   {
04140    bool tolua_ret = (bool)  self->is_escaping_enabled();
04141    tolua_pushboolean(tolua_S,(bool)tolua_ret);
04142   }
04143  }
04144  return 1;
04145 #ifndef TOLUA_RELEASE
04146  tolua_lerror:
04147  tolua_error(tolua_S,"#ferror in function 'is_escaping_enabled'.",&tolua_err);
04148  return 0;
04149 #endif
04150 }
04151 #endif //#ifndef TOLUA_DISABLE
04152 
04153 /* method: set_escaping_enabled of class  fawkes::NavigatorInterface */
04154 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_set_escaping_enabled00
04155 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_set_escaping_enabled00(lua_State* tolua_S)
04156 {
04157 #ifndef TOLUA_RELEASE
04158  tolua_Error tolua_err;
04159  if (
04160      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface",0,&tolua_err) ||
04161      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
04162      !tolua_isnoobj(tolua_S,3,&tolua_err)
04163  )
04164   goto tolua_lerror;
04165  else
04166 #endif
04167  {
04168   fawkes::NavigatorInterface* self = (fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
04169   const bool new_escaping_enabled = ((const bool)  tolua_toboolean(tolua_S,2,0));
04170 #ifndef TOLUA_RELEASE
04171   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_escaping_enabled'",NULL);
04172 #endif
04173   {
04174    self->set_escaping_enabled(new_escaping_enabled);
04175   }
04176  }
04177  return 0;
04178 #ifndef TOLUA_RELEASE
04179  tolua_lerror:
04180  tolua_error(tolua_S,"#ferror in function 'set_escaping_enabled'.",&tolua_err);
04181  return 0;
04182 #endif
04183 }
04184 #endif //#ifndef TOLUA_DISABLE
04185 
04186 /* method: maxlenof_escaping_enabled of class  fawkes::NavigatorInterface */
04187 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_maxlenof_escaping_enabled00
04188 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_maxlenof_escaping_enabled00(lua_State* tolua_S)
04189 {
04190 #ifndef TOLUA_RELEASE
04191  tolua_Error tolua_err;
04192  if (
04193      !tolua_isusertype(tolua_S,1,"const fawkes::NavigatorInterface",0,&tolua_err) ||
04194      !tolua_isnoobj(tolua_S,2,&tolua_err)
04195  )
04196   goto tolua_lerror;
04197  else
04198 #endif
04199  {
04200   const fawkes::NavigatorInterface* self = (const fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
04201 #ifndef TOLUA_RELEASE
04202   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_escaping_enabled'",NULL);
04203 #endif
04204   {
04205    int tolua_ret = (int)  self->maxlenof_escaping_enabled();
04206    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04207   }
04208  }
04209  return 1;
04210 #ifndef TOLUA_RELEASE
04211  tolua_lerror:
04212  tolua_error(tolua_S,"#ferror in function 'maxlenof_escaping_enabled'.",&tolua_err);
04213  return 0;
04214 #endif
04215 }
04216 #endif //#ifndef TOLUA_DISABLE
04217 
04218 /* method: oftype of class  fawkes::NavigatorInterface */
04219 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_oftype00
04220 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_oftype00(lua_State* tolua_S)
04221 {
04222 #ifndef TOLUA_RELEASE
04223  tolua_Error tolua_err;
04224  if (
04225      !tolua_isusertype(tolua_S,1,"const fawkes::NavigatorInterface",0,&tolua_err) ||
04226      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
04227      !tolua_isnoobj(tolua_S,3,&tolua_err)
04228  )
04229   goto tolua_lerror;
04230  else
04231 #endif
04232  {
04233   const fawkes::NavigatorInterface* self = (const fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
04234   const char* interface_type = ((const char*)  tolua_tostring(tolua_S,2,0));
04235 #ifndef TOLUA_RELEASE
04236   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'oftype'",NULL);
04237 #endif
04238   {
04239    bool tolua_ret = (bool)  self->oftype(interface_type);
04240    tolua_pushboolean(tolua_S,(bool)tolua_ret);
04241   }
04242  }
04243  return 1;
04244 #ifndef TOLUA_RELEASE
04245  tolua_lerror:
04246  tolua_error(tolua_S,"#ferror in function 'oftype'.",&tolua_err);
04247  return 0;
04248 #endif
04249 }
04250 #endif //#ifndef TOLUA_DISABLE
04251 
04252 /* method: datachunk of class  fawkes::NavigatorInterface */
04253 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_datachunk00
04254 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_datachunk00(lua_State* tolua_S)
04255 {
04256 #ifndef TOLUA_RELEASE
04257  tolua_Error tolua_err;
04258  if (
04259      !tolua_isusertype(tolua_S,1,"const fawkes::NavigatorInterface",0,&tolua_err) ||
04260      !tolua_isnoobj(tolua_S,2,&tolua_err)
04261  )
04262   goto tolua_lerror;
04263  else
04264 #endif
04265  {
04266   const fawkes::NavigatorInterface* self = (const fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
04267 #ifndef TOLUA_RELEASE
04268   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datachunk'",NULL);
04269 #endif
04270   {
04271    const void* tolua_ret = (const void*)  self->datachunk();
04272    tolua_pushuserdata(tolua_S,(void*)tolua_ret);
04273   }
04274  }
04275  return 1;
04276 #ifndef TOLUA_RELEASE
04277  tolua_lerror:
04278  tolua_error(tolua_S,"#ferror in function 'datachunk'.",&tolua_err);
04279  return 0;
04280 #endif
04281 }
04282 #endif //#ifndef TOLUA_DISABLE
04283 
04284 /* method: datasize of class  fawkes::NavigatorInterface */
04285 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_datasize00
04286 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_datasize00(lua_State* tolua_S)
04287 {
04288 #ifndef TOLUA_RELEASE
04289  tolua_Error tolua_err;
04290  if (
04291      !tolua_isusertype(tolua_S,1,"const fawkes::NavigatorInterface",0,&tolua_err) ||
04292      !tolua_isnoobj(tolua_S,2,&tolua_err)
04293  )
04294   goto tolua_lerror;
04295  else
04296 #endif
04297  {
04298   const fawkes::NavigatorInterface* self = (const fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
04299 #ifndef TOLUA_RELEASE
04300   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datasize'",NULL);
04301 #endif
04302   {
04303    unsigned int tolua_ret = (unsigned int)  self->datasize();
04304    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04305   }
04306  }
04307  return 1;
04308 #ifndef TOLUA_RELEASE
04309  tolua_lerror:
04310  tolua_error(tolua_S,"#ferror in function 'datasize'.",&tolua_err);
04311  return 0;
04312 #endif
04313 }
04314 #endif //#ifndef TOLUA_DISABLE
04315 
04316 /* method: type of class  fawkes::NavigatorInterface */
04317 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_type00
04318 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_type00(lua_State* tolua_S)
04319 {
04320 #ifndef TOLUA_RELEASE
04321  tolua_Error tolua_err;
04322  if (
04323      !tolua_isusertype(tolua_S,1,"const fawkes::NavigatorInterface",0,&tolua_err) ||
04324      !tolua_isnoobj(tolua_S,2,&tolua_err)
04325  )
04326   goto tolua_lerror;
04327  else
04328 #endif
04329  {
04330   const fawkes::NavigatorInterface* self = (const fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
04331 #ifndef TOLUA_RELEASE
04332   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'type'",NULL);
04333 #endif
04334   {
04335    const char* tolua_ret = (const char*)  self->type();
04336    tolua_pushstring(tolua_S,(const char*)tolua_ret);
04337   }
04338  }
04339  return 1;
04340 #ifndef TOLUA_RELEASE
04341  tolua_lerror:
04342  tolua_error(tolua_S,"#ferror in function 'type'.",&tolua_err);
04343  return 0;
04344 #endif
04345 }
04346 #endif //#ifndef TOLUA_DISABLE
04347 
04348 /* method: id of class  fawkes::NavigatorInterface */
04349 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_id00
04350 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_id00(lua_State* tolua_S)
04351 {
04352 #ifndef TOLUA_RELEASE
04353  tolua_Error tolua_err;
04354  if (
04355      !tolua_isusertype(tolua_S,1,"const fawkes::NavigatorInterface",0,&tolua_err) ||
04356      !tolua_isnoobj(tolua_S,2,&tolua_err)
04357  )
04358   goto tolua_lerror;
04359  else
04360 #endif
04361  {
04362   const fawkes::NavigatorInterface* self = (const fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
04363 #ifndef TOLUA_RELEASE
04364   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'id'",NULL);
04365 #endif
04366   {
04367    const char* tolua_ret = (const char*)  self->id();
04368    tolua_pushstring(tolua_S,(const char*)tolua_ret);
04369   }
04370  }
04371  return 1;
04372 #ifndef TOLUA_RELEASE
04373  tolua_lerror:
04374  tolua_error(tolua_S,"#ferror in function 'id'.",&tolua_err);
04375  return 0;
04376 #endif
04377 }
04378 #endif //#ifndef TOLUA_DISABLE
04379 
04380 /* method: uid of class  fawkes::NavigatorInterface */
04381 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_uid00
04382 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_uid00(lua_State* tolua_S)
04383 {
04384 #ifndef TOLUA_RELEASE
04385  tolua_Error tolua_err;
04386  if (
04387      !tolua_isusertype(tolua_S,1,"const fawkes::NavigatorInterface",0,&tolua_err) ||
04388      !tolua_isnoobj(tolua_S,2,&tolua_err)
04389  )
04390   goto tolua_lerror;
04391  else
04392 #endif
04393  {
04394   const fawkes::NavigatorInterface* self = (const fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
04395 #ifndef TOLUA_RELEASE
04396   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'uid'",NULL);
04397 #endif
04398   {
04399    const char* tolua_ret = (const char*)  self->uid();
04400    tolua_pushstring(tolua_S,(const char*)tolua_ret);
04401   }
04402  }
04403  return 1;
04404 #ifndef TOLUA_RELEASE
04405  tolua_lerror:
04406  tolua_error(tolua_S,"#ferror in function 'uid'.",&tolua_err);
04407  return 0;
04408 #endif
04409 }
04410 #endif //#ifndef TOLUA_DISABLE
04411 
04412 /* method: serial of class  fawkes::NavigatorInterface */
04413 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_serial00
04414 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_serial00(lua_State* tolua_S)
04415 {
04416 #ifndef TOLUA_RELEASE
04417  tolua_Error tolua_err;
04418  if (
04419      !tolua_isusertype(tolua_S,1,"const fawkes::NavigatorInterface",0,&tolua_err) ||
04420      !tolua_isnoobj(tolua_S,2,&tolua_err)
04421  )
04422   goto tolua_lerror;
04423  else
04424 #endif
04425  {
04426   const fawkes::NavigatorInterface* self = (const fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
04427 #ifndef TOLUA_RELEASE
04428   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'serial'",NULL);
04429 #endif
04430   {
04431    unsigned int tolua_ret = (unsigned int)  self->serial();
04432    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04433   }
04434  }
04435  return 1;
04436 #ifndef TOLUA_RELEASE
04437  tolua_lerror:
04438  tolua_error(tolua_S,"#ferror in function 'serial'.",&tolua_err);
04439  return 0;
04440 #endif
04441 }
04442 #endif //#ifndef TOLUA_DISABLE
04443 
04444 /* method: mem_serial of class  fawkes::NavigatorInterface */
04445 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_mem_serial00
04446 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_mem_serial00(lua_State* tolua_S)
04447 {
04448 #ifndef TOLUA_RELEASE
04449  tolua_Error tolua_err;
04450  if (
04451      !tolua_isusertype(tolua_S,1,"const fawkes::NavigatorInterface",0,&tolua_err) ||
04452      !tolua_isnoobj(tolua_S,2,&tolua_err)
04453  )
04454   goto tolua_lerror;
04455  else
04456 #endif
04457  {
04458   const fawkes::NavigatorInterface* self = (const fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
04459 #ifndef TOLUA_RELEASE
04460   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'mem_serial'",NULL);
04461 #endif
04462   {
04463    unsigned int tolua_ret = (unsigned int)  self->mem_serial();
04464    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04465   }
04466  }
04467  return 1;
04468 #ifndef TOLUA_RELEASE
04469  tolua_lerror:
04470  tolua_error(tolua_S,"#ferror in function 'mem_serial'.",&tolua_err);
04471  return 0;
04472 #endif
04473 }
04474 #endif //#ifndef TOLUA_DISABLE
04475 
04476 /* method: operator== of class  fawkes::NavigatorInterface */
04477 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface__eq00
04478 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface__eq00(lua_State* tolua_S)
04479 {
04480 #ifndef TOLUA_RELEASE
04481  tolua_Error tolua_err;
04482  if (
04483      !tolua_isusertype(tolua_S,1,"const fawkes::NavigatorInterface",0,&tolua_err) ||
04484      !tolua_isusertype(tolua_S,2,"Interface",0,&tolua_err) ||
04485      !tolua_isnoobj(tolua_S,3,&tolua_err)
04486  )
04487   goto tolua_lerror;
04488  else
04489 #endif
04490  {
04491   const fawkes::NavigatorInterface* self = (const fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
04492   Interface* comp = ((Interface*)  tolua_tousertype(tolua_S,2,0));
04493 #ifndef TOLUA_RELEASE
04494   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='",NULL);
04495 #endif
04496   {
04497    bool tolua_ret = (bool)  self->operator==(*comp);
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 '.eq'.",&tolua_err);
04505  return 0;
04506 #endif
04507 }
04508 #endif //#ifndef TOLUA_DISABLE
04509 
04510 /* method: hash of class  fawkes::NavigatorInterface */
04511 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_hash00
04512 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_hash00(lua_State* tolua_S)
04513 {
04514 #ifndef TOLUA_RELEASE
04515  tolua_Error tolua_err;
04516  if (
04517      !tolua_isusertype(tolua_S,1,"const fawkes::NavigatorInterface",0,&tolua_err) ||
04518      !tolua_isnoobj(tolua_S,2,&tolua_err)
04519  )
04520   goto tolua_lerror;
04521  else
04522 #endif
04523  {
04524   const fawkes::NavigatorInterface* self = (const fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
04525 #ifndef TOLUA_RELEASE
04526   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash'",NULL);
04527 #endif
04528   {
04529    unsigned const char* tolua_ret = ( unsigned const char*)  self->hash();
04530    tolua_pushstring(tolua_S,(const char*)tolua_ret);
04531   }
04532  }
04533  return 1;
04534 #ifndef TOLUA_RELEASE
04535  tolua_lerror:
04536  tolua_error(tolua_S,"#ferror in function 'hash'.",&tolua_err);
04537  return 0;
04538 #endif
04539 }
04540 #endif //#ifndef TOLUA_DISABLE
04541 
04542 /* method: hash_size of class  fawkes::NavigatorInterface */
04543 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_hash_size00
04544 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_hash_size00(lua_State* tolua_S)
04545 {
04546 #ifndef TOLUA_RELEASE
04547  tolua_Error tolua_err;
04548  if (
04549      !tolua_isusertype(tolua_S,1,"const fawkes::NavigatorInterface",0,&tolua_err) ||
04550      !tolua_isnoobj(tolua_S,2,&tolua_err)
04551  )
04552   goto tolua_lerror;
04553  else
04554 #endif
04555  {
04556   const fawkes::NavigatorInterface* self = (const fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
04557 #ifndef TOLUA_RELEASE
04558   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash_size'",NULL);
04559 #endif
04560   {
04561    int tolua_ret = (int)  self->hash_size();
04562    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04563   }
04564  }
04565  return 1;
04566 #ifndef TOLUA_RELEASE
04567  tolua_lerror:
04568  tolua_error(tolua_S,"#ferror in function 'hash_size'.",&tolua_err);
04569  return 0;
04570 #endif
04571 }
04572 #endif //#ifndef TOLUA_DISABLE
04573 
04574 /* method: hash_printable of class  fawkes::NavigatorInterface */
04575 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_hash_printable00
04576 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_hash_printable00(lua_State* tolua_S)
04577 {
04578 #ifndef TOLUA_RELEASE
04579  tolua_Error tolua_err;
04580  if (
04581      !tolua_isusertype(tolua_S,1,"const fawkes::NavigatorInterface",0,&tolua_err) ||
04582      !tolua_isnoobj(tolua_S,2,&tolua_err)
04583  )
04584   goto tolua_lerror;
04585  else
04586 #endif
04587  {
04588   const fawkes::NavigatorInterface* self = (const fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
04589 #ifndef TOLUA_RELEASE
04590   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash_printable'",NULL);
04591 #endif
04592   {
04593    const char* tolua_ret = (const char*)  self->hash_printable();
04594    tolua_pushstring(tolua_S,(const char*)tolua_ret);
04595   }
04596  }
04597  return 1;
04598 #ifndef TOLUA_RELEASE
04599  tolua_lerror:
04600  tolua_error(tolua_S,"#ferror in function 'hash_printable'.",&tolua_err);
04601  return 0;
04602 #endif
04603 }
04604 #endif //#ifndef TOLUA_DISABLE
04605 
04606 /* method: is_writer of class  fawkes::NavigatorInterface */
04607 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_is_writer00
04608 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_is_writer00(lua_State* tolua_S)
04609 {
04610 #ifndef TOLUA_RELEASE
04611  tolua_Error tolua_err;
04612  if (
04613      !tolua_isusertype(tolua_S,1,"const fawkes::NavigatorInterface",0,&tolua_err) ||
04614      !tolua_isnoobj(tolua_S,2,&tolua_err)
04615  )
04616   goto tolua_lerror;
04617  else
04618 #endif
04619  {
04620   const fawkes::NavigatorInterface* self = (const fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
04621 #ifndef TOLUA_RELEASE
04622   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_writer'",NULL);
04623 #endif
04624   {
04625    bool tolua_ret = (bool)  self->is_writer();
04626    tolua_pushboolean(tolua_S,(bool)tolua_ret);
04627   }
04628  }
04629  return 1;
04630 #ifndef TOLUA_RELEASE
04631  tolua_lerror:
04632  tolua_error(tolua_S,"#ferror in function 'is_writer'.",&tolua_err);
04633  return 0;
04634 #endif
04635 }
04636 #endif //#ifndef TOLUA_DISABLE
04637 
04638 /* method: set_from_chunk of class  fawkes::NavigatorInterface */
04639 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_set_from_chunk00
04640 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_set_from_chunk00(lua_State* tolua_S)
04641 {
04642 #ifndef TOLUA_RELEASE
04643  tolua_Error tolua_err;
04644  if (
04645      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface",0,&tolua_err) ||
04646      !tolua_isuserdata(tolua_S,2,0,&tolua_err) ||
04647      !tolua_isnoobj(tolua_S,3,&tolua_err)
04648  )
04649   goto tolua_lerror;
04650  else
04651 #endif
04652  {
04653   fawkes::NavigatorInterface* self = (fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
04654   void* chunk = ((void*)  tolua_touserdata(tolua_S,2,0));
04655 #ifndef TOLUA_RELEASE
04656   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_from_chunk'",NULL);
04657 #endif
04658   {
04659    self->set_from_chunk(chunk);
04660   }
04661  }
04662  return 0;
04663 #ifndef TOLUA_RELEASE
04664  tolua_lerror:
04665  tolua_error(tolua_S,"#ferror in function 'set_from_chunk'.",&tolua_err);
04666  return 0;
04667 #endif
04668 }
04669 #endif //#ifndef TOLUA_DISABLE
04670 
04671 /* method: create_message of class  fawkes::NavigatorInterface */
04672 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_create_message00
04673 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_create_message00(lua_State* tolua_S)
04674 {
04675 #ifndef TOLUA_RELEASE
04676  tolua_Error tolua_err;
04677  if (
04678      !tolua_isusertype(tolua_S,1,"const fawkes::NavigatorInterface",0,&tolua_err) ||
04679      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
04680      !tolua_isnoobj(tolua_S,3,&tolua_err)
04681  )
04682   goto tolua_lerror;
04683  else
04684 #endif
04685  {
04686   const fawkes::NavigatorInterface* self = (const fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
04687   const char* type = ((const char*)  tolua_tostring(tolua_S,2,0));
04688 #ifndef TOLUA_RELEASE
04689   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'create_message'",NULL);
04690 #endif
04691   {
04692    Message* tolua_ret = (Message*)  self->create_message(type);
04693    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Message");
04694   }
04695  }
04696  return 1;
04697 #ifndef TOLUA_RELEASE
04698  tolua_lerror:
04699  tolua_error(tolua_S,"#ferror in function 'create_message'.",&tolua_err);
04700  return 0;
04701 #endif
04702 }
04703 #endif //#ifndef TOLUA_DISABLE
04704 
04705 /* method: read of class  fawkes::NavigatorInterface */
04706 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_read00
04707 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_read00(lua_State* tolua_S)
04708 {
04709 #ifndef TOLUA_RELEASE
04710  tolua_Error tolua_err;
04711  if (
04712      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface",0,&tolua_err) ||
04713      !tolua_isnoobj(tolua_S,2,&tolua_err)
04714  )
04715   goto tolua_lerror;
04716  else
04717 #endif
04718  {
04719   fawkes::NavigatorInterface* self = (fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
04720 #ifndef TOLUA_RELEASE
04721   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'read'",NULL);
04722 #endif
04723   {
04724    self->read();
04725   }
04726  }
04727  return 0;
04728 #ifndef TOLUA_RELEASE
04729  tolua_lerror:
04730  tolua_error(tolua_S,"#ferror in function 'read'.",&tolua_err);
04731  return 0;
04732 #endif
04733 }
04734 #endif //#ifndef TOLUA_DISABLE
04735 
04736 /* method: write of class  fawkes::NavigatorInterface */
04737 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_write00
04738 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_write00(lua_State* tolua_S)
04739 {
04740 #ifndef TOLUA_RELEASE
04741  tolua_Error tolua_err;
04742  if (
04743      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface",0,&tolua_err) ||
04744      !tolua_isnoobj(tolua_S,2,&tolua_err)
04745  )
04746   goto tolua_lerror;
04747  else
04748 #endif
04749  {
04750   fawkes::NavigatorInterface* self = (fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
04751 #ifndef TOLUA_RELEASE
04752   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'write'",NULL);
04753 #endif
04754   {
04755    self->write();
04756   }
04757  }
04758  return 0;
04759 #ifndef TOLUA_RELEASE
04760  tolua_lerror:
04761  tolua_error(tolua_S,"#ferror in function 'write'.",&tolua_err);
04762  return 0;
04763 #endif
04764 }
04765 #endif //#ifndef TOLUA_DISABLE
04766 
04767 /* method: has_writer of class  fawkes::NavigatorInterface */
04768 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_has_writer00
04769 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_has_writer00(lua_State* tolua_S)
04770 {
04771 #ifndef TOLUA_RELEASE
04772  tolua_Error tolua_err;
04773  if (
04774      !tolua_isusertype(tolua_S,1,"const fawkes::NavigatorInterface",0,&tolua_err) ||
04775      !tolua_isnoobj(tolua_S,2,&tolua_err)
04776  )
04777   goto tolua_lerror;
04778  else
04779 #endif
04780  {
04781   const fawkes::NavigatorInterface* self = (const fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
04782 #ifndef TOLUA_RELEASE
04783   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'has_writer'",NULL);
04784 #endif
04785   {
04786    bool tolua_ret = (bool)  self->has_writer();
04787    tolua_pushboolean(tolua_S,(bool)tolua_ret);
04788   }
04789  }
04790  return 1;
04791 #ifndef TOLUA_RELEASE
04792  tolua_lerror:
04793  tolua_error(tolua_S,"#ferror in function 'has_writer'.",&tolua_err);
04794  return 0;
04795 #endif
04796 }
04797 #endif //#ifndef TOLUA_DISABLE
04798 
04799 /* method: num_readers of class  fawkes::NavigatorInterface */
04800 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_num_readers00
04801 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_num_readers00(lua_State* tolua_S)
04802 {
04803 #ifndef TOLUA_RELEASE
04804  tolua_Error tolua_err;
04805  if (
04806      !tolua_isusertype(tolua_S,1,"const fawkes::NavigatorInterface",0,&tolua_err) ||
04807      !tolua_isnoobj(tolua_S,2,&tolua_err)
04808  )
04809   goto tolua_lerror;
04810  else
04811 #endif
04812  {
04813   const fawkes::NavigatorInterface* self = (const fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
04814 #ifndef TOLUA_RELEASE
04815   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'num_readers'",NULL);
04816 #endif
04817   {
04818    unsigned int tolua_ret = (unsigned int)  self->num_readers();
04819    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04820   }
04821  }
04822  return 1;
04823 #ifndef TOLUA_RELEASE
04824  tolua_lerror:
04825  tolua_error(tolua_S,"#ferror in function 'num_readers'.",&tolua_err);
04826  return 0;
04827 #endif
04828 }
04829 #endif //#ifndef TOLUA_DISABLE
04830 
04831 /* method: msgq_enqueue_copy of class  fawkes::NavigatorInterface */
04832 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_msgq_enqueue_copy00
04833 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_msgq_enqueue_copy00(lua_State* tolua_S)
04834 {
04835 #ifndef TOLUA_RELEASE
04836  tolua_Error tolua_err;
04837  if (
04838      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface",0,&tolua_err) ||
04839      !tolua_isusertype(tolua_S,2,"Message",0,&tolua_err) ||
04840      !tolua_isnoobj(tolua_S,3,&tolua_err)
04841  )
04842   goto tolua_lerror;
04843  else
04844 #endif
04845  {
04846   fawkes::NavigatorInterface* self = (fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
04847   Message* message = ((Message*)  tolua_tousertype(tolua_S,2,0));
04848 #ifndef TOLUA_RELEASE
04849   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_enqueue_copy'",NULL);
04850 #endif
04851   {
04852    unsigned int tolua_ret = (unsigned int)  self->msgq_enqueue_copy(message);
04853    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04854   }
04855  }
04856  return 1;
04857 #ifndef TOLUA_RELEASE
04858  tolua_lerror:
04859  tolua_error(tolua_S,"#ferror in function 'msgq_enqueue_copy'.",&tolua_err);
04860  return 0;
04861 #endif
04862 }
04863 #endif //#ifndef TOLUA_DISABLE
04864 
04865 /* method: msgq_remove of class  fawkes::NavigatorInterface */
04866 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_msgq_remove00
04867 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_msgq_remove00(lua_State* tolua_S)
04868 {
04869 #ifndef TOLUA_RELEASE
04870  tolua_Error tolua_err;
04871  if (
04872      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface",0,&tolua_err) ||
04873      !tolua_isusertype(tolua_S,2,"Message",0,&tolua_err) ||
04874      !tolua_isnoobj(tolua_S,3,&tolua_err)
04875  )
04876   goto tolua_lerror;
04877  else
04878 #endif
04879  {
04880   fawkes::NavigatorInterface* self = (fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
04881   Message* message = ((Message*)  tolua_tousertype(tolua_S,2,0));
04882 #ifndef TOLUA_RELEASE
04883   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_remove'",NULL);
04884 #endif
04885   {
04886    self->msgq_remove(message);
04887   }
04888  }
04889  return 0;
04890 #ifndef TOLUA_RELEASE
04891  tolua_lerror:
04892  tolua_error(tolua_S,"#ferror in function 'msgq_remove'.",&tolua_err);
04893  return 0;
04894 #endif
04895 }
04896 #endif //#ifndef TOLUA_DISABLE
04897 
04898 /* method: msgq_remove of class  fawkes::NavigatorInterface */
04899 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_msgq_remove01
04900 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_msgq_remove01(lua_State* tolua_S)
04901 {
04902  tolua_Error tolua_err;
04903  if (
04904      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface",0,&tolua_err) ||
04905      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
04906      !tolua_isnoobj(tolua_S,3,&tolua_err)
04907  )
04908   goto tolua_lerror;
04909  else
04910  {
04911   fawkes::NavigatorInterface* self = (fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
04912   unsigned int message_id = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
04913 #ifndef TOLUA_RELEASE
04914   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_remove'",NULL);
04915 #endif
04916   {
04917    self->msgq_remove(message_id);
04918   }
04919  }
04920  return 0;
04921 tolua_lerror:
04922  return tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_msgq_remove00(tolua_S);
04923 }
04924 #endif //#ifndef TOLUA_DISABLE
04925 
04926 /* method: msgq_size of class  fawkes::NavigatorInterface */
04927 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_msgq_size00
04928 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_msgq_size00(lua_State* tolua_S)
04929 {
04930 #ifndef TOLUA_RELEASE
04931  tolua_Error tolua_err;
04932  if (
04933      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface",0,&tolua_err) ||
04934      !tolua_isnoobj(tolua_S,2,&tolua_err)
04935  )
04936   goto tolua_lerror;
04937  else
04938 #endif
04939  {
04940   fawkes::NavigatorInterface* self = (fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
04941 #ifndef TOLUA_RELEASE
04942   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_size'",NULL);
04943 #endif
04944   {
04945    unsigned int tolua_ret = (unsigned int)  self->msgq_size();
04946    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04947   }
04948  }
04949  return 1;
04950 #ifndef TOLUA_RELEASE
04951  tolua_lerror:
04952  tolua_error(tolua_S,"#ferror in function 'msgq_size'.",&tolua_err);
04953  return 0;
04954 #endif
04955 }
04956 #endif //#ifndef TOLUA_DISABLE
04957 
04958 /* method: msgq_flush of class  fawkes::NavigatorInterface */
04959 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_msgq_flush00
04960 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_msgq_flush00(lua_State* tolua_S)
04961 {
04962 #ifndef TOLUA_RELEASE
04963  tolua_Error tolua_err;
04964  if (
04965      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface",0,&tolua_err) ||
04966      !tolua_isnoobj(tolua_S,2,&tolua_err)
04967  )
04968   goto tolua_lerror;
04969  else
04970 #endif
04971  {
04972   fawkes::NavigatorInterface* self = (fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
04973 #ifndef TOLUA_RELEASE
04974   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_flush'",NULL);
04975 #endif
04976   {
04977    self->msgq_flush();
04978   }
04979  }
04980  return 0;
04981 #ifndef TOLUA_RELEASE
04982  tolua_lerror:
04983  tolua_error(tolua_S,"#ferror in function 'msgq_flush'.",&tolua_err);
04984  return 0;
04985 #endif
04986 }
04987 #endif //#ifndef TOLUA_DISABLE
04988 
04989 /* method: msgq_lock of class  fawkes::NavigatorInterface */
04990 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_msgq_lock00
04991 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_msgq_lock00(lua_State* tolua_S)
04992 {
04993 #ifndef TOLUA_RELEASE
04994  tolua_Error tolua_err;
04995  if (
04996      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface",0,&tolua_err) ||
04997      !tolua_isnoobj(tolua_S,2,&tolua_err)
04998  )
04999   goto tolua_lerror;
05000  else
05001 #endif
05002  {
05003   fawkes::NavigatorInterface* self = (fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
05004 #ifndef TOLUA_RELEASE
05005   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_lock'",NULL);
05006 #endif
05007   {
05008    self->msgq_lock();
05009   }
05010  }
05011  return 0;
05012 #ifndef TOLUA_RELEASE
05013  tolua_lerror:
05014  tolua_error(tolua_S,"#ferror in function 'msgq_lock'.",&tolua_err);
05015  return 0;
05016 #endif
05017 }
05018 #endif //#ifndef TOLUA_DISABLE
05019 
05020 /* method: msgq_try_lock of class  fawkes::NavigatorInterface */
05021 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_msgq_try_lock00
05022 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_msgq_try_lock00(lua_State* tolua_S)
05023 {
05024 #ifndef TOLUA_RELEASE
05025  tolua_Error tolua_err;
05026  if (
05027      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface",0,&tolua_err) ||
05028      !tolua_isnoobj(tolua_S,2,&tolua_err)
05029  )
05030   goto tolua_lerror;
05031  else
05032 #endif
05033  {
05034   fawkes::NavigatorInterface* self = (fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
05035 #ifndef TOLUA_RELEASE
05036   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_try_lock'",NULL);
05037 #endif
05038   {
05039    bool tolua_ret = (bool)  self->msgq_try_lock();
05040    tolua_pushboolean(tolua_S,(bool)tolua_ret);
05041   }
05042  }
05043  return 1;
05044 #ifndef TOLUA_RELEASE
05045  tolua_lerror:
05046  tolua_error(tolua_S,"#ferror in function 'msgq_try_lock'.",&tolua_err);
05047  return 0;
05048 #endif
05049 }
05050 #endif //#ifndef TOLUA_DISABLE
05051 
05052 /* method: msgq_unlock of class  fawkes::NavigatorInterface */
05053 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_msgq_unlock00
05054 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_msgq_unlock00(lua_State* tolua_S)
05055 {
05056 #ifndef TOLUA_RELEASE
05057  tolua_Error tolua_err;
05058  if (
05059      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface",0,&tolua_err) ||
05060      !tolua_isnoobj(tolua_S,2,&tolua_err)
05061  )
05062   goto tolua_lerror;
05063  else
05064 #endif
05065  {
05066   fawkes::NavigatorInterface* self = (fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
05067 #ifndef TOLUA_RELEASE
05068   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_unlock'",NULL);
05069 #endif
05070   {
05071    self->msgq_unlock();
05072   }
05073  }
05074  return 0;
05075 #ifndef TOLUA_RELEASE
05076  tolua_lerror:
05077  tolua_error(tolua_S,"#ferror in function 'msgq_unlock'.",&tolua_err);
05078  return 0;
05079 #endif
05080 }
05081 #endif //#ifndef TOLUA_DISABLE
05082 
05083 /* method: msgq_pop of class  fawkes::NavigatorInterface */
05084 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_msgq_pop00
05085 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_msgq_pop00(lua_State* tolua_S)
05086 {
05087 #ifndef TOLUA_RELEASE
05088  tolua_Error tolua_err;
05089  if (
05090      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface",0,&tolua_err) ||
05091      !tolua_isnoobj(tolua_S,2,&tolua_err)
05092  )
05093   goto tolua_lerror;
05094  else
05095 #endif
05096  {
05097   fawkes::NavigatorInterface* self = (fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
05098 #ifndef TOLUA_RELEASE
05099   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_pop'",NULL);
05100 #endif
05101   {
05102    self->msgq_pop();
05103   }
05104  }
05105  return 0;
05106 #ifndef TOLUA_RELEASE
05107  tolua_lerror:
05108  tolua_error(tolua_S,"#ferror in function 'msgq_pop'.",&tolua_err);
05109  return 0;
05110 #endif
05111 }
05112 #endif //#ifndef TOLUA_DISABLE
05113 
05114 /* method: msgq_first of class  fawkes::NavigatorInterface */
05115 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_msgq_first00
05116 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_msgq_first00(lua_State* tolua_S)
05117 {
05118 #ifndef TOLUA_RELEASE
05119  tolua_Error tolua_err;
05120  if (
05121      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface",0,&tolua_err) ||
05122      !tolua_isnoobj(tolua_S,2,&tolua_err)
05123  )
05124   goto tolua_lerror;
05125  else
05126 #endif
05127  {
05128   fawkes::NavigatorInterface* self = (fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
05129 #ifndef TOLUA_RELEASE
05130   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_first'",NULL);
05131 #endif
05132   {
05133    Message* tolua_ret = (Message*)  self->msgq_first();
05134    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Message");
05135   }
05136  }
05137  return 1;
05138 #ifndef TOLUA_RELEASE
05139  tolua_lerror:
05140  tolua_error(tolua_S,"#ferror in function 'msgq_first'.",&tolua_err);
05141  return 0;
05142 #endif
05143 }
05144 #endif //#ifndef TOLUA_DISABLE
05145 
05146 /* method: msgq_empty of class  fawkes::NavigatorInterface */
05147 #ifndef TOLUA_DISABLE_tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_msgq_empty00
05148 static int tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_msgq_empty00(lua_State* tolua_S)
05149 {
05150 #ifndef TOLUA_RELEASE
05151  tolua_Error tolua_err;
05152  if (
05153      !tolua_isusertype(tolua_S,1,"fawkes::NavigatorInterface",0,&tolua_err) ||
05154      !tolua_isnoobj(tolua_S,2,&tolua_err)
05155  )
05156   goto tolua_lerror;
05157  else
05158 #endif
05159  {
05160   fawkes::NavigatorInterface* self = (fawkes::NavigatorInterface*)  tolua_tousertype(tolua_S,1,0);
05161 #ifndef TOLUA_RELEASE
05162   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_empty'",NULL);
05163 #endif
05164   {
05165    bool tolua_ret = (bool)  self->msgq_empty();
05166    tolua_pushboolean(tolua_S,(bool)tolua_ret);
05167   }
05168  }
05169  return 1;
05170 #ifndef TOLUA_RELEASE
05171  tolua_lerror:
05172  tolua_error(tolua_S,"#ferror in function 'msgq_empty'.",&tolua_err);
05173  return 0;
05174 #endif
05175 }
05176 #endif //#ifndef TOLUA_DISABLE
05177 
05178 /* Open function */
05179 TOLUA_API int tolua_interfaces_NavigatorInterface_open (lua_State* tolua_S)
05180 {
05181  tolua_open(tolua_S);
05182  tolua_reg_types(tolua_S);
05183  tolua_module(tolua_S,NULL,0);
05184  tolua_beginmodule(tolua_S,NULL);
05185   tolua_module(tolua_S,"fawkes",0);
05186   tolua_beginmodule(tolua_S,"fawkes");
05187    tolua_cclass(tolua_S,"NavigatorInterface","fawkes::NavigatorInterface","Interface",NULL);
05188    tolua_beginmodule(tolua_S,"NavigatorInterface");
05189     tolua_variable(tolua_S,"ERROR_NONE",tolua_get_fawkes__NavigatorInterface_unsigned_ERROR_NONE,NULL);
05190     tolua_variable(tolua_S,"ERROR_MOTOR",tolua_get_fawkes__NavigatorInterface_unsigned_ERROR_MOTOR,NULL);
05191     tolua_variable(tolua_S,"ERROR_OBSTRUCTION",tolua_get_fawkes__NavigatorInterface_unsigned_ERROR_OBSTRUCTION,NULL);
05192     tolua_variable(tolua_S,"ERROR_UNKNOWN_PLACE",tolua_get_fawkes__NavigatorInterface_unsigned_ERROR_UNKNOWN_PLACE,NULL);
05193     tolua_variable(tolua_S,"FLAG_NONE",tolua_get_fawkes__NavigatorInterface_unsigned_FLAG_NONE,NULL);
05194     tolua_variable(tolua_S,"FLAG_CART_GOTO",tolua_get_fawkes__NavigatorInterface_unsigned_FLAG_CART_GOTO,NULL);
05195     tolua_variable(tolua_S,"FLAG_POLAR_GOTO",tolua_get_fawkes__NavigatorInterface_unsigned_FLAG_POLAR_GOTO,NULL);
05196     tolua_variable(tolua_S,"FLAG_PLACE_GOTO",tolua_get_fawkes__NavigatorInterface_unsigned_FLAG_PLACE_GOTO,NULL);
05197     tolua_variable(tolua_S,"FLAG_UPDATES_DEST_DIST",tolua_get_fawkes__NavigatorInterface_unsigned_FLAG_UPDATES_DEST_DIST,NULL);
05198     tolua_variable(tolua_S,"FLAG_SECURITY_DISTANCE",tolua_get_fawkes__NavigatorInterface_unsigned_FLAG_SECURITY_DISTANCE,NULL);
05199     tolua_variable(tolua_S,"FLAG_ESCAPING",tolua_get_fawkes__NavigatorInterface_unsigned_FLAG_ESCAPING,NULL);
05200     #ifdef __cplusplus
05201     tolua_cclass(tolua_S,"StopMessage","fawkes::NavigatorInterface::StopMessage","Message",tolua_collect_fawkes__NavigatorInterface__StopMessage);
05202     #else
05203     tolua_cclass(tolua_S,"StopMessage","fawkes::NavigatorInterface::StopMessage","Message",NULL);
05204     #endif
05205     tolua_beginmodule(tolua_S,"StopMessage");
05206      tolua_function(tolua_S,"new",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_StopMessage_new00);
05207      tolua_function(tolua_S,"new_local",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_StopMessage_new00_local);
05208      tolua_function(tolua_S,".call",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_StopMessage_new00_local);
05209      tolua_function(tolua_S,"delete",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_StopMessage_delete00);
05210     tolua_endmodule(tolua_S);
05211     #ifdef __cplusplus
05212     tolua_cclass(tolua_S,"TurnMessage","fawkes::NavigatorInterface::TurnMessage","Message",tolua_collect_fawkes__NavigatorInterface__TurnMessage);
05213     #else
05214     tolua_cclass(tolua_S,"TurnMessage","fawkes::NavigatorInterface::TurnMessage","Message",NULL);
05215     #endif
05216     tolua_beginmodule(tolua_S,"TurnMessage");
05217      tolua_function(tolua_S,"new",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_TurnMessage_new00);
05218      tolua_function(tolua_S,"new_local",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_TurnMessage_new00_local);
05219      tolua_function(tolua_S,".call",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_TurnMessage_new00_local);
05220      tolua_function(tolua_S,"new",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_TurnMessage_new01);
05221      tolua_function(tolua_S,"new_local",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_TurnMessage_new01_local);
05222      tolua_function(tolua_S,".call",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_TurnMessage_new01_local);
05223      tolua_function(tolua_S,"delete",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_TurnMessage_delete00);
05224      tolua_function(tolua_S,"angle",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_TurnMessage_angle00);
05225      tolua_function(tolua_S,"set_angle",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_TurnMessage_set_angle00);
05226      tolua_function(tolua_S,"maxlenof_angle",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_TurnMessage_maxlenof_angle00);
05227      tolua_function(tolua_S,"velocity",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_TurnMessage_velocity00);
05228      tolua_function(tolua_S,"set_velocity",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_TurnMessage_set_velocity00);
05229      tolua_function(tolua_S,"maxlenof_velocity",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_TurnMessage_maxlenof_velocity00);
05230     tolua_endmodule(tolua_S);
05231     #ifdef __cplusplus
05232     tolua_cclass(tolua_S,"CartesianGotoMessage","fawkes::NavigatorInterface::CartesianGotoMessage","Message",tolua_collect_fawkes__NavigatorInterface__CartesianGotoMessage);
05233     #else
05234     tolua_cclass(tolua_S,"CartesianGotoMessage","fawkes::NavigatorInterface::CartesianGotoMessage","Message",NULL);
05235     #endif
05236     tolua_beginmodule(tolua_S,"CartesianGotoMessage");
05237      tolua_function(tolua_S,"new",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_CartesianGotoMessage_new00);
05238      tolua_function(tolua_S,"new_local",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_CartesianGotoMessage_new00_local);
05239      tolua_function(tolua_S,".call",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_CartesianGotoMessage_new00_local);
05240      tolua_function(tolua_S,"new",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_CartesianGotoMessage_new01);
05241      tolua_function(tolua_S,"new_local",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_CartesianGotoMessage_new01_local);
05242      tolua_function(tolua_S,".call",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_CartesianGotoMessage_new01_local);
05243      tolua_function(tolua_S,"delete",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_CartesianGotoMessage_delete00);
05244      tolua_function(tolua_S,"x",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_CartesianGotoMessage_x00);
05245      tolua_function(tolua_S,"set_x",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_CartesianGotoMessage_set_x00);
05246      tolua_function(tolua_S,"maxlenof_x",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_CartesianGotoMessage_maxlenof_x00);
05247      tolua_function(tolua_S,"y",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_CartesianGotoMessage_y00);
05248      tolua_function(tolua_S,"set_y",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_CartesianGotoMessage_set_y00);
05249      tolua_function(tolua_S,"maxlenof_y",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_CartesianGotoMessage_maxlenof_y00);
05250      tolua_function(tolua_S,"orientation",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_CartesianGotoMessage_orientation00);
05251      tolua_function(tolua_S,"set_orientation",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_CartesianGotoMessage_set_orientation00);
05252      tolua_function(tolua_S,"maxlenof_orientation",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_CartesianGotoMessage_maxlenof_orientation00);
05253     tolua_endmodule(tolua_S);
05254     #ifdef __cplusplus
05255     tolua_cclass(tolua_S,"PolarGotoMessage","fawkes::NavigatorInterface::PolarGotoMessage","Message",tolua_collect_fawkes__NavigatorInterface__PolarGotoMessage);
05256     #else
05257     tolua_cclass(tolua_S,"PolarGotoMessage","fawkes::NavigatorInterface::PolarGotoMessage","Message",NULL);
05258     #endif
05259     tolua_beginmodule(tolua_S,"PolarGotoMessage");
05260      tolua_function(tolua_S,"new",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PolarGotoMessage_new00);
05261      tolua_function(tolua_S,"new_local",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PolarGotoMessage_new00_local);
05262      tolua_function(tolua_S,".call",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PolarGotoMessage_new00_local);
05263      tolua_function(tolua_S,"new",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PolarGotoMessage_new01);
05264      tolua_function(tolua_S,"new_local",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PolarGotoMessage_new01_local);
05265      tolua_function(tolua_S,".call",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PolarGotoMessage_new01_local);
05266      tolua_function(tolua_S,"delete",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PolarGotoMessage_delete00);
05267      tolua_function(tolua_S,"phi",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PolarGotoMessage_phi00);
05268      tolua_function(tolua_S,"set_phi",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PolarGotoMessage_set_phi00);
05269      tolua_function(tolua_S,"maxlenof_phi",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PolarGotoMessage_maxlenof_phi00);
05270      tolua_function(tolua_S,"dist",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PolarGotoMessage_dist00);
05271      tolua_function(tolua_S,"set_dist",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PolarGotoMessage_set_dist00);
05272      tolua_function(tolua_S,"maxlenof_dist",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PolarGotoMessage_maxlenof_dist00);
05273      tolua_function(tolua_S,"orientation",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PolarGotoMessage_orientation00);
05274      tolua_function(tolua_S,"set_orientation",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PolarGotoMessage_set_orientation00);
05275      tolua_function(tolua_S,"maxlenof_orientation",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PolarGotoMessage_maxlenof_orientation00);
05276     tolua_endmodule(tolua_S);
05277     #ifdef __cplusplus
05278     tolua_cclass(tolua_S,"PlaceGotoMessage","fawkes::NavigatorInterface::PlaceGotoMessage","Message",tolua_collect_fawkes__NavigatorInterface__PlaceGotoMessage);
05279     #else
05280     tolua_cclass(tolua_S,"PlaceGotoMessage","fawkes::NavigatorInterface::PlaceGotoMessage","Message",NULL);
05281     #endif
05282     tolua_beginmodule(tolua_S,"PlaceGotoMessage");
05283      tolua_function(tolua_S,"new",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PlaceGotoMessage_new00);
05284      tolua_function(tolua_S,"new_local",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PlaceGotoMessage_new00_local);
05285      tolua_function(tolua_S,".call",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PlaceGotoMessage_new00_local);
05286      tolua_function(tolua_S,"new",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PlaceGotoMessage_new01);
05287      tolua_function(tolua_S,"new_local",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PlaceGotoMessage_new01_local);
05288      tolua_function(tolua_S,".call",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PlaceGotoMessage_new01_local);
05289      tolua_function(tolua_S,"delete",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PlaceGotoMessage_delete00);
05290      tolua_function(tolua_S,"place",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PlaceGotoMessage_place00);
05291      tolua_function(tolua_S,"set_place",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PlaceGotoMessage_set_place00);
05292      tolua_function(tolua_S,"maxlenof_place",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_PlaceGotoMessage_maxlenof_place00);
05293     tolua_endmodule(tolua_S);
05294     #ifdef __cplusplus
05295     tolua_cclass(tolua_S,"ObstacleMessage","fawkes::NavigatorInterface::ObstacleMessage","Message",tolua_collect_fawkes__NavigatorInterface__ObstacleMessage);
05296     #else
05297     tolua_cclass(tolua_S,"ObstacleMessage","fawkes::NavigatorInterface::ObstacleMessage","Message",NULL);
05298     #endif
05299     tolua_beginmodule(tolua_S,"ObstacleMessage");
05300      tolua_function(tolua_S,"new",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_ObstacleMessage_new00);
05301      tolua_function(tolua_S,"new_local",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_ObstacleMessage_new00_local);
05302      tolua_function(tolua_S,".call",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_ObstacleMessage_new00_local);
05303      tolua_function(tolua_S,"new",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_ObstacleMessage_new01);
05304      tolua_function(tolua_S,"new_local",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_ObstacleMessage_new01_local);
05305      tolua_function(tolua_S,".call",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_ObstacleMessage_new01_local);
05306      tolua_function(tolua_S,"delete",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_ObstacleMessage_delete00);
05307      tolua_function(tolua_S,"x",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_ObstacleMessage_x00);
05308      tolua_function(tolua_S,"set_x",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_ObstacleMessage_set_x00);
05309      tolua_function(tolua_S,"maxlenof_x",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_ObstacleMessage_maxlenof_x00);
05310      tolua_function(tolua_S,"y",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_ObstacleMessage_y00);
05311      tolua_function(tolua_S,"set_y",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_ObstacleMessage_set_y00);
05312      tolua_function(tolua_S,"maxlenof_y",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_ObstacleMessage_maxlenof_y00);
05313      tolua_function(tolua_S,"width",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_ObstacleMessage_width00);
05314      tolua_function(tolua_S,"set_width",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_ObstacleMessage_set_width00);
05315      tolua_function(tolua_S,"maxlenof_width",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_ObstacleMessage_maxlenof_width00);
05316     tolua_endmodule(tolua_S);
05317     #ifdef __cplusplus
05318     tolua_cclass(tolua_S,"ResetOdometryMessage","fawkes::NavigatorInterface::ResetOdometryMessage","Message",tolua_collect_fawkes__NavigatorInterface__ResetOdometryMessage);
05319     #else
05320     tolua_cclass(tolua_S,"ResetOdometryMessage","fawkes::NavigatorInterface::ResetOdometryMessage","Message",NULL);
05321     #endif
05322     tolua_beginmodule(tolua_S,"ResetOdometryMessage");
05323      tolua_function(tolua_S,"new",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_ResetOdometryMessage_new00);
05324      tolua_function(tolua_S,"new_local",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_ResetOdometryMessage_new00_local);
05325      tolua_function(tolua_S,".call",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_ResetOdometryMessage_new00_local);
05326      tolua_function(tolua_S,"delete",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_ResetOdometryMessage_delete00);
05327     tolua_endmodule(tolua_S);
05328     #ifdef __cplusplus
05329     tolua_cclass(tolua_S,"SetMaxVelocityMessage","fawkes::NavigatorInterface::SetMaxVelocityMessage","Message",tolua_collect_fawkes__NavigatorInterface__SetMaxVelocityMessage);
05330     #else
05331     tolua_cclass(tolua_S,"SetMaxVelocityMessage","fawkes::NavigatorInterface::SetMaxVelocityMessage","Message",NULL);
05332     #endif
05333     tolua_beginmodule(tolua_S,"SetMaxVelocityMessage");
05334      tolua_function(tolua_S,"new",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetMaxVelocityMessage_new00);
05335      tolua_function(tolua_S,"new_local",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetMaxVelocityMessage_new00_local);
05336      tolua_function(tolua_S,".call",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetMaxVelocityMessage_new00_local);
05337      tolua_function(tolua_S,"new",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetMaxVelocityMessage_new01);
05338      tolua_function(tolua_S,"new_local",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetMaxVelocityMessage_new01_local);
05339      tolua_function(tolua_S,".call",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetMaxVelocityMessage_new01_local);
05340      tolua_function(tolua_S,"delete",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetMaxVelocityMessage_delete00);
05341      tolua_function(tolua_S,"max_velocity",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetMaxVelocityMessage_max_velocity00);
05342      tolua_function(tolua_S,"set_max_velocity",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetMaxVelocityMessage_set_max_velocity00);
05343      tolua_function(tolua_S,"maxlenof_max_velocity",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetMaxVelocityMessage_maxlenof_max_velocity00);
05344     tolua_endmodule(tolua_S);
05345     #ifdef __cplusplus
05346     tolua_cclass(tolua_S,"SetEscapingMessage","fawkes::NavigatorInterface::SetEscapingMessage","Message",tolua_collect_fawkes__NavigatorInterface__SetEscapingMessage);
05347     #else
05348     tolua_cclass(tolua_S,"SetEscapingMessage","fawkes::NavigatorInterface::SetEscapingMessage","Message",NULL);
05349     #endif
05350     tolua_beginmodule(tolua_S,"SetEscapingMessage");
05351      tolua_function(tolua_S,"new",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetEscapingMessage_new00);
05352      tolua_function(tolua_S,"new_local",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetEscapingMessage_new00_local);
05353      tolua_function(tolua_S,".call",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetEscapingMessage_new00_local);
05354      tolua_function(tolua_S,"new",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetEscapingMessage_new01);
05355      tolua_function(tolua_S,"new_local",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetEscapingMessage_new01_local);
05356      tolua_function(tolua_S,".call",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetEscapingMessage_new01_local);
05357      tolua_function(tolua_S,"delete",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetEscapingMessage_delete00);
05358      tolua_function(tolua_S,"is_escaping_enabled",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetEscapingMessage_is_escaping_enabled00);
05359      tolua_function(tolua_S,"set_escaping_enabled",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetEscapingMessage_set_escaping_enabled00);
05360      tolua_function(tolua_S,"maxlenof_escaping_enabled",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetEscapingMessage_maxlenof_escaping_enabled00);
05361     tolua_endmodule(tolua_S);
05362     #ifdef __cplusplus
05363     tolua_cclass(tolua_S,"SetSecurityDistanceMessage","fawkes::NavigatorInterface::SetSecurityDistanceMessage","Message",tolua_collect_fawkes__NavigatorInterface__SetSecurityDistanceMessage);
05364     #else
05365     tolua_cclass(tolua_S,"SetSecurityDistanceMessage","fawkes::NavigatorInterface::SetSecurityDistanceMessage","Message",NULL);
05366     #endif
05367     tolua_beginmodule(tolua_S,"SetSecurityDistanceMessage");
05368      tolua_function(tolua_S,"new",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetSecurityDistanceMessage_new00);
05369      tolua_function(tolua_S,"new_local",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetSecurityDistanceMessage_new00_local);
05370      tolua_function(tolua_S,".call",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetSecurityDistanceMessage_new00_local);
05371      tolua_function(tolua_S,"new",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetSecurityDistanceMessage_new01);
05372      tolua_function(tolua_S,"new_local",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetSecurityDistanceMessage_new01_local);
05373      tolua_function(tolua_S,".call",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetSecurityDistanceMessage_new01_local);
05374      tolua_function(tolua_S,"delete",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetSecurityDistanceMessage_delete00);
05375      tolua_function(tolua_S,"security_distance",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetSecurityDistanceMessage_security_distance00);
05376      tolua_function(tolua_S,"set_security_distance",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetSecurityDistanceMessage_set_security_distance00);
05377      tolua_function(tolua_S,"maxlenof_security_distance",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_SetSecurityDistanceMessage_maxlenof_security_distance00);
05378     tolua_endmodule(tolua_S);
05379     tolua_function(tolua_S,"flags",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_flags00);
05380     tolua_function(tolua_S,"set_flags",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_set_flags00);
05381     tolua_function(tolua_S,"maxlenof_flags",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_maxlenof_flags00);
05382     tolua_function(tolua_S,"x",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_x00);
05383     tolua_function(tolua_S,"set_x",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_set_x00);
05384     tolua_function(tolua_S,"maxlenof_x",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_maxlenof_x00);
05385     tolua_function(tolua_S,"y",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_y00);
05386     tolua_function(tolua_S,"set_y",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_set_y00);
05387     tolua_function(tolua_S,"maxlenof_y",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_maxlenof_y00);
05388     tolua_function(tolua_S,"dest_x",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_dest_x00);
05389     tolua_function(tolua_S,"set_dest_x",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_set_dest_x00);
05390     tolua_function(tolua_S,"maxlenof_dest_x",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_maxlenof_dest_x00);
05391     tolua_function(tolua_S,"dest_y",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_dest_y00);
05392     tolua_function(tolua_S,"set_dest_y",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_set_dest_y00);
05393     tolua_function(tolua_S,"maxlenof_dest_y",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_maxlenof_dest_y00);
05394     tolua_function(tolua_S,"dest_ori",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_dest_ori00);
05395     tolua_function(tolua_S,"set_dest_ori",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_set_dest_ori00);
05396     tolua_function(tolua_S,"maxlenof_dest_ori",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_maxlenof_dest_ori00);
05397     tolua_function(tolua_S,"dest_dist",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_dest_dist00);
05398     tolua_function(tolua_S,"set_dest_dist",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_set_dest_dist00);
05399     tolua_function(tolua_S,"maxlenof_dest_dist",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_maxlenof_dest_dist00);
05400     tolua_function(tolua_S,"msgid",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_msgid00);
05401     tolua_function(tolua_S,"set_msgid",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_set_msgid00);
05402     tolua_function(tolua_S,"maxlenof_msgid",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_maxlenof_msgid00);
05403     tolua_function(tolua_S,"is_final",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_is_final00);
05404     tolua_function(tolua_S,"set_final",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_set_final00);
05405     tolua_function(tolua_S,"maxlenof_final",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_maxlenof_final00);
05406     tolua_function(tolua_S,"error_code",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_error_code00);
05407     tolua_function(tolua_S,"set_error_code",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_set_error_code00);
05408     tolua_function(tolua_S,"maxlenof_error_code",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_maxlenof_error_code00);
05409     tolua_function(tolua_S,"max_velocity",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_max_velocity00);
05410     tolua_function(tolua_S,"set_max_velocity",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_set_max_velocity00);
05411     tolua_function(tolua_S,"maxlenof_max_velocity",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_maxlenof_max_velocity00);
05412     tolua_function(tolua_S,"security_distance",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_security_distance00);
05413     tolua_function(tolua_S,"set_security_distance",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_set_security_distance00);
05414     tolua_function(tolua_S,"maxlenof_security_distance",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_maxlenof_security_distance00);
05415     tolua_function(tolua_S,"is_escaping_enabled",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_is_escaping_enabled00);
05416     tolua_function(tolua_S,"set_escaping_enabled",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_set_escaping_enabled00);
05417     tolua_function(tolua_S,"maxlenof_escaping_enabled",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_maxlenof_escaping_enabled00);
05418     tolua_function(tolua_S,"oftype",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_oftype00);
05419     tolua_function(tolua_S,"datachunk",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_datachunk00);
05420     tolua_function(tolua_S,"datasize",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_datasize00);
05421     tolua_function(tolua_S,"type",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_type00);
05422     tolua_function(tolua_S,"id",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_id00);
05423     tolua_function(tolua_S,"uid",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_uid00);
05424     tolua_function(tolua_S,"serial",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_serial00);
05425     tolua_function(tolua_S,"mem_serial",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_mem_serial00);
05426     tolua_function(tolua_S,".eq",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface__eq00);
05427     tolua_function(tolua_S,"hash",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_hash00);
05428     tolua_function(tolua_S,"hash_size",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_hash_size00);
05429     tolua_function(tolua_S,"hash_printable",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_hash_printable00);
05430     tolua_function(tolua_S,"is_writer",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_is_writer00);
05431     tolua_function(tolua_S,"set_from_chunk",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_set_from_chunk00);
05432     tolua_function(tolua_S,"create_message",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_create_message00);
05433     tolua_function(tolua_S,"read",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_read00);
05434     tolua_function(tolua_S,"write",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_write00);
05435     tolua_function(tolua_S,"has_writer",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_has_writer00);
05436     tolua_function(tolua_S,"num_readers",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_num_readers00);
05437     tolua_function(tolua_S,"msgq_enqueue_copy",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_msgq_enqueue_copy00);
05438     tolua_function(tolua_S,"msgq_remove",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_msgq_remove00);
05439     tolua_function(tolua_S,"msgq_remove",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_msgq_remove01);
05440     tolua_function(tolua_S,"msgq_size",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_msgq_size00);
05441     tolua_function(tolua_S,"msgq_flush",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_msgq_flush00);
05442     tolua_function(tolua_S,"msgq_lock",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_msgq_lock00);
05443     tolua_function(tolua_S,"msgq_try_lock",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_msgq_try_lock00);
05444     tolua_function(tolua_S,"msgq_unlock",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_msgq_unlock00);
05445     tolua_function(tolua_S,"msgq_pop",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_msgq_pop00);
05446     tolua_function(tolua_S,"msgq_first",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_msgq_first00);
05447     tolua_function(tolua_S,"msgq_empty",tolua_interfaces_NavigatorInterface_fawkes_NavigatorInterface_msgq_empty00);
05448    tolua_endmodule(tolua_S);
05449   tolua_endmodule(tolua_S);
05450  tolua_endmodule(tolua_S);
05451  return 1;
05452 }
05453
05454
05455 extern "C" {
05456 #if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501
05457  TOLUA_API int luaopen_interfaces_NavigatorInterface (lua_State* tolua_S) {
05458  return tolua_interfaces_NavigatorInterface_open(tolua_S);
05459 };
05460 #endif
05461 }
05462
05463