00001 /*
00002 ** Lua binding: interfaces_TestInterface
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_TestInterface_open (lua_State* tolua_S);
00028
00029 #include <interfaces/TestInterface.h>
00030 using namespace fawkes;
00031
00032 /* function to release collected object via destructor */
00033 #ifdef __cplusplus
00034 
00035 static int tolua_collect_fawkes__TestInterface__SetTestIntMessage (lua_State* tolua_S)
00036 {
00037  fawkes::TestInterface::SetTestIntMessage* self = (fawkes::TestInterface::SetTestIntMessage*) tolua_tousertype(tolua_S,1,0);
00038         delete self;
00039         return 0;
00040 }
00041
00042 static int tolua_collect_fawkes__TestInterface__CalculateMessage (lua_State* tolua_S)
00043 {
00044  fawkes::TestInterface::CalculateMessage* self = (fawkes::TestInterface::CalculateMessage*) tolua_tousertype(tolua_S,1,0);
00045         delete self;
00046         return 0;
00047 }
00048
00049 static int tolua_collect_fawkes__TestInterface__SetTestStringMessage (lua_State* tolua_S)
00050 {
00051  fawkes::TestInterface::SetTestStringMessage* self = (fawkes::TestInterface::SetTestStringMessage*) tolua_tousertype(tolua_S,1,0);
00052         delete self;
00053         return 0;
00054 }
00055 #endif
00056 
00057
00058 /* function to register type */
00059 static void tolua_reg_types (lua_State* tolua_S)
00060 {
00061  tolua_usertype(tolua_S,"Message");
00062  tolua_usertype(tolua_S,"fawkes::TestInterface::SetTestIntMessage");
00063  tolua_usertype(tolua_S,"fawkes::TestInterface");
00064  tolua_usertype(tolua_S,"fawkes::TestInterface::CalculateMessage");
00065  tolua_usertype(tolua_S,"fawkes::TestInterface::SetTestStringMessage");
00066  tolua_usertype(tolua_S,"Interface");
00067 }
00068
00069 /* get function: TEST_CONSTANT of class  fawkes::TestInterface */
00070 #ifndef TOLUA_DISABLE_tolua_get_fawkes__TestInterface_TEST_CONSTANT
00071 static int tolua_get_fawkes__TestInterface_TEST_CONSTANT(lua_State* tolua_S)
00072 {
00073   tolua_pushnumber(tolua_S,(lua_Number)fawkes::TestInterface::TEST_CONSTANT);
00074  return 1;
00075 }
00076 #endif //#ifndef TOLUA_DISABLE
00077 
00078 /* get function: TEST_FLOAT_CONSTANT of class  fawkes::TestInterface */
00079 #ifndef TOLUA_DISABLE_tolua_get_fawkes__TestInterface_TEST_FLOAT_CONSTANT
00080 static int tolua_get_fawkes__TestInterface_TEST_FLOAT_CONSTANT(lua_State* tolua_S)
00081 {
00082   tolua_pushnumber(tolua_S,(lua_Number)fawkes::TestInterface::TEST_FLOAT_CONSTANT);
00083  return 1;
00084 }
00085 #endif //#ifndef TOLUA_DISABLE
00086 
00087 /* method: new of class  SetTestIntMessage */
00088 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_new00
00089 static int tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_new00(lua_State* tolua_S)
00090 {
00091 #ifndef TOLUA_RELEASE
00092  tolua_Error tolua_err;
00093  if (
00094      !tolua_isusertable(tolua_S,1,"fawkes::TestInterface::SetTestIntMessage",0,&tolua_err) ||
00095      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00096      !tolua_isnoobj(tolua_S,3,&tolua_err)
00097  )
00098   goto tolua_lerror;
00099  else
00100 #endif
00101  {
00102   int ini_test_int = ((int)  tolua_tonumber(tolua_S,2,0));
00103   {
00104    fawkes::TestInterface::SetTestIntMessage* tolua_ret = (fawkes::TestInterface::SetTestIntMessage*)  new fawkes::TestInterface::SetTestIntMessage(ini_test_int);
00105    tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::TestInterface::SetTestIntMessage");
00106   }
00107  }
00108  return 1;
00109 #ifndef TOLUA_RELEASE
00110  tolua_lerror:
00111  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00112  return 0;
00113 #endif
00114 }
00115 #endif //#ifndef TOLUA_DISABLE
00116 
00117 /* method: new_local of class  SetTestIntMessage */
00118 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_new00_local
00119 static int tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_new00_local(lua_State* tolua_S)
00120 {
00121 #ifndef TOLUA_RELEASE
00122  tolua_Error tolua_err;
00123  if (
00124      !tolua_isusertable(tolua_S,1,"fawkes::TestInterface::SetTestIntMessage",0,&tolua_err) ||
00125      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00126      !tolua_isnoobj(tolua_S,3,&tolua_err)
00127  )
00128   goto tolua_lerror;
00129  else
00130 #endif
00131  {
00132   int ini_test_int = ((int)  tolua_tonumber(tolua_S,2,0));
00133   {
00134    fawkes::TestInterface::SetTestIntMessage* tolua_ret = (fawkes::TestInterface::SetTestIntMessage*)  new fawkes::TestInterface::SetTestIntMessage(ini_test_int);
00135    tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"fawkes::TestInterface::SetTestIntMessage");
00136   }
00137  }
00138  return 1;
00139 #ifndef TOLUA_RELEASE
00140  tolua_lerror:
00141  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00142  return 0;
00143 #endif
00144 }
00145 #endif //#ifndef TOLUA_DISABLE
00146 
00147 /* method: new of class  SetTestIntMessage */
00148 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_new01
00149 static int tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_new01(lua_State* tolua_S)
00150 {
00151  tolua_Error tolua_err;
00152  if (
00153      !tolua_isusertable(tolua_S,1,"fawkes::TestInterface::SetTestIntMessage",0,&tolua_err) ||
00154      !tolua_isnoobj(tolua_S,2,&tolua_err)
00155  )
00156   goto tolua_lerror;
00157  else
00158  {
00159   {
00160    fawkes::TestInterface::SetTestIntMessage* tolua_ret = (fawkes::TestInterface::SetTestIntMessage*)  new fawkes::TestInterface::SetTestIntMessage();
00161    tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::TestInterface::SetTestIntMessage");
00162   }
00163  }
00164  return 1;
00165 tolua_lerror:
00166  return tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_new00(tolua_S);
00167 }
00168 #endif //#ifndef TOLUA_DISABLE
00169 
00170 /* method: new_local of class  SetTestIntMessage */
00171 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_new01_local
00172 static int tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_new01_local(lua_State* tolua_S)
00173 {
00174  tolua_Error tolua_err;
00175  if (
00176      !tolua_isusertable(tolua_S,1,"fawkes::TestInterface::SetTestIntMessage",0,&tolua_err) ||
00177      !tolua_isnoobj(tolua_S,2,&tolua_err)
00178  )
00179   goto tolua_lerror;
00180  else
00181  {
00182   {
00183    fawkes::TestInterface::SetTestIntMessage* tolua_ret = (fawkes::TestInterface::SetTestIntMessage*)  new fawkes::TestInterface::SetTestIntMessage();
00184    tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"fawkes::TestInterface::SetTestIntMessage");
00185   }
00186  }
00187  return 1;
00188 tolua_lerror:
00189  return tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_new00_local(tolua_S);
00190 }
00191 #endif //#ifndef TOLUA_DISABLE
00192 
00193 /* method: delete of class  SetTestIntMessage */
00194 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_delete00
00195 static int tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_delete00(lua_State* tolua_S)
00196 {
00197 #ifndef TOLUA_RELEASE
00198  tolua_Error tolua_err;
00199  if (
00200      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface::SetTestIntMessage",0,&tolua_err) ||
00201      !tolua_isnoobj(tolua_S,2,&tolua_err)
00202  )
00203   goto tolua_lerror;
00204  else
00205 #endif
00206  {
00207   fawkes::TestInterface::SetTestIntMessage* self = (fawkes::TestInterface::SetTestIntMessage*)  tolua_tousertype(tolua_S,1,0);
00208 #ifndef TOLUA_RELEASE
00209   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
00210 #endif
00211   delete self;
00212  }
00213  return 0;
00214 #ifndef TOLUA_RELEASE
00215  tolua_lerror:
00216  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
00217  return 0;
00218 #endif
00219 }
00220 #endif //#ifndef TOLUA_DISABLE
00221 
00222 /* method: test_int of class  SetTestIntMessage */
00223 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_test_int00
00224 static int tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_test_int00(lua_State* tolua_S)
00225 {
00226 #ifndef TOLUA_RELEASE
00227  tolua_Error tolua_err;
00228  if (
00229      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface::SetTestIntMessage",0,&tolua_err) ||
00230      !tolua_isnoobj(tolua_S,2,&tolua_err)
00231  )
00232   goto tolua_lerror;
00233  else
00234 #endif
00235  {
00236   fawkes::TestInterface::SetTestIntMessage* self = (fawkes::TestInterface::SetTestIntMessage*)  tolua_tousertype(tolua_S,1,0);
00237 #ifndef TOLUA_RELEASE
00238   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'test_int'",NULL);
00239 #endif
00240   {
00241    int tolua_ret = (int)  self->test_int();
00242    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00243   }
00244  }
00245  return 1;
00246 #ifndef TOLUA_RELEASE
00247  tolua_lerror:
00248  tolua_error(tolua_S,"#ferror in function 'test_int'.",&tolua_err);
00249  return 0;
00250 #endif
00251 }
00252 #endif //#ifndef TOLUA_DISABLE
00253 
00254 /* method: set_test_int of class  SetTestIntMessage */
00255 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_set_test_int00
00256 static int tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_set_test_int00(lua_State* tolua_S)
00257 {
00258 #ifndef TOLUA_RELEASE
00259  tolua_Error tolua_err;
00260  if (
00261      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface::SetTestIntMessage",0,&tolua_err) ||
00262      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00263      !tolua_isnoobj(tolua_S,3,&tolua_err)
00264  )
00265   goto tolua_lerror;
00266  else
00267 #endif
00268  {
00269   fawkes::TestInterface::SetTestIntMessage* self = (fawkes::TestInterface::SetTestIntMessage*)  tolua_tousertype(tolua_S,1,0);
00270   const int new_test_int = ((const int)  tolua_tonumber(tolua_S,2,0));
00271 #ifndef TOLUA_RELEASE
00272   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_test_int'",NULL);
00273 #endif
00274   {
00275    self->set_test_int(new_test_int);
00276   }
00277  }
00278  return 0;
00279 #ifndef TOLUA_RELEASE
00280  tolua_lerror:
00281  tolua_error(tolua_S,"#ferror in function 'set_test_int'.",&tolua_err);
00282  return 0;
00283 #endif
00284 }
00285 #endif //#ifndef TOLUA_DISABLE
00286 
00287 /* method: maxlenof_test_int of class  SetTestIntMessage */
00288 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_maxlenof_test_int00
00289 static int tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_maxlenof_test_int00(lua_State* tolua_S)
00290 {
00291 #ifndef TOLUA_RELEASE
00292  tolua_Error tolua_err;
00293  if (
00294      !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface::SetTestIntMessage",0,&tolua_err) ||
00295      !tolua_isnoobj(tolua_S,2,&tolua_err)
00296  )
00297   goto tolua_lerror;
00298  else
00299 #endif
00300  {
00301   const fawkes::TestInterface::SetTestIntMessage* self = (const fawkes::TestInterface::SetTestIntMessage*)  tolua_tousertype(tolua_S,1,0);
00302 #ifndef TOLUA_RELEASE
00303   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_test_int'",NULL);
00304 #endif
00305   {
00306    int tolua_ret = (int)  self->maxlenof_test_int();
00307    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00308   }
00309  }
00310  return 1;
00311 #ifndef TOLUA_RELEASE
00312  tolua_lerror:
00313  tolua_error(tolua_S,"#ferror in function 'maxlenof_test_int'.",&tolua_err);
00314  return 0;
00315 #endif
00316 }
00317 #endif //#ifndef TOLUA_DISABLE
00318 
00319 /* method: new of class  SetTestStringMessage */
00320 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_new00
00321 static int tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_new00(lua_State* tolua_S)
00322 {
00323 #ifndef TOLUA_RELEASE
00324  tolua_Error tolua_err;
00325  if (
00326      !tolua_isusertable(tolua_S,1,"fawkes::TestInterface::SetTestStringMessage",0,&tolua_err) ||
00327      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
00328      !tolua_isnoobj(tolua_S,3,&tolua_err)
00329  )
00330   goto tolua_lerror;
00331  else
00332 #endif
00333  {
00334   char* ini_test_string = ((char*)  tolua_tostring(tolua_S,2,0));
00335   {
00336    fawkes::TestInterface::SetTestStringMessage* tolua_ret = (fawkes::TestInterface::SetTestStringMessage*)  new fawkes::TestInterface::SetTestStringMessage(ini_test_string);
00337    tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::TestInterface::SetTestStringMessage");
00338   }
00339  }
00340  return 1;
00341 #ifndef TOLUA_RELEASE
00342  tolua_lerror:
00343  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00344  return 0;
00345 #endif
00346 }
00347 #endif //#ifndef TOLUA_DISABLE
00348 
00349 /* method: new_local of class  SetTestStringMessage */
00350 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_new00_local
00351 static int tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_new00_local(lua_State* tolua_S)
00352 {
00353 #ifndef TOLUA_RELEASE
00354  tolua_Error tolua_err;
00355  if (
00356      !tolua_isusertable(tolua_S,1,"fawkes::TestInterface::SetTestStringMessage",0,&tolua_err) ||
00357      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
00358      !tolua_isnoobj(tolua_S,3,&tolua_err)
00359  )
00360   goto tolua_lerror;
00361  else
00362 #endif
00363  {
00364   char* ini_test_string = ((char*)  tolua_tostring(tolua_S,2,0));
00365   {
00366    fawkes::TestInterface::SetTestStringMessage* tolua_ret = (fawkes::TestInterface::SetTestStringMessage*)  new fawkes::TestInterface::SetTestStringMessage(ini_test_string);
00367    tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"fawkes::TestInterface::SetTestStringMessage");
00368   }
00369  }
00370  return 1;
00371 #ifndef TOLUA_RELEASE
00372  tolua_lerror:
00373  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00374  return 0;
00375 #endif
00376 }
00377 #endif //#ifndef TOLUA_DISABLE
00378 
00379 /* method: new of class  SetTestStringMessage */
00380 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_new01
00381 static int tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_new01(lua_State* tolua_S)
00382 {
00383  tolua_Error tolua_err;
00384  if (
00385      !tolua_isusertable(tolua_S,1,"fawkes::TestInterface::SetTestStringMessage",0,&tolua_err) ||
00386      !tolua_isnoobj(tolua_S,2,&tolua_err)
00387  )
00388   goto tolua_lerror;
00389  else
00390  {
00391   {
00392    fawkes::TestInterface::SetTestStringMessage* tolua_ret = (fawkes::TestInterface::SetTestStringMessage*)  new fawkes::TestInterface::SetTestStringMessage();
00393    tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::TestInterface::SetTestStringMessage");
00394   }
00395  }
00396  return 1;
00397 tolua_lerror:
00398  return tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_new00(tolua_S);
00399 }
00400 #endif //#ifndef TOLUA_DISABLE
00401 
00402 /* method: new_local of class  SetTestStringMessage */
00403 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_new01_local
00404 static int tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_new01_local(lua_State* tolua_S)
00405 {
00406  tolua_Error tolua_err;
00407  if (
00408      !tolua_isusertable(tolua_S,1,"fawkes::TestInterface::SetTestStringMessage",0,&tolua_err) ||
00409      !tolua_isnoobj(tolua_S,2,&tolua_err)
00410  )
00411   goto tolua_lerror;
00412  else
00413  {
00414   {
00415    fawkes::TestInterface::SetTestStringMessage* tolua_ret = (fawkes::TestInterface::SetTestStringMessage*)  new fawkes::TestInterface::SetTestStringMessage();
00416    tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"fawkes::TestInterface::SetTestStringMessage");
00417   }
00418  }
00419  return 1;
00420 tolua_lerror:
00421  return tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_new00_local(tolua_S);
00422 }
00423 #endif //#ifndef TOLUA_DISABLE
00424 
00425 /* method: delete of class  SetTestStringMessage */
00426 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_delete00
00427 static int tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_delete00(lua_State* tolua_S)
00428 {
00429 #ifndef TOLUA_RELEASE
00430  tolua_Error tolua_err;
00431  if (
00432      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface::SetTestStringMessage",0,&tolua_err) ||
00433      !tolua_isnoobj(tolua_S,2,&tolua_err)
00434  )
00435   goto tolua_lerror;
00436  else
00437 #endif
00438  {
00439   fawkes::TestInterface::SetTestStringMessage* self = (fawkes::TestInterface::SetTestStringMessage*)  tolua_tousertype(tolua_S,1,0);
00440 #ifndef TOLUA_RELEASE
00441   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
00442 #endif
00443   delete self;
00444  }
00445  return 0;
00446 #ifndef TOLUA_RELEASE
00447  tolua_lerror:
00448  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
00449  return 0;
00450 #endif
00451 }
00452 #endif //#ifndef TOLUA_DISABLE
00453 
00454 /* method: test_string of class  SetTestStringMessage */
00455 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_test_string00
00456 static int tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_test_string00(lua_State* tolua_S)
00457 {
00458 #ifndef TOLUA_RELEASE
00459  tolua_Error tolua_err;
00460  if (
00461      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface::SetTestStringMessage",0,&tolua_err) ||
00462      !tolua_isnoobj(tolua_S,2,&tolua_err)
00463  )
00464   goto tolua_lerror;
00465  else
00466 #endif
00467  {
00468   fawkes::TestInterface::SetTestStringMessage* self = (fawkes::TestInterface::SetTestStringMessage*)  tolua_tousertype(tolua_S,1,0);
00469 #ifndef TOLUA_RELEASE
00470   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'test_string'",NULL);
00471 #endif
00472   {
00473    char* tolua_ret = (char*)  self->test_string();
00474    tolua_pushstring(tolua_S,(const char*)tolua_ret);
00475   }
00476  }
00477  return 1;
00478 #ifndef TOLUA_RELEASE
00479  tolua_lerror:
00480  tolua_error(tolua_S,"#ferror in function 'test_string'.",&tolua_err);
00481  return 0;
00482 #endif
00483 }
00484 #endif //#ifndef TOLUA_DISABLE
00485 
00486 /* method: set_test_string of class  SetTestStringMessage */
00487 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_set_test_string00
00488 static int tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_set_test_string00(lua_State* tolua_S)
00489 {
00490 #ifndef TOLUA_RELEASE
00491  tolua_Error tolua_err;
00492  if (
00493      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface::SetTestStringMessage",0,&tolua_err) ||
00494      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
00495      !tolua_isnoobj(tolua_S,3,&tolua_err)
00496  )
00497   goto tolua_lerror;
00498  else
00499 #endif
00500  {
00501   fawkes::TestInterface::SetTestStringMessage* self = (fawkes::TestInterface::SetTestStringMessage*)  tolua_tousertype(tolua_S,1,0);
00502   const char* new_test_string = ((const char*)  tolua_tostring(tolua_S,2,0));
00503 #ifndef TOLUA_RELEASE
00504   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_test_string'",NULL);
00505 #endif
00506   {
00507    self->set_test_string(new_test_string);
00508   }
00509  }
00510  return 0;
00511 #ifndef TOLUA_RELEASE
00512  tolua_lerror:
00513  tolua_error(tolua_S,"#ferror in function 'set_test_string'.",&tolua_err);
00514  return 0;
00515 #endif
00516 }
00517 #endif //#ifndef TOLUA_DISABLE
00518 
00519 /* method: maxlenof_test_string of class  SetTestStringMessage */
00520 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_maxlenof_test_string00
00521 static int tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_maxlenof_test_string00(lua_State* tolua_S)
00522 {
00523 #ifndef TOLUA_RELEASE
00524  tolua_Error tolua_err;
00525  if (
00526      !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface::SetTestStringMessage",0,&tolua_err) ||
00527      !tolua_isnoobj(tolua_S,2,&tolua_err)
00528  )
00529   goto tolua_lerror;
00530  else
00531 #endif
00532  {
00533   const fawkes::TestInterface::SetTestStringMessage* self = (const fawkes::TestInterface::SetTestStringMessage*)  tolua_tousertype(tolua_S,1,0);
00534 #ifndef TOLUA_RELEASE
00535   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_test_string'",NULL);
00536 #endif
00537   {
00538    int tolua_ret = (int)  self->maxlenof_test_string();
00539    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00540   }
00541  }
00542  return 1;
00543 #ifndef TOLUA_RELEASE
00544  tolua_lerror:
00545  tolua_error(tolua_S,"#ferror in function 'maxlenof_test_string'.",&tolua_err);
00546  return 0;
00547 #endif
00548 }
00549 #endif //#ifndef TOLUA_DISABLE
00550 
00551 /* method: new of class  CalculateMessage */
00552 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_new00
00553 static int tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_new00(lua_State* tolua_S)
00554 {
00555 #ifndef TOLUA_RELEASE
00556  tolua_Error tolua_err;
00557  if (
00558      !tolua_isusertable(tolua_S,1,"fawkes::TestInterface::CalculateMessage",0,&tolua_err) ||
00559      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00560      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
00561      !tolua_isnoobj(tolua_S,4,&tolua_err)
00562  )
00563   goto tolua_lerror;
00564  else
00565 #endif
00566  {
00567   int ini_summand = ((int)  tolua_tonumber(tolua_S,2,0));
00568   int ini_addend = ((int)  tolua_tonumber(tolua_S,3,0));
00569   {
00570    fawkes::TestInterface::CalculateMessage* tolua_ret = (fawkes::TestInterface::CalculateMessage*)  new fawkes::TestInterface::CalculateMessage(ini_summand,ini_addend);
00571    tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::TestInterface::CalculateMessage");
00572   }
00573  }
00574  return 1;
00575 #ifndef TOLUA_RELEASE
00576  tolua_lerror:
00577  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00578  return 0;
00579 #endif
00580 }
00581 #endif //#ifndef TOLUA_DISABLE
00582 
00583 /* method: new_local of class  CalculateMessage */
00584 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_new00_local
00585 static int tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_new00_local(lua_State* tolua_S)
00586 {
00587 #ifndef TOLUA_RELEASE
00588  tolua_Error tolua_err;
00589  if (
00590      !tolua_isusertable(tolua_S,1,"fawkes::TestInterface::CalculateMessage",0,&tolua_err) ||
00591      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00592      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
00593      !tolua_isnoobj(tolua_S,4,&tolua_err)
00594  )
00595   goto tolua_lerror;
00596  else
00597 #endif
00598  {
00599   int ini_summand = ((int)  tolua_tonumber(tolua_S,2,0));
00600   int ini_addend = ((int)  tolua_tonumber(tolua_S,3,0));
00601   {
00602    fawkes::TestInterface::CalculateMessage* tolua_ret = (fawkes::TestInterface::CalculateMessage*)  new fawkes::TestInterface::CalculateMessage(ini_summand,ini_addend);
00603    tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"fawkes::TestInterface::CalculateMessage");
00604   }
00605  }
00606  return 1;
00607 #ifndef TOLUA_RELEASE
00608  tolua_lerror:
00609  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00610  return 0;
00611 #endif
00612 }
00613 #endif //#ifndef TOLUA_DISABLE
00614 
00615 /* method: new of class  CalculateMessage */
00616 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_new01
00617 static int tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_new01(lua_State* tolua_S)
00618 {
00619  tolua_Error tolua_err;
00620  if (
00621      !tolua_isusertable(tolua_S,1,"fawkes::TestInterface::CalculateMessage",0,&tolua_err) ||
00622      !tolua_isnoobj(tolua_S,2,&tolua_err)
00623  )
00624   goto tolua_lerror;
00625  else
00626  {
00627   {
00628    fawkes::TestInterface::CalculateMessage* tolua_ret = (fawkes::TestInterface::CalculateMessage*)  new fawkes::TestInterface::CalculateMessage();
00629    tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::TestInterface::CalculateMessage");
00630   }
00631  }
00632  return 1;
00633 tolua_lerror:
00634  return tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_new00(tolua_S);
00635 }
00636 #endif //#ifndef TOLUA_DISABLE
00637 
00638 /* method: new_local of class  CalculateMessage */
00639 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_new01_local
00640 static int tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_new01_local(lua_State* tolua_S)
00641 {
00642  tolua_Error tolua_err;
00643  if (
00644      !tolua_isusertable(tolua_S,1,"fawkes::TestInterface::CalculateMessage",0,&tolua_err) ||
00645      !tolua_isnoobj(tolua_S,2,&tolua_err)
00646  )
00647   goto tolua_lerror;
00648  else
00649  {
00650   {
00651    fawkes::TestInterface::CalculateMessage* tolua_ret = (fawkes::TestInterface::CalculateMessage*)  new fawkes::TestInterface::CalculateMessage();
00652    tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"fawkes::TestInterface::CalculateMessage");
00653   }
00654  }
00655  return 1;
00656 tolua_lerror:
00657  return tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_new00_local(tolua_S);
00658 }
00659 #endif //#ifndef TOLUA_DISABLE
00660 
00661 /* method: delete of class  CalculateMessage */
00662 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_delete00
00663 static int tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_delete00(lua_State* tolua_S)
00664 {
00665 #ifndef TOLUA_RELEASE
00666  tolua_Error tolua_err;
00667  if (
00668      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface::CalculateMessage",0,&tolua_err) ||
00669      !tolua_isnoobj(tolua_S,2,&tolua_err)
00670  )
00671   goto tolua_lerror;
00672  else
00673 #endif
00674  {
00675   fawkes::TestInterface::CalculateMessage* self = (fawkes::TestInterface::CalculateMessage*)  tolua_tousertype(tolua_S,1,0);
00676 #ifndef TOLUA_RELEASE
00677   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
00678 #endif
00679   delete self;
00680  }
00681  return 0;
00682 #ifndef TOLUA_RELEASE
00683  tolua_lerror:
00684  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
00685  return 0;
00686 #endif
00687 }
00688 #endif //#ifndef TOLUA_DISABLE
00689 
00690 /* method: summand of class  CalculateMessage */
00691 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_summand00
00692 static int tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_summand00(lua_State* tolua_S)
00693 {
00694 #ifndef TOLUA_RELEASE
00695  tolua_Error tolua_err;
00696  if (
00697      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface::CalculateMessage",0,&tolua_err) ||
00698      !tolua_isnoobj(tolua_S,2,&tolua_err)
00699  )
00700   goto tolua_lerror;
00701  else
00702 #endif
00703  {
00704   fawkes::TestInterface::CalculateMessage* self = (fawkes::TestInterface::CalculateMessage*)  tolua_tousertype(tolua_S,1,0);
00705 #ifndef TOLUA_RELEASE
00706   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'summand'",NULL);
00707 #endif
00708   {
00709    int tolua_ret = (int)  self->summand();
00710    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00711   }
00712  }
00713  return 1;
00714 #ifndef TOLUA_RELEASE
00715  tolua_lerror:
00716  tolua_error(tolua_S,"#ferror in function 'summand'.",&tolua_err);
00717  return 0;
00718 #endif
00719 }
00720 #endif //#ifndef TOLUA_DISABLE
00721 
00722 /* method: set_summand of class  CalculateMessage */
00723 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_set_summand00
00724 static int tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_set_summand00(lua_State* tolua_S)
00725 {
00726 #ifndef TOLUA_RELEASE
00727  tolua_Error tolua_err;
00728  if (
00729      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface::CalculateMessage",0,&tolua_err) ||
00730      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00731      !tolua_isnoobj(tolua_S,3,&tolua_err)
00732  )
00733   goto tolua_lerror;
00734  else
00735 #endif
00736  {
00737   fawkes::TestInterface::CalculateMessage* self = (fawkes::TestInterface::CalculateMessage*)  tolua_tousertype(tolua_S,1,0);
00738   const int new_summand = ((const int)  tolua_tonumber(tolua_S,2,0));
00739 #ifndef TOLUA_RELEASE
00740   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_summand'",NULL);
00741 #endif
00742   {
00743    self->set_summand(new_summand);
00744   }
00745  }
00746  return 0;
00747 #ifndef TOLUA_RELEASE
00748  tolua_lerror:
00749  tolua_error(tolua_S,"#ferror in function 'set_summand'.",&tolua_err);
00750  return 0;
00751 #endif
00752 }
00753 #endif //#ifndef TOLUA_DISABLE
00754 
00755 /* method: maxlenof_summand of class  CalculateMessage */
00756 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_maxlenof_summand00
00757 static int tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_maxlenof_summand00(lua_State* tolua_S)
00758 {
00759 #ifndef TOLUA_RELEASE
00760  tolua_Error tolua_err;
00761  if (
00762      !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface::CalculateMessage",0,&tolua_err) ||
00763      !tolua_isnoobj(tolua_S,2,&tolua_err)
00764  )
00765   goto tolua_lerror;
00766  else
00767 #endif
00768  {
00769   const fawkes::TestInterface::CalculateMessage* self = (const fawkes::TestInterface::CalculateMessage*)  tolua_tousertype(tolua_S,1,0);
00770 #ifndef TOLUA_RELEASE
00771   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_summand'",NULL);
00772 #endif
00773   {
00774    int tolua_ret = (int)  self->maxlenof_summand();
00775    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00776   }
00777  }
00778  return 1;
00779 #ifndef TOLUA_RELEASE
00780  tolua_lerror:
00781  tolua_error(tolua_S,"#ferror in function 'maxlenof_summand'.",&tolua_err);
00782  return 0;
00783 #endif
00784 }
00785 #endif //#ifndef TOLUA_DISABLE
00786 
00787 /* method: addend of class  CalculateMessage */
00788 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_addend00
00789 static int tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_addend00(lua_State* tolua_S)
00790 {
00791 #ifndef TOLUA_RELEASE
00792  tolua_Error tolua_err;
00793  if (
00794      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface::CalculateMessage",0,&tolua_err) ||
00795      !tolua_isnoobj(tolua_S,2,&tolua_err)
00796  )
00797   goto tolua_lerror;
00798  else
00799 #endif
00800  {
00801   fawkes::TestInterface::CalculateMessage* self = (fawkes::TestInterface::CalculateMessage*)  tolua_tousertype(tolua_S,1,0);
00802 #ifndef TOLUA_RELEASE
00803   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addend'",NULL);
00804 #endif
00805   {
00806    int tolua_ret = (int)  self->addend();
00807    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00808   }
00809  }
00810  return 1;
00811 #ifndef TOLUA_RELEASE
00812  tolua_lerror:
00813  tolua_error(tolua_S,"#ferror in function 'addend'.",&tolua_err);
00814  return 0;
00815 #endif
00816 }
00817 #endif //#ifndef TOLUA_DISABLE
00818 
00819 /* method: set_addend of class  CalculateMessage */
00820 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_set_addend00
00821 static int tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_set_addend00(lua_State* tolua_S)
00822 {
00823 #ifndef TOLUA_RELEASE
00824  tolua_Error tolua_err;
00825  if (
00826      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface::CalculateMessage",0,&tolua_err) ||
00827      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00828      !tolua_isnoobj(tolua_S,3,&tolua_err)
00829  )
00830   goto tolua_lerror;
00831  else
00832 #endif
00833  {
00834   fawkes::TestInterface::CalculateMessage* self = (fawkes::TestInterface::CalculateMessage*)  tolua_tousertype(tolua_S,1,0);
00835   const int new_addend = ((const int)  tolua_tonumber(tolua_S,2,0));
00836 #ifndef TOLUA_RELEASE
00837   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_addend'",NULL);
00838 #endif
00839   {
00840    self->set_addend(new_addend);
00841   }
00842  }
00843  return 0;
00844 #ifndef TOLUA_RELEASE
00845  tolua_lerror:
00846  tolua_error(tolua_S,"#ferror in function 'set_addend'.",&tolua_err);
00847  return 0;
00848 #endif
00849 }
00850 #endif //#ifndef TOLUA_DISABLE
00851 
00852 /* method: maxlenof_addend of class  CalculateMessage */
00853 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_maxlenof_addend00
00854 static int tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_maxlenof_addend00(lua_State* tolua_S)
00855 {
00856 #ifndef TOLUA_RELEASE
00857  tolua_Error tolua_err;
00858  if (
00859      !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface::CalculateMessage",0,&tolua_err) ||
00860      !tolua_isnoobj(tolua_S,2,&tolua_err)
00861  )
00862   goto tolua_lerror;
00863  else
00864 #endif
00865  {
00866   const fawkes::TestInterface::CalculateMessage* self = (const fawkes::TestInterface::CalculateMessage*)  tolua_tousertype(tolua_S,1,0);
00867 #ifndef TOLUA_RELEASE
00868   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_addend'",NULL);
00869 #endif
00870   {
00871    int tolua_ret = (int)  self->maxlenof_addend();
00872    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00873   }
00874  }
00875  return 1;
00876 #ifndef TOLUA_RELEASE
00877  tolua_lerror:
00878  tolua_error(tolua_S,"#ferror in function 'maxlenof_addend'.",&tolua_err);
00879  return 0;
00880 #endif
00881 }
00882 #endif //#ifndef TOLUA_DISABLE
00883 
00884 /* method: is_test_bool of class  fawkes::TestInterface */
00885 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_is_test_bool00
00886 static int tolua_interfaces_TestInterface_fawkes_TestInterface_is_test_bool00(lua_State* tolua_S)
00887 {
00888 #ifndef TOLUA_RELEASE
00889  tolua_Error tolua_err;
00890  if (
00891      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
00892      !tolua_isnoobj(tolua_S,2,&tolua_err)
00893  )
00894   goto tolua_lerror;
00895  else
00896 #endif
00897  {
00898   fawkes::TestInterface* self = (fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
00899 #ifndef TOLUA_RELEASE
00900   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_test_bool'",NULL);
00901 #endif
00902   {
00903    bool tolua_ret = (bool)  self->is_test_bool();
00904    tolua_pushboolean(tolua_S,(bool)tolua_ret);
00905   }
00906  }
00907  return 1;
00908 #ifndef TOLUA_RELEASE
00909  tolua_lerror:
00910  tolua_error(tolua_S,"#ferror in function 'is_test_bool'.",&tolua_err);
00911  return 0;
00912 #endif
00913 }
00914 #endif //#ifndef TOLUA_DISABLE
00915 
00916 /* method: set_test_bool of class  fawkes::TestInterface */
00917 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_bool00
00918 static int tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_bool00(lua_State* tolua_S)
00919 {
00920 #ifndef TOLUA_RELEASE
00921  tolua_Error tolua_err;
00922  if (
00923      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
00924      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
00925      !tolua_isnoobj(tolua_S,3,&tolua_err)
00926  )
00927   goto tolua_lerror;
00928  else
00929 #endif
00930  {
00931   fawkes::TestInterface* self = (fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
00932   const bool new_test_bool = ((const bool)  tolua_toboolean(tolua_S,2,0));
00933 #ifndef TOLUA_RELEASE
00934   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_test_bool'",NULL);
00935 #endif
00936   {
00937    self->set_test_bool(new_test_bool);
00938   }
00939  }
00940  return 0;
00941 #ifndef TOLUA_RELEASE
00942  tolua_lerror:
00943  tolua_error(tolua_S,"#ferror in function 'set_test_bool'.",&tolua_err);
00944  return 0;
00945 #endif
00946 }
00947 #endif //#ifndef TOLUA_DISABLE
00948 
00949 /* method: maxlenof_test_bool of class  fawkes::TestInterface */
00950 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_bool00
00951 static int tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_bool00(lua_State* tolua_S)
00952 {
00953 #ifndef TOLUA_RELEASE
00954  tolua_Error tolua_err;
00955  if (
00956      !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
00957      !tolua_isnoobj(tolua_S,2,&tolua_err)
00958  )
00959   goto tolua_lerror;
00960  else
00961 #endif
00962  {
00963   const fawkes::TestInterface* self = (const fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
00964 #ifndef TOLUA_RELEASE
00965   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_test_bool'",NULL);
00966 #endif
00967   {
00968    int tolua_ret = (int)  self->maxlenof_test_bool();
00969    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00970   }
00971  }
00972  return 1;
00973 #ifndef TOLUA_RELEASE
00974  tolua_lerror:
00975  tolua_error(tolua_S,"#ferror in function 'maxlenof_test_bool'.",&tolua_err);
00976  return 0;
00977 #endif
00978 }
00979 #endif //#ifndef TOLUA_DISABLE
00980 
00981 /* method: test_int of class  fawkes::TestInterface */
00982 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_test_int00
00983 static int tolua_interfaces_TestInterface_fawkes_TestInterface_test_int00(lua_State* tolua_S)
00984 {
00985 #ifndef TOLUA_RELEASE
00986  tolua_Error tolua_err;
00987  if (
00988      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
00989      !tolua_isnoobj(tolua_S,2,&tolua_err)
00990  )
00991   goto tolua_lerror;
00992  else
00993 #endif
00994  {
00995   fawkes::TestInterface* self = (fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
00996 #ifndef TOLUA_RELEASE
00997   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'test_int'",NULL);
00998 #endif
00999   {
01000    int tolua_ret = (int)  self->test_int();
01001    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01002   }
01003  }
01004  return 1;
01005 #ifndef TOLUA_RELEASE
01006  tolua_lerror:
01007  tolua_error(tolua_S,"#ferror in function 'test_int'.",&tolua_err);
01008  return 0;
01009 #endif
01010 }
01011 #endif //#ifndef TOLUA_DISABLE
01012 
01013 /* method: set_test_int of class  fawkes::TestInterface */
01014 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_int00
01015 static int tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_int00(lua_State* tolua_S)
01016 {
01017 #ifndef TOLUA_RELEASE
01018  tolua_Error tolua_err;
01019  if (
01020      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
01021      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01022      !tolua_isnoobj(tolua_S,3,&tolua_err)
01023  )
01024   goto tolua_lerror;
01025  else
01026 #endif
01027  {
01028   fawkes::TestInterface* self = (fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
01029   const int new_test_int = ((const int)  tolua_tonumber(tolua_S,2,0));
01030 #ifndef TOLUA_RELEASE
01031   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_test_int'",NULL);
01032 #endif
01033   {
01034    self->set_test_int(new_test_int);
01035   }
01036  }
01037  return 0;
01038 #ifndef TOLUA_RELEASE
01039  tolua_lerror:
01040  tolua_error(tolua_S,"#ferror in function 'set_test_int'.",&tolua_err);
01041  return 0;
01042 #endif
01043 }
01044 #endif //#ifndef TOLUA_DISABLE
01045 
01046 /* method: maxlenof_test_int of class  fawkes::TestInterface */
01047 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_int00
01048 static int tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_int00(lua_State* tolua_S)
01049 {
01050 #ifndef TOLUA_RELEASE
01051  tolua_Error tolua_err;
01052  if (
01053      !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
01054      !tolua_isnoobj(tolua_S,2,&tolua_err)
01055  )
01056   goto tolua_lerror;
01057  else
01058 #endif
01059  {
01060   const fawkes::TestInterface* self = (const fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
01061 #ifndef TOLUA_RELEASE
01062   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_test_int'",NULL);
01063 #endif
01064   {
01065    int tolua_ret = (int)  self->maxlenof_test_int();
01066    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01067   }
01068  }
01069  return 1;
01070 #ifndef TOLUA_RELEASE
01071  tolua_lerror:
01072  tolua_error(tolua_S,"#ferror in function 'maxlenof_test_int'.",&tolua_err);
01073  return 0;
01074 #endif
01075 }
01076 #endif //#ifndef TOLUA_DISABLE
01077 
01078 /* method: flags of class  fawkes::TestInterface */
01079 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_flags00
01080 static int tolua_interfaces_TestInterface_fawkes_TestInterface_flags00(lua_State* tolua_S)
01081 {
01082 #ifndef TOLUA_RELEASE
01083  tolua_Error tolua_err;
01084  if (
01085      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
01086      !tolua_isnoobj(tolua_S,2,&tolua_err)
01087  )
01088   goto tolua_lerror;
01089  else
01090 #endif
01091  {
01092   fawkes::TestInterface* self = (fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
01093 #ifndef TOLUA_RELEASE
01094   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'flags'",NULL);
01095 #endif
01096   {
01097    unsigned char tolua_ret = (unsigned char)  self->flags();
01098    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01099   }
01100  }
01101  return 1;
01102 #ifndef TOLUA_RELEASE
01103  tolua_lerror:
01104  tolua_error(tolua_S,"#ferror in function 'flags'.",&tolua_err);
01105  return 0;
01106 #endif
01107 }
01108 #endif //#ifndef TOLUA_DISABLE
01109 
01110 /* method: set_flags of class  fawkes::TestInterface */
01111 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_set_flags00
01112 static int tolua_interfaces_TestInterface_fawkes_TestInterface_set_flags00(lua_State* tolua_S)
01113 {
01114 #ifndef TOLUA_RELEASE
01115  tolua_Error tolua_err;
01116  if (
01117      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
01118      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01119      !tolua_isnoobj(tolua_S,3,&tolua_err)
01120  )
01121   goto tolua_lerror;
01122  else
01123 #endif
01124  {
01125   fawkes::TestInterface* self = (fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
01126   unsigned const char new_flags = ((unsigned const char)  tolua_tonumber(tolua_S,2,0));
01127 #ifndef TOLUA_RELEASE
01128   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_flags'",NULL);
01129 #endif
01130   {
01131    self->set_flags(new_flags);
01132   }
01133  }
01134  return 0;
01135 #ifndef TOLUA_RELEASE
01136  tolua_lerror:
01137  tolua_error(tolua_S,"#ferror in function 'set_flags'.",&tolua_err);
01138  return 0;
01139 #endif
01140 }
01141 #endif //#ifndef TOLUA_DISABLE
01142 
01143 /* method: maxlenof_flags of class  fawkes::TestInterface */
01144 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_flags00
01145 static int tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_flags00(lua_State* tolua_S)
01146 {
01147 #ifndef TOLUA_RELEASE
01148  tolua_Error tolua_err;
01149  if (
01150      !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
01151      !tolua_isnoobj(tolua_S,2,&tolua_err)
01152  )
01153   goto tolua_lerror;
01154  else
01155 #endif
01156  {
01157   const fawkes::TestInterface* self = (const fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
01158 #ifndef TOLUA_RELEASE
01159   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_flags'",NULL);
01160 #endif
01161   {
01162    int tolua_ret = (int)  self->maxlenof_flags();
01163    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01164   }
01165  }
01166  return 1;
01167 #ifndef TOLUA_RELEASE
01168  tolua_lerror:
01169  tolua_error(tolua_S,"#ferror in function 'maxlenof_flags'.",&tolua_err);
01170  return 0;
01171 #endif
01172 }
01173 #endif //#ifndef TOLUA_DISABLE
01174 
01175 /* method: test_string of class  fawkes::TestInterface */
01176 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_test_string00
01177 static int tolua_interfaces_TestInterface_fawkes_TestInterface_test_string00(lua_State* tolua_S)
01178 {
01179 #ifndef TOLUA_RELEASE
01180  tolua_Error tolua_err;
01181  if (
01182      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
01183      !tolua_isnoobj(tolua_S,2,&tolua_err)
01184  )
01185   goto tolua_lerror;
01186  else
01187 #endif
01188  {
01189   fawkes::TestInterface* self = (fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
01190 #ifndef TOLUA_RELEASE
01191   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'test_string'",NULL);
01192 #endif
01193   {
01194    char* tolua_ret = (char*)  self->test_string();
01195    tolua_pushstring(tolua_S,(const char*)tolua_ret);
01196   }
01197  }
01198  return 1;
01199 #ifndef TOLUA_RELEASE
01200  tolua_lerror:
01201  tolua_error(tolua_S,"#ferror in function 'test_string'.",&tolua_err);
01202  return 0;
01203 #endif
01204 }
01205 #endif //#ifndef TOLUA_DISABLE
01206 
01207 /* method: set_test_string of class  fawkes::TestInterface */
01208 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_string00
01209 static int tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_string00(lua_State* tolua_S)
01210 {
01211 #ifndef TOLUA_RELEASE
01212  tolua_Error tolua_err;
01213  if (
01214      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
01215      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
01216      !tolua_isnoobj(tolua_S,3,&tolua_err)
01217  )
01218   goto tolua_lerror;
01219  else
01220 #endif
01221  {
01222   fawkes::TestInterface* self = (fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
01223   const char* new_test_string = ((const char*)  tolua_tostring(tolua_S,2,0));
01224 #ifndef TOLUA_RELEASE
01225   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_test_string'",NULL);
01226 #endif
01227   {
01228    self->set_test_string(new_test_string);
01229   }
01230  }
01231  return 0;
01232 #ifndef TOLUA_RELEASE
01233  tolua_lerror:
01234  tolua_error(tolua_S,"#ferror in function 'set_test_string'.",&tolua_err);
01235  return 0;
01236 #endif
01237 }
01238 #endif //#ifndef TOLUA_DISABLE
01239 
01240 /* method: maxlenof_test_string of class  fawkes::TestInterface */
01241 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_string00
01242 static int tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_string00(lua_State* tolua_S)
01243 {
01244 #ifndef TOLUA_RELEASE
01245  tolua_Error tolua_err;
01246  if (
01247      !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
01248      !tolua_isnoobj(tolua_S,2,&tolua_err)
01249  )
01250   goto tolua_lerror;
01251  else
01252 #endif
01253  {
01254   const fawkes::TestInterface* self = (const fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
01255 #ifndef TOLUA_RELEASE
01256   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_test_string'",NULL);
01257 #endif
01258   {
01259    int tolua_ret = (int)  self->maxlenof_test_string();
01260    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01261   }
01262  }
01263  return 1;
01264 #ifndef TOLUA_RELEASE
01265  tolua_lerror:
01266  tolua_error(tolua_S,"#ferror in function 'maxlenof_test_string'.",&tolua_err);
01267  return 0;
01268 #endif
01269 }
01270 #endif //#ifndef TOLUA_DISABLE
01271 
01272 /* method: result of class  fawkes::TestInterface */
01273 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_result00
01274 static int tolua_interfaces_TestInterface_fawkes_TestInterface_result00(lua_State* tolua_S)
01275 {
01276 #ifndef TOLUA_RELEASE
01277  tolua_Error tolua_err;
01278  if (
01279      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
01280      !tolua_isnoobj(tolua_S,2,&tolua_err)
01281  )
01282   goto tolua_lerror;
01283  else
01284 #endif
01285  {
01286   fawkes::TestInterface* self = (fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
01287 #ifndef TOLUA_RELEASE
01288   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'result'",NULL);
01289 #endif
01290   {
01291    int tolua_ret = (int)  self->result();
01292    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01293   }
01294  }
01295  return 1;
01296 #ifndef TOLUA_RELEASE
01297  tolua_lerror:
01298  tolua_error(tolua_S,"#ferror in function 'result'.",&tolua_err);
01299  return 0;
01300 #endif
01301 }
01302 #endif //#ifndef TOLUA_DISABLE
01303 
01304 /* method: set_result of class  fawkes::TestInterface */
01305 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_set_result00
01306 static int tolua_interfaces_TestInterface_fawkes_TestInterface_set_result00(lua_State* tolua_S)
01307 {
01308 #ifndef TOLUA_RELEASE
01309  tolua_Error tolua_err;
01310  if (
01311      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
01312      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01313      !tolua_isnoobj(tolua_S,3,&tolua_err)
01314  )
01315   goto tolua_lerror;
01316  else
01317 #endif
01318  {
01319   fawkes::TestInterface* self = (fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
01320   const int new_result = ((const int)  tolua_tonumber(tolua_S,2,0));
01321 #ifndef TOLUA_RELEASE
01322   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_result'",NULL);
01323 #endif
01324   {
01325    self->set_result(new_result);
01326   }
01327  }
01328  return 0;
01329 #ifndef TOLUA_RELEASE
01330  tolua_lerror:
01331  tolua_error(tolua_S,"#ferror in function 'set_result'.",&tolua_err);
01332  return 0;
01333 #endif
01334 }
01335 #endif //#ifndef TOLUA_DISABLE
01336 
01337 /* method: maxlenof_result of class  fawkes::TestInterface */
01338 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_result00
01339 static int tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_result00(lua_State* tolua_S)
01340 {
01341 #ifndef TOLUA_RELEASE
01342  tolua_Error tolua_err;
01343  if (
01344      !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
01345      !tolua_isnoobj(tolua_S,2,&tolua_err)
01346  )
01347   goto tolua_lerror;
01348  else
01349 #endif
01350  {
01351   const fawkes::TestInterface* self = (const fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
01352 #ifndef TOLUA_RELEASE
01353   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_result'",NULL);
01354 #endif
01355   {
01356    int tolua_ret = (int)  self->maxlenof_result();
01357    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01358   }
01359  }
01360  return 1;
01361 #ifndef TOLUA_RELEASE
01362  tolua_lerror:
01363  tolua_error(tolua_S,"#ferror in function 'maxlenof_result'.",&tolua_err);
01364  return 0;
01365 #endif
01366 }
01367 #endif //#ifndef TOLUA_DISABLE
01368 
01369 /* method: test_uint of class  fawkes::TestInterface */
01370 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_test_uint00
01371 static int tolua_interfaces_TestInterface_fawkes_TestInterface_test_uint00(lua_State* tolua_S)
01372 {
01373 #ifndef TOLUA_RELEASE
01374  tolua_Error tolua_err;
01375  if (
01376      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
01377      !tolua_isnoobj(tolua_S,2,&tolua_err)
01378  )
01379   goto tolua_lerror;
01380  else
01381 #endif
01382  {
01383   fawkes::TestInterface* self = (fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
01384 #ifndef TOLUA_RELEASE
01385   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'test_uint'",NULL);
01386 #endif
01387   {
01388    unsigned int tolua_ret = (unsigned int)  self->test_uint();
01389    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01390   }
01391  }
01392  return 1;
01393 #ifndef TOLUA_RELEASE
01394  tolua_lerror:
01395  tolua_error(tolua_S,"#ferror in function 'test_uint'.",&tolua_err);
01396  return 0;
01397 #endif
01398 }
01399 #endif //#ifndef TOLUA_DISABLE
01400 
01401 /* method: set_test_uint of class  fawkes::TestInterface */
01402 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_uint00
01403 static int tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_uint00(lua_State* tolua_S)
01404 {
01405 #ifndef TOLUA_RELEASE
01406  tolua_Error tolua_err;
01407  if (
01408      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
01409      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01410      !tolua_isnoobj(tolua_S,3,&tolua_err)
01411  )
01412   goto tolua_lerror;
01413  else
01414 #endif
01415  {
01416   fawkes::TestInterface* self = (fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
01417   unsigned const int new_test_uint = ((unsigned const int)  tolua_tonumber(tolua_S,2,0));
01418 #ifndef TOLUA_RELEASE
01419   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_test_uint'",NULL);
01420 #endif
01421   {
01422    self->set_test_uint(new_test_uint);
01423   }
01424  }
01425  return 0;
01426 #ifndef TOLUA_RELEASE
01427  tolua_lerror:
01428  tolua_error(tolua_S,"#ferror in function 'set_test_uint'.",&tolua_err);
01429  return 0;
01430 #endif
01431 }
01432 #endif //#ifndef TOLUA_DISABLE
01433 
01434 /* method: maxlenof_test_uint of class  fawkes::TestInterface */
01435 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_uint00
01436 static int tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_uint00(lua_State* tolua_S)
01437 {
01438 #ifndef TOLUA_RELEASE
01439  tolua_Error tolua_err;
01440  if (
01441      !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
01442      !tolua_isnoobj(tolua_S,2,&tolua_err)
01443  )
01444   goto tolua_lerror;
01445  else
01446 #endif
01447  {
01448   const fawkes::TestInterface* self = (const fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
01449 #ifndef TOLUA_RELEASE
01450   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_test_uint'",NULL);
01451 #endif
01452   {
01453    int tolua_ret = (int)  self->maxlenof_test_uint();
01454    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01455   }
01456  }
01457  return 1;
01458 #ifndef TOLUA_RELEASE
01459  tolua_lerror:
01460  tolua_error(tolua_S,"#ferror in function 'maxlenof_test_uint'.",&tolua_err);
01461  return 0;
01462 #endif
01463 }
01464 #endif //#ifndef TOLUA_DISABLE
01465 
01466 /* method: test_ulint of class  fawkes::TestInterface */
01467 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_test_ulint00
01468 static int tolua_interfaces_TestInterface_fawkes_TestInterface_test_ulint00(lua_State* tolua_S)
01469 {
01470 #ifndef TOLUA_RELEASE
01471  tolua_Error tolua_err;
01472  if (
01473      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
01474      !tolua_isnoobj(tolua_S,2,&tolua_err)
01475  )
01476   goto tolua_lerror;
01477  else
01478 #endif
01479  {
01480   fawkes::TestInterface* self = (fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
01481 #ifndef TOLUA_RELEASE
01482   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'test_ulint'",NULL);
01483 #endif
01484   {
01485    unsigned long int tolua_ret = (unsigned long int)  self->test_ulint();
01486    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01487   }
01488  }
01489  return 1;
01490 #ifndef TOLUA_RELEASE
01491  tolua_lerror:
01492  tolua_error(tolua_S,"#ferror in function 'test_ulint'.",&tolua_err);
01493  return 0;
01494 #endif
01495 }
01496 #endif //#ifndef TOLUA_DISABLE
01497 
01498 /* method: set_test_ulint of class  fawkes::TestInterface */
01499 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_ulint00
01500 static int tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_ulint00(lua_State* tolua_S)
01501 {
01502 #ifndef TOLUA_RELEASE
01503  tolua_Error tolua_err;
01504  if (
01505      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
01506      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01507      !tolua_isnoobj(tolua_S,3,&tolua_err)
01508  )
01509   goto tolua_lerror;
01510  else
01511 #endif
01512  {
01513   fawkes::TestInterface* self = (fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
01514   unsigned long const int new_test_ulint = ((unsigned long const int)  tolua_tonumber(tolua_S,2,0));
01515 #ifndef TOLUA_RELEASE
01516   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_test_ulint'",NULL);
01517 #endif
01518   {
01519    self->set_test_ulint(new_test_ulint);
01520   }
01521  }
01522  return 0;
01523 #ifndef TOLUA_RELEASE
01524  tolua_lerror:
01525  tolua_error(tolua_S,"#ferror in function 'set_test_ulint'.",&tolua_err);
01526  return 0;
01527 #endif
01528 }
01529 #endif //#ifndef TOLUA_DISABLE
01530 
01531 /* method: maxlenof_test_ulint of class  fawkes::TestInterface */
01532 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_ulint00
01533 static int tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_ulint00(lua_State* tolua_S)
01534 {
01535 #ifndef TOLUA_RELEASE
01536  tolua_Error tolua_err;
01537  if (
01538      !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
01539      !tolua_isnoobj(tolua_S,2,&tolua_err)
01540  )
01541   goto tolua_lerror;
01542  else
01543 #endif
01544  {
01545   const fawkes::TestInterface* self = (const fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
01546 #ifndef TOLUA_RELEASE
01547   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_test_ulint'",NULL);
01548 #endif
01549   {
01550    int tolua_ret = (int)  self->maxlenof_test_ulint();
01551    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01552   }
01553  }
01554  return 1;
01555 #ifndef TOLUA_RELEASE
01556  tolua_lerror:
01557  tolua_error(tolua_S,"#ferror in function 'maxlenof_test_ulint'.",&tolua_err);
01558  return 0;
01559 #endif
01560 }
01561 #endif //#ifndef TOLUA_DISABLE
01562 
01563 /* method: test_lint of class  fawkes::TestInterface */
01564 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_test_lint00
01565 static int tolua_interfaces_TestInterface_fawkes_TestInterface_test_lint00(lua_State* tolua_S)
01566 {
01567 #ifndef TOLUA_RELEASE
01568  tolua_Error tolua_err;
01569  if (
01570      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
01571      !tolua_isnoobj(tolua_S,2,&tolua_err)
01572  )
01573   goto tolua_lerror;
01574  else
01575 #endif
01576  {
01577   fawkes::TestInterface* self = (fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
01578 #ifndef TOLUA_RELEASE
01579   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'test_lint'",NULL);
01580 #endif
01581   {
01582    long int tolua_ret = (long int)  self->test_lint();
01583    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01584   }
01585  }
01586  return 1;
01587 #ifndef TOLUA_RELEASE
01588  tolua_lerror:
01589  tolua_error(tolua_S,"#ferror in function 'test_lint'.",&tolua_err);
01590  return 0;
01591 #endif
01592 }
01593 #endif //#ifndef TOLUA_DISABLE
01594 
01595 /* method: set_test_lint of class  fawkes::TestInterface */
01596 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_lint00
01597 static int tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_lint00(lua_State* tolua_S)
01598 {
01599 #ifndef TOLUA_RELEASE
01600  tolua_Error tolua_err;
01601  if (
01602      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
01603      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01604      !tolua_isnoobj(tolua_S,3,&tolua_err)
01605  )
01606   goto tolua_lerror;
01607  else
01608 #endif
01609  {
01610   fawkes::TestInterface* self = (fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
01611   long const int new_test_lint = ((long const int)  tolua_tonumber(tolua_S,2,0));
01612 #ifndef TOLUA_RELEASE
01613   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_test_lint'",NULL);
01614 #endif
01615   {
01616    self->set_test_lint(new_test_lint);
01617   }
01618  }
01619  return 0;
01620 #ifndef TOLUA_RELEASE
01621  tolua_lerror:
01622  tolua_error(tolua_S,"#ferror in function 'set_test_lint'.",&tolua_err);
01623  return 0;
01624 #endif
01625 }
01626 #endif //#ifndef TOLUA_DISABLE
01627 
01628 /* method: maxlenof_test_lint of class  fawkes::TestInterface */
01629 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_lint00
01630 static int tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_lint00(lua_State* tolua_S)
01631 {
01632 #ifndef TOLUA_RELEASE
01633  tolua_Error tolua_err;
01634  if (
01635      !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
01636      !tolua_isnoobj(tolua_S,2,&tolua_err)
01637  )
01638   goto tolua_lerror;
01639  else
01640 #endif
01641  {
01642   const fawkes::TestInterface* self = (const fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
01643 #ifndef TOLUA_RELEASE
01644   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_test_lint'",NULL);
01645 #endif
01646   {
01647    int tolua_ret = (int)  self->maxlenof_test_lint();
01648    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01649   }
01650  }
01651  return 1;
01652 #ifndef TOLUA_RELEASE
01653  tolua_lerror:
01654  tolua_error(tolua_S,"#ferror in function 'maxlenof_test_lint'.",&tolua_err);
01655  return 0;
01656 #endif
01657 }
01658 #endif //#ifndef TOLUA_DISABLE
01659 
01660 /* method: oftype of class  fawkes::TestInterface */
01661 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_oftype00
01662 static int tolua_interfaces_TestInterface_fawkes_TestInterface_oftype00(lua_State* tolua_S)
01663 {
01664 #ifndef TOLUA_RELEASE
01665  tolua_Error tolua_err;
01666  if (
01667      !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
01668      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
01669      !tolua_isnoobj(tolua_S,3,&tolua_err)
01670  )
01671   goto tolua_lerror;
01672  else
01673 #endif
01674  {
01675   const fawkes::TestInterface* self = (const fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
01676   const char* interface_type = ((const char*)  tolua_tostring(tolua_S,2,0));
01677 #ifndef TOLUA_RELEASE
01678   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'oftype'",NULL);
01679 #endif
01680   {
01681    bool tolua_ret = (bool)  self->oftype(interface_type);
01682    tolua_pushboolean(tolua_S,(bool)tolua_ret);
01683   }
01684  }
01685  return 1;
01686 #ifndef TOLUA_RELEASE
01687  tolua_lerror:
01688  tolua_error(tolua_S,"#ferror in function 'oftype'.",&tolua_err);
01689  return 0;
01690 #endif
01691 }
01692 #endif //#ifndef TOLUA_DISABLE
01693 
01694 /* method: datachunk of class  fawkes::TestInterface */
01695 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_datachunk00
01696 static int tolua_interfaces_TestInterface_fawkes_TestInterface_datachunk00(lua_State* tolua_S)
01697 {
01698 #ifndef TOLUA_RELEASE
01699  tolua_Error tolua_err;
01700  if (
01701      !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
01702      !tolua_isnoobj(tolua_S,2,&tolua_err)
01703  )
01704   goto tolua_lerror;
01705  else
01706 #endif
01707  {
01708   const fawkes::TestInterface* self = (const fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
01709 #ifndef TOLUA_RELEASE
01710   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datachunk'",NULL);
01711 #endif
01712   {
01713    const void* tolua_ret = (const void*)  self->datachunk();
01714    tolua_pushuserdata(tolua_S,(void*)tolua_ret);
01715   }
01716  }
01717  return 1;
01718 #ifndef TOLUA_RELEASE
01719  tolua_lerror:
01720  tolua_error(tolua_S,"#ferror in function 'datachunk'.",&tolua_err);
01721  return 0;
01722 #endif
01723 }
01724 #endif //#ifndef TOLUA_DISABLE
01725 
01726 /* method: datasize of class  fawkes::TestInterface */
01727 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_datasize00
01728 static int tolua_interfaces_TestInterface_fawkes_TestInterface_datasize00(lua_State* tolua_S)
01729 {
01730 #ifndef TOLUA_RELEASE
01731  tolua_Error tolua_err;
01732  if (
01733      !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
01734      !tolua_isnoobj(tolua_S,2,&tolua_err)
01735  )
01736   goto tolua_lerror;
01737  else
01738 #endif
01739  {
01740   const fawkes::TestInterface* self = (const fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
01741 #ifndef TOLUA_RELEASE
01742   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datasize'",NULL);
01743 #endif
01744   {
01745    unsigned int tolua_ret = (unsigned int)  self->datasize();
01746    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01747   }
01748  }
01749  return 1;
01750 #ifndef TOLUA_RELEASE
01751  tolua_lerror:
01752  tolua_error(tolua_S,"#ferror in function 'datasize'.",&tolua_err);
01753  return 0;
01754 #endif
01755 }
01756 #endif //#ifndef TOLUA_DISABLE
01757 
01758 /* method: type of class  fawkes::TestInterface */
01759 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_type00
01760 static int tolua_interfaces_TestInterface_fawkes_TestInterface_type00(lua_State* tolua_S)
01761 {
01762 #ifndef TOLUA_RELEASE
01763  tolua_Error tolua_err;
01764  if (
01765      !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
01766      !tolua_isnoobj(tolua_S,2,&tolua_err)
01767  )
01768   goto tolua_lerror;
01769  else
01770 #endif
01771  {
01772   const fawkes::TestInterface* self = (const fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
01773 #ifndef TOLUA_RELEASE
01774   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'type'",NULL);
01775 #endif
01776   {
01777    const char* tolua_ret = (const char*)  self->type();
01778    tolua_pushstring(tolua_S,(const char*)tolua_ret);
01779   }
01780  }
01781  return 1;
01782 #ifndef TOLUA_RELEASE
01783  tolua_lerror:
01784  tolua_error(tolua_S,"#ferror in function 'type'.",&tolua_err);
01785  return 0;
01786 #endif
01787 }
01788 #endif //#ifndef TOLUA_DISABLE
01789 
01790 /* method: id of class  fawkes::TestInterface */
01791 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_id00
01792 static int tolua_interfaces_TestInterface_fawkes_TestInterface_id00(lua_State* tolua_S)
01793 {
01794 #ifndef TOLUA_RELEASE
01795  tolua_Error tolua_err;
01796  if (
01797      !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
01798      !tolua_isnoobj(tolua_S,2,&tolua_err)
01799  )
01800   goto tolua_lerror;
01801  else
01802 #endif
01803  {
01804   const fawkes::TestInterface* self = (const fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
01805 #ifndef TOLUA_RELEASE
01806   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'id'",NULL);
01807 #endif
01808   {
01809    const char* tolua_ret = (const char*)  self->id();
01810    tolua_pushstring(tolua_S,(const char*)tolua_ret);
01811   }
01812  }
01813  return 1;
01814 #ifndef TOLUA_RELEASE
01815  tolua_lerror:
01816  tolua_error(tolua_S,"#ferror in function 'id'.",&tolua_err);
01817  return 0;
01818 #endif
01819 }
01820 #endif //#ifndef TOLUA_DISABLE
01821 
01822 /* method: uid of class  fawkes::TestInterface */
01823 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_uid00
01824 static int tolua_interfaces_TestInterface_fawkes_TestInterface_uid00(lua_State* tolua_S)
01825 {
01826 #ifndef TOLUA_RELEASE
01827  tolua_Error tolua_err;
01828  if (
01829      !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
01830      !tolua_isnoobj(tolua_S,2,&tolua_err)
01831  )
01832   goto tolua_lerror;
01833  else
01834 #endif
01835  {
01836   const fawkes::TestInterface* self = (const fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
01837 #ifndef TOLUA_RELEASE
01838   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'uid'",NULL);
01839 #endif
01840   {
01841    const char* tolua_ret = (const char*)  self->uid();
01842    tolua_pushstring(tolua_S,(const char*)tolua_ret);
01843   }
01844  }
01845  return 1;
01846 #ifndef TOLUA_RELEASE
01847  tolua_lerror:
01848  tolua_error(tolua_S,"#ferror in function 'uid'.",&tolua_err);
01849  return 0;
01850 #endif
01851 }
01852 #endif //#ifndef TOLUA_DISABLE
01853 
01854 /* method: serial of class  fawkes::TestInterface */
01855 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_serial00
01856 static int tolua_interfaces_TestInterface_fawkes_TestInterface_serial00(lua_State* tolua_S)
01857 {
01858 #ifndef TOLUA_RELEASE
01859  tolua_Error tolua_err;
01860  if (
01861      !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
01862      !tolua_isnoobj(tolua_S,2,&tolua_err)
01863  )
01864   goto tolua_lerror;
01865  else
01866 #endif
01867  {
01868   const fawkes::TestInterface* self = (const fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
01869 #ifndef TOLUA_RELEASE
01870   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'serial'",NULL);
01871 #endif
01872   {
01873    unsigned int tolua_ret = (unsigned int)  self->serial();
01874    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01875   }
01876  }
01877  return 1;
01878 #ifndef TOLUA_RELEASE
01879  tolua_lerror:
01880  tolua_error(tolua_S,"#ferror in function 'serial'.",&tolua_err);
01881  return 0;
01882 #endif
01883 }
01884 #endif //#ifndef TOLUA_DISABLE
01885 
01886 /* method: mem_serial of class  fawkes::TestInterface */
01887 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_mem_serial00
01888 static int tolua_interfaces_TestInterface_fawkes_TestInterface_mem_serial00(lua_State* tolua_S)
01889 {
01890 #ifndef TOLUA_RELEASE
01891  tolua_Error tolua_err;
01892  if (
01893      !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
01894      !tolua_isnoobj(tolua_S,2,&tolua_err)
01895  )
01896   goto tolua_lerror;
01897  else
01898 #endif
01899  {
01900   const fawkes::TestInterface* self = (const fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
01901 #ifndef TOLUA_RELEASE
01902   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'mem_serial'",NULL);
01903 #endif
01904   {
01905    unsigned int tolua_ret = (unsigned int)  self->mem_serial();
01906    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01907   }
01908  }
01909  return 1;
01910 #ifndef TOLUA_RELEASE
01911  tolua_lerror:
01912  tolua_error(tolua_S,"#ferror in function 'mem_serial'.",&tolua_err);
01913  return 0;
01914 #endif
01915 }
01916 #endif //#ifndef TOLUA_DISABLE
01917 
01918 /* method: operator== of class  fawkes::TestInterface */
01919 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface__eq00
01920 static int tolua_interfaces_TestInterface_fawkes_TestInterface__eq00(lua_State* tolua_S)
01921 {
01922 #ifndef TOLUA_RELEASE
01923  tolua_Error tolua_err;
01924  if (
01925      !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
01926      !tolua_isusertype(tolua_S,2,"Interface",0,&tolua_err) ||
01927      !tolua_isnoobj(tolua_S,3,&tolua_err)
01928  )
01929   goto tolua_lerror;
01930  else
01931 #endif
01932  {
01933   const fawkes::TestInterface* self = (const fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
01934   Interface* comp = ((Interface*)  tolua_tousertype(tolua_S,2,0));
01935 #ifndef TOLUA_RELEASE
01936   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='",NULL);
01937 #endif
01938   {
01939    bool tolua_ret = (bool)  self->operator==(*comp);
01940    tolua_pushboolean(tolua_S,(bool)tolua_ret);
01941   }
01942  }
01943  return 1;
01944 #ifndef TOLUA_RELEASE
01945  tolua_lerror:
01946  tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err);
01947  return 0;
01948 #endif
01949 }
01950 #endif //#ifndef TOLUA_DISABLE
01951 
01952 /* method: hash of class  fawkes::TestInterface */
01953 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_hash00
01954 static int tolua_interfaces_TestInterface_fawkes_TestInterface_hash00(lua_State* tolua_S)
01955 {
01956 #ifndef TOLUA_RELEASE
01957  tolua_Error tolua_err;
01958  if (
01959      !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
01960      !tolua_isnoobj(tolua_S,2,&tolua_err)
01961  )
01962   goto tolua_lerror;
01963  else
01964 #endif
01965  {
01966   const fawkes::TestInterface* self = (const fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
01967 #ifndef TOLUA_RELEASE
01968   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash'",NULL);
01969 #endif
01970   {
01971    unsigned const char* tolua_ret = ( unsigned const char*)  self->hash();
01972    tolua_pushstring(tolua_S,(const char*)tolua_ret);
01973   }
01974  }
01975  return 1;
01976 #ifndef TOLUA_RELEASE
01977  tolua_lerror:
01978  tolua_error(tolua_S,"#ferror in function 'hash'.",&tolua_err);
01979  return 0;
01980 #endif
01981 }
01982 #endif //#ifndef TOLUA_DISABLE
01983 
01984 /* method: hash_size of class  fawkes::TestInterface */
01985 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_hash_size00
01986 static int tolua_interfaces_TestInterface_fawkes_TestInterface_hash_size00(lua_State* tolua_S)
01987 {
01988 #ifndef TOLUA_RELEASE
01989  tolua_Error tolua_err;
01990  if (
01991      !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
01992      !tolua_isnoobj(tolua_S,2,&tolua_err)
01993  )
01994   goto tolua_lerror;
01995  else
01996 #endif
01997  {
01998   const fawkes::TestInterface* self = (const fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
01999 #ifndef TOLUA_RELEASE
02000   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash_size'",NULL);
02001 #endif
02002   {
02003    int tolua_ret = (int)  self->hash_size();
02004    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02005   }
02006  }
02007  return 1;
02008 #ifndef TOLUA_RELEASE
02009  tolua_lerror:
02010  tolua_error(tolua_S,"#ferror in function 'hash_size'.",&tolua_err);
02011  return 0;
02012 #endif
02013 }
02014 #endif //#ifndef TOLUA_DISABLE
02015 
02016 /* method: hash_printable of class  fawkes::TestInterface */
02017 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_hash_printable00
02018 static int tolua_interfaces_TestInterface_fawkes_TestInterface_hash_printable00(lua_State* tolua_S)
02019 {
02020 #ifndef TOLUA_RELEASE
02021  tolua_Error tolua_err;
02022  if (
02023      !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
02024      !tolua_isnoobj(tolua_S,2,&tolua_err)
02025  )
02026   goto tolua_lerror;
02027  else
02028 #endif
02029  {
02030   const fawkes::TestInterface* self = (const fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
02031 #ifndef TOLUA_RELEASE
02032   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash_printable'",NULL);
02033 #endif
02034   {
02035    const char* tolua_ret = (const char*)  self->hash_printable();
02036    tolua_pushstring(tolua_S,(const char*)tolua_ret);
02037   }
02038  }
02039  return 1;
02040 #ifndef TOLUA_RELEASE
02041  tolua_lerror:
02042  tolua_error(tolua_S,"#ferror in function 'hash_printable'.",&tolua_err);
02043  return 0;
02044 #endif
02045 }
02046 #endif //#ifndef TOLUA_DISABLE
02047 
02048 /* method: is_writer of class  fawkes::TestInterface */
02049 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_is_writer00
02050 static int tolua_interfaces_TestInterface_fawkes_TestInterface_is_writer00(lua_State* tolua_S)
02051 {
02052 #ifndef TOLUA_RELEASE
02053  tolua_Error tolua_err;
02054  if (
02055      !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
02056      !tolua_isnoobj(tolua_S,2,&tolua_err)
02057  )
02058   goto tolua_lerror;
02059  else
02060 #endif
02061  {
02062   const fawkes::TestInterface* self = (const fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
02063 #ifndef TOLUA_RELEASE
02064   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_writer'",NULL);
02065 #endif
02066   {
02067    bool tolua_ret = (bool)  self->is_writer();
02068    tolua_pushboolean(tolua_S,(bool)tolua_ret);
02069   }
02070  }
02071  return 1;
02072 #ifndef TOLUA_RELEASE
02073  tolua_lerror:
02074  tolua_error(tolua_S,"#ferror in function 'is_writer'.",&tolua_err);
02075  return 0;
02076 #endif
02077 }
02078 #endif //#ifndef TOLUA_DISABLE
02079 
02080 /* method: set_from_chunk of class  fawkes::TestInterface */
02081 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_set_from_chunk00
02082 static int tolua_interfaces_TestInterface_fawkes_TestInterface_set_from_chunk00(lua_State* tolua_S)
02083 {
02084 #ifndef TOLUA_RELEASE
02085  tolua_Error tolua_err;
02086  if (
02087      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
02088      !tolua_isuserdata(tolua_S,2,0,&tolua_err) ||
02089      !tolua_isnoobj(tolua_S,3,&tolua_err)
02090  )
02091   goto tolua_lerror;
02092  else
02093 #endif
02094  {
02095   fawkes::TestInterface* self = (fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
02096   void* chunk = ((void*)  tolua_touserdata(tolua_S,2,0));
02097 #ifndef TOLUA_RELEASE
02098   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_from_chunk'",NULL);
02099 #endif
02100   {
02101    self->set_from_chunk(chunk);
02102   }
02103  }
02104  return 0;
02105 #ifndef TOLUA_RELEASE
02106  tolua_lerror:
02107  tolua_error(tolua_S,"#ferror in function 'set_from_chunk'.",&tolua_err);
02108  return 0;
02109 #endif
02110 }
02111 #endif //#ifndef TOLUA_DISABLE
02112 
02113 /* method: create_message of class  fawkes::TestInterface */
02114 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_create_message00
02115 static int tolua_interfaces_TestInterface_fawkes_TestInterface_create_message00(lua_State* tolua_S)
02116 {
02117 #ifndef TOLUA_RELEASE
02118  tolua_Error tolua_err;
02119  if (
02120      !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
02121      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
02122      !tolua_isnoobj(tolua_S,3,&tolua_err)
02123  )
02124   goto tolua_lerror;
02125  else
02126 #endif
02127  {
02128   const fawkes::TestInterface* self = (const fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
02129   const char* type = ((const char*)  tolua_tostring(tolua_S,2,0));
02130 #ifndef TOLUA_RELEASE
02131   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'create_message'",NULL);
02132 #endif
02133   {
02134    Message* tolua_ret = (Message*)  self->create_message(type);
02135    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Message");
02136   }
02137  }
02138  return 1;
02139 #ifndef TOLUA_RELEASE
02140  tolua_lerror:
02141  tolua_error(tolua_S,"#ferror in function 'create_message'.",&tolua_err);
02142  return 0;
02143 #endif
02144 }
02145 #endif //#ifndef TOLUA_DISABLE
02146 
02147 /* method: read of class  fawkes::TestInterface */
02148 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_read00
02149 static int tolua_interfaces_TestInterface_fawkes_TestInterface_read00(lua_State* tolua_S)
02150 {
02151 #ifndef TOLUA_RELEASE
02152  tolua_Error tolua_err;
02153  if (
02154      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
02155      !tolua_isnoobj(tolua_S,2,&tolua_err)
02156  )
02157   goto tolua_lerror;
02158  else
02159 #endif
02160  {
02161   fawkes::TestInterface* self = (fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
02162 #ifndef TOLUA_RELEASE
02163   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'read'",NULL);
02164 #endif
02165   {
02166    self->read();
02167   }
02168  }
02169  return 0;
02170 #ifndef TOLUA_RELEASE
02171  tolua_lerror:
02172  tolua_error(tolua_S,"#ferror in function 'read'.",&tolua_err);
02173  return 0;
02174 #endif
02175 }
02176 #endif //#ifndef TOLUA_DISABLE
02177 
02178 /* method: write of class  fawkes::TestInterface */
02179 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_write00
02180 static int tolua_interfaces_TestInterface_fawkes_TestInterface_write00(lua_State* tolua_S)
02181 {
02182 #ifndef TOLUA_RELEASE
02183  tolua_Error tolua_err;
02184  if (
02185      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
02186      !tolua_isnoobj(tolua_S,2,&tolua_err)
02187  )
02188   goto tolua_lerror;
02189  else
02190 #endif
02191  {
02192   fawkes::TestInterface* self = (fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
02193 #ifndef TOLUA_RELEASE
02194   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'write'",NULL);
02195 #endif
02196   {
02197    self->write();
02198   }
02199  }
02200  return 0;
02201 #ifndef TOLUA_RELEASE
02202  tolua_lerror:
02203  tolua_error(tolua_S,"#ferror in function 'write'.",&tolua_err);
02204  return 0;
02205 #endif
02206 }
02207 #endif //#ifndef TOLUA_DISABLE
02208 
02209 /* method: has_writer of class  fawkes::TestInterface */
02210 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_has_writer00
02211 static int tolua_interfaces_TestInterface_fawkes_TestInterface_has_writer00(lua_State* tolua_S)
02212 {
02213 #ifndef TOLUA_RELEASE
02214  tolua_Error tolua_err;
02215  if (
02216      !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
02217      !tolua_isnoobj(tolua_S,2,&tolua_err)
02218  )
02219   goto tolua_lerror;
02220  else
02221 #endif
02222  {
02223   const fawkes::TestInterface* self = (const fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
02224 #ifndef TOLUA_RELEASE
02225   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'has_writer'",NULL);
02226 #endif
02227   {
02228    bool tolua_ret = (bool)  self->has_writer();
02229    tolua_pushboolean(tolua_S,(bool)tolua_ret);
02230   }
02231  }
02232  return 1;
02233 #ifndef TOLUA_RELEASE
02234  tolua_lerror:
02235  tolua_error(tolua_S,"#ferror in function 'has_writer'.",&tolua_err);
02236  return 0;
02237 #endif
02238 }
02239 #endif //#ifndef TOLUA_DISABLE
02240 
02241 /* method: num_readers of class  fawkes::TestInterface */
02242 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_num_readers00
02243 static int tolua_interfaces_TestInterface_fawkes_TestInterface_num_readers00(lua_State* tolua_S)
02244 {
02245 #ifndef TOLUA_RELEASE
02246  tolua_Error tolua_err;
02247  if (
02248      !tolua_isusertype(tolua_S,1,"const fawkes::TestInterface",0,&tolua_err) ||
02249      !tolua_isnoobj(tolua_S,2,&tolua_err)
02250  )
02251   goto tolua_lerror;
02252  else
02253 #endif
02254  {
02255   const fawkes::TestInterface* self = (const fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
02256 #ifndef TOLUA_RELEASE
02257   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'num_readers'",NULL);
02258 #endif
02259   {
02260    unsigned int tolua_ret = (unsigned int)  self->num_readers();
02261    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02262   }
02263  }
02264  return 1;
02265 #ifndef TOLUA_RELEASE
02266  tolua_lerror:
02267  tolua_error(tolua_S,"#ferror in function 'num_readers'.",&tolua_err);
02268  return 0;
02269 #endif
02270 }
02271 #endif //#ifndef TOLUA_DISABLE
02272 
02273 /* method: msgq_enqueue_copy of class  fawkes::TestInterface */
02274 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_enqueue_copy00
02275 static int tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_enqueue_copy00(lua_State* tolua_S)
02276 {
02277 #ifndef TOLUA_RELEASE
02278  tolua_Error tolua_err;
02279  if (
02280      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
02281      !tolua_isusertype(tolua_S,2,"Message",0,&tolua_err) ||
02282      !tolua_isnoobj(tolua_S,3,&tolua_err)
02283  )
02284   goto tolua_lerror;
02285  else
02286 #endif
02287  {
02288   fawkes::TestInterface* self = (fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
02289   Message* message = ((Message*)  tolua_tousertype(tolua_S,2,0));
02290 #ifndef TOLUA_RELEASE
02291   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_enqueue_copy'",NULL);
02292 #endif
02293   {
02294    unsigned int tolua_ret = (unsigned int)  self->msgq_enqueue_copy(message);
02295    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02296   }
02297  }
02298  return 1;
02299 #ifndef TOLUA_RELEASE
02300  tolua_lerror:
02301  tolua_error(tolua_S,"#ferror in function 'msgq_enqueue_copy'.",&tolua_err);
02302  return 0;
02303 #endif
02304 }
02305 #endif //#ifndef TOLUA_DISABLE
02306 
02307 /* method: msgq_remove of class  fawkes::TestInterface */
02308 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_remove00
02309 static int tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_remove00(lua_State* tolua_S)
02310 {
02311 #ifndef TOLUA_RELEASE
02312  tolua_Error tolua_err;
02313  if (
02314      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
02315      !tolua_isusertype(tolua_S,2,"Message",0,&tolua_err) ||
02316      !tolua_isnoobj(tolua_S,3,&tolua_err)
02317  )
02318   goto tolua_lerror;
02319  else
02320 #endif
02321  {
02322   fawkes::TestInterface* self = (fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
02323   Message* message = ((Message*)  tolua_tousertype(tolua_S,2,0));
02324 #ifndef TOLUA_RELEASE
02325   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_remove'",NULL);
02326 #endif
02327   {
02328    self->msgq_remove(message);
02329   }
02330  }
02331  return 0;
02332 #ifndef TOLUA_RELEASE
02333  tolua_lerror:
02334  tolua_error(tolua_S,"#ferror in function 'msgq_remove'.",&tolua_err);
02335  return 0;
02336 #endif
02337 }
02338 #endif //#ifndef TOLUA_DISABLE
02339 
02340 /* method: msgq_remove of class  fawkes::TestInterface */
02341 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_remove01
02342 static int tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_remove01(lua_State* tolua_S)
02343 {
02344  tolua_Error tolua_err;
02345  if (
02346      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
02347      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02348      !tolua_isnoobj(tolua_S,3,&tolua_err)
02349  )
02350   goto tolua_lerror;
02351  else
02352  {
02353   fawkes::TestInterface* self = (fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
02354   unsigned int message_id = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
02355 #ifndef TOLUA_RELEASE
02356   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_remove'",NULL);
02357 #endif
02358   {
02359    self->msgq_remove(message_id);
02360   }
02361  }
02362  return 0;
02363 tolua_lerror:
02364  return tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_remove00(tolua_S);
02365 }
02366 #endif //#ifndef TOLUA_DISABLE
02367 
02368 /* method: msgq_size of class  fawkes::TestInterface */
02369 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_size00
02370 static int tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_size00(lua_State* tolua_S)
02371 {
02372 #ifndef TOLUA_RELEASE
02373  tolua_Error tolua_err;
02374  if (
02375      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
02376      !tolua_isnoobj(tolua_S,2,&tolua_err)
02377  )
02378   goto tolua_lerror;
02379  else
02380 #endif
02381  {
02382   fawkes::TestInterface* self = (fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
02383 #ifndef TOLUA_RELEASE
02384   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_size'",NULL);
02385 #endif
02386   {
02387    unsigned int tolua_ret = (unsigned int)  self->msgq_size();
02388    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02389   }
02390  }
02391  return 1;
02392 #ifndef TOLUA_RELEASE
02393  tolua_lerror:
02394  tolua_error(tolua_S,"#ferror in function 'msgq_size'.",&tolua_err);
02395  return 0;
02396 #endif
02397 }
02398 #endif //#ifndef TOLUA_DISABLE
02399 
02400 /* method: msgq_flush of class  fawkes::TestInterface */
02401 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_flush00
02402 static int tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_flush00(lua_State* tolua_S)
02403 {
02404 #ifndef TOLUA_RELEASE
02405  tolua_Error tolua_err;
02406  if (
02407      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
02408      !tolua_isnoobj(tolua_S,2,&tolua_err)
02409  )
02410   goto tolua_lerror;
02411  else
02412 #endif
02413  {
02414   fawkes::TestInterface* self = (fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
02415 #ifndef TOLUA_RELEASE
02416   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_flush'",NULL);
02417 #endif
02418   {
02419    self->msgq_flush();
02420   }
02421  }
02422  return 0;
02423 #ifndef TOLUA_RELEASE
02424  tolua_lerror:
02425  tolua_error(tolua_S,"#ferror in function 'msgq_flush'.",&tolua_err);
02426  return 0;
02427 #endif
02428 }
02429 #endif //#ifndef TOLUA_DISABLE
02430 
02431 /* method: msgq_lock of class  fawkes::TestInterface */
02432 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_lock00
02433 static int tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_lock00(lua_State* tolua_S)
02434 {
02435 #ifndef TOLUA_RELEASE
02436  tolua_Error tolua_err;
02437  if (
02438      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
02439      !tolua_isnoobj(tolua_S,2,&tolua_err)
02440  )
02441   goto tolua_lerror;
02442  else
02443 #endif
02444  {
02445   fawkes::TestInterface* self = (fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
02446 #ifndef TOLUA_RELEASE
02447   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_lock'",NULL);
02448 #endif
02449   {
02450    self->msgq_lock();
02451   }
02452  }
02453  return 0;
02454 #ifndef TOLUA_RELEASE
02455  tolua_lerror:
02456  tolua_error(tolua_S,"#ferror in function 'msgq_lock'.",&tolua_err);
02457  return 0;
02458 #endif
02459 }
02460 #endif //#ifndef TOLUA_DISABLE
02461 
02462 /* method: msgq_try_lock of class  fawkes::TestInterface */
02463 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_try_lock00
02464 static int tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_try_lock00(lua_State* tolua_S)
02465 {
02466 #ifndef TOLUA_RELEASE
02467  tolua_Error tolua_err;
02468  if (
02469      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
02470      !tolua_isnoobj(tolua_S,2,&tolua_err)
02471  )
02472   goto tolua_lerror;
02473  else
02474 #endif
02475  {
02476   fawkes::TestInterface* self = (fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
02477 #ifndef TOLUA_RELEASE
02478   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_try_lock'",NULL);
02479 #endif
02480   {
02481    bool tolua_ret = (bool)  self->msgq_try_lock();
02482    tolua_pushboolean(tolua_S,(bool)tolua_ret);
02483   }
02484  }
02485  return 1;
02486 #ifndef TOLUA_RELEASE
02487  tolua_lerror:
02488  tolua_error(tolua_S,"#ferror in function 'msgq_try_lock'.",&tolua_err);
02489  return 0;
02490 #endif
02491 }
02492 #endif //#ifndef TOLUA_DISABLE
02493 
02494 /* method: msgq_unlock of class  fawkes::TestInterface */
02495 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_unlock00
02496 static int tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_unlock00(lua_State* tolua_S)
02497 {
02498 #ifndef TOLUA_RELEASE
02499  tolua_Error tolua_err;
02500  if (
02501      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
02502      !tolua_isnoobj(tolua_S,2,&tolua_err)
02503  )
02504   goto tolua_lerror;
02505  else
02506 #endif
02507  {
02508   fawkes::TestInterface* self = (fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
02509 #ifndef TOLUA_RELEASE
02510   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_unlock'",NULL);
02511 #endif
02512   {
02513    self->msgq_unlock();
02514   }
02515  }
02516  return 0;
02517 #ifndef TOLUA_RELEASE
02518  tolua_lerror:
02519  tolua_error(tolua_S,"#ferror in function 'msgq_unlock'.",&tolua_err);
02520  return 0;
02521 #endif
02522 }
02523 #endif //#ifndef TOLUA_DISABLE
02524 
02525 /* method: msgq_pop of class  fawkes::TestInterface */
02526 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_pop00
02527 static int tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_pop00(lua_State* tolua_S)
02528 {
02529 #ifndef TOLUA_RELEASE
02530  tolua_Error tolua_err;
02531  if (
02532      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
02533      !tolua_isnoobj(tolua_S,2,&tolua_err)
02534  )
02535   goto tolua_lerror;
02536  else
02537 #endif
02538  {
02539   fawkes::TestInterface* self = (fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
02540 #ifndef TOLUA_RELEASE
02541   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_pop'",NULL);
02542 #endif
02543   {
02544    self->msgq_pop();
02545   }
02546  }
02547  return 0;
02548 #ifndef TOLUA_RELEASE
02549  tolua_lerror:
02550  tolua_error(tolua_S,"#ferror in function 'msgq_pop'.",&tolua_err);
02551  return 0;
02552 #endif
02553 }
02554 #endif //#ifndef TOLUA_DISABLE
02555 
02556 /* method: msgq_first of class  fawkes::TestInterface */
02557 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_first00
02558 static int tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_first00(lua_State* tolua_S)
02559 {
02560 #ifndef TOLUA_RELEASE
02561  tolua_Error tolua_err;
02562  if (
02563      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
02564      !tolua_isnoobj(tolua_S,2,&tolua_err)
02565  )
02566   goto tolua_lerror;
02567  else
02568 #endif
02569  {
02570   fawkes::TestInterface* self = (fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
02571 #ifndef TOLUA_RELEASE
02572   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_first'",NULL);
02573 #endif
02574   {
02575    Message* tolua_ret = (Message*)  self->msgq_first();
02576    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Message");
02577   }
02578  }
02579  return 1;
02580 #ifndef TOLUA_RELEASE
02581  tolua_lerror:
02582  tolua_error(tolua_S,"#ferror in function 'msgq_first'.",&tolua_err);
02583  return 0;
02584 #endif
02585 }
02586 #endif //#ifndef TOLUA_DISABLE
02587 
02588 /* method: msgq_empty of class  fawkes::TestInterface */
02589 #ifndef TOLUA_DISABLE_tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_empty00
02590 static int tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_empty00(lua_State* tolua_S)
02591 {
02592 #ifndef TOLUA_RELEASE
02593  tolua_Error tolua_err;
02594  if (
02595      !tolua_isusertype(tolua_S,1,"fawkes::TestInterface",0,&tolua_err) ||
02596      !tolua_isnoobj(tolua_S,2,&tolua_err)
02597  )
02598   goto tolua_lerror;
02599  else
02600 #endif
02601  {
02602   fawkes::TestInterface* self = (fawkes::TestInterface*)  tolua_tousertype(tolua_S,1,0);
02603 #ifndef TOLUA_RELEASE
02604   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_empty'",NULL);
02605 #endif
02606   {
02607    bool tolua_ret = (bool)  self->msgq_empty();
02608    tolua_pushboolean(tolua_S,(bool)tolua_ret);
02609   }
02610  }
02611  return 1;
02612 #ifndef TOLUA_RELEASE
02613  tolua_lerror:
02614  tolua_error(tolua_S,"#ferror in function 'msgq_empty'.",&tolua_err);
02615  return 0;
02616 #endif
02617 }
02618 #endif //#ifndef TOLUA_DISABLE
02619 
02620 /* Open function */
02621 TOLUA_API int tolua_interfaces_TestInterface_open (lua_State* tolua_S)
02622 {
02623  tolua_open(tolua_S);
02624  tolua_reg_types(tolua_S);
02625  tolua_module(tolua_S,NULL,0);
02626  tolua_beginmodule(tolua_S,NULL);
02627   tolua_module(tolua_S,"fawkes",0);
02628   tolua_beginmodule(tolua_S,"fawkes");
02629    tolua_cclass(tolua_S,"TestInterface","fawkes::TestInterface","Interface",NULL);
02630    tolua_beginmodule(tolua_S,"TestInterface");
02631     tolua_variable(tolua_S,"TEST_CONSTANT",tolua_get_fawkes__TestInterface_TEST_CONSTANT,NULL);
02632     tolua_variable(tolua_S,"TEST_FLOAT_CONSTANT",tolua_get_fawkes__TestInterface_TEST_FLOAT_CONSTANT,NULL);
02633     tolua_constant(tolua_S,"TEST_ENUM_1",fawkes::TestInterface::TEST_ENUM_1);
02634     tolua_constant(tolua_S,"TEST_ENUM_2",fawkes::TestInterface::TEST_ENUM_2);
02635     #ifdef __cplusplus
02636     tolua_cclass(tolua_S,"SetTestIntMessage","fawkes::TestInterface::SetTestIntMessage","Message",tolua_collect_fawkes__TestInterface__SetTestIntMessage);
02637     #else
02638     tolua_cclass(tolua_S,"SetTestIntMessage","fawkes::TestInterface::SetTestIntMessage","Message",NULL);
02639     #endif
02640     tolua_beginmodule(tolua_S,"SetTestIntMessage");
02641      tolua_function(tolua_S,"new",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_new00);
02642      tolua_function(tolua_S,"new_local",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_new00_local);
02643      tolua_function(tolua_S,".call",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_new00_local);
02644      tolua_function(tolua_S,"new",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_new01);
02645      tolua_function(tolua_S,"new_local",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_new01_local);
02646      tolua_function(tolua_S,".call",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_new01_local);
02647      tolua_function(tolua_S,"delete",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_delete00);
02648      tolua_function(tolua_S,"test_int",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_test_int00);
02649      tolua_function(tolua_S,"set_test_int",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_set_test_int00);
02650      tolua_function(tolua_S,"maxlenof_test_int",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestIntMessage_maxlenof_test_int00);
02651     tolua_endmodule(tolua_S);
02652     #ifdef __cplusplus
02653     tolua_cclass(tolua_S,"SetTestStringMessage","fawkes::TestInterface::SetTestStringMessage","Message",tolua_collect_fawkes__TestInterface__SetTestStringMessage);
02654     #else
02655     tolua_cclass(tolua_S,"SetTestStringMessage","fawkes::TestInterface::SetTestStringMessage","Message",NULL);
02656     #endif
02657     tolua_beginmodule(tolua_S,"SetTestStringMessage");
02658      tolua_function(tolua_S,"new",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_new00);
02659      tolua_function(tolua_S,"new_local",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_new00_local);
02660      tolua_function(tolua_S,".call",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_new00_local);
02661      tolua_function(tolua_S,"new",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_new01);
02662      tolua_function(tolua_S,"new_local",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_new01_local);
02663      tolua_function(tolua_S,".call",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_new01_local);
02664      tolua_function(tolua_S,"delete",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_delete00);
02665      tolua_function(tolua_S,"test_string",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_test_string00);
02666      tolua_function(tolua_S,"set_test_string",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_set_test_string00);
02667      tolua_function(tolua_S,"maxlenof_test_string",tolua_interfaces_TestInterface_fawkes_TestInterface_SetTestStringMessage_maxlenof_test_string00);
02668     tolua_endmodule(tolua_S);
02669     #ifdef __cplusplus
02670     tolua_cclass(tolua_S,"CalculateMessage","fawkes::TestInterface::CalculateMessage","Message",tolua_collect_fawkes__TestInterface__CalculateMessage);
02671     #else
02672     tolua_cclass(tolua_S,"CalculateMessage","fawkes::TestInterface::CalculateMessage","Message",NULL);
02673     #endif
02674     tolua_beginmodule(tolua_S,"CalculateMessage");
02675      tolua_function(tolua_S,"new",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_new00);
02676      tolua_function(tolua_S,"new_local",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_new00_local);
02677      tolua_function(tolua_S,".call",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_new00_local);
02678      tolua_function(tolua_S,"new",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_new01);
02679      tolua_function(tolua_S,"new_local",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_new01_local);
02680      tolua_function(tolua_S,".call",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_new01_local);
02681      tolua_function(tolua_S,"delete",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_delete00);
02682      tolua_function(tolua_S,"summand",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_summand00);
02683      tolua_function(tolua_S,"set_summand",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_set_summand00);
02684      tolua_function(tolua_S,"maxlenof_summand",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_maxlenof_summand00);
02685      tolua_function(tolua_S,"addend",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_addend00);
02686      tolua_function(tolua_S,"set_addend",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_set_addend00);
02687      tolua_function(tolua_S,"maxlenof_addend",tolua_interfaces_TestInterface_fawkes_TestInterface_CalculateMessage_maxlenof_addend00);
02688     tolua_endmodule(tolua_S);
02689     tolua_function(tolua_S,"is_test_bool",tolua_interfaces_TestInterface_fawkes_TestInterface_is_test_bool00);
02690     tolua_function(tolua_S,"set_test_bool",tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_bool00);
02691     tolua_function(tolua_S,"maxlenof_test_bool",tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_bool00);
02692     tolua_function(tolua_S,"test_int",tolua_interfaces_TestInterface_fawkes_TestInterface_test_int00);
02693     tolua_function(tolua_S,"set_test_int",tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_int00);
02694     tolua_function(tolua_S,"maxlenof_test_int",tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_int00);
02695     tolua_function(tolua_S,"flags",tolua_interfaces_TestInterface_fawkes_TestInterface_flags00);
02696     tolua_function(tolua_S,"set_flags",tolua_interfaces_TestInterface_fawkes_TestInterface_set_flags00);
02697     tolua_function(tolua_S,"maxlenof_flags",tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_flags00);
02698     tolua_function(tolua_S,"test_string",tolua_interfaces_TestInterface_fawkes_TestInterface_test_string00);
02699     tolua_function(tolua_S,"set_test_string",tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_string00);
02700     tolua_function(tolua_S,"maxlenof_test_string",tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_string00);
02701     tolua_function(tolua_S,"result",tolua_interfaces_TestInterface_fawkes_TestInterface_result00);
02702     tolua_function(tolua_S,"set_result",tolua_interfaces_TestInterface_fawkes_TestInterface_set_result00);
02703     tolua_function(tolua_S,"maxlenof_result",tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_result00);
02704     tolua_function(tolua_S,"test_uint",tolua_interfaces_TestInterface_fawkes_TestInterface_test_uint00);
02705     tolua_function(tolua_S,"set_test_uint",tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_uint00);
02706     tolua_function(tolua_S,"maxlenof_test_uint",tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_uint00);
02707     tolua_function(tolua_S,"test_ulint",tolua_interfaces_TestInterface_fawkes_TestInterface_test_ulint00);
02708     tolua_function(tolua_S,"set_test_ulint",tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_ulint00);
02709     tolua_function(tolua_S,"maxlenof_test_ulint",tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_ulint00);
02710     tolua_function(tolua_S,"test_lint",tolua_interfaces_TestInterface_fawkes_TestInterface_test_lint00);
02711     tolua_function(tolua_S,"set_test_lint",tolua_interfaces_TestInterface_fawkes_TestInterface_set_test_lint00);
02712     tolua_function(tolua_S,"maxlenof_test_lint",tolua_interfaces_TestInterface_fawkes_TestInterface_maxlenof_test_lint00);
02713     tolua_function(tolua_S,"oftype",tolua_interfaces_TestInterface_fawkes_TestInterface_oftype00);
02714     tolua_function(tolua_S,"datachunk",tolua_interfaces_TestInterface_fawkes_TestInterface_datachunk00);
02715     tolua_function(tolua_S,"datasize",tolua_interfaces_TestInterface_fawkes_TestInterface_datasize00);
02716     tolua_function(tolua_S,"type",tolua_interfaces_TestInterface_fawkes_TestInterface_type00);
02717     tolua_function(tolua_S,"id",tolua_interfaces_TestInterface_fawkes_TestInterface_id00);
02718     tolua_function(tolua_S,"uid",tolua_interfaces_TestInterface_fawkes_TestInterface_uid00);
02719     tolua_function(tolua_S,"serial",tolua_interfaces_TestInterface_fawkes_TestInterface_serial00);
02720     tolua_function(tolua_S,"mem_serial",tolua_interfaces_TestInterface_fawkes_TestInterface_mem_serial00);
02721     tolua_function(tolua_S,".eq",tolua_interfaces_TestInterface_fawkes_TestInterface__eq00);
02722     tolua_function(tolua_S,"hash",tolua_interfaces_TestInterface_fawkes_TestInterface_hash00);
02723     tolua_function(tolua_S,"hash_size",tolua_interfaces_TestInterface_fawkes_TestInterface_hash_size00);
02724     tolua_function(tolua_S,"hash_printable",tolua_interfaces_TestInterface_fawkes_TestInterface_hash_printable00);
02725     tolua_function(tolua_S,"is_writer",tolua_interfaces_TestInterface_fawkes_TestInterface_is_writer00);
02726     tolua_function(tolua_S,"set_from_chunk",tolua_interfaces_TestInterface_fawkes_TestInterface_set_from_chunk00);
02727     tolua_function(tolua_S,"create_message",tolua_interfaces_TestInterface_fawkes_TestInterface_create_message00);
02728     tolua_function(tolua_S,"read",tolua_interfaces_TestInterface_fawkes_TestInterface_read00);
02729     tolua_function(tolua_S,"write",tolua_interfaces_TestInterface_fawkes_TestInterface_write00);
02730     tolua_function(tolua_S,"has_writer",tolua_interfaces_TestInterface_fawkes_TestInterface_has_writer00);
02731     tolua_function(tolua_S,"num_readers",tolua_interfaces_TestInterface_fawkes_TestInterface_num_readers00);
02732     tolua_function(tolua_S,"msgq_enqueue_copy",tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_enqueue_copy00);
02733     tolua_function(tolua_S,"msgq_remove",tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_remove00);
02734     tolua_function(tolua_S,"msgq_remove",tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_remove01);
02735     tolua_function(tolua_S,"msgq_size",tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_size00);
02736     tolua_function(tolua_S,"msgq_flush",tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_flush00);
02737     tolua_function(tolua_S,"msgq_lock",tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_lock00);
02738     tolua_function(tolua_S,"msgq_try_lock",tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_try_lock00);
02739     tolua_function(tolua_S,"msgq_unlock",tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_unlock00);
02740     tolua_function(tolua_S,"msgq_pop",tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_pop00);
02741     tolua_function(tolua_S,"msgq_first",tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_first00);
02742     tolua_function(tolua_S,"msgq_empty",tolua_interfaces_TestInterface_fawkes_TestInterface_msgq_empty00);
02743    tolua_endmodule(tolua_S);
02744   tolua_endmodule(tolua_S);
02745  tolua_endmodule(tolua_S);
02746  return 1;
02747 }
02748
02749
02750 extern "C" {
02751 #if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501
02752  TOLUA_API int luaopen_interfaces_TestInterface (lua_State* tolua_S) {
02753  return tolua_interfaces_TestInterface_open(tolua_S);
02754 };
02755 #endif
02756 }
02757
02758