00001 /*
00002 ** Lua binding: interfaces_LocalizerControlInterface
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_LocalizerControlInterface_open (lua_State* tolua_S);
00028
00029 #include <interfaces/LocalizerControlInterface.h>
00030 using namespace fawkes;
00031
00032 /* function to release collected object via destructor */
00033 #ifdef __cplusplus
00034 
00035 static int tolua_collect_fawkes__LocalizerControlInterface__ResetMessage (lua_State* tolua_S)
00036 {
00037  fawkes::LocalizerControlInterface::ResetMessage* self = (fawkes::LocalizerControlInterface::ResetMessage*) tolua_tousertype(tolua_S,1,0);
00038         delete self;
00039         return 0;
00040 }
00041 #endif
00042 
00043
00044 /* function to register type */
00045 static void tolua_reg_types (lua_State* tolua_S)
00046 {
00047  tolua_usertype(tolua_S,"fawkes::LocalizerControlInterface::ResetMessage");
00048  tolua_usertype(tolua_S,"Message");
00049  tolua_usertype(tolua_S,"fawkes::LocalizerControlInterface");
00050  tolua_usertype(tolua_S,"Interface");
00051 }
00052
00053 /* method: new of class  ResetMessage */
00054 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_new00
00055 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_new00(lua_State* tolua_S)
00056 {
00057 #ifndef TOLUA_RELEASE
00058  tolua_Error tolua_err;
00059  if (
00060      !tolua_isusertable(tolua_S,1,"fawkes::LocalizerControlInterface::ResetMessage",0,&tolua_err) ||
00061      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00062      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
00063      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
00064      !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
00065      !tolua_isnoobj(tolua_S,6,&tolua_err)
00066  )
00067   goto tolua_lerror;
00068  else
00069 #endif
00070  {
00071   float ini_x = ((float)  tolua_tonumber(tolua_S,2,0));
00072   float ini_y = ((float)  tolua_tonumber(tolua_S,3,0));
00073   float ini_ori = ((float)  tolua_tonumber(tolua_S,4,0));
00074   float ini_variance = ((float)  tolua_tonumber(tolua_S,5,0));
00075   {
00076    fawkes::LocalizerControlInterface::ResetMessage* tolua_ret = (fawkes::LocalizerControlInterface::ResetMessage*)  new fawkes::LocalizerControlInterface::ResetMessage(ini_x,ini_y,ini_ori,ini_variance);
00077    tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::LocalizerControlInterface::ResetMessage");
00078   }
00079  }
00080  return 1;
00081 #ifndef TOLUA_RELEASE
00082  tolua_lerror:
00083  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00084  return 0;
00085 #endif
00086 }
00087 #endif //#ifndef TOLUA_DISABLE
00088 
00089 /* method: new_local of class  ResetMessage */
00090 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_new00_local
00091 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_new00_local(lua_State* tolua_S)
00092 {
00093 #ifndef TOLUA_RELEASE
00094  tolua_Error tolua_err;
00095  if (
00096      !tolua_isusertable(tolua_S,1,"fawkes::LocalizerControlInterface::ResetMessage",0,&tolua_err) ||
00097      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00098      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
00099      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
00100      !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
00101      !tolua_isnoobj(tolua_S,6,&tolua_err)
00102  )
00103   goto tolua_lerror;
00104  else
00105 #endif
00106  {
00107   float ini_x = ((float)  tolua_tonumber(tolua_S,2,0));
00108   float ini_y = ((float)  tolua_tonumber(tolua_S,3,0));
00109   float ini_ori = ((float)  tolua_tonumber(tolua_S,4,0));
00110   float ini_variance = ((float)  tolua_tonumber(tolua_S,5,0));
00111   {
00112    fawkes::LocalizerControlInterface::ResetMessage* tolua_ret = (fawkes::LocalizerControlInterface::ResetMessage*)  new fawkes::LocalizerControlInterface::ResetMessage(ini_x,ini_y,ini_ori,ini_variance);
00113    tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"fawkes::LocalizerControlInterface::ResetMessage");
00114   }
00115  }
00116  return 1;
00117 #ifndef TOLUA_RELEASE
00118  tolua_lerror:
00119  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00120  return 0;
00121 #endif
00122 }
00123 #endif //#ifndef TOLUA_DISABLE
00124 
00125 /* method: new of class  ResetMessage */
00126 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_new01
00127 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_new01(lua_State* tolua_S)
00128 {
00129  tolua_Error tolua_err;
00130  if (
00131      !tolua_isusertable(tolua_S,1,"fawkes::LocalizerControlInterface::ResetMessage",0,&tolua_err) ||
00132      !tolua_isnoobj(tolua_S,2,&tolua_err)
00133  )
00134   goto tolua_lerror;
00135  else
00136  {
00137   {
00138    fawkes::LocalizerControlInterface::ResetMessage* tolua_ret = (fawkes::LocalizerControlInterface::ResetMessage*)  new fawkes::LocalizerControlInterface::ResetMessage();
00139    tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::LocalizerControlInterface::ResetMessage");
00140   }
00141  }
00142  return 1;
00143 tolua_lerror:
00144  return tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_new00(tolua_S);
00145 }
00146 #endif //#ifndef TOLUA_DISABLE
00147 
00148 /* method: new_local of class  ResetMessage */
00149 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_new01_local
00150 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_new01_local(lua_State* tolua_S)
00151 {
00152  tolua_Error tolua_err;
00153  if (
00154      !tolua_isusertable(tolua_S,1,"fawkes::LocalizerControlInterface::ResetMessage",0,&tolua_err) ||
00155      !tolua_isnoobj(tolua_S,2,&tolua_err)
00156  )
00157   goto tolua_lerror;
00158  else
00159  {
00160   {
00161    fawkes::LocalizerControlInterface::ResetMessage* tolua_ret = (fawkes::LocalizerControlInterface::ResetMessage*)  new fawkes::LocalizerControlInterface::ResetMessage();
00162    tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"fawkes::LocalizerControlInterface::ResetMessage");
00163   }
00164  }
00165  return 1;
00166 tolua_lerror:
00167  return tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_new00_local(tolua_S);
00168 }
00169 #endif //#ifndef TOLUA_DISABLE
00170 
00171 /* method: delete of class  ResetMessage */
00172 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_delete00
00173 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_delete00(lua_State* tolua_S)
00174 {
00175 #ifndef TOLUA_RELEASE
00176  tolua_Error tolua_err;
00177  if (
00178      !tolua_isusertype(tolua_S,1,"fawkes::LocalizerControlInterface::ResetMessage",0,&tolua_err) ||
00179      !tolua_isnoobj(tolua_S,2,&tolua_err)
00180  )
00181   goto tolua_lerror;
00182  else
00183 #endif
00184  {
00185   fawkes::LocalizerControlInterface::ResetMessage* self = (fawkes::LocalizerControlInterface::ResetMessage*)  tolua_tousertype(tolua_S,1,0);
00186 #ifndef TOLUA_RELEASE
00187   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
00188 #endif
00189   delete self;
00190  }
00191  return 0;
00192 #ifndef TOLUA_RELEASE
00193  tolua_lerror:
00194  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
00195  return 0;
00196 #endif
00197 }
00198 #endif //#ifndef TOLUA_DISABLE
00199 
00200 /* method: x of class  ResetMessage */
00201 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_x00
00202 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_x00(lua_State* tolua_S)
00203 {
00204 #ifndef TOLUA_RELEASE
00205  tolua_Error tolua_err;
00206  if (
00207      !tolua_isusertype(tolua_S,1,"fawkes::LocalizerControlInterface::ResetMessage",0,&tolua_err) ||
00208      !tolua_isnoobj(tolua_S,2,&tolua_err)
00209  )
00210   goto tolua_lerror;
00211  else
00212 #endif
00213  {
00214   fawkes::LocalizerControlInterface::ResetMessage* self = (fawkes::LocalizerControlInterface::ResetMessage*)  tolua_tousertype(tolua_S,1,0);
00215 #ifndef TOLUA_RELEASE
00216   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'x'",NULL);
00217 #endif
00218   {
00219    float tolua_ret = (float)  self->x();
00220    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00221   }
00222  }
00223  return 1;
00224 #ifndef TOLUA_RELEASE
00225  tolua_lerror:
00226  tolua_error(tolua_S,"#ferror in function 'x'.",&tolua_err);
00227  return 0;
00228 #endif
00229 }
00230 #endif //#ifndef TOLUA_DISABLE
00231 
00232 /* method: set_x of class  ResetMessage */
00233 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_set_x00
00234 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_set_x00(lua_State* tolua_S)
00235 {
00236 #ifndef TOLUA_RELEASE
00237  tolua_Error tolua_err;
00238  if (
00239      !tolua_isusertype(tolua_S,1,"fawkes::LocalizerControlInterface::ResetMessage",0,&tolua_err) ||
00240      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00241      !tolua_isnoobj(tolua_S,3,&tolua_err)
00242  )
00243   goto tolua_lerror;
00244  else
00245 #endif
00246  {
00247   fawkes::LocalizerControlInterface::ResetMessage* self = (fawkes::LocalizerControlInterface::ResetMessage*)  tolua_tousertype(tolua_S,1,0);
00248   const float new_x = ((const float)  tolua_tonumber(tolua_S,2,0));
00249 #ifndef TOLUA_RELEASE
00250   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_x'",NULL);
00251 #endif
00252   {
00253    self->set_x(new_x);
00254   }
00255  }
00256  return 0;
00257 #ifndef TOLUA_RELEASE
00258  tolua_lerror:
00259  tolua_error(tolua_S,"#ferror in function 'set_x'.",&tolua_err);
00260  return 0;
00261 #endif
00262 }
00263 #endif //#ifndef TOLUA_DISABLE
00264 
00265 /* method: maxlenof_x of class  ResetMessage */
00266 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_maxlenof_x00
00267 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_maxlenof_x00(lua_State* tolua_S)
00268 {
00269 #ifndef TOLUA_RELEASE
00270  tolua_Error tolua_err;
00271  if (
00272      !tolua_isusertype(tolua_S,1,"const fawkes::LocalizerControlInterface::ResetMessage",0,&tolua_err) ||
00273      !tolua_isnoobj(tolua_S,2,&tolua_err)
00274  )
00275   goto tolua_lerror;
00276  else
00277 #endif
00278  {
00279   const fawkes::LocalizerControlInterface::ResetMessage* self = (const fawkes::LocalizerControlInterface::ResetMessage*)  tolua_tousertype(tolua_S,1,0);
00280 #ifndef TOLUA_RELEASE
00281   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_x'",NULL);
00282 #endif
00283   {
00284    int tolua_ret = (int)  self->maxlenof_x();
00285    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00286   }
00287  }
00288  return 1;
00289 #ifndef TOLUA_RELEASE
00290  tolua_lerror:
00291  tolua_error(tolua_S,"#ferror in function 'maxlenof_x'.",&tolua_err);
00292  return 0;
00293 #endif
00294 }
00295 #endif //#ifndef TOLUA_DISABLE
00296 
00297 /* method: y of class  ResetMessage */
00298 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_y00
00299 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_y00(lua_State* tolua_S)
00300 {
00301 #ifndef TOLUA_RELEASE
00302  tolua_Error tolua_err;
00303  if (
00304      !tolua_isusertype(tolua_S,1,"fawkes::LocalizerControlInterface::ResetMessage",0,&tolua_err) ||
00305      !tolua_isnoobj(tolua_S,2,&tolua_err)
00306  )
00307   goto tolua_lerror;
00308  else
00309 #endif
00310  {
00311   fawkes::LocalizerControlInterface::ResetMessage* self = (fawkes::LocalizerControlInterface::ResetMessage*)  tolua_tousertype(tolua_S,1,0);
00312 #ifndef TOLUA_RELEASE
00313   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'y'",NULL);
00314 #endif
00315   {
00316    float tolua_ret = (float)  self->y();
00317    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00318   }
00319  }
00320  return 1;
00321 #ifndef TOLUA_RELEASE
00322  tolua_lerror:
00323  tolua_error(tolua_S,"#ferror in function 'y'.",&tolua_err);
00324  return 0;
00325 #endif
00326 }
00327 #endif //#ifndef TOLUA_DISABLE
00328 
00329 /* method: set_y of class  ResetMessage */
00330 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_set_y00
00331 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_set_y00(lua_State* tolua_S)
00332 {
00333 #ifndef TOLUA_RELEASE
00334  tolua_Error tolua_err;
00335  if (
00336      !tolua_isusertype(tolua_S,1,"fawkes::LocalizerControlInterface::ResetMessage",0,&tolua_err) ||
00337      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00338      !tolua_isnoobj(tolua_S,3,&tolua_err)
00339  )
00340   goto tolua_lerror;
00341  else
00342 #endif
00343  {
00344   fawkes::LocalizerControlInterface::ResetMessage* self = (fawkes::LocalizerControlInterface::ResetMessage*)  tolua_tousertype(tolua_S,1,0);
00345   const float new_y = ((const float)  tolua_tonumber(tolua_S,2,0));
00346 #ifndef TOLUA_RELEASE
00347   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_y'",NULL);
00348 #endif
00349   {
00350    self->set_y(new_y);
00351   }
00352  }
00353  return 0;
00354 #ifndef TOLUA_RELEASE
00355  tolua_lerror:
00356  tolua_error(tolua_S,"#ferror in function 'set_y'.",&tolua_err);
00357  return 0;
00358 #endif
00359 }
00360 #endif //#ifndef TOLUA_DISABLE
00361 
00362 /* method: maxlenof_y of class  ResetMessage */
00363 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_maxlenof_y00
00364 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_maxlenof_y00(lua_State* tolua_S)
00365 {
00366 #ifndef TOLUA_RELEASE
00367  tolua_Error tolua_err;
00368  if (
00369      !tolua_isusertype(tolua_S,1,"const fawkes::LocalizerControlInterface::ResetMessage",0,&tolua_err) ||
00370      !tolua_isnoobj(tolua_S,2,&tolua_err)
00371  )
00372   goto tolua_lerror;
00373  else
00374 #endif
00375  {
00376   const fawkes::LocalizerControlInterface::ResetMessage* self = (const fawkes::LocalizerControlInterface::ResetMessage*)  tolua_tousertype(tolua_S,1,0);
00377 #ifndef TOLUA_RELEASE
00378   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_y'",NULL);
00379 #endif
00380   {
00381    int tolua_ret = (int)  self->maxlenof_y();
00382    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00383   }
00384  }
00385  return 1;
00386 #ifndef TOLUA_RELEASE
00387  tolua_lerror:
00388  tolua_error(tolua_S,"#ferror in function 'maxlenof_y'.",&tolua_err);
00389  return 0;
00390 #endif
00391 }
00392 #endif //#ifndef TOLUA_DISABLE
00393 
00394 /* method: ori of class  ResetMessage */
00395 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_ori00
00396 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_ori00(lua_State* tolua_S)
00397 {
00398 #ifndef TOLUA_RELEASE
00399  tolua_Error tolua_err;
00400  if (
00401      !tolua_isusertype(tolua_S,1,"fawkes::LocalizerControlInterface::ResetMessage",0,&tolua_err) ||
00402      !tolua_isnoobj(tolua_S,2,&tolua_err)
00403  )
00404   goto tolua_lerror;
00405  else
00406 #endif
00407  {
00408   fawkes::LocalizerControlInterface::ResetMessage* self = (fawkes::LocalizerControlInterface::ResetMessage*)  tolua_tousertype(tolua_S,1,0);
00409 #ifndef TOLUA_RELEASE
00410   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ori'",NULL);
00411 #endif
00412   {
00413    float tolua_ret = (float)  self->ori();
00414    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00415   }
00416  }
00417  return 1;
00418 #ifndef TOLUA_RELEASE
00419  tolua_lerror:
00420  tolua_error(tolua_S,"#ferror in function 'ori'.",&tolua_err);
00421  return 0;
00422 #endif
00423 }
00424 #endif //#ifndef TOLUA_DISABLE
00425 
00426 /* method: set_ori of class  ResetMessage */
00427 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_set_ori00
00428 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_set_ori00(lua_State* tolua_S)
00429 {
00430 #ifndef TOLUA_RELEASE
00431  tolua_Error tolua_err;
00432  if (
00433      !tolua_isusertype(tolua_S,1,"fawkes::LocalizerControlInterface::ResetMessage",0,&tolua_err) ||
00434      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00435      !tolua_isnoobj(tolua_S,3,&tolua_err)
00436  )
00437   goto tolua_lerror;
00438  else
00439 #endif
00440  {
00441   fawkes::LocalizerControlInterface::ResetMessage* self = (fawkes::LocalizerControlInterface::ResetMessage*)  tolua_tousertype(tolua_S,1,0);
00442   const float new_ori = ((const float)  tolua_tonumber(tolua_S,2,0));
00443 #ifndef TOLUA_RELEASE
00444   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_ori'",NULL);
00445 #endif
00446   {
00447    self->set_ori(new_ori);
00448   }
00449  }
00450  return 0;
00451 #ifndef TOLUA_RELEASE
00452  tolua_lerror:
00453  tolua_error(tolua_S,"#ferror in function 'set_ori'.",&tolua_err);
00454  return 0;
00455 #endif
00456 }
00457 #endif //#ifndef TOLUA_DISABLE
00458 
00459 /* method: maxlenof_ori of class  ResetMessage */
00460 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_maxlenof_ori00
00461 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_maxlenof_ori00(lua_State* tolua_S)
00462 {
00463 #ifndef TOLUA_RELEASE
00464  tolua_Error tolua_err;
00465  if (
00466      !tolua_isusertype(tolua_S,1,"const fawkes::LocalizerControlInterface::ResetMessage",0,&tolua_err) ||
00467      !tolua_isnoobj(tolua_S,2,&tolua_err)
00468  )
00469   goto tolua_lerror;
00470  else
00471 #endif
00472  {
00473   const fawkes::LocalizerControlInterface::ResetMessage* self = (const fawkes::LocalizerControlInterface::ResetMessage*)  tolua_tousertype(tolua_S,1,0);
00474 #ifndef TOLUA_RELEASE
00475   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_ori'",NULL);
00476 #endif
00477   {
00478    int tolua_ret = (int)  self->maxlenof_ori();
00479    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00480   }
00481  }
00482  return 1;
00483 #ifndef TOLUA_RELEASE
00484  tolua_lerror:
00485  tolua_error(tolua_S,"#ferror in function 'maxlenof_ori'.",&tolua_err);
00486  return 0;
00487 #endif
00488 }
00489 #endif //#ifndef TOLUA_DISABLE
00490 
00491 /* method: variance of class  ResetMessage */
00492 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_variance00
00493 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_variance00(lua_State* tolua_S)
00494 {
00495 #ifndef TOLUA_RELEASE
00496  tolua_Error tolua_err;
00497  if (
00498      !tolua_isusertype(tolua_S,1,"fawkes::LocalizerControlInterface::ResetMessage",0,&tolua_err) ||
00499      !tolua_isnoobj(tolua_S,2,&tolua_err)
00500  )
00501   goto tolua_lerror;
00502  else
00503 #endif
00504  {
00505   fawkes::LocalizerControlInterface::ResetMessage* self = (fawkes::LocalizerControlInterface::ResetMessage*)  tolua_tousertype(tolua_S,1,0);
00506 #ifndef TOLUA_RELEASE
00507   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'variance'",NULL);
00508 #endif
00509   {
00510    float tolua_ret = (float)  self->variance();
00511    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00512   }
00513  }
00514  return 1;
00515 #ifndef TOLUA_RELEASE
00516  tolua_lerror:
00517  tolua_error(tolua_S,"#ferror in function 'variance'.",&tolua_err);
00518  return 0;
00519 #endif
00520 }
00521 #endif //#ifndef TOLUA_DISABLE
00522 
00523 /* method: set_variance of class  ResetMessage */
00524 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_set_variance00
00525 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_set_variance00(lua_State* tolua_S)
00526 {
00527 #ifndef TOLUA_RELEASE
00528  tolua_Error tolua_err;
00529  if (
00530      !tolua_isusertype(tolua_S,1,"fawkes::LocalizerControlInterface::ResetMessage",0,&tolua_err) ||
00531      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00532      !tolua_isnoobj(tolua_S,3,&tolua_err)
00533  )
00534   goto tolua_lerror;
00535  else
00536 #endif
00537  {
00538   fawkes::LocalizerControlInterface::ResetMessage* self = (fawkes::LocalizerControlInterface::ResetMessage*)  tolua_tousertype(tolua_S,1,0);
00539   const float new_variance = ((const float)  tolua_tonumber(tolua_S,2,0));
00540 #ifndef TOLUA_RELEASE
00541   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_variance'",NULL);
00542 #endif
00543   {
00544    self->set_variance(new_variance);
00545   }
00546  }
00547  return 0;
00548 #ifndef TOLUA_RELEASE
00549  tolua_lerror:
00550  tolua_error(tolua_S,"#ferror in function 'set_variance'.",&tolua_err);
00551  return 0;
00552 #endif
00553 }
00554 #endif //#ifndef TOLUA_DISABLE
00555 
00556 /* method: maxlenof_variance of class  ResetMessage */
00557 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_maxlenof_variance00
00558 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_maxlenof_variance00(lua_State* tolua_S)
00559 {
00560 #ifndef TOLUA_RELEASE
00561  tolua_Error tolua_err;
00562  if (
00563      !tolua_isusertype(tolua_S,1,"const fawkes::LocalizerControlInterface::ResetMessage",0,&tolua_err) ||
00564      !tolua_isnoobj(tolua_S,2,&tolua_err)
00565  )
00566   goto tolua_lerror;
00567  else
00568 #endif
00569  {
00570   const fawkes::LocalizerControlInterface::ResetMessage* self = (const fawkes::LocalizerControlInterface::ResetMessage*)  tolua_tousertype(tolua_S,1,0);
00571 #ifndef TOLUA_RELEASE
00572   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_variance'",NULL);
00573 #endif
00574   {
00575    int tolua_ret = (int)  self->maxlenof_variance();
00576    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00577   }
00578  }
00579  return 1;
00580 #ifndef TOLUA_RELEASE
00581  tolua_lerror:
00582  tolua_error(tolua_S,"#ferror in function 'maxlenof_variance'.",&tolua_err);
00583  return 0;
00584 #endif
00585 }
00586 #endif //#ifndef TOLUA_DISABLE
00587 
00588 /* method: map_name of class  fawkes::LocalizerControlInterface */
00589 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_map_name00
00590 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_map_name00(lua_State* tolua_S)
00591 {
00592 #ifndef TOLUA_RELEASE
00593  tolua_Error tolua_err;
00594  if (
00595      !tolua_isusertype(tolua_S,1,"fawkes::LocalizerControlInterface",0,&tolua_err) ||
00596      !tolua_isnoobj(tolua_S,2,&tolua_err)
00597  )
00598   goto tolua_lerror;
00599  else
00600 #endif
00601  {
00602   fawkes::LocalizerControlInterface* self = (fawkes::LocalizerControlInterface*)  tolua_tousertype(tolua_S,1,0);
00603 #ifndef TOLUA_RELEASE
00604   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'map_name'",NULL);
00605 #endif
00606   {
00607    char* tolua_ret = (char*)  self->map_name();
00608    tolua_pushstring(tolua_S,(const char*)tolua_ret);
00609   }
00610  }
00611  return 1;
00612 #ifndef TOLUA_RELEASE
00613  tolua_lerror:
00614  tolua_error(tolua_S,"#ferror in function 'map_name'.",&tolua_err);
00615  return 0;
00616 #endif
00617 }
00618 #endif //#ifndef TOLUA_DISABLE
00619 
00620 /* method: set_map_name of class  fawkes::LocalizerControlInterface */
00621 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_set_map_name00
00622 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_set_map_name00(lua_State* tolua_S)
00623 {
00624 #ifndef TOLUA_RELEASE
00625  tolua_Error tolua_err;
00626  if (
00627      !tolua_isusertype(tolua_S,1,"fawkes::LocalizerControlInterface",0,&tolua_err) ||
00628      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
00629      !tolua_isnoobj(tolua_S,3,&tolua_err)
00630  )
00631   goto tolua_lerror;
00632  else
00633 #endif
00634  {
00635   fawkes::LocalizerControlInterface* self = (fawkes::LocalizerControlInterface*)  tolua_tousertype(tolua_S,1,0);
00636   const char* new_map_name = ((const char*)  tolua_tostring(tolua_S,2,0));
00637 #ifndef TOLUA_RELEASE
00638   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_map_name'",NULL);
00639 #endif
00640   {
00641    self->set_map_name(new_map_name);
00642   }
00643  }
00644  return 0;
00645 #ifndef TOLUA_RELEASE
00646  tolua_lerror:
00647  tolua_error(tolua_S,"#ferror in function 'set_map_name'.",&tolua_err);
00648  return 0;
00649 #endif
00650 }
00651 #endif //#ifndef TOLUA_DISABLE
00652 
00653 /* method: maxlenof_map_name of class  fawkes::LocalizerControlInterface */
00654 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_maxlenof_map_name00
00655 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_maxlenof_map_name00(lua_State* tolua_S)
00656 {
00657 #ifndef TOLUA_RELEASE
00658  tolua_Error tolua_err;
00659  if (
00660      !tolua_isusertype(tolua_S,1,"const fawkes::LocalizerControlInterface",0,&tolua_err) ||
00661      !tolua_isnoobj(tolua_S,2,&tolua_err)
00662  )
00663   goto tolua_lerror;
00664  else
00665 #endif
00666  {
00667   const fawkes::LocalizerControlInterface* self = (const fawkes::LocalizerControlInterface*)  tolua_tousertype(tolua_S,1,0);
00668 #ifndef TOLUA_RELEASE
00669   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_map_name'",NULL);
00670 #endif
00671   {
00672    int tolua_ret = (int)  self->maxlenof_map_name();
00673    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00674   }
00675  }
00676  return 1;
00677 #ifndef TOLUA_RELEASE
00678  tolua_lerror:
00679  tolua_error(tolua_S,"#ferror in function 'maxlenof_map_name'.",&tolua_err);
00680  return 0;
00681 #endif
00682 }
00683 #endif //#ifndef TOLUA_DISABLE
00684 
00685 /* method: oftype of class  fawkes::LocalizerControlInterface */
00686 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_oftype00
00687 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_oftype00(lua_State* tolua_S)
00688 {
00689 #ifndef TOLUA_RELEASE
00690  tolua_Error tolua_err;
00691  if (
00692      !tolua_isusertype(tolua_S,1,"const fawkes::LocalizerControlInterface",0,&tolua_err) ||
00693      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
00694      !tolua_isnoobj(tolua_S,3,&tolua_err)
00695  )
00696   goto tolua_lerror;
00697  else
00698 #endif
00699  {
00700   const fawkes::LocalizerControlInterface* self = (const fawkes::LocalizerControlInterface*)  tolua_tousertype(tolua_S,1,0);
00701   const char* interface_type = ((const char*)  tolua_tostring(tolua_S,2,0));
00702 #ifndef TOLUA_RELEASE
00703   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'oftype'",NULL);
00704 #endif
00705   {
00706    bool tolua_ret = (bool)  self->oftype(interface_type);
00707    tolua_pushboolean(tolua_S,(bool)tolua_ret);
00708   }
00709  }
00710  return 1;
00711 #ifndef TOLUA_RELEASE
00712  tolua_lerror:
00713  tolua_error(tolua_S,"#ferror in function 'oftype'.",&tolua_err);
00714  return 0;
00715 #endif
00716 }
00717 #endif //#ifndef TOLUA_DISABLE
00718 
00719 /* method: datachunk of class  fawkes::LocalizerControlInterface */
00720 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_datachunk00
00721 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_datachunk00(lua_State* tolua_S)
00722 {
00723 #ifndef TOLUA_RELEASE
00724  tolua_Error tolua_err;
00725  if (
00726      !tolua_isusertype(tolua_S,1,"const fawkes::LocalizerControlInterface",0,&tolua_err) ||
00727      !tolua_isnoobj(tolua_S,2,&tolua_err)
00728  )
00729   goto tolua_lerror;
00730  else
00731 #endif
00732  {
00733   const fawkes::LocalizerControlInterface* self = (const fawkes::LocalizerControlInterface*)  tolua_tousertype(tolua_S,1,0);
00734 #ifndef TOLUA_RELEASE
00735   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datachunk'",NULL);
00736 #endif
00737   {
00738    const void* tolua_ret = (const void*)  self->datachunk();
00739    tolua_pushuserdata(tolua_S,(void*)tolua_ret);
00740   }
00741  }
00742  return 1;
00743 #ifndef TOLUA_RELEASE
00744  tolua_lerror:
00745  tolua_error(tolua_S,"#ferror in function 'datachunk'.",&tolua_err);
00746  return 0;
00747 #endif
00748 }
00749 #endif //#ifndef TOLUA_DISABLE
00750 
00751 /* method: datasize of class  fawkes::LocalizerControlInterface */
00752 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_datasize00
00753 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_datasize00(lua_State* tolua_S)
00754 {
00755 #ifndef TOLUA_RELEASE
00756  tolua_Error tolua_err;
00757  if (
00758      !tolua_isusertype(tolua_S,1,"const fawkes::LocalizerControlInterface",0,&tolua_err) ||
00759      !tolua_isnoobj(tolua_S,2,&tolua_err)
00760  )
00761   goto tolua_lerror;
00762  else
00763 #endif
00764  {
00765   const fawkes::LocalizerControlInterface* self = (const fawkes::LocalizerControlInterface*)  tolua_tousertype(tolua_S,1,0);
00766 #ifndef TOLUA_RELEASE
00767   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datasize'",NULL);
00768 #endif
00769   {
00770    unsigned int tolua_ret = (unsigned int)  self->datasize();
00771    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00772   }
00773  }
00774  return 1;
00775 #ifndef TOLUA_RELEASE
00776  tolua_lerror:
00777  tolua_error(tolua_S,"#ferror in function 'datasize'.",&tolua_err);
00778  return 0;
00779 #endif
00780 }
00781 #endif //#ifndef TOLUA_DISABLE
00782 
00783 /* method: type of class  fawkes::LocalizerControlInterface */
00784 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_type00
00785 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_type00(lua_State* tolua_S)
00786 {
00787 #ifndef TOLUA_RELEASE
00788  tolua_Error tolua_err;
00789  if (
00790      !tolua_isusertype(tolua_S,1,"const fawkes::LocalizerControlInterface",0,&tolua_err) ||
00791      !tolua_isnoobj(tolua_S,2,&tolua_err)
00792  )
00793   goto tolua_lerror;
00794  else
00795 #endif
00796  {
00797   const fawkes::LocalizerControlInterface* self = (const fawkes::LocalizerControlInterface*)  tolua_tousertype(tolua_S,1,0);
00798 #ifndef TOLUA_RELEASE
00799   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'type'",NULL);
00800 #endif
00801   {
00802    const char* tolua_ret = (const char*)  self->type();
00803    tolua_pushstring(tolua_S,(const char*)tolua_ret);
00804   }
00805  }
00806  return 1;
00807 #ifndef TOLUA_RELEASE
00808  tolua_lerror:
00809  tolua_error(tolua_S,"#ferror in function 'type'.",&tolua_err);
00810  return 0;
00811 #endif
00812 }
00813 #endif //#ifndef TOLUA_DISABLE
00814 
00815 /* method: id of class  fawkes::LocalizerControlInterface */
00816 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_id00
00817 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_id00(lua_State* tolua_S)
00818 {
00819 #ifndef TOLUA_RELEASE
00820  tolua_Error tolua_err;
00821  if (
00822      !tolua_isusertype(tolua_S,1,"const fawkes::LocalizerControlInterface",0,&tolua_err) ||
00823      !tolua_isnoobj(tolua_S,2,&tolua_err)
00824  )
00825   goto tolua_lerror;
00826  else
00827 #endif
00828  {
00829   const fawkes::LocalizerControlInterface* self = (const fawkes::LocalizerControlInterface*)  tolua_tousertype(tolua_S,1,0);
00830 #ifndef TOLUA_RELEASE
00831   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'id'",NULL);
00832 #endif
00833   {
00834    const char* tolua_ret = (const char*)  self->id();
00835    tolua_pushstring(tolua_S,(const char*)tolua_ret);
00836   }
00837  }
00838  return 1;
00839 #ifndef TOLUA_RELEASE
00840  tolua_lerror:
00841  tolua_error(tolua_S,"#ferror in function 'id'.",&tolua_err);
00842  return 0;
00843 #endif
00844 }
00845 #endif //#ifndef TOLUA_DISABLE
00846 
00847 /* method: uid of class  fawkes::LocalizerControlInterface */
00848 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_uid00
00849 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_uid00(lua_State* tolua_S)
00850 {
00851 #ifndef TOLUA_RELEASE
00852  tolua_Error tolua_err;
00853  if (
00854      !tolua_isusertype(tolua_S,1,"const fawkes::LocalizerControlInterface",0,&tolua_err) ||
00855      !tolua_isnoobj(tolua_S,2,&tolua_err)
00856  )
00857   goto tolua_lerror;
00858  else
00859 #endif
00860  {
00861   const fawkes::LocalizerControlInterface* self = (const fawkes::LocalizerControlInterface*)  tolua_tousertype(tolua_S,1,0);
00862 #ifndef TOLUA_RELEASE
00863   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'uid'",NULL);
00864 #endif
00865   {
00866    const char* tolua_ret = (const char*)  self->uid();
00867    tolua_pushstring(tolua_S,(const char*)tolua_ret);
00868   }
00869  }
00870  return 1;
00871 #ifndef TOLUA_RELEASE
00872  tolua_lerror:
00873  tolua_error(tolua_S,"#ferror in function 'uid'.",&tolua_err);
00874  return 0;
00875 #endif
00876 }
00877 #endif //#ifndef TOLUA_DISABLE
00878 
00879 /* method: serial of class  fawkes::LocalizerControlInterface */
00880 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_serial00
00881 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_serial00(lua_State* tolua_S)
00882 {
00883 #ifndef TOLUA_RELEASE
00884  tolua_Error tolua_err;
00885  if (
00886      !tolua_isusertype(tolua_S,1,"const fawkes::LocalizerControlInterface",0,&tolua_err) ||
00887      !tolua_isnoobj(tolua_S,2,&tolua_err)
00888  )
00889   goto tolua_lerror;
00890  else
00891 #endif
00892  {
00893   const fawkes::LocalizerControlInterface* self = (const fawkes::LocalizerControlInterface*)  tolua_tousertype(tolua_S,1,0);
00894 #ifndef TOLUA_RELEASE
00895   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'serial'",NULL);
00896 #endif
00897   {
00898    unsigned int tolua_ret = (unsigned int)  self->serial();
00899    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00900   }
00901  }
00902  return 1;
00903 #ifndef TOLUA_RELEASE
00904  tolua_lerror:
00905  tolua_error(tolua_S,"#ferror in function 'serial'.",&tolua_err);
00906  return 0;
00907 #endif
00908 }
00909 #endif //#ifndef TOLUA_DISABLE
00910 
00911 /* method: mem_serial of class  fawkes::LocalizerControlInterface */
00912 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_mem_serial00
00913 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_mem_serial00(lua_State* tolua_S)
00914 {
00915 #ifndef TOLUA_RELEASE
00916  tolua_Error tolua_err;
00917  if (
00918      !tolua_isusertype(tolua_S,1,"const fawkes::LocalizerControlInterface",0,&tolua_err) ||
00919      !tolua_isnoobj(tolua_S,2,&tolua_err)
00920  )
00921   goto tolua_lerror;
00922  else
00923 #endif
00924  {
00925   const fawkes::LocalizerControlInterface* self = (const fawkes::LocalizerControlInterface*)  tolua_tousertype(tolua_S,1,0);
00926 #ifndef TOLUA_RELEASE
00927   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'mem_serial'",NULL);
00928 #endif
00929   {
00930    unsigned int tolua_ret = (unsigned int)  self->mem_serial();
00931    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00932   }
00933  }
00934  return 1;
00935 #ifndef TOLUA_RELEASE
00936  tolua_lerror:
00937  tolua_error(tolua_S,"#ferror in function 'mem_serial'.",&tolua_err);
00938  return 0;
00939 #endif
00940 }
00941 #endif //#ifndef TOLUA_DISABLE
00942 
00943 /* method: operator== of class  fawkes::LocalizerControlInterface */
00944 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface__eq00
00945 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface__eq00(lua_State* tolua_S)
00946 {
00947 #ifndef TOLUA_RELEASE
00948  tolua_Error tolua_err;
00949  if (
00950      !tolua_isusertype(tolua_S,1,"const fawkes::LocalizerControlInterface",0,&tolua_err) ||
00951      !tolua_isusertype(tolua_S,2,"Interface",0,&tolua_err) ||
00952      !tolua_isnoobj(tolua_S,3,&tolua_err)
00953  )
00954   goto tolua_lerror;
00955  else
00956 #endif
00957  {
00958   const fawkes::LocalizerControlInterface* self = (const fawkes::LocalizerControlInterface*)  tolua_tousertype(tolua_S,1,0);
00959   Interface* comp = ((Interface*)  tolua_tousertype(tolua_S,2,0));
00960 #ifndef TOLUA_RELEASE
00961   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='",NULL);
00962 #endif
00963   {
00964    bool tolua_ret = (bool)  self->operator==(*comp);
00965    tolua_pushboolean(tolua_S,(bool)tolua_ret);
00966   }
00967  }
00968  return 1;
00969 #ifndef TOLUA_RELEASE
00970  tolua_lerror:
00971  tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err);
00972  return 0;
00973 #endif
00974 }
00975 #endif //#ifndef TOLUA_DISABLE
00976 
00977 /* method: hash of class  fawkes::LocalizerControlInterface */
00978 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_hash00
00979 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_hash00(lua_State* tolua_S)
00980 {
00981 #ifndef TOLUA_RELEASE
00982  tolua_Error tolua_err;
00983  if (
00984      !tolua_isusertype(tolua_S,1,"const fawkes::LocalizerControlInterface",0,&tolua_err) ||
00985      !tolua_isnoobj(tolua_S,2,&tolua_err)
00986  )
00987   goto tolua_lerror;
00988  else
00989 #endif
00990  {
00991   const fawkes::LocalizerControlInterface* self = (const fawkes::LocalizerControlInterface*)  tolua_tousertype(tolua_S,1,0);
00992 #ifndef TOLUA_RELEASE
00993   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash'",NULL);
00994 #endif
00995   {
00996    unsigned const char* tolua_ret = ( unsigned const char*)  self->hash();
00997    tolua_pushstring(tolua_S,(const char*)tolua_ret);
00998   }
00999  }
01000  return 1;
01001 #ifndef TOLUA_RELEASE
01002  tolua_lerror:
01003  tolua_error(tolua_S,"#ferror in function 'hash'.",&tolua_err);
01004  return 0;
01005 #endif
01006 }
01007 #endif //#ifndef TOLUA_DISABLE
01008 
01009 /* method: hash_size of class  fawkes::LocalizerControlInterface */
01010 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_hash_size00
01011 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_hash_size00(lua_State* tolua_S)
01012 {
01013 #ifndef TOLUA_RELEASE
01014  tolua_Error tolua_err;
01015  if (
01016      !tolua_isusertype(tolua_S,1,"const fawkes::LocalizerControlInterface",0,&tolua_err) ||
01017      !tolua_isnoobj(tolua_S,2,&tolua_err)
01018  )
01019   goto tolua_lerror;
01020  else
01021 #endif
01022  {
01023   const fawkes::LocalizerControlInterface* self = (const fawkes::LocalizerControlInterface*)  tolua_tousertype(tolua_S,1,0);
01024 #ifndef TOLUA_RELEASE
01025   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash_size'",NULL);
01026 #endif
01027   {
01028    int tolua_ret = (int)  self->hash_size();
01029    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01030   }
01031  }
01032  return 1;
01033 #ifndef TOLUA_RELEASE
01034  tolua_lerror:
01035  tolua_error(tolua_S,"#ferror in function 'hash_size'.",&tolua_err);
01036  return 0;
01037 #endif
01038 }
01039 #endif //#ifndef TOLUA_DISABLE
01040 
01041 /* method: hash_printable of class  fawkes::LocalizerControlInterface */
01042 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_hash_printable00
01043 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_hash_printable00(lua_State* tolua_S)
01044 {
01045 #ifndef TOLUA_RELEASE
01046  tolua_Error tolua_err;
01047  if (
01048      !tolua_isusertype(tolua_S,1,"const fawkes::LocalizerControlInterface",0,&tolua_err) ||
01049      !tolua_isnoobj(tolua_S,2,&tolua_err)
01050  )
01051   goto tolua_lerror;
01052  else
01053 #endif
01054  {
01055   const fawkes::LocalizerControlInterface* self = (const fawkes::LocalizerControlInterface*)  tolua_tousertype(tolua_S,1,0);
01056 #ifndef TOLUA_RELEASE
01057   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash_printable'",NULL);
01058 #endif
01059   {
01060    const char* tolua_ret = (const char*)  self->hash_printable();
01061    tolua_pushstring(tolua_S,(const char*)tolua_ret);
01062   }
01063  }
01064  return 1;
01065 #ifndef TOLUA_RELEASE
01066  tolua_lerror:
01067  tolua_error(tolua_S,"#ferror in function 'hash_printable'.",&tolua_err);
01068  return 0;
01069 #endif
01070 }
01071 #endif //#ifndef TOLUA_DISABLE
01072 
01073 /* method: is_writer of class  fawkes::LocalizerControlInterface */
01074 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_is_writer00
01075 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_is_writer00(lua_State* tolua_S)
01076 {
01077 #ifndef TOLUA_RELEASE
01078  tolua_Error tolua_err;
01079  if (
01080      !tolua_isusertype(tolua_S,1,"const fawkes::LocalizerControlInterface",0,&tolua_err) ||
01081      !tolua_isnoobj(tolua_S,2,&tolua_err)
01082  )
01083   goto tolua_lerror;
01084  else
01085 #endif
01086  {
01087   const fawkes::LocalizerControlInterface* self = (const fawkes::LocalizerControlInterface*)  tolua_tousertype(tolua_S,1,0);
01088 #ifndef TOLUA_RELEASE
01089   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_writer'",NULL);
01090 #endif
01091   {
01092    bool tolua_ret = (bool)  self->is_writer();
01093    tolua_pushboolean(tolua_S,(bool)tolua_ret);
01094   }
01095  }
01096  return 1;
01097 #ifndef TOLUA_RELEASE
01098  tolua_lerror:
01099  tolua_error(tolua_S,"#ferror in function 'is_writer'.",&tolua_err);
01100  return 0;
01101 #endif
01102 }
01103 #endif //#ifndef TOLUA_DISABLE
01104 
01105 /* method: set_from_chunk of class  fawkes::LocalizerControlInterface */
01106 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_set_from_chunk00
01107 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_set_from_chunk00(lua_State* tolua_S)
01108 {
01109 #ifndef TOLUA_RELEASE
01110  tolua_Error tolua_err;
01111  if (
01112      !tolua_isusertype(tolua_S,1,"fawkes::LocalizerControlInterface",0,&tolua_err) ||
01113      !tolua_isuserdata(tolua_S,2,0,&tolua_err) ||
01114      !tolua_isnoobj(tolua_S,3,&tolua_err)
01115  )
01116   goto tolua_lerror;
01117  else
01118 #endif
01119  {
01120   fawkes::LocalizerControlInterface* self = (fawkes::LocalizerControlInterface*)  tolua_tousertype(tolua_S,1,0);
01121   void* chunk = ((void*)  tolua_touserdata(tolua_S,2,0));
01122 #ifndef TOLUA_RELEASE
01123   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_from_chunk'",NULL);
01124 #endif
01125   {
01126    self->set_from_chunk(chunk);
01127   }
01128  }
01129  return 0;
01130 #ifndef TOLUA_RELEASE
01131  tolua_lerror:
01132  tolua_error(tolua_S,"#ferror in function 'set_from_chunk'.",&tolua_err);
01133  return 0;
01134 #endif
01135 }
01136 #endif //#ifndef TOLUA_DISABLE
01137 
01138 /* method: create_message of class  fawkes::LocalizerControlInterface */
01139 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_create_message00
01140 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_create_message00(lua_State* tolua_S)
01141 {
01142 #ifndef TOLUA_RELEASE
01143  tolua_Error tolua_err;
01144  if (
01145      !tolua_isusertype(tolua_S,1,"const fawkes::LocalizerControlInterface",0,&tolua_err) ||
01146      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
01147      !tolua_isnoobj(tolua_S,3,&tolua_err)
01148  )
01149   goto tolua_lerror;
01150  else
01151 #endif
01152  {
01153   const fawkes::LocalizerControlInterface* self = (const fawkes::LocalizerControlInterface*)  tolua_tousertype(tolua_S,1,0);
01154   const char* type = ((const char*)  tolua_tostring(tolua_S,2,0));
01155 #ifndef TOLUA_RELEASE
01156   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'create_message'",NULL);
01157 #endif
01158   {
01159    Message* tolua_ret = (Message*)  self->create_message(type);
01160    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Message");
01161   }
01162  }
01163  return 1;
01164 #ifndef TOLUA_RELEASE
01165  tolua_lerror:
01166  tolua_error(tolua_S,"#ferror in function 'create_message'.",&tolua_err);
01167  return 0;
01168 #endif
01169 }
01170 #endif //#ifndef TOLUA_DISABLE
01171 
01172 /* method: read of class  fawkes::LocalizerControlInterface */
01173 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_read00
01174 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_read00(lua_State* tolua_S)
01175 {
01176 #ifndef TOLUA_RELEASE
01177  tolua_Error tolua_err;
01178  if (
01179      !tolua_isusertype(tolua_S,1,"fawkes::LocalizerControlInterface",0,&tolua_err) ||
01180      !tolua_isnoobj(tolua_S,2,&tolua_err)
01181  )
01182   goto tolua_lerror;
01183  else
01184 #endif
01185  {
01186   fawkes::LocalizerControlInterface* self = (fawkes::LocalizerControlInterface*)  tolua_tousertype(tolua_S,1,0);
01187 #ifndef TOLUA_RELEASE
01188   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'read'",NULL);
01189 #endif
01190   {
01191    self->read();
01192   }
01193  }
01194  return 0;
01195 #ifndef TOLUA_RELEASE
01196  tolua_lerror:
01197  tolua_error(tolua_S,"#ferror in function 'read'.",&tolua_err);
01198  return 0;
01199 #endif
01200 }
01201 #endif //#ifndef TOLUA_DISABLE
01202 
01203 /* method: write of class  fawkes::LocalizerControlInterface */
01204 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_write00
01205 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_write00(lua_State* tolua_S)
01206 {
01207 #ifndef TOLUA_RELEASE
01208  tolua_Error tolua_err;
01209  if (
01210      !tolua_isusertype(tolua_S,1,"fawkes::LocalizerControlInterface",0,&tolua_err) ||
01211      !tolua_isnoobj(tolua_S,2,&tolua_err)
01212  )
01213   goto tolua_lerror;
01214  else
01215 #endif
01216  {
01217   fawkes::LocalizerControlInterface* self = (fawkes::LocalizerControlInterface*)  tolua_tousertype(tolua_S,1,0);
01218 #ifndef TOLUA_RELEASE
01219   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'write'",NULL);
01220 #endif
01221   {
01222    self->write();
01223   }
01224  }
01225  return 0;
01226 #ifndef TOLUA_RELEASE
01227  tolua_lerror:
01228  tolua_error(tolua_S,"#ferror in function 'write'.",&tolua_err);
01229  return 0;
01230 #endif
01231 }
01232 #endif //#ifndef TOLUA_DISABLE
01233 
01234 /* method: has_writer of class  fawkes::LocalizerControlInterface */
01235 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_has_writer00
01236 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_has_writer00(lua_State* tolua_S)
01237 {
01238 #ifndef TOLUA_RELEASE
01239  tolua_Error tolua_err;
01240  if (
01241      !tolua_isusertype(tolua_S,1,"const fawkes::LocalizerControlInterface",0,&tolua_err) ||
01242      !tolua_isnoobj(tolua_S,2,&tolua_err)
01243  )
01244   goto tolua_lerror;
01245  else
01246 #endif
01247  {
01248   const fawkes::LocalizerControlInterface* self = (const fawkes::LocalizerControlInterface*)  tolua_tousertype(tolua_S,1,0);
01249 #ifndef TOLUA_RELEASE
01250   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'has_writer'",NULL);
01251 #endif
01252   {
01253    bool tolua_ret = (bool)  self->has_writer();
01254    tolua_pushboolean(tolua_S,(bool)tolua_ret);
01255   }
01256  }
01257  return 1;
01258 #ifndef TOLUA_RELEASE
01259  tolua_lerror:
01260  tolua_error(tolua_S,"#ferror in function 'has_writer'.",&tolua_err);
01261  return 0;
01262 #endif
01263 }
01264 #endif //#ifndef TOLUA_DISABLE
01265 
01266 /* method: num_readers of class  fawkes::LocalizerControlInterface */
01267 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_num_readers00
01268 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_num_readers00(lua_State* tolua_S)
01269 {
01270 #ifndef TOLUA_RELEASE
01271  tolua_Error tolua_err;
01272  if (
01273      !tolua_isusertype(tolua_S,1,"const fawkes::LocalizerControlInterface",0,&tolua_err) ||
01274      !tolua_isnoobj(tolua_S,2,&tolua_err)
01275  )
01276   goto tolua_lerror;
01277  else
01278 #endif
01279  {
01280   const fawkes::LocalizerControlInterface* self = (const fawkes::LocalizerControlInterface*)  tolua_tousertype(tolua_S,1,0);
01281 #ifndef TOLUA_RELEASE
01282   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'num_readers'",NULL);
01283 #endif
01284   {
01285    unsigned int tolua_ret = (unsigned int)  self->num_readers();
01286    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01287   }
01288  }
01289  return 1;
01290 #ifndef TOLUA_RELEASE
01291  tolua_lerror:
01292  tolua_error(tolua_S,"#ferror in function 'num_readers'.",&tolua_err);
01293  return 0;
01294 #endif
01295 }
01296 #endif //#ifndef TOLUA_DISABLE
01297 
01298 /* method: msgq_enqueue_copy of class  fawkes::LocalizerControlInterface */
01299 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_enqueue_copy00
01300 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_enqueue_copy00(lua_State* tolua_S)
01301 {
01302 #ifndef TOLUA_RELEASE
01303  tolua_Error tolua_err;
01304  if (
01305      !tolua_isusertype(tolua_S,1,"fawkes::LocalizerControlInterface",0,&tolua_err) ||
01306      !tolua_isusertype(tolua_S,2,"Message",0,&tolua_err) ||
01307      !tolua_isnoobj(tolua_S,3,&tolua_err)
01308  )
01309   goto tolua_lerror;
01310  else
01311 #endif
01312  {
01313   fawkes::LocalizerControlInterface* self = (fawkes::LocalizerControlInterface*)  tolua_tousertype(tolua_S,1,0);
01314   Message* message = ((Message*)  tolua_tousertype(tolua_S,2,0));
01315 #ifndef TOLUA_RELEASE
01316   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_enqueue_copy'",NULL);
01317 #endif
01318   {
01319    unsigned int tolua_ret = (unsigned int)  self->msgq_enqueue_copy(message);
01320    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01321   }
01322  }
01323  return 1;
01324 #ifndef TOLUA_RELEASE
01325  tolua_lerror:
01326  tolua_error(tolua_S,"#ferror in function 'msgq_enqueue_copy'.",&tolua_err);
01327  return 0;
01328 #endif
01329 }
01330 #endif //#ifndef TOLUA_DISABLE
01331 
01332 /* method: msgq_remove of class  fawkes::LocalizerControlInterface */
01333 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_remove00
01334 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_remove00(lua_State* tolua_S)
01335 {
01336 #ifndef TOLUA_RELEASE
01337  tolua_Error tolua_err;
01338  if (
01339      !tolua_isusertype(tolua_S,1,"fawkes::LocalizerControlInterface",0,&tolua_err) ||
01340      !tolua_isusertype(tolua_S,2,"Message",0,&tolua_err) ||
01341      !tolua_isnoobj(tolua_S,3,&tolua_err)
01342  )
01343   goto tolua_lerror;
01344  else
01345 #endif
01346  {
01347   fawkes::LocalizerControlInterface* self = (fawkes::LocalizerControlInterface*)  tolua_tousertype(tolua_S,1,0);
01348   Message* message = ((Message*)  tolua_tousertype(tolua_S,2,0));
01349 #ifndef TOLUA_RELEASE
01350   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_remove'",NULL);
01351 #endif
01352   {
01353    self->msgq_remove(message);
01354   }
01355  }
01356  return 0;
01357 #ifndef TOLUA_RELEASE
01358  tolua_lerror:
01359  tolua_error(tolua_S,"#ferror in function 'msgq_remove'.",&tolua_err);
01360  return 0;
01361 #endif
01362 }
01363 #endif //#ifndef TOLUA_DISABLE
01364 
01365 /* method: msgq_remove of class  fawkes::LocalizerControlInterface */
01366 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_remove01
01367 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_remove01(lua_State* tolua_S)
01368 {
01369  tolua_Error tolua_err;
01370  if (
01371      !tolua_isusertype(tolua_S,1,"fawkes::LocalizerControlInterface",0,&tolua_err) ||
01372      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01373      !tolua_isnoobj(tolua_S,3,&tolua_err)
01374  )
01375   goto tolua_lerror;
01376  else
01377  {
01378   fawkes::LocalizerControlInterface* self = (fawkes::LocalizerControlInterface*)  tolua_tousertype(tolua_S,1,0);
01379   unsigned int message_id = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
01380 #ifndef TOLUA_RELEASE
01381   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_remove'",NULL);
01382 #endif
01383   {
01384    self->msgq_remove(message_id);
01385   }
01386  }
01387  return 0;
01388 tolua_lerror:
01389  return tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_remove00(tolua_S);
01390 }
01391 #endif //#ifndef TOLUA_DISABLE
01392 
01393 /* method: msgq_size of class  fawkes::LocalizerControlInterface */
01394 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_size00
01395 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_size00(lua_State* tolua_S)
01396 {
01397 #ifndef TOLUA_RELEASE
01398  tolua_Error tolua_err;
01399  if (
01400      !tolua_isusertype(tolua_S,1,"fawkes::LocalizerControlInterface",0,&tolua_err) ||
01401      !tolua_isnoobj(tolua_S,2,&tolua_err)
01402  )
01403   goto tolua_lerror;
01404  else
01405 #endif
01406  {
01407   fawkes::LocalizerControlInterface* self = (fawkes::LocalizerControlInterface*)  tolua_tousertype(tolua_S,1,0);
01408 #ifndef TOLUA_RELEASE
01409   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_size'",NULL);
01410 #endif
01411   {
01412    unsigned int tolua_ret = (unsigned int)  self->msgq_size();
01413    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01414   }
01415  }
01416  return 1;
01417 #ifndef TOLUA_RELEASE
01418  tolua_lerror:
01419  tolua_error(tolua_S,"#ferror in function 'msgq_size'.",&tolua_err);
01420  return 0;
01421 #endif
01422 }
01423 #endif //#ifndef TOLUA_DISABLE
01424 
01425 /* method: msgq_flush of class  fawkes::LocalizerControlInterface */
01426 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_flush00
01427 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_flush00(lua_State* tolua_S)
01428 {
01429 #ifndef TOLUA_RELEASE
01430  tolua_Error tolua_err;
01431  if (
01432      !tolua_isusertype(tolua_S,1,"fawkes::LocalizerControlInterface",0,&tolua_err) ||
01433      !tolua_isnoobj(tolua_S,2,&tolua_err)
01434  )
01435   goto tolua_lerror;
01436  else
01437 #endif
01438  {
01439   fawkes::LocalizerControlInterface* self = (fawkes::LocalizerControlInterface*)  tolua_tousertype(tolua_S,1,0);
01440 #ifndef TOLUA_RELEASE
01441   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_flush'",NULL);
01442 #endif
01443   {
01444    self->msgq_flush();
01445   }
01446  }
01447  return 0;
01448 #ifndef TOLUA_RELEASE
01449  tolua_lerror:
01450  tolua_error(tolua_S,"#ferror in function 'msgq_flush'.",&tolua_err);
01451  return 0;
01452 #endif
01453 }
01454 #endif //#ifndef TOLUA_DISABLE
01455 
01456 /* method: msgq_lock of class  fawkes::LocalizerControlInterface */
01457 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_lock00
01458 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_lock00(lua_State* tolua_S)
01459 {
01460 #ifndef TOLUA_RELEASE
01461  tolua_Error tolua_err;
01462  if (
01463      !tolua_isusertype(tolua_S,1,"fawkes::LocalizerControlInterface",0,&tolua_err) ||
01464      !tolua_isnoobj(tolua_S,2,&tolua_err)
01465  )
01466   goto tolua_lerror;
01467  else
01468 #endif
01469  {
01470   fawkes::LocalizerControlInterface* self = (fawkes::LocalizerControlInterface*)  tolua_tousertype(tolua_S,1,0);
01471 #ifndef TOLUA_RELEASE
01472   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_lock'",NULL);
01473 #endif
01474   {
01475    self->msgq_lock();
01476   }
01477  }
01478  return 0;
01479 #ifndef TOLUA_RELEASE
01480  tolua_lerror:
01481  tolua_error(tolua_S,"#ferror in function 'msgq_lock'.",&tolua_err);
01482  return 0;
01483 #endif
01484 }
01485 #endif //#ifndef TOLUA_DISABLE
01486 
01487 /* method: msgq_try_lock of class  fawkes::LocalizerControlInterface */
01488 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_try_lock00
01489 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_try_lock00(lua_State* tolua_S)
01490 {
01491 #ifndef TOLUA_RELEASE
01492  tolua_Error tolua_err;
01493  if (
01494      !tolua_isusertype(tolua_S,1,"fawkes::LocalizerControlInterface",0,&tolua_err) ||
01495      !tolua_isnoobj(tolua_S,2,&tolua_err)
01496  )
01497   goto tolua_lerror;
01498  else
01499 #endif
01500  {
01501   fawkes::LocalizerControlInterface* self = (fawkes::LocalizerControlInterface*)  tolua_tousertype(tolua_S,1,0);
01502 #ifndef TOLUA_RELEASE
01503   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_try_lock'",NULL);
01504 #endif
01505   {
01506    bool tolua_ret = (bool)  self->msgq_try_lock();
01507    tolua_pushboolean(tolua_S,(bool)tolua_ret);
01508   }
01509  }
01510  return 1;
01511 #ifndef TOLUA_RELEASE
01512  tolua_lerror:
01513  tolua_error(tolua_S,"#ferror in function 'msgq_try_lock'.",&tolua_err);
01514  return 0;
01515 #endif
01516 }
01517 #endif //#ifndef TOLUA_DISABLE
01518 
01519 /* method: msgq_unlock of class  fawkes::LocalizerControlInterface */
01520 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_unlock00
01521 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_unlock00(lua_State* tolua_S)
01522 {
01523 #ifndef TOLUA_RELEASE
01524  tolua_Error tolua_err;
01525  if (
01526      !tolua_isusertype(tolua_S,1,"fawkes::LocalizerControlInterface",0,&tolua_err) ||
01527      !tolua_isnoobj(tolua_S,2,&tolua_err)
01528  )
01529   goto tolua_lerror;
01530  else
01531 #endif
01532  {
01533   fawkes::LocalizerControlInterface* self = (fawkes::LocalizerControlInterface*)  tolua_tousertype(tolua_S,1,0);
01534 #ifndef TOLUA_RELEASE
01535   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_unlock'",NULL);
01536 #endif
01537   {
01538    self->msgq_unlock();
01539   }
01540  }
01541  return 0;
01542 #ifndef TOLUA_RELEASE
01543  tolua_lerror:
01544  tolua_error(tolua_S,"#ferror in function 'msgq_unlock'.",&tolua_err);
01545  return 0;
01546 #endif
01547 }
01548 #endif //#ifndef TOLUA_DISABLE
01549 
01550 /* method: msgq_pop of class  fawkes::LocalizerControlInterface */
01551 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_pop00
01552 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_pop00(lua_State* tolua_S)
01553 {
01554 #ifndef TOLUA_RELEASE
01555  tolua_Error tolua_err;
01556  if (
01557      !tolua_isusertype(tolua_S,1,"fawkes::LocalizerControlInterface",0,&tolua_err) ||
01558      !tolua_isnoobj(tolua_S,2,&tolua_err)
01559  )
01560   goto tolua_lerror;
01561  else
01562 #endif
01563  {
01564   fawkes::LocalizerControlInterface* self = (fawkes::LocalizerControlInterface*)  tolua_tousertype(tolua_S,1,0);
01565 #ifndef TOLUA_RELEASE
01566   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_pop'",NULL);
01567 #endif
01568   {
01569    self->msgq_pop();
01570   }
01571  }
01572  return 0;
01573 #ifndef TOLUA_RELEASE
01574  tolua_lerror:
01575  tolua_error(tolua_S,"#ferror in function 'msgq_pop'.",&tolua_err);
01576  return 0;
01577 #endif
01578 }
01579 #endif //#ifndef TOLUA_DISABLE
01580 
01581 /* method: msgq_first of class  fawkes::LocalizerControlInterface */
01582 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_first00
01583 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_first00(lua_State* tolua_S)
01584 {
01585 #ifndef TOLUA_RELEASE
01586  tolua_Error tolua_err;
01587  if (
01588      !tolua_isusertype(tolua_S,1,"fawkes::LocalizerControlInterface",0,&tolua_err) ||
01589      !tolua_isnoobj(tolua_S,2,&tolua_err)
01590  )
01591   goto tolua_lerror;
01592  else
01593 #endif
01594  {
01595   fawkes::LocalizerControlInterface* self = (fawkes::LocalizerControlInterface*)  tolua_tousertype(tolua_S,1,0);
01596 #ifndef TOLUA_RELEASE
01597   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_first'",NULL);
01598 #endif
01599   {
01600    Message* tolua_ret = (Message*)  self->msgq_first();
01601    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Message");
01602   }
01603  }
01604  return 1;
01605 #ifndef TOLUA_RELEASE
01606  tolua_lerror:
01607  tolua_error(tolua_S,"#ferror in function 'msgq_first'.",&tolua_err);
01608  return 0;
01609 #endif
01610 }
01611 #endif //#ifndef TOLUA_DISABLE
01612 
01613 /* method: msgq_empty of class  fawkes::LocalizerControlInterface */
01614 #ifndef TOLUA_DISABLE_tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_empty00
01615 static int tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_empty00(lua_State* tolua_S)
01616 {
01617 #ifndef TOLUA_RELEASE
01618  tolua_Error tolua_err;
01619  if (
01620      !tolua_isusertype(tolua_S,1,"fawkes::LocalizerControlInterface",0,&tolua_err) ||
01621      !tolua_isnoobj(tolua_S,2,&tolua_err)
01622  )
01623   goto tolua_lerror;
01624  else
01625 #endif
01626  {
01627   fawkes::LocalizerControlInterface* self = (fawkes::LocalizerControlInterface*)  tolua_tousertype(tolua_S,1,0);
01628 #ifndef TOLUA_RELEASE
01629   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_empty'",NULL);
01630 #endif
01631   {
01632    bool tolua_ret = (bool)  self->msgq_empty();
01633    tolua_pushboolean(tolua_S,(bool)tolua_ret);
01634   }
01635  }
01636  return 1;
01637 #ifndef TOLUA_RELEASE
01638  tolua_lerror:
01639  tolua_error(tolua_S,"#ferror in function 'msgq_empty'.",&tolua_err);
01640  return 0;
01641 #endif
01642 }
01643 #endif //#ifndef TOLUA_DISABLE
01644 
01645 /* Open function */
01646 TOLUA_API int tolua_interfaces_LocalizerControlInterface_open (lua_State* tolua_S)
01647 {
01648  tolua_open(tolua_S);
01649  tolua_reg_types(tolua_S);
01650  tolua_module(tolua_S,NULL,0);
01651  tolua_beginmodule(tolua_S,NULL);
01652   tolua_module(tolua_S,"fawkes",0);
01653   tolua_beginmodule(tolua_S,"fawkes");
01654    tolua_cclass(tolua_S,"LocalizerControlInterface","fawkes::LocalizerControlInterface","Interface",NULL);
01655    tolua_beginmodule(tolua_S,"LocalizerControlInterface");
01656     #ifdef __cplusplus
01657     tolua_cclass(tolua_S,"ResetMessage","fawkes::LocalizerControlInterface::ResetMessage","Message",tolua_collect_fawkes__LocalizerControlInterface__ResetMessage);
01658     #else
01659     tolua_cclass(tolua_S,"ResetMessage","fawkes::LocalizerControlInterface::ResetMessage","Message",NULL);
01660     #endif
01661     tolua_beginmodule(tolua_S,"ResetMessage");
01662      tolua_function(tolua_S,"new",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_new00);
01663      tolua_function(tolua_S,"new_local",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_new00_local);
01664      tolua_function(tolua_S,".call",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_new00_local);
01665      tolua_function(tolua_S,"new",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_new01);
01666      tolua_function(tolua_S,"new_local",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_new01_local);
01667      tolua_function(tolua_S,".call",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_new01_local);
01668      tolua_function(tolua_S,"delete",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_delete00);
01669      tolua_function(tolua_S,"x",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_x00);
01670      tolua_function(tolua_S,"set_x",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_set_x00);
01671      tolua_function(tolua_S,"maxlenof_x",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_maxlenof_x00);
01672      tolua_function(tolua_S,"y",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_y00);
01673      tolua_function(tolua_S,"set_y",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_set_y00);
01674      tolua_function(tolua_S,"maxlenof_y",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_maxlenof_y00);
01675      tolua_function(tolua_S,"ori",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_ori00);
01676      tolua_function(tolua_S,"set_ori",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_set_ori00);
01677      tolua_function(tolua_S,"maxlenof_ori",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_maxlenof_ori00);
01678      tolua_function(tolua_S,"variance",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_variance00);
01679      tolua_function(tolua_S,"set_variance",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_set_variance00);
01680      tolua_function(tolua_S,"maxlenof_variance",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_ResetMessage_maxlenof_variance00);
01681     tolua_endmodule(tolua_S);
01682     tolua_function(tolua_S,"map_name",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_map_name00);
01683     tolua_function(tolua_S,"set_map_name",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_set_map_name00);
01684     tolua_function(tolua_S,"maxlenof_map_name",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_maxlenof_map_name00);
01685     tolua_function(tolua_S,"oftype",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_oftype00);
01686     tolua_function(tolua_S,"datachunk",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_datachunk00);
01687     tolua_function(tolua_S,"datasize",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_datasize00);
01688     tolua_function(tolua_S,"type",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_type00);
01689     tolua_function(tolua_S,"id",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_id00);
01690     tolua_function(tolua_S,"uid",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_uid00);
01691     tolua_function(tolua_S,"serial",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_serial00);
01692     tolua_function(tolua_S,"mem_serial",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_mem_serial00);
01693     tolua_function(tolua_S,".eq",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface__eq00);
01694     tolua_function(tolua_S,"hash",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_hash00);
01695     tolua_function(tolua_S,"hash_size",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_hash_size00);
01696     tolua_function(tolua_S,"hash_printable",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_hash_printable00);
01697     tolua_function(tolua_S,"is_writer",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_is_writer00);
01698     tolua_function(tolua_S,"set_from_chunk",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_set_from_chunk00);
01699     tolua_function(tolua_S,"create_message",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_create_message00);
01700     tolua_function(tolua_S,"read",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_read00);
01701     tolua_function(tolua_S,"write",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_write00);
01702     tolua_function(tolua_S,"has_writer",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_has_writer00);
01703     tolua_function(tolua_S,"num_readers",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_num_readers00);
01704     tolua_function(tolua_S,"msgq_enqueue_copy",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_enqueue_copy00);
01705     tolua_function(tolua_S,"msgq_remove",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_remove00);
01706     tolua_function(tolua_S,"msgq_remove",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_remove01);
01707     tolua_function(tolua_S,"msgq_size",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_size00);
01708     tolua_function(tolua_S,"msgq_flush",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_flush00);
01709     tolua_function(tolua_S,"msgq_lock",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_lock00);
01710     tolua_function(tolua_S,"msgq_try_lock",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_try_lock00);
01711     tolua_function(tolua_S,"msgq_unlock",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_unlock00);
01712     tolua_function(tolua_S,"msgq_pop",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_pop00);
01713     tolua_function(tolua_S,"msgq_first",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_first00);
01714     tolua_function(tolua_S,"msgq_empty",tolua_interfaces_LocalizerControlInterface_fawkes_LocalizerControlInterface_msgq_empty00);
01715    tolua_endmodule(tolua_S);
01716   tolua_endmodule(tolua_S);
01717  tolua_endmodule(tolua_S);
01718  return 1;
01719 }
01720
01721
01722 extern "C" {
01723 #if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501
01724  TOLUA_API int luaopen_interfaces_LocalizerControlInterface (lua_State* tolua_S) {
01725  return tolua_interfaces_LocalizerControlInterface_open(tolua_S);
01726 };
01727 #endif
01728 }
01729
01730