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