00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019 #ifndef __cplusplus
00020 #include "stdlib.h"
00021 #endif
00022 #include "string.h"
00023
00024 #include "tolua++.h"
00025
00026
00027 TOLUA_API int tolua_fawkesconfig_open (lua_State* tolua_S);
00028
00029 #include <config/config.h>
00030
00031
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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