Fawkes API Fawkes Development Version
fawkesconfig_tolua.cpp
1/*
2** Lua binding: fawkesconfig
3** Generated automatically by tolua++-1.0.92
4*/
5/* This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version. A runtime exception applies to
9 * this software (see LICENSE.GPL_WRE file mentioned below for details).
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU Library General Public License for more details.
15 *
16 * Read the full text in the LICENSE.GPL_WRE file in the doc directory.
17 */
18
19#include <core/exception.h>
20
21#ifndef __cplusplus
22#include "stdlib.h"
23#endif
24#include "string.h"
25
26#include "tolua++.h"
27
28/* Exported function */
29TOLUA_API int tolua_fawkesconfig_open (lua_State* tolua_S);
30
31#include <config/config.h>
32
33/* function to release collected object via destructor */
34#ifdef __cplusplus
35
36static int tolua_collect_fawkes__Configuration__ValueIterator (lua_State* tolua_S)
37{
39 Mtolua_delete(self);
40 return 0;
41}
42#endif
43
44
45/* function to register type */
46static void tolua_reg_types (lua_State* tolua_S)
47{
48 tolua_usertype(tolua_S,"fawkes::Configuration::ValueIterator");
49 tolua_usertype(tolua_S,"fawkes::Configuration");
50}
51
52/* method: delete of class ValueIterator */
53#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_ValueIterator_delete00
54static int tolua_fawkesconfig_fawkes_Configuration_ValueIterator_delete00(lua_State* tolua_S)
55{
56#ifndef TOLUA_RELEASE
57 tolua_Error tolua_err;
58 if (
59 !tolua_isusertype(tolua_S,1,"fawkes::Configuration::ValueIterator",0,&tolua_err) ||
60 !tolua_isnoobj(tolua_S,2,&tolua_err)
61 )
62 goto tolua_lerror;
63 else
64#endif
65 {
67#ifndef TOLUA_RELEASE
68 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
69#endif
70 bool exc_caught = false;
71 try {
72 Mtolua_delete(self);
73 } catch (fawkes::Exception &e) {
74 exc_caught = true;
75 lua_pushstring(tolua_S, e.what_no_backtrace());
76 }
77 catch (std::exception &e) {
78 exc_caught = true;
79 lua_pushstring(tolua_S, e.what());
80 }
81 if (exc_caught) lua_error(tolua_S);
82
83 }
84 return 0;
85#ifndef TOLUA_RELEASE
86 tolua_lerror:
87 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
88 return 0;
89#endif
90}
91#endif //#ifndef TOLUA_DISABLE
92
93/* method: next of class ValueIterator */
94#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_ValueIterator_next00
95static int tolua_fawkesconfig_fawkes_Configuration_ValueIterator_next00(lua_State* tolua_S)
96{
97#ifndef TOLUA_RELEASE
98 tolua_Error tolua_err;
99 if (
100 !tolua_isusertype(tolua_S,1,"fawkes::Configuration::ValueIterator",0,&tolua_err) ||
101 !tolua_isnoobj(tolua_S,2,&tolua_err)
102 )
103 goto tolua_lerror;
104 else
105#endif
106 {
107 fawkes::Configuration::ValueIterator* self = (fawkes::Configuration::ValueIterator*) tolua_tousertype(tolua_S,1,0);
108#ifndef TOLUA_RELEASE
109 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'next'", NULL);
110#endif
111 bool exc_caught = false;
112 try {
113 {
114 bool tolua_ret = (bool) self->next();
115 tolua_pushboolean(tolua_S,(bool)tolua_ret);
116 }
117 } catch (fawkes::Exception &e) {
118 exc_caught = true;
119 lua_pushstring(tolua_S, e.what_no_backtrace());
120 }
121 catch (std::exception &e) {
122 exc_caught = true;
123 lua_pushstring(tolua_S, e.what());
124 }
125 if (exc_caught) lua_error(tolua_S);
126
127 }
128 return 1;
129#ifndef TOLUA_RELEASE
130 tolua_lerror:
131 tolua_error(tolua_S,"#ferror in function 'next'.",&tolua_err);
132 return 0;
133#endif
134}
135#endif //#ifndef TOLUA_DISABLE
136
137/* method: valid of class ValueIterator */
138#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_ValueIterator_valid00
139static int tolua_fawkesconfig_fawkes_Configuration_ValueIterator_valid00(lua_State* tolua_S)
140{
141#ifndef TOLUA_RELEASE
142 tolua_Error tolua_err;
143 if (
144 !tolua_isusertype(tolua_S,1,"fawkes::Configuration::ValueIterator",0,&tolua_err) ||
145 !tolua_isnoobj(tolua_S,2,&tolua_err)
146 )
147 goto tolua_lerror;
148 else
149#endif
150 {
151 fawkes::Configuration::ValueIterator* self = (fawkes::Configuration::ValueIterator*) tolua_tousertype(tolua_S,1,0);
152#ifndef TOLUA_RELEASE
153 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'valid'", NULL);
154#endif
155 bool exc_caught = false;
156 try {
157 {
158 bool tolua_ret = (bool) self->valid();
159 tolua_pushboolean(tolua_S,(bool)tolua_ret);
160 }
161 } catch (fawkes::Exception &e) {
162 exc_caught = true;
163 lua_pushstring(tolua_S, e.what_no_backtrace());
164 }
165 catch (std::exception &e) {
166 exc_caught = true;
167 lua_pushstring(tolua_S, e.what());
168 }
169 if (exc_caught) lua_error(tolua_S);
170
171 }
172 return 1;
173#ifndef TOLUA_RELEASE
174 tolua_lerror:
175 tolua_error(tolua_S,"#ferror in function 'valid'.",&tolua_err);
176 return 0;
177#endif
178}
179#endif //#ifndef TOLUA_DISABLE
180
181/* method: path of class ValueIterator */
182#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_ValueIterator_path00
183static int tolua_fawkesconfig_fawkes_Configuration_ValueIterator_path00(lua_State* tolua_S)
184{
185#ifndef TOLUA_RELEASE
186 tolua_Error tolua_err;
187 if (
188 !tolua_isusertype(tolua_S,1,"fawkes::Configuration::ValueIterator",0,&tolua_err) ||
189 !tolua_isnoobj(tolua_S,2,&tolua_err)
190 )
191 goto tolua_lerror;
192 else
193#endif
194 {
195 fawkes::Configuration::ValueIterator* self = (fawkes::Configuration::ValueIterator*) tolua_tousertype(tolua_S,1,0);
196#ifndef TOLUA_RELEASE
197 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'path'", NULL);
198#endif
199 bool exc_caught = false;
200 try {
201 {
202 const char* tolua_ret = (const char*) self->path();
203 tolua_pushstring(tolua_S,(const char*)tolua_ret);
204 }
205 } catch (fawkes::Exception &e) {
206 exc_caught = true;
207 lua_pushstring(tolua_S, e.what_no_backtrace());
208 }
209 catch (std::exception &e) {
210 exc_caught = true;
211 lua_pushstring(tolua_S, e.what());
212 }
213 if (exc_caught) lua_error(tolua_S);
214
215 }
216 return 1;
217#ifndef TOLUA_RELEASE
218 tolua_lerror:
219 tolua_error(tolua_S,"#ferror in function 'path'.",&tolua_err);
220 return 0;
221#endif
222}
223#endif //#ifndef TOLUA_DISABLE
224
225/* method: type of class ValueIterator */
226#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_ValueIterator_type00
227static int tolua_fawkesconfig_fawkes_Configuration_ValueIterator_type00(lua_State* tolua_S)
228{
229#ifndef TOLUA_RELEASE
230 tolua_Error tolua_err;
231 if (
232 !tolua_isusertype(tolua_S,1,"fawkes::Configuration::ValueIterator",0,&tolua_err) ||
233 !tolua_isnoobj(tolua_S,2,&tolua_err)
234 )
235 goto tolua_lerror;
236 else
237#endif
238 {
239 fawkes::Configuration::ValueIterator* self = (fawkes::Configuration::ValueIterator*) tolua_tousertype(tolua_S,1,0);
240#ifndef TOLUA_RELEASE
241 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'type'", NULL);
242#endif
243 bool exc_caught = false;
244 try {
245 {
246 const char* tolua_ret = (const char*) self->type();
247 tolua_pushstring(tolua_S,(const char*)tolua_ret);
248 }
249 } catch (fawkes::Exception &e) {
250 exc_caught = true;
251 lua_pushstring(tolua_S, e.what_no_backtrace());
252 }
253 catch (std::exception &e) {
254 exc_caught = true;
255 lua_pushstring(tolua_S, e.what());
256 }
257 if (exc_caught) lua_error(tolua_S);
258
259 }
260 return 1;
261#ifndef TOLUA_RELEASE
262 tolua_lerror:
263 tolua_error(tolua_S,"#ferror in function 'type'.",&tolua_err);
264 return 0;
265#endif
266}
267#endif //#ifndef TOLUA_DISABLE
268
269/* method: is_float of class ValueIterator */
270#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_ValueIterator_is_float00
271static int tolua_fawkesconfig_fawkes_Configuration_ValueIterator_is_float00(lua_State* tolua_S)
272{
273#ifndef TOLUA_RELEASE
274 tolua_Error tolua_err;
275 if (
276 !tolua_isusertype(tolua_S,1,"fawkes::Configuration::ValueIterator",0,&tolua_err) ||
277 !tolua_isnoobj(tolua_S,2,&tolua_err)
278 )
279 goto tolua_lerror;
280 else
281#endif
282 {
283 fawkes::Configuration::ValueIterator* self = (fawkes::Configuration::ValueIterator*) tolua_tousertype(tolua_S,1,0);
284#ifndef TOLUA_RELEASE
285 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_float'", NULL);
286#endif
287 bool exc_caught = false;
288 try {
289 {
290 bool tolua_ret = (bool) self->is_float();
291 tolua_pushboolean(tolua_S,(bool)tolua_ret);
292 }
293 } catch (fawkes::Exception &e) {
294 exc_caught = true;
295 lua_pushstring(tolua_S, e.what_no_backtrace());
296 }
297 catch (std::exception &e) {
298 exc_caught = true;
299 lua_pushstring(tolua_S, e.what());
300 }
301 if (exc_caught) lua_error(tolua_S);
302
303 }
304 return 1;
305#ifndef TOLUA_RELEASE
306 tolua_lerror:
307 tolua_error(tolua_S,"#ferror in function 'is_float'.",&tolua_err);
308 return 0;
309#endif
310}
311#endif //#ifndef TOLUA_DISABLE
312
313/* method: is_uint of class ValueIterator */
314#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_ValueIterator_is_uint00
315static int tolua_fawkesconfig_fawkes_Configuration_ValueIterator_is_uint00(lua_State* tolua_S)
316{
317#ifndef TOLUA_RELEASE
318 tolua_Error tolua_err;
319 if (
320 !tolua_isusertype(tolua_S,1,"fawkes::Configuration::ValueIterator",0,&tolua_err) ||
321 !tolua_isnoobj(tolua_S,2,&tolua_err)
322 )
323 goto tolua_lerror;
324 else
325#endif
326 {
327 fawkes::Configuration::ValueIterator* self = (fawkes::Configuration::ValueIterator*) tolua_tousertype(tolua_S,1,0);
328#ifndef TOLUA_RELEASE
329 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_uint'", NULL);
330#endif
331 bool exc_caught = false;
332 try {
333 {
334 bool tolua_ret = (bool) self->is_uint();
335 tolua_pushboolean(tolua_S,(bool)tolua_ret);
336 }
337 } catch (fawkes::Exception &e) {
338 exc_caught = true;
339 lua_pushstring(tolua_S, e.what_no_backtrace());
340 }
341 catch (std::exception &e) {
342 exc_caught = true;
343 lua_pushstring(tolua_S, e.what());
344 }
345 if (exc_caught) lua_error(tolua_S);
346
347 }
348 return 1;
349#ifndef TOLUA_RELEASE
350 tolua_lerror:
351 tolua_error(tolua_S,"#ferror in function 'is_uint'.",&tolua_err);
352 return 0;
353#endif
354}
355#endif //#ifndef TOLUA_DISABLE
356
357/* method: is_int of class ValueIterator */
358#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_ValueIterator_is_int00
359static int tolua_fawkesconfig_fawkes_Configuration_ValueIterator_is_int00(lua_State* tolua_S)
360{
361#ifndef TOLUA_RELEASE
362 tolua_Error tolua_err;
363 if (
364 !tolua_isusertype(tolua_S,1,"fawkes::Configuration::ValueIterator",0,&tolua_err) ||
365 !tolua_isnoobj(tolua_S,2,&tolua_err)
366 )
367 goto tolua_lerror;
368 else
369#endif
370 {
371 fawkes::Configuration::ValueIterator* self = (fawkes::Configuration::ValueIterator*) tolua_tousertype(tolua_S,1,0);
372#ifndef TOLUA_RELEASE
373 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_int'", NULL);
374#endif
375 bool exc_caught = false;
376 try {
377 {
378 bool tolua_ret = (bool) self->is_int();
379 tolua_pushboolean(tolua_S,(bool)tolua_ret);
380 }
381 } catch (fawkes::Exception &e) {
382 exc_caught = true;
383 lua_pushstring(tolua_S, e.what_no_backtrace());
384 }
385 catch (std::exception &e) {
386 exc_caught = true;
387 lua_pushstring(tolua_S, e.what());
388 }
389 if (exc_caught) lua_error(tolua_S);
390
391 }
392 return 1;
393#ifndef TOLUA_RELEASE
394 tolua_lerror:
395 tolua_error(tolua_S,"#ferror in function 'is_int'.",&tolua_err);
396 return 0;
397#endif
398}
399#endif //#ifndef TOLUA_DISABLE
400
401/* method: is_bool of class ValueIterator */
402#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_ValueIterator_is_bool00
403static int tolua_fawkesconfig_fawkes_Configuration_ValueIterator_is_bool00(lua_State* tolua_S)
404{
405#ifndef TOLUA_RELEASE
406 tolua_Error tolua_err;
407 if (
408 !tolua_isusertype(tolua_S,1,"fawkes::Configuration::ValueIterator",0,&tolua_err) ||
409 !tolua_isnoobj(tolua_S,2,&tolua_err)
410 )
411 goto tolua_lerror;
412 else
413#endif
414 {
415 fawkes::Configuration::ValueIterator* self = (fawkes::Configuration::ValueIterator*) tolua_tousertype(tolua_S,1,0);
416#ifndef TOLUA_RELEASE
417 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_bool'", NULL);
418#endif
419 bool exc_caught = false;
420 try {
421 {
422 bool tolua_ret = (bool) self->is_bool();
423 tolua_pushboolean(tolua_S,(bool)tolua_ret);
424 }
425 } catch (fawkes::Exception &e) {
426 exc_caught = true;
427 lua_pushstring(tolua_S, e.what_no_backtrace());
428 }
429 catch (std::exception &e) {
430 exc_caught = true;
431 lua_pushstring(tolua_S, e.what());
432 }
433 if (exc_caught) lua_error(tolua_S);
434
435 }
436 return 1;
437#ifndef TOLUA_RELEASE
438 tolua_lerror:
439 tolua_error(tolua_S,"#ferror in function 'is_bool'.",&tolua_err);
440 return 0;
441#endif
442}
443#endif //#ifndef TOLUA_DISABLE
444
445/* method: is_string of class ValueIterator */
446#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_ValueIterator_is_string00
447static int tolua_fawkesconfig_fawkes_Configuration_ValueIterator_is_string00(lua_State* tolua_S)
448{
449#ifndef TOLUA_RELEASE
450 tolua_Error tolua_err;
451 if (
452 !tolua_isusertype(tolua_S,1,"fawkes::Configuration::ValueIterator",0,&tolua_err) ||
453 !tolua_isnoobj(tolua_S,2,&tolua_err)
454 )
455 goto tolua_lerror;
456 else
457#endif
458 {
459 fawkes::Configuration::ValueIterator* self = (fawkes::Configuration::ValueIterator*) tolua_tousertype(tolua_S,1,0);
460#ifndef TOLUA_RELEASE
461 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_string'", NULL);
462#endif
463 bool exc_caught = false;
464 try {
465 {
466 bool tolua_ret = (bool) self->is_string();
467 tolua_pushboolean(tolua_S,(bool)tolua_ret);
468 }
469 } catch (fawkes::Exception &e) {
470 exc_caught = true;
471 lua_pushstring(tolua_S, e.what_no_backtrace());
472 }
473 catch (std::exception &e) {
474 exc_caught = true;
475 lua_pushstring(tolua_S, e.what());
476 }
477 if (exc_caught) lua_error(tolua_S);
478
479 }
480 return 1;
481#ifndef TOLUA_RELEASE
482 tolua_lerror:
483 tolua_error(tolua_S,"#ferror in function 'is_string'.",&tolua_err);
484 return 0;
485#endif
486}
487#endif //#ifndef TOLUA_DISABLE
488
489/* method: get_float of class ValueIterator */
490#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_ValueIterator_get_float00
491static int tolua_fawkesconfig_fawkes_Configuration_ValueIterator_get_float00(lua_State* tolua_S)
492{
493#ifndef TOLUA_RELEASE
494 tolua_Error tolua_err;
495 if (
496 !tolua_isusertype(tolua_S,1,"fawkes::Configuration::ValueIterator",0,&tolua_err) ||
497 !tolua_isnoobj(tolua_S,2,&tolua_err)
498 )
499 goto tolua_lerror;
500 else
501#endif
502 {
503 fawkes::Configuration::ValueIterator* self = (fawkes::Configuration::ValueIterator*) tolua_tousertype(tolua_S,1,0);
504#ifndef TOLUA_RELEASE
505 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_float'", NULL);
506#endif
507 bool exc_caught = false;
508 try {
509 {
510 float tolua_ret = (float) self->get_float();
511 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
512 }
513 } catch (fawkes::Exception &e) {
514 exc_caught = true;
515 lua_pushstring(tolua_S, e.what_no_backtrace());
516 }
517 catch (std::exception &e) {
518 exc_caught = true;
519 lua_pushstring(tolua_S, e.what());
520 }
521 if (exc_caught) lua_error(tolua_S);
522
523 }
524 return 1;
525#ifndef TOLUA_RELEASE
526 tolua_lerror:
527 tolua_error(tolua_S,"#ferror in function 'get_float'.",&tolua_err);
528 return 0;
529#endif
530}
531#endif //#ifndef TOLUA_DISABLE
532
533/* method: get_uint of class ValueIterator */
534#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_ValueIterator_get_uint00
535static int tolua_fawkesconfig_fawkes_Configuration_ValueIterator_get_uint00(lua_State* tolua_S)
536{
537#ifndef TOLUA_RELEASE
538 tolua_Error tolua_err;
539 if (
540 !tolua_isusertype(tolua_S,1,"fawkes::Configuration::ValueIterator",0,&tolua_err) ||
541 !tolua_isnoobj(tolua_S,2,&tolua_err)
542 )
543 goto tolua_lerror;
544 else
545#endif
546 {
547 fawkes::Configuration::ValueIterator* self = (fawkes::Configuration::ValueIterator*) tolua_tousertype(tolua_S,1,0);
548#ifndef TOLUA_RELEASE
549 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_uint'", NULL);
550#endif
551 bool exc_caught = false;
552 try {
553 {
554 unsigned int tolua_ret = (unsigned int) self->get_uint();
555 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
556 }
557 } catch (fawkes::Exception &e) {
558 exc_caught = true;
559 lua_pushstring(tolua_S, e.what_no_backtrace());
560 }
561 catch (std::exception &e) {
562 exc_caught = true;
563 lua_pushstring(tolua_S, e.what());
564 }
565 if (exc_caught) lua_error(tolua_S);
566
567 }
568 return 1;
569#ifndef TOLUA_RELEASE
570 tolua_lerror:
571 tolua_error(tolua_S,"#ferror in function 'get_uint'.",&tolua_err);
572 return 0;
573#endif
574}
575#endif //#ifndef TOLUA_DISABLE
576
577/* method: get_int of class ValueIterator */
578#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_ValueIterator_get_int00
579static int tolua_fawkesconfig_fawkes_Configuration_ValueIterator_get_int00(lua_State* tolua_S)
580{
581#ifndef TOLUA_RELEASE
582 tolua_Error tolua_err;
583 if (
584 !tolua_isusertype(tolua_S,1,"fawkes::Configuration::ValueIterator",0,&tolua_err) ||
585 !tolua_isnoobj(tolua_S,2,&tolua_err)
586 )
587 goto tolua_lerror;
588 else
589#endif
590 {
591 fawkes::Configuration::ValueIterator* self = (fawkes::Configuration::ValueIterator*) tolua_tousertype(tolua_S,1,0);
592#ifndef TOLUA_RELEASE
593 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_int'", NULL);
594#endif
595 bool exc_caught = false;
596 try {
597 {
598 int tolua_ret = (int) self->get_int();
599 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
600 }
601 } catch (fawkes::Exception &e) {
602 exc_caught = true;
603 lua_pushstring(tolua_S, e.what_no_backtrace());
604 }
605 catch (std::exception &e) {
606 exc_caught = true;
607 lua_pushstring(tolua_S, e.what());
608 }
609 if (exc_caught) lua_error(tolua_S);
610
611 }
612 return 1;
613#ifndef TOLUA_RELEASE
614 tolua_lerror:
615 tolua_error(tolua_S,"#ferror in function 'get_int'.",&tolua_err);
616 return 0;
617#endif
618}
619#endif //#ifndef TOLUA_DISABLE
620
621/* method: get_bool of class ValueIterator */
622#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_ValueIterator_get_bool00
623static int tolua_fawkesconfig_fawkes_Configuration_ValueIterator_get_bool00(lua_State* tolua_S)
624{
625#ifndef TOLUA_RELEASE
626 tolua_Error tolua_err;
627 if (
628 !tolua_isusertype(tolua_S,1,"fawkes::Configuration::ValueIterator",0,&tolua_err) ||
629 !tolua_isnoobj(tolua_S,2,&tolua_err)
630 )
631 goto tolua_lerror;
632 else
633#endif
634 {
635 fawkes::Configuration::ValueIterator* self = (fawkes::Configuration::ValueIterator*) tolua_tousertype(tolua_S,1,0);
636#ifndef TOLUA_RELEASE
637 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_bool'", NULL);
638#endif
639 bool exc_caught = false;
640 try {
641 {
642 bool tolua_ret = (bool) self->get_bool();
643 tolua_pushboolean(tolua_S,(bool)tolua_ret);
644 }
645 } catch (fawkes::Exception &e) {
646 exc_caught = true;
647 lua_pushstring(tolua_S, e.what_no_backtrace());
648 }
649 catch (std::exception &e) {
650 exc_caught = true;
651 lua_pushstring(tolua_S, e.what());
652 }
653 if (exc_caught) lua_error(tolua_S);
654
655 }
656 return 1;
657#ifndef TOLUA_RELEASE
658 tolua_lerror:
659 tolua_error(tolua_S,"#ferror in function 'get_bool'.",&tolua_err);
660 return 0;
661#endif
662}
663#endif //#ifndef TOLUA_DISABLE
664
665/* method: get_string of class ValueIterator */
666#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_ValueIterator_get_string00
667static int tolua_fawkesconfig_fawkes_Configuration_ValueIterator_get_string00(lua_State* tolua_S)
668{
669#ifndef TOLUA_RELEASE
670 tolua_Error tolua_err;
671 if (
672 !tolua_isusertype(tolua_S,1,"fawkes::Configuration::ValueIterator",0,&tolua_err) ||
673 !tolua_isnoobj(tolua_S,2,&tolua_err)
674 )
675 goto tolua_lerror;
676 else
677#endif
678 {
679 fawkes::Configuration::ValueIterator* self = (fawkes::Configuration::ValueIterator*) tolua_tousertype(tolua_S,1,0);
680#ifndef TOLUA_RELEASE
681 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_string'", NULL);
682#endif
683 bool exc_caught = false;
684 try {
685 {
686 std::string tolua_ret = (std::string) self->get_string();
687 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
688 }
689 } catch (fawkes::Exception &e) {
690 exc_caught = true;
691 lua_pushstring(tolua_S, e.what_no_backtrace());
692 }
693 catch (std::exception &e) {
694 exc_caught = true;
695 lua_pushstring(tolua_S, e.what());
696 }
697 if (exc_caught) lua_error(tolua_S);
698
699 }
700 return 1;
701#ifndef TOLUA_RELEASE
702 tolua_lerror:
703 tolua_error(tolua_S,"#ferror in function 'get_string'.",&tolua_err);
704 return 0;
705#endif
706}
707#endif //#ifndef TOLUA_DISABLE
708
709/* method: is_default of class ValueIterator */
710#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_ValueIterator_is_default00
711static int tolua_fawkesconfig_fawkes_Configuration_ValueIterator_is_default00(lua_State* tolua_S)
712{
713#ifndef TOLUA_RELEASE
714 tolua_Error tolua_err;
715 if (
716 !tolua_isusertype(tolua_S,1,"fawkes::Configuration::ValueIterator",0,&tolua_err) ||
717 !tolua_isnoobj(tolua_S,2,&tolua_err)
718 )
719 goto tolua_lerror;
720 else
721#endif
722 {
723 fawkes::Configuration::ValueIterator* self = (fawkes::Configuration::ValueIterator*) tolua_tousertype(tolua_S,1,0);
724#ifndef TOLUA_RELEASE
725 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_default'", NULL);
726#endif
727 bool exc_caught = false;
728 try {
729 {
730 bool tolua_ret = (bool) self->is_default();
731 tolua_pushboolean(tolua_S,(bool)tolua_ret);
732 }
733 } catch (fawkes::Exception &e) {
734 exc_caught = true;
735 lua_pushstring(tolua_S, e.what_no_backtrace());
736 }
737 catch (std::exception &e) {
738 exc_caught = true;
739 lua_pushstring(tolua_S, e.what());
740 }
741 if (exc_caught) lua_error(tolua_S);
742
743 }
744 return 1;
745#ifndef TOLUA_RELEASE
746 tolua_lerror:
747 tolua_error(tolua_S,"#ferror in function 'is_default'.",&tolua_err);
748 return 0;
749#endif
750}
751#endif //#ifndef TOLUA_DISABLE
752
753/* method: exists of class fawkes::Configuration */
754#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_exists00
755static int tolua_fawkesconfig_fawkes_Configuration_exists00(lua_State* tolua_S)
756{
757#ifndef TOLUA_RELEASE
758 tolua_Error tolua_err;
759 if (
760 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
761 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
762 !tolua_isnoobj(tolua_S,3,&tolua_err)
763 )
764 goto tolua_lerror;
765 else
766#endif
767 {
768 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
769 const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
770#ifndef TOLUA_RELEASE
771 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'exists'", NULL);
772#endif
773 bool exc_caught = false;
774 try {
775 {
776 bool tolua_ret = (bool) self->exists(path);
777 tolua_pushboolean(tolua_S,(bool)tolua_ret);
778 }
779 } catch (fawkes::Exception &e) {
780 exc_caught = true;
781 lua_pushstring(tolua_S, e.what_no_backtrace());
782 }
783 catch (std::exception &e) {
784 exc_caught = true;
785 lua_pushstring(tolua_S, e.what());
786 }
787 if (exc_caught) lua_error(tolua_S);
788
789 }
790 return 1;
791#ifndef TOLUA_RELEASE
792 tolua_lerror:
793 tolua_error(tolua_S,"#ferror in function 'exists'.",&tolua_err);
794 return 0;
795#endif
796}
797#endif //#ifndef TOLUA_DISABLE
798
799/* method: is_float of class fawkes::Configuration */
800#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_is_float00
801static int tolua_fawkesconfig_fawkes_Configuration_is_float00(lua_State* tolua_S)
802{
803#ifndef TOLUA_RELEASE
804 tolua_Error tolua_err;
805 if (
806 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
807 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
808 !tolua_isnoobj(tolua_S,3,&tolua_err)
809 )
810 goto tolua_lerror;
811 else
812#endif
813 {
814 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
815 const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
816#ifndef TOLUA_RELEASE
817 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_float'", NULL);
818#endif
819 bool exc_caught = false;
820 try {
821 {
822 bool tolua_ret = (bool) self->is_float(path);
823 tolua_pushboolean(tolua_S,(bool)tolua_ret);
824 }
825 } catch (fawkes::Exception &e) {
826 exc_caught = true;
827 lua_pushstring(tolua_S, e.what_no_backtrace());
828 }
829 catch (std::exception &e) {
830 exc_caught = true;
831 lua_pushstring(tolua_S, e.what());
832 }
833 if (exc_caught) lua_error(tolua_S);
834
835 }
836 return 1;
837#ifndef TOLUA_RELEASE
838 tolua_lerror:
839 tolua_error(tolua_S,"#ferror in function 'is_float'.",&tolua_err);
840 return 0;
841#endif
842}
843#endif //#ifndef TOLUA_DISABLE
844
845/* method: is_uint of class fawkes::Configuration */
846#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_is_uint00
847static int tolua_fawkesconfig_fawkes_Configuration_is_uint00(lua_State* tolua_S)
848{
849#ifndef TOLUA_RELEASE
850 tolua_Error tolua_err;
851 if (
852 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
853 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
854 !tolua_isnoobj(tolua_S,3,&tolua_err)
855 )
856 goto tolua_lerror;
857 else
858#endif
859 {
860 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
861 const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
862#ifndef TOLUA_RELEASE
863 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_uint'", NULL);
864#endif
865 bool exc_caught = false;
866 try {
867 {
868 bool tolua_ret = (bool) self->is_uint(path);
869 tolua_pushboolean(tolua_S,(bool)tolua_ret);
870 }
871 } catch (fawkes::Exception &e) {
872 exc_caught = true;
873 lua_pushstring(tolua_S, e.what_no_backtrace());
874 }
875 catch (std::exception &e) {
876 exc_caught = true;
877 lua_pushstring(tolua_S, e.what());
878 }
879 if (exc_caught) lua_error(tolua_S);
880
881 }
882 return 1;
883#ifndef TOLUA_RELEASE
884 tolua_lerror:
885 tolua_error(tolua_S,"#ferror in function 'is_uint'.",&tolua_err);
886 return 0;
887#endif
888}
889#endif //#ifndef TOLUA_DISABLE
890
891/* method: is_int of class fawkes::Configuration */
892#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_is_int00
893static int tolua_fawkesconfig_fawkes_Configuration_is_int00(lua_State* tolua_S)
894{
895#ifndef TOLUA_RELEASE
896 tolua_Error tolua_err;
897 if (
898 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
899 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
900 !tolua_isnoobj(tolua_S,3,&tolua_err)
901 )
902 goto tolua_lerror;
903 else
904#endif
905 {
906 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
907 const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
908#ifndef TOLUA_RELEASE
909 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_int'", NULL);
910#endif
911 bool exc_caught = false;
912 try {
913 {
914 bool tolua_ret = (bool) self->is_int(path);
915 tolua_pushboolean(tolua_S,(bool)tolua_ret);
916 }
917 } catch (fawkes::Exception &e) {
918 exc_caught = true;
919 lua_pushstring(tolua_S, e.what_no_backtrace());
920 }
921 catch (std::exception &e) {
922 exc_caught = true;
923 lua_pushstring(tolua_S, e.what());
924 }
925 if (exc_caught) lua_error(tolua_S);
926
927 }
928 return 1;
929#ifndef TOLUA_RELEASE
930 tolua_lerror:
931 tolua_error(tolua_S,"#ferror in function 'is_int'.",&tolua_err);
932 return 0;
933#endif
934}
935#endif //#ifndef TOLUA_DISABLE
936
937/* method: is_bool of class fawkes::Configuration */
938#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_is_bool00
939static int tolua_fawkesconfig_fawkes_Configuration_is_bool00(lua_State* tolua_S)
940{
941#ifndef TOLUA_RELEASE
942 tolua_Error tolua_err;
943 if (
944 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
945 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
946 !tolua_isnoobj(tolua_S,3,&tolua_err)
947 )
948 goto tolua_lerror;
949 else
950#endif
951 {
952 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
953 const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
954#ifndef TOLUA_RELEASE
955 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_bool'", NULL);
956#endif
957 bool exc_caught = false;
958 try {
959 {
960 bool tolua_ret = (bool) self->is_bool(path);
961 tolua_pushboolean(tolua_S,(bool)tolua_ret);
962 }
963 } catch (fawkes::Exception &e) {
964 exc_caught = true;
965 lua_pushstring(tolua_S, e.what_no_backtrace());
966 }
967 catch (std::exception &e) {
968 exc_caught = true;
969 lua_pushstring(tolua_S, e.what());
970 }
971 if (exc_caught) lua_error(tolua_S);
972
973 }
974 return 1;
975#ifndef TOLUA_RELEASE
976 tolua_lerror:
977 tolua_error(tolua_S,"#ferror in function 'is_bool'.",&tolua_err);
978 return 0;
979#endif
980}
981#endif //#ifndef TOLUA_DISABLE
982
983/* method: is_string of class fawkes::Configuration */
984#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_is_string00
985static int tolua_fawkesconfig_fawkes_Configuration_is_string00(lua_State* tolua_S)
986{
987#ifndef TOLUA_RELEASE
988 tolua_Error tolua_err;
989 if (
990 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
991 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
992 !tolua_isnoobj(tolua_S,3,&tolua_err)
993 )
994 goto tolua_lerror;
995 else
996#endif
997 {
998 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
999 const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
1000#ifndef TOLUA_RELEASE
1001 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_string'", NULL);
1002#endif
1003 bool exc_caught = false;
1004 try {
1005 {
1006 bool tolua_ret = (bool) self->is_string(path);
1007 tolua_pushboolean(tolua_S,(bool)tolua_ret);
1008 }
1009 } catch (fawkes::Exception &e) {
1010 exc_caught = true;
1011 lua_pushstring(tolua_S, e.what_no_backtrace());
1012 }
1013 catch (std::exception &e) {
1014 exc_caught = true;
1015 lua_pushstring(tolua_S, e.what());
1016 }
1017 if (exc_caught) lua_error(tolua_S);
1018
1019 }
1020 return 1;
1021#ifndef TOLUA_RELEASE
1022 tolua_lerror:
1023 tolua_error(tolua_S,"#ferror in function 'is_string'.",&tolua_err);
1024 return 0;
1025#endif
1026}
1027#endif //#ifndef TOLUA_DISABLE
1028
1029/* method: is_default of class fawkes::Configuration */
1030#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_is_default00
1031static int tolua_fawkesconfig_fawkes_Configuration_is_default00(lua_State* tolua_S)
1032{
1033#ifndef TOLUA_RELEASE
1034 tolua_Error tolua_err;
1035 if (
1036 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1037 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1038 !tolua_isnoobj(tolua_S,3,&tolua_err)
1039 )
1040 goto tolua_lerror;
1041 else
1042#endif
1043 {
1044 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1045 const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
1046#ifndef TOLUA_RELEASE
1047 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_default'", NULL);
1048#endif
1049 bool exc_caught = false;
1050 try {
1051 {
1052 bool tolua_ret = (bool) self->is_default(path);
1053 tolua_pushboolean(tolua_S,(bool)tolua_ret);
1054 }
1055 } catch (fawkes::Exception &e) {
1056 exc_caught = true;
1057 lua_pushstring(tolua_S, e.what_no_backtrace());
1058 }
1059 catch (std::exception &e) {
1060 exc_caught = true;
1061 lua_pushstring(tolua_S, e.what());
1062 }
1063 if (exc_caught) lua_error(tolua_S);
1064
1065 }
1066 return 1;
1067#ifndef TOLUA_RELEASE
1068 tolua_lerror:
1069 tolua_error(tolua_S,"#ferror in function 'is_default'.",&tolua_err);
1070 return 0;
1071#endif
1072}
1073#endif //#ifndef TOLUA_DISABLE
1074
1075/* method: get_float of class fawkes::Configuration */
1076#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_get_float00
1077static int tolua_fawkesconfig_fawkes_Configuration_get_float00(lua_State* tolua_S)
1078{
1079#ifndef TOLUA_RELEASE
1080 tolua_Error tolua_err;
1081 if (
1082 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1083 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1084 !tolua_isnoobj(tolua_S,3,&tolua_err)
1085 )
1086 goto tolua_lerror;
1087 else
1088#endif
1089 {
1090 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1091 const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
1092#ifndef TOLUA_RELEASE
1093 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_float'", NULL);
1094#endif
1095 bool exc_caught = false;
1096 try {
1097 {
1098 float tolua_ret = (float) self->get_float(path);
1099 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1100 }
1101 } catch (fawkes::Exception &e) {
1102 exc_caught = true;
1103 lua_pushstring(tolua_S, e.what_no_backtrace());
1104 }
1105 catch (std::exception &e) {
1106 exc_caught = true;
1107 lua_pushstring(tolua_S, e.what());
1108 }
1109 if (exc_caught) lua_error(tolua_S);
1110
1111 }
1112 return 1;
1113#ifndef TOLUA_RELEASE
1114 tolua_lerror:
1115 tolua_error(tolua_S,"#ferror in function 'get_float'.",&tolua_err);
1116 return 0;
1117#endif
1118}
1119#endif //#ifndef TOLUA_DISABLE
1120
1121/* method: get_uint of class fawkes::Configuration */
1122#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_get_uint00
1123static int tolua_fawkesconfig_fawkes_Configuration_get_uint00(lua_State* tolua_S)
1124{
1125#ifndef TOLUA_RELEASE
1126 tolua_Error tolua_err;
1127 if (
1128 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1129 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1130 !tolua_isnoobj(tolua_S,3,&tolua_err)
1131 )
1132 goto tolua_lerror;
1133 else
1134#endif
1135 {
1136 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1137 const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
1138#ifndef TOLUA_RELEASE
1139 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_uint'", NULL);
1140#endif
1141 bool exc_caught = false;
1142 try {
1143 {
1144 unsigned int tolua_ret = (unsigned int) self->get_uint(path);
1145 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1146 }
1147 } catch (fawkes::Exception &e) {
1148 exc_caught = true;
1149 lua_pushstring(tolua_S, e.what_no_backtrace());
1150 }
1151 catch (std::exception &e) {
1152 exc_caught = true;
1153 lua_pushstring(tolua_S, e.what());
1154 }
1155 if (exc_caught) lua_error(tolua_S);
1156
1157 }
1158 return 1;
1159#ifndef TOLUA_RELEASE
1160 tolua_lerror:
1161 tolua_error(tolua_S,"#ferror in function 'get_uint'.",&tolua_err);
1162 return 0;
1163#endif
1164}
1165#endif //#ifndef TOLUA_DISABLE
1166
1167/* method: get_int of class fawkes::Configuration */
1168#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_get_int00
1169static int tolua_fawkesconfig_fawkes_Configuration_get_int00(lua_State* tolua_S)
1170{
1171#ifndef TOLUA_RELEASE
1172 tolua_Error tolua_err;
1173 if (
1174 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1175 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1176 !tolua_isnoobj(tolua_S,3,&tolua_err)
1177 )
1178 goto tolua_lerror;
1179 else
1180#endif
1181 {
1182 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1183 const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
1184#ifndef TOLUA_RELEASE
1185 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_int'", NULL);
1186#endif
1187 bool exc_caught = false;
1188 try {
1189 {
1190 int tolua_ret = (int) self->get_int(path);
1191 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1192 }
1193 } catch (fawkes::Exception &e) {
1194 exc_caught = true;
1195 lua_pushstring(tolua_S, e.what_no_backtrace());
1196 }
1197 catch (std::exception &e) {
1198 exc_caught = true;
1199 lua_pushstring(tolua_S, e.what());
1200 }
1201 if (exc_caught) lua_error(tolua_S);
1202
1203 }
1204 return 1;
1205#ifndef TOLUA_RELEASE
1206 tolua_lerror:
1207 tolua_error(tolua_S,"#ferror in function 'get_int'.",&tolua_err);
1208 return 0;
1209#endif
1210}
1211#endif //#ifndef TOLUA_DISABLE
1212
1213/* method: get_bool of class fawkes::Configuration */
1214#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_get_bool00
1215static int tolua_fawkesconfig_fawkes_Configuration_get_bool00(lua_State* tolua_S)
1216{
1217#ifndef TOLUA_RELEASE
1218 tolua_Error tolua_err;
1219 if (
1220 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1221 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1222 !tolua_isnoobj(tolua_S,3,&tolua_err)
1223 )
1224 goto tolua_lerror;
1225 else
1226#endif
1227 {
1228 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1229 const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
1230#ifndef TOLUA_RELEASE
1231 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_bool'", NULL);
1232#endif
1233 bool exc_caught = false;
1234 try {
1235 {
1236 bool tolua_ret = (bool) self->get_bool(path);
1237 tolua_pushboolean(tolua_S,(bool)tolua_ret);
1238 }
1239 } catch (fawkes::Exception &e) {
1240 exc_caught = true;
1241 lua_pushstring(tolua_S, e.what_no_backtrace());
1242 }
1243 catch (std::exception &e) {
1244 exc_caught = true;
1245 lua_pushstring(tolua_S, e.what());
1246 }
1247 if (exc_caught) lua_error(tolua_S);
1248
1249 }
1250 return 1;
1251#ifndef TOLUA_RELEASE
1252 tolua_lerror:
1253 tolua_error(tolua_S,"#ferror in function 'get_bool'.",&tolua_err);
1254 return 0;
1255#endif
1256}
1257#endif //#ifndef TOLUA_DISABLE
1258
1259/* method: get_string of class fawkes::Configuration */
1260#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_get_string00
1261static int tolua_fawkesconfig_fawkes_Configuration_get_string00(lua_State* tolua_S)
1262{
1263#ifndef TOLUA_RELEASE
1264 tolua_Error tolua_err;
1265 if (
1266 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1267 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1268 !tolua_isnoobj(tolua_S,3,&tolua_err)
1269 )
1270 goto tolua_lerror;
1271 else
1272#endif
1273 {
1274 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1275 const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
1276#ifndef TOLUA_RELEASE
1277 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_string'", NULL);
1278#endif
1279 bool exc_caught = false;
1280 try {
1281 {
1282 std::string tolua_ret = (std::string) self->get_string(path);
1283 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
1284 }
1285 } catch (fawkes::Exception &e) {
1286 exc_caught = true;
1287 lua_pushstring(tolua_S, e.what_no_backtrace());
1288 }
1289 catch (std::exception &e) {
1290 exc_caught = true;
1291 lua_pushstring(tolua_S, e.what());
1292 }
1293 if (exc_caught) lua_error(tolua_S);
1294
1295 }
1296 return 1;
1297#ifndef TOLUA_RELEASE
1298 tolua_lerror:
1299 tolua_error(tolua_S,"#ferror in function 'get_string'.",&tolua_err);
1300 return 0;
1301#endif
1302}
1303#endif //#ifndef TOLUA_DISABLE
1304
1305/* method: get_value of class fawkes::Configuration */
1306#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_get_value00
1307static int tolua_fawkesconfig_fawkes_Configuration_get_value00(lua_State* tolua_S)
1308{
1309#ifndef TOLUA_RELEASE
1310 tolua_Error tolua_err;
1311 if (
1312 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1313 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1314 !tolua_isnoobj(tolua_S,3,&tolua_err)
1315 )
1316 goto tolua_lerror;
1317 else
1318#endif
1319 {
1320 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1321 const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
1322#ifndef TOLUA_RELEASE
1323 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_value'", NULL);
1324#endif
1325 bool exc_caught = false;
1326 try {
1327 {
1329 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Configuration::ValueIterator");
1330 }
1331 } catch (fawkes::Exception &e) {
1332 exc_caught = true;
1333 lua_pushstring(tolua_S, e.what_no_backtrace());
1334 }
1335 catch (std::exception &e) {
1336 exc_caught = true;
1337 lua_pushstring(tolua_S, e.what());
1338 }
1339 if (exc_caught) lua_error(tolua_S);
1340
1341 }
1342 return 1;
1343#ifndef TOLUA_RELEASE
1344 tolua_lerror:
1345 tolua_error(tolua_S,"#ferror in function 'get_value'.",&tolua_err);
1346 return 0;
1347#endif
1348}
1349#endif //#ifndef TOLUA_DISABLE
1350
1351/* method: get_float_or_default of class fawkes::Configuration */
1352#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_get_float_or_default00
1353static int tolua_fawkesconfig_fawkes_Configuration_get_float_or_default00(lua_State* tolua_S)
1354{
1355#ifndef TOLUA_RELEASE
1356 tolua_Error tolua_err;
1357 if (
1358 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1359 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1360 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
1361 !tolua_isnoobj(tolua_S,4,&tolua_err)
1362 )
1363 goto tolua_lerror;
1364 else
1365#endif
1366 {
1367 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1368 char* path = ((char*) tolua_tostring(tolua_S,2,0));
1369 float f = ((float) tolua_tonumber(tolua_S,3,0));
1370#ifndef TOLUA_RELEASE
1371 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_float_or_default'", NULL);
1372#endif
1373 bool exc_caught = false;
1374 try {
1375 {
1376 float tolua_ret = (float) self->get_float_or_default(path,f);
1377 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1378 }
1379 } catch (fawkes::Exception &e) {
1380 exc_caught = true;
1381 lua_pushstring(tolua_S, e.what_no_backtrace());
1382 }
1383 catch (std::exception &e) {
1384 exc_caught = true;
1385 lua_pushstring(tolua_S, e.what());
1386 }
1387 if (exc_caught) lua_error(tolua_S);
1388
1389 }
1390 return 1;
1391#ifndef TOLUA_RELEASE
1392 tolua_lerror:
1393 tolua_error(tolua_S,"#ferror in function 'get_float_or_default'.",&tolua_err);
1394 return 0;
1395#endif
1396}
1397#endif //#ifndef TOLUA_DISABLE
1398
1399/* method: get_int_or_default of class fawkes::Configuration */
1400#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_get_int_or_default00
1401static int tolua_fawkesconfig_fawkes_Configuration_get_int_or_default00(lua_State* tolua_S)
1402{
1403#ifndef TOLUA_RELEASE
1404 tolua_Error tolua_err;
1405 if (
1406 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1407 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1408 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
1409 !tolua_isnoobj(tolua_S,4,&tolua_err)
1410 )
1411 goto tolua_lerror;
1412 else
1413#endif
1414 {
1415 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1416 char* path = ((char*) tolua_tostring(tolua_S,2,0));
1417 int i = ((int) tolua_tonumber(tolua_S,3,0));
1418#ifndef TOLUA_RELEASE
1419 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_int_or_default'", NULL);
1420#endif
1421 bool exc_caught = false;
1422 try {
1423 {
1424 int tolua_ret = (int) self->get_int_or_default(path,i);
1425 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1426 }
1427 } catch (fawkes::Exception &e) {
1428 exc_caught = true;
1429 lua_pushstring(tolua_S, e.what_no_backtrace());
1430 }
1431 catch (std::exception &e) {
1432 exc_caught = true;
1433 lua_pushstring(tolua_S, e.what());
1434 }
1435 if (exc_caught) lua_error(tolua_S);
1436
1437 }
1438 return 1;
1439#ifndef TOLUA_RELEASE
1440 tolua_lerror:
1441 tolua_error(tolua_S,"#ferror in function 'get_int_or_default'.",&tolua_err);
1442 return 0;
1443#endif
1444}
1445#endif //#ifndef TOLUA_DISABLE
1446
1447/* method: set_float of class fawkes::Configuration */
1448#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_set_float00
1449static int tolua_fawkesconfig_fawkes_Configuration_set_float00(lua_State* tolua_S)
1450{
1451#ifndef TOLUA_RELEASE
1452 tolua_Error tolua_err;
1453 if (
1454 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1455 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1456 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
1457 !tolua_isnoobj(tolua_S,4,&tolua_err)
1458 )
1459 goto tolua_lerror;
1460 else
1461#endif
1462 {
1463 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1464 const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
1465 float f = ((float) tolua_tonumber(tolua_S,3,0));
1466#ifndef TOLUA_RELEASE
1467 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_float'", NULL);
1468#endif
1469 bool exc_caught = false;
1470 try {
1471 {
1472 self->set_float(path,f);
1473 }
1474 } catch (fawkes::Exception &e) {
1475 exc_caught = true;
1476 lua_pushstring(tolua_S, e.what_no_backtrace());
1477 }
1478 catch (std::exception &e) {
1479 exc_caught = true;
1480 lua_pushstring(tolua_S, e.what());
1481 }
1482 if (exc_caught) lua_error(tolua_S);
1483
1484 }
1485 return 0;
1486#ifndef TOLUA_RELEASE
1487 tolua_lerror:
1488 tolua_error(tolua_S,"#ferror in function 'set_float'.",&tolua_err);
1489 return 0;
1490#endif
1491}
1492#endif //#ifndef TOLUA_DISABLE
1493
1494/* method: set_uint of class fawkes::Configuration */
1495#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_set_uint00
1496static int tolua_fawkesconfig_fawkes_Configuration_set_uint00(lua_State* tolua_S)
1497{
1498#ifndef TOLUA_RELEASE
1499 tolua_Error tolua_err;
1500 if (
1501 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1502 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1503 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
1504 !tolua_isnoobj(tolua_S,4,&tolua_err)
1505 )
1506 goto tolua_lerror;
1507 else
1508#endif
1509 {
1510 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1511 const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
1512 unsigned int uint = ((unsigned int) tolua_tonumber(tolua_S,3,0));
1513#ifndef TOLUA_RELEASE
1514 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_uint'", NULL);
1515#endif
1516 bool exc_caught = false;
1517 try {
1518 {
1519 self->set_uint(path,uint);
1520 }
1521 } catch (fawkes::Exception &e) {
1522 exc_caught = true;
1523 lua_pushstring(tolua_S, e.what_no_backtrace());
1524 }
1525 catch (std::exception &e) {
1526 exc_caught = true;
1527 lua_pushstring(tolua_S, e.what());
1528 }
1529 if (exc_caught) lua_error(tolua_S);
1530
1531 }
1532 return 0;
1533#ifndef TOLUA_RELEASE
1534 tolua_lerror:
1535 tolua_error(tolua_S,"#ferror in function 'set_uint'.",&tolua_err);
1536 return 0;
1537#endif
1538}
1539#endif //#ifndef TOLUA_DISABLE
1540
1541/* method: set_int of class fawkes::Configuration */
1542#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_set_int00
1543static int tolua_fawkesconfig_fawkes_Configuration_set_int00(lua_State* tolua_S)
1544{
1545#ifndef TOLUA_RELEASE
1546 tolua_Error tolua_err;
1547 if (
1548 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1549 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1550 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
1551 !tolua_isnoobj(tolua_S,4,&tolua_err)
1552 )
1553 goto tolua_lerror;
1554 else
1555#endif
1556 {
1557 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1558 const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
1559 int i = ((int) tolua_tonumber(tolua_S,3,0));
1560#ifndef TOLUA_RELEASE
1561 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_int'", NULL);
1562#endif
1563 bool exc_caught = false;
1564 try {
1565 {
1566 self->set_int(path,i);
1567 }
1568 } catch (fawkes::Exception &e) {
1569 exc_caught = true;
1570 lua_pushstring(tolua_S, e.what_no_backtrace());
1571 }
1572 catch (std::exception &e) {
1573 exc_caught = true;
1574 lua_pushstring(tolua_S, e.what());
1575 }
1576 if (exc_caught) lua_error(tolua_S);
1577
1578 }
1579 return 0;
1580#ifndef TOLUA_RELEASE
1581 tolua_lerror:
1582 tolua_error(tolua_S,"#ferror in function 'set_int'.",&tolua_err);
1583 return 0;
1584#endif
1585}
1586#endif //#ifndef TOLUA_DISABLE
1587
1588/* method: set_bool of class fawkes::Configuration */
1589#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_set_bool00
1590static int tolua_fawkesconfig_fawkes_Configuration_set_bool00(lua_State* tolua_S)
1591{
1592#ifndef TOLUA_RELEASE
1593 tolua_Error tolua_err;
1594 if (
1595 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1596 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1597 !tolua_isboolean(tolua_S,3,0,&tolua_err) ||
1598 !tolua_isnoobj(tolua_S,4,&tolua_err)
1599 )
1600 goto tolua_lerror;
1601 else
1602#endif
1603 {
1604 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1605 const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
1606 bool b = ((bool) tolua_toboolean(tolua_S,3,0));
1607#ifndef TOLUA_RELEASE
1608 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_bool'", NULL);
1609#endif
1610 bool exc_caught = false;
1611 try {
1612 {
1613 self->set_bool(path,b);
1614 }
1615 } catch (fawkes::Exception &e) {
1616 exc_caught = true;
1617 lua_pushstring(tolua_S, e.what_no_backtrace());
1618 }
1619 catch (std::exception &e) {
1620 exc_caught = true;
1621 lua_pushstring(tolua_S, e.what());
1622 }
1623 if (exc_caught) lua_error(tolua_S);
1624
1625 }
1626 return 0;
1627#ifndef TOLUA_RELEASE
1628 tolua_lerror:
1629 tolua_error(tolua_S,"#ferror in function 'set_bool'.",&tolua_err);
1630 return 0;
1631#endif
1632}
1633#endif //#ifndef TOLUA_DISABLE
1634
1635/* method: set_string of class fawkes::Configuration */
1636#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_set_string00
1637static int tolua_fawkesconfig_fawkes_Configuration_set_string00(lua_State* tolua_S)
1638{
1639#ifndef TOLUA_RELEASE
1640 tolua_Error tolua_err;
1641 if (
1642 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1643 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1644 !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
1645 !tolua_isnoobj(tolua_S,4,&tolua_err)
1646 )
1647 goto tolua_lerror;
1648 else
1649#endif
1650 {
1651 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1652 const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
1653 std::string s = ((std::string) tolua_tocppstring(tolua_S,3,0));
1654#ifndef TOLUA_RELEASE
1655 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_string'", NULL);
1656#endif
1657 bool exc_caught = false;
1658 try {
1659 {
1660 self->set_string(path,s);
1661 }
1662 } catch (fawkes::Exception &e) {
1663 exc_caught = true;
1664 lua_pushstring(tolua_S, e.what_no_backtrace());
1665 }
1666 catch (std::exception &e) {
1667 exc_caught = true;
1668 lua_pushstring(tolua_S, e.what());
1669 }
1670 if (exc_caught) lua_error(tolua_S);
1671
1672 }
1673 return 0;
1674#ifndef TOLUA_RELEASE
1675 tolua_lerror:
1676 tolua_error(tolua_S,"#ferror in function 'set_string'.",&tolua_err);
1677 return 0;
1678#endif
1679}
1680#endif //#ifndef TOLUA_DISABLE
1681
1682/* method: set_string of class fawkes::Configuration */
1683#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_set_string01
1684static int tolua_fawkesconfig_fawkes_Configuration_set_string01(lua_State* tolua_S)
1685{
1686 tolua_Error tolua_err;
1687 if (
1688 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1689 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1690 !tolua_isstring(tolua_S,3,0,&tolua_err) ||
1691 !tolua_isnoobj(tolua_S,4,&tolua_err)
1692 )
1693 goto tolua_lerror;
1694 else
1695 {
1696 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1697 const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
1698 const char* s = ((const char*) tolua_tostring(tolua_S,3,0));
1699#ifndef TOLUA_RELEASE
1700 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_string'", NULL);
1701#endif
1702 bool exc_caught = false;
1703 try {
1704 {
1705 self->set_string(path,s);
1706 }
1707 } catch (fawkes::Exception &e) {
1708 exc_caught = true;
1709 lua_pushstring(tolua_S, e.what_no_backtrace());
1710 }
1711 catch (std::exception &e) {
1712 exc_caught = true;
1713 lua_pushstring(tolua_S, e.what());
1714 }
1715 if (exc_caught) lua_error(tolua_S);
1716
1717 }
1718 return 0;
1719tolua_lerror:
1720 return tolua_fawkesconfig_fawkes_Configuration_set_string00(tolua_S);
1721}
1722#endif //#ifndef TOLUA_DISABLE
1723
1724/* method: erase of class fawkes::Configuration */
1725#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_erase00
1726static int tolua_fawkesconfig_fawkes_Configuration_erase00(lua_State* tolua_S)
1727{
1728#ifndef TOLUA_RELEASE
1729 tolua_Error tolua_err;
1730 if (
1731 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1732 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1733 !tolua_isnoobj(tolua_S,3,&tolua_err)
1734 )
1735 goto tolua_lerror;
1736 else
1737#endif
1738 {
1739 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1740 const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
1741#ifndef TOLUA_RELEASE
1742 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'erase'", NULL);
1743#endif
1744 bool exc_caught = false;
1745 try {
1746 {
1747 self->erase(path);
1748 }
1749 } catch (fawkes::Exception &e) {
1750 exc_caught = true;
1751 lua_pushstring(tolua_S, e.what_no_backtrace());
1752 }
1753 catch (std::exception &e) {
1754 exc_caught = true;
1755 lua_pushstring(tolua_S, e.what());
1756 }
1757 if (exc_caught) lua_error(tolua_S);
1758
1759 }
1760 return 0;
1761#ifndef TOLUA_RELEASE
1762 tolua_lerror:
1763 tolua_error(tolua_S,"#ferror in function 'erase'.",&tolua_err);
1764 return 0;
1765#endif
1766}
1767#endif //#ifndef TOLUA_DISABLE
1768
1769/* method: set_default_float of class fawkes::Configuration */
1770#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_set_default_float00
1771static int tolua_fawkesconfig_fawkes_Configuration_set_default_float00(lua_State* tolua_S)
1772{
1773#ifndef TOLUA_RELEASE
1774 tolua_Error tolua_err;
1775 if (
1776 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1777 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1778 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
1779 !tolua_isnoobj(tolua_S,4,&tolua_err)
1780 )
1781 goto tolua_lerror;
1782 else
1783#endif
1784 {
1785 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1786 const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
1787 float f = ((float) tolua_tonumber(tolua_S,3,0));
1788#ifndef TOLUA_RELEASE
1789 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_default_float'", NULL);
1790#endif
1791 bool exc_caught = false;
1792 try {
1793 {
1794 self->set_default_float(path,f);
1795 }
1796 } catch (fawkes::Exception &e) {
1797 exc_caught = true;
1798 lua_pushstring(tolua_S, e.what_no_backtrace());
1799 }
1800 catch (std::exception &e) {
1801 exc_caught = true;
1802 lua_pushstring(tolua_S, e.what());
1803 }
1804 if (exc_caught) lua_error(tolua_S);
1805
1806 }
1807 return 0;
1808#ifndef TOLUA_RELEASE
1809 tolua_lerror:
1810 tolua_error(tolua_S,"#ferror in function 'set_default_float'.",&tolua_err);
1811 return 0;
1812#endif
1813}
1814#endif //#ifndef TOLUA_DISABLE
1815
1816/* method: set_default_uint of class fawkes::Configuration */
1817#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_set_default_uint00
1818static int tolua_fawkesconfig_fawkes_Configuration_set_default_uint00(lua_State* tolua_S)
1819{
1820#ifndef TOLUA_RELEASE
1821 tolua_Error tolua_err;
1822 if (
1823 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1824 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1825 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
1826 !tolua_isnoobj(tolua_S,4,&tolua_err)
1827 )
1828 goto tolua_lerror;
1829 else
1830#endif
1831 {
1832 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1833 const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
1834 unsigned int uint = ((unsigned int) tolua_tonumber(tolua_S,3,0));
1835#ifndef TOLUA_RELEASE
1836 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_default_uint'", NULL);
1837#endif
1838 bool exc_caught = false;
1839 try {
1840 {
1841 self->set_default_uint(path,uint);
1842 }
1843 } catch (fawkes::Exception &e) {
1844 exc_caught = true;
1845 lua_pushstring(tolua_S, e.what_no_backtrace());
1846 }
1847 catch (std::exception &e) {
1848 exc_caught = true;
1849 lua_pushstring(tolua_S, e.what());
1850 }
1851 if (exc_caught) lua_error(tolua_S);
1852
1853 }
1854 return 0;
1855#ifndef TOLUA_RELEASE
1856 tolua_lerror:
1857 tolua_error(tolua_S,"#ferror in function 'set_default_uint'.",&tolua_err);
1858 return 0;
1859#endif
1860}
1861#endif //#ifndef TOLUA_DISABLE
1862
1863/* method: set_default_int of class fawkes::Configuration */
1864#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_set_default_int00
1865static int tolua_fawkesconfig_fawkes_Configuration_set_default_int00(lua_State* tolua_S)
1866{
1867#ifndef TOLUA_RELEASE
1868 tolua_Error tolua_err;
1869 if (
1870 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1871 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1872 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
1873 !tolua_isnoobj(tolua_S,4,&tolua_err)
1874 )
1875 goto tolua_lerror;
1876 else
1877#endif
1878 {
1879 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1880 const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
1881 int i = ((int) tolua_tonumber(tolua_S,3,0));
1882#ifndef TOLUA_RELEASE
1883 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_default_int'", NULL);
1884#endif
1885 bool exc_caught = false;
1886 try {
1887 {
1888 self->set_default_int(path,i);
1889 }
1890 } catch (fawkes::Exception &e) {
1891 exc_caught = true;
1892 lua_pushstring(tolua_S, e.what_no_backtrace());
1893 }
1894 catch (std::exception &e) {
1895 exc_caught = true;
1896 lua_pushstring(tolua_S, e.what());
1897 }
1898 if (exc_caught) lua_error(tolua_S);
1899
1900 }
1901 return 0;
1902#ifndef TOLUA_RELEASE
1903 tolua_lerror:
1904 tolua_error(tolua_S,"#ferror in function 'set_default_int'.",&tolua_err);
1905 return 0;
1906#endif
1907}
1908#endif //#ifndef TOLUA_DISABLE
1909
1910/* method: set_default_bool of class fawkes::Configuration */
1911#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_set_default_bool00
1912static int tolua_fawkesconfig_fawkes_Configuration_set_default_bool00(lua_State* tolua_S)
1913{
1914#ifndef TOLUA_RELEASE
1915 tolua_Error tolua_err;
1916 if (
1917 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1918 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1919 !tolua_isboolean(tolua_S,3,0,&tolua_err) ||
1920 !tolua_isnoobj(tolua_S,4,&tolua_err)
1921 )
1922 goto tolua_lerror;
1923 else
1924#endif
1925 {
1926 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1927 const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
1928 bool b = ((bool) tolua_toboolean(tolua_S,3,0));
1929#ifndef TOLUA_RELEASE
1930 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_default_bool'", NULL);
1931#endif
1932 bool exc_caught = false;
1933 try {
1934 {
1935 self->set_default_bool(path,b);
1936 }
1937 } catch (fawkes::Exception &e) {
1938 exc_caught = true;
1939 lua_pushstring(tolua_S, e.what_no_backtrace());
1940 }
1941 catch (std::exception &e) {
1942 exc_caught = true;
1943 lua_pushstring(tolua_S, e.what());
1944 }
1945 if (exc_caught) lua_error(tolua_S);
1946
1947 }
1948 return 0;
1949#ifndef TOLUA_RELEASE
1950 tolua_lerror:
1951 tolua_error(tolua_S,"#ferror in function 'set_default_bool'.",&tolua_err);
1952 return 0;
1953#endif
1954}
1955#endif //#ifndef TOLUA_DISABLE
1956
1957/* method: set_default_string of class fawkes::Configuration */
1958#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_set_default_string00
1959static int tolua_fawkesconfig_fawkes_Configuration_set_default_string00(lua_State* tolua_S)
1960{
1961#ifndef TOLUA_RELEASE
1962 tolua_Error tolua_err;
1963 if (
1964 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1965 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1966 !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
1967 !tolua_isnoobj(tolua_S,4,&tolua_err)
1968 )
1969 goto tolua_lerror;
1970 else
1971#endif
1972 {
1973 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1974 const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
1975 std::string s = ((std::string) tolua_tocppstring(tolua_S,3,0));
1976#ifndef TOLUA_RELEASE
1977 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_default_string'", NULL);
1978#endif
1979 bool exc_caught = false;
1980 try {
1981 {
1982 self->set_default_string(path,s);
1983 }
1984 } catch (fawkes::Exception &e) {
1985 exc_caught = true;
1986 lua_pushstring(tolua_S, e.what_no_backtrace());
1987 }
1988 catch (std::exception &e) {
1989 exc_caught = true;
1990 lua_pushstring(tolua_S, e.what());
1991 }
1992 if (exc_caught) lua_error(tolua_S);
1993
1994 }
1995 return 0;
1996#ifndef TOLUA_RELEASE
1997 tolua_lerror:
1998 tolua_error(tolua_S,"#ferror in function 'set_default_string'.",&tolua_err);
1999 return 0;
2000#endif
2001}
2002#endif //#ifndef TOLUA_DISABLE
2003
2004/* method: set_default_string of class fawkes::Configuration */
2005#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_set_default_string01
2006static int tolua_fawkesconfig_fawkes_Configuration_set_default_string01(lua_State* tolua_S)
2007{
2008 tolua_Error tolua_err;
2009 if (
2010 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
2011 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
2012 !tolua_isstring(tolua_S,3,0,&tolua_err) ||
2013 !tolua_isnoobj(tolua_S,4,&tolua_err)
2014 )
2015 goto tolua_lerror;
2016 else
2017 {
2018 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
2019 const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
2020 const char* s = ((const char*) tolua_tostring(tolua_S,3,0));
2021#ifndef TOLUA_RELEASE
2022 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_default_string'", NULL);
2023#endif
2024 bool exc_caught = false;
2025 try {
2026 {
2027 self->set_default_string(path,s);
2028 }
2029 } catch (fawkes::Exception &e) {
2030 exc_caught = true;
2031 lua_pushstring(tolua_S, e.what_no_backtrace());
2032 }
2033 catch (std::exception &e) {
2034 exc_caught = true;
2035 lua_pushstring(tolua_S, e.what());
2036 }
2037 if (exc_caught) lua_error(tolua_S);
2038
2039 }
2040 return 0;
2041tolua_lerror:
2042 return tolua_fawkesconfig_fawkes_Configuration_set_default_string00(tolua_S);
2043}
2044#endif //#ifndef TOLUA_DISABLE
2045
2046/* method: erase_default of class fawkes::Configuration */
2047#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_erase_default00
2048static int tolua_fawkesconfig_fawkes_Configuration_erase_default00(lua_State* tolua_S)
2049{
2050#ifndef TOLUA_RELEASE
2051 tolua_Error tolua_err;
2052 if (
2053 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
2054 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
2055 !tolua_isnoobj(tolua_S,3,&tolua_err)
2056 )
2057 goto tolua_lerror;
2058 else
2059#endif
2060 {
2061 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
2062 const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
2063#ifndef TOLUA_RELEASE
2064 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'erase_default'", NULL);
2065#endif
2066 bool exc_caught = false;
2067 try {
2068 {
2069 self->erase_default(path);
2070 }
2071 } catch (fawkes::Exception &e) {
2072 exc_caught = true;
2073 lua_pushstring(tolua_S, e.what_no_backtrace());
2074 }
2075 catch (std::exception &e) {
2076 exc_caught = true;
2077 lua_pushstring(tolua_S, e.what());
2078 }
2079 if (exc_caught) lua_error(tolua_S);
2080
2081 }
2082 return 0;
2083#ifndef TOLUA_RELEASE
2084 tolua_lerror:
2085 tolua_error(tolua_S,"#ferror in function 'erase_default'.",&tolua_err);
2086 return 0;
2087#endif
2088}
2089#endif //#ifndef TOLUA_DISABLE
2090
2091/* method: iterator of class fawkes::Configuration */
2092#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_iterator00
2093static int tolua_fawkesconfig_fawkes_Configuration_iterator00(lua_State* tolua_S)
2094{
2095#ifndef TOLUA_RELEASE
2096 tolua_Error tolua_err;
2097 if (
2098 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
2099 !tolua_isnoobj(tolua_S,2,&tolua_err)
2100 )
2101 goto tolua_lerror;
2102 else
2103#endif
2104 {
2105 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
2106#ifndef TOLUA_RELEASE
2107 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'iterator'", NULL);
2108#endif
2109 bool exc_caught = false;
2110 try {
2111 {
2113 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Configuration::ValueIterator");
2114 }
2115 } catch (fawkes::Exception &e) {
2116 exc_caught = true;
2117 lua_pushstring(tolua_S, e.what_no_backtrace());
2118 }
2119 catch (std::exception &e) {
2120 exc_caught = true;
2121 lua_pushstring(tolua_S, e.what());
2122 }
2123 if (exc_caught) lua_error(tolua_S);
2124
2125 }
2126 return 1;
2127#ifndef TOLUA_RELEASE
2128 tolua_lerror:
2129 tolua_error(tolua_S,"#ferror in function 'iterator'.",&tolua_err);
2130 return 0;
2131#endif
2132}
2133#endif //#ifndef TOLUA_DISABLE
2134
2135/* method: search of class fawkes::Configuration */
2136#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_search00
2137static int tolua_fawkesconfig_fawkes_Configuration_search00(lua_State* tolua_S)
2138{
2139#ifndef TOLUA_RELEASE
2140 tolua_Error tolua_err;
2141 if (
2142 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
2143 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
2144 !tolua_isnoobj(tolua_S,3,&tolua_err)
2145 )
2146 goto tolua_lerror;
2147 else
2148#endif
2149 {
2150 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
2151 const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
2152#ifndef TOLUA_RELEASE
2153 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'search'", NULL);
2154#endif
2155 bool exc_caught = false;
2156 try {
2157 {
2159 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Configuration::ValueIterator");
2160 }
2161 } catch (fawkes::Exception &e) {
2162 exc_caught = true;
2163 lua_pushstring(tolua_S, e.what_no_backtrace());
2164 }
2165 catch (std::exception &e) {
2166 exc_caught = true;
2167 lua_pushstring(tolua_S, e.what());
2168 }
2169 if (exc_caught) lua_error(tolua_S);
2170
2171 }
2172 return 1;
2173#ifndef TOLUA_RELEASE
2174 tolua_lerror:
2175 tolua_error(tolua_S,"#ferror in function 'search'.",&tolua_err);
2176 return 0;
2177#endif
2178}
2179#endif //#ifndef TOLUA_DISABLE
2180
2181/* method: lock of class fawkes::Configuration */
2182#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_lock00
2183static int tolua_fawkesconfig_fawkes_Configuration_lock00(lua_State* tolua_S)
2184{
2185#ifndef TOLUA_RELEASE
2186 tolua_Error tolua_err;
2187 if (
2188 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
2189 !tolua_isnoobj(tolua_S,2,&tolua_err)
2190 )
2191 goto tolua_lerror;
2192 else
2193#endif
2194 {
2195 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
2196#ifndef TOLUA_RELEASE
2197 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'lock'", NULL);
2198#endif
2199 bool exc_caught = false;
2200 try {
2201 {
2202 self->lock();
2203 }
2204 } catch (fawkes::Exception &e) {
2205 exc_caught = true;
2206 lua_pushstring(tolua_S, e.what_no_backtrace());
2207 }
2208 catch (std::exception &e) {
2209 exc_caught = true;
2210 lua_pushstring(tolua_S, e.what());
2211 }
2212 if (exc_caught) lua_error(tolua_S);
2213
2214 }
2215 return 0;
2216#ifndef TOLUA_RELEASE
2217 tolua_lerror:
2218 tolua_error(tolua_S,"#ferror in function 'lock'.",&tolua_err);
2219 return 0;
2220#endif
2221}
2222#endif //#ifndef TOLUA_DISABLE
2223
2224/* method: try_lock of class fawkes::Configuration */
2225#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_try_lock00
2226static int tolua_fawkesconfig_fawkes_Configuration_try_lock00(lua_State* tolua_S)
2227{
2228#ifndef TOLUA_RELEASE
2229 tolua_Error tolua_err;
2230 if (
2231 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
2232 !tolua_isnoobj(tolua_S,2,&tolua_err)
2233 )
2234 goto tolua_lerror;
2235 else
2236#endif
2237 {
2238 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
2239#ifndef TOLUA_RELEASE
2240 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'try_lock'", NULL);
2241#endif
2242 bool exc_caught = false;
2243 try {
2244 {
2245 bool tolua_ret = (bool) self->try_lock();
2246 tolua_pushboolean(tolua_S,(bool)tolua_ret);
2247 }
2248 } catch (fawkes::Exception &e) {
2249 exc_caught = true;
2250 lua_pushstring(tolua_S, e.what_no_backtrace());
2251 }
2252 catch (std::exception &e) {
2253 exc_caught = true;
2254 lua_pushstring(tolua_S, e.what());
2255 }
2256 if (exc_caught) lua_error(tolua_S);
2257
2258 }
2259 return 1;
2260#ifndef TOLUA_RELEASE
2261 tolua_lerror:
2262 tolua_error(tolua_S,"#ferror in function 'try_lock'.",&tolua_err);
2263 return 0;
2264#endif
2265}
2266#endif //#ifndef TOLUA_DISABLE
2267
2268/* method: unlock of class fawkes::Configuration */
2269#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_unlock00
2270static int tolua_fawkesconfig_fawkes_Configuration_unlock00(lua_State* tolua_S)
2271{
2272#ifndef TOLUA_RELEASE
2273 tolua_Error tolua_err;
2274 if (
2275 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
2276 !tolua_isnoobj(tolua_S,2,&tolua_err)
2277 )
2278 goto tolua_lerror;
2279 else
2280#endif
2281 {
2282 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
2283#ifndef TOLUA_RELEASE
2284 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'unlock'", NULL);
2285#endif
2286 bool exc_caught = false;
2287 try {
2288 {
2289 self->unlock();
2290 }
2291 } catch (fawkes::Exception &e) {
2292 exc_caught = true;
2293 lua_pushstring(tolua_S, e.what_no_backtrace());
2294 }
2295 catch (std::exception &e) {
2296 exc_caught = true;
2297 lua_pushstring(tolua_S, e.what());
2298 }
2299 if (exc_caught) lua_error(tolua_S);
2300
2301 }
2302 return 0;
2303#ifndef TOLUA_RELEASE
2304 tolua_lerror:
2305 tolua_error(tolua_S,"#ferror in function 'unlock'.",&tolua_err);
2306 return 0;
2307#endif
2308}
2309#endif //#ifndef TOLUA_DISABLE
2310
2311/* Open function */
2312TOLUA_API int tolua_fawkesconfig_open (lua_State* tolua_S)
2313{
2314 tolua_open(tolua_S);
2315 tolua_reg_types(tolua_S);
2316 tolua_module(tolua_S,NULL,0);
2317 tolua_beginmodule(tolua_S,NULL);
2318 tolua_module(tolua_S,"fawkes",0);
2319 tolua_beginmodule(tolua_S,"fawkes");
2320 tolua_cclass(tolua_S,"Configuration","fawkes::Configuration","",NULL);
2321 tolua_beginmodule(tolua_S,"Configuration");
2322 #ifdef __cplusplus
2323 tolua_cclass(tolua_S,"ValueIterator","fawkes::Configuration::ValueIterator","",tolua_collect_fawkes__Configuration__ValueIterator);
2324 #else
2325 tolua_cclass(tolua_S,"ValueIterator","fawkes::Configuration::ValueIterator","",NULL);
2326 #endif
2327 tolua_beginmodule(tolua_S,"ValueIterator");
2328 tolua_function(tolua_S,"delete",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_delete00);
2329 tolua_function(tolua_S,"next",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_next00);
2330 tolua_function(tolua_S,"valid",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_valid00);
2331 tolua_function(tolua_S,"path",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_path00);
2332 tolua_function(tolua_S,"type",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_type00);
2333 tolua_function(tolua_S,"is_float",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_is_float00);
2334 tolua_function(tolua_S,"is_uint",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_is_uint00);
2335 tolua_function(tolua_S,"is_int",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_is_int00);
2336 tolua_function(tolua_S,"is_bool",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_is_bool00);
2337 tolua_function(tolua_S,"is_string",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_is_string00);
2338 tolua_function(tolua_S,"get_float",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_get_float00);
2339 tolua_function(tolua_S,"get_uint",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_get_uint00);
2340 tolua_function(tolua_S,"get_int",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_get_int00);
2341 tolua_function(tolua_S,"get_bool",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_get_bool00);
2342 tolua_function(tolua_S,"get_string",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_get_string00);
2343 tolua_function(tolua_S,"is_default",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_is_default00);
2344 tolua_endmodule(tolua_S);
2345 tolua_function(tolua_S,"exists",tolua_fawkesconfig_fawkes_Configuration_exists00);
2346 tolua_function(tolua_S,"is_float",tolua_fawkesconfig_fawkes_Configuration_is_float00);
2347 tolua_function(tolua_S,"is_uint",tolua_fawkesconfig_fawkes_Configuration_is_uint00);
2348 tolua_function(tolua_S,"is_int",tolua_fawkesconfig_fawkes_Configuration_is_int00);
2349 tolua_function(tolua_S,"is_bool",tolua_fawkesconfig_fawkes_Configuration_is_bool00);
2350 tolua_function(tolua_S,"is_string",tolua_fawkesconfig_fawkes_Configuration_is_string00);
2351 tolua_function(tolua_S,"is_default",tolua_fawkesconfig_fawkes_Configuration_is_default00);
2352 tolua_function(tolua_S,"get_float",tolua_fawkesconfig_fawkes_Configuration_get_float00);
2353 tolua_function(tolua_S,"get_uint",tolua_fawkesconfig_fawkes_Configuration_get_uint00);
2354 tolua_function(tolua_S,"get_int",tolua_fawkesconfig_fawkes_Configuration_get_int00);
2355 tolua_function(tolua_S,"get_bool",tolua_fawkesconfig_fawkes_Configuration_get_bool00);
2356 tolua_function(tolua_S,"get_string",tolua_fawkesconfig_fawkes_Configuration_get_string00);
2357 tolua_function(tolua_S,"get_value",tolua_fawkesconfig_fawkes_Configuration_get_value00);
2358 tolua_function(tolua_S,"get_float_or_default",tolua_fawkesconfig_fawkes_Configuration_get_float_or_default00);
2359 tolua_function(tolua_S,"get_int_or_default",tolua_fawkesconfig_fawkes_Configuration_get_int_or_default00);
2360 tolua_function(tolua_S,"set_float",tolua_fawkesconfig_fawkes_Configuration_set_float00);
2361 tolua_function(tolua_S,"set_uint",tolua_fawkesconfig_fawkes_Configuration_set_uint00);
2362 tolua_function(tolua_S,"set_int",tolua_fawkesconfig_fawkes_Configuration_set_int00);
2363 tolua_function(tolua_S,"set_bool",tolua_fawkesconfig_fawkes_Configuration_set_bool00);
2364 tolua_function(tolua_S,"set_string",tolua_fawkesconfig_fawkes_Configuration_set_string00);
2365 tolua_function(tolua_S,"set_string",tolua_fawkesconfig_fawkes_Configuration_set_string01);
2366 tolua_function(tolua_S,"erase",tolua_fawkesconfig_fawkes_Configuration_erase00);
2367 tolua_function(tolua_S,"set_default_float",tolua_fawkesconfig_fawkes_Configuration_set_default_float00);
2368 tolua_function(tolua_S,"set_default_uint",tolua_fawkesconfig_fawkes_Configuration_set_default_uint00);
2369 tolua_function(tolua_S,"set_default_int",tolua_fawkesconfig_fawkes_Configuration_set_default_int00);
2370 tolua_function(tolua_S,"set_default_bool",tolua_fawkesconfig_fawkes_Configuration_set_default_bool00);
2371 tolua_function(tolua_S,"set_default_string",tolua_fawkesconfig_fawkes_Configuration_set_default_string00);
2372 tolua_function(tolua_S,"set_default_string",tolua_fawkesconfig_fawkes_Configuration_set_default_string01);
2373 tolua_function(tolua_S,"erase_default",tolua_fawkesconfig_fawkes_Configuration_erase_default00);
2374 tolua_function(tolua_S,"iterator",tolua_fawkesconfig_fawkes_Configuration_iterator00);
2375 tolua_function(tolua_S,"search",tolua_fawkesconfig_fawkes_Configuration_search00);
2376 tolua_function(tolua_S,"lock",tolua_fawkesconfig_fawkes_Configuration_lock00);
2377 tolua_function(tolua_S,"try_lock",tolua_fawkesconfig_fawkes_Configuration_try_lock00);
2378 tolua_function(tolua_S,"unlock",tolua_fawkesconfig_fawkes_Configuration_unlock00);
2379 tolua_endmodule(tolua_S);
2380 tolua_endmodule(tolua_S);
2381 tolua_endmodule(tolua_S);
2382 return 1;
2383}
2384
2385
2386extern "C" {
2387#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501
2388 TOLUA_API int luaopen_fawkesconfig (lua_State* tolua_S) {
2389 return tolua_fawkesconfig_open(tolua_S);
2390};
2391#endif
2392}
2393
2394
Iterator interface to iterate over config values.
Definition: config.h:75
virtual bool is_uint() const =0
Check if current value is a unsigned int.
virtual const char * path() const =0
Path of value.
virtual bool get_bool() const =0
Get bool value.
virtual unsigned int get_uint() const =0
Get unsigned int value.
virtual bool next()=0
Check if there is another element and advance to this if possible.
virtual float get_float() const =0
Get float value.
virtual bool is_float() const =0
Check if current value is a float.
virtual bool is_int() const =0
Check if current value is a int.
virtual bool is_default() const =0
Check if current value was read from the default config.
virtual bool is_string() const =0
Check if current value is a string.
virtual bool is_bool() const =0
Check if current value is a bool.
virtual int get_int() const =0
Get int value.
virtual bool valid() const =0
Check if the current element is valid.
virtual const char * type() const =0
Type of value.
virtual std::string get_string() const =0
Get string value.
Interface for configuration handling.
Definition: config.h:68
virtual float get_float_or_default(const char *path, const float &default_val)
Get value from configuration which is of type float, or the given default if the path does not exist.
Definition: config.cpp:696
virtual unsigned int get_uint(const char *path)=0
Get value from configuration which is of type unsigned int.
virtual bool is_float(const char *path)=0
Check if a value is of type float.
virtual bool is_uint(const char *path)=0
Check if a value is of type unsigned int.
virtual bool get_bool(const char *path)=0
Get value from configuration which is of type bool.
virtual void set_uint(const char *path, unsigned int uint)=0
Set new value in configuration of type unsigned int.
virtual float get_float(const char *path)=0
Get value from configuration which is of type float.
virtual void set_bool(const char *path, bool b)=0
Set new value in configuration of type bool.
virtual ValueIterator * iterator()=0
Iterator for all values.
virtual void set_default_float(const char *path, float f)=0
Set new default value in configuration of type float.
virtual void set_float(const char *path, float f)=0
Set new value in configuration of type float.
virtual ValueIterator * search(const char *path)=0
Iterator with search results.
virtual bool is_bool(const char *path)=0
Check if a value is of type bool.
virtual void set_default_string(const char *path, std::string &s)=0
Set new default value in configuration of type string.
virtual ValueIterator * get_value(const char *path)=0
Get value from configuration.
virtual void set_string(const char *path, std::string &s)=0
Set new value in configuration of type string.
virtual int get_int_or_default(const char *path, const int &default_val)
Get value from configuration which is of type int, or the given default if the path does not exist.
Definition: config.cpp:716
virtual void erase_default(const char *path)=0
Erase the given default value from the configuration.
virtual bool is_int(const char *path)=0
Check if a value is of type int.
virtual bool exists(const char *path)=0
Check if a given value exists.
virtual bool is_string(const char *path)=0
Check if a value is of type string.
virtual std::string get_string(const char *path)=0
Get value from configuration which is of type string.
virtual void lock()=0
Lock the config.
virtual void unlock()=0
Unlock the config.
virtual void set_default_bool(const char *path, bool b)=0
Set new default value in configuration of type bool.
virtual void set_int(const char *path, int i)=0
Set new value in configuration of type int.
virtual int get_int(const char *path)=0
Get value from configuration which is of type int.
virtual void set_default_uint(const char *path, unsigned int uint)=0
Set new default value in configuration of type unsigned int.
virtual void set_default_int(const char *path, int i)=0
Set new default value in configuration of type int.
virtual bool try_lock()=0
Try to lock the config.
virtual bool is_default(const char *path)=0
Check if a value was read from the default config.
virtual void erase(const char *path)=0
Erase the given value from the configuration.
Base class for exceptions in Fawkes.
Definition: exception.h:36
virtual const char * what_no_backtrace() const noexcept
Get primary string (does not implicitly print the back trace).
Definition: exception.cpp:663