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