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         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         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   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 = new std::list<std::string>(tolua_ret);
00623     tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"std::list<std::string>");
00624 #else
00625     void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(std::list<std::string>));
00626     tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"std::list<std::string>");
00627 #endif
00628    }
00629   }
00630  }
00631  return 1;
00632 #ifndef TOLUA_RELEASE
00633  tolua_lerror:
00634  tolua_error(tolua_S,"#ferror in function 'tags'.",&tolua_err);
00635  return 0;
00636 #endif
00637 }
00638 #endif //#ifndef TOLUA_DISABLE
00639 
00640 /* method: exists of class  fawkes::Configuration */
00641 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_exists00
00642 static int tolua_fawkesconfig_fawkes_Configuration_exists00(lua_State* tolua_S)
00643 {
00644 #ifndef TOLUA_RELEASE
00645  tolua_Error tolua_err;
00646  if (
00647      !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
00648      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
00649      !tolua_isnoobj(tolua_S,3,&tolua_err)
00650  )
00651   goto tolua_lerror;
00652  else
00653 #endif
00654  {
00655   fawkes::Configuration* self = (fawkes::Configuration*)  tolua_tousertype(tolua_S,1,0);
00656   const char* path = ((const char*)  tolua_tostring(tolua_S,2,0));
00657 #ifndef TOLUA_RELEASE
00658   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'exists'",NULL);
00659 #endif
00660   {
00661    bool tolua_ret = (bool)  self->exists(path);
00662    tolua_pushboolean(tolua_S,(bool)tolua_ret);
00663   }
00664  }
00665  return 1;
00666 #ifndef TOLUA_RELEASE
00667  tolua_lerror:
00668  tolua_error(tolua_S,"#ferror in function 'exists'.",&tolua_err);
00669  return 0;
00670 #endif
00671 }
00672 #endif //#ifndef TOLUA_DISABLE
00673 
00674 /* method: is_float of class  fawkes::Configuration */
00675 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_is_float00
00676 static int tolua_fawkesconfig_fawkes_Configuration_is_float00(lua_State* tolua_S)
00677 {
00678 #ifndef TOLUA_RELEASE
00679  tolua_Error tolua_err;
00680  if (
00681      !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
00682      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
00683      !tolua_isnoobj(tolua_S,3,&tolua_err)
00684  )
00685   goto tolua_lerror;
00686  else
00687 #endif
00688  {
00689   fawkes::Configuration* self = (fawkes::Configuration*)  tolua_tousertype(tolua_S,1,0);
00690   const char* path = ((const char*)  tolua_tostring(tolua_S,2,0));
00691 #ifndef TOLUA_RELEASE
00692   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_float'",NULL);
00693 #endif
00694   {
00695    bool tolua_ret = (bool)  self->is_float(path);
00696    tolua_pushboolean(tolua_S,(bool)tolua_ret);
00697   }
00698  }
00699  return 1;
00700 #ifndef TOLUA_RELEASE
00701  tolua_lerror:
00702  tolua_error(tolua_S,"#ferror in function 'is_float'.",&tolua_err);
00703  return 0;
00704 #endif
00705 }
00706 #endif //#ifndef TOLUA_DISABLE
00707 
00708 /* method: is_uint of class  fawkes::Configuration */
00709 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_is_uint00
00710 static int tolua_fawkesconfig_fawkes_Configuration_is_uint00(lua_State* tolua_S)
00711 {
00712 #ifndef TOLUA_RELEASE
00713  tolua_Error tolua_err;
00714  if (
00715      !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
00716      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
00717      !tolua_isnoobj(tolua_S,3,&tolua_err)
00718  )
00719   goto tolua_lerror;
00720  else
00721 #endif
00722  {
00723   fawkes::Configuration* self = (fawkes::Configuration*)  tolua_tousertype(tolua_S,1,0);
00724   const char* path = ((const char*)  tolua_tostring(tolua_S,2,0));
00725 #ifndef TOLUA_RELEASE
00726   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_uint'",NULL);
00727 #endif
00728   {
00729    bool tolua_ret = (bool)  self->is_uint(path);
00730    tolua_pushboolean(tolua_S,(bool)tolua_ret);
00731   }
00732  }
00733  return 1;
00734 #ifndef TOLUA_RELEASE
00735  tolua_lerror:
00736  tolua_error(tolua_S,"#ferror in function 'is_uint'.",&tolua_err);
00737  return 0;
00738 #endif
00739 }
00740 #endif //#ifndef TOLUA_DISABLE
00741 
00742 /* method: is_int of class  fawkes::Configuration */
00743 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_is_int00
00744 static int tolua_fawkesconfig_fawkes_Configuration_is_int00(lua_State* tolua_S)
00745 {
00746 #ifndef TOLUA_RELEASE
00747  tolua_Error tolua_err;
00748  if (
00749      !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
00750      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
00751      !tolua_isnoobj(tolua_S,3,&tolua_err)
00752  )
00753   goto tolua_lerror;
00754  else
00755 #endif
00756  {
00757   fawkes::Configuration* self = (fawkes::Configuration*)  tolua_tousertype(tolua_S,1,0);
00758   const char* path = ((const char*)  tolua_tostring(tolua_S,2,0));
00759 #ifndef TOLUA_RELEASE
00760   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_int'",NULL);
00761 #endif
00762   {
00763    bool tolua_ret = (bool)  self->is_int(path);
00764    tolua_pushboolean(tolua_S,(bool)tolua_ret);
00765   }
00766  }
00767  return 1;
00768 #ifndef TOLUA_RELEASE
00769  tolua_lerror:
00770  tolua_error(tolua_S,"#ferror in function 'is_int'.",&tolua_err);
00771  return 0;
00772 #endif
00773 }
00774 #endif //#ifndef TOLUA_DISABLE
00775 
00776 /* method: is_bool of class  fawkes::Configuration */
00777 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_is_bool00
00778 static int tolua_fawkesconfig_fawkes_Configuration_is_bool00(lua_State* tolua_S)
00779 {
00780 #ifndef TOLUA_RELEASE
00781  tolua_Error tolua_err;
00782  if (
00783      !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
00784      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
00785      !tolua_isnoobj(tolua_S,3,&tolua_err)
00786  )
00787   goto tolua_lerror;
00788  else
00789 #endif
00790  {
00791   fawkes::Configuration* self = (fawkes::Configuration*)  tolua_tousertype(tolua_S,1,0);
00792   const char* path = ((const char*)  tolua_tostring(tolua_S,2,0));
00793 #ifndef TOLUA_RELEASE
00794   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_bool'",NULL);
00795 #endif
00796   {
00797    bool tolua_ret = (bool)  self->is_bool(path);
00798    tolua_pushboolean(tolua_S,(bool)tolua_ret);
00799   }
00800  }
00801  return 1;
00802 #ifndef TOLUA_RELEASE
00803  tolua_lerror:
00804  tolua_error(tolua_S,"#ferror in function 'is_bool'.",&tolua_err);
00805  return 0;
00806 #endif
00807 }
00808 #endif //#ifndef TOLUA_DISABLE
00809 
00810 /* method: is_string of class  fawkes::Configuration */
00811 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_is_string00
00812 static int tolua_fawkesconfig_fawkes_Configuration_is_string00(lua_State* tolua_S)
00813 {
00814 #ifndef TOLUA_RELEASE
00815  tolua_Error tolua_err;
00816  if (
00817      !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
00818      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
00819      !tolua_isnoobj(tolua_S,3,&tolua_err)
00820  )
00821   goto tolua_lerror;
00822  else
00823 #endif
00824  {
00825   fawkes::Configuration* self = (fawkes::Configuration*)  tolua_tousertype(tolua_S,1,0);
00826   const char* path = ((const char*)  tolua_tostring(tolua_S,2,0));
00827 #ifndef TOLUA_RELEASE
00828   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_string'",NULL);
00829 #endif
00830   {
00831    bool tolua_ret = (bool)  self->is_string(path);
00832    tolua_pushboolean(tolua_S,(bool)tolua_ret);
00833   }
00834  }
00835  return 1;
00836 #ifndef TOLUA_RELEASE
00837  tolua_lerror:
00838  tolua_error(tolua_S,"#ferror in function 'is_string'.",&tolua_err);
00839  return 0;
00840 #endif
00841 }
00842 #endif //#ifndef TOLUA_DISABLE
00843 
00844 /* method: is_default of class  fawkes::Configuration */
00845 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_is_default00
00846 static int tolua_fawkesconfig_fawkes_Configuration_is_default00(lua_State* tolua_S)
00847 {
00848 #ifndef TOLUA_RELEASE
00849  tolua_Error tolua_err;
00850  if (
00851      !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
00852      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
00853      !tolua_isnoobj(tolua_S,3,&tolua_err)
00854  )
00855   goto tolua_lerror;
00856  else
00857 #endif
00858  {
00859   fawkes::Configuration* self = (fawkes::Configuration*)  tolua_tousertype(tolua_S,1,0);
00860   const char* path = ((const char*)  tolua_tostring(tolua_S,2,0));
00861 #ifndef TOLUA_RELEASE
00862   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_default'",NULL);
00863 #endif
00864   {
00865    bool tolua_ret = (bool)  self->is_default(path);
00866    tolua_pushboolean(tolua_S,(bool)tolua_ret);
00867   }
00868  }
00869  return 1;
00870 #ifndef TOLUA_RELEASE
00871  tolua_lerror:
00872  tolua_error(tolua_S,"#ferror in function 'is_default'.",&tolua_err);
00873  return 0;
00874 #endif
00875 }
00876 #endif //#ifndef TOLUA_DISABLE
00877 
00878 /* method: get_float of class  fawkes::Configuration */
00879 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_get_float00
00880 static int tolua_fawkesconfig_fawkes_Configuration_get_float00(lua_State* tolua_S)
00881 {
00882 #ifndef TOLUA_RELEASE
00883  tolua_Error tolua_err;
00884  if (
00885      !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
00886      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
00887      !tolua_isnoobj(tolua_S,3,&tolua_err)
00888  )
00889   goto tolua_lerror;
00890  else
00891 #endif
00892  {
00893   fawkes::Configuration* self = (fawkes::Configuration*)  tolua_tousertype(tolua_S,1,0);
00894   const char* path = ((const char*)  tolua_tostring(tolua_S,2,0));
00895 #ifndef TOLUA_RELEASE
00896   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_float'",NULL);
00897 #endif
00898   {
00899    float tolua_ret = (float)  self->get_float(path);
00900    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00901   }
00902  }
00903  return 1;
00904 #ifndef TOLUA_RELEASE
00905  tolua_lerror:
00906  tolua_error(tolua_S,"#ferror in function 'get_float'.",&tolua_err);
00907  return 0;
00908 #endif
00909 }
00910 #endif //#ifndef TOLUA_DISABLE
00911 
00912 /* method: get_uint of class  fawkes::Configuration */
00913 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_get_uint00
00914 static int tolua_fawkesconfig_fawkes_Configuration_get_uint00(lua_State* tolua_S)
00915 {
00916 #ifndef TOLUA_RELEASE
00917  tolua_Error tolua_err;
00918  if (
00919      !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
00920      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
00921      !tolua_isnoobj(tolua_S,3,&tolua_err)
00922  )
00923   goto tolua_lerror;
00924  else
00925 #endif
00926  {
00927   fawkes::Configuration* self = (fawkes::Configuration*)  tolua_tousertype(tolua_S,1,0);
00928   const char* path = ((const char*)  tolua_tostring(tolua_S,2,0));
00929 #ifndef TOLUA_RELEASE
00930   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_uint'",NULL);
00931 #endif
00932   {
00933    unsigned int tolua_ret = (unsigned int)  self->get_uint(path);
00934    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00935   }
00936  }
00937  return 1;
00938 #ifndef TOLUA_RELEASE
00939  tolua_lerror:
00940  tolua_error(tolua_S,"#ferror in function 'get_uint'.",&tolua_err);
00941  return 0;
00942 #endif
00943 }
00944 #endif //#ifndef TOLUA_DISABLE
00945 
00946 /* method: get_int of class  fawkes::Configuration */
00947 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_get_int00
00948 static int tolua_fawkesconfig_fawkes_Configuration_get_int00(lua_State* tolua_S)
00949 {
00950 #ifndef TOLUA_RELEASE
00951  tolua_Error tolua_err;
00952  if (
00953      !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
00954      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
00955      !tolua_isnoobj(tolua_S,3,&tolua_err)
00956  )
00957   goto tolua_lerror;
00958  else
00959 #endif
00960  {
00961   fawkes::Configuration* self = (fawkes::Configuration*)  tolua_tousertype(tolua_S,1,0);
00962   const char* path = ((const char*)  tolua_tostring(tolua_S,2,0));
00963 #ifndef TOLUA_RELEASE
00964   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_int'",NULL);
00965 #endif
00966   {
00967    int tolua_ret = (int)  self->get_int(path);
00968    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00969   }
00970  }
00971  return 1;
00972 #ifndef TOLUA_RELEASE
00973  tolua_lerror:
00974  tolua_error(tolua_S,"#ferror in function 'get_int'.",&tolua_err);
00975  return 0;
00976 #endif
00977 }
00978 #endif //#ifndef TOLUA_DISABLE
00979 
00980 /* method: get_bool of class  fawkes::Configuration */
00981 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_get_bool00
00982 static int tolua_fawkesconfig_fawkes_Configuration_get_bool00(lua_State* tolua_S)
00983 {
00984 #ifndef TOLUA_RELEASE
00985  tolua_Error tolua_err;
00986  if (
00987      !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
00988      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
00989      !tolua_isnoobj(tolua_S,3,&tolua_err)
00990  )
00991   goto tolua_lerror;
00992  else
00993 #endif
00994  {
00995   fawkes::Configuration* self = (fawkes::Configuration*)  tolua_tousertype(tolua_S,1,0);
00996   const char* path = ((const char*)  tolua_tostring(tolua_S,2,0));
00997 #ifndef TOLUA_RELEASE
00998   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_bool'",NULL);
00999 #endif
01000   {
01001    bool tolua_ret = (bool)  self->get_bool(path);
01002    tolua_pushboolean(tolua_S,(bool)tolua_ret);
01003   }
01004  }
01005  return 1;
01006 #ifndef TOLUA_RELEASE
01007  tolua_lerror:
01008  tolua_error(tolua_S,"#ferror in function 'get_bool'.",&tolua_err);
01009  return 0;
01010 #endif
01011 }
01012 #endif //#ifndef TOLUA_DISABLE
01013 
01014 /* method: get_string of class  fawkes::Configuration */
01015 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_get_string00
01016 static int tolua_fawkesconfig_fawkes_Configuration_get_string00(lua_State* tolua_S)
01017 {
01018 #ifndef TOLUA_RELEASE
01019  tolua_Error tolua_err;
01020  if (
01021      !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
01022      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
01023      !tolua_isnoobj(tolua_S,3,&tolua_err)
01024  )
01025   goto tolua_lerror;
01026  else
01027 #endif
01028  {
01029   fawkes::Configuration* self = (fawkes::Configuration*)  tolua_tousertype(tolua_S,1,0);
01030   const char* path = ((const char*)  tolua_tostring(tolua_S,2,0));
01031 #ifndef TOLUA_RELEASE
01032   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_string'",NULL);
01033 #endif
01034   {
01035    std::string tolua_ret = (std::string)  self->get_string(path);
01036    tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
01037   }
01038  }
01039  return 1;
01040 #ifndef TOLUA_RELEASE
01041  tolua_lerror:
01042  tolua_error(tolua_S,"#ferror in function 'get_string'.",&tolua_err);
01043  return 0;
01044 #endif
01045 }
01046 #endif //#ifndef TOLUA_DISABLE
01047 
01048 /* method: get_value of class  fawkes::Configuration */
01049 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_get_value00
01050 static int tolua_fawkesconfig_fawkes_Configuration_get_value00(lua_State* tolua_S)
01051 {
01052 #ifndef TOLUA_RELEASE
01053  tolua_Error tolua_err;
01054  if (
01055      !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
01056      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
01057      !tolua_isnoobj(tolua_S,3,&tolua_err)
01058  )
01059   goto tolua_lerror;
01060  else
01061 #endif
01062  {
01063   fawkes::Configuration* self = (fawkes::Configuration*)  tolua_tousertype(tolua_S,1,0);
01064   const char* path = ((const char*)  tolua_tostring(tolua_S,2,0));
01065 #ifndef TOLUA_RELEASE
01066   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_value'",NULL);
01067 #endif
01068   {
01069    fawkes::Configuration::ValueIterator* tolua_ret = (fawkes::Configuration::ValueIterator*)  self->get_value(path);
01070    tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Configuration::ValueIterator");
01071   }
01072  }
01073  return 1;
01074 #ifndef TOLUA_RELEASE
01075  tolua_lerror:
01076  tolua_error(tolua_S,"#ferror in function 'get_value'.",&tolua_err);
01077  return 0;
01078 #endif
01079 }
01080 #endif //#ifndef TOLUA_DISABLE
01081 
01082 /* method: set_float of class  fawkes::Configuration */
01083 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_set_float00
01084 static int tolua_fawkesconfig_fawkes_Configuration_set_float00(lua_State* tolua_S)
01085 {
01086 #ifndef TOLUA_RELEASE
01087  tolua_Error tolua_err;
01088  if (
01089      !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
01090      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
01091      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
01092      !tolua_isnoobj(tolua_S,4,&tolua_err)
01093  )
01094   goto tolua_lerror;
01095  else
01096 #endif
01097  {
01098   fawkes::Configuration* self = (fawkes::Configuration*)  tolua_tousertype(tolua_S,1,0);
01099   const char* path = ((const char*)  tolua_tostring(tolua_S,2,0));
01100   float f = ((float)  tolua_tonumber(tolua_S,3,0));
01101 #ifndef TOLUA_RELEASE
01102   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_float'",NULL);
01103 #endif
01104   {
01105    self->set_float(path,f);
01106   }
01107  }
01108  return 0;
01109 #ifndef TOLUA_RELEASE
01110  tolua_lerror:
01111  tolua_error(tolua_S,"#ferror in function 'set_float'.",&tolua_err);
01112  return 0;
01113 #endif
01114 }
01115 #endif //#ifndef TOLUA_DISABLE
01116 
01117 /* method: set_uint of class  fawkes::Configuration */
01118 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_set_uint00
01119 static int tolua_fawkesconfig_fawkes_Configuration_set_uint00(lua_State* tolua_S)
01120 {
01121 #ifndef TOLUA_RELEASE
01122  tolua_Error tolua_err;
01123  if (
01124      !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
01125      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
01126      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
01127      !tolua_isnoobj(tolua_S,4,&tolua_err)
01128  )
01129   goto tolua_lerror;
01130  else
01131 #endif
01132  {
01133   fawkes::Configuration* self = (fawkes::Configuration*)  tolua_tousertype(tolua_S,1,0);
01134   const char* path = ((const char*)  tolua_tostring(tolua_S,2,0));
01135   unsigned int uint = ((unsigned int)  tolua_tonumber(tolua_S,3,0));
01136 #ifndef TOLUA_RELEASE
01137   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_uint'",NULL);
01138 #endif
01139   {
01140    self->set_uint(path,uint);
01141   }
01142  }
01143  return 0;
01144 #ifndef TOLUA_RELEASE
01145  tolua_lerror:
01146  tolua_error(tolua_S,"#ferror in function 'set_uint'.",&tolua_err);
01147  return 0;
01148 #endif
01149 }
01150 #endif //#ifndef TOLUA_DISABLE
01151 
01152 /* method: set_int of class  fawkes::Configuration */
01153 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_set_int00
01154 static int tolua_fawkesconfig_fawkes_Configuration_set_int00(lua_State* tolua_S)
01155 {
01156 #ifndef TOLUA_RELEASE
01157  tolua_Error tolua_err;
01158  if (
01159      !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
01160      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
01161      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
01162      !tolua_isnoobj(tolua_S,4,&tolua_err)
01163  )
01164   goto tolua_lerror;
01165  else
01166 #endif
01167  {
01168   fawkes::Configuration* self = (fawkes::Configuration*)  tolua_tousertype(tolua_S,1,0);
01169   const char* path = ((const char*)  tolua_tostring(tolua_S,2,0));
01170   int i = ((int)  tolua_tonumber(tolua_S,3,0));
01171 #ifndef TOLUA_RELEASE
01172   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_int'",NULL);
01173 #endif
01174   {
01175    self->set_int(path,i);
01176   }
01177  }
01178  return 0;
01179 #ifndef TOLUA_RELEASE
01180  tolua_lerror:
01181  tolua_error(tolua_S,"#ferror in function 'set_int'.",&tolua_err);
01182  return 0;
01183 #endif
01184 }
01185 #endif //#ifndef TOLUA_DISABLE
01186 
01187 /* method: set_bool of class  fawkes::Configuration */
01188 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_set_bool00
01189 static int tolua_fawkesconfig_fawkes_Configuration_set_bool00(lua_State* tolua_S)
01190 {
01191 #ifndef TOLUA_RELEASE
01192  tolua_Error tolua_err;
01193  if (
01194      !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
01195      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
01196      !tolua_isboolean(tolua_S,3,0,&tolua_err) ||
01197      !tolua_isnoobj(tolua_S,4,&tolua_err)
01198  )
01199   goto tolua_lerror;
01200  else
01201 #endif
01202  {
01203   fawkes::Configuration* self = (fawkes::Configuration*)  tolua_tousertype(tolua_S,1,0);
01204   const char* path = ((const char*)  tolua_tostring(tolua_S,2,0));
01205   bool b = ((bool)  tolua_toboolean(tolua_S,3,0));
01206 #ifndef TOLUA_RELEASE
01207   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_bool'",NULL);
01208 #endif
01209   {
01210    self->set_bool(path,b);
01211   }
01212  }
01213  return 0;
01214 #ifndef TOLUA_RELEASE
01215  tolua_lerror:
01216  tolua_error(tolua_S,"#ferror in function 'set_bool'.",&tolua_err);
01217  return 0;
01218 #endif
01219 }
01220 #endif //#ifndef TOLUA_DISABLE
01221 
01222 /* method: set_string of class  fawkes::Configuration */
01223 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_set_string00
01224 static int tolua_fawkesconfig_fawkes_Configuration_set_string00(lua_State* tolua_S)
01225 {
01226 #ifndef TOLUA_RELEASE
01227  tolua_Error tolua_err;
01228  if (
01229      !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
01230      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
01231      !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
01232      !tolua_isnoobj(tolua_S,4,&tolua_err)
01233  )
01234   goto tolua_lerror;
01235  else
01236 #endif
01237  {
01238   fawkes::Configuration* self = (fawkes::Configuration*)  tolua_tousertype(tolua_S,1,0);
01239   const char* path = ((const char*)  tolua_tostring(tolua_S,2,0));
01240   std::string s = ((std::string)  tolua_tocppstring(tolua_S,3,0));
01241 #ifndef TOLUA_RELEASE
01242   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_string'",NULL);
01243 #endif
01244   {
01245    self->set_string(path,s);
01246   }
01247  }
01248  return 0;
01249 #ifndef TOLUA_RELEASE
01250  tolua_lerror:
01251  tolua_error(tolua_S,"#ferror in function 'set_string'.",&tolua_err);
01252  return 0;
01253 #endif
01254 }
01255 #endif //#ifndef TOLUA_DISABLE
01256 
01257 /* method: set_string of class  fawkes::Configuration */
01258 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_set_string01
01259 static int tolua_fawkesconfig_fawkes_Configuration_set_string01(lua_State* tolua_S)
01260 {
01261  tolua_Error tolua_err;
01262  if (
01263      !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
01264      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
01265      !tolua_isstring(tolua_S,3,0,&tolua_err) ||
01266      !tolua_isnoobj(tolua_S,4,&tolua_err)
01267  )
01268   goto tolua_lerror;
01269  else
01270  {
01271   fawkes::Configuration* self = (fawkes::Configuration*)  tolua_tousertype(tolua_S,1,0);
01272   const char* path = ((const char*)  tolua_tostring(tolua_S,2,0));
01273   const char* s = ((const char*)  tolua_tostring(tolua_S,3,0));
01274 #ifndef TOLUA_RELEASE
01275   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_string'",NULL);
01276 #endif
01277   {
01278    self->set_string(path,s);
01279   }
01280  }
01281  return 0;
01282 tolua_lerror:
01283  return tolua_fawkesconfig_fawkes_Configuration_set_string00(tolua_S);
01284 }
01285 #endif //#ifndef TOLUA_DISABLE
01286 
01287 /* method: erase of class  fawkes::Configuration */
01288 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_erase00
01289 static int tolua_fawkesconfig_fawkes_Configuration_erase00(lua_State* tolua_S)
01290 {
01291 #ifndef TOLUA_RELEASE
01292  tolua_Error tolua_err;
01293  if (
01294      !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
01295      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
01296      !tolua_isnoobj(tolua_S,3,&tolua_err)
01297  )
01298   goto tolua_lerror;
01299  else
01300 #endif
01301  {
01302   fawkes::Configuration* self = (fawkes::Configuration*)  tolua_tousertype(tolua_S,1,0);
01303   const char* path = ((const char*)  tolua_tostring(tolua_S,2,0));
01304 #ifndef TOLUA_RELEASE
01305   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'erase'",NULL);
01306 #endif
01307   {
01308    self->erase(path);
01309   }
01310  }
01311  return 0;
01312 #ifndef TOLUA_RELEASE
01313  tolua_lerror:
01314  tolua_error(tolua_S,"#ferror in function 'erase'.",&tolua_err);
01315  return 0;
01316 #endif
01317 }
01318 #endif //#ifndef TOLUA_DISABLE
01319 
01320 /* method: set_default_float of class  fawkes::Configuration */
01321 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_set_default_float00
01322 static int tolua_fawkesconfig_fawkes_Configuration_set_default_float00(lua_State* tolua_S)
01323 {
01324 #ifndef TOLUA_RELEASE
01325  tolua_Error tolua_err;
01326  if (
01327      !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
01328      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
01329      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
01330      !tolua_isnoobj(tolua_S,4,&tolua_err)
01331  )
01332   goto tolua_lerror;
01333  else
01334 #endif
01335  {
01336   fawkes::Configuration* self = (fawkes::Configuration*)  tolua_tousertype(tolua_S,1,0);
01337   const char* path = ((const char*)  tolua_tostring(tolua_S,2,0));
01338   float f = ((float)  tolua_tonumber(tolua_S,3,0));
01339 #ifndef TOLUA_RELEASE
01340   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_default_float'",NULL);
01341 #endif
01342   {
01343    self->set_default_float(path,f);
01344   }
01345  }
01346  return 0;
01347 #ifndef TOLUA_RELEASE
01348  tolua_lerror:
01349  tolua_error(tolua_S,"#ferror in function 'set_default_float'.",&tolua_err);
01350  return 0;
01351 #endif
01352 }
01353 #endif //#ifndef TOLUA_DISABLE
01354 
01355 /* method: set_default_uint of class  fawkes::Configuration */
01356 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_set_default_uint00
01357 static int tolua_fawkesconfig_fawkes_Configuration_set_default_uint00(lua_State* tolua_S)
01358 {
01359 #ifndef TOLUA_RELEASE
01360  tolua_Error tolua_err;
01361  if (
01362      !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
01363      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
01364      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
01365      !tolua_isnoobj(tolua_S,4,&tolua_err)
01366  )
01367   goto tolua_lerror;
01368  else
01369 #endif
01370  {
01371   fawkes::Configuration* self = (fawkes::Configuration*)  tolua_tousertype(tolua_S,1,0);
01372   const char* path = ((const char*)  tolua_tostring(tolua_S,2,0));
01373   unsigned int uint = ((unsigned int)  tolua_tonumber(tolua_S,3,0));
01374 #ifndef TOLUA_RELEASE
01375   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_default_uint'",NULL);
01376 #endif
01377   {
01378    self->set_default_uint(path,uint);
01379   }
01380  }
01381  return 0;
01382 #ifndef TOLUA_RELEASE
01383  tolua_lerror:
01384  tolua_error(tolua_S,"#ferror in function 'set_default_uint'.",&tolua_err);
01385  return 0;
01386 #endif
01387 }
01388 #endif //#ifndef TOLUA_DISABLE
01389 
01390 /* method: set_default_int of class  fawkes::Configuration */
01391 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_set_default_int00
01392 static int tolua_fawkesconfig_fawkes_Configuration_set_default_int00(lua_State* tolua_S)
01393 {
01394 #ifndef TOLUA_RELEASE
01395  tolua_Error tolua_err;
01396  if (
01397      !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
01398      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
01399      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
01400      !tolua_isnoobj(tolua_S,4,&tolua_err)
01401  )
01402   goto tolua_lerror;
01403  else
01404 #endif
01405  {
01406   fawkes::Configuration* self = (fawkes::Configuration*)  tolua_tousertype(tolua_S,1,0);
01407   const char* path = ((const char*)  tolua_tostring(tolua_S,2,0));
01408   int i = ((int)  tolua_tonumber(tolua_S,3,0));
01409 #ifndef TOLUA_RELEASE
01410   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_default_int'",NULL);
01411 #endif
01412   {
01413    self->set_default_int(path,i);
01414   }
01415  }
01416  return 0;
01417 #ifndef TOLUA_RELEASE
01418  tolua_lerror:
01419  tolua_error(tolua_S,"#ferror in function 'set_default_int'.",&tolua_err);
01420  return 0;
01421 #endif
01422 }
01423 #endif //#ifndef TOLUA_DISABLE
01424 
01425 /* method: set_default_bool of class  fawkes::Configuration */
01426 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_set_default_bool00
01427 static int tolua_fawkesconfig_fawkes_Configuration_set_default_bool00(lua_State* tolua_S)
01428 {
01429 #ifndef TOLUA_RELEASE
01430  tolua_Error tolua_err;
01431  if (
01432      !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
01433      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
01434      !tolua_isboolean(tolua_S,3,0,&tolua_err) ||
01435      !tolua_isnoobj(tolua_S,4,&tolua_err)
01436  )
01437   goto tolua_lerror;
01438  else
01439 #endif
01440  {
01441   fawkes::Configuration* self = (fawkes::Configuration*)  tolua_tousertype(tolua_S,1,0);
01442   const char* path = ((const char*)  tolua_tostring(tolua_S,2,0));
01443   bool b = ((bool)  tolua_toboolean(tolua_S,3,0));
01444 #ifndef TOLUA_RELEASE
01445   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_default_bool'",NULL);
01446 #endif
01447   {
01448    self->set_default_bool(path,b);
01449   }
01450  }
01451  return 0;
01452 #ifndef TOLUA_RELEASE
01453  tolua_lerror:
01454  tolua_error(tolua_S,"#ferror in function 'set_default_bool'.",&tolua_err);
01455  return 0;
01456 #endif
01457 }
01458 #endif //#ifndef TOLUA_DISABLE
01459 
01460 /* method: set_default_string of class  fawkes::Configuration */
01461 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_set_default_string00
01462 static int tolua_fawkesconfig_fawkes_Configuration_set_default_string00(lua_State* tolua_S)
01463 {
01464 #ifndef TOLUA_RELEASE
01465  tolua_Error tolua_err;
01466  if (
01467      !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
01468      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
01469      !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
01470      !tolua_isnoobj(tolua_S,4,&tolua_err)
01471  )
01472   goto tolua_lerror;
01473  else
01474 #endif
01475  {
01476   fawkes::Configuration* self = (fawkes::Configuration*)  tolua_tousertype(tolua_S,1,0);
01477   const char* path = ((const char*)  tolua_tostring(tolua_S,2,0));
01478   std::string s = ((std::string)  tolua_tocppstring(tolua_S,3,0));
01479 #ifndef TOLUA_RELEASE
01480   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_default_string'",NULL);
01481 #endif
01482   {
01483    self->set_default_string(path,s);
01484   }
01485  }
01486  return 0;
01487 #ifndef TOLUA_RELEASE
01488  tolua_lerror:
01489  tolua_error(tolua_S,"#ferror in function 'set_default_string'.",&tolua_err);
01490  return 0;
01491 #endif
01492 }
01493 #endif //#ifndef TOLUA_DISABLE
01494 
01495 /* method: set_default_string of class  fawkes::Configuration */
01496 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_set_default_string01
01497 static int tolua_fawkesconfig_fawkes_Configuration_set_default_string01(lua_State* tolua_S)
01498 {
01499  tolua_Error tolua_err;
01500  if (
01501      !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
01502      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
01503      !tolua_isstring(tolua_S,3,0,&tolua_err) ||
01504      !tolua_isnoobj(tolua_S,4,&tolua_err)
01505  )
01506   goto tolua_lerror;
01507  else
01508  {
01509   fawkes::Configuration* self = (fawkes::Configuration*)  tolua_tousertype(tolua_S,1,0);
01510   const char* path = ((const char*)  tolua_tostring(tolua_S,2,0));
01511   const char* s = ((const char*)  tolua_tostring(tolua_S,3,0));
01512 #ifndef TOLUA_RELEASE
01513   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_default_string'",NULL);
01514 #endif
01515   {
01516    self->set_default_string(path,s);
01517   }
01518  }
01519  return 0;
01520 tolua_lerror:
01521  return tolua_fawkesconfig_fawkes_Configuration_set_default_string00(tolua_S);
01522 }
01523 #endif //#ifndef TOLUA_DISABLE
01524 
01525 /* method: erase_default of class  fawkes::Configuration */
01526 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_erase_default00
01527 static int tolua_fawkesconfig_fawkes_Configuration_erase_default00(lua_State* tolua_S)
01528 {
01529 #ifndef TOLUA_RELEASE
01530  tolua_Error tolua_err;
01531  if (
01532      !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
01533      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
01534      !tolua_isnoobj(tolua_S,3,&tolua_err)
01535  )
01536   goto tolua_lerror;
01537  else
01538 #endif
01539  {
01540   fawkes::Configuration* self = (fawkes::Configuration*)  tolua_tousertype(tolua_S,1,0);
01541   const char* path = ((const char*)  tolua_tostring(tolua_S,2,0));
01542 #ifndef TOLUA_RELEASE
01543   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'erase_default'",NULL);
01544 #endif
01545   {
01546    self->erase_default(path);
01547   }
01548  }
01549  return 0;
01550 #ifndef TOLUA_RELEASE
01551  tolua_lerror:
01552  tolua_error(tolua_S,"#ferror in function 'erase_default'.",&tolua_err);
01553  return 0;
01554 #endif
01555 }
01556 #endif //#ifndef TOLUA_DISABLE
01557 
01558 /* method: iterator of class  fawkes::Configuration */
01559 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_iterator00
01560 static int tolua_fawkesconfig_fawkes_Configuration_iterator00(lua_State* tolua_S)
01561 {
01562 #ifndef TOLUA_RELEASE
01563  tolua_Error tolua_err;
01564  if (
01565      !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
01566      !tolua_isnoobj(tolua_S,2,&tolua_err)
01567  )
01568   goto tolua_lerror;
01569  else
01570 #endif
01571  {
01572   fawkes::Configuration* self = (fawkes::Configuration*)  tolua_tousertype(tolua_S,1,0);
01573 #ifndef TOLUA_RELEASE
01574   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'iterator'",NULL);
01575 #endif
01576   {
01577    fawkes::Configuration::ValueIterator* tolua_ret = (fawkes::Configuration::ValueIterator*)  self->iterator();
01578    tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Configuration::ValueIterator");
01579   }
01580  }
01581  return 1;
01582 #ifndef TOLUA_RELEASE
01583  tolua_lerror:
01584  tolua_error(tolua_S,"#ferror in function 'iterator'.",&tolua_err);
01585  return 0;
01586 #endif
01587 }
01588 #endif //#ifndef TOLUA_DISABLE
01589 
01590 /* method: search of class  fawkes::Configuration */
01591 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_search00
01592 static int tolua_fawkesconfig_fawkes_Configuration_search00(lua_State* tolua_S)
01593 {
01594 #ifndef TOLUA_RELEASE
01595  tolua_Error tolua_err;
01596  if (
01597      !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
01598      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
01599      !tolua_isnoobj(tolua_S,3,&tolua_err)
01600  )
01601   goto tolua_lerror;
01602  else
01603 #endif
01604  {
01605   fawkes::Configuration* self = (fawkes::Configuration*)  tolua_tousertype(tolua_S,1,0);
01606   const char* path = ((const char*)  tolua_tostring(tolua_S,2,0));
01607 #ifndef TOLUA_RELEASE
01608   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'search'",NULL);
01609 #endif
01610   {
01611    fawkes::Configuration::ValueIterator* tolua_ret = (fawkes::Configuration::ValueIterator*)  self->search(path);
01612    tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Configuration::ValueIterator");
01613   }
01614  }
01615  return 1;
01616 #ifndef TOLUA_RELEASE
01617  tolua_lerror:
01618  tolua_error(tolua_S,"#ferror in function 'search'.",&tolua_err);
01619  return 0;
01620 #endif
01621 }
01622 #endif //#ifndef TOLUA_DISABLE
01623 
01624 /* method: lock of class  fawkes::Configuration */
01625 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_lock00
01626 static int tolua_fawkesconfig_fawkes_Configuration_lock00(lua_State* tolua_S)
01627 {
01628 #ifndef TOLUA_RELEASE
01629  tolua_Error tolua_err;
01630  if (
01631      !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
01632      !tolua_isnoobj(tolua_S,2,&tolua_err)
01633  )
01634   goto tolua_lerror;
01635  else
01636 #endif
01637  {
01638   fawkes::Configuration* self = (fawkes::Configuration*)  tolua_tousertype(tolua_S,1,0);
01639 #ifndef TOLUA_RELEASE
01640   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'lock'",NULL);
01641 #endif
01642   {
01643    self->lock();
01644   }
01645  }
01646  return 0;
01647 #ifndef TOLUA_RELEASE
01648  tolua_lerror:
01649  tolua_error(tolua_S,"#ferror in function 'lock'.",&tolua_err);
01650  return 0;
01651 #endif
01652 }
01653 #endif //#ifndef TOLUA_DISABLE
01654 
01655 /* method: try_lock of class  fawkes::Configuration */
01656 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_try_lock00
01657 static int tolua_fawkesconfig_fawkes_Configuration_try_lock00(lua_State* tolua_S)
01658 {
01659 #ifndef TOLUA_RELEASE
01660  tolua_Error tolua_err;
01661  if (
01662      !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
01663      !tolua_isnoobj(tolua_S,2,&tolua_err)
01664  )
01665   goto tolua_lerror;
01666  else
01667 #endif
01668  {
01669   fawkes::Configuration* self = (fawkes::Configuration*)  tolua_tousertype(tolua_S,1,0);
01670 #ifndef TOLUA_RELEASE
01671   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'try_lock'",NULL);
01672 #endif
01673   {
01674    bool tolua_ret = (bool)  self->try_lock();
01675    tolua_pushboolean(tolua_S,(bool)tolua_ret);
01676   }
01677  }
01678  return 1;
01679 #ifndef TOLUA_RELEASE
01680  tolua_lerror:
01681  tolua_error(tolua_S,"#ferror in function 'try_lock'.",&tolua_err);
01682  return 0;
01683 #endif
01684 }
01685 #endif //#ifndef TOLUA_DISABLE
01686 
01687 /* method: unlock of class  fawkes::Configuration */
01688 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_unlock00
01689 static int tolua_fawkesconfig_fawkes_Configuration_unlock00(lua_State* tolua_S)
01690 {
01691 #ifndef TOLUA_RELEASE
01692  tolua_Error tolua_err;
01693  if (
01694      !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
01695      !tolua_isnoobj(tolua_S,2,&tolua_err)
01696  )
01697   goto tolua_lerror;
01698  else
01699 #endif
01700  {
01701   fawkes::Configuration* self = (fawkes::Configuration*)  tolua_tousertype(tolua_S,1,0);
01702 #ifndef TOLUA_RELEASE
01703   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'unlock'",NULL);
01704 #endif
01705   {
01706    self->unlock();
01707   }
01708  }
01709  return 0;
01710 #ifndef TOLUA_RELEASE
01711  tolua_lerror:
01712  tolua_error(tolua_S,"#ferror in function 'unlock'.",&tolua_err);
01713  return 0;
01714 #endif
01715 }
01716 #endif //#ifndef TOLUA_DISABLE
01717 
01718 /* Open function */
01719 TOLUA_API int tolua_fawkesconfig_open (lua_State* tolua_S)
01720 {
01721  tolua_open(tolua_S);
01722  tolua_reg_types(tolua_S);
01723  tolua_module(tolua_S,NULL,0);
01724  tolua_beginmodule(tolua_S,NULL);
01725   tolua_module(tolua_S,"fawkes",0);
01726   tolua_beginmodule(tolua_S,"fawkes");
01727    tolua_cclass(tolua_S,"Configuration","fawkes::Configuration","",NULL);
01728    tolua_beginmodule(tolua_S,"Configuration");
01729     #ifdef __cplusplus
01730     tolua_cclass(tolua_S,"ValueIterator","fawkes::Configuration::ValueIterator","",tolua_collect_fawkes__Configuration__ValueIterator);
01731     #else
01732     tolua_cclass(tolua_S,"ValueIterator","fawkes::Configuration::ValueIterator","",NULL);
01733     #endif
01734     tolua_beginmodule(tolua_S,"ValueIterator");
01735      tolua_function(tolua_S,"delete",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_delete00);
01736      tolua_function(tolua_S,"next",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_next00);
01737      tolua_function(tolua_S,"valid",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_valid00);
01738      tolua_function(tolua_S,"path",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_path00);
01739      tolua_function(tolua_S,"type",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_type00);
01740      tolua_function(tolua_S,"is_float",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_is_float00);
01741      tolua_function(tolua_S,"is_uint",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_is_uint00);
01742      tolua_function(tolua_S,"is_int",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_is_int00);
01743      tolua_function(tolua_S,"is_bool",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_is_bool00);
01744      tolua_function(tolua_S,"is_string",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_is_string00);
01745      tolua_function(tolua_S,"get_float",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_get_float00);
01746      tolua_function(tolua_S,"get_uint",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_get_uint00);
01747      tolua_function(tolua_S,"get_int",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_get_int00);
01748      tolua_function(tolua_S,"get_bool",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_get_bool00);
01749      tolua_function(tolua_S,"get_string",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_get_string00);
01750      tolua_function(tolua_S,"is_default",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_is_default00);
01751     tolua_endmodule(tolua_S);
01752     tolua_function(tolua_S,"tag",tolua_fawkesconfig_fawkes_Configuration_tag00);
01753     tolua_function(tolua_S,"tags",tolua_fawkesconfig_fawkes_Configuration_tags00);
01754     tolua_function(tolua_S,"exists",tolua_fawkesconfig_fawkes_Configuration_exists00);
01755     tolua_function(tolua_S,"is_float",tolua_fawkesconfig_fawkes_Configuration_is_float00);
01756     tolua_function(tolua_S,"is_uint",tolua_fawkesconfig_fawkes_Configuration_is_uint00);
01757     tolua_function(tolua_S,"is_int",tolua_fawkesconfig_fawkes_Configuration_is_int00);
01758     tolua_function(tolua_S,"is_bool",tolua_fawkesconfig_fawkes_Configuration_is_bool00);
01759     tolua_function(tolua_S,"is_string",tolua_fawkesconfig_fawkes_Configuration_is_string00);
01760     tolua_function(tolua_S,"is_default",tolua_fawkesconfig_fawkes_Configuration_is_default00);
01761     tolua_function(tolua_S,"get_float",tolua_fawkesconfig_fawkes_Configuration_get_float00);
01762     tolua_function(tolua_S,"get_uint",tolua_fawkesconfig_fawkes_Configuration_get_uint00);
01763     tolua_function(tolua_S,"get_int",tolua_fawkesconfig_fawkes_Configuration_get_int00);
01764     tolua_function(tolua_S,"get_bool",tolua_fawkesconfig_fawkes_Configuration_get_bool00);
01765     tolua_function(tolua_S,"get_string",tolua_fawkesconfig_fawkes_Configuration_get_string00);
01766     tolua_function(tolua_S,"get_value",tolua_fawkesconfig_fawkes_Configuration_get_value00);
01767     tolua_function(tolua_S,"set_float",tolua_fawkesconfig_fawkes_Configuration_set_float00);
01768     tolua_function(tolua_S,"set_uint",tolua_fawkesconfig_fawkes_Configuration_set_uint00);
01769     tolua_function(tolua_S,"set_int",tolua_fawkesconfig_fawkes_Configuration_set_int00);
01770     tolua_function(tolua_S,"set_bool",tolua_fawkesconfig_fawkes_Configuration_set_bool00);
01771     tolua_function(tolua_S,"set_string",tolua_fawkesconfig_fawkes_Configuration_set_string00);
01772     tolua_function(tolua_S,"set_string",tolua_fawkesconfig_fawkes_Configuration_set_string01);
01773     tolua_function(tolua_S,"erase",tolua_fawkesconfig_fawkes_Configuration_erase00);
01774     tolua_function(tolua_S,"set_default_float",tolua_fawkesconfig_fawkes_Configuration_set_default_float00);
01775     tolua_function(tolua_S,"set_default_uint",tolua_fawkesconfig_fawkes_Configuration_set_default_uint00);
01776     tolua_function(tolua_S,"set_default_int",tolua_fawkesconfig_fawkes_Configuration_set_default_int00);
01777     tolua_function(tolua_S,"set_default_bool",tolua_fawkesconfig_fawkes_Configuration_set_default_bool00);
01778     tolua_function(tolua_S,"set_default_string",tolua_fawkesconfig_fawkes_Configuration_set_default_string00);
01779     tolua_function(tolua_S,"set_default_string",tolua_fawkesconfig_fawkes_Configuration_set_default_string01);
01780     tolua_function(tolua_S,"erase_default",tolua_fawkesconfig_fawkes_Configuration_erase_default00);
01781     tolua_function(tolua_S,"iterator",tolua_fawkesconfig_fawkes_Configuration_iterator00);
01782     tolua_function(tolua_S,"search",tolua_fawkesconfig_fawkes_Configuration_search00);
01783     tolua_function(tolua_S,"lock",tolua_fawkesconfig_fawkes_Configuration_lock00);
01784     tolua_function(tolua_S,"try_lock",tolua_fawkesconfig_fawkes_Configuration_try_lock00);
01785     tolua_function(tolua_S,"unlock",tolua_fawkesconfig_fawkes_Configuration_unlock00);
01786    tolua_endmodule(tolua_S);
01787   tolua_endmodule(tolua_S);
01788  tolua_endmodule(tolua_S);
01789  return 1;
01790 }
01791
01792
01793 extern "C" {
01794 #if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501
01795  TOLUA_API int luaopen_fawkesconfig (lua_State* tolua_S) {
01796  return tolua_fawkesconfig_open(tolua_S);
01797 };
01798 #endif
01799 }
01800
01801