NavigatorInterface_tolua.cpp

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