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 Mtolua_delete(self);
71 }
72 return 0;
73#ifndef TOLUA_RELEASE
74 tolua_lerror:
75 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
76 return 0;
77#endif
78}
79#endif //#ifndef TOLUA_DISABLE
80
81/* method: next of class ValueIterator */
82#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_ValueIterator_next00
83static int tolua_fawkesconfig_fawkes_Configuration_ValueIterator_next00(lua_State* tolua_S)
84{
85#ifndef TOLUA_RELEASE
86 tolua_Error tolua_err;
87 if (
88 !tolua_isusertype(tolua_S,1,"fawkes::Configuration::ValueIterator",0,&tolua_err) ||
89 !tolua_isnoobj(tolua_S,2,&tolua_err)
90 )
91 goto tolua_lerror;
92 else
93#endif
94 {
96#ifndef TOLUA_RELEASE
97 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'next'",NULL);
98#endif
99 {
100 bool tolua_ret = (bool) self->next();
101 tolua_pushboolean(tolua_S,(bool)tolua_ret);
102 }
103 }
104 return 1;
105#ifndef TOLUA_RELEASE
106 tolua_lerror:
107 tolua_error(tolua_S,"#ferror in function 'next'.",&tolua_err);
108 return 0;
109#endif
110}
111#endif //#ifndef TOLUA_DISABLE
112
113/* method: valid of class ValueIterator */
114#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_ValueIterator_valid00
115static int tolua_fawkesconfig_fawkes_Configuration_ValueIterator_valid00(lua_State* tolua_S)
116{
117#ifndef TOLUA_RELEASE
118 tolua_Error tolua_err;
119 if (
120 !tolua_isusertype(tolua_S,1,"fawkes::Configuration::ValueIterator",0,&tolua_err) ||
121 !tolua_isnoobj(tolua_S,2,&tolua_err)
122 )
123 goto tolua_lerror;
124 else
125#endif
126 {
127 fawkes::Configuration::ValueIterator* self = (fawkes::Configuration::ValueIterator*) tolua_tousertype(tolua_S,1,0);
128#ifndef TOLUA_RELEASE
129 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'valid'",NULL);
130#endif
131 {
132 bool tolua_ret = (bool) self->valid();
133 tolua_pushboolean(tolua_S,(bool)tolua_ret);
134 }
135 }
136 return 1;
137#ifndef TOLUA_RELEASE
138 tolua_lerror:
139 tolua_error(tolua_S,"#ferror in function 'valid'.",&tolua_err);
140 return 0;
141#endif
142}
143#endif //#ifndef TOLUA_DISABLE
144
145/* method: path of class ValueIterator */
146#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_ValueIterator_path00
147static int tolua_fawkesconfig_fawkes_Configuration_ValueIterator_path00(lua_State* tolua_S)
148{
149#ifndef TOLUA_RELEASE
150 tolua_Error tolua_err;
151 if (
152 !tolua_isusertype(tolua_S,1,"fawkes::Configuration::ValueIterator",0,&tolua_err) ||
153 !tolua_isnoobj(tolua_S,2,&tolua_err)
154 )
155 goto tolua_lerror;
156 else
157#endif
158 {
159 fawkes::Configuration::ValueIterator* self = (fawkes::Configuration::ValueIterator*) tolua_tousertype(tolua_S,1,0);
160#ifndef TOLUA_RELEASE
161 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'path'",NULL);
162#endif
163 {
164 const char* tolua_ret = (const char*) self->path();
165 tolua_pushstring(tolua_S,(const char*)tolua_ret);
166 }
167 }
168 return 1;
169#ifndef TOLUA_RELEASE
170 tolua_lerror:
171 tolua_error(tolua_S,"#ferror in function 'path'.",&tolua_err);
172 return 0;
173#endif
174}
175#endif //#ifndef TOLUA_DISABLE
176
177/* method: type of class ValueIterator */
178#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_ValueIterator_type00
179static int tolua_fawkesconfig_fawkes_Configuration_ValueIterator_type00(lua_State* tolua_S)
180{
181#ifndef TOLUA_RELEASE
182 tolua_Error tolua_err;
183 if (
184 !tolua_isusertype(tolua_S,1,"fawkes::Configuration::ValueIterator",0,&tolua_err) ||
185 !tolua_isnoobj(tolua_S,2,&tolua_err)
186 )
187 goto tolua_lerror;
188 else
189#endif
190 {
191 fawkes::Configuration::ValueIterator* self = (fawkes::Configuration::ValueIterator*) tolua_tousertype(tolua_S,1,0);
192#ifndef TOLUA_RELEASE
193 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'type'",NULL);
194#endif
195 {
196 const char* tolua_ret = (const char*) self->type();
197 tolua_pushstring(tolua_S,(const char*)tolua_ret);
198 }
199 }
200 return 1;
201#ifndef TOLUA_RELEASE
202 tolua_lerror:
203 tolua_error(tolua_S,"#ferror in function 'type'.",&tolua_err);
204 return 0;
205#endif
206}
207#endif //#ifndef TOLUA_DISABLE
208
209/* method: is_float of class ValueIterator */
210#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_ValueIterator_is_float00
211static int tolua_fawkesconfig_fawkes_Configuration_ValueIterator_is_float00(lua_State* tolua_S)
212{
213#ifndef TOLUA_RELEASE
214 tolua_Error tolua_err;
215 if (
216 !tolua_isusertype(tolua_S,1,"fawkes::Configuration::ValueIterator",0,&tolua_err) ||
217 !tolua_isnoobj(tolua_S,2,&tolua_err)
218 )
219 goto tolua_lerror;
220 else
221#endif
222 {
223 fawkes::Configuration::ValueIterator* self = (fawkes::Configuration::ValueIterator*) tolua_tousertype(tolua_S,1,0);
224#ifndef TOLUA_RELEASE
225 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_float'",NULL);
226#endif
227 {
228 bool tolua_ret = (bool) self->is_float();
229 tolua_pushboolean(tolua_S,(bool)tolua_ret);
230 }
231 }
232 return 1;
233#ifndef TOLUA_RELEASE
234 tolua_lerror:
235 tolua_error(tolua_S,"#ferror in function 'is_float'.",&tolua_err);
236 return 0;
237#endif
238}
239#endif //#ifndef TOLUA_DISABLE
240
241/* method: is_uint of class ValueIterator */
242#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_ValueIterator_is_uint00
243static int tolua_fawkesconfig_fawkes_Configuration_ValueIterator_is_uint00(lua_State* tolua_S)
244{
245#ifndef TOLUA_RELEASE
246 tolua_Error tolua_err;
247 if (
248 !tolua_isusertype(tolua_S,1,"fawkes::Configuration::ValueIterator",0,&tolua_err) ||
249 !tolua_isnoobj(tolua_S,2,&tolua_err)
250 )
251 goto tolua_lerror;
252 else
253#endif
254 {
255 fawkes::Configuration::ValueIterator* self = (fawkes::Configuration::ValueIterator*) tolua_tousertype(tolua_S,1,0);
256#ifndef TOLUA_RELEASE
257 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_uint'",NULL);
258#endif
259 {
260 bool tolua_ret = (bool) self->is_uint();
261 tolua_pushboolean(tolua_S,(bool)tolua_ret);
262 }
263 }
264 return 1;
265#ifndef TOLUA_RELEASE
266 tolua_lerror:
267 tolua_error(tolua_S,"#ferror in function 'is_uint'.",&tolua_err);
268 return 0;
269#endif
270}
271#endif //#ifndef TOLUA_DISABLE
272
273/* method: is_int of class ValueIterator */
274#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_ValueIterator_is_int00
275static int tolua_fawkesconfig_fawkes_Configuration_ValueIterator_is_int00(lua_State* tolua_S)
276{
277#ifndef TOLUA_RELEASE
278 tolua_Error tolua_err;
279 if (
280 !tolua_isusertype(tolua_S,1,"fawkes::Configuration::ValueIterator",0,&tolua_err) ||
281 !tolua_isnoobj(tolua_S,2,&tolua_err)
282 )
283 goto tolua_lerror;
284 else
285#endif
286 {
287 fawkes::Configuration::ValueIterator* self = (fawkes::Configuration::ValueIterator*) tolua_tousertype(tolua_S,1,0);
288#ifndef TOLUA_RELEASE
289 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_int'",NULL);
290#endif
291 {
292 bool tolua_ret = (bool) self->is_int();
293 tolua_pushboolean(tolua_S,(bool)tolua_ret);
294 }
295 }
296 return 1;
297#ifndef TOLUA_RELEASE
298 tolua_lerror:
299 tolua_error(tolua_S,"#ferror in function 'is_int'.",&tolua_err);
300 return 0;
301#endif
302}
303#endif //#ifndef TOLUA_DISABLE
304
305/* method: is_bool of class ValueIterator */
306#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_ValueIterator_is_bool00
307static int tolua_fawkesconfig_fawkes_Configuration_ValueIterator_is_bool00(lua_State* tolua_S)
308{
309#ifndef TOLUA_RELEASE
310 tolua_Error tolua_err;
311 if (
312 !tolua_isusertype(tolua_S,1,"fawkes::Configuration::ValueIterator",0,&tolua_err) ||
313 !tolua_isnoobj(tolua_S,2,&tolua_err)
314 )
315 goto tolua_lerror;
316 else
317#endif
318 {
319 fawkes::Configuration::ValueIterator* self = (fawkes::Configuration::ValueIterator*) tolua_tousertype(tolua_S,1,0);
320#ifndef TOLUA_RELEASE
321 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_bool'",NULL);
322#endif
323 {
324 bool tolua_ret = (bool) self->is_bool();
325 tolua_pushboolean(tolua_S,(bool)tolua_ret);
326 }
327 }
328 return 1;
329#ifndef TOLUA_RELEASE
330 tolua_lerror:
331 tolua_error(tolua_S,"#ferror in function 'is_bool'.",&tolua_err);
332 return 0;
333#endif
334}
335#endif //#ifndef TOLUA_DISABLE
336
337/* method: is_string of class ValueIterator */
338#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_ValueIterator_is_string00
339static int tolua_fawkesconfig_fawkes_Configuration_ValueIterator_is_string00(lua_State* tolua_S)
340{
341#ifndef TOLUA_RELEASE
342 tolua_Error tolua_err;
343 if (
344 !tolua_isusertype(tolua_S,1,"fawkes::Configuration::ValueIterator",0,&tolua_err) ||
345 !tolua_isnoobj(tolua_S,2,&tolua_err)
346 )
347 goto tolua_lerror;
348 else
349#endif
350 {
351 fawkes::Configuration::ValueIterator* self = (fawkes::Configuration::ValueIterator*) tolua_tousertype(tolua_S,1,0);
352#ifndef TOLUA_RELEASE
353 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_string'",NULL);
354#endif
355 {
356 bool tolua_ret = (bool) self->is_string();
357 tolua_pushboolean(tolua_S,(bool)tolua_ret);
358 }
359 }
360 return 1;
361#ifndef TOLUA_RELEASE
362 tolua_lerror:
363 tolua_error(tolua_S,"#ferror in function 'is_string'.",&tolua_err);
364 return 0;
365#endif
366}
367#endif //#ifndef TOLUA_DISABLE
368
369/* method: get_float of class ValueIterator */
370#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_ValueIterator_get_float00
371static int tolua_fawkesconfig_fawkes_Configuration_ValueIterator_get_float00(lua_State* tolua_S)
372{
373#ifndef TOLUA_RELEASE
374 tolua_Error tolua_err;
375 if (
376 !tolua_isusertype(tolua_S,1,"fawkes::Configuration::ValueIterator",0,&tolua_err) ||
377 !tolua_isnoobj(tolua_S,2,&tolua_err)
378 )
379 goto tolua_lerror;
380 else
381#endif
382 {
383 fawkes::Configuration::ValueIterator* self = (fawkes::Configuration::ValueIterator*) tolua_tousertype(tolua_S,1,0);
384#ifndef TOLUA_RELEASE
385 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_float'",NULL);
386#endif
387 {
388 float tolua_ret = (float) self->get_float();
389 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
390 }
391 }
392 return 1;
393#ifndef TOLUA_RELEASE
394 tolua_lerror:
395 tolua_error(tolua_S,"#ferror in function 'get_float'.",&tolua_err);
396 return 0;
397#endif
398}
399#endif //#ifndef TOLUA_DISABLE
400
401/* method: get_uint of class ValueIterator */
402#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_ValueIterator_get_uint00
403static int tolua_fawkesconfig_fawkes_Configuration_ValueIterator_get_uint00(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 'get_uint'",NULL);
418#endif
419 {
420 unsigned int tolua_ret = (unsigned int) self->get_uint();
421 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
422 }
423 }
424 return 1;
425#ifndef TOLUA_RELEASE
426 tolua_lerror:
427 tolua_error(tolua_S,"#ferror in function 'get_uint'.",&tolua_err);
428 return 0;
429#endif
430}
431#endif //#ifndef TOLUA_DISABLE
432
433/* method: get_int of class ValueIterator */
434#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_ValueIterator_get_int00
435static int tolua_fawkesconfig_fawkes_Configuration_ValueIterator_get_int00(lua_State* tolua_S)
436{
437#ifndef TOLUA_RELEASE
438 tolua_Error tolua_err;
439 if (
440 !tolua_isusertype(tolua_S,1,"fawkes::Configuration::ValueIterator",0,&tolua_err) ||
441 !tolua_isnoobj(tolua_S,2,&tolua_err)
442 )
443 goto tolua_lerror;
444 else
445#endif
446 {
447 fawkes::Configuration::ValueIterator* self = (fawkes::Configuration::ValueIterator*) tolua_tousertype(tolua_S,1,0);
448#ifndef TOLUA_RELEASE
449 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_int'",NULL);
450#endif
451 {
452 int tolua_ret = (int) self->get_int();
453 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
454 }
455 }
456 return 1;
457#ifndef TOLUA_RELEASE
458 tolua_lerror:
459 tolua_error(tolua_S,"#ferror in function 'get_int'.",&tolua_err);
460 return 0;
461#endif
462}
463#endif //#ifndef TOLUA_DISABLE
464
465/* method: get_bool of class ValueIterator */
466#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_ValueIterator_get_bool00
467static int tolua_fawkesconfig_fawkes_Configuration_ValueIterator_get_bool00(lua_State* tolua_S)
468{
469#ifndef TOLUA_RELEASE
470 tolua_Error tolua_err;
471 if (
472 !tolua_isusertype(tolua_S,1,"fawkes::Configuration::ValueIterator",0,&tolua_err) ||
473 !tolua_isnoobj(tolua_S,2,&tolua_err)
474 )
475 goto tolua_lerror;
476 else
477#endif
478 {
479 fawkes::Configuration::ValueIterator* self = (fawkes::Configuration::ValueIterator*) tolua_tousertype(tolua_S,1,0);
480#ifndef TOLUA_RELEASE
481 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_bool'",NULL);
482#endif
483 {
484 bool tolua_ret = (bool) self->get_bool();
485 tolua_pushboolean(tolua_S,(bool)tolua_ret);
486 }
487 }
488 return 1;
489#ifndef TOLUA_RELEASE
490 tolua_lerror:
491 tolua_error(tolua_S,"#ferror in function 'get_bool'.",&tolua_err);
492 return 0;
493#endif
494}
495#endif //#ifndef TOLUA_DISABLE
496
497/* method: get_string of class ValueIterator */
498#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_ValueIterator_get_string00
499static int tolua_fawkesconfig_fawkes_Configuration_ValueIterator_get_string00(lua_State* tolua_S)
500{
501#ifndef TOLUA_RELEASE
502 tolua_Error tolua_err;
503 if (
504 !tolua_isusertype(tolua_S,1,"fawkes::Configuration::ValueIterator",0,&tolua_err) ||
505 !tolua_isnoobj(tolua_S,2,&tolua_err)
506 )
507 goto tolua_lerror;
508 else
509#endif
510 {
511 fawkes::Configuration::ValueIterator* self = (fawkes::Configuration::ValueIterator*) tolua_tousertype(tolua_S,1,0);
512#ifndef TOLUA_RELEASE
513 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_string'",NULL);
514#endif
515 {
516 std::string tolua_ret = (std::string) self->get_string();
517 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
518 }
519 }
520 return 1;
521#ifndef TOLUA_RELEASE
522 tolua_lerror:
523 tolua_error(tolua_S,"#ferror in function 'get_string'.",&tolua_err);
524 return 0;
525#endif
526}
527#endif //#ifndef TOLUA_DISABLE
528
529/* method: is_default of class ValueIterator */
530#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_ValueIterator_is_default00
531static int tolua_fawkesconfig_fawkes_Configuration_ValueIterator_is_default00(lua_State* tolua_S)
532{
533#ifndef TOLUA_RELEASE
534 tolua_Error tolua_err;
535 if (
536 !tolua_isusertype(tolua_S,1,"fawkes::Configuration::ValueIterator",0,&tolua_err) ||
537 !tolua_isnoobj(tolua_S,2,&tolua_err)
538 )
539 goto tolua_lerror;
540 else
541#endif
542 {
543 fawkes::Configuration::ValueIterator* self = (fawkes::Configuration::ValueIterator*) tolua_tousertype(tolua_S,1,0);
544#ifndef TOLUA_RELEASE
545 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_default'",NULL);
546#endif
547 {
548 bool tolua_ret = (bool) self->is_default();
549 tolua_pushboolean(tolua_S,(bool)tolua_ret);
550 }
551 }
552 return 1;
553#ifndef TOLUA_RELEASE
554 tolua_lerror:
555 tolua_error(tolua_S,"#ferror in function 'is_default'.",&tolua_err);
556 return 0;
557#endif
558}
559#endif //#ifndef TOLUA_DISABLE
560
561/* method: exists of class fawkes::Configuration */
562#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_exists00
563static int tolua_fawkesconfig_fawkes_Configuration_exists00(lua_State* tolua_S)
564{
565#ifndef TOLUA_RELEASE
566 tolua_Error tolua_err;
567 if (
568 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
569 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
570 !tolua_isnoobj(tolua_S,3,&tolua_err)
571 )
572 goto tolua_lerror;
573 else
574#endif
575 {
576 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
577 const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
578#ifndef TOLUA_RELEASE
579 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'exists'",NULL);
580#endif
581 {
582 bool tolua_ret = (bool) self->exists(path);
583 tolua_pushboolean(tolua_S,(bool)tolua_ret);
584 }
585 }
586 return 1;
587#ifndef TOLUA_RELEASE
588 tolua_lerror:
589 tolua_error(tolua_S,"#ferror in function 'exists'.",&tolua_err);
590 return 0;
591#endif
592}
593#endif //#ifndef TOLUA_DISABLE
594
595/* method: is_float of class fawkes::Configuration */
596#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_is_float00
597static int tolua_fawkesconfig_fawkes_Configuration_is_float00(lua_State* tolua_S)
598{
599#ifndef TOLUA_RELEASE
600 tolua_Error tolua_err;
601 if (
602 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
603 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
604 !tolua_isnoobj(tolua_S,3,&tolua_err)
605 )
606 goto tolua_lerror;
607 else
608#endif
609 {
610 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
611 const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
612#ifndef TOLUA_RELEASE
613 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_float'",NULL);
614#endif
615 {
616 bool tolua_ret = (bool) self->is_float(path);
617 tolua_pushboolean(tolua_S,(bool)tolua_ret);
618 }
619 }
620 return 1;
621#ifndef TOLUA_RELEASE
622 tolua_lerror:
623 tolua_error(tolua_S,"#ferror in function 'is_float'.",&tolua_err);
624 return 0;
625#endif
626}
627#endif //#ifndef TOLUA_DISABLE
628
629/* method: is_uint of class fawkes::Configuration */
630#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_is_uint00
631static int tolua_fawkesconfig_fawkes_Configuration_is_uint00(lua_State* tolua_S)
632{
633#ifndef TOLUA_RELEASE
634 tolua_Error tolua_err;
635 if (
636 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
637 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
638 !tolua_isnoobj(tolua_S,3,&tolua_err)
639 )
640 goto tolua_lerror;
641 else
642#endif
643 {
644 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
645 const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
646#ifndef TOLUA_RELEASE
647 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_uint'",NULL);
648#endif
649 {
650 bool tolua_ret = (bool) self->is_uint(path);
651 tolua_pushboolean(tolua_S,(bool)tolua_ret);
652 }
653 }
654 return 1;
655#ifndef TOLUA_RELEASE
656 tolua_lerror:
657 tolua_error(tolua_S,"#ferror in function 'is_uint'.",&tolua_err);
658 return 0;
659#endif
660}
661#endif //#ifndef TOLUA_DISABLE
662
663/* method: is_int of class fawkes::Configuration */
664#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_is_int00
665static int tolua_fawkesconfig_fawkes_Configuration_is_int00(lua_State* tolua_S)
666{
667#ifndef TOLUA_RELEASE
668 tolua_Error tolua_err;
669 if (
670 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
671 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
672 !tolua_isnoobj(tolua_S,3,&tolua_err)
673 )
674 goto tolua_lerror;
675 else
676#endif
677 {
678 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
679 const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
680#ifndef TOLUA_RELEASE
681 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_int'",NULL);
682#endif
683 {
684 bool tolua_ret = (bool) self->is_int(path);
685 tolua_pushboolean(tolua_S,(bool)tolua_ret);
686 }
687 }
688 return 1;
689#ifndef TOLUA_RELEASE
690 tolua_lerror:
691 tolua_error(tolua_S,"#ferror in function 'is_int'.",&tolua_err);
692 return 0;
693#endif
694}
695#endif //#ifndef TOLUA_DISABLE
696
697/* method: is_bool of class fawkes::Configuration */
698#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_is_bool00
699static int tolua_fawkesconfig_fawkes_Configuration_is_bool00(lua_State* tolua_S)
700{
701#ifndef TOLUA_RELEASE
702 tolua_Error tolua_err;
703 if (
704 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
705 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
706 !tolua_isnoobj(tolua_S,3,&tolua_err)
707 )
708 goto tolua_lerror;
709 else
710#endif
711 {
712 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
713 const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
714#ifndef TOLUA_RELEASE
715 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_bool'",NULL);
716#endif
717 {
718 bool tolua_ret = (bool) self->is_bool(path);
719 tolua_pushboolean(tolua_S,(bool)tolua_ret);
720 }
721 }
722 return 1;
723#ifndef TOLUA_RELEASE
724 tolua_lerror:
725 tolua_error(tolua_S,"#ferror in function 'is_bool'.",&tolua_err);
726 return 0;
727#endif
728}
729#endif //#ifndef TOLUA_DISABLE
730
731/* method: is_string of class fawkes::Configuration */
732#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_is_string00
733static int tolua_fawkesconfig_fawkes_Configuration_is_string00(lua_State* tolua_S)
734{
735#ifndef TOLUA_RELEASE
736 tolua_Error tolua_err;
737 if (
738 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
739 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
740 !tolua_isnoobj(tolua_S,3,&tolua_err)
741 )
742 goto tolua_lerror;
743 else
744#endif
745 {
746 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
747 const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
748#ifndef TOLUA_RELEASE
749 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_string'",NULL);
750#endif
751 {
752 bool tolua_ret = (bool) self->is_string(path);
753 tolua_pushboolean(tolua_S,(bool)tolua_ret);
754 }
755 }
756 return 1;
757#ifndef TOLUA_RELEASE
758 tolua_lerror:
759 tolua_error(tolua_S,"#ferror in function 'is_string'.",&tolua_err);
760 return 0;
761#endif
762}
763#endif //#ifndef TOLUA_DISABLE
764
765/* method: is_default of class fawkes::Configuration */
766#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_is_default00
767static int tolua_fawkesconfig_fawkes_Configuration_is_default00(lua_State* tolua_S)
768{
769#ifndef TOLUA_RELEASE
770 tolua_Error tolua_err;
771 if (
772 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
773 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
774 !tolua_isnoobj(tolua_S,3,&tolua_err)
775 )
776 goto tolua_lerror;
777 else
778#endif
779 {
780 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
781 const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
782#ifndef TOLUA_RELEASE
783 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_default'",NULL);
784#endif
785 {
786 bool tolua_ret = (bool) self->is_default(path);
787 tolua_pushboolean(tolua_S,(bool)tolua_ret);
788 }
789 }
790 return 1;
791#ifndef TOLUA_RELEASE
792 tolua_lerror:
793 tolua_error(tolua_S,"#ferror in function 'is_default'.",&tolua_err);
794 return 0;
795#endif
796}
797#endif //#ifndef TOLUA_DISABLE
798
799/* method: get_float of class fawkes::Configuration */
800#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_get_float00
801static int tolua_fawkesconfig_fawkes_Configuration_get_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 'get_float'",NULL);
818#endif
819 {
820 float tolua_ret = (float) self->get_float(path);
821 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
822 }
823 }
824 return 1;
825#ifndef TOLUA_RELEASE
826 tolua_lerror:
827 tolua_error(tolua_S,"#ferror in function 'get_float'.",&tolua_err);
828 return 0;
829#endif
830}
831#endif //#ifndef TOLUA_DISABLE
832
833/* method: get_uint of class fawkes::Configuration */
834#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_get_uint00
835static int tolua_fawkesconfig_fawkes_Configuration_get_uint00(lua_State* tolua_S)
836{
837#ifndef TOLUA_RELEASE
838 tolua_Error tolua_err;
839 if (
840 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
841 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
842 !tolua_isnoobj(tolua_S,3,&tolua_err)
843 )
844 goto tolua_lerror;
845 else
846#endif
847 {
848 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
849 const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
850#ifndef TOLUA_RELEASE
851 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_uint'",NULL);
852#endif
853 {
854 unsigned int tolua_ret = (unsigned int) self->get_uint(path);
855 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
856 }
857 }
858 return 1;
859#ifndef TOLUA_RELEASE
860 tolua_lerror:
861 tolua_error(tolua_S,"#ferror in function 'get_uint'.",&tolua_err);
862 return 0;
863#endif
864}
865#endif //#ifndef TOLUA_DISABLE
866
867/* method: get_int of class fawkes::Configuration */
868#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_get_int00
869static int tolua_fawkesconfig_fawkes_Configuration_get_int00(lua_State* tolua_S)
870{
871#ifndef TOLUA_RELEASE
872 tolua_Error tolua_err;
873 if (
874 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
875 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
876 !tolua_isnoobj(tolua_S,3,&tolua_err)
877 )
878 goto tolua_lerror;
879 else
880#endif
881 {
882 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
883 const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
884#ifndef TOLUA_RELEASE
885 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_int'",NULL);
886#endif
887 {
888 int tolua_ret = (int) self->get_int(path);
889 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
890 }
891 }
892 return 1;
893#ifndef TOLUA_RELEASE
894 tolua_lerror:
895 tolua_error(tolua_S,"#ferror in function 'get_int'.",&tolua_err);
896 return 0;
897#endif
898}
899#endif //#ifndef TOLUA_DISABLE
900
901/* method: get_bool of class fawkes::Configuration */
902#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_get_bool00
903static int tolua_fawkesconfig_fawkes_Configuration_get_bool00(lua_State* tolua_S)
904{
905#ifndef TOLUA_RELEASE
906 tolua_Error tolua_err;
907 if (
908 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
909 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
910 !tolua_isnoobj(tolua_S,3,&tolua_err)
911 )
912 goto tolua_lerror;
913 else
914#endif
915 {
916 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
917 const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
918#ifndef TOLUA_RELEASE
919 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_bool'",NULL);
920#endif
921 {
922 bool tolua_ret = (bool) self->get_bool(path);
923 tolua_pushboolean(tolua_S,(bool)tolua_ret);
924 }
925 }
926 return 1;
927#ifndef TOLUA_RELEASE
928 tolua_lerror:
929 tolua_error(tolua_S,"#ferror in function 'get_bool'.",&tolua_err);
930 return 0;
931#endif
932}
933#endif //#ifndef TOLUA_DISABLE
934
935/* method: get_string of class fawkes::Configuration */
936#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_get_string00
937static int tolua_fawkesconfig_fawkes_Configuration_get_string00(lua_State* tolua_S)
938{
939#ifndef TOLUA_RELEASE
940 tolua_Error tolua_err;
941 if (
942 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
943 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
944 !tolua_isnoobj(tolua_S,3,&tolua_err)
945 )
946 goto tolua_lerror;
947 else
948#endif
949 {
950 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
951 const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
952#ifndef TOLUA_RELEASE
953 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_string'",NULL);
954#endif
955 {
956 std::string tolua_ret = (std::string) self->get_string(path);
957 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
958 }
959 }
960 return 1;
961#ifndef TOLUA_RELEASE
962 tolua_lerror:
963 tolua_error(tolua_S,"#ferror in function 'get_string'.",&tolua_err);
964 return 0;
965#endif
966}
967#endif //#ifndef TOLUA_DISABLE
968
969/* method: get_value of class fawkes::Configuration */
970#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_get_value00
971static int tolua_fawkesconfig_fawkes_Configuration_get_value00(lua_State* tolua_S)
972{
973#ifndef TOLUA_RELEASE
974 tolua_Error tolua_err;
975 if (
976 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
977 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
978 !tolua_isnoobj(tolua_S,3,&tolua_err)
979 )
980 goto tolua_lerror;
981 else
982#endif
983 {
984 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
985 const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
986#ifndef TOLUA_RELEASE
987 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_value'",NULL);
988#endif
989 {
991 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Configuration::ValueIterator");
992 }
993 }
994 return 1;
995#ifndef TOLUA_RELEASE
996 tolua_lerror:
997 tolua_error(tolua_S,"#ferror in function 'get_value'.",&tolua_err);
998 return 0;
999#endif
1000}
1001#endif //#ifndef TOLUA_DISABLE
1002
1003/* method: get_float_or_default of class fawkes::Configuration */
1004#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_get_float_or_default00
1005static int tolua_fawkesconfig_fawkes_Configuration_get_float_or_default00(lua_State* tolua_S)
1006{
1007#ifndef TOLUA_RELEASE
1008 tolua_Error tolua_err;
1009 if (
1010 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1011 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1012 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
1013 !tolua_isnoobj(tolua_S,4,&tolua_err)
1014 )
1015 goto tolua_lerror;
1016 else
1017#endif
1018 {
1019 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1020 char* path = ((char*) tolua_tostring(tolua_S,2,0));
1021 float f = ((float) tolua_tonumber(tolua_S,3,0));
1022#ifndef TOLUA_RELEASE
1023 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_float_or_default'",NULL);
1024#endif
1025 {
1026 float tolua_ret = (float) self->get_float_or_default(path,f);
1027 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1028 }
1029 }
1030 return 1;
1031#ifndef TOLUA_RELEASE
1032 tolua_lerror:
1033 tolua_error(tolua_S,"#ferror in function 'get_float_or_default'.",&tolua_err);
1034 return 0;
1035#endif
1036}
1037#endif //#ifndef TOLUA_DISABLE
1038
1039/* method: get_int_or_default of class fawkes::Configuration */
1040#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_get_int_or_default00
1041static int tolua_fawkesconfig_fawkes_Configuration_get_int_or_default00(lua_State* tolua_S)
1042{
1043#ifndef TOLUA_RELEASE
1044 tolua_Error tolua_err;
1045 if (
1046 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1047 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1048 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
1049 !tolua_isnoobj(tolua_S,4,&tolua_err)
1050 )
1051 goto tolua_lerror;
1052 else
1053#endif
1054 {
1055 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1056 char* path = ((char*) tolua_tostring(tolua_S,2,0));
1057 int i = ((int) tolua_tonumber(tolua_S,3,0));
1058#ifndef TOLUA_RELEASE
1059 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_int_or_default'",NULL);
1060#endif
1061 {
1062 int tolua_ret = (int) self->get_int_or_default(path,i);
1063 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1064 }
1065 }
1066 return 1;
1067#ifndef TOLUA_RELEASE
1068 tolua_lerror:
1069 tolua_error(tolua_S,"#ferror in function 'get_int_or_default'.",&tolua_err);
1070 return 0;
1071#endif
1072}
1073#endif //#ifndef TOLUA_DISABLE
1074
1075/* method: set_float of class fawkes::Configuration */
1076#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_set_float00
1077static int tolua_fawkesconfig_fawkes_Configuration_set_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_isnumber(tolua_S,3,0,&tolua_err) ||
1085 !tolua_isnoobj(tolua_S,4,&tolua_err)
1086 )
1087 goto tolua_lerror;
1088 else
1089#endif
1090 {
1091 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1092 const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
1093 float f = ((float) tolua_tonumber(tolua_S,3,0));
1094#ifndef TOLUA_RELEASE
1095 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_float'",NULL);
1096#endif
1097 {
1098 self->set_float(path,f);
1099 }
1100 }
1101 return 0;
1102#ifndef TOLUA_RELEASE
1103 tolua_lerror:
1104 tolua_error(tolua_S,"#ferror in function 'set_float'.",&tolua_err);
1105 return 0;
1106#endif
1107}
1108#endif //#ifndef TOLUA_DISABLE
1109
1110/* method: set_uint of class fawkes::Configuration */
1111#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_set_uint00
1112static int tolua_fawkesconfig_fawkes_Configuration_set_uint00(lua_State* tolua_S)
1113{
1114#ifndef TOLUA_RELEASE
1115 tolua_Error tolua_err;
1116 if (
1117 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1118 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1119 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
1120 !tolua_isnoobj(tolua_S,4,&tolua_err)
1121 )
1122 goto tolua_lerror;
1123 else
1124#endif
1125 {
1126 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1127 const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
1128 unsigned int uint = ((unsigned int) tolua_tonumber(tolua_S,3,0));
1129#ifndef TOLUA_RELEASE
1130 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_uint'",NULL);
1131#endif
1132 {
1133 self->set_uint(path,uint);
1134 }
1135 }
1136 return 0;
1137#ifndef TOLUA_RELEASE
1138 tolua_lerror:
1139 tolua_error(tolua_S,"#ferror in function 'set_uint'.",&tolua_err);
1140 return 0;
1141#endif
1142}
1143#endif //#ifndef TOLUA_DISABLE
1144
1145/* method: set_int of class fawkes::Configuration */
1146#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_set_int00
1147static int tolua_fawkesconfig_fawkes_Configuration_set_int00(lua_State* tolua_S)
1148{
1149#ifndef TOLUA_RELEASE
1150 tolua_Error tolua_err;
1151 if (
1152 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1153 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1154 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
1155 !tolua_isnoobj(tolua_S,4,&tolua_err)
1156 )
1157 goto tolua_lerror;
1158 else
1159#endif
1160 {
1161 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1162 const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
1163 int i = ((int) tolua_tonumber(tolua_S,3,0));
1164#ifndef TOLUA_RELEASE
1165 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_int'",NULL);
1166#endif
1167 {
1168 self->set_int(path,i);
1169 }
1170 }
1171 return 0;
1172#ifndef TOLUA_RELEASE
1173 tolua_lerror:
1174 tolua_error(tolua_S,"#ferror in function 'set_int'.",&tolua_err);
1175 return 0;
1176#endif
1177}
1178#endif //#ifndef TOLUA_DISABLE
1179
1180/* method: set_bool of class fawkes::Configuration */
1181#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_set_bool00
1182static int tolua_fawkesconfig_fawkes_Configuration_set_bool00(lua_State* tolua_S)
1183{
1184#ifndef TOLUA_RELEASE
1185 tolua_Error tolua_err;
1186 if (
1187 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1188 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1189 !tolua_isboolean(tolua_S,3,0,&tolua_err) ||
1190 !tolua_isnoobj(tolua_S,4,&tolua_err)
1191 )
1192 goto tolua_lerror;
1193 else
1194#endif
1195 {
1196 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1197 const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
1198 bool b = ((bool) tolua_toboolean(tolua_S,3,0));
1199#ifndef TOLUA_RELEASE
1200 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_bool'",NULL);
1201#endif
1202 {
1203 self->set_bool(path,b);
1204 }
1205 }
1206 return 0;
1207#ifndef TOLUA_RELEASE
1208 tolua_lerror:
1209 tolua_error(tolua_S,"#ferror in function 'set_bool'.",&tolua_err);
1210 return 0;
1211#endif
1212}
1213#endif //#ifndef TOLUA_DISABLE
1214
1215/* method: set_string of class fawkes::Configuration */
1216#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_set_string00
1217static int tolua_fawkesconfig_fawkes_Configuration_set_string00(lua_State* tolua_S)
1218{
1219#ifndef TOLUA_RELEASE
1220 tolua_Error tolua_err;
1221 if (
1222 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1223 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1224 !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
1225 !tolua_isnoobj(tolua_S,4,&tolua_err)
1226 )
1227 goto tolua_lerror;
1228 else
1229#endif
1230 {
1231 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1232 const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
1233 std::string s = ((std::string) tolua_tocppstring(tolua_S,3,0));
1234#ifndef TOLUA_RELEASE
1235 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_string'",NULL);
1236#endif
1237 {
1238 self->set_string(path,s);
1239 }
1240 }
1241 return 0;
1242#ifndef TOLUA_RELEASE
1243 tolua_lerror:
1244 tolua_error(tolua_S,"#ferror in function 'set_string'.",&tolua_err);
1245 return 0;
1246#endif
1247}
1248#endif //#ifndef TOLUA_DISABLE
1249
1250/* method: set_string of class fawkes::Configuration */
1251#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_set_string01
1252static int tolua_fawkesconfig_fawkes_Configuration_set_string01(lua_State* tolua_S)
1253{
1254 tolua_Error tolua_err;
1255 if (
1256 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1257 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1258 !tolua_isstring(tolua_S,3,0,&tolua_err) ||
1259 !tolua_isnoobj(tolua_S,4,&tolua_err)
1260 )
1261 goto tolua_lerror;
1262 else
1263 {
1264 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1265 const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
1266 const char* s = ((const char*) tolua_tostring(tolua_S,3,0));
1267#ifndef TOLUA_RELEASE
1268 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_string'",NULL);
1269#endif
1270 {
1271 self->set_string(path,s);
1272 }
1273 }
1274 return 0;
1275tolua_lerror:
1276 return tolua_fawkesconfig_fawkes_Configuration_set_string00(tolua_S);
1277}
1278#endif //#ifndef TOLUA_DISABLE
1279
1280/* method: erase of class fawkes::Configuration */
1281#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_erase00
1282static int tolua_fawkesconfig_fawkes_Configuration_erase00(lua_State* tolua_S)
1283{
1284#ifndef TOLUA_RELEASE
1285 tolua_Error tolua_err;
1286 if (
1287 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1288 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1289 !tolua_isnoobj(tolua_S,3,&tolua_err)
1290 )
1291 goto tolua_lerror;
1292 else
1293#endif
1294 {
1295 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1296 const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
1297#ifndef TOLUA_RELEASE
1298 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'erase'",NULL);
1299#endif
1300 {
1301 self->erase(path);
1302 }
1303 }
1304 return 0;
1305#ifndef TOLUA_RELEASE
1306 tolua_lerror:
1307 tolua_error(tolua_S,"#ferror in function 'erase'.",&tolua_err);
1308 return 0;
1309#endif
1310}
1311#endif //#ifndef TOLUA_DISABLE
1312
1313/* method: set_default_float of class fawkes::Configuration */
1314#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_set_default_float00
1315static int tolua_fawkesconfig_fawkes_Configuration_set_default_float00(lua_State* tolua_S)
1316{
1317#ifndef TOLUA_RELEASE
1318 tolua_Error tolua_err;
1319 if (
1320 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1321 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1322 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
1323 !tolua_isnoobj(tolua_S,4,&tolua_err)
1324 )
1325 goto tolua_lerror;
1326 else
1327#endif
1328 {
1329 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1330 const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
1331 float f = ((float) tolua_tonumber(tolua_S,3,0));
1332#ifndef TOLUA_RELEASE
1333 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_default_float'",NULL);
1334#endif
1335 {
1336 self->set_default_float(path,f);
1337 }
1338 }
1339 return 0;
1340#ifndef TOLUA_RELEASE
1341 tolua_lerror:
1342 tolua_error(tolua_S,"#ferror in function 'set_default_float'.",&tolua_err);
1343 return 0;
1344#endif
1345}
1346#endif //#ifndef TOLUA_DISABLE
1347
1348/* method: set_default_uint of class fawkes::Configuration */
1349#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_set_default_uint00
1350static int tolua_fawkesconfig_fawkes_Configuration_set_default_uint00(lua_State* tolua_S)
1351{
1352#ifndef TOLUA_RELEASE
1353 tolua_Error tolua_err;
1354 if (
1355 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1356 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1357 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
1358 !tolua_isnoobj(tolua_S,4,&tolua_err)
1359 )
1360 goto tolua_lerror;
1361 else
1362#endif
1363 {
1364 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1365 const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
1366 unsigned int uint = ((unsigned int) tolua_tonumber(tolua_S,3,0));
1367#ifndef TOLUA_RELEASE
1368 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_default_uint'",NULL);
1369#endif
1370 {
1371 self->set_default_uint(path,uint);
1372 }
1373 }
1374 return 0;
1375#ifndef TOLUA_RELEASE
1376 tolua_lerror:
1377 tolua_error(tolua_S,"#ferror in function 'set_default_uint'.",&tolua_err);
1378 return 0;
1379#endif
1380}
1381#endif //#ifndef TOLUA_DISABLE
1382
1383/* method: set_default_int of class fawkes::Configuration */
1384#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_set_default_int00
1385static int tolua_fawkesconfig_fawkes_Configuration_set_default_int00(lua_State* tolua_S)
1386{
1387#ifndef TOLUA_RELEASE
1388 tolua_Error tolua_err;
1389 if (
1390 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1391 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1392 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
1393 !tolua_isnoobj(tolua_S,4,&tolua_err)
1394 )
1395 goto tolua_lerror;
1396 else
1397#endif
1398 {
1399 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1400 const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
1401 int i = ((int) tolua_tonumber(tolua_S,3,0));
1402#ifndef TOLUA_RELEASE
1403 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_default_int'",NULL);
1404#endif
1405 {
1406 self->set_default_int(path,i);
1407 }
1408 }
1409 return 0;
1410#ifndef TOLUA_RELEASE
1411 tolua_lerror:
1412 tolua_error(tolua_S,"#ferror in function 'set_default_int'.",&tolua_err);
1413 return 0;
1414#endif
1415}
1416#endif //#ifndef TOLUA_DISABLE
1417
1418/* method: set_default_bool of class fawkes::Configuration */
1419#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_set_default_bool00
1420static int tolua_fawkesconfig_fawkes_Configuration_set_default_bool00(lua_State* tolua_S)
1421{
1422#ifndef TOLUA_RELEASE
1423 tolua_Error tolua_err;
1424 if (
1425 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1426 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1427 !tolua_isboolean(tolua_S,3,0,&tolua_err) ||
1428 !tolua_isnoobj(tolua_S,4,&tolua_err)
1429 )
1430 goto tolua_lerror;
1431 else
1432#endif
1433 {
1434 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1435 const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
1436 bool b = ((bool) tolua_toboolean(tolua_S,3,0));
1437#ifndef TOLUA_RELEASE
1438 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_default_bool'",NULL);
1439#endif
1440 {
1441 self->set_default_bool(path,b);
1442 }
1443 }
1444 return 0;
1445#ifndef TOLUA_RELEASE
1446 tolua_lerror:
1447 tolua_error(tolua_S,"#ferror in function 'set_default_bool'.",&tolua_err);
1448 return 0;
1449#endif
1450}
1451#endif //#ifndef TOLUA_DISABLE
1452
1453/* method: set_default_string of class fawkes::Configuration */
1454#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_set_default_string00
1455static int tolua_fawkesconfig_fawkes_Configuration_set_default_string00(lua_State* tolua_S)
1456{
1457#ifndef TOLUA_RELEASE
1458 tolua_Error tolua_err;
1459 if (
1460 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1461 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1462 !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
1463 !tolua_isnoobj(tolua_S,4,&tolua_err)
1464 )
1465 goto tolua_lerror;
1466 else
1467#endif
1468 {
1469 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1470 const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
1471 std::string s = ((std::string) tolua_tocppstring(tolua_S,3,0));
1472#ifndef TOLUA_RELEASE
1473 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_default_string'",NULL);
1474#endif
1475 {
1476 self->set_default_string(path,s);
1477 }
1478 }
1479 return 0;
1480#ifndef TOLUA_RELEASE
1481 tolua_lerror:
1482 tolua_error(tolua_S,"#ferror in function 'set_default_string'.",&tolua_err);
1483 return 0;
1484#endif
1485}
1486#endif //#ifndef TOLUA_DISABLE
1487
1488/* method: set_default_string of class fawkes::Configuration */
1489#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_set_default_string01
1490static int tolua_fawkesconfig_fawkes_Configuration_set_default_string01(lua_State* tolua_S)
1491{
1492 tolua_Error tolua_err;
1493 if (
1494 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1495 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1496 !tolua_isstring(tolua_S,3,0,&tolua_err) ||
1497 !tolua_isnoobj(tolua_S,4,&tolua_err)
1498 )
1499 goto tolua_lerror;
1500 else
1501 {
1502 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1503 const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
1504 const char* s = ((const char*) tolua_tostring(tolua_S,3,0));
1505#ifndef TOLUA_RELEASE
1506 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_default_string'",NULL);
1507#endif
1508 {
1509 self->set_default_string(path,s);
1510 }
1511 }
1512 return 0;
1513tolua_lerror:
1514 return tolua_fawkesconfig_fawkes_Configuration_set_default_string00(tolua_S);
1515}
1516#endif //#ifndef TOLUA_DISABLE
1517
1518/* method: erase_default of class fawkes::Configuration */
1519#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_erase_default00
1520static int tolua_fawkesconfig_fawkes_Configuration_erase_default00(lua_State* tolua_S)
1521{
1522#ifndef TOLUA_RELEASE
1523 tolua_Error tolua_err;
1524 if (
1525 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1526 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1527 !tolua_isnoobj(tolua_S,3,&tolua_err)
1528 )
1529 goto tolua_lerror;
1530 else
1531#endif
1532 {
1533 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1534 const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
1535#ifndef TOLUA_RELEASE
1536 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'erase_default'",NULL);
1537#endif
1538 {
1539 self->erase_default(path);
1540 }
1541 }
1542 return 0;
1543#ifndef TOLUA_RELEASE
1544 tolua_lerror:
1545 tolua_error(tolua_S,"#ferror in function 'erase_default'.",&tolua_err);
1546 return 0;
1547#endif
1548}
1549#endif //#ifndef TOLUA_DISABLE
1550
1551/* method: iterator of class fawkes::Configuration */
1552#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_iterator00
1553static int tolua_fawkesconfig_fawkes_Configuration_iterator00(lua_State* tolua_S)
1554{
1555#ifndef TOLUA_RELEASE
1556 tolua_Error tolua_err;
1557 if (
1558 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1559 !tolua_isnoobj(tolua_S,2,&tolua_err)
1560 )
1561 goto tolua_lerror;
1562 else
1563#endif
1564 {
1565 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1566#ifndef TOLUA_RELEASE
1567 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'iterator'",NULL);
1568#endif
1569 {
1571 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Configuration::ValueIterator");
1572 }
1573 }
1574 return 1;
1575#ifndef TOLUA_RELEASE
1576 tolua_lerror:
1577 tolua_error(tolua_S,"#ferror in function 'iterator'.",&tolua_err);
1578 return 0;
1579#endif
1580}
1581#endif //#ifndef TOLUA_DISABLE
1582
1583/* method: search of class fawkes::Configuration */
1584#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_search00
1585static int tolua_fawkesconfig_fawkes_Configuration_search00(lua_State* tolua_S)
1586{
1587#ifndef TOLUA_RELEASE
1588 tolua_Error tolua_err;
1589 if (
1590 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1591 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1592 !tolua_isnoobj(tolua_S,3,&tolua_err)
1593 )
1594 goto tolua_lerror;
1595 else
1596#endif
1597 {
1598 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1599 const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
1600#ifndef TOLUA_RELEASE
1601 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'search'",NULL);
1602#endif
1603 {
1605 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Configuration::ValueIterator");
1606 }
1607 }
1608 return 1;
1609#ifndef TOLUA_RELEASE
1610 tolua_lerror:
1611 tolua_error(tolua_S,"#ferror in function 'search'.",&tolua_err);
1612 return 0;
1613#endif
1614}
1615#endif //#ifndef TOLUA_DISABLE
1616
1617/* method: lock of class fawkes::Configuration */
1618#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_lock00
1619static int tolua_fawkesconfig_fawkes_Configuration_lock00(lua_State* tolua_S)
1620{
1621#ifndef TOLUA_RELEASE
1622 tolua_Error tolua_err;
1623 if (
1624 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1625 !tolua_isnoobj(tolua_S,2,&tolua_err)
1626 )
1627 goto tolua_lerror;
1628 else
1629#endif
1630 {
1631 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1632#ifndef TOLUA_RELEASE
1633 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'lock'",NULL);
1634#endif
1635 {
1636 self->lock();
1637 }
1638 }
1639 return 0;
1640#ifndef TOLUA_RELEASE
1641 tolua_lerror:
1642 tolua_error(tolua_S,"#ferror in function 'lock'.",&tolua_err);
1643 return 0;
1644#endif
1645}
1646#endif //#ifndef TOLUA_DISABLE
1647
1648/* method: try_lock of class fawkes::Configuration */
1649#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_try_lock00
1650static int tolua_fawkesconfig_fawkes_Configuration_try_lock00(lua_State* tolua_S)
1651{
1652#ifndef TOLUA_RELEASE
1653 tolua_Error tolua_err;
1654 if (
1655 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1656 !tolua_isnoobj(tolua_S,2,&tolua_err)
1657 )
1658 goto tolua_lerror;
1659 else
1660#endif
1661 {
1662 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1663#ifndef TOLUA_RELEASE
1664 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'try_lock'",NULL);
1665#endif
1666 {
1667 bool tolua_ret = (bool) self->try_lock();
1668 tolua_pushboolean(tolua_S,(bool)tolua_ret);
1669 }
1670 }
1671 return 1;
1672#ifndef TOLUA_RELEASE
1673 tolua_lerror:
1674 tolua_error(tolua_S,"#ferror in function 'try_lock'.",&tolua_err);
1675 return 0;
1676#endif
1677}
1678#endif //#ifndef TOLUA_DISABLE
1679
1680/* method: unlock of class fawkes::Configuration */
1681#ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_unlock00
1682static int tolua_fawkesconfig_fawkes_Configuration_unlock00(lua_State* tolua_S)
1683{
1684#ifndef TOLUA_RELEASE
1685 tolua_Error tolua_err;
1686 if (
1687 !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1688 !tolua_isnoobj(tolua_S,2,&tolua_err)
1689 )
1690 goto tolua_lerror;
1691 else
1692#endif
1693 {
1694 fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1695#ifndef TOLUA_RELEASE
1696 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'unlock'",NULL);
1697#endif
1698 {
1699 self->unlock();
1700 }
1701 }
1702 return 0;
1703#ifndef TOLUA_RELEASE
1704 tolua_lerror:
1705 tolua_error(tolua_S,"#ferror in function 'unlock'.",&tolua_err);
1706 return 0;
1707#endif
1708}
1709#endif //#ifndef TOLUA_DISABLE
1710
1711/* Open function */
1712TOLUA_API int tolua_fawkesconfig_open (lua_State* tolua_S)
1713{
1714 tolua_open(tolua_S);
1715 tolua_reg_types(tolua_S);
1716 tolua_module(tolua_S,NULL,0);
1717 tolua_beginmodule(tolua_S,NULL);
1718 tolua_module(tolua_S,"fawkes",0);
1719 tolua_beginmodule(tolua_S,"fawkes");
1720 tolua_cclass(tolua_S,"Configuration","fawkes::Configuration","",NULL);
1721 tolua_beginmodule(tolua_S,"Configuration");
1722 #ifdef __cplusplus
1723 tolua_cclass(tolua_S,"ValueIterator","fawkes::Configuration::ValueIterator","",tolua_collect_fawkes__Configuration__ValueIterator);
1724 #else
1725 tolua_cclass(tolua_S,"ValueIterator","fawkes::Configuration::ValueIterator","",NULL);
1726 #endif
1727 tolua_beginmodule(tolua_S,"ValueIterator");
1728 tolua_function(tolua_S,"delete",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_delete00);
1729 tolua_function(tolua_S,"next",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_next00);
1730 tolua_function(tolua_S,"valid",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_valid00);
1731 tolua_function(tolua_S,"path",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_path00);
1732 tolua_function(tolua_S,"type",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_type00);
1733 tolua_function(tolua_S,"is_float",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_is_float00);
1734 tolua_function(tolua_S,"is_uint",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_is_uint00);
1735 tolua_function(tolua_S,"is_int",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_is_int00);
1736 tolua_function(tolua_S,"is_bool",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_is_bool00);
1737 tolua_function(tolua_S,"is_string",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_is_string00);
1738 tolua_function(tolua_S,"get_float",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_get_float00);
1739 tolua_function(tolua_S,"get_uint",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_get_uint00);
1740 tolua_function(tolua_S,"get_int",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_get_int00);
1741 tolua_function(tolua_S,"get_bool",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_get_bool00);
1742 tolua_function(tolua_S,"get_string",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_get_string00);
1743 tolua_function(tolua_S,"is_default",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_is_default00);
1744 tolua_endmodule(tolua_S);
1745 tolua_function(tolua_S,"exists",tolua_fawkesconfig_fawkes_Configuration_exists00);
1746 tolua_function(tolua_S,"is_float",tolua_fawkesconfig_fawkes_Configuration_is_float00);
1747 tolua_function(tolua_S,"is_uint",tolua_fawkesconfig_fawkes_Configuration_is_uint00);
1748 tolua_function(tolua_S,"is_int",tolua_fawkesconfig_fawkes_Configuration_is_int00);
1749 tolua_function(tolua_S,"is_bool",tolua_fawkesconfig_fawkes_Configuration_is_bool00);
1750 tolua_function(tolua_S,"is_string",tolua_fawkesconfig_fawkes_Configuration_is_string00);
1751 tolua_function(tolua_S,"is_default",tolua_fawkesconfig_fawkes_Configuration_is_default00);
1752 tolua_function(tolua_S,"get_float",tolua_fawkesconfig_fawkes_Configuration_get_float00);
1753 tolua_function(tolua_S,"get_uint",tolua_fawkesconfig_fawkes_Configuration_get_uint00);
1754 tolua_function(tolua_S,"get_int",tolua_fawkesconfig_fawkes_Configuration_get_int00);
1755 tolua_function(tolua_S,"get_bool",tolua_fawkesconfig_fawkes_Configuration_get_bool00);
1756 tolua_function(tolua_S,"get_string",tolua_fawkesconfig_fawkes_Configuration_get_string00);
1757 tolua_function(tolua_S,"get_value",tolua_fawkesconfig_fawkes_Configuration_get_value00);
1758 tolua_function(tolua_S,"get_float_or_default",tolua_fawkesconfig_fawkes_Configuration_get_float_or_default00);
1759 tolua_function(tolua_S,"get_int_or_default",tolua_fawkesconfig_fawkes_Configuration_get_int_or_default00);
1760 tolua_function(tolua_S,"set_float",tolua_fawkesconfig_fawkes_Configuration_set_float00);
1761 tolua_function(tolua_S,"set_uint",tolua_fawkesconfig_fawkes_Configuration_set_uint00);
1762 tolua_function(tolua_S,"set_int",tolua_fawkesconfig_fawkes_Configuration_set_int00);
1763 tolua_function(tolua_S,"set_bool",tolua_fawkesconfig_fawkes_Configuration_set_bool00);
1764 tolua_function(tolua_S,"set_string",tolua_fawkesconfig_fawkes_Configuration_set_string00);
1765 tolua_function(tolua_S,"set_string",tolua_fawkesconfig_fawkes_Configuration_set_string01);
1766 tolua_function(tolua_S,"erase",tolua_fawkesconfig_fawkes_Configuration_erase00);
1767 tolua_function(tolua_S,"set_default_float",tolua_fawkesconfig_fawkes_Configuration_set_default_float00);
1768 tolua_function(tolua_S,"set_default_uint",tolua_fawkesconfig_fawkes_Configuration_set_default_uint00);
1769 tolua_function(tolua_S,"set_default_int",tolua_fawkesconfig_fawkes_Configuration_set_default_int00);
1770 tolua_function(tolua_S,"set_default_bool",tolua_fawkesconfig_fawkes_Configuration_set_default_bool00);
1771 tolua_function(tolua_S,"set_default_string",tolua_fawkesconfig_fawkes_Configuration_set_default_string00);
1772 tolua_function(tolua_S,"set_default_string",tolua_fawkesconfig_fawkes_Configuration_set_default_string01);
1773 tolua_function(tolua_S,"erase_default",tolua_fawkesconfig_fawkes_Configuration_erase_default00);
1774 tolua_function(tolua_S,"iterator",tolua_fawkesconfig_fawkes_Configuration_iterator00);
1775 tolua_function(tolua_S,"search",tolua_fawkesconfig_fawkes_Configuration_search00);
1776 tolua_function(tolua_S,"lock",tolua_fawkesconfig_fawkes_Configuration_lock00);
1777 tolua_function(tolua_S,"try_lock",tolua_fawkesconfig_fawkes_Configuration_try_lock00);
1778 tolua_function(tolua_S,"unlock",tolua_fawkesconfig_fawkes_Configuration_unlock00);
1779 tolua_endmodule(tolua_S);
1780 tolua_endmodule(tolua_S);
1781 tolua_endmodule(tolua_S);
1782 return 1;
1783}
1784
1785
1786extern "C" {
1787#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501
1788 TOLUA_API int luaopen_fawkesconfig (lua_State* tolua_S) {
1789 return tolua_fawkesconfig_open(tolua_S);
1790};
1791#endif
1792}
1793
1794
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.