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 */
29 TOLUA_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 
36 static int tolua_collect_fawkes__Configuration__ValueIterator (lua_State* tolua_S)
37 {
38  fawkes::Configuration::ValueIterator* self = (fawkes::Configuration::ValueIterator*) tolua_tousertype(tolua_S,1,0);
39  Mtolua_delete(self);
40  return 0;
41 }
42 #endif
43 
44 
45 /* function to register type */
46 static 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
54 static 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  {
66  fawkes::Configuration::ValueIterator* self = (fawkes::Configuration::ValueIterator*) tolua_tousertype(tolua_S,1,0);
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
95 static 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
139 static 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
183 static 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
227 static 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
271 static 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
315 static 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
359 static 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
403 static 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
447 static 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
491 static 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
535 static 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
579 static 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
623 static 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
667 static 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
711 static 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
755 static 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
801 static 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
847 static 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
893 static 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
939 static 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
985 static 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
1031 static 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
1077 static 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
1123 static 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
1169 static 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
1215 static 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
1261 static 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
1307 static 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  {
1328  fawkes::Configuration::ValueIterator* tolua_ret = (fawkes::Configuration::ValueIterator*) self->get_value(path);
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
1353 static 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
1401 static 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
1449 static 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
1496 static 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
1543 static 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
1590 static 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
1637 static 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
1684 static 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;
1719 tolua_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
1726 static 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
1771 static 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
1818 static 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
1865 static 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
1912 static 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
1959 static 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
2006 static 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;
2041 tolua_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
2048 static 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
2093 static 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  {
2112  fawkes::Configuration::ValueIterator* tolua_ret = (fawkes::Configuration::ValueIterator*) self->iterator();
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
2137 static 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  {
2158  fawkes::Configuration::ValueIterator* tolua_ret = (fawkes::Configuration::ValueIterator*) self->search(path);
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
2183 static 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
2226 static 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
2270 static 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 */
2312 TOLUA_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 
2386 extern "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 
fawkes::Configuration::ValueIterator
Iterator interface to iterate over config values.
Definition: config.h:75
fawkes::Configuration
Interface for configuration handling.
Definition: config.h:68
fawkes::Exception
Base class for exceptions in Fawkes.
Definition: exception.h:36
fawkes::Exception::what_no_backtrace
virtual const char * what_no_backtrace() const noexcept
Get primary string (does not implicitly print the back trace).
Definition: exception.cpp:663