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