Fawkes API  Fawkes Development Version
OpenRaveInterface_tolua.cpp
00001 /*
00002 ** Lua binding: interfaces_OpenRaveInterface
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_OpenRaveInterface_open (lua_State* tolua_S);
00028 
00029 #include <interfaces/OpenRaveInterface.h>
00030 using namespace fawkes;
00031 
00032 /* function to release collected object via destructor */
00033 #ifdef __cplusplus
00034 
00035 static int tolua_collect_fawkes__OpenRaveInterface__RotateObjectQuatMessage (lua_State* tolua_S)
00036 {
00037  fawkes::OpenRaveInterface::RotateObjectQuatMessage* self = (fawkes::OpenRaveInterface::RotateObjectQuatMessage*) tolua_tousertype(tolua_S,1,0);
00038         Mtolua_delete(self);
00039         return 0;
00040 }
00041 
00042 static int tolua_collect_fawkes__OpenRaveInterface__MoveObjectMessage (lua_State* tolua_S)
00043 {
00044  fawkes::OpenRaveInterface::MoveObjectMessage* self = (fawkes::OpenRaveInterface::MoveObjectMessage*) tolua_tousertype(tolua_S,1,0);
00045         Mtolua_delete(self);
00046         return 0;
00047 }
00048 
00049 static int tolua_collect_fawkes__OpenRaveInterface__AddObjectMessage (lua_State* tolua_S)
00050 {
00051  fawkes::OpenRaveInterface::AddObjectMessage* self = (fawkes::OpenRaveInterface::AddObjectMessage*) tolua_tousertype(tolua_S,1,0);
00052         Mtolua_delete(self);
00053         return 0;
00054 }
00055 
00056 static int tolua_collect_fawkes__OpenRaveInterface__ReleaseAllObjectsMessage (lua_State* tolua_S)
00057 {
00058  fawkes::OpenRaveInterface::ReleaseAllObjectsMessage* self = (fawkes::OpenRaveInterface::ReleaseAllObjectsMessage*) tolua_tousertype(tolua_S,1,0);
00059         Mtolua_delete(self);
00060         return 0;
00061 }
00062 
00063 static int tolua_collect_fawkes__OpenRaveInterface__DeleteObjectMessage (lua_State* tolua_S)
00064 {
00065  fawkes::OpenRaveInterface::DeleteObjectMessage* self = (fawkes::OpenRaveInterface::DeleteObjectMessage*) tolua_tousertype(tolua_S,1,0);
00066         Mtolua_delete(self);
00067         return 0;
00068 }
00069 
00070 static int tolua_collect_fawkes__OpenRaveInterface__RenameObjectMessage (lua_State* tolua_S)
00071 {
00072  fawkes::OpenRaveInterface::RenameObjectMessage* self = (fawkes::OpenRaveInterface::RenameObjectMessage*) tolua_tousertype(tolua_S,1,0);
00073         Mtolua_delete(self);
00074         return 0;
00075 }
00076 
00077 static int tolua_collect_fawkes__OpenRaveInterface__AttachObjectMessage (lua_State* tolua_S)
00078 {
00079  fawkes::OpenRaveInterface::AttachObjectMessage* self = (fawkes::OpenRaveInterface::AttachObjectMessage*) tolua_tousertype(tolua_S,1,0);
00080         Mtolua_delete(self);
00081         return 0;
00082 }
00083 
00084 static int tolua_collect_fawkes__OpenRaveInterface__RotateObjectMessage (lua_State* tolua_S)
00085 {
00086  fawkes::OpenRaveInterface::RotateObjectMessage* self = (fawkes::OpenRaveInterface::RotateObjectMessage*) tolua_tousertype(tolua_S,1,0);
00087         Mtolua_delete(self);
00088         return 0;
00089 }
00090 
00091 static int tolua_collect_fawkes__OpenRaveInterface__ReleaseObjectMessage (lua_State* tolua_S)
00092 {
00093  fawkes::OpenRaveInterface::ReleaseObjectMessage* self = (fawkes::OpenRaveInterface::ReleaseObjectMessage*) tolua_tousertype(tolua_S,1,0);
00094         Mtolua_delete(self);
00095         return 0;
00096 }
00097 #endif
00098 
00099 
00100 /* function to register type */
00101 static void tolua_reg_types (lua_State* tolua_S)
00102 {
00103  tolua_usertype(tolua_S,"fawkes::OpenRaveInterface::RotateObjectQuatMessage");
00104  tolua_usertype(tolua_S,"fawkes::OpenRaveInterface::MoveObjectMessage");
00105  tolua_usertype(tolua_S,"fawkes::OpenRaveInterface::RenameObjectMessage");
00106  tolua_usertype(tolua_S,"fawkes::OpenRaveInterface");
00107  tolua_usertype(tolua_S,"Message");
00108  tolua_usertype(tolua_S,"fawkes::OpenRaveInterface::AddObjectMessage");
00109  tolua_usertype(tolua_S,"fawkes::OpenRaveInterface::ReleaseAllObjectsMessage");
00110  tolua_usertype(tolua_S,"fawkes::OpenRaveInterface::DeleteObjectMessage");
00111  tolua_usertype(tolua_S,"fawkes::OpenRaveInterface::ReleaseObjectMessage");
00112  tolua_usertype(tolua_S,"fawkes::OpenRaveInterface::AttachObjectMessage");
00113  tolua_usertype(tolua_S,"fawkes::OpenRaveInterface::RotateObjectMessage");
00114  tolua_usertype(tolua_S,"Interface");
00115 }
00116 
00117 /* method: new of class  AddObjectMessage */
00118 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AddObjectMessage_new00
00119 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AddObjectMessage_new00(lua_State* tolua_S)
00120 {
00121 #ifndef TOLUA_RELEASE
00122  tolua_Error tolua_err;
00123  if (
00124      !tolua_isusertable(tolua_S,1,"fawkes::OpenRaveInterface::AddObjectMessage",0,&tolua_err) ||
00125      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
00126      !tolua_isstring(tolua_S,3,0,&tolua_err) ||
00127      !tolua_isnoobj(tolua_S,4,&tolua_err)
00128  )
00129   goto tolua_lerror;
00130  else
00131 #endif
00132  {
00133   char* ini_name = ((char*)  tolua_tostring(tolua_S,2,0));
00134   char* ini_path = ((char*)  tolua_tostring(tolua_S,3,0));
00135   {
00136    fawkes::OpenRaveInterface::AddObjectMessage* tolua_ret = (fawkes::OpenRaveInterface::AddObjectMessage*)  Mtolua_new((fawkes::OpenRaveInterface::AddObjectMessage)(ini_name,ini_path));
00137     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::OpenRaveInterface::AddObjectMessage");
00138   }
00139  }
00140  return 1;
00141 #ifndef TOLUA_RELEASE
00142  tolua_lerror:
00143  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00144  return 0;
00145 #endif
00146 }
00147 #endif //#ifndef TOLUA_DISABLE
00148 
00149 /* method: new_local of class  AddObjectMessage */
00150 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AddObjectMessage_new00_local
00151 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AddObjectMessage_new00_local(lua_State* tolua_S)
00152 {
00153 #ifndef TOLUA_RELEASE
00154  tolua_Error tolua_err;
00155  if (
00156      !tolua_isusertable(tolua_S,1,"fawkes::OpenRaveInterface::AddObjectMessage",0,&tolua_err) ||
00157      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
00158      !tolua_isstring(tolua_S,3,0,&tolua_err) ||
00159      !tolua_isnoobj(tolua_S,4,&tolua_err)
00160  )
00161   goto tolua_lerror;
00162  else
00163 #endif
00164  {
00165   char* ini_name = ((char*)  tolua_tostring(tolua_S,2,0));
00166   char* ini_path = ((char*)  tolua_tostring(tolua_S,3,0));
00167   {
00168    fawkes::OpenRaveInterface::AddObjectMessage* tolua_ret = (fawkes::OpenRaveInterface::AddObjectMessage*)  Mtolua_new((fawkes::OpenRaveInterface::AddObjectMessage)(ini_name,ini_path));
00169     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::OpenRaveInterface::AddObjectMessage");
00170     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00171   }
00172  }
00173  return 1;
00174 #ifndef TOLUA_RELEASE
00175  tolua_lerror:
00176  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00177  return 0;
00178 #endif
00179 }
00180 #endif //#ifndef TOLUA_DISABLE
00181 
00182 /* method: new of class  AddObjectMessage */
00183 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AddObjectMessage_new01
00184 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AddObjectMessage_new01(lua_State* tolua_S)
00185 {
00186  tolua_Error tolua_err;
00187  if (
00188      !tolua_isusertable(tolua_S,1,"fawkes::OpenRaveInterface::AddObjectMessage",0,&tolua_err) ||
00189      !tolua_isnoobj(tolua_S,2,&tolua_err)
00190  )
00191   goto tolua_lerror;
00192  else
00193  {
00194   {
00195    fawkes::OpenRaveInterface::AddObjectMessage* tolua_ret = (fawkes::OpenRaveInterface::AddObjectMessage*)  Mtolua_new((fawkes::OpenRaveInterface::AddObjectMessage)());
00196     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::OpenRaveInterface::AddObjectMessage");
00197   }
00198  }
00199  return 1;
00200 tolua_lerror:
00201  return tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AddObjectMessage_new00(tolua_S);
00202 }
00203 #endif //#ifndef TOLUA_DISABLE
00204 
00205 /* method: new_local of class  AddObjectMessage */
00206 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AddObjectMessage_new01_local
00207 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AddObjectMessage_new01_local(lua_State* tolua_S)
00208 {
00209  tolua_Error tolua_err;
00210  if (
00211      !tolua_isusertable(tolua_S,1,"fawkes::OpenRaveInterface::AddObjectMessage",0,&tolua_err) ||
00212      !tolua_isnoobj(tolua_S,2,&tolua_err)
00213  )
00214   goto tolua_lerror;
00215  else
00216  {
00217   {
00218    fawkes::OpenRaveInterface::AddObjectMessage* tolua_ret = (fawkes::OpenRaveInterface::AddObjectMessage*)  Mtolua_new((fawkes::OpenRaveInterface::AddObjectMessage)());
00219     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::OpenRaveInterface::AddObjectMessage");
00220     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00221   }
00222  }
00223  return 1;
00224 tolua_lerror:
00225  return tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AddObjectMessage_new00_local(tolua_S);
00226 }
00227 #endif //#ifndef TOLUA_DISABLE
00228 
00229 /* method: delete of class  AddObjectMessage */
00230 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AddObjectMessage_delete00
00231 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AddObjectMessage_delete00(lua_State* tolua_S)
00232 {
00233 #ifndef TOLUA_RELEASE
00234  tolua_Error tolua_err;
00235  if (
00236      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface::AddObjectMessage",0,&tolua_err) ||
00237      !tolua_isnoobj(tolua_S,2,&tolua_err)
00238  )
00239   goto tolua_lerror;
00240  else
00241 #endif
00242  {
00243   fawkes::OpenRaveInterface::AddObjectMessage* self = (fawkes::OpenRaveInterface::AddObjectMessage*)  tolua_tousertype(tolua_S,1,0);
00244 #ifndef TOLUA_RELEASE
00245   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
00246 #endif
00247   Mtolua_delete(self);
00248  }
00249  return 0;
00250 #ifndef TOLUA_RELEASE
00251  tolua_lerror:
00252  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
00253  return 0;
00254 #endif
00255 }
00256 #endif //#ifndef TOLUA_DISABLE
00257 
00258 /* method: name of class  AddObjectMessage */
00259 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AddObjectMessage_name00
00260 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AddObjectMessage_name00(lua_State* tolua_S)
00261 {
00262 #ifndef TOLUA_RELEASE
00263  tolua_Error tolua_err;
00264  if (
00265      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface::AddObjectMessage",0,&tolua_err) ||
00266      !tolua_isnoobj(tolua_S,2,&tolua_err)
00267  )
00268   goto tolua_lerror;
00269  else
00270 #endif
00271  {
00272   fawkes::OpenRaveInterface::AddObjectMessage* self = (fawkes::OpenRaveInterface::AddObjectMessage*)  tolua_tousertype(tolua_S,1,0);
00273 #ifndef TOLUA_RELEASE
00274   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'name'", NULL);
00275 #endif
00276   {
00277    char* tolua_ret = (char*)  self->name();
00278    tolua_pushstring(tolua_S,(const char*)tolua_ret);
00279   }
00280  }
00281  return 1;
00282 #ifndef TOLUA_RELEASE
00283  tolua_lerror:
00284  tolua_error(tolua_S,"#ferror in function 'name'.",&tolua_err);
00285  return 0;
00286 #endif
00287 }
00288 #endif //#ifndef TOLUA_DISABLE
00289 
00290 /* method: set_name of class  AddObjectMessage */
00291 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AddObjectMessage_set_name00
00292 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AddObjectMessage_set_name00(lua_State* tolua_S)
00293 {
00294 #ifndef TOLUA_RELEASE
00295  tolua_Error tolua_err;
00296  if (
00297      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface::AddObjectMessage",0,&tolua_err) ||
00298      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
00299      !tolua_isnoobj(tolua_S,3,&tolua_err)
00300  )
00301   goto tolua_lerror;
00302  else
00303 #endif
00304  {
00305   fawkes::OpenRaveInterface::AddObjectMessage* self = (fawkes::OpenRaveInterface::AddObjectMessage*)  tolua_tousertype(tolua_S,1,0);
00306   const char* new_name = ((const char*)  tolua_tostring(tolua_S,2,0));
00307 #ifndef TOLUA_RELEASE
00308   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_name'", NULL);
00309 #endif
00310   {
00311    self->set_name(new_name);
00312   }
00313  }
00314  return 0;
00315 #ifndef TOLUA_RELEASE
00316  tolua_lerror:
00317  tolua_error(tolua_S,"#ferror in function 'set_name'.",&tolua_err);
00318  return 0;
00319 #endif
00320 }
00321 #endif //#ifndef TOLUA_DISABLE
00322 
00323 /* method: maxlenof_name of class  AddObjectMessage */
00324 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AddObjectMessage_maxlenof_name00
00325 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AddObjectMessage_maxlenof_name00(lua_State* tolua_S)
00326 {
00327 #ifndef TOLUA_RELEASE
00328  tolua_Error tolua_err;
00329  if (
00330      !tolua_isusertype(tolua_S,1,"const fawkes::OpenRaveInterface::AddObjectMessage",0,&tolua_err) ||
00331      !tolua_isnoobj(tolua_S,2,&tolua_err)
00332  )
00333   goto tolua_lerror;
00334  else
00335 #endif
00336  {
00337   const fawkes::OpenRaveInterface::AddObjectMessage* self = (const fawkes::OpenRaveInterface::AddObjectMessage*)  tolua_tousertype(tolua_S,1,0);
00338 #ifndef TOLUA_RELEASE
00339   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_name'", NULL);
00340 #endif
00341   {
00342    int tolua_ret = (int)  self->maxlenof_name();
00343    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00344   }
00345  }
00346  return 1;
00347 #ifndef TOLUA_RELEASE
00348  tolua_lerror:
00349  tolua_error(tolua_S,"#ferror in function 'maxlenof_name'.",&tolua_err);
00350  return 0;
00351 #endif
00352 }
00353 #endif //#ifndef TOLUA_DISABLE
00354 
00355 /* method: path of class  AddObjectMessage */
00356 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AddObjectMessage_path00
00357 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AddObjectMessage_path00(lua_State* tolua_S)
00358 {
00359 #ifndef TOLUA_RELEASE
00360  tolua_Error tolua_err;
00361  if (
00362      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface::AddObjectMessage",0,&tolua_err) ||
00363      !tolua_isnoobj(tolua_S,2,&tolua_err)
00364  )
00365   goto tolua_lerror;
00366  else
00367 #endif
00368  {
00369   fawkes::OpenRaveInterface::AddObjectMessage* self = (fawkes::OpenRaveInterface::AddObjectMessage*)  tolua_tousertype(tolua_S,1,0);
00370 #ifndef TOLUA_RELEASE
00371   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'path'", NULL);
00372 #endif
00373   {
00374    char* tolua_ret = (char*)  self->path();
00375    tolua_pushstring(tolua_S,(const char*)tolua_ret);
00376   }
00377  }
00378  return 1;
00379 #ifndef TOLUA_RELEASE
00380  tolua_lerror:
00381  tolua_error(tolua_S,"#ferror in function 'path'.",&tolua_err);
00382  return 0;
00383 #endif
00384 }
00385 #endif //#ifndef TOLUA_DISABLE
00386 
00387 /* method: set_path of class  AddObjectMessage */
00388 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AddObjectMessage_set_path00
00389 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AddObjectMessage_set_path00(lua_State* tolua_S)
00390 {
00391 #ifndef TOLUA_RELEASE
00392  tolua_Error tolua_err;
00393  if (
00394      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface::AddObjectMessage",0,&tolua_err) ||
00395      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
00396      !tolua_isnoobj(tolua_S,3,&tolua_err)
00397  )
00398   goto tolua_lerror;
00399  else
00400 #endif
00401  {
00402   fawkes::OpenRaveInterface::AddObjectMessage* self = (fawkes::OpenRaveInterface::AddObjectMessage*)  tolua_tousertype(tolua_S,1,0);
00403   const char* new_path = ((const char*)  tolua_tostring(tolua_S,2,0));
00404 #ifndef TOLUA_RELEASE
00405   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_path'", NULL);
00406 #endif
00407   {
00408    self->set_path(new_path);
00409   }
00410  }
00411  return 0;
00412 #ifndef TOLUA_RELEASE
00413  tolua_lerror:
00414  tolua_error(tolua_S,"#ferror in function 'set_path'.",&tolua_err);
00415  return 0;
00416 #endif
00417 }
00418 #endif //#ifndef TOLUA_DISABLE
00419 
00420 /* method: maxlenof_path of class  AddObjectMessage */
00421 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AddObjectMessage_maxlenof_path00
00422 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AddObjectMessage_maxlenof_path00(lua_State* tolua_S)
00423 {
00424 #ifndef TOLUA_RELEASE
00425  tolua_Error tolua_err;
00426  if (
00427      !tolua_isusertype(tolua_S,1,"const fawkes::OpenRaveInterface::AddObjectMessage",0,&tolua_err) ||
00428      !tolua_isnoobj(tolua_S,2,&tolua_err)
00429  )
00430   goto tolua_lerror;
00431  else
00432 #endif
00433  {
00434   const fawkes::OpenRaveInterface::AddObjectMessage* self = (const fawkes::OpenRaveInterface::AddObjectMessage*)  tolua_tousertype(tolua_S,1,0);
00435 #ifndef TOLUA_RELEASE
00436   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_path'", NULL);
00437 #endif
00438   {
00439    int tolua_ret = (int)  self->maxlenof_path();
00440    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00441   }
00442  }
00443  return 1;
00444 #ifndef TOLUA_RELEASE
00445  tolua_lerror:
00446  tolua_error(tolua_S,"#ferror in function 'maxlenof_path'.",&tolua_err);
00447  return 0;
00448 #endif
00449 }
00450 #endif //#ifndef TOLUA_DISABLE
00451 
00452 /* method: new of class  DeleteObjectMessage */
00453 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_DeleteObjectMessage_new00
00454 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_DeleteObjectMessage_new00(lua_State* tolua_S)
00455 {
00456 #ifndef TOLUA_RELEASE
00457  tolua_Error tolua_err;
00458  if (
00459      !tolua_isusertable(tolua_S,1,"fawkes::OpenRaveInterface::DeleteObjectMessage",0,&tolua_err) ||
00460      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
00461      !tolua_isnoobj(tolua_S,3,&tolua_err)
00462  )
00463   goto tolua_lerror;
00464  else
00465 #endif
00466  {
00467   char* ini_name = ((char*)  tolua_tostring(tolua_S,2,0));
00468   {
00469    fawkes::OpenRaveInterface::DeleteObjectMessage* tolua_ret = (fawkes::OpenRaveInterface::DeleteObjectMessage*)  Mtolua_new((fawkes::OpenRaveInterface::DeleteObjectMessage)(ini_name));
00470     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::OpenRaveInterface::DeleteObjectMessage");
00471   }
00472  }
00473  return 1;
00474 #ifndef TOLUA_RELEASE
00475  tolua_lerror:
00476  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00477  return 0;
00478 #endif
00479 }
00480 #endif //#ifndef TOLUA_DISABLE
00481 
00482 /* method: new_local of class  DeleteObjectMessage */
00483 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_DeleteObjectMessage_new00_local
00484 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_DeleteObjectMessage_new00_local(lua_State* tolua_S)
00485 {
00486 #ifndef TOLUA_RELEASE
00487  tolua_Error tolua_err;
00488  if (
00489      !tolua_isusertable(tolua_S,1,"fawkes::OpenRaveInterface::DeleteObjectMessage",0,&tolua_err) ||
00490      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
00491      !tolua_isnoobj(tolua_S,3,&tolua_err)
00492  )
00493   goto tolua_lerror;
00494  else
00495 #endif
00496  {
00497   char* ini_name = ((char*)  tolua_tostring(tolua_S,2,0));
00498   {
00499    fawkes::OpenRaveInterface::DeleteObjectMessage* tolua_ret = (fawkes::OpenRaveInterface::DeleteObjectMessage*)  Mtolua_new((fawkes::OpenRaveInterface::DeleteObjectMessage)(ini_name));
00500     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::OpenRaveInterface::DeleteObjectMessage");
00501     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00502   }
00503  }
00504  return 1;
00505 #ifndef TOLUA_RELEASE
00506  tolua_lerror:
00507  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00508  return 0;
00509 #endif
00510 }
00511 #endif //#ifndef TOLUA_DISABLE
00512 
00513 /* method: new of class  DeleteObjectMessage */
00514 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_DeleteObjectMessage_new01
00515 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_DeleteObjectMessage_new01(lua_State* tolua_S)
00516 {
00517  tolua_Error tolua_err;
00518  if (
00519      !tolua_isusertable(tolua_S,1,"fawkes::OpenRaveInterface::DeleteObjectMessage",0,&tolua_err) ||
00520      !tolua_isnoobj(tolua_S,2,&tolua_err)
00521  )
00522   goto tolua_lerror;
00523  else
00524  {
00525   {
00526    fawkes::OpenRaveInterface::DeleteObjectMessage* tolua_ret = (fawkes::OpenRaveInterface::DeleteObjectMessage*)  Mtolua_new((fawkes::OpenRaveInterface::DeleteObjectMessage)());
00527     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::OpenRaveInterface::DeleteObjectMessage");
00528   }
00529  }
00530  return 1;
00531 tolua_lerror:
00532  return tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_DeleteObjectMessage_new00(tolua_S);
00533 }
00534 #endif //#ifndef TOLUA_DISABLE
00535 
00536 /* method: new_local of class  DeleteObjectMessage */
00537 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_DeleteObjectMessage_new01_local
00538 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_DeleteObjectMessage_new01_local(lua_State* tolua_S)
00539 {
00540  tolua_Error tolua_err;
00541  if (
00542      !tolua_isusertable(tolua_S,1,"fawkes::OpenRaveInterface::DeleteObjectMessage",0,&tolua_err) ||
00543      !tolua_isnoobj(tolua_S,2,&tolua_err)
00544  )
00545   goto tolua_lerror;
00546  else
00547  {
00548   {
00549    fawkes::OpenRaveInterface::DeleteObjectMessage* tolua_ret = (fawkes::OpenRaveInterface::DeleteObjectMessage*)  Mtolua_new((fawkes::OpenRaveInterface::DeleteObjectMessage)());
00550     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::OpenRaveInterface::DeleteObjectMessage");
00551     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00552   }
00553  }
00554  return 1;
00555 tolua_lerror:
00556  return tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_DeleteObjectMessage_new00_local(tolua_S);
00557 }
00558 #endif //#ifndef TOLUA_DISABLE
00559 
00560 /* method: delete of class  DeleteObjectMessage */
00561 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_DeleteObjectMessage_delete00
00562 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_DeleteObjectMessage_delete00(lua_State* tolua_S)
00563 {
00564 #ifndef TOLUA_RELEASE
00565  tolua_Error tolua_err;
00566  if (
00567      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface::DeleteObjectMessage",0,&tolua_err) ||
00568      !tolua_isnoobj(tolua_S,2,&tolua_err)
00569  )
00570   goto tolua_lerror;
00571  else
00572 #endif
00573  {
00574   fawkes::OpenRaveInterface::DeleteObjectMessage* self = (fawkes::OpenRaveInterface::DeleteObjectMessage*)  tolua_tousertype(tolua_S,1,0);
00575 #ifndef TOLUA_RELEASE
00576   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
00577 #endif
00578   Mtolua_delete(self);
00579  }
00580  return 0;
00581 #ifndef TOLUA_RELEASE
00582  tolua_lerror:
00583  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
00584  return 0;
00585 #endif
00586 }
00587 #endif //#ifndef TOLUA_DISABLE
00588 
00589 /* method: name of class  DeleteObjectMessage */
00590 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_DeleteObjectMessage_name00
00591 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_DeleteObjectMessage_name00(lua_State* tolua_S)
00592 {
00593 #ifndef TOLUA_RELEASE
00594  tolua_Error tolua_err;
00595  if (
00596      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface::DeleteObjectMessage",0,&tolua_err) ||
00597      !tolua_isnoobj(tolua_S,2,&tolua_err)
00598  )
00599   goto tolua_lerror;
00600  else
00601 #endif
00602  {
00603   fawkes::OpenRaveInterface::DeleteObjectMessage* self = (fawkes::OpenRaveInterface::DeleteObjectMessage*)  tolua_tousertype(tolua_S,1,0);
00604 #ifndef TOLUA_RELEASE
00605   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'name'", NULL);
00606 #endif
00607   {
00608    char* tolua_ret = (char*)  self->name();
00609    tolua_pushstring(tolua_S,(const char*)tolua_ret);
00610   }
00611  }
00612  return 1;
00613 #ifndef TOLUA_RELEASE
00614  tolua_lerror:
00615  tolua_error(tolua_S,"#ferror in function 'name'.",&tolua_err);
00616  return 0;
00617 #endif
00618 }
00619 #endif //#ifndef TOLUA_DISABLE
00620 
00621 /* method: set_name of class  DeleteObjectMessage */
00622 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_DeleteObjectMessage_set_name00
00623 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_DeleteObjectMessage_set_name00(lua_State* tolua_S)
00624 {
00625 #ifndef TOLUA_RELEASE
00626  tolua_Error tolua_err;
00627  if (
00628      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface::DeleteObjectMessage",0,&tolua_err) ||
00629      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
00630      !tolua_isnoobj(tolua_S,3,&tolua_err)
00631  )
00632   goto tolua_lerror;
00633  else
00634 #endif
00635  {
00636   fawkes::OpenRaveInterface::DeleteObjectMessage* self = (fawkes::OpenRaveInterface::DeleteObjectMessage*)  tolua_tousertype(tolua_S,1,0);
00637   const char* new_name = ((const char*)  tolua_tostring(tolua_S,2,0));
00638 #ifndef TOLUA_RELEASE
00639   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_name'", NULL);
00640 #endif
00641   {
00642    self->set_name(new_name);
00643   }
00644  }
00645  return 0;
00646 #ifndef TOLUA_RELEASE
00647  tolua_lerror:
00648  tolua_error(tolua_S,"#ferror in function 'set_name'.",&tolua_err);
00649  return 0;
00650 #endif
00651 }
00652 #endif //#ifndef TOLUA_DISABLE
00653 
00654 /* method: maxlenof_name of class  DeleteObjectMessage */
00655 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_DeleteObjectMessage_maxlenof_name00
00656 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_DeleteObjectMessage_maxlenof_name00(lua_State* tolua_S)
00657 {
00658 #ifndef TOLUA_RELEASE
00659  tolua_Error tolua_err;
00660  if (
00661      !tolua_isusertype(tolua_S,1,"const fawkes::OpenRaveInterface::DeleteObjectMessage",0,&tolua_err) ||
00662      !tolua_isnoobj(tolua_S,2,&tolua_err)
00663  )
00664   goto tolua_lerror;
00665  else
00666 #endif
00667  {
00668   const fawkes::OpenRaveInterface::DeleteObjectMessage* self = (const fawkes::OpenRaveInterface::DeleteObjectMessage*)  tolua_tousertype(tolua_S,1,0);
00669 #ifndef TOLUA_RELEASE
00670   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_name'", NULL);
00671 #endif
00672   {
00673    int tolua_ret = (int)  self->maxlenof_name();
00674    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00675   }
00676  }
00677  return 1;
00678 #ifndef TOLUA_RELEASE
00679  tolua_lerror:
00680  tolua_error(tolua_S,"#ferror in function 'maxlenof_name'.",&tolua_err);
00681  return 0;
00682 #endif
00683 }
00684 #endif //#ifndef TOLUA_DISABLE
00685 
00686 /* method: new of class  AttachObjectMessage */
00687 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AttachObjectMessage_new00
00688 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AttachObjectMessage_new00(lua_State* tolua_S)
00689 {
00690 #ifndef TOLUA_RELEASE
00691  tolua_Error tolua_err;
00692  if (
00693      !tolua_isusertable(tolua_S,1,"fawkes::OpenRaveInterface::AttachObjectMessage",0,&tolua_err) ||
00694      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
00695      !tolua_isnoobj(tolua_S,3,&tolua_err)
00696  )
00697   goto tolua_lerror;
00698  else
00699 #endif
00700  {
00701   char* ini_name = ((char*)  tolua_tostring(tolua_S,2,0));
00702   {
00703    fawkes::OpenRaveInterface::AttachObjectMessage* tolua_ret = (fawkes::OpenRaveInterface::AttachObjectMessage*)  Mtolua_new((fawkes::OpenRaveInterface::AttachObjectMessage)(ini_name));
00704     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::OpenRaveInterface::AttachObjectMessage");
00705   }
00706  }
00707  return 1;
00708 #ifndef TOLUA_RELEASE
00709  tolua_lerror:
00710  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00711  return 0;
00712 #endif
00713 }
00714 #endif //#ifndef TOLUA_DISABLE
00715 
00716 /* method: new_local of class  AttachObjectMessage */
00717 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AttachObjectMessage_new00_local
00718 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AttachObjectMessage_new00_local(lua_State* tolua_S)
00719 {
00720 #ifndef TOLUA_RELEASE
00721  tolua_Error tolua_err;
00722  if (
00723      !tolua_isusertable(tolua_S,1,"fawkes::OpenRaveInterface::AttachObjectMessage",0,&tolua_err) ||
00724      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
00725      !tolua_isnoobj(tolua_S,3,&tolua_err)
00726  )
00727   goto tolua_lerror;
00728  else
00729 #endif
00730  {
00731   char* ini_name = ((char*)  tolua_tostring(tolua_S,2,0));
00732   {
00733    fawkes::OpenRaveInterface::AttachObjectMessage* tolua_ret = (fawkes::OpenRaveInterface::AttachObjectMessage*)  Mtolua_new((fawkes::OpenRaveInterface::AttachObjectMessage)(ini_name));
00734     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::OpenRaveInterface::AttachObjectMessage");
00735     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00736   }
00737  }
00738  return 1;
00739 #ifndef TOLUA_RELEASE
00740  tolua_lerror:
00741  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00742  return 0;
00743 #endif
00744 }
00745 #endif //#ifndef TOLUA_DISABLE
00746 
00747 /* method: new of class  AttachObjectMessage */
00748 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AttachObjectMessage_new01
00749 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AttachObjectMessage_new01(lua_State* tolua_S)
00750 {
00751  tolua_Error tolua_err;
00752  if (
00753      !tolua_isusertable(tolua_S,1,"fawkes::OpenRaveInterface::AttachObjectMessage",0,&tolua_err) ||
00754      !tolua_isnoobj(tolua_S,2,&tolua_err)
00755  )
00756   goto tolua_lerror;
00757  else
00758  {
00759   {
00760    fawkes::OpenRaveInterface::AttachObjectMessage* tolua_ret = (fawkes::OpenRaveInterface::AttachObjectMessage*)  Mtolua_new((fawkes::OpenRaveInterface::AttachObjectMessage)());
00761     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::OpenRaveInterface::AttachObjectMessage");
00762   }
00763  }
00764  return 1;
00765 tolua_lerror:
00766  return tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AttachObjectMessage_new00(tolua_S);
00767 }
00768 #endif //#ifndef TOLUA_DISABLE
00769 
00770 /* method: new_local of class  AttachObjectMessage */
00771 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AttachObjectMessage_new01_local
00772 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AttachObjectMessage_new01_local(lua_State* tolua_S)
00773 {
00774  tolua_Error tolua_err;
00775  if (
00776      !tolua_isusertable(tolua_S,1,"fawkes::OpenRaveInterface::AttachObjectMessage",0,&tolua_err) ||
00777      !tolua_isnoobj(tolua_S,2,&tolua_err)
00778  )
00779   goto tolua_lerror;
00780  else
00781  {
00782   {
00783    fawkes::OpenRaveInterface::AttachObjectMessage* tolua_ret = (fawkes::OpenRaveInterface::AttachObjectMessage*)  Mtolua_new((fawkes::OpenRaveInterface::AttachObjectMessage)());
00784     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::OpenRaveInterface::AttachObjectMessage");
00785     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00786   }
00787  }
00788  return 1;
00789 tolua_lerror:
00790  return tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AttachObjectMessage_new00_local(tolua_S);
00791 }
00792 #endif //#ifndef TOLUA_DISABLE
00793 
00794 /* method: delete of class  AttachObjectMessage */
00795 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AttachObjectMessage_delete00
00796 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AttachObjectMessage_delete00(lua_State* tolua_S)
00797 {
00798 #ifndef TOLUA_RELEASE
00799  tolua_Error tolua_err;
00800  if (
00801      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface::AttachObjectMessage",0,&tolua_err) ||
00802      !tolua_isnoobj(tolua_S,2,&tolua_err)
00803  )
00804   goto tolua_lerror;
00805  else
00806 #endif
00807  {
00808   fawkes::OpenRaveInterface::AttachObjectMessage* self = (fawkes::OpenRaveInterface::AttachObjectMessage*)  tolua_tousertype(tolua_S,1,0);
00809 #ifndef TOLUA_RELEASE
00810   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
00811 #endif
00812   Mtolua_delete(self);
00813  }
00814  return 0;
00815 #ifndef TOLUA_RELEASE
00816  tolua_lerror:
00817  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
00818  return 0;
00819 #endif
00820 }
00821 #endif //#ifndef TOLUA_DISABLE
00822 
00823 /* method: name of class  AttachObjectMessage */
00824 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AttachObjectMessage_name00
00825 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AttachObjectMessage_name00(lua_State* tolua_S)
00826 {
00827 #ifndef TOLUA_RELEASE
00828  tolua_Error tolua_err;
00829  if (
00830      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface::AttachObjectMessage",0,&tolua_err) ||
00831      !tolua_isnoobj(tolua_S,2,&tolua_err)
00832  )
00833   goto tolua_lerror;
00834  else
00835 #endif
00836  {
00837   fawkes::OpenRaveInterface::AttachObjectMessage* self = (fawkes::OpenRaveInterface::AttachObjectMessage*)  tolua_tousertype(tolua_S,1,0);
00838 #ifndef TOLUA_RELEASE
00839   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'name'", NULL);
00840 #endif
00841   {
00842    char* tolua_ret = (char*)  self->name();
00843    tolua_pushstring(tolua_S,(const char*)tolua_ret);
00844   }
00845  }
00846  return 1;
00847 #ifndef TOLUA_RELEASE
00848  tolua_lerror:
00849  tolua_error(tolua_S,"#ferror in function 'name'.",&tolua_err);
00850  return 0;
00851 #endif
00852 }
00853 #endif //#ifndef TOLUA_DISABLE
00854 
00855 /* method: set_name of class  AttachObjectMessage */
00856 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AttachObjectMessage_set_name00
00857 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AttachObjectMessage_set_name00(lua_State* tolua_S)
00858 {
00859 #ifndef TOLUA_RELEASE
00860  tolua_Error tolua_err;
00861  if (
00862      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface::AttachObjectMessage",0,&tolua_err) ||
00863      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
00864      !tolua_isnoobj(tolua_S,3,&tolua_err)
00865  )
00866   goto tolua_lerror;
00867  else
00868 #endif
00869  {
00870   fawkes::OpenRaveInterface::AttachObjectMessage* self = (fawkes::OpenRaveInterface::AttachObjectMessage*)  tolua_tousertype(tolua_S,1,0);
00871   const char* new_name = ((const char*)  tolua_tostring(tolua_S,2,0));
00872 #ifndef TOLUA_RELEASE
00873   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_name'", NULL);
00874 #endif
00875   {
00876    self->set_name(new_name);
00877   }
00878  }
00879  return 0;
00880 #ifndef TOLUA_RELEASE
00881  tolua_lerror:
00882  tolua_error(tolua_S,"#ferror in function 'set_name'.",&tolua_err);
00883  return 0;
00884 #endif
00885 }
00886 #endif //#ifndef TOLUA_DISABLE
00887 
00888 /* method: maxlenof_name of class  AttachObjectMessage */
00889 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AttachObjectMessage_maxlenof_name00
00890 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AttachObjectMessage_maxlenof_name00(lua_State* tolua_S)
00891 {
00892 #ifndef TOLUA_RELEASE
00893  tolua_Error tolua_err;
00894  if (
00895      !tolua_isusertype(tolua_S,1,"const fawkes::OpenRaveInterface::AttachObjectMessage",0,&tolua_err) ||
00896      !tolua_isnoobj(tolua_S,2,&tolua_err)
00897  )
00898   goto tolua_lerror;
00899  else
00900 #endif
00901  {
00902   const fawkes::OpenRaveInterface::AttachObjectMessage* self = (const fawkes::OpenRaveInterface::AttachObjectMessage*)  tolua_tousertype(tolua_S,1,0);
00903 #ifndef TOLUA_RELEASE
00904   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_name'", NULL);
00905 #endif
00906   {
00907    int tolua_ret = (int)  self->maxlenof_name();
00908    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00909   }
00910  }
00911  return 1;
00912 #ifndef TOLUA_RELEASE
00913  tolua_lerror:
00914  tolua_error(tolua_S,"#ferror in function 'maxlenof_name'.",&tolua_err);
00915  return 0;
00916 #endif
00917 }
00918 #endif //#ifndef TOLUA_DISABLE
00919 
00920 /* method: new of class  ReleaseObjectMessage */
00921 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_ReleaseObjectMessage_new00
00922 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_ReleaseObjectMessage_new00(lua_State* tolua_S)
00923 {
00924 #ifndef TOLUA_RELEASE
00925  tolua_Error tolua_err;
00926  if (
00927      !tolua_isusertable(tolua_S,1,"fawkes::OpenRaveInterface::ReleaseObjectMessage",0,&tolua_err) ||
00928      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
00929      !tolua_isnoobj(tolua_S,3,&tolua_err)
00930  )
00931   goto tolua_lerror;
00932  else
00933 #endif
00934  {
00935   char* ini_name = ((char*)  tolua_tostring(tolua_S,2,0));
00936   {
00937    fawkes::OpenRaveInterface::ReleaseObjectMessage* tolua_ret = (fawkes::OpenRaveInterface::ReleaseObjectMessage*)  Mtolua_new((fawkes::OpenRaveInterface::ReleaseObjectMessage)(ini_name));
00938     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::OpenRaveInterface::ReleaseObjectMessage");
00939   }
00940  }
00941  return 1;
00942 #ifndef TOLUA_RELEASE
00943  tolua_lerror:
00944  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00945  return 0;
00946 #endif
00947 }
00948 #endif //#ifndef TOLUA_DISABLE
00949 
00950 /* method: new_local of class  ReleaseObjectMessage */
00951 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_ReleaseObjectMessage_new00_local
00952 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_ReleaseObjectMessage_new00_local(lua_State* tolua_S)
00953 {
00954 #ifndef TOLUA_RELEASE
00955  tolua_Error tolua_err;
00956  if (
00957      !tolua_isusertable(tolua_S,1,"fawkes::OpenRaveInterface::ReleaseObjectMessage",0,&tolua_err) ||
00958      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
00959      !tolua_isnoobj(tolua_S,3,&tolua_err)
00960  )
00961   goto tolua_lerror;
00962  else
00963 #endif
00964  {
00965   char* ini_name = ((char*)  tolua_tostring(tolua_S,2,0));
00966   {
00967    fawkes::OpenRaveInterface::ReleaseObjectMessage* tolua_ret = (fawkes::OpenRaveInterface::ReleaseObjectMessage*)  Mtolua_new((fawkes::OpenRaveInterface::ReleaseObjectMessage)(ini_name));
00968     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::OpenRaveInterface::ReleaseObjectMessage");
00969     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00970   }
00971  }
00972  return 1;
00973 #ifndef TOLUA_RELEASE
00974  tolua_lerror:
00975  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00976  return 0;
00977 #endif
00978 }
00979 #endif //#ifndef TOLUA_DISABLE
00980 
00981 /* method: new of class  ReleaseObjectMessage */
00982 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_ReleaseObjectMessage_new01
00983 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_ReleaseObjectMessage_new01(lua_State* tolua_S)
00984 {
00985  tolua_Error tolua_err;
00986  if (
00987      !tolua_isusertable(tolua_S,1,"fawkes::OpenRaveInterface::ReleaseObjectMessage",0,&tolua_err) ||
00988      !tolua_isnoobj(tolua_S,2,&tolua_err)
00989  )
00990   goto tolua_lerror;
00991  else
00992  {
00993   {
00994    fawkes::OpenRaveInterface::ReleaseObjectMessage* tolua_ret = (fawkes::OpenRaveInterface::ReleaseObjectMessage*)  Mtolua_new((fawkes::OpenRaveInterface::ReleaseObjectMessage)());
00995     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::OpenRaveInterface::ReleaseObjectMessage");
00996   }
00997  }
00998  return 1;
00999 tolua_lerror:
01000  return tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_ReleaseObjectMessage_new00(tolua_S);
01001 }
01002 #endif //#ifndef TOLUA_DISABLE
01003 
01004 /* method: new_local of class  ReleaseObjectMessage */
01005 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_ReleaseObjectMessage_new01_local
01006 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_ReleaseObjectMessage_new01_local(lua_State* tolua_S)
01007 {
01008  tolua_Error tolua_err;
01009  if (
01010      !tolua_isusertable(tolua_S,1,"fawkes::OpenRaveInterface::ReleaseObjectMessage",0,&tolua_err) ||
01011      !tolua_isnoobj(tolua_S,2,&tolua_err)
01012  )
01013   goto tolua_lerror;
01014  else
01015  {
01016   {
01017    fawkes::OpenRaveInterface::ReleaseObjectMessage* tolua_ret = (fawkes::OpenRaveInterface::ReleaseObjectMessage*)  Mtolua_new((fawkes::OpenRaveInterface::ReleaseObjectMessage)());
01018     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::OpenRaveInterface::ReleaseObjectMessage");
01019     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01020   }
01021  }
01022  return 1;
01023 tolua_lerror:
01024  return tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_ReleaseObjectMessage_new00_local(tolua_S);
01025 }
01026 #endif //#ifndef TOLUA_DISABLE
01027 
01028 /* method: delete of class  ReleaseObjectMessage */
01029 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_ReleaseObjectMessage_delete00
01030 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_ReleaseObjectMessage_delete00(lua_State* tolua_S)
01031 {
01032 #ifndef TOLUA_RELEASE
01033  tolua_Error tolua_err;
01034  if (
01035      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface::ReleaseObjectMessage",0,&tolua_err) ||
01036      !tolua_isnoobj(tolua_S,2,&tolua_err)
01037  )
01038   goto tolua_lerror;
01039  else
01040 #endif
01041  {
01042   fawkes::OpenRaveInterface::ReleaseObjectMessage* self = (fawkes::OpenRaveInterface::ReleaseObjectMessage*)  tolua_tousertype(tolua_S,1,0);
01043 #ifndef TOLUA_RELEASE
01044   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
01045 #endif
01046   Mtolua_delete(self);
01047  }
01048  return 0;
01049 #ifndef TOLUA_RELEASE
01050  tolua_lerror:
01051  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
01052  return 0;
01053 #endif
01054 }
01055 #endif //#ifndef TOLUA_DISABLE
01056 
01057 /* method: name of class  ReleaseObjectMessage */
01058 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_ReleaseObjectMessage_name00
01059 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_ReleaseObjectMessage_name00(lua_State* tolua_S)
01060 {
01061 #ifndef TOLUA_RELEASE
01062  tolua_Error tolua_err;
01063  if (
01064      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface::ReleaseObjectMessage",0,&tolua_err) ||
01065      !tolua_isnoobj(tolua_S,2,&tolua_err)
01066  )
01067   goto tolua_lerror;
01068  else
01069 #endif
01070  {
01071   fawkes::OpenRaveInterface::ReleaseObjectMessage* self = (fawkes::OpenRaveInterface::ReleaseObjectMessage*)  tolua_tousertype(tolua_S,1,0);
01072 #ifndef TOLUA_RELEASE
01073   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'name'", NULL);
01074 #endif
01075   {
01076    char* tolua_ret = (char*)  self->name();
01077    tolua_pushstring(tolua_S,(const char*)tolua_ret);
01078   }
01079  }
01080  return 1;
01081 #ifndef TOLUA_RELEASE
01082  tolua_lerror:
01083  tolua_error(tolua_S,"#ferror in function 'name'.",&tolua_err);
01084  return 0;
01085 #endif
01086 }
01087 #endif //#ifndef TOLUA_DISABLE
01088 
01089 /* method: set_name of class  ReleaseObjectMessage */
01090 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_ReleaseObjectMessage_set_name00
01091 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_ReleaseObjectMessage_set_name00(lua_State* tolua_S)
01092 {
01093 #ifndef TOLUA_RELEASE
01094  tolua_Error tolua_err;
01095  if (
01096      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface::ReleaseObjectMessage",0,&tolua_err) ||
01097      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
01098      !tolua_isnoobj(tolua_S,3,&tolua_err)
01099  )
01100   goto tolua_lerror;
01101  else
01102 #endif
01103  {
01104   fawkes::OpenRaveInterface::ReleaseObjectMessage* self = (fawkes::OpenRaveInterface::ReleaseObjectMessage*)  tolua_tousertype(tolua_S,1,0);
01105   const char* new_name = ((const char*)  tolua_tostring(tolua_S,2,0));
01106 #ifndef TOLUA_RELEASE
01107   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_name'", NULL);
01108 #endif
01109   {
01110    self->set_name(new_name);
01111   }
01112  }
01113  return 0;
01114 #ifndef TOLUA_RELEASE
01115  tolua_lerror:
01116  tolua_error(tolua_S,"#ferror in function 'set_name'.",&tolua_err);
01117  return 0;
01118 #endif
01119 }
01120 #endif //#ifndef TOLUA_DISABLE
01121 
01122 /* method: maxlenof_name of class  ReleaseObjectMessage */
01123 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_ReleaseObjectMessage_maxlenof_name00
01124 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_ReleaseObjectMessage_maxlenof_name00(lua_State* tolua_S)
01125 {
01126 #ifndef TOLUA_RELEASE
01127  tolua_Error tolua_err;
01128  if (
01129      !tolua_isusertype(tolua_S,1,"const fawkes::OpenRaveInterface::ReleaseObjectMessage",0,&tolua_err) ||
01130      !tolua_isnoobj(tolua_S,2,&tolua_err)
01131  )
01132   goto tolua_lerror;
01133  else
01134 #endif
01135  {
01136   const fawkes::OpenRaveInterface::ReleaseObjectMessage* self = (const fawkes::OpenRaveInterface::ReleaseObjectMessage*)  tolua_tousertype(tolua_S,1,0);
01137 #ifndef TOLUA_RELEASE
01138   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_name'", NULL);
01139 #endif
01140   {
01141    int tolua_ret = (int)  self->maxlenof_name();
01142    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01143   }
01144  }
01145  return 1;
01146 #ifndef TOLUA_RELEASE
01147  tolua_lerror:
01148  tolua_error(tolua_S,"#ferror in function 'maxlenof_name'.",&tolua_err);
01149  return 0;
01150 #endif
01151 }
01152 #endif //#ifndef TOLUA_DISABLE
01153 
01154 /* method: new of class  ReleaseAllObjectsMessage */
01155 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_ReleaseAllObjectsMessage_new00
01156 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_ReleaseAllObjectsMessage_new00(lua_State* tolua_S)
01157 {
01158 #ifndef TOLUA_RELEASE
01159  tolua_Error tolua_err;
01160  if (
01161      !tolua_isusertable(tolua_S,1,"fawkes::OpenRaveInterface::ReleaseAllObjectsMessage",0,&tolua_err) ||
01162      !tolua_isnoobj(tolua_S,2,&tolua_err)
01163  )
01164   goto tolua_lerror;
01165  else
01166 #endif
01167  {
01168   {
01169    fawkes::OpenRaveInterface::ReleaseAllObjectsMessage* tolua_ret = (fawkes::OpenRaveInterface::ReleaseAllObjectsMessage*)  Mtolua_new((fawkes::OpenRaveInterface::ReleaseAllObjectsMessage)());
01170     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::OpenRaveInterface::ReleaseAllObjectsMessage");
01171   }
01172  }
01173  return 1;
01174 #ifndef TOLUA_RELEASE
01175  tolua_lerror:
01176  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
01177  return 0;
01178 #endif
01179 }
01180 #endif //#ifndef TOLUA_DISABLE
01181 
01182 /* method: new_local of class  ReleaseAllObjectsMessage */
01183 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_ReleaseAllObjectsMessage_new00_local
01184 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_ReleaseAllObjectsMessage_new00_local(lua_State* tolua_S)
01185 {
01186 #ifndef TOLUA_RELEASE
01187  tolua_Error tolua_err;
01188  if (
01189      !tolua_isusertable(tolua_S,1,"fawkes::OpenRaveInterface::ReleaseAllObjectsMessage",0,&tolua_err) ||
01190      !tolua_isnoobj(tolua_S,2,&tolua_err)
01191  )
01192   goto tolua_lerror;
01193  else
01194 #endif
01195  {
01196   {
01197    fawkes::OpenRaveInterface::ReleaseAllObjectsMessage* tolua_ret = (fawkes::OpenRaveInterface::ReleaseAllObjectsMessage*)  Mtolua_new((fawkes::OpenRaveInterface::ReleaseAllObjectsMessage)());
01198     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::OpenRaveInterface::ReleaseAllObjectsMessage");
01199     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01200   }
01201  }
01202  return 1;
01203 #ifndef TOLUA_RELEASE
01204  tolua_lerror:
01205  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
01206  return 0;
01207 #endif
01208 }
01209 #endif //#ifndef TOLUA_DISABLE
01210 
01211 /* method: delete of class  ReleaseAllObjectsMessage */
01212 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_ReleaseAllObjectsMessage_delete00
01213 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_ReleaseAllObjectsMessage_delete00(lua_State* tolua_S)
01214 {
01215 #ifndef TOLUA_RELEASE
01216  tolua_Error tolua_err;
01217  if (
01218      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface::ReleaseAllObjectsMessage",0,&tolua_err) ||
01219      !tolua_isnoobj(tolua_S,2,&tolua_err)
01220  )
01221   goto tolua_lerror;
01222  else
01223 #endif
01224  {
01225   fawkes::OpenRaveInterface::ReleaseAllObjectsMessage* self = (fawkes::OpenRaveInterface::ReleaseAllObjectsMessage*)  tolua_tousertype(tolua_S,1,0);
01226 #ifndef TOLUA_RELEASE
01227   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
01228 #endif
01229   Mtolua_delete(self);
01230  }
01231  return 0;
01232 #ifndef TOLUA_RELEASE
01233  tolua_lerror:
01234  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
01235  return 0;
01236 #endif
01237 }
01238 #endif //#ifndef TOLUA_DISABLE
01239 
01240 /* method: new of class  MoveObjectMessage */
01241 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_MoveObjectMessage_new00
01242 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_MoveObjectMessage_new00(lua_State* tolua_S)
01243 {
01244 #ifndef TOLUA_RELEASE
01245  tolua_Error tolua_err;
01246  if (
01247      !tolua_isusertable(tolua_S,1,"fawkes::OpenRaveInterface::MoveObjectMessage",0,&tolua_err) ||
01248      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
01249      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
01250      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
01251      !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
01252      !tolua_isnoobj(tolua_S,6,&tolua_err)
01253  )
01254   goto tolua_lerror;
01255  else
01256 #endif
01257  {
01258   char* ini_name = ((char*)  tolua_tostring(tolua_S,2,0));
01259   float ini_x = ((float)  tolua_tonumber(tolua_S,3,0));
01260   float ini_y = ((float)  tolua_tonumber(tolua_S,4,0));
01261   float ini_z = ((float)  tolua_tonumber(tolua_S,5,0));
01262   {
01263    fawkes::OpenRaveInterface::MoveObjectMessage* tolua_ret = (fawkes::OpenRaveInterface::MoveObjectMessage*)  Mtolua_new((fawkes::OpenRaveInterface::MoveObjectMessage)(ini_name,ini_x,ini_y,ini_z));
01264     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::OpenRaveInterface::MoveObjectMessage");
01265   }
01266  }
01267  return 1;
01268 #ifndef TOLUA_RELEASE
01269  tolua_lerror:
01270  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
01271  return 0;
01272 #endif
01273 }
01274 #endif //#ifndef TOLUA_DISABLE
01275 
01276 /* method: new_local of class  MoveObjectMessage */
01277 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_MoveObjectMessage_new00_local
01278 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_MoveObjectMessage_new00_local(lua_State* tolua_S)
01279 {
01280 #ifndef TOLUA_RELEASE
01281  tolua_Error tolua_err;
01282  if (
01283      !tolua_isusertable(tolua_S,1,"fawkes::OpenRaveInterface::MoveObjectMessage",0,&tolua_err) ||
01284      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
01285      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
01286      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
01287      !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
01288      !tolua_isnoobj(tolua_S,6,&tolua_err)
01289  )
01290   goto tolua_lerror;
01291  else
01292 #endif
01293  {
01294   char* ini_name = ((char*)  tolua_tostring(tolua_S,2,0));
01295   float ini_x = ((float)  tolua_tonumber(tolua_S,3,0));
01296   float ini_y = ((float)  tolua_tonumber(tolua_S,4,0));
01297   float ini_z = ((float)  tolua_tonumber(tolua_S,5,0));
01298   {
01299    fawkes::OpenRaveInterface::MoveObjectMessage* tolua_ret = (fawkes::OpenRaveInterface::MoveObjectMessage*)  Mtolua_new((fawkes::OpenRaveInterface::MoveObjectMessage)(ini_name,ini_x,ini_y,ini_z));
01300     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::OpenRaveInterface::MoveObjectMessage");
01301     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01302   }
01303  }
01304  return 1;
01305 #ifndef TOLUA_RELEASE
01306  tolua_lerror:
01307  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
01308  return 0;
01309 #endif
01310 }
01311 #endif //#ifndef TOLUA_DISABLE
01312 
01313 /* method: new of class  MoveObjectMessage */
01314 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_MoveObjectMessage_new01
01315 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_MoveObjectMessage_new01(lua_State* tolua_S)
01316 {
01317  tolua_Error tolua_err;
01318  if (
01319      !tolua_isusertable(tolua_S,1,"fawkes::OpenRaveInterface::MoveObjectMessage",0,&tolua_err) ||
01320      !tolua_isnoobj(tolua_S,2,&tolua_err)
01321  )
01322   goto tolua_lerror;
01323  else
01324  {
01325   {
01326    fawkes::OpenRaveInterface::MoveObjectMessage* tolua_ret = (fawkes::OpenRaveInterface::MoveObjectMessage*)  Mtolua_new((fawkes::OpenRaveInterface::MoveObjectMessage)());
01327     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::OpenRaveInterface::MoveObjectMessage");
01328   }
01329  }
01330  return 1;
01331 tolua_lerror:
01332  return tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_MoveObjectMessage_new00(tolua_S);
01333 }
01334 #endif //#ifndef TOLUA_DISABLE
01335 
01336 /* method: new_local of class  MoveObjectMessage */
01337 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_MoveObjectMessage_new01_local
01338 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_MoveObjectMessage_new01_local(lua_State* tolua_S)
01339 {
01340  tolua_Error tolua_err;
01341  if (
01342      !tolua_isusertable(tolua_S,1,"fawkes::OpenRaveInterface::MoveObjectMessage",0,&tolua_err) ||
01343      !tolua_isnoobj(tolua_S,2,&tolua_err)
01344  )
01345   goto tolua_lerror;
01346  else
01347  {
01348   {
01349    fawkes::OpenRaveInterface::MoveObjectMessage* tolua_ret = (fawkes::OpenRaveInterface::MoveObjectMessage*)  Mtolua_new((fawkes::OpenRaveInterface::MoveObjectMessage)());
01350     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::OpenRaveInterface::MoveObjectMessage");
01351     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01352   }
01353  }
01354  return 1;
01355 tolua_lerror:
01356  return tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_MoveObjectMessage_new00_local(tolua_S);
01357 }
01358 #endif //#ifndef TOLUA_DISABLE
01359 
01360 /* method: delete of class  MoveObjectMessage */
01361 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_MoveObjectMessage_delete00
01362 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_MoveObjectMessage_delete00(lua_State* tolua_S)
01363 {
01364 #ifndef TOLUA_RELEASE
01365  tolua_Error tolua_err;
01366  if (
01367      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface::MoveObjectMessage",0,&tolua_err) ||
01368      !tolua_isnoobj(tolua_S,2,&tolua_err)
01369  )
01370   goto tolua_lerror;
01371  else
01372 #endif
01373  {
01374   fawkes::OpenRaveInterface::MoveObjectMessage* self = (fawkes::OpenRaveInterface::MoveObjectMessage*)  tolua_tousertype(tolua_S,1,0);
01375 #ifndef TOLUA_RELEASE
01376   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
01377 #endif
01378   Mtolua_delete(self);
01379  }
01380  return 0;
01381 #ifndef TOLUA_RELEASE
01382  tolua_lerror:
01383  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
01384  return 0;
01385 #endif
01386 }
01387 #endif //#ifndef TOLUA_DISABLE
01388 
01389 /* method: name of class  MoveObjectMessage */
01390 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_MoveObjectMessage_name00
01391 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_MoveObjectMessage_name00(lua_State* tolua_S)
01392 {
01393 #ifndef TOLUA_RELEASE
01394  tolua_Error tolua_err;
01395  if (
01396      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface::MoveObjectMessage",0,&tolua_err) ||
01397      !tolua_isnoobj(tolua_S,2,&tolua_err)
01398  )
01399   goto tolua_lerror;
01400  else
01401 #endif
01402  {
01403   fawkes::OpenRaveInterface::MoveObjectMessage* self = (fawkes::OpenRaveInterface::MoveObjectMessage*)  tolua_tousertype(tolua_S,1,0);
01404 #ifndef TOLUA_RELEASE
01405   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'name'", NULL);
01406 #endif
01407   {
01408    char* tolua_ret = (char*)  self->name();
01409    tolua_pushstring(tolua_S,(const char*)tolua_ret);
01410   }
01411  }
01412  return 1;
01413 #ifndef TOLUA_RELEASE
01414  tolua_lerror:
01415  tolua_error(tolua_S,"#ferror in function 'name'.",&tolua_err);
01416  return 0;
01417 #endif
01418 }
01419 #endif //#ifndef TOLUA_DISABLE
01420 
01421 /* method: set_name of class  MoveObjectMessage */
01422 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_MoveObjectMessage_set_name00
01423 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_MoveObjectMessage_set_name00(lua_State* tolua_S)
01424 {
01425 #ifndef TOLUA_RELEASE
01426  tolua_Error tolua_err;
01427  if (
01428      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface::MoveObjectMessage",0,&tolua_err) ||
01429      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
01430      !tolua_isnoobj(tolua_S,3,&tolua_err)
01431  )
01432   goto tolua_lerror;
01433  else
01434 #endif
01435  {
01436   fawkes::OpenRaveInterface::MoveObjectMessage* self = (fawkes::OpenRaveInterface::MoveObjectMessage*)  tolua_tousertype(tolua_S,1,0);
01437   const char* new_name = ((const char*)  tolua_tostring(tolua_S,2,0));
01438 #ifndef TOLUA_RELEASE
01439   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_name'", NULL);
01440 #endif
01441   {
01442    self->set_name(new_name);
01443   }
01444  }
01445  return 0;
01446 #ifndef TOLUA_RELEASE
01447  tolua_lerror:
01448  tolua_error(tolua_S,"#ferror in function 'set_name'.",&tolua_err);
01449  return 0;
01450 #endif
01451 }
01452 #endif //#ifndef TOLUA_DISABLE
01453 
01454 /* method: maxlenof_name of class  MoveObjectMessage */
01455 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_MoveObjectMessage_maxlenof_name00
01456 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_MoveObjectMessage_maxlenof_name00(lua_State* tolua_S)
01457 {
01458 #ifndef TOLUA_RELEASE
01459  tolua_Error tolua_err;
01460  if (
01461      !tolua_isusertype(tolua_S,1,"const fawkes::OpenRaveInterface::MoveObjectMessage",0,&tolua_err) ||
01462      !tolua_isnoobj(tolua_S,2,&tolua_err)
01463  )
01464   goto tolua_lerror;
01465  else
01466 #endif
01467  {
01468   const fawkes::OpenRaveInterface::MoveObjectMessage* self = (const fawkes::OpenRaveInterface::MoveObjectMessage*)  tolua_tousertype(tolua_S,1,0);
01469 #ifndef TOLUA_RELEASE
01470   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_name'", NULL);
01471 #endif
01472   {
01473    int tolua_ret = (int)  self->maxlenof_name();
01474    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01475   }
01476  }
01477  return 1;
01478 #ifndef TOLUA_RELEASE
01479  tolua_lerror:
01480  tolua_error(tolua_S,"#ferror in function 'maxlenof_name'.",&tolua_err);
01481  return 0;
01482 #endif
01483 }
01484 #endif //#ifndef TOLUA_DISABLE
01485 
01486 /* method: x of class  MoveObjectMessage */
01487 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_MoveObjectMessage_x00
01488 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_MoveObjectMessage_x00(lua_State* tolua_S)
01489 {
01490 #ifndef TOLUA_RELEASE
01491  tolua_Error tolua_err;
01492  if (
01493      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface::MoveObjectMessage",0,&tolua_err) ||
01494      !tolua_isnoobj(tolua_S,2,&tolua_err)
01495  )
01496   goto tolua_lerror;
01497  else
01498 #endif
01499  {
01500   fawkes::OpenRaveInterface::MoveObjectMessage* self = (fawkes::OpenRaveInterface::MoveObjectMessage*)  tolua_tousertype(tolua_S,1,0);
01501 #ifndef TOLUA_RELEASE
01502   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'x'", NULL);
01503 #endif
01504   {
01505    float tolua_ret = (float)  self->x();
01506    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01507   }
01508  }
01509  return 1;
01510 #ifndef TOLUA_RELEASE
01511  tolua_lerror:
01512  tolua_error(tolua_S,"#ferror in function 'x'.",&tolua_err);
01513  return 0;
01514 #endif
01515 }
01516 #endif //#ifndef TOLUA_DISABLE
01517 
01518 /* method: set_x of class  MoveObjectMessage */
01519 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_MoveObjectMessage_set_x00
01520 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_MoveObjectMessage_set_x00(lua_State* tolua_S)
01521 {
01522 #ifndef TOLUA_RELEASE
01523  tolua_Error tolua_err;
01524  if (
01525      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface::MoveObjectMessage",0,&tolua_err) ||
01526      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01527      !tolua_isnoobj(tolua_S,3,&tolua_err)
01528  )
01529   goto tolua_lerror;
01530  else
01531 #endif
01532  {
01533   fawkes::OpenRaveInterface::MoveObjectMessage* self = (fawkes::OpenRaveInterface::MoveObjectMessage*)  tolua_tousertype(tolua_S,1,0);
01534   const float new_x = ((const float)  tolua_tonumber(tolua_S,2,0));
01535 #ifndef TOLUA_RELEASE
01536   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_x'", NULL);
01537 #endif
01538   {
01539    self->set_x(new_x);
01540   }
01541  }
01542  return 0;
01543 #ifndef TOLUA_RELEASE
01544  tolua_lerror:
01545  tolua_error(tolua_S,"#ferror in function 'set_x'.",&tolua_err);
01546  return 0;
01547 #endif
01548 }
01549 #endif //#ifndef TOLUA_DISABLE
01550 
01551 /* method: maxlenof_x of class  MoveObjectMessage */
01552 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_MoveObjectMessage_maxlenof_x00
01553 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_MoveObjectMessage_maxlenof_x00(lua_State* tolua_S)
01554 {
01555 #ifndef TOLUA_RELEASE
01556  tolua_Error tolua_err;
01557  if (
01558      !tolua_isusertype(tolua_S,1,"const fawkes::OpenRaveInterface::MoveObjectMessage",0,&tolua_err) ||
01559      !tolua_isnoobj(tolua_S,2,&tolua_err)
01560  )
01561   goto tolua_lerror;
01562  else
01563 #endif
01564  {
01565   const fawkes::OpenRaveInterface::MoveObjectMessage* self = (const fawkes::OpenRaveInterface::MoveObjectMessage*)  tolua_tousertype(tolua_S,1,0);
01566 #ifndef TOLUA_RELEASE
01567   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_x'", NULL);
01568 #endif
01569   {
01570    int tolua_ret = (int)  self->maxlenof_x();
01571    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01572   }
01573  }
01574  return 1;
01575 #ifndef TOLUA_RELEASE
01576  tolua_lerror:
01577  tolua_error(tolua_S,"#ferror in function 'maxlenof_x'.",&tolua_err);
01578  return 0;
01579 #endif
01580 }
01581 #endif //#ifndef TOLUA_DISABLE
01582 
01583 /* method: y of class  MoveObjectMessage */
01584 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_MoveObjectMessage_y00
01585 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_MoveObjectMessage_y00(lua_State* tolua_S)
01586 {
01587 #ifndef TOLUA_RELEASE
01588  tolua_Error tolua_err;
01589  if (
01590      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface::MoveObjectMessage",0,&tolua_err) ||
01591      !tolua_isnoobj(tolua_S,2,&tolua_err)
01592  )
01593   goto tolua_lerror;
01594  else
01595 #endif
01596  {
01597   fawkes::OpenRaveInterface::MoveObjectMessage* self = (fawkes::OpenRaveInterface::MoveObjectMessage*)  tolua_tousertype(tolua_S,1,0);
01598 #ifndef TOLUA_RELEASE
01599   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'y'", NULL);
01600 #endif
01601   {
01602    float tolua_ret = (float)  self->y();
01603    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01604   }
01605  }
01606  return 1;
01607 #ifndef TOLUA_RELEASE
01608  tolua_lerror:
01609  tolua_error(tolua_S,"#ferror in function 'y'.",&tolua_err);
01610  return 0;
01611 #endif
01612 }
01613 #endif //#ifndef TOLUA_DISABLE
01614 
01615 /* method: set_y of class  MoveObjectMessage */
01616 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_MoveObjectMessage_set_y00
01617 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_MoveObjectMessage_set_y00(lua_State* tolua_S)
01618 {
01619 #ifndef TOLUA_RELEASE
01620  tolua_Error tolua_err;
01621  if (
01622      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface::MoveObjectMessage",0,&tolua_err) ||
01623      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01624      !tolua_isnoobj(tolua_S,3,&tolua_err)
01625  )
01626   goto tolua_lerror;
01627  else
01628 #endif
01629  {
01630   fawkes::OpenRaveInterface::MoveObjectMessage* self = (fawkes::OpenRaveInterface::MoveObjectMessage*)  tolua_tousertype(tolua_S,1,0);
01631   const float new_y = ((const float)  tolua_tonumber(tolua_S,2,0));
01632 #ifndef TOLUA_RELEASE
01633   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_y'", NULL);
01634 #endif
01635   {
01636    self->set_y(new_y);
01637   }
01638  }
01639  return 0;
01640 #ifndef TOLUA_RELEASE
01641  tolua_lerror:
01642  tolua_error(tolua_S,"#ferror in function 'set_y'.",&tolua_err);
01643  return 0;
01644 #endif
01645 }
01646 #endif //#ifndef TOLUA_DISABLE
01647 
01648 /* method: maxlenof_y of class  MoveObjectMessage */
01649 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_MoveObjectMessage_maxlenof_y00
01650 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_MoveObjectMessage_maxlenof_y00(lua_State* tolua_S)
01651 {
01652 #ifndef TOLUA_RELEASE
01653  tolua_Error tolua_err;
01654  if (
01655      !tolua_isusertype(tolua_S,1,"const fawkes::OpenRaveInterface::MoveObjectMessage",0,&tolua_err) ||
01656      !tolua_isnoobj(tolua_S,2,&tolua_err)
01657  )
01658   goto tolua_lerror;
01659  else
01660 #endif
01661  {
01662   const fawkes::OpenRaveInterface::MoveObjectMessage* self = (const fawkes::OpenRaveInterface::MoveObjectMessage*)  tolua_tousertype(tolua_S,1,0);
01663 #ifndef TOLUA_RELEASE
01664   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_y'", NULL);
01665 #endif
01666   {
01667    int tolua_ret = (int)  self->maxlenof_y();
01668    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01669   }
01670  }
01671  return 1;
01672 #ifndef TOLUA_RELEASE
01673  tolua_lerror:
01674  tolua_error(tolua_S,"#ferror in function 'maxlenof_y'.",&tolua_err);
01675  return 0;
01676 #endif
01677 }
01678 #endif //#ifndef TOLUA_DISABLE
01679 
01680 /* method: z of class  MoveObjectMessage */
01681 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_MoveObjectMessage_z00
01682 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_MoveObjectMessage_z00(lua_State* tolua_S)
01683 {
01684 #ifndef TOLUA_RELEASE
01685  tolua_Error tolua_err;
01686  if (
01687      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface::MoveObjectMessage",0,&tolua_err) ||
01688      !tolua_isnoobj(tolua_S,2,&tolua_err)
01689  )
01690   goto tolua_lerror;
01691  else
01692 #endif
01693  {
01694   fawkes::OpenRaveInterface::MoveObjectMessage* self = (fawkes::OpenRaveInterface::MoveObjectMessage*)  tolua_tousertype(tolua_S,1,0);
01695 #ifndef TOLUA_RELEASE
01696   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'z'", NULL);
01697 #endif
01698   {
01699    float tolua_ret = (float)  self->z();
01700    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01701   }
01702  }
01703  return 1;
01704 #ifndef TOLUA_RELEASE
01705  tolua_lerror:
01706  tolua_error(tolua_S,"#ferror in function 'z'.",&tolua_err);
01707  return 0;
01708 #endif
01709 }
01710 #endif //#ifndef TOLUA_DISABLE
01711 
01712 /* method: set_z of class  MoveObjectMessage */
01713 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_MoveObjectMessage_set_z00
01714 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_MoveObjectMessage_set_z00(lua_State* tolua_S)
01715 {
01716 #ifndef TOLUA_RELEASE
01717  tolua_Error tolua_err;
01718  if (
01719      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface::MoveObjectMessage",0,&tolua_err) ||
01720      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01721      !tolua_isnoobj(tolua_S,3,&tolua_err)
01722  )
01723   goto tolua_lerror;
01724  else
01725 #endif
01726  {
01727   fawkes::OpenRaveInterface::MoveObjectMessage* self = (fawkes::OpenRaveInterface::MoveObjectMessage*)  tolua_tousertype(tolua_S,1,0);
01728   const float new_z = ((const float)  tolua_tonumber(tolua_S,2,0));
01729 #ifndef TOLUA_RELEASE
01730   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_z'", NULL);
01731 #endif
01732   {
01733    self->set_z(new_z);
01734   }
01735  }
01736  return 0;
01737 #ifndef TOLUA_RELEASE
01738  tolua_lerror:
01739  tolua_error(tolua_S,"#ferror in function 'set_z'.",&tolua_err);
01740  return 0;
01741 #endif
01742 }
01743 #endif //#ifndef TOLUA_DISABLE
01744 
01745 /* method: maxlenof_z of class  MoveObjectMessage */
01746 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_MoveObjectMessage_maxlenof_z00
01747 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_MoveObjectMessage_maxlenof_z00(lua_State* tolua_S)
01748 {
01749 #ifndef TOLUA_RELEASE
01750  tolua_Error tolua_err;
01751  if (
01752      !tolua_isusertype(tolua_S,1,"const fawkes::OpenRaveInterface::MoveObjectMessage",0,&tolua_err) ||
01753      !tolua_isnoobj(tolua_S,2,&tolua_err)
01754  )
01755   goto tolua_lerror;
01756  else
01757 #endif
01758  {
01759   const fawkes::OpenRaveInterface::MoveObjectMessage* self = (const fawkes::OpenRaveInterface::MoveObjectMessage*)  tolua_tousertype(tolua_S,1,0);
01760 #ifndef TOLUA_RELEASE
01761   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_z'", NULL);
01762 #endif
01763   {
01764    int tolua_ret = (int)  self->maxlenof_z();
01765    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01766   }
01767  }
01768  return 1;
01769 #ifndef TOLUA_RELEASE
01770  tolua_lerror:
01771  tolua_error(tolua_S,"#ferror in function 'maxlenof_z'.",&tolua_err);
01772  return 0;
01773 #endif
01774 }
01775 #endif //#ifndef TOLUA_DISABLE
01776 
01777 /* method: new of class  RotateObjectQuatMessage */
01778 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectQuatMessage_new00
01779 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectQuatMessage_new00(lua_State* tolua_S)
01780 {
01781 #ifndef TOLUA_RELEASE
01782  tolua_Error tolua_err;
01783  if (
01784      !tolua_isusertable(tolua_S,1,"fawkes::OpenRaveInterface::RotateObjectQuatMessage",0,&tolua_err) ||
01785      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
01786      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
01787      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
01788      !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
01789      !tolua_isnumber(tolua_S,6,0,&tolua_err) ||
01790      !tolua_isnoobj(tolua_S,7,&tolua_err)
01791  )
01792   goto tolua_lerror;
01793  else
01794 #endif
01795  {
01796   char* ini_name = ((char*)  tolua_tostring(tolua_S,2,0));
01797   float ini_x = ((float)  tolua_tonumber(tolua_S,3,0));
01798   float ini_y = ((float)  tolua_tonumber(tolua_S,4,0));
01799   float ini_z = ((float)  tolua_tonumber(tolua_S,5,0));
01800   float ini_w = ((float)  tolua_tonumber(tolua_S,6,0));
01801   {
01802    fawkes::OpenRaveInterface::RotateObjectQuatMessage* tolua_ret = (fawkes::OpenRaveInterface::RotateObjectQuatMessage*)  Mtolua_new((fawkes::OpenRaveInterface::RotateObjectQuatMessage)(ini_name,ini_x,ini_y,ini_z,ini_w));
01803     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::OpenRaveInterface::RotateObjectQuatMessage");
01804   }
01805  }
01806  return 1;
01807 #ifndef TOLUA_RELEASE
01808  tolua_lerror:
01809  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
01810  return 0;
01811 #endif
01812 }
01813 #endif //#ifndef TOLUA_DISABLE
01814 
01815 /* method: new_local of class  RotateObjectQuatMessage */
01816 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectQuatMessage_new00_local
01817 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectQuatMessage_new00_local(lua_State* tolua_S)
01818 {
01819 #ifndef TOLUA_RELEASE
01820  tolua_Error tolua_err;
01821  if (
01822      !tolua_isusertable(tolua_S,1,"fawkes::OpenRaveInterface::RotateObjectQuatMessage",0,&tolua_err) ||
01823      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
01824      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
01825      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
01826      !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
01827      !tolua_isnumber(tolua_S,6,0,&tolua_err) ||
01828      !tolua_isnoobj(tolua_S,7,&tolua_err)
01829  )
01830   goto tolua_lerror;
01831  else
01832 #endif
01833  {
01834   char* ini_name = ((char*)  tolua_tostring(tolua_S,2,0));
01835   float ini_x = ((float)  tolua_tonumber(tolua_S,3,0));
01836   float ini_y = ((float)  tolua_tonumber(tolua_S,4,0));
01837   float ini_z = ((float)  tolua_tonumber(tolua_S,5,0));
01838   float ini_w = ((float)  tolua_tonumber(tolua_S,6,0));
01839   {
01840    fawkes::OpenRaveInterface::RotateObjectQuatMessage* tolua_ret = (fawkes::OpenRaveInterface::RotateObjectQuatMessage*)  Mtolua_new((fawkes::OpenRaveInterface::RotateObjectQuatMessage)(ini_name,ini_x,ini_y,ini_z,ini_w));
01841     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::OpenRaveInterface::RotateObjectQuatMessage");
01842     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01843   }
01844  }
01845  return 1;
01846 #ifndef TOLUA_RELEASE
01847  tolua_lerror:
01848  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
01849  return 0;
01850 #endif
01851 }
01852 #endif //#ifndef TOLUA_DISABLE
01853 
01854 /* method: new of class  RotateObjectQuatMessage */
01855 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectQuatMessage_new01
01856 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectQuatMessage_new01(lua_State* tolua_S)
01857 {
01858  tolua_Error tolua_err;
01859  if (
01860      !tolua_isusertable(tolua_S,1,"fawkes::OpenRaveInterface::RotateObjectQuatMessage",0,&tolua_err) ||
01861      !tolua_isnoobj(tolua_S,2,&tolua_err)
01862  )
01863   goto tolua_lerror;
01864  else
01865  {
01866   {
01867    fawkes::OpenRaveInterface::RotateObjectQuatMessage* tolua_ret = (fawkes::OpenRaveInterface::RotateObjectQuatMessage*)  Mtolua_new((fawkes::OpenRaveInterface::RotateObjectQuatMessage)());
01868     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::OpenRaveInterface::RotateObjectQuatMessage");
01869   }
01870  }
01871  return 1;
01872 tolua_lerror:
01873  return tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectQuatMessage_new00(tolua_S);
01874 }
01875 #endif //#ifndef TOLUA_DISABLE
01876 
01877 /* method: new_local of class  RotateObjectQuatMessage */
01878 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectQuatMessage_new01_local
01879 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectQuatMessage_new01_local(lua_State* tolua_S)
01880 {
01881  tolua_Error tolua_err;
01882  if (
01883      !tolua_isusertable(tolua_S,1,"fawkes::OpenRaveInterface::RotateObjectQuatMessage",0,&tolua_err) ||
01884      !tolua_isnoobj(tolua_S,2,&tolua_err)
01885  )
01886   goto tolua_lerror;
01887  else
01888  {
01889   {
01890    fawkes::OpenRaveInterface::RotateObjectQuatMessage* tolua_ret = (fawkes::OpenRaveInterface::RotateObjectQuatMessage*)  Mtolua_new((fawkes::OpenRaveInterface::RotateObjectQuatMessage)());
01891     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::OpenRaveInterface::RotateObjectQuatMessage");
01892     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01893   }
01894  }
01895  return 1;
01896 tolua_lerror:
01897  return tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectQuatMessage_new00_local(tolua_S);
01898 }
01899 #endif //#ifndef TOLUA_DISABLE
01900 
01901 /* method: delete of class  RotateObjectQuatMessage */
01902 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectQuatMessage_delete00
01903 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectQuatMessage_delete00(lua_State* tolua_S)
01904 {
01905 #ifndef TOLUA_RELEASE
01906  tolua_Error tolua_err;
01907  if (
01908      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface::RotateObjectQuatMessage",0,&tolua_err) ||
01909      !tolua_isnoobj(tolua_S,2,&tolua_err)
01910  )
01911   goto tolua_lerror;
01912  else
01913 #endif
01914  {
01915   fawkes::OpenRaveInterface::RotateObjectQuatMessage* self = (fawkes::OpenRaveInterface::RotateObjectQuatMessage*)  tolua_tousertype(tolua_S,1,0);
01916 #ifndef TOLUA_RELEASE
01917   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
01918 #endif
01919   Mtolua_delete(self);
01920  }
01921  return 0;
01922 #ifndef TOLUA_RELEASE
01923  tolua_lerror:
01924  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
01925  return 0;
01926 #endif
01927 }
01928 #endif //#ifndef TOLUA_DISABLE
01929 
01930 /* method: name of class  RotateObjectQuatMessage */
01931 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectQuatMessage_name00
01932 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectQuatMessage_name00(lua_State* tolua_S)
01933 {
01934 #ifndef TOLUA_RELEASE
01935  tolua_Error tolua_err;
01936  if (
01937      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface::RotateObjectQuatMessage",0,&tolua_err) ||
01938      !tolua_isnoobj(tolua_S,2,&tolua_err)
01939  )
01940   goto tolua_lerror;
01941  else
01942 #endif
01943  {
01944   fawkes::OpenRaveInterface::RotateObjectQuatMessage* self = (fawkes::OpenRaveInterface::RotateObjectQuatMessage*)  tolua_tousertype(tolua_S,1,0);
01945 #ifndef TOLUA_RELEASE
01946   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'name'", NULL);
01947 #endif
01948   {
01949    char* tolua_ret = (char*)  self->name();
01950    tolua_pushstring(tolua_S,(const char*)tolua_ret);
01951   }
01952  }
01953  return 1;
01954 #ifndef TOLUA_RELEASE
01955  tolua_lerror:
01956  tolua_error(tolua_S,"#ferror in function 'name'.",&tolua_err);
01957  return 0;
01958 #endif
01959 }
01960 #endif //#ifndef TOLUA_DISABLE
01961 
01962 /* method: set_name of class  RotateObjectQuatMessage */
01963 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectQuatMessage_set_name00
01964 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectQuatMessage_set_name00(lua_State* tolua_S)
01965 {
01966 #ifndef TOLUA_RELEASE
01967  tolua_Error tolua_err;
01968  if (
01969      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface::RotateObjectQuatMessage",0,&tolua_err) ||
01970      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
01971      !tolua_isnoobj(tolua_S,3,&tolua_err)
01972  )
01973   goto tolua_lerror;
01974  else
01975 #endif
01976  {
01977   fawkes::OpenRaveInterface::RotateObjectQuatMessage* self = (fawkes::OpenRaveInterface::RotateObjectQuatMessage*)  tolua_tousertype(tolua_S,1,0);
01978   const char* new_name = ((const char*)  tolua_tostring(tolua_S,2,0));
01979 #ifndef TOLUA_RELEASE
01980   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_name'", NULL);
01981 #endif
01982   {
01983    self->set_name(new_name);
01984   }
01985  }
01986  return 0;
01987 #ifndef TOLUA_RELEASE
01988  tolua_lerror:
01989  tolua_error(tolua_S,"#ferror in function 'set_name'.",&tolua_err);
01990  return 0;
01991 #endif
01992 }
01993 #endif //#ifndef TOLUA_DISABLE
01994 
01995 /* method: maxlenof_name of class  RotateObjectQuatMessage */
01996 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectQuatMessage_maxlenof_name00
01997 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectQuatMessage_maxlenof_name00(lua_State* tolua_S)
01998 {
01999 #ifndef TOLUA_RELEASE
02000  tolua_Error tolua_err;
02001  if (
02002      !tolua_isusertype(tolua_S,1,"const fawkes::OpenRaveInterface::RotateObjectQuatMessage",0,&tolua_err) ||
02003      !tolua_isnoobj(tolua_S,2,&tolua_err)
02004  )
02005   goto tolua_lerror;
02006  else
02007 #endif
02008  {
02009   const fawkes::OpenRaveInterface::RotateObjectQuatMessage* self = (const fawkes::OpenRaveInterface::RotateObjectQuatMessage*)  tolua_tousertype(tolua_S,1,0);
02010 #ifndef TOLUA_RELEASE
02011   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_name'", NULL);
02012 #endif
02013   {
02014    int tolua_ret = (int)  self->maxlenof_name();
02015    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02016   }
02017  }
02018  return 1;
02019 #ifndef TOLUA_RELEASE
02020  tolua_lerror:
02021  tolua_error(tolua_S,"#ferror in function 'maxlenof_name'.",&tolua_err);
02022  return 0;
02023 #endif
02024 }
02025 #endif //#ifndef TOLUA_DISABLE
02026 
02027 /* method: x of class  RotateObjectQuatMessage */
02028 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectQuatMessage_x00
02029 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectQuatMessage_x00(lua_State* tolua_S)
02030 {
02031 #ifndef TOLUA_RELEASE
02032  tolua_Error tolua_err;
02033  if (
02034      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface::RotateObjectQuatMessage",0,&tolua_err) ||
02035      !tolua_isnoobj(tolua_S,2,&tolua_err)
02036  )
02037   goto tolua_lerror;
02038  else
02039 #endif
02040  {
02041   fawkes::OpenRaveInterface::RotateObjectQuatMessage* self = (fawkes::OpenRaveInterface::RotateObjectQuatMessage*)  tolua_tousertype(tolua_S,1,0);
02042 #ifndef TOLUA_RELEASE
02043   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'x'", NULL);
02044 #endif
02045   {
02046    float tolua_ret = (float)  self->x();
02047    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02048   }
02049  }
02050  return 1;
02051 #ifndef TOLUA_RELEASE
02052  tolua_lerror:
02053  tolua_error(tolua_S,"#ferror in function 'x'.",&tolua_err);
02054  return 0;
02055 #endif
02056 }
02057 #endif //#ifndef TOLUA_DISABLE
02058 
02059 /* method: set_x of class  RotateObjectQuatMessage */
02060 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectQuatMessage_set_x00
02061 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectQuatMessage_set_x00(lua_State* tolua_S)
02062 {
02063 #ifndef TOLUA_RELEASE
02064  tolua_Error tolua_err;
02065  if (
02066      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface::RotateObjectQuatMessage",0,&tolua_err) ||
02067      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02068      !tolua_isnoobj(tolua_S,3,&tolua_err)
02069  )
02070   goto tolua_lerror;
02071  else
02072 #endif
02073  {
02074   fawkes::OpenRaveInterface::RotateObjectQuatMessage* self = (fawkes::OpenRaveInterface::RotateObjectQuatMessage*)  tolua_tousertype(tolua_S,1,0);
02075   const float new_x = ((const float)  tolua_tonumber(tolua_S,2,0));
02076 #ifndef TOLUA_RELEASE
02077   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_x'", NULL);
02078 #endif
02079   {
02080    self->set_x(new_x);
02081   }
02082  }
02083  return 0;
02084 #ifndef TOLUA_RELEASE
02085  tolua_lerror:
02086  tolua_error(tolua_S,"#ferror in function 'set_x'.",&tolua_err);
02087  return 0;
02088 #endif
02089 }
02090 #endif //#ifndef TOLUA_DISABLE
02091 
02092 /* method: maxlenof_x of class  RotateObjectQuatMessage */
02093 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectQuatMessage_maxlenof_x00
02094 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectQuatMessage_maxlenof_x00(lua_State* tolua_S)
02095 {
02096 #ifndef TOLUA_RELEASE
02097  tolua_Error tolua_err;
02098  if (
02099      !tolua_isusertype(tolua_S,1,"const fawkes::OpenRaveInterface::RotateObjectQuatMessage",0,&tolua_err) ||
02100      !tolua_isnoobj(tolua_S,2,&tolua_err)
02101  )
02102   goto tolua_lerror;
02103  else
02104 #endif
02105  {
02106   const fawkes::OpenRaveInterface::RotateObjectQuatMessage* self = (const fawkes::OpenRaveInterface::RotateObjectQuatMessage*)  tolua_tousertype(tolua_S,1,0);
02107 #ifndef TOLUA_RELEASE
02108   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_x'", NULL);
02109 #endif
02110   {
02111    int tolua_ret = (int)  self->maxlenof_x();
02112    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02113   }
02114  }
02115  return 1;
02116 #ifndef TOLUA_RELEASE
02117  tolua_lerror:
02118  tolua_error(tolua_S,"#ferror in function 'maxlenof_x'.",&tolua_err);
02119  return 0;
02120 #endif
02121 }
02122 #endif //#ifndef TOLUA_DISABLE
02123 
02124 /* method: y of class  RotateObjectQuatMessage */
02125 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectQuatMessage_y00
02126 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectQuatMessage_y00(lua_State* tolua_S)
02127 {
02128 #ifndef TOLUA_RELEASE
02129  tolua_Error tolua_err;
02130  if (
02131      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface::RotateObjectQuatMessage",0,&tolua_err) ||
02132      !tolua_isnoobj(tolua_S,2,&tolua_err)
02133  )
02134   goto tolua_lerror;
02135  else
02136 #endif
02137  {
02138   fawkes::OpenRaveInterface::RotateObjectQuatMessage* self = (fawkes::OpenRaveInterface::RotateObjectQuatMessage*)  tolua_tousertype(tolua_S,1,0);
02139 #ifndef TOLUA_RELEASE
02140   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'y'", NULL);
02141 #endif
02142   {
02143    float tolua_ret = (float)  self->y();
02144    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02145   }
02146  }
02147  return 1;
02148 #ifndef TOLUA_RELEASE
02149  tolua_lerror:
02150  tolua_error(tolua_S,"#ferror in function 'y'.",&tolua_err);
02151  return 0;
02152 #endif
02153 }
02154 #endif //#ifndef TOLUA_DISABLE
02155 
02156 /* method: set_y of class  RotateObjectQuatMessage */
02157 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectQuatMessage_set_y00
02158 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectQuatMessage_set_y00(lua_State* tolua_S)
02159 {
02160 #ifndef TOLUA_RELEASE
02161  tolua_Error tolua_err;
02162  if (
02163      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface::RotateObjectQuatMessage",0,&tolua_err) ||
02164      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02165      !tolua_isnoobj(tolua_S,3,&tolua_err)
02166  )
02167   goto tolua_lerror;
02168  else
02169 #endif
02170  {
02171   fawkes::OpenRaveInterface::RotateObjectQuatMessage* self = (fawkes::OpenRaveInterface::RotateObjectQuatMessage*)  tolua_tousertype(tolua_S,1,0);
02172   const float new_y = ((const float)  tolua_tonumber(tolua_S,2,0));
02173 #ifndef TOLUA_RELEASE
02174   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_y'", NULL);
02175 #endif
02176   {
02177    self->set_y(new_y);
02178   }
02179  }
02180  return 0;
02181 #ifndef TOLUA_RELEASE
02182  tolua_lerror:
02183  tolua_error(tolua_S,"#ferror in function 'set_y'.",&tolua_err);
02184  return 0;
02185 #endif
02186 }
02187 #endif //#ifndef TOLUA_DISABLE
02188 
02189 /* method: maxlenof_y of class  RotateObjectQuatMessage */
02190 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectQuatMessage_maxlenof_y00
02191 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectQuatMessage_maxlenof_y00(lua_State* tolua_S)
02192 {
02193 #ifndef TOLUA_RELEASE
02194  tolua_Error tolua_err;
02195  if (
02196      !tolua_isusertype(tolua_S,1,"const fawkes::OpenRaveInterface::RotateObjectQuatMessage",0,&tolua_err) ||
02197      !tolua_isnoobj(tolua_S,2,&tolua_err)
02198  )
02199   goto tolua_lerror;
02200  else
02201 #endif
02202  {
02203   const fawkes::OpenRaveInterface::RotateObjectQuatMessage* self = (const fawkes::OpenRaveInterface::RotateObjectQuatMessage*)  tolua_tousertype(tolua_S,1,0);
02204 #ifndef TOLUA_RELEASE
02205   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_y'", NULL);
02206 #endif
02207   {
02208    int tolua_ret = (int)  self->maxlenof_y();
02209    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02210   }
02211  }
02212  return 1;
02213 #ifndef TOLUA_RELEASE
02214  tolua_lerror:
02215  tolua_error(tolua_S,"#ferror in function 'maxlenof_y'.",&tolua_err);
02216  return 0;
02217 #endif
02218 }
02219 #endif //#ifndef TOLUA_DISABLE
02220 
02221 /* method: z of class  RotateObjectQuatMessage */
02222 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectQuatMessage_z00
02223 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectQuatMessage_z00(lua_State* tolua_S)
02224 {
02225 #ifndef TOLUA_RELEASE
02226  tolua_Error tolua_err;
02227  if (
02228      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface::RotateObjectQuatMessage",0,&tolua_err) ||
02229      !tolua_isnoobj(tolua_S,2,&tolua_err)
02230  )
02231   goto tolua_lerror;
02232  else
02233 #endif
02234  {
02235   fawkes::OpenRaveInterface::RotateObjectQuatMessage* self = (fawkes::OpenRaveInterface::RotateObjectQuatMessage*)  tolua_tousertype(tolua_S,1,0);
02236 #ifndef TOLUA_RELEASE
02237   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'z'", NULL);
02238 #endif
02239   {
02240    float tolua_ret = (float)  self->z();
02241    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02242   }
02243  }
02244  return 1;
02245 #ifndef TOLUA_RELEASE
02246  tolua_lerror:
02247  tolua_error(tolua_S,"#ferror in function 'z'.",&tolua_err);
02248  return 0;
02249 #endif
02250 }
02251 #endif //#ifndef TOLUA_DISABLE
02252 
02253 /* method: set_z of class  RotateObjectQuatMessage */
02254 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectQuatMessage_set_z00
02255 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectQuatMessage_set_z00(lua_State* tolua_S)
02256 {
02257 #ifndef TOLUA_RELEASE
02258  tolua_Error tolua_err;
02259  if (
02260      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface::RotateObjectQuatMessage",0,&tolua_err) ||
02261      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02262      !tolua_isnoobj(tolua_S,3,&tolua_err)
02263  )
02264   goto tolua_lerror;
02265  else
02266 #endif
02267  {
02268   fawkes::OpenRaveInterface::RotateObjectQuatMessage* self = (fawkes::OpenRaveInterface::RotateObjectQuatMessage*)  tolua_tousertype(tolua_S,1,0);
02269   const float new_z = ((const float)  tolua_tonumber(tolua_S,2,0));
02270 #ifndef TOLUA_RELEASE
02271   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_z'", NULL);
02272 #endif
02273   {
02274    self->set_z(new_z);
02275   }
02276  }
02277  return 0;
02278 #ifndef TOLUA_RELEASE
02279  tolua_lerror:
02280  tolua_error(tolua_S,"#ferror in function 'set_z'.",&tolua_err);
02281  return 0;
02282 #endif
02283 }
02284 #endif //#ifndef TOLUA_DISABLE
02285 
02286 /* method: maxlenof_z of class  RotateObjectQuatMessage */
02287 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectQuatMessage_maxlenof_z00
02288 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectQuatMessage_maxlenof_z00(lua_State* tolua_S)
02289 {
02290 #ifndef TOLUA_RELEASE
02291  tolua_Error tolua_err;
02292  if (
02293      !tolua_isusertype(tolua_S,1,"const fawkes::OpenRaveInterface::RotateObjectQuatMessage",0,&tolua_err) ||
02294      !tolua_isnoobj(tolua_S,2,&tolua_err)
02295  )
02296   goto tolua_lerror;
02297  else
02298 #endif
02299  {
02300   const fawkes::OpenRaveInterface::RotateObjectQuatMessage* self = (const fawkes::OpenRaveInterface::RotateObjectQuatMessage*)  tolua_tousertype(tolua_S,1,0);
02301 #ifndef TOLUA_RELEASE
02302   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_z'", NULL);
02303 #endif
02304   {
02305    int tolua_ret = (int)  self->maxlenof_z();
02306    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02307   }
02308  }
02309  return 1;
02310 #ifndef TOLUA_RELEASE
02311  tolua_lerror:
02312  tolua_error(tolua_S,"#ferror in function 'maxlenof_z'.",&tolua_err);
02313  return 0;
02314 #endif
02315 }
02316 #endif //#ifndef TOLUA_DISABLE
02317 
02318 /* method: w of class  RotateObjectQuatMessage */
02319 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectQuatMessage_w00
02320 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectQuatMessage_w00(lua_State* tolua_S)
02321 {
02322 #ifndef TOLUA_RELEASE
02323  tolua_Error tolua_err;
02324  if (
02325      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface::RotateObjectQuatMessage",0,&tolua_err) ||
02326      !tolua_isnoobj(tolua_S,2,&tolua_err)
02327  )
02328   goto tolua_lerror;
02329  else
02330 #endif
02331  {
02332   fawkes::OpenRaveInterface::RotateObjectQuatMessage* self = (fawkes::OpenRaveInterface::RotateObjectQuatMessage*)  tolua_tousertype(tolua_S,1,0);
02333 #ifndef TOLUA_RELEASE
02334   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'w'", NULL);
02335 #endif
02336   {
02337    float tolua_ret = (float)  self->w();
02338    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02339   }
02340  }
02341  return 1;
02342 #ifndef TOLUA_RELEASE
02343  tolua_lerror:
02344  tolua_error(tolua_S,"#ferror in function 'w'.",&tolua_err);
02345  return 0;
02346 #endif
02347 }
02348 #endif //#ifndef TOLUA_DISABLE
02349 
02350 /* method: set_w of class  RotateObjectQuatMessage */
02351 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectQuatMessage_set_w00
02352 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectQuatMessage_set_w00(lua_State* tolua_S)
02353 {
02354 #ifndef TOLUA_RELEASE
02355  tolua_Error tolua_err;
02356  if (
02357      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface::RotateObjectQuatMessage",0,&tolua_err) ||
02358      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02359      !tolua_isnoobj(tolua_S,3,&tolua_err)
02360  )
02361   goto tolua_lerror;
02362  else
02363 #endif
02364  {
02365   fawkes::OpenRaveInterface::RotateObjectQuatMessage* self = (fawkes::OpenRaveInterface::RotateObjectQuatMessage*)  tolua_tousertype(tolua_S,1,0);
02366   const float new_w = ((const float)  tolua_tonumber(tolua_S,2,0));
02367 #ifndef TOLUA_RELEASE
02368   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_w'", NULL);
02369 #endif
02370   {
02371    self->set_w(new_w);
02372   }
02373  }
02374  return 0;
02375 #ifndef TOLUA_RELEASE
02376  tolua_lerror:
02377  tolua_error(tolua_S,"#ferror in function 'set_w'.",&tolua_err);
02378  return 0;
02379 #endif
02380 }
02381 #endif //#ifndef TOLUA_DISABLE
02382 
02383 /* method: maxlenof_w of class  RotateObjectQuatMessage */
02384 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectQuatMessage_maxlenof_w00
02385 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectQuatMessage_maxlenof_w00(lua_State* tolua_S)
02386 {
02387 #ifndef TOLUA_RELEASE
02388  tolua_Error tolua_err;
02389  if (
02390      !tolua_isusertype(tolua_S,1,"const fawkes::OpenRaveInterface::RotateObjectQuatMessage",0,&tolua_err) ||
02391      !tolua_isnoobj(tolua_S,2,&tolua_err)
02392  )
02393   goto tolua_lerror;
02394  else
02395 #endif
02396  {
02397   const fawkes::OpenRaveInterface::RotateObjectQuatMessage* self = (const fawkes::OpenRaveInterface::RotateObjectQuatMessage*)  tolua_tousertype(tolua_S,1,0);
02398 #ifndef TOLUA_RELEASE
02399   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_w'", NULL);
02400 #endif
02401   {
02402    int tolua_ret = (int)  self->maxlenof_w();
02403    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02404   }
02405  }
02406  return 1;
02407 #ifndef TOLUA_RELEASE
02408  tolua_lerror:
02409  tolua_error(tolua_S,"#ferror in function 'maxlenof_w'.",&tolua_err);
02410  return 0;
02411 #endif
02412 }
02413 #endif //#ifndef TOLUA_DISABLE
02414 
02415 /* method: new of class  RotateObjectMessage */
02416 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectMessage_new00
02417 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectMessage_new00(lua_State* tolua_S)
02418 {
02419 #ifndef TOLUA_RELEASE
02420  tolua_Error tolua_err;
02421  if (
02422      !tolua_isusertable(tolua_S,1,"fawkes::OpenRaveInterface::RotateObjectMessage",0,&tolua_err) ||
02423      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
02424      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
02425      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
02426      !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
02427      !tolua_isnoobj(tolua_S,6,&tolua_err)
02428  )
02429   goto tolua_lerror;
02430  else
02431 #endif
02432  {
02433   char* ini_name = ((char*)  tolua_tostring(tolua_S,2,0));
02434   float ini_x = ((float)  tolua_tonumber(tolua_S,3,0));
02435   float ini_y = ((float)  tolua_tonumber(tolua_S,4,0));
02436   float ini_z = ((float)  tolua_tonumber(tolua_S,5,0));
02437   {
02438    fawkes::OpenRaveInterface::RotateObjectMessage* tolua_ret = (fawkes::OpenRaveInterface::RotateObjectMessage*)  Mtolua_new((fawkes::OpenRaveInterface::RotateObjectMessage)(ini_name,ini_x,ini_y,ini_z));
02439     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::OpenRaveInterface::RotateObjectMessage");
02440   }
02441  }
02442  return 1;
02443 #ifndef TOLUA_RELEASE
02444  tolua_lerror:
02445  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
02446  return 0;
02447 #endif
02448 }
02449 #endif //#ifndef TOLUA_DISABLE
02450 
02451 /* method: new_local of class  RotateObjectMessage */
02452 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectMessage_new00_local
02453 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectMessage_new00_local(lua_State* tolua_S)
02454 {
02455 #ifndef TOLUA_RELEASE
02456  tolua_Error tolua_err;
02457  if (
02458      !tolua_isusertable(tolua_S,1,"fawkes::OpenRaveInterface::RotateObjectMessage",0,&tolua_err) ||
02459      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
02460      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
02461      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
02462      !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
02463      !tolua_isnoobj(tolua_S,6,&tolua_err)
02464  )
02465   goto tolua_lerror;
02466  else
02467 #endif
02468  {
02469   char* ini_name = ((char*)  tolua_tostring(tolua_S,2,0));
02470   float ini_x = ((float)  tolua_tonumber(tolua_S,3,0));
02471   float ini_y = ((float)  tolua_tonumber(tolua_S,4,0));
02472   float ini_z = ((float)  tolua_tonumber(tolua_S,5,0));
02473   {
02474    fawkes::OpenRaveInterface::RotateObjectMessage* tolua_ret = (fawkes::OpenRaveInterface::RotateObjectMessage*)  Mtolua_new((fawkes::OpenRaveInterface::RotateObjectMessage)(ini_name,ini_x,ini_y,ini_z));
02475     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::OpenRaveInterface::RotateObjectMessage");
02476     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
02477   }
02478  }
02479  return 1;
02480 #ifndef TOLUA_RELEASE
02481  tolua_lerror:
02482  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
02483  return 0;
02484 #endif
02485 }
02486 #endif //#ifndef TOLUA_DISABLE
02487 
02488 /* method: new of class  RotateObjectMessage */
02489 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectMessage_new01
02490 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectMessage_new01(lua_State* tolua_S)
02491 {
02492  tolua_Error tolua_err;
02493  if (
02494      !tolua_isusertable(tolua_S,1,"fawkes::OpenRaveInterface::RotateObjectMessage",0,&tolua_err) ||
02495      !tolua_isnoobj(tolua_S,2,&tolua_err)
02496  )
02497   goto tolua_lerror;
02498  else
02499  {
02500   {
02501    fawkes::OpenRaveInterface::RotateObjectMessage* tolua_ret = (fawkes::OpenRaveInterface::RotateObjectMessage*)  Mtolua_new((fawkes::OpenRaveInterface::RotateObjectMessage)());
02502     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::OpenRaveInterface::RotateObjectMessage");
02503   }
02504  }
02505  return 1;
02506 tolua_lerror:
02507  return tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectMessage_new00(tolua_S);
02508 }
02509 #endif //#ifndef TOLUA_DISABLE
02510 
02511 /* method: new_local of class  RotateObjectMessage */
02512 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectMessage_new01_local
02513 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectMessage_new01_local(lua_State* tolua_S)
02514 {
02515  tolua_Error tolua_err;
02516  if (
02517      !tolua_isusertable(tolua_S,1,"fawkes::OpenRaveInterface::RotateObjectMessage",0,&tolua_err) ||
02518      !tolua_isnoobj(tolua_S,2,&tolua_err)
02519  )
02520   goto tolua_lerror;
02521  else
02522  {
02523   {
02524    fawkes::OpenRaveInterface::RotateObjectMessage* tolua_ret = (fawkes::OpenRaveInterface::RotateObjectMessage*)  Mtolua_new((fawkes::OpenRaveInterface::RotateObjectMessage)());
02525     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::OpenRaveInterface::RotateObjectMessage");
02526     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
02527   }
02528  }
02529  return 1;
02530 tolua_lerror:
02531  return tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectMessage_new00_local(tolua_S);
02532 }
02533 #endif //#ifndef TOLUA_DISABLE
02534 
02535 /* method: delete of class  RotateObjectMessage */
02536 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectMessage_delete00
02537 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectMessage_delete00(lua_State* tolua_S)
02538 {
02539 #ifndef TOLUA_RELEASE
02540  tolua_Error tolua_err;
02541  if (
02542      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface::RotateObjectMessage",0,&tolua_err) ||
02543      !tolua_isnoobj(tolua_S,2,&tolua_err)
02544  )
02545   goto tolua_lerror;
02546  else
02547 #endif
02548  {
02549   fawkes::OpenRaveInterface::RotateObjectMessage* self = (fawkes::OpenRaveInterface::RotateObjectMessage*)  tolua_tousertype(tolua_S,1,0);
02550 #ifndef TOLUA_RELEASE
02551   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
02552 #endif
02553   Mtolua_delete(self);
02554  }
02555  return 0;
02556 #ifndef TOLUA_RELEASE
02557  tolua_lerror:
02558  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
02559  return 0;
02560 #endif
02561 }
02562 #endif //#ifndef TOLUA_DISABLE
02563 
02564 /* method: name of class  RotateObjectMessage */
02565 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectMessage_name00
02566 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectMessage_name00(lua_State* tolua_S)
02567 {
02568 #ifndef TOLUA_RELEASE
02569  tolua_Error tolua_err;
02570  if (
02571      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface::RotateObjectMessage",0,&tolua_err) ||
02572      !tolua_isnoobj(tolua_S,2,&tolua_err)
02573  )
02574   goto tolua_lerror;
02575  else
02576 #endif
02577  {
02578   fawkes::OpenRaveInterface::RotateObjectMessage* self = (fawkes::OpenRaveInterface::RotateObjectMessage*)  tolua_tousertype(tolua_S,1,0);
02579 #ifndef TOLUA_RELEASE
02580   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'name'", NULL);
02581 #endif
02582   {
02583    char* tolua_ret = (char*)  self->name();
02584    tolua_pushstring(tolua_S,(const char*)tolua_ret);
02585   }
02586  }
02587  return 1;
02588 #ifndef TOLUA_RELEASE
02589  tolua_lerror:
02590  tolua_error(tolua_S,"#ferror in function 'name'.",&tolua_err);
02591  return 0;
02592 #endif
02593 }
02594 #endif //#ifndef TOLUA_DISABLE
02595 
02596 /* method: set_name of class  RotateObjectMessage */
02597 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectMessage_set_name00
02598 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectMessage_set_name00(lua_State* tolua_S)
02599 {
02600 #ifndef TOLUA_RELEASE
02601  tolua_Error tolua_err;
02602  if (
02603      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface::RotateObjectMessage",0,&tolua_err) ||
02604      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
02605      !tolua_isnoobj(tolua_S,3,&tolua_err)
02606  )
02607   goto tolua_lerror;
02608  else
02609 #endif
02610  {
02611   fawkes::OpenRaveInterface::RotateObjectMessage* self = (fawkes::OpenRaveInterface::RotateObjectMessage*)  tolua_tousertype(tolua_S,1,0);
02612   const char* new_name = ((const char*)  tolua_tostring(tolua_S,2,0));
02613 #ifndef TOLUA_RELEASE
02614   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_name'", NULL);
02615 #endif
02616   {
02617    self->set_name(new_name);
02618   }
02619  }
02620  return 0;
02621 #ifndef TOLUA_RELEASE
02622  tolua_lerror:
02623  tolua_error(tolua_S,"#ferror in function 'set_name'.",&tolua_err);
02624  return 0;
02625 #endif
02626 }
02627 #endif //#ifndef TOLUA_DISABLE
02628 
02629 /* method: maxlenof_name of class  RotateObjectMessage */
02630 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectMessage_maxlenof_name00
02631 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectMessage_maxlenof_name00(lua_State* tolua_S)
02632 {
02633 #ifndef TOLUA_RELEASE
02634  tolua_Error tolua_err;
02635  if (
02636      !tolua_isusertype(tolua_S,1,"const fawkes::OpenRaveInterface::RotateObjectMessage",0,&tolua_err) ||
02637      !tolua_isnoobj(tolua_S,2,&tolua_err)
02638  )
02639   goto tolua_lerror;
02640  else
02641 #endif
02642  {
02643   const fawkes::OpenRaveInterface::RotateObjectMessage* self = (const fawkes::OpenRaveInterface::RotateObjectMessage*)  tolua_tousertype(tolua_S,1,0);
02644 #ifndef TOLUA_RELEASE
02645   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_name'", NULL);
02646 #endif
02647   {
02648    int tolua_ret = (int)  self->maxlenof_name();
02649    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02650   }
02651  }
02652  return 1;
02653 #ifndef TOLUA_RELEASE
02654  tolua_lerror:
02655  tolua_error(tolua_S,"#ferror in function 'maxlenof_name'.",&tolua_err);
02656  return 0;
02657 #endif
02658 }
02659 #endif //#ifndef TOLUA_DISABLE
02660 
02661 /* method: x of class  RotateObjectMessage */
02662 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectMessage_x00
02663 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectMessage_x00(lua_State* tolua_S)
02664 {
02665 #ifndef TOLUA_RELEASE
02666  tolua_Error tolua_err;
02667  if (
02668      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface::RotateObjectMessage",0,&tolua_err) ||
02669      !tolua_isnoobj(tolua_S,2,&tolua_err)
02670  )
02671   goto tolua_lerror;
02672  else
02673 #endif
02674  {
02675   fawkes::OpenRaveInterface::RotateObjectMessage* self = (fawkes::OpenRaveInterface::RotateObjectMessage*)  tolua_tousertype(tolua_S,1,0);
02676 #ifndef TOLUA_RELEASE
02677   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'x'", NULL);
02678 #endif
02679   {
02680    float tolua_ret = (float)  self->x();
02681    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02682   }
02683  }
02684  return 1;
02685 #ifndef TOLUA_RELEASE
02686  tolua_lerror:
02687  tolua_error(tolua_S,"#ferror in function 'x'.",&tolua_err);
02688  return 0;
02689 #endif
02690 }
02691 #endif //#ifndef TOLUA_DISABLE
02692 
02693 /* method: set_x of class  RotateObjectMessage */
02694 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectMessage_set_x00
02695 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectMessage_set_x00(lua_State* tolua_S)
02696 {
02697 #ifndef TOLUA_RELEASE
02698  tolua_Error tolua_err;
02699  if (
02700      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface::RotateObjectMessage",0,&tolua_err) ||
02701      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02702      !tolua_isnoobj(tolua_S,3,&tolua_err)
02703  )
02704   goto tolua_lerror;
02705  else
02706 #endif
02707  {
02708   fawkes::OpenRaveInterface::RotateObjectMessage* self = (fawkes::OpenRaveInterface::RotateObjectMessage*)  tolua_tousertype(tolua_S,1,0);
02709   const float new_x = ((const float)  tolua_tonumber(tolua_S,2,0));
02710 #ifndef TOLUA_RELEASE
02711   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_x'", NULL);
02712 #endif
02713   {
02714    self->set_x(new_x);
02715   }
02716  }
02717  return 0;
02718 #ifndef TOLUA_RELEASE
02719  tolua_lerror:
02720  tolua_error(tolua_S,"#ferror in function 'set_x'.",&tolua_err);
02721  return 0;
02722 #endif
02723 }
02724 #endif //#ifndef TOLUA_DISABLE
02725 
02726 /* method: maxlenof_x of class  RotateObjectMessage */
02727 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectMessage_maxlenof_x00
02728 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectMessage_maxlenof_x00(lua_State* tolua_S)
02729 {
02730 #ifndef TOLUA_RELEASE
02731  tolua_Error tolua_err;
02732  if (
02733      !tolua_isusertype(tolua_S,1,"const fawkes::OpenRaveInterface::RotateObjectMessage",0,&tolua_err) ||
02734      !tolua_isnoobj(tolua_S,2,&tolua_err)
02735  )
02736   goto tolua_lerror;
02737  else
02738 #endif
02739  {
02740   const fawkes::OpenRaveInterface::RotateObjectMessage* self = (const fawkes::OpenRaveInterface::RotateObjectMessage*)  tolua_tousertype(tolua_S,1,0);
02741 #ifndef TOLUA_RELEASE
02742   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_x'", NULL);
02743 #endif
02744   {
02745    int tolua_ret = (int)  self->maxlenof_x();
02746    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02747   }
02748  }
02749  return 1;
02750 #ifndef TOLUA_RELEASE
02751  tolua_lerror:
02752  tolua_error(tolua_S,"#ferror in function 'maxlenof_x'.",&tolua_err);
02753  return 0;
02754 #endif
02755 }
02756 #endif //#ifndef TOLUA_DISABLE
02757 
02758 /* method: y of class  RotateObjectMessage */
02759 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectMessage_y00
02760 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectMessage_y00(lua_State* tolua_S)
02761 {
02762 #ifndef TOLUA_RELEASE
02763  tolua_Error tolua_err;
02764  if (
02765      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface::RotateObjectMessage",0,&tolua_err) ||
02766      !tolua_isnoobj(tolua_S,2,&tolua_err)
02767  )
02768   goto tolua_lerror;
02769  else
02770 #endif
02771  {
02772   fawkes::OpenRaveInterface::RotateObjectMessage* self = (fawkes::OpenRaveInterface::RotateObjectMessage*)  tolua_tousertype(tolua_S,1,0);
02773 #ifndef TOLUA_RELEASE
02774   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'y'", NULL);
02775 #endif
02776   {
02777    float tolua_ret = (float)  self->y();
02778    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02779   }
02780  }
02781  return 1;
02782 #ifndef TOLUA_RELEASE
02783  tolua_lerror:
02784  tolua_error(tolua_S,"#ferror in function 'y'.",&tolua_err);
02785  return 0;
02786 #endif
02787 }
02788 #endif //#ifndef TOLUA_DISABLE
02789 
02790 /* method: set_y of class  RotateObjectMessage */
02791 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectMessage_set_y00
02792 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectMessage_set_y00(lua_State* tolua_S)
02793 {
02794 #ifndef TOLUA_RELEASE
02795  tolua_Error tolua_err;
02796  if (
02797      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface::RotateObjectMessage",0,&tolua_err) ||
02798      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02799      !tolua_isnoobj(tolua_S,3,&tolua_err)
02800  )
02801   goto tolua_lerror;
02802  else
02803 #endif
02804  {
02805   fawkes::OpenRaveInterface::RotateObjectMessage* self = (fawkes::OpenRaveInterface::RotateObjectMessage*)  tolua_tousertype(tolua_S,1,0);
02806   const float new_y = ((const float)  tolua_tonumber(tolua_S,2,0));
02807 #ifndef TOLUA_RELEASE
02808   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_y'", NULL);
02809 #endif
02810   {
02811    self->set_y(new_y);
02812   }
02813  }
02814  return 0;
02815 #ifndef TOLUA_RELEASE
02816  tolua_lerror:
02817  tolua_error(tolua_S,"#ferror in function 'set_y'.",&tolua_err);
02818  return 0;
02819 #endif
02820 }
02821 #endif //#ifndef TOLUA_DISABLE
02822 
02823 /* method: maxlenof_y of class  RotateObjectMessage */
02824 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectMessage_maxlenof_y00
02825 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectMessage_maxlenof_y00(lua_State* tolua_S)
02826 {
02827 #ifndef TOLUA_RELEASE
02828  tolua_Error tolua_err;
02829  if (
02830      !tolua_isusertype(tolua_S,1,"const fawkes::OpenRaveInterface::RotateObjectMessage",0,&tolua_err) ||
02831      !tolua_isnoobj(tolua_S,2,&tolua_err)
02832  )
02833   goto tolua_lerror;
02834  else
02835 #endif
02836  {
02837   const fawkes::OpenRaveInterface::RotateObjectMessage* self = (const fawkes::OpenRaveInterface::RotateObjectMessage*)  tolua_tousertype(tolua_S,1,0);
02838 #ifndef TOLUA_RELEASE
02839   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_y'", NULL);
02840 #endif
02841   {
02842    int tolua_ret = (int)  self->maxlenof_y();
02843    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02844   }
02845  }
02846  return 1;
02847 #ifndef TOLUA_RELEASE
02848  tolua_lerror:
02849  tolua_error(tolua_S,"#ferror in function 'maxlenof_y'.",&tolua_err);
02850  return 0;
02851 #endif
02852 }
02853 #endif //#ifndef TOLUA_DISABLE
02854 
02855 /* method: z of class  RotateObjectMessage */
02856 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectMessage_z00
02857 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectMessage_z00(lua_State* tolua_S)
02858 {
02859 #ifndef TOLUA_RELEASE
02860  tolua_Error tolua_err;
02861  if (
02862      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface::RotateObjectMessage",0,&tolua_err) ||
02863      !tolua_isnoobj(tolua_S,2,&tolua_err)
02864  )
02865   goto tolua_lerror;
02866  else
02867 #endif
02868  {
02869   fawkes::OpenRaveInterface::RotateObjectMessage* self = (fawkes::OpenRaveInterface::RotateObjectMessage*)  tolua_tousertype(tolua_S,1,0);
02870 #ifndef TOLUA_RELEASE
02871   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'z'", NULL);
02872 #endif
02873   {
02874    float tolua_ret = (float)  self->z();
02875    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02876   }
02877  }
02878  return 1;
02879 #ifndef TOLUA_RELEASE
02880  tolua_lerror:
02881  tolua_error(tolua_S,"#ferror in function 'z'.",&tolua_err);
02882  return 0;
02883 #endif
02884 }
02885 #endif //#ifndef TOLUA_DISABLE
02886 
02887 /* method: set_z of class  RotateObjectMessage */
02888 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectMessage_set_z00
02889 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectMessage_set_z00(lua_State* tolua_S)
02890 {
02891 #ifndef TOLUA_RELEASE
02892  tolua_Error tolua_err;
02893  if (
02894      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface::RotateObjectMessage",0,&tolua_err) ||
02895      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02896      !tolua_isnoobj(tolua_S,3,&tolua_err)
02897  )
02898   goto tolua_lerror;
02899  else
02900 #endif
02901  {
02902   fawkes::OpenRaveInterface::RotateObjectMessage* self = (fawkes::OpenRaveInterface::RotateObjectMessage*)  tolua_tousertype(tolua_S,1,0);
02903   const float new_z = ((const float)  tolua_tonumber(tolua_S,2,0));
02904 #ifndef TOLUA_RELEASE
02905   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_z'", NULL);
02906 #endif
02907   {
02908    self->set_z(new_z);
02909   }
02910  }
02911  return 0;
02912 #ifndef TOLUA_RELEASE
02913  tolua_lerror:
02914  tolua_error(tolua_S,"#ferror in function 'set_z'.",&tolua_err);
02915  return 0;
02916 #endif
02917 }
02918 #endif //#ifndef TOLUA_DISABLE
02919 
02920 /* method: maxlenof_z of class  RotateObjectMessage */
02921 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectMessage_maxlenof_z00
02922 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectMessage_maxlenof_z00(lua_State* tolua_S)
02923 {
02924 #ifndef TOLUA_RELEASE
02925  tolua_Error tolua_err;
02926  if (
02927      !tolua_isusertype(tolua_S,1,"const fawkes::OpenRaveInterface::RotateObjectMessage",0,&tolua_err) ||
02928      !tolua_isnoobj(tolua_S,2,&tolua_err)
02929  )
02930   goto tolua_lerror;
02931  else
02932 #endif
02933  {
02934   const fawkes::OpenRaveInterface::RotateObjectMessage* self = (const fawkes::OpenRaveInterface::RotateObjectMessage*)  tolua_tousertype(tolua_S,1,0);
02935 #ifndef TOLUA_RELEASE
02936   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_z'", NULL);
02937 #endif
02938   {
02939    int tolua_ret = (int)  self->maxlenof_z();
02940    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02941   }
02942  }
02943  return 1;
02944 #ifndef TOLUA_RELEASE
02945  tolua_lerror:
02946  tolua_error(tolua_S,"#ferror in function 'maxlenof_z'.",&tolua_err);
02947  return 0;
02948 #endif
02949 }
02950 #endif //#ifndef TOLUA_DISABLE
02951 
02952 /* method: new of class  RenameObjectMessage */
02953 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RenameObjectMessage_new00
02954 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RenameObjectMessage_new00(lua_State* tolua_S)
02955 {
02956 #ifndef TOLUA_RELEASE
02957  tolua_Error tolua_err;
02958  if (
02959      !tolua_isusertable(tolua_S,1,"fawkes::OpenRaveInterface::RenameObjectMessage",0,&tolua_err) ||
02960      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
02961      !tolua_isstring(tolua_S,3,0,&tolua_err) ||
02962      !tolua_isnoobj(tolua_S,4,&tolua_err)
02963  )
02964   goto tolua_lerror;
02965  else
02966 #endif
02967  {
02968   char* ini_name = ((char*)  tolua_tostring(tolua_S,2,0));
02969   char* ini_newName = ((char*)  tolua_tostring(tolua_S,3,0));
02970   {
02971    fawkes::OpenRaveInterface::RenameObjectMessage* tolua_ret = (fawkes::OpenRaveInterface::RenameObjectMessage*)  Mtolua_new((fawkes::OpenRaveInterface::RenameObjectMessage)(ini_name,ini_newName));
02972     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::OpenRaveInterface::RenameObjectMessage");
02973   }
02974  }
02975  return 1;
02976 #ifndef TOLUA_RELEASE
02977  tolua_lerror:
02978  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
02979  return 0;
02980 #endif
02981 }
02982 #endif //#ifndef TOLUA_DISABLE
02983 
02984 /* method: new_local of class  RenameObjectMessage */
02985 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RenameObjectMessage_new00_local
02986 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RenameObjectMessage_new00_local(lua_State* tolua_S)
02987 {
02988 #ifndef TOLUA_RELEASE
02989  tolua_Error tolua_err;
02990  if (
02991      !tolua_isusertable(tolua_S,1,"fawkes::OpenRaveInterface::RenameObjectMessage",0,&tolua_err) ||
02992      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
02993      !tolua_isstring(tolua_S,3,0,&tolua_err) ||
02994      !tolua_isnoobj(tolua_S,4,&tolua_err)
02995  )
02996   goto tolua_lerror;
02997  else
02998 #endif
02999  {
03000   char* ini_name = ((char*)  tolua_tostring(tolua_S,2,0));
03001   char* ini_newName = ((char*)  tolua_tostring(tolua_S,3,0));
03002   {
03003    fawkes::OpenRaveInterface::RenameObjectMessage* tolua_ret = (fawkes::OpenRaveInterface::RenameObjectMessage*)  Mtolua_new((fawkes::OpenRaveInterface::RenameObjectMessage)(ini_name,ini_newName));
03004     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::OpenRaveInterface::RenameObjectMessage");
03005     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
03006   }
03007  }
03008  return 1;
03009 #ifndef TOLUA_RELEASE
03010  tolua_lerror:
03011  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
03012  return 0;
03013 #endif
03014 }
03015 #endif //#ifndef TOLUA_DISABLE
03016 
03017 /* method: new of class  RenameObjectMessage */
03018 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RenameObjectMessage_new01
03019 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RenameObjectMessage_new01(lua_State* tolua_S)
03020 {
03021  tolua_Error tolua_err;
03022  if (
03023      !tolua_isusertable(tolua_S,1,"fawkes::OpenRaveInterface::RenameObjectMessage",0,&tolua_err) ||
03024      !tolua_isnoobj(tolua_S,2,&tolua_err)
03025  )
03026   goto tolua_lerror;
03027  else
03028  {
03029   {
03030    fawkes::OpenRaveInterface::RenameObjectMessage* tolua_ret = (fawkes::OpenRaveInterface::RenameObjectMessage*)  Mtolua_new((fawkes::OpenRaveInterface::RenameObjectMessage)());
03031     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::OpenRaveInterface::RenameObjectMessage");
03032   }
03033  }
03034  return 1;
03035 tolua_lerror:
03036  return tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RenameObjectMessage_new00(tolua_S);
03037 }
03038 #endif //#ifndef TOLUA_DISABLE
03039 
03040 /* method: new_local of class  RenameObjectMessage */
03041 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RenameObjectMessage_new01_local
03042 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RenameObjectMessage_new01_local(lua_State* tolua_S)
03043 {
03044  tolua_Error tolua_err;
03045  if (
03046      !tolua_isusertable(tolua_S,1,"fawkes::OpenRaveInterface::RenameObjectMessage",0,&tolua_err) ||
03047      !tolua_isnoobj(tolua_S,2,&tolua_err)
03048  )
03049   goto tolua_lerror;
03050  else
03051  {
03052   {
03053    fawkes::OpenRaveInterface::RenameObjectMessage* tolua_ret = (fawkes::OpenRaveInterface::RenameObjectMessage*)  Mtolua_new((fawkes::OpenRaveInterface::RenameObjectMessage)());
03054     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::OpenRaveInterface::RenameObjectMessage");
03055     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
03056   }
03057  }
03058  return 1;
03059 tolua_lerror:
03060  return tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RenameObjectMessage_new00_local(tolua_S);
03061 }
03062 #endif //#ifndef TOLUA_DISABLE
03063 
03064 /* method: delete of class  RenameObjectMessage */
03065 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RenameObjectMessage_delete00
03066 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RenameObjectMessage_delete00(lua_State* tolua_S)
03067 {
03068 #ifndef TOLUA_RELEASE
03069  tolua_Error tolua_err;
03070  if (
03071      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface::RenameObjectMessage",0,&tolua_err) ||
03072      !tolua_isnoobj(tolua_S,2,&tolua_err)
03073  )
03074   goto tolua_lerror;
03075  else
03076 #endif
03077  {
03078   fawkes::OpenRaveInterface::RenameObjectMessage* self = (fawkes::OpenRaveInterface::RenameObjectMessage*)  tolua_tousertype(tolua_S,1,0);
03079 #ifndef TOLUA_RELEASE
03080   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
03081 #endif
03082   Mtolua_delete(self);
03083  }
03084  return 0;
03085 #ifndef TOLUA_RELEASE
03086  tolua_lerror:
03087  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
03088  return 0;
03089 #endif
03090 }
03091 #endif //#ifndef TOLUA_DISABLE
03092 
03093 /* method: name of class  RenameObjectMessage */
03094 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RenameObjectMessage_name00
03095 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RenameObjectMessage_name00(lua_State* tolua_S)
03096 {
03097 #ifndef TOLUA_RELEASE
03098  tolua_Error tolua_err;
03099  if (
03100      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface::RenameObjectMessage",0,&tolua_err) ||
03101      !tolua_isnoobj(tolua_S,2,&tolua_err)
03102  )
03103   goto tolua_lerror;
03104  else
03105 #endif
03106  {
03107   fawkes::OpenRaveInterface::RenameObjectMessage* self = (fawkes::OpenRaveInterface::RenameObjectMessage*)  tolua_tousertype(tolua_S,1,0);
03108 #ifndef TOLUA_RELEASE
03109   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'name'", NULL);
03110 #endif
03111   {
03112    char* tolua_ret = (char*)  self->name();
03113    tolua_pushstring(tolua_S,(const char*)tolua_ret);
03114   }
03115  }
03116  return 1;
03117 #ifndef TOLUA_RELEASE
03118  tolua_lerror:
03119  tolua_error(tolua_S,"#ferror in function 'name'.",&tolua_err);
03120  return 0;
03121 #endif
03122 }
03123 #endif //#ifndef TOLUA_DISABLE
03124 
03125 /* method: set_name of class  RenameObjectMessage */
03126 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RenameObjectMessage_set_name00
03127 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RenameObjectMessage_set_name00(lua_State* tolua_S)
03128 {
03129 #ifndef TOLUA_RELEASE
03130  tolua_Error tolua_err;
03131  if (
03132      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface::RenameObjectMessage",0,&tolua_err) ||
03133      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
03134      !tolua_isnoobj(tolua_S,3,&tolua_err)
03135  )
03136   goto tolua_lerror;
03137  else
03138 #endif
03139  {
03140   fawkes::OpenRaveInterface::RenameObjectMessage* self = (fawkes::OpenRaveInterface::RenameObjectMessage*)  tolua_tousertype(tolua_S,1,0);
03141   const char* new_name = ((const char*)  tolua_tostring(tolua_S,2,0));
03142 #ifndef TOLUA_RELEASE
03143   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_name'", NULL);
03144 #endif
03145   {
03146    self->set_name(new_name);
03147   }
03148  }
03149  return 0;
03150 #ifndef TOLUA_RELEASE
03151  tolua_lerror:
03152  tolua_error(tolua_S,"#ferror in function 'set_name'.",&tolua_err);
03153  return 0;
03154 #endif
03155 }
03156 #endif //#ifndef TOLUA_DISABLE
03157 
03158 /* method: maxlenof_name of class  RenameObjectMessage */
03159 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RenameObjectMessage_maxlenof_name00
03160 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RenameObjectMessage_maxlenof_name00(lua_State* tolua_S)
03161 {
03162 #ifndef TOLUA_RELEASE
03163  tolua_Error tolua_err;
03164  if (
03165      !tolua_isusertype(tolua_S,1,"const fawkes::OpenRaveInterface::RenameObjectMessage",0,&tolua_err) ||
03166      !tolua_isnoobj(tolua_S,2,&tolua_err)
03167  )
03168   goto tolua_lerror;
03169  else
03170 #endif
03171  {
03172   const fawkes::OpenRaveInterface::RenameObjectMessage* self = (const fawkes::OpenRaveInterface::RenameObjectMessage*)  tolua_tousertype(tolua_S,1,0);
03173 #ifndef TOLUA_RELEASE
03174   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_name'", NULL);
03175 #endif
03176   {
03177    int tolua_ret = (int)  self->maxlenof_name();
03178    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03179   }
03180  }
03181  return 1;
03182 #ifndef TOLUA_RELEASE
03183  tolua_lerror:
03184  tolua_error(tolua_S,"#ferror in function 'maxlenof_name'.",&tolua_err);
03185  return 0;
03186 #endif
03187 }
03188 #endif //#ifndef TOLUA_DISABLE
03189 
03190 /* method: newName of class  RenameObjectMessage */
03191 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RenameObjectMessage_newName00
03192 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RenameObjectMessage_newName00(lua_State* tolua_S)
03193 {
03194 #ifndef TOLUA_RELEASE
03195  tolua_Error tolua_err;
03196  if (
03197      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface::RenameObjectMessage",0,&tolua_err) ||
03198      !tolua_isnoobj(tolua_S,2,&tolua_err)
03199  )
03200   goto tolua_lerror;
03201  else
03202 #endif
03203  {
03204   fawkes::OpenRaveInterface::RenameObjectMessage* self = (fawkes::OpenRaveInterface::RenameObjectMessage*)  tolua_tousertype(tolua_S,1,0);
03205 #ifndef TOLUA_RELEASE
03206   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'newName'", NULL);
03207 #endif
03208   {
03209    char* tolua_ret = (char*)  self->newName();
03210    tolua_pushstring(tolua_S,(const char*)tolua_ret);
03211   }
03212  }
03213  return 1;
03214 #ifndef TOLUA_RELEASE
03215  tolua_lerror:
03216  tolua_error(tolua_S,"#ferror in function 'newName'.",&tolua_err);
03217  return 0;
03218 #endif
03219 }
03220 #endif //#ifndef TOLUA_DISABLE
03221 
03222 /* method: set_newName of class  RenameObjectMessage */
03223 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RenameObjectMessage_set_newName00
03224 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RenameObjectMessage_set_newName00(lua_State* tolua_S)
03225 {
03226 #ifndef TOLUA_RELEASE
03227  tolua_Error tolua_err;
03228  if (
03229      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface::RenameObjectMessage",0,&tolua_err) ||
03230      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
03231      !tolua_isnoobj(tolua_S,3,&tolua_err)
03232  )
03233   goto tolua_lerror;
03234  else
03235 #endif
03236  {
03237   fawkes::OpenRaveInterface::RenameObjectMessage* self = (fawkes::OpenRaveInterface::RenameObjectMessage*)  tolua_tousertype(tolua_S,1,0);
03238   const char* new_newName = ((const char*)  tolua_tostring(tolua_S,2,0));
03239 #ifndef TOLUA_RELEASE
03240   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_newName'", NULL);
03241 #endif
03242   {
03243    self->set_newName(new_newName);
03244   }
03245  }
03246  return 0;
03247 #ifndef TOLUA_RELEASE
03248  tolua_lerror:
03249  tolua_error(tolua_S,"#ferror in function 'set_newName'.",&tolua_err);
03250  return 0;
03251 #endif
03252 }
03253 #endif //#ifndef TOLUA_DISABLE
03254 
03255 /* method: maxlenof_newName of class  RenameObjectMessage */
03256 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RenameObjectMessage_maxlenof_newName00
03257 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RenameObjectMessage_maxlenof_newName00(lua_State* tolua_S)
03258 {
03259 #ifndef TOLUA_RELEASE
03260  tolua_Error tolua_err;
03261  if (
03262      !tolua_isusertype(tolua_S,1,"const fawkes::OpenRaveInterface::RenameObjectMessage",0,&tolua_err) ||
03263      !tolua_isnoobj(tolua_S,2,&tolua_err)
03264  )
03265   goto tolua_lerror;
03266  else
03267 #endif
03268  {
03269   const fawkes::OpenRaveInterface::RenameObjectMessage* self = (const fawkes::OpenRaveInterface::RenameObjectMessage*)  tolua_tousertype(tolua_S,1,0);
03270 #ifndef TOLUA_RELEASE
03271   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_newName'", NULL);
03272 #endif
03273   {
03274    int tolua_ret = (int)  self->maxlenof_newName();
03275    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03276   }
03277  }
03278  return 1;
03279 #ifndef TOLUA_RELEASE
03280  tolua_lerror:
03281  tolua_error(tolua_S,"#ferror in function 'maxlenof_newName'.",&tolua_err);
03282  return 0;
03283 #endif
03284 }
03285 #endif //#ifndef TOLUA_DISABLE
03286 
03287 /* method: msgid of class  fawkes::OpenRaveInterface */
03288 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_msgid00
03289 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_msgid00(lua_State* tolua_S)
03290 {
03291 #ifndef TOLUA_RELEASE
03292  tolua_Error tolua_err;
03293  if (
03294      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface",0,&tolua_err) ||
03295      !tolua_isnoobj(tolua_S,2,&tolua_err)
03296  )
03297   goto tolua_lerror;
03298  else
03299 #endif
03300  {
03301   fawkes::OpenRaveInterface* self = (fawkes::OpenRaveInterface*)  tolua_tousertype(tolua_S,1,0);
03302 #ifndef TOLUA_RELEASE
03303   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgid'", NULL);
03304 #endif
03305   {
03306    unsigned int tolua_ret = (unsigned int)  self->msgid();
03307    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03308   }
03309  }
03310  return 1;
03311 #ifndef TOLUA_RELEASE
03312  tolua_lerror:
03313  tolua_error(tolua_S,"#ferror in function 'msgid'.",&tolua_err);
03314  return 0;
03315 #endif
03316 }
03317 #endif //#ifndef TOLUA_DISABLE
03318 
03319 /* method: set_msgid of class  fawkes::OpenRaveInterface */
03320 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_set_msgid00
03321 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_set_msgid00(lua_State* tolua_S)
03322 {
03323 #ifndef TOLUA_RELEASE
03324  tolua_Error tolua_err;
03325  if (
03326      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface",0,&tolua_err) ||
03327      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
03328      !tolua_isnoobj(tolua_S,3,&tolua_err)
03329  )
03330   goto tolua_lerror;
03331  else
03332 #endif
03333  {
03334   fawkes::OpenRaveInterface* self = (fawkes::OpenRaveInterface*)  tolua_tousertype(tolua_S,1,0);
03335   unsigned const int new_msgid = ((unsigned const int)  tolua_tonumber(tolua_S,2,0));
03336 #ifndef TOLUA_RELEASE
03337   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_msgid'", NULL);
03338 #endif
03339   {
03340    self->set_msgid(new_msgid);
03341   }
03342  }
03343  return 0;
03344 #ifndef TOLUA_RELEASE
03345  tolua_lerror:
03346  tolua_error(tolua_S,"#ferror in function 'set_msgid'.",&tolua_err);
03347  return 0;
03348 #endif
03349 }
03350 #endif //#ifndef TOLUA_DISABLE
03351 
03352 /* method: maxlenof_msgid of class  fawkes::OpenRaveInterface */
03353 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_maxlenof_msgid00
03354 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_maxlenof_msgid00(lua_State* tolua_S)
03355 {
03356 #ifndef TOLUA_RELEASE
03357  tolua_Error tolua_err;
03358  if (
03359      !tolua_isusertype(tolua_S,1,"const fawkes::OpenRaveInterface",0,&tolua_err) ||
03360      !tolua_isnoobj(tolua_S,2,&tolua_err)
03361  )
03362   goto tolua_lerror;
03363  else
03364 #endif
03365  {
03366   const fawkes::OpenRaveInterface* self = (const fawkes::OpenRaveInterface*)  tolua_tousertype(tolua_S,1,0);
03367 #ifndef TOLUA_RELEASE
03368   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_msgid'", NULL);
03369 #endif
03370   {
03371    int tolua_ret = (int)  self->maxlenof_msgid();
03372    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03373   }
03374  }
03375  return 1;
03376 #ifndef TOLUA_RELEASE
03377  tolua_lerror:
03378  tolua_error(tolua_S,"#ferror in function 'maxlenof_msgid'.",&tolua_err);
03379  return 0;
03380 #endif
03381 }
03382 #endif //#ifndef TOLUA_DISABLE
03383 
03384 /* method: is_final of class  fawkes::OpenRaveInterface */
03385 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_is_final00
03386 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_is_final00(lua_State* tolua_S)
03387 {
03388 #ifndef TOLUA_RELEASE
03389  tolua_Error tolua_err;
03390  if (
03391      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface",0,&tolua_err) ||
03392      !tolua_isnoobj(tolua_S,2,&tolua_err)
03393  )
03394   goto tolua_lerror;
03395  else
03396 #endif
03397  {
03398   fawkes::OpenRaveInterface* self = (fawkes::OpenRaveInterface*)  tolua_tousertype(tolua_S,1,0);
03399 #ifndef TOLUA_RELEASE
03400   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_final'", NULL);
03401 #endif
03402   {
03403    bool tolua_ret = (bool)  self->is_final();
03404    tolua_pushboolean(tolua_S,(bool)tolua_ret);
03405   }
03406  }
03407  return 1;
03408 #ifndef TOLUA_RELEASE
03409  tolua_lerror:
03410  tolua_error(tolua_S,"#ferror in function 'is_final'.",&tolua_err);
03411  return 0;
03412 #endif
03413 }
03414 #endif //#ifndef TOLUA_DISABLE
03415 
03416 /* method: set_final of class  fawkes::OpenRaveInterface */
03417 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_set_final00
03418 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_set_final00(lua_State* tolua_S)
03419 {
03420 #ifndef TOLUA_RELEASE
03421  tolua_Error tolua_err;
03422  if (
03423      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface",0,&tolua_err) ||
03424      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
03425      !tolua_isnoobj(tolua_S,3,&tolua_err)
03426  )
03427   goto tolua_lerror;
03428  else
03429 #endif
03430  {
03431   fawkes::OpenRaveInterface* self = (fawkes::OpenRaveInterface*)  tolua_tousertype(tolua_S,1,0);
03432   const bool new_final = ((const bool)  tolua_toboolean(tolua_S,2,0));
03433 #ifndef TOLUA_RELEASE
03434   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_final'", NULL);
03435 #endif
03436   {
03437    self->set_final(new_final);
03438   }
03439  }
03440  return 0;
03441 #ifndef TOLUA_RELEASE
03442  tolua_lerror:
03443  tolua_error(tolua_S,"#ferror in function 'set_final'.",&tolua_err);
03444  return 0;
03445 #endif
03446 }
03447 #endif //#ifndef TOLUA_DISABLE
03448 
03449 /* method: maxlenof_final of class  fawkes::OpenRaveInterface */
03450 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_maxlenof_final00
03451 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_maxlenof_final00(lua_State* tolua_S)
03452 {
03453 #ifndef TOLUA_RELEASE
03454  tolua_Error tolua_err;
03455  if (
03456      !tolua_isusertype(tolua_S,1,"const fawkes::OpenRaveInterface",0,&tolua_err) ||
03457      !tolua_isnoobj(tolua_S,2,&tolua_err)
03458  )
03459   goto tolua_lerror;
03460  else
03461 #endif
03462  {
03463   const fawkes::OpenRaveInterface* self = (const fawkes::OpenRaveInterface*)  tolua_tousertype(tolua_S,1,0);
03464 #ifndef TOLUA_RELEASE
03465   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_final'", NULL);
03466 #endif
03467   {
03468    int tolua_ret = (int)  self->maxlenof_final();
03469    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03470   }
03471  }
03472  return 1;
03473 #ifndef TOLUA_RELEASE
03474  tolua_lerror:
03475  tolua_error(tolua_S,"#ferror in function 'maxlenof_final'.",&tolua_err);
03476  return 0;
03477 #endif
03478 }
03479 #endif //#ifndef TOLUA_DISABLE
03480 
03481 /* method: error_code of class  fawkes::OpenRaveInterface */
03482 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_error_code00
03483 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_error_code00(lua_State* tolua_S)
03484 {
03485 #ifndef TOLUA_RELEASE
03486  tolua_Error tolua_err;
03487  if (
03488      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface",0,&tolua_err) ||
03489      !tolua_isnoobj(tolua_S,2,&tolua_err)
03490  )
03491   goto tolua_lerror;
03492  else
03493 #endif
03494  {
03495   fawkes::OpenRaveInterface* self = (fawkes::OpenRaveInterface*)  tolua_tousertype(tolua_S,1,0);
03496 #ifndef TOLUA_RELEASE
03497   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'error_code'", NULL);
03498 #endif
03499   {
03500    unsigned int tolua_ret = (unsigned int)  self->error_code();
03501    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03502   }
03503  }
03504  return 1;
03505 #ifndef TOLUA_RELEASE
03506  tolua_lerror:
03507  tolua_error(tolua_S,"#ferror in function 'error_code'.",&tolua_err);
03508  return 0;
03509 #endif
03510 }
03511 #endif //#ifndef TOLUA_DISABLE
03512 
03513 /* method: set_error_code of class  fawkes::OpenRaveInterface */
03514 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_set_error_code00
03515 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_set_error_code00(lua_State* tolua_S)
03516 {
03517 #ifndef TOLUA_RELEASE
03518  tolua_Error tolua_err;
03519  if (
03520      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface",0,&tolua_err) ||
03521      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
03522      !tolua_isnoobj(tolua_S,3,&tolua_err)
03523  )
03524   goto tolua_lerror;
03525  else
03526 #endif
03527  {
03528   fawkes::OpenRaveInterface* self = (fawkes::OpenRaveInterface*)  tolua_tousertype(tolua_S,1,0);
03529   unsigned const int new_error_code = ((unsigned const int)  tolua_tonumber(tolua_S,2,0));
03530 #ifndef TOLUA_RELEASE
03531   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_error_code'", NULL);
03532 #endif
03533   {
03534    self->set_error_code(new_error_code);
03535   }
03536  }
03537  return 0;
03538 #ifndef TOLUA_RELEASE
03539  tolua_lerror:
03540  tolua_error(tolua_S,"#ferror in function 'set_error_code'.",&tolua_err);
03541  return 0;
03542 #endif
03543 }
03544 #endif //#ifndef TOLUA_DISABLE
03545 
03546 /* method: maxlenof_error_code of class  fawkes::OpenRaveInterface */
03547 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_maxlenof_error_code00
03548 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_maxlenof_error_code00(lua_State* tolua_S)
03549 {
03550 #ifndef TOLUA_RELEASE
03551  tolua_Error tolua_err;
03552  if (
03553      !tolua_isusertype(tolua_S,1,"const fawkes::OpenRaveInterface",0,&tolua_err) ||
03554      !tolua_isnoobj(tolua_S,2,&tolua_err)
03555  )
03556   goto tolua_lerror;
03557  else
03558 #endif
03559  {
03560   const fawkes::OpenRaveInterface* self = (const fawkes::OpenRaveInterface*)  tolua_tousertype(tolua_S,1,0);
03561 #ifndef TOLUA_RELEASE
03562   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_error_code'", NULL);
03563 #endif
03564   {
03565    int tolua_ret = (int)  self->maxlenof_error_code();
03566    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03567   }
03568  }
03569  return 1;
03570 #ifndef TOLUA_RELEASE
03571  tolua_lerror:
03572  tolua_error(tolua_S,"#ferror in function 'maxlenof_error_code'.",&tolua_err);
03573  return 0;
03574 #endif
03575 }
03576 #endif //#ifndef TOLUA_DISABLE
03577 
03578 /* method: is_success of class  fawkes::OpenRaveInterface */
03579 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_is_success00
03580 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_is_success00(lua_State* tolua_S)
03581 {
03582 #ifndef TOLUA_RELEASE
03583  tolua_Error tolua_err;
03584  if (
03585      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface",0,&tolua_err) ||
03586      !tolua_isnoobj(tolua_S,2,&tolua_err)
03587  )
03588   goto tolua_lerror;
03589  else
03590 #endif
03591  {
03592   fawkes::OpenRaveInterface* self = (fawkes::OpenRaveInterface*)  tolua_tousertype(tolua_S,1,0);
03593 #ifndef TOLUA_RELEASE
03594   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_success'", NULL);
03595 #endif
03596   {
03597    bool tolua_ret = (bool)  self->is_success();
03598    tolua_pushboolean(tolua_S,(bool)tolua_ret);
03599   }
03600  }
03601  return 1;
03602 #ifndef TOLUA_RELEASE
03603  tolua_lerror:
03604  tolua_error(tolua_S,"#ferror in function 'is_success'.",&tolua_err);
03605  return 0;
03606 #endif
03607 }
03608 #endif //#ifndef TOLUA_DISABLE
03609 
03610 /* method: set_success of class  fawkes::OpenRaveInterface */
03611 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_set_success00
03612 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_set_success00(lua_State* tolua_S)
03613 {
03614 #ifndef TOLUA_RELEASE
03615  tolua_Error tolua_err;
03616  if (
03617      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface",0,&tolua_err) ||
03618      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
03619      !tolua_isnoobj(tolua_S,3,&tolua_err)
03620  )
03621   goto tolua_lerror;
03622  else
03623 #endif
03624  {
03625   fawkes::OpenRaveInterface* self = (fawkes::OpenRaveInterface*)  tolua_tousertype(tolua_S,1,0);
03626   const bool new_success = ((const bool)  tolua_toboolean(tolua_S,2,0));
03627 #ifndef TOLUA_RELEASE
03628   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_success'", NULL);
03629 #endif
03630   {
03631    self->set_success(new_success);
03632   }
03633  }
03634  return 0;
03635 #ifndef TOLUA_RELEASE
03636  tolua_lerror:
03637  tolua_error(tolua_S,"#ferror in function 'set_success'.",&tolua_err);
03638  return 0;
03639 #endif
03640 }
03641 #endif //#ifndef TOLUA_DISABLE
03642 
03643 /* method: maxlenof_success of class  fawkes::OpenRaveInterface */
03644 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_maxlenof_success00
03645 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_maxlenof_success00(lua_State* tolua_S)
03646 {
03647 #ifndef TOLUA_RELEASE
03648  tolua_Error tolua_err;
03649  if (
03650      !tolua_isusertype(tolua_S,1,"const fawkes::OpenRaveInterface",0,&tolua_err) ||
03651      !tolua_isnoobj(tolua_S,2,&tolua_err)
03652  )
03653   goto tolua_lerror;
03654  else
03655 #endif
03656  {
03657   const fawkes::OpenRaveInterface* self = (const fawkes::OpenRaveInterface*)  tolua_tousertype(tolua_S,1,0);
03658 #ifndef TOLUA_RELEASE
03659   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_success'", NULL);
03660 #endif
03661   {
03662    int tolua_ret = (int)  self->maxlenof_success();
03663    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03664   }
03665  }
03666  return 1;
03667 #ifndef TOLUA_RELEASE
03668  tolua_lerror:
03669  tolua_error(tolua_S,"#ferror in function 'maxlenof_success'.",&tolua_err);
03670  return 0;
03671 #endif
03672 }
03673 #endif //#ifndef TOLUA_DISABLE
03674 
03675 /* method: oftype of class  fawkes::OpenRaveInterface */
03676 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_oftype00
03677 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_oftype00(lua_State* tolua_S)
03678 {
03679 #ifndef TOLUA_RELEASE
03680  tolua_Error tolua_err;
03681  if (
03682      !tolua_isusertype(tolua_S,1,"const fawkes::OpenRaveInterface",0,&tolua_err) ||
03683      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
03684      !tolua_isnoobj(tolua_S,3,&tolua_err)
03685  )
03686   goto tolua_lerror;
03687  else
03688 #endif
03689  {
03690   const fawkes::OpenRaveInterface* self = (const fawkes::OpenRaveInterface*)  tolua_tousertype(tolua_S,1,0);
03691   const char* interface_type = ((const char*)  tolua_tostring(tolua_S,2,0));
03692 #ifndef TOLUA_RELEASE
03693   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'oftype'", NULL);
03694 #endif
03695   {
03696    bool tolua_ret = (bool)  self->oftype(interface_type);
03697    tolua_pushboolean(tolua_S,(bool)tolua_ret);
03698   }
03699  }
03700  return 1;
03701 #ifndef TOLUA_RELEASE
03702  tolua_lerror:
03703  tolua_error(tolua_S,"#ferror in function 'oftype'.",&tolua_err);
03704  return 0;
03705 #endif
03706 }
03707 #endif //#ifndef TOLUA_DISABLE
03708 
03709 /* method: datachunk of class  fawkes::OpenRaveInterface */
03710 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_datachunk00
03711 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_datachunk00(lua_State* tolua_S)
03712 {
03713 #ifndef TOLUA_RELEASE
03714  tolua_Error tolua_err;
03715  if (
03716      !tolua_isusertype(tolua_S,1,"const fawkes::OpenRaveInterface",0,&tolua_err) ||
03717      !tolua_isnoobj(tolua_S,2,&tolua_err)
03718  )
03719   goto tolua_lerror;
03720  else
03721 #endif
03722  {
03723   const fawkes::OpenRaveInterface* self = (const fawkes::OpenRaveInterface*)  tolua_tousertype(tolua_S,1,0);
03724 #ifndef TOLUA_RELEASE
03725   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datachunk'", NULL);
03726 #endif
03727   {
03728    const void* tolua_ret = (const void*)  self->datachunk();
03729    tolua_pushuserdata(tolua_S,(void*)tolua_ret);
03730   }
03731  }
03732  return 1;
03733 #ifndef TOLUA_RELEASE
03734  tolua_lerror:
03735  tolua_error(tolua_S,"#ferror in function 'datachunk'.",&tolua_err);
03736  return 0;
03737 #endif
03738 }
03739 #endif //#ifndef TOLUA_DISABLE
03740 
03741 /* method: datasize of class  fawkes::OpenRaveInterface */
03742 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_datasize00
03743 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_datasize00(lua_State* tolua_S)
03744 {
03745 #ifndef TOLUA_RELEASE
03746  tolua_Error tolua_err;
03747  if (
03748      !tolua_isusertype(tolua_S,1,"const fawkes::OpenRaveInterface",0,&tolua_err) ||
03749      !tolua_isnoobj(tolua_S,2,&tolua_err)
03750  )
03751   goto tolua_lerror;
03752  else
03753 #endif
03754  {
03755   const fawkes::OpenRaveInterface* self = (const fawkes::OpenRaveInterface*)  tolua_tousertype(tolua_S,1,0);
03756 #ifndef TOLUA_RELEASE
03757   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datasize'", NULL);
03758 #endif
03759   {
03760    unsigned int tolua_ret = (unsigned int)  self->datasize();
03761    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03762   }
03763  }
03764  return 1;
03765 #ifndef TOLUA_RELEASE
03766  tolua_lerror:
03767  tolua_error(tolua_S,"#ferror in function 'datasize'.",&tolua_err);
03768  return 0;
03769 #endif
03770 }
03771 #endif //#ifndef TOLUA_DISABLE
03772 
03773 /* method: type of class  fawkes::OpenRaveInterface */
03774 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_type00
03775 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_type00(lua_State* tolua_S)
03776 {
03777 #ifndef TOLUA_RELEASE
03778  tolua_Error tolua_err;
03779  if (
03780      !tolua_isusertype(tolua_S,1,"const fawkes::OpenRaveInterface",0,&tolua_err) ||
03781      !tolua_isnoobj(tolua_S,2,&tolua_err)
03782  )
03783   goto tolua_lerror;
03784  else
03785 #endif
03786  {
03787   const fawkes::OpenRaveInterface* self = (const fawkes::OpenRaveInterface*)  tolua_tousertype(tolua_S,1,0);
03788 #ifndef TOLUA_RELEASE
03789   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'type'", NULL);
03790 #endif
03791   {
03792    const char* tolua_ret = (const char*)  self->type();
03793    tolua_pushstring(tolua_S,(const char*)tolua_ret);
03794   }
03795  }
03796  return 1;
03797 #ifndef TOLUA_RELEASE
03798  tolua_lerror:
03799  tolua_error(tolua_S,"#ferror in function 'type'.",&tolua_err);
03800  return 0;
03801 #endif
03802 }
03803 #endif //#ifndef TOLUA_DISABLE
03804 
03805 /* method: id of class  fawkes::OpenRaveInterface */
03806 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_id00
03807 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_id00(lua_State* tolua_S)
03808 {
03809 #ifndef TOLUA_RELEASE
03810  tolua_Error tolua_err;
03811  if (
03812      !tolua_isusertype(tolua_S,1,"const fawkes::OpenRaveInterface",0,&tolua_err) ||
03813      !tolua_isnoobj(tolua_S,2,&tolua_err)
03814  )
03815   goto tolua_lerror;
03816  else
03817 #endif
03818  {
03819   const fawkes::OpenRaveInterface* self = (const fawkes::OpenRaveInterface*)  tolua_tousertype(tolua_S,1,0);
03820 #ifndef TOLUA_RELEASE
03821   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'id'", NULL);
03822 #endif
03823   {
03824    const char* tolua_ret = (const char*)  self->id();
03825    tolua_pushstring(tolua_S,(const char*)tolua_ret);
03826   }
03827  }
03828  return 1;
03829 #ifndef TOLUA_RELEASE
03830  tolua_lerror:
03831  tolua_error(tolua_S,"#ferror in function 'id'.",&tolua_err);
03832  return 0;
03833 #endif
03834 }
03835 #endif //#ifndef TOLUA_DISABLE
03836 
03837 /* method: uid of class  fawkes::OpenRaveInterface */
03838 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_uid00
03839 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_uid00(lua_State* tolua_S)
03840 {
03841 #ifndef TOLUA_RELEASE
03842  tolua_Error tolua_err;
03843  if (
03844      !tolua_isusertype(tolua_S,1,"const fawkes::OpenRaveInterface",0,&tolua_err) ||
03845      !tolua_isnoobj(tolua_S,2,&tolua_err)
03846  )
03847   goto tolua_lerror;
03848  else
03849 #endif
03850  {
03851   const fawkes::OpenRaveInterface* self = (const fawkes::OpenRaveInterface*)  tolua_tousertype(tolua_S,1,0);
03852 #ifndef TOLUA_RELEASE
03853   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'uid'", NULL);
03854 #endif
03855   {
03856    const char* tolua_ret = (const char*)  self->uid();
03857    tolua_pushstring(tolua_S,(const char*)tolua_ret);
03858   }
03859  }
03860  return 1;
03861 #ifndef TOLUA_RELEASE
03862  tolua_lerror:
03863  tolua_error(tolua_S,"#ferror in function 'uid'.",&tolua_err);
03864  return 0;
03865 #endif
03866 }
03867 #endif //#ifndef TOLUA_DISABLE
03868 
03869 /* method: serial of class  fawkes::OpenRaveInterface */
03870 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_serial00
03871 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_serial00(lua_State* tolua_S)
03872 {
03873 #ifndef TOLUA_RELEASE
03874  tolua_Error tolua_err;
03875  if (
03876      !tolua_isusertype(tolua_S,1,"const fawkes::OpenRaveInterface",0,&tolua_err) ||
03877      !tolua_isnoobj(tolua_S,2,&tolua_err)
03878  )
03879   goto tolua_lerror;
03880  else
03881 #endif
03882  {
03883   const fawkes::OpenRaveInterface* self = (const fawkes::OpenRaveInterface*)  tolua_tousertype(tolua_S,1,0);
03884 #ifndef TOLUA_RELEASE
03885   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'serial'", NULL);
03886 #endif
03887   {
03888    unsigned int tolua_ret = (unsigned int)  self->serial();
03889    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03890   }
03891  }
03892  return 1;
03893 #ifndef TOLUA_RELEASE
03894  tolua_lerror:
03895  tolua_error(tolua_S,"#ferror in function 'serial'.",&tolua_err);
03896  return 0;
03897 #endif
03898 }
03899 #endif //#ifndef TOLUA_DISABLE
03900 
03901 /* method: mem_serial of class  fawkes::OpenRaveInterface */
03902 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_mem_serial00
03903 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_mem_serial00(lua_State* tolua_S)
03904 {
03905 #ifndef TOLUA_RELEASE
03906  tolua_Error tolua_err;
03907  if (
03908      !tolua_isusertype(tolua_S,1,"const fawkes::OpenRaveInterface",0,&tolua_err) ||
03909      !tolua_isnoobj(tolua_S,2,&tolua_err)
03910  )
03911   goto tolua_lerror;
03912  else
03913 #endif
03914  {
03915   const fawkes::OpenRaveInterface* self = (const fawkes::OpenRaveInterface*)  tolua_tousertype(tolua_S,1,0);
03916 #ifndef TOLUA_RELEASE
03917   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'mem_serial'", NULL);
03918 #endif
03919   {
03920    unsigned int tolua_ret = (unsigned int)  self->mem_serial();
03921    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03922   }
03923  }
03924  return 1;
03925 #ifndef TOLUA_RELEASE
03926  tolua_lerror:
03927  tolua_error(tolua_S,"#ferror in function 'mem_serial'.",&tolua_err);
03928  return 0;
03929 #endif
03930 }
03931 #endif //#ifndef TOLUA_DISABLE
03932 
03933 /* method: operator== of class  fawkes::OpenRaveInterface */
03934 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface__eq00
03935 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface__eq00(lua_State* tolua_S)
03936 {
03937 #ifndef TOLUA_RELEASE
03938  tolua_Error tolua_err;
03939  if (
03940      !tolua_isusertype(tolua_S,1,"const fawkes::OpenRaveInterface",0,&tolua_err) ||
03941      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Interface",0,&tolua_err)) ||
03942      !tolua_isnoobj(tolua_S,3,&tolua_err)
03943  )
03944   goto tolua_lerror;
03945  else
03946 #endif
03947  {
03948   const fawkes::OpenRaveInterface* self = (const fawkes::OpenRaveInterface*)  tolua_tousertype(tolua_S,1,0);
03949   Interface* comp = ((Interface*)  tolua_tousertype(tolua_S,2,0));
03950 #ifndef TOLUA_RELEASE
03951   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='", NULL);
03952 #endif
03953   {
03954    bool tolua_ret = (bool)  self->operator==(*comp);
03955    tolua_pushboolean(tolua_S,(bool)tolua_ret);
03956   }
03957  }
03958  return 1;
03959 #ifndef TOLUA_RELEASE
03960  tolua_lerror:
03961  tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err);
03962  return 0;
03963 #endif
03964 }
03965 #endif //#ifndef TOLUA_DISABLE
03966 
03967 /* method: hash of class  fawkes::OpenRaveInterface */
03968 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_hash00
03969 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_hash00(lua_State* tolua_S)
03970 {
03971 #ifndef TOLUA_RELEASE
03972  tolua_Error tolua_err;
03973  if (
03974      !tolua_isusertype(tolua_S,1,"const fawkes::OpenRaveInterface",0,&tolua_err) ||
03975      !tolua_isnoobj(tolua_S,2,&tolua_err)
03976  )
03977   goto tolua_lerror;
03978  else
03979 #endif
03980  {
03981   const fawkes::OpenRaveInterface* self = (const fawkes::OpenRaveInterface*)  tolua_tousertype(tolua_S,1,0);
03982 #ifndef TOLUA_RELEASE
03983   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash'", NULL);
03984 #endif
03985   {
03986    unsigned const char* tolua_ret = ( unsigned const char*)  self->hash();
03987    tolua_pushstring(tolua_S,(const char*)tolua_ret);
03988   }
03989  }
03990  return 1;
03991 #ifndef TOLUA_RELEASE
03992  tolua_lerror:
03993  tolua_error(tolua_S,"#ferror in function 'hash'.",&tolua_err);
03994  return 0;
03995 #endif
03996 }
03997 #endif //#ifndef TOLUA_DISABLE
03998 
03999 /* method: hash_size of class  fawkes::OpenRaveInterface */
04000 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_hash_size00
04001 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_hash_size00(lua_State* tolua_S)
04002 {
04003 #ifndef TOLUA_RELEASE
04004  tolua_Error tolua_err;
04005  if (
04006      !tolua_isusertype(tolua_S,1,"const fawkes::OpenRaveInterface",0,&tolua_err) ||
04007      !tolua_isnoobj(tolua_S,2,&tolua_err)
04008  )
04009   goto tolua_lerror;
04010  else
04011 #endif
04012  {
04013   const fawkes::OpenRaveInterface* self = (const fawkes::OpenRaveInterface*)  tolua_tousertype(tolua_S,1,0);
04014 #ifndef TOLUA_RELEASE
04015   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash_size'", NULL);
04016 #endif
04017   {
04018    int tolua_ret = (int)  self->hash_size();
04019    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04020   }
04021  }
04022  return 1;
04023 #ifndef TOLUA_RELEASE
04024  tolua_lerror:
04025  tolua_error(tolua_S,"#ferror in function 'hash_size'.",&tolua_err);
04026  return 0;
04027 #endif
04028 }
04029 #endif //#ifndef TOLUA_DISABLE
04030 
04031 /* method: hash_printable of class  fawkes::OpenRaveInterface */
04032 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_hash_printable00
04033 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_hash_printable00(lua_State* tolua_S)
04034 {
04035 #ifndef TOLUA_RELEASE
04036  tolua_Error tolua_err;
04037  if (
04038      !tolua_isusertype(tolua_S,1,"const fawkes::OpenRaveInterface",0,&tolua_err) ||
04039      !tolua_isnoobj(tolua_S,2,&tolua_err)
04040  )
04041   goto tolua_lerror;
04042  else
04043 #endif
04044  {
04045   const fawkes::OpenRaveInterface* self = (const fawkes::OpenRaveInterface*)  tolua_tousertype(tolua_S,1,0);
04046 #ifndef TOLUA_RELEASE
04047   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash_printable'", NULL);
04048 #endif
04049   {
04050    const char* tolua_ret = (const char*)  self->hash_printable();
04051    tolua_pushstring(tolua_S,(const char*)tolua_ret);
04052   }
04053  }
04054  return 1;
04055 #ifndef TOLUA_RELEASE
04056  tolua_lerror:
04057  tolua_error(tolua_S,"#ferror in function 'hash_printable'.",&tolua_err);
04058  return 0;
04059 #endif
04060 }
04061 #endif //#ifndef TOLUA_DISABLE
04062 
04063 /* method: is_writer of class  fawkes::OpenRaveInterface */
04064 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_is_writer00
04065 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_is_writer00(lua_State* tolua_S)
04066 {
04067 #ifndef TOLUA_RELEASE
04068  tolua_Error tolua_err;
04069  if (
04070      !tolua_isusertype(tolua_S,1,"const fawkes::OpenRaveInterface",0,&tolua_err) ||
04071      !tolua_isnoobj(tolua_S,2,&tolua_err)
04072  )
04073   goto tolua_lerror;
04074  else
04075 #endif
04076  {
04077   const fawkes::OpenRaveInterface* self = (const fawkes::OpenRaveInterface*)  tolua_tousertype(tolua_S,1,0);
04078 #ifndef TOLUA_RELEASE
04079   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_writer'", NULL);
04080 #endif
04081   {
04082    bool tolua_ret = (bool)  self->is_writer();
04083    tolua_pushboolean(tolua_S,(bool)tolua_ret);
04084   }
04085  }
04086  return 1;
04087 #ifndef TOLUA_RELEASE
04088  tolua_lerror:
04089  tolua_error(tolua_S,"#ferror in function 'is_writer'.",&tolua_err);
04090  return 0;
04091 #endif
04092 }
04093 #endif //#ifndef TOLUA_DISABLE
04094 
04095 /* method: set_from_chunk of class  fawkes::OpenRaveInterface */
04096 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_set_from_chunk00
04097 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_set_from_chunk00(lua_State* tolua_S)
04098 {
04099 #ifndef TOLUA_RELEASE
04100  tolua_Error tolua_err;
04101  if (
04102      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface",0,&tolua_err) ||
04103      !tolua_isuserdata(tolua_S,2,0,&tolua_err) ||
04104      !tolua_isnoobj(tolua_S,3,&tolua_err)
04105  )
04106   goto tolua_lerror;
04107  else
04108 #endif
04109  {
04110   fawkes::OpenRaveInterface* self = (fawkes::OpenRaveInterface*)  tolua_tousertype(tolua_S,1,0);
04111   void* chunk = ((void*)  tolua_touserdata(tolua_S,2,0));
04112 #ifndef TOLUA_RELEASE
04113   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_from_chunk'", NULL);
04114 #endif
04115   {
04116    self->set_from_chunk(chunk);
04117   }
04118  }
04119  return 0;
04120 #ifndef TOLUA_RELEASE
04121  tolua_lerror:
04122  tolua_error(tolua_S,"#ferror in function 'set_from_chunk'.",&tolua_err);
04123  return 0;
04124 #endif
04125 }
04126 #endif //#ifndef TOLUA_DISABLE
04127 
04128 /* method: create_message of class  fawkes::OpenRaveInterface */
04129 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_create_message00
04130 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_create_message00(lua_State* tolua_S)
04131 {
04132 #ifndef TOLUA_RELEASE
04133  tolua_Error tolua_err;
04134  if (
04135      !tolua_isusertype(tolua_S,1,"const fawkes::OpenRaveInterface",0,&tolua_err) ||
04136      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
04137      !tolua_isnoobj(tolua_S,3,&tolua_err)
04138  )
04139   goto tolua_lerror;
04140  else
04141 #endif
04142  {
04143   const fawkes::OpenRaveInterface* self = (const fawkes::OpenRaveInterface*)  tolua_tousertype(tolua_S,1,0);
04144   const char* type = ((const char*)  tolua_tostring(tolua_S,2,0));
04145 #ifndef TOLUA_RELEASE
04146   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'create_message'", NULL);
04147 #endif
04148   {
04149    Message* tolua_ret = (Message*)  self->create_message(type);
04150     tolua_pushusertype(tolua_S,(void*)tolua_ret,"Message");
04151   }
04152  }
04153  return 1;
04154 #ifndef TOLUA_RELEASE
04155  tolua_lerror:
04156  tolua_error(tolua_S,"#ferror in function 'create_message'.",&tolua_err);
04157  return 0;
04158 #endif
04159 }
04160 #endif //#ifndef TOLUA_DISABLE
04161 
04162 /* method: read of class  fawkes::OpenRaveInterface */
04163 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_read00
04164 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_read00(lua_State* tolua_S)
04165 {
04166 #ifndef TOLUA_RELEASE
04167  tolua_Error tolua_err;
04168  if (
04169      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface",0,&tolua_err) ||
04170      !tolua_isnoobj(tolua_S,2,&tolua_err)
04171  )
04172   goto tolua_lerror;
04173  else
04174 #endif
04175  {
04176   fawkes::OpenRaveInterface* self = (fawkes::OpenRaveInterface*)  tolua_tousertype(tolua_S,1,0);
04177 #ifndef TOLUA_RELEASE
04178   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'read'", NULL);
04179 #endif
04180   {
04181    self->read();
04182   }
04183  }
04184  return 0;
04185 #ifndef TOLUA_RELEASE
04186  tolua_lerror:
04187  tolua_error(tolua_S,"#ferror in function 'read'.",&tolua_err);
04188  return 0;
04189 #endif
04190 }
04191 #endif //#ifndef TOLUA_DISABLE
04192 
04193 /* method: write of class  fawkes::OpenRaveInterface */
04194 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_write00
04195 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_write00(lua_State* tolua_S)
04196 {
04197 #ifndef TOLUA_RELEASE
04198  tolua_Error tolua_err;
04199  if (
04200      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface",0,&tolua_err) ||
04201      !tolua_isnoobj(tolua_S,2,&tolua_err)
04202  )
04203   goto tolua_lerror;
04204  else
04205 #endif
04206  {
04207   fawkes::OpenRaveInterface* self = (fawkes::OpenRaveInterface*)  tolua_tousertype(tolua_S,1,0);
04208 #ifndef TOLUA_RELEASE
04209   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'write'", NULL);
04210 #endif
04211   {
04212    self->write();
04213   }
04214  }
04215  return 0;
04216 #ifndef TOLUA_RELEASE
04217  tolua_lerror:
04218  tolua_error(tolua_S,"#ferror in function 'write'.",&tolua_err);
04219  return 0;
04220 #endif
04221 }
04222 #endif //#ifndef TOLUA_DISABLE
04223 
04224 /* method: has_writer of class  fawkes::OpenRaveInterface */
04225 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_has_writer00
04226 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_has_writer00(lua_State* tolua_S)
04227 {
04228 #ifndef TOLUA_RELEASE
04229  tolua_Error tolua_err;
04230  if (
04231      !tolua_isusertype(tolua_S,1,"const fawkes::OpenRaveInterface",0,&tolua_err) ||
04232      !tolua_isnoobj(tolua_S,2,&tolua_err)
04233  )
04234   goto tolua_lerror;
04235  else
04236 #endif
04237  {
04238   const fawkes::OpenRaveInterface* self = (const fawkes::OpenRaveInterface*)  tolua_tousertype(tolua_S,1,0);
04239 #ifndef TOLUA_RELEASE
04240   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'has_writer'", NULL);
04241 #endif
04242   {
04243    bool tolua_ret = (bool)  self->has_writer();
04244    tolua_pushboolean(tolua_S,(bool)tolua_ret);
04245   }
04246  }
04247  return 1;
04248 #ifndef TOLUA_RELEASE
04249  tolua_lerror:
04250  tolua_error(tolua_S,"#ferror in function 'has_writer'.",&tolua_err);
04251  return 0;
04252 #endif
04253 }
04254 #endif //#ifndef TOLUA_DISABLE
04255 
04256 /* method: num_readers of class  fawkes::OpenRaveInterface */
04257 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_num_readers00
04258 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_num_readers00(lua_State* tolua_S)
04259 {
04260 #ifndef TOLUA_RELEASE
04261  tolua_Error tolua_err;
04262  if (
04263      !tolua_isusertype(tolua_S,1,"const fawkes::OpenRaveInterface",0,&tolua_err) ||
04264      !tolua_isnoobj(tolua_S,2,&tolua_err)
04265  )
04266   goto tolua_lerror;
04267  else
04268 #endif
04269  {
04270   const fawkes::OpenRaveInterface* self = (const fawkes::OpenRaveInterface*)  tolua_tousertype(tolua_S,1,0);
04271 #ifndef TOLUA_RELEASE
04272   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'num_readers'", NULL);
04273 #endif
04274   {
04275    unsigned int tolua_ret = (unsigned int)  self->num_readers();
04276    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04277   }
04278  }
04279  return 1;
04280 #ifndef TOLUA_RELEASE
04281  tolua_lerror:
04282  tolua_error(tolua_S,"#ferror in function 'num_readers'.",&tolua_err);
04283  return 0;
04284 #endif
04285 }
04286 #endif //#ifndef TOLUA_DISABLE
04287 
04288 /* method: msgq_enqueue_copy of class  fawkes::OpenRaveInterface */
04289 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_msgq_enqueue_copy00
04290 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_msgq_enqueue_copy00(lua_State* tolua_S)
04291 {
04292 #ifndef TOLUA_RELEASE
04293  tolua_Error tolua_err;
04294  if (
04295      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface",0,&tolua_err) ||
04296      !tolua_isusertype(tolua_S,2,"Message",0,&tolua_err) ||
04297      !tolua_isnoobj(tolua_S,3,&tolua_err)
04298  )
04299   goto tolua_lerror;
04300  else
04301 #endif
04302  {
04303   fawkes::OpenRaveInterface* self = (fawkes::OpenRaveInterface*)  tolua_tousertype(tolua_S,1,0);
04304   Message* message = ((Message*)  tolua_tousertype(tolua_S,2,0));
04305 #ifndef TOLUA_RELEASE
04306   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_enqueue_copy'", NULL);
04307 #endif
04308   {
04309    unsigned int tolua_ret = (unsigned int)  self->msgq_enqueue_copy(message);
04310    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04311   }
04312  }
04313  return 1;
04314 #ifndef TOLUA_RELEASE
04315  tolua_lerror:
04316  tolua_error(tolua_S,"#ferror in function 'msgq_enqueue_copy'.",&tolua_err);
04317  return 0;
04318 #endif
04319 }
04320 #endif //#ifndef TOLUA_DISABLE
04321 
04322 /* method: msgq_remove of class  fawkes::OpenRaveInterface */
04323 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_msgq_remove00
04324 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_msgq_remove00(lua_State* tolua_S)
04325 {
04326 #ifndef TOLUA_RELEASE
04327  tolua_Error tolua_err;
04328  if (
04329      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface",0,&tolua_err) ||
04330      !tolua_isusertype(tolua_S,2,"Message",0,&tolua_err) ||
04331      !tolua_isnoobj(tolua_S,3,&tolua_err)
04332  )
04333   goto tolua_lerror;
04334  else
04335 #endif
04336  {
04337   fawkes::OpenRaveInterface* self = (fawkes::OpenRaveInterface*)  tolua_tousertype(tolua_S,1,0);
04338   Message* message = ((Message*)  tolua_tousertype(tolua_S,2,0));
04339 #ifndef TOLUA_RELEASE
04340   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_remove'", NULL);
04341 #endif
04342   {
04343    self->msgq_remove(message);
04344   }
04345  }
04346  return 0;
04347 #ifndef TOLUA_RELEASE
04348  tolua_lerror:
04349  tolua_error(tolua_S,"#ferror in function 'msgq_remove'.",&tolua_err);
04350  return 0;
04351 #endif
04352 }
04353 #endif //#ifndef TOLUA_DISABLE
04354 
04355 /* method: msgq_remove of class  fawkes::OpenRaveInterface */
04356 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_msgq_remove01
04357 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_msgq_remove01(lua_State* tolua_S)
04358 {
04359  tolua_Error tolua_err;
04360  if (
04361      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface",0,&tolua_err) ||
04362      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
04363      !tolua_isnoobj(tolua_S,3,&tolua_err)
04364  )
04365   goto tolua_lerror;
04366  else
04367  {
04368   fawkes::OpenRaveInterface* self = (fawkes::OpenRaveInterface*)  tolua_tousertype(tolua_S,1,0);
04369   unsigned int message_id = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
04370 #ifndef TOLUA_RELEASE
04371   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_remove'", NULL);
04372 #endif
04373   {
04374    self->msgq_remove(message_id);
04375   }
04376  }
04377  return 0;
04378 tolua_lerror:
04379  return tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_msgq_remove00(tolua_S);
04380 }
04381 #endif //#ifndef TOLUA_DISABLE
04382 
04383 /* method: msgq_size of class  fawkes::OpenRaveInterface */
04384 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_msgq_size00
04385 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_msgq_size00(lua_State* tolua_S)
04386 {
04387 #ifndef TOLUA_RELEASE
04388  tolua_Error tolua_err;
04389  if (
04390      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface",0,&tolua_err) ||
04391      !tolua_isnoobj(tolua_S,2,&tolua_err)
04392  )
04393   goto tolua_lerror;
04394  else
04395 #endif
04396  {
04397   fawkes::OpenRaveInterface* self = (fawkes::OpenRaveInterface*)  tolua_tousertype(tolua_S,1,0);
04398 #ifndef TOLUA_RELEASE
04399   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_size'", NULL);
04400 #endif
04401   {
04402    unsigned int tolua_ret = (unsigned int)  self->msgq_size();
04403    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04404   }
04405  }
04406  return 1;
04407 #ifndef TOLUA_RELEASE
04408  tolua_lerror:
04409  tolua_error(tolua_S,"#ferror in function 'msgq_size'.",&tolua_err);
04410  return 0;
04411 #endif
04412 }
04413 #endif //#ifndef TOLUA_DISABLE
04414 
04415 /* method: msgq_flush of class  fawkes::OpenRaveInterface */
04416 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_msgq_flush00
04417 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_msgq_flush00(lua_State* tolua_S)
04418 {
04419 #ifndef TOLUA_RELEASE
04420  tolua_Error tolua_err;
04421  if (
04422      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface",0,&tolua_err) ||
04423      !tolua_isnoobj(tolua_S,2,&tolua_err)
04424  )
04425   goto tolua_lerror;
04426  else
04427 #endif
04428  {
04429   fawkes::OpenRaveInterface* self = (fawkes::OpenRaveInterface*)  tolua_tousertype(tolua_S,1,0);
04430 #ifndef TOLUA_RELEASE
04431   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_flush'", NULL);
04432 #endif
04433   {
04434    self->msgq_flush();
04435   }
04436  }
04437  return 0;
04438 #ifndef TOLUA_RELEASE
04439  tolua_lerror:
04440  tolua_error(tolua_S,"#ferror in function 'msgq_flush'.",&tolua_err);
04441  return 0;
04442 #endif
04443 }
04444 #endif //#ifndef TOLUA_DISABLE
04445 
04446 /* method: msgq_lock of class  fawkes::OpenRaveInterface */
04447 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_msgq_lock00
04448 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_msgq_lock00(lua_State* tolua_S)
04449 {
04450 #ifndef TOLUA_RELEASE
04451  tolua_Error tolua_err;
04452  if (
04453      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface",0,&tolua_err) ||
04454      !tolua_isnoobj(tolua_S,2,&tolua_err)
04455  )
04456   goto tolua_lerror;
04457  else
04458 #endif
04459  {
04460   fawkes::OpenRaveInterface* self = (fawkes::OpenRaveInterface*)  tolua_tousertype(tolua_S,1,0);
04461 #ifndef TOLUA_RELEASE
04462   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_lock'", NULL);
04463 #endif
04464   {
04465    self->msgq_lock();
04466   }
04467  }
04468  return 0;
04469 #ifndef TOLUA_RELEASE
04470  tolua_lerror:
04471  tolua_error(tolua_S,"#ferror in function 'msgq_lock'.",&tolua_err);
04472  return 0;
04473 #endif
04474 }
04475 #endif //#ifndef TOLUA_DISABLE
04476 
04477 /* method: msgq_try_lock of class  fawkes::OpenRaveInterface */
04478 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_msgq_try_lock00
04479 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_msgq_try_lock00(lua_State* tolua_S)
04480 {
04481 #ifndef TOLUA_RELEASE
04482  tolua_Error tolua_err;
04483  if (
04484      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface",0,&tolua_err) ||
04485      !tolua_isnoobj(tolua_S,2,&tolua_err)
04486  )
04487   goto tolua_lerror;
04488  else
04489 #endif
04490  {
04491   fawkes::OpenRaveInterface* self = (fawkes::OpenRaveInterface*)  tolua_tousertype(tolua_S,1,0);
04492 #ifndef TOLUA_RELEASE
04493   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_try_lock'", NULL);
04494 #endif
04495   {
04496    bool tolua_ret = (bool)  self->msgq_try_lock();
04497    tolua_pushboolean(tolua_S,(bool)tolua_ret);
04498   }
04499  }
04500  return 1;
04501 #ifndef TOLUA_RELEASE
04502  tolua_lerror:
04503  tolua_error(tolua_S,"#ferror in function 'msgq_try_lock'.",&tolua_err);
04504  return 0;
04505 #endif
04506 }
04507 #endif //#ifndef TOLUA_DISABLE
04508 
04509 /* method: msgq_unlock of class  fawkes::OpenRaveInterface */
04510 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_msgq_unlock00
04511 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_msgq_unlock00(lua_State* tolua_S)
04512 {
04513 #ifndef TOLUA_RELEASE
04514  tolua_Error tolua_err;
04515  if (
04516      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface",0,&tolua_err) ||
04517      !tolua_isnoobj(tolua_S,2,&tolua_err)
04518  )
04519   goto tolua_lerror;
04520  else
04521 #endif
04522  {
04523   fawkes::OpenRaveInterface* self = (fawkes::OpenRaveInterface*)  tolua_tousertype(tolua_S,1,0);
04524 #ifndef TOLUA_RELEASE
04525   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_unlock'", NULL);
04526 #endif
04527   {
04528    self->msgq_unlock();
04529   }
04530  }
04531  return 0;
04532 #ifndef TOLUA_RELEASE
04533  tolua_lerror:
04534  tolua_error(tolua_S,"#ferror in function 'msgq_unlock'.",&tolua_err);
04535  return 0;
04536 #endif
04537 }
04538 #endif //#ifndef TOLUA_DISABLE
04539 
04540 /* method: msgq_pop of class  fawkes::OpenRaveInterface */
04541 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_msgq_pop00
04542 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_msgq_pop00(lua_State* tolua_S)
04543 {
04544 #ifndef TOLUA_RELEASE
04545  tolua_Error tolua_err;
04546  if (
04547      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface",0,&tolua_err) ||
04548      !tolua_isnoobj(tolua_S,2,&tolua_err)
04549  )
04550   goto tolua_lerror;
04551  else
04552 #endif
04553  {
04554   fawkes::OpenRaveInterface* self = (fawkes::OpenRaveInterface*)  tolua_tousertype(tolua_S,1,0);
04555 #ifndef TOLUA_RELEASE
04556   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_pop'", NULL);
04557 #endif
04558   {
04559    self->msgq_pop();
04560   }
04561  }
04562  return 0;
04563 #ifndef TOLUA_RELEASE
04564  tolua_lerror:
04565  tolua_error(tolua_S,"#ferror in function 'msgq_pop'.",&tolua_err);
04566  return 0;
04567 #endif
04568 }
04569 #endif //#ifndef TOLUA_DISABLE
04570 
04571 /* method: msgq_first of class  fawkes::OpenRaveInterface */
04572 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_msgq_first00
04573 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_msgq_first00(lua_State* tolua_S)
04574 {
04575 #ifndef TOLUA_RELEASE
04576  tolua_Error tolua_err;
04577  if (
04578      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface",0,&tolua_err) ||
04579      !tolua_isnoobj(tolua_S,2,&tolua_err)
04580  )
04581   goto tolua_lerror;
04582  else
04583 #endif
04584  {
04585   fawkes::OpenRaveInterface* self = (fawkes::OpenRaveInterface*)  tolua_tousertype(tolua_S,1,0);
04586 #ifndef TOLUA_RELEASE
04587   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_first'", NULL);
04588 #endif
04589   {
04590    Message* tolua_ret = (Message*)  self->msgq_first();
04591     tolua_pushusertype(tolua_S,(void*)tolua_ret,"Message");
04592   }
04593  }
04594  return 1;
04595 #ifndef TOLUA_RELEASE
04596  tolua_lerror:
04597  tolua_error(tolua_S,"#ferror in function 'msgq_first'.",&tolua_err);
04598  return 0;
04599 #endif
04600 }
04601 #endif //#ifndef TOLUA_DISABLE
04602 
04603 /* method: msgq_empty of class  fawkes::OpenRaveInterface */
04604 #ifndef TOLUA_DISABLE_tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_msgq_empty00
04605 static int tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_msgq_empty00(lua_State* tolua_S)
04606 {
04607 #ifndef TOLUA_RELEASE
04608  tolua_Error tolua_err;
04609  if (
04610      !tolua_isusertype(tolua_S,1,"fawkes::OpenRaveInterface",0,&tolua_err) ||
04611      !tolua_isnoobj(tolua_S,2,&tolua_err)
04612  )
04613   goto tolua_lerror;
04614  else
04615 #endif
04616  {
04617   fawkes::OpenRaveInterface* self = (fawkes::OpenRaveInterface*)  tolua_tousertype(tolua_S,1,0);
04618 #ifndef TOLUA_RELEASE
04619   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_empty'", NULL);
04620 #endif
04621   {
04622    bool tolua_ret = (bool)  self->msgq_empty();
04623    tolua_pushboolean(tolua_S,(bool)tolua_ret);
04624   }
04625  }
04626  return 1;
04627 #ifndef TOLUA_RELEASE
04628  tolua_lerror:
04629  tolua_error(tolua_S,"#ferror in function 'msgq_empty'.",&tolua_err);
04630  return 0;
04631 #endif
04632 }
04633 #endif //#ifndef TOLUA_DISABLE
04634 
04635 /* Open function */
04636 TOLUA_API int tolua_interfaces_OpenRaveInterface_open (lua_State* tolua_S)
04637 {
04638  tolua_open(tolua_S);
04639  tolua_reg_types(tolua_S);
04640  tolua_module(tolua_S,NULL,0);
04641  tolua_beginmodule(tolua_S,NULL);
04642   tolua_module(tolua_S,"fawkes",0);
04643   tolua_beginmodule(tolua_S,"fawkes");
04644    tolua_cclass(tolua_S,"OpenRaveInterface","fawkes::OpenRaveInterface","Interface",NULL);
04645    tolua_beginmodule(tolua_S,"OpenRaveInterface");
04646     #ifdef __cplusplus
04647     tolua_cclass(tolua_S,"AddObjectMessage","fawkes::OpenRaveInterface::AddObjectMessage","Message",tolua_collect_fawkes__OpenRaveInterface__AddObjectMessage);
04648     #else
04649     tolua_cclass(tolua_S,"AddObjectMessage","fawkes::OpenRaveInterface::AddObjectMessage","Message",NULL);
04650     #endif
04651     tolua_beginmodule(tolua_S,"AddObjectMessage");
04652      tolua_function(tolua_S,"new",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AddObjectMessage_new00);
04653      tolua_function(tolua_S,"new_local",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AddObjectMessage_new00_local);
04654      tolua_function(tolua_S,".call",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AddObjectMessage_new00_local);
04655      tolua_function(tolua_S,"new",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AddObjectMessage_new01);
04656      tolua_function(tolua_S,"new_local",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AddObjectMessage_new01_local);
04657      tolua_function(tolua_S,".call",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AddObjectMessage_new01_local);
04658      tolua_function(tolua_S,"delete",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AddObjectMessage_delete00);
04659      tolua_function(tolua_S,"name",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AddObjectMessage_name00);
04660      tolua_function(tolua_S,"set_name",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AddObjectMessage_set_name00);
04661      tolua_function(tolua_S,"maxlenof_name",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AddObjectMessage_maxlenof_name00);
04662      tolua_function(tolua_S,"path",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AddObjectMessage_path00);
04663      tolua_function(tolua_S,"set_path",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AddObjectMessage_set_path00);
04664      tolua_function(tolua_S,"maxlenof_path",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AddObjectMessage_maxlenof_path00);
04665     tolua_endmodule(tolua_S);
04666     #ifdef __cplusplus
04667     tolua_cclass(tolua_S,"DeleteObjectMessage","fawkes::OpenRaveInterface::DeleteObjectMessage","Message",tolua_collect_fawkes__OpenRaveInterface__DeleteObjectMessage);
04668     #else
04669     tolua_cclass(tolua_S,"DeleteObjectMessage","fawkes::OpenRaveInterface::DeleteObjectMessage","Message",NULL);
04670     #endif
04671     tolua_beginmodule(tolua_S,"DeleteObjectMessage");
04672      tolua_function(tolua_S,"new",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_DeleteObjectMessage_new00);
04673      tolua_function(tolua_S,"new_local",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_DeleteObjectMessage_new00_local);
04674      tolua_function(tolua_S,".call",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_DeleteObjectMessage_new00_local);
04675      tolua_function(tolua_S,"new",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_DeleteObjectMessage_new01);
04676      tolua_function(tolua_S,"new_local",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_DeleteObjectMessage_new01_local);
04677      tolua_function(tolua_S,".call",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_DeleteObjectMessage_new01_local);
04678      tolua_function(tolua_S,"delete",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_DeleteObjectMessage_delete00);
04679      tolua_function(tolua_S,"name",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_DeleteObjectMessage_name00);
04680      tolua_function(tolua_S,"set_name",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_DeleteObjectMessage_set_name00);
04681      tolua_function(tolua_S,"maxlenof_name",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_DeleteObjectMessage_maxlenof_name00);
04682     tolua_endmodule(tolua_S);
04683     #ifdef __cplusplus
04684     tolua_cclass(tolua_S,"AttachObjectMessage","fawkes::OpenRaveInterface::AttachObjectMessage","Message",tolua_collect_fawkes__OpenRaveInterface__AttachObjectMessage);
04685     #else
04686     tolua_cclass(tolua_S,"AttachObjectMessage","fawkes::OpenRaveInterface::AttachObjectMessage","Message",NULL);
04687     #endif
04688     tolua_beginmodule(tolua_S,"AttachObjectMessage");
04689      tolua_function(tolua_S,"new",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AttachObjectMessage_new00);
04690      tolua_function(tolua_S,"new_local",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AttachObjectMessage_new00_local);
04691      tolua_function(tolua_S,".call",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AttachObjectMessage_new00_local);
04692      tolua_function(tolua_S,"new",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AttachObjectMessage_new01);
04693      tolua_function(tolua_S,"new_local",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AttachObjectMessage_new01_local);
04694      tolua_function(tolua_S,".call",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AttachObjectMessage_new01_local);
04695      tolua_function(tolua_S,"delete",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AttachObjectMessage_delete00);
04696      tolua_function(tolua_S,"name",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AttachObjectMessage_name00);
04697      tolua_function(tolua_S,"set_name",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AttachObjectMessage_set_name00);
04698      tolua_function(tolua_S,"maxlenof_name",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_AttachObjectMessage_maxlenof_name00);
04699     tolua_endmodule(tolua_S);
04700     #ifdef __cplusplus
04701     tolua_cclass(tolua_S,"ReleaseObjectMessage","fawkes::OpenRaveInterface::ReleaseObjectMessage","Message",tolua_collect_fawkes__OpenRaveInterface__ReleaseObjectMessage);
04702     #else
04703     tolua_cclass(tolua_S,"ReleaseObjectMessage","fawkes::OpenRaveInterface::ReleaseObjectMessage","Message",NULL);
04704     #endif
04705     tolua_beginmodule(tolua_S,"ReleaseObjectMessage");
04706      tolua_function(tolua_S,"new",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_ReleaseObjectMessage_new00);
04707      tolua_function(tolua_S,"new_local",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_ReleaseObjectMessage_new00_local);
04708      tolua_function(tolua_S,".call",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_ReleaseObjectMessage_new00_local);
04709      tolua_function(tolua_S,"new",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_ReleaseObjectMessage_new01);
04710      tolua_function(tolua_S,"new_local",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_ReleaseObjectMessage_new01_local);
04711      tolua_function(tolua_S,".call",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_ReleaseObjectMessage_new01_local);
04712      tolua_function(tolua_S,"delete",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_ReleaseObjectMessage_delete00);
04713      tolua_function(tolua_S,"name",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_ReleaseObjectMessage_name00);
04714      tolua_function(tolua_S,"set_name",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_ReleaseObjectMessage_set_name00);
04715      tolua_function(tolua_S,"maxlenof_name",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_ReleaseObjectMessage_maxlenof_name00);
04716     tolua_endmodule(tolua_S);
04717     #ifdef __cplusplus
04718     tolua_cclass(tolua_S,"ReleaseAllObjectsMessage","fawkes::OpenRaveInterface::ReleaseAllObjectsMessage","Message",tolua_collect_fawkes__OpenRaveInterface__ReleaseAllObjectsMessage);
04719     #else
04720     tolua_cclass(tolua_S,"ReleaseAllObjectsMessage","fawkes::OpenRaveInterface::ReleaseAllObjectsMessage","Message",NULL);
04721     #endif
04722     tolua_beginmodule(tolua_S,"ReleaseAllObjectsMessage");
04723      tolua_function(tolua_S,"new",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_ReleaseAllObjectsMessage_new00);
04724      tolua_function(tolua_S,"new_local",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_ReleaseAllObjectsMessage_new00_local);
04725      tolua_function(tolua_S,".call",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_ReleaseAllObjectsMessage_new00_local);
04726      tolua_function(tolua_S,"delete",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_ReleaseAllObjectsMessage_delete00);
04727     tolua_endmodule(tolua_S);
04728     #ifdef __cplusplus
04729     tolua_cclass(tolua_S,"MoveObjectMessage","fawkes::OpenRaveInterface::MoveObjectMessage","Message",tolua_collect_fawkes__OpenRaveInterface__MoveObjectMessage);
04730     #else
04731     tolua_cclass(tolua_S,"MoveObjectMessage","fawkes::OpenRaveInterface::MoveObjectMessage","Message",NULL);
04732     #endif
04733     tolua_beginmodule(tolua_S,"MoveObjectMessage");
04734      tolua_function(tolua_S,"new",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_MoveObjectMessage_new00);
04735      tolua_function(tolua_S,"new_local",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_MoveObjectMessage_new00_local);
04736      tolua_function(tolua_S,".call",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_MoveObjectMessage_new00_local);
04737      tolua_function(tolua_S,"new",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_MoveObjectMessage_new01);
04738      tolua_function(tolua_S,"new_local",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_MoveObjectMessage_new01_local);
04739      tolua_function(tolua_S,".call",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_MoveObjectMessage_new01_local);
04740      tolua_function(tolua_S,"delete",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_MoveObjectMessage_delete00);
04741      tolua_function(tolua_S,"name",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_MoveObjectMessage_name00);
04742      tolua_function(tolua_S,"set_name",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_MoveObjectMessage_set_name00);
04743      tolua_function(tolua_S,"maxlenof_name",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_MoveObjectMessage_maxlenof_name00);
04744      tolua_function(tolua_S,"x",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_MoveObjectMessage_x00);
04745      tolua_function(tolua_S,"set_x",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_MoveObjectMessage_set_x00);
04746      tolua_function(tolua_S,"maxlenof_x",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_MoveObjectMessage_maxlenof_x00);
04747      tolua_function(tolua_S,"y",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_MoveObjectMessage_y00);
04748      tolua_function(tolua_S,"set_y",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_MoveObjectMessage_set_y00);
04749      tolua_function(tolua_S,"maxlenof_y",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_MoveObjectMessage_maxlenof_y00);
04750      tolua_function(tolua_S,"z",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_MoveObjectMessage_z00);
04751      tolua_function(tolua_S,"set_z",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_MoveObjectMessage_set_z00);
04752      tolua_function(tolua_S,"maxlenof_z",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_MoveObjectMessage_maxlenof_z00);
04753     tolua_endmodule(tolua_S);
04754     #ifdef __cplusplus
04755     tolua_cclass(tolua_S,"RotateObjectQuatMessage","fawkes::OpenRaveInterface::RotateObjectQuatMessage","Message",tolua_collect_fawkes__OpenRaveInterface__RotateObjectQuatMessage);
04756     #else
04757     tolua_cclass(tolua_S,"RotateObjectQuatMessage","fawkes::OpenRaveInterface::RotateObjectQuatMessage","Message",NULL);
04758     #endif
04759     tolua_beginmodule(tolua_S,"RotateObjectQuatMessage");
04760      tolua_function(tolua_S,"new",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectQuatMessage_new00);
04761      tolua_function(tolua_S,"new_local",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectQuatMessage_new00_local);
04762      tolua_function(tolua_S,".call",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectQuatMessage_new00_local);
04763      tolua_function(tolua_S,"new",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectQuatMessage_new01);
04764      tolua_function(tolua_S,"new_local",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectQuatMessage_new01_local);
04765      tolua_function(tolua_S,".call",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectQuatMessage_new01_local);
04766      tolua_function(tolua_S,"delete",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectQuatMessage_delete00);
04767      tolua_function(tolua_S,"name",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectQuatMessage_name00);
04768      tolua_function(tolua_S,"set_name",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectQuatMessage_set_name00);
04769      tolua_function(tolua_S,"maxlenof_name",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectQuatMessage_maxlenof_name00);
04770      tolua_function(tolua_S,"x",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectQuatMessage_x00);
04771      tolua_function(tolua_S,"set_x",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectQuatMessage_set_x00);
04772      tolua_function(tolua_S,"maxlenof_x",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectQuatMessage_maxlenof_x00);
04773      tolua_function(tolua_S,"y",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectQuatMessage_y00);
04774      tolua_function(tolua_S,"set_y",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectQuatMessage_set_y00);
04775      tolua_function(tolua_S,"maxlenof_y",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectQuatMessage_maxlenof_y00);
04776      tolua_function(tolua_S,"z",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectQuatMessage_z00);
04777      tolua_function(tolua_S,"set_z",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectQuatMessage_set_z00);
04778      tolua_function(tolua_S,"maxlenof_z",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectQuatMessage_maxlenof_z00);
04779      tolua_function(tolua_S,"w",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectQuatMessage_w00);
04780      tolua_function(tolua_S,"set_w",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectQuatMessage_set_w00);
04781      tolua_function(tolua_S,"maxlenof_w",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectQuatMessage_maxlenof_w00);
04782     tolua_endmodule(tolua_S);
04783     #ifdef __cplusplus
04784     tolua_cclass(tolua_S,"RotateObjectMessage","fawkes::OpenRaveInterface::RotateObjectMessage","Message",tolua_collect_fawkes__OpenRaveInterface__RotateObjectMessage);
04785     #else
04786     tolua_cclass(tolua_S,"RotateObjectMessage","fawkes::OpenRaveInterface::RotateObjectMessage","Message",NULL);
04787     #endif
04788     tolua_beginmodule(tolua_S,"RotateObjectMessage");
04789      tolua_function(tolua_S,"new",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectMessage_new00);
04790      tolua_function(tolua_S,"new_local",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectMessage_new00_local);
04791      tolua_function(tolua_S,".call",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectMessage_new00_local);
04792      tolua_function(tolua_S,"new",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectMessage_new01);
04793      tolua_function(tolua_S,"new_local",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectMessage_new01_local);
04794      tolua_function(tolua_S,".call",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectMessage_new01_local);
04795      tolua_function(tolua_S,"delete",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectMessage_delete00);
04796      tolua_function(tolua_S,"name",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectMessage_name00);
04797      tolua_function(tolua_S,"set_name",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectMessage_set_name00);
04798      tolua_function(tolua_S,"maxlenof_name",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectMessage_maxlenof_name00);
04799      tolua_function(tolua_S,"x",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectMessage_x00);
04800      tolua_function(tolua_S,"set_x",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectMessage_set_x00);
04801      tolua_function(tolua_S,"maxlenof_x",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectMessage_maxlenof_x00);
04802      tolua_function(tolua_S,"y",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectMessage_y00);
04803      tolua_function(tolua_S,"set_y",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectMessage_set_y00);
04804      tolua_function(tolua_S,"maxlenof_y",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectMessage_maxlenof_y00);
04805      tolua_function(tolua_S,"z",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectMessage_z00);
04806      tolua_function(tolua_S,"set_z",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectMessage_set_z00);
04807      tolua_function(tolua_S,"maxlenof_z",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RotateObjectMessage_maxlenof_z00);
04808     tolua_endmodule(tolua_S);
04809     #ifdef __cplusplus
04810     tolua_cclass(tolua_S,"RenameObjectMessage","fawkes::OpenRaveInterface::RenameObjectMessage","Message",tolua_collect_fawkes__OpenRaveInterface__RenameObjectMessage);
04811     #else
04812     tolua_cclass(tolua_S,"RenameObjectMessage","fawkes::OpenRaveInterface::RenameObjectMessage","Message",NULL);
04813     #endif
04814     tolua_beginmodule(tolua_S,"RenameObjectMessage");
04815      tolua_function(tolua_S,"new",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RenameObjectMessage_new00);
04816      tolua_function(tolua_S,"new_local",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RenameObjectMessage_new00_local);
04817      tolua_function(tolua_S,".call",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RenameObjectMessage_new00_local);
04818      tolua_function(tolua_S,"new",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RenameObjectMessage_new01);
04819      tolua_function(tolua_S,"new_local",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RenameObjectMessage_new01_local);
04820      tolua_function(tolua_S,".call",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RenameObjectMessage_new01_local);
04821      tolua_function(tolua_S,"delete",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RenameObjectMessage_delete00);
04822      tolua_function(tolua_S,"name",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RenameObjectMessage_name00);
04823      tolua_function(tolua_S,"set_name",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RenameObjectMessage_set_name00);
04824      tolua_function(tolua_S,"maxlenof_name",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RenameObjectMessage_maxlenof_name00);
04825      tolua_function(tolua_S,"newName",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RenameObjectMessage_newName00);
04826      tolua_function(tolua_S,"set_newName",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RenameObjectMessage_set_newName00);
04827      tolua_function(tolua_S,"maxlenof_newName",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_RenameObjectMessage_maxlenof_newName00);
04828     tolua_endmodule(tolua_S);
04829     tolua_function(tolua_S,"msgid",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_msgid00);
04830     tolua_function(tolua_S,"set_msgid",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_set_msgid00);
04831     tolua_function(tolua_S,"maxlenof_msgid",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_maxlenof_msgid00);
04832     tolua_function(tolua_S,"is_final",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_is_final00);
04833     tolua_function(tolua_S,"set_final",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_set_final00);
04834     tolua_function(tolua_S,"maxlenof_final",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_maxlenof_final00);
04835     tolua_function(tolua_S,"error_code",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_error_code00);
04836     tolua_function(tolua_S,"set_error_code",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_set_error_code00);
04837     tolua_function(tolua_S,"maxlenof_error_code",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_maxlenof_error_code00);
04838     tolua_function(tolua_S,"is_success",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_is_success00);
04839     tolua_function(tolua_S,"set_success",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_set_success00);
04840     tolua_function(tolua_S,"maxlenof_success",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_maxlenof_success00);
04841     tolua_function(tolua_S,"oftype",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_oftype00);
04842     tolua_function(tolua_S,"datachunk",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_datachunk00);
04843     tolua_function(tolua_S,"datasize",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_datasize00);
04844     tolua_function(tolua_S,"type",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_type00);
04845     tolua_function(tolua_S,"id",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_id00);
04846     tolua_function(tolua_S,"uid",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_uid00);
04847     tolua_function(tolua_S,"serial",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_serial00);
04848     tolua_function(tolua_S,"mem_serial",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_mem_serial00);
04849     tolua_function(tolua_S,".eq",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface__eq00);
04850     tolua_function(tolua_S,"hash",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_hash00);
04851     tolua_function(tolua_S,"hash_size",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_hash_size00);
04852     tolua_function(tolua_S,"hash_printable",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_hash_printable00);
04853     tolua_function(tolua_S,"is_writer",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_is_writer00);
04854     tolua_function(tolua_S,"set_from_chunk",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_set_from_chunk00);
04855     tolua_function(tolua_S,"create_message",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_create_message00);
04856     tolua_function(tolua_S,"read",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_read00);
04857     tolua_function(tolua_S,"write",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_write00);
04858     tolua_function(tolua_S,"has_writer",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_has_writer00);
04859     tolua_function(tolua_S,"num_readers",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_num_readers00);
04860     tolua_function(tolua_S,"msgq_enqueue_copy",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_msgq_enqueue_copy00);
04861     tolua_function(tolua_S,"msgq_remove",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_msgq_remove00);
04862     tolua_function(tolua_S,"msgq_remove",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_msgq_remove01);
04863     tolua_function(tolua_S,"msgq_size",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_msgq_size00);
04864     tolua_function(tolua_S,"msgq_flush",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_msgq_flush00);
04865     tolua_function(tolua_S,"msgq_lock",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_msgq_lock00);
04866     tolua_function(tolua_S,"msgq_try_lock",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_msgq_try_lock00);
04867     tolua_function(tolua_S,"msgq_unlock",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_msgq_unlock00);
04868     tolua_function(tolua_S,"msgq_pop",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_msgq_pop00);
04869     tolua_function(tolua_S,"msgq_first",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_msgq_first00);
04870     tolua_function(tolua_S,"msgq_empty",tolua_interfaces_OpenRaveInterface_fawkes_OpenRaveInterface_msgq_empty00);
04871    tolua_endmodule(tolua_S);
04872   tolua_endmodule(tolua_S);
04873  tolua_endmodule(tolua_S);
04874  return 1;
04875 }
04876 
04877 
04878 extern "C" {
04879 #if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501
04880  TOLUA_API int luaopen_interfaces_OpenRaveInterface (lua_State* tolua_S) {
04881  return tolua_interfaces_OpenRaveInterface_open(tolua_S);
04882 };
04883 #endif
04884 }
04885 
04886