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: set_float of class fawkes::Configuration */
1352 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_set_float00
1353 static int tolua_fawkesconfig_fawkes_Configuration_set_float00(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  const char* path = ((const 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 'set_float'", NULL);
1372 #endif
1373  bool exc_caught = false;
1374  try {
1375  {
1376  self->set_float(path,f);
1377  }
1378  } catch (fawkes::Exception &e) {
1379  exc_caught = true;
1380  lua_pushstring(tolua_S, e.what_no_backtrace());
1381  }
1382  catch (std::exception &e) {
1383  exc_caught = true;
1384  lua_pushstring(tolua_S, e.what());
1385  }
1386  if (exc_caught) lua_error(tolua_S);
1387 
1388  }
1389  return 0;
1390 #ifndef TOLUA_RELEASE
1391  tolua_lerror:
1392  tolua_error(tolua_S,"#ferror in function 'set_float'.",&tolua_err);
1393  return 0;
1394 #endif
1395 }
1396 #endif //#ifndef TOLUA_DISABLE
1397 
1398 /* method: set_uint of class fawkes::Configuration */
1399 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_set_uint00
1400 static int tolua_fawkesconfig_fawkes_Configuration_set_uint00(lua_State* tolua_S)
1401 {
1402 #ifndef TOLUA_RELEASE
1403  tolua_Error tolua_err;
1404  if (
1405  !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1406  !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1407  !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
1408  !tolua_isnoobj(tolua_S,4,&tolua_err)
1409  )
1410  goto tolua_lerror;
1411  else
1412 #endif
1413  {
1414  fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1415  const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
1416  unsigned int uint = ((unsigned int) tolua_tonumber(tolua_S,3,0));
1417 #ifndef TOLUA_RELEASE
1418  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_uint'", NULL);
1419 #endif
1420  bool exc_caught = false;
1421  try {
1422  {
1423  self->set_uint(path,uint);
1424  }
1425  } catch (fawkes::Exception &e) {
1426  exc_caught = true;
1427  lua_pushstring(tolua_S, e.what_no_backtrace());
1428  }
1429  catch (std::exception &e) {
1430  exc_caught = true;
1431  lua_pushstring(tolua_S, e.what());
1432  }
1433  if (exc_caught) lua_error(tolua_S);
1434 
1435  }
1436  return 0;
1437 #ifndef TOLUA_RELEASE
1438  tolua_lerror:
1439  tolua_error(tolua_S,"#ferror in function 'set_uint'.",&tolua_err);
1440  return 0;
1441 #endif
1442 }
1443 #endif //#ifndef TOLUA_DISABLE
1444 
1445 /* method: set_int of class fawkes::Configuration */
1446 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_set_int00
1447 static int tolua_fawkesconfig_fawkes_Configuration_set_int00(lua_State* tolua_S)
1448 {
1449 #ifndef TOLUA_RELEASE
1450  tolua_Error tolua_err;
1451  if (
1452  !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1453  !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1454  !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
1455  !tolua_isnoobj(tolua_S,4,&tolua_err)
1456  )
1457  goto tolua_lerror;
1458  else
1459 #endif
1460  {
1461  fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1462  const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
1463  int i = ((int) tolua_tonumber(tolua_S,3,0));
1464 #ifndef TOLUA_RELEASE
1465  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_int'", NULL);
1466 #endif
1467  bool exc_caught = false;
1468  try {
1469  {
1470  self->set_int(path,i);
1471  }
1472  } catch (fawkes::Exception &e) {
1473  exc_caught = true;
1474  lua_pushstring(tolua_S, e.what_no_backtrace());
1475  }
1476  catch (std::exception &e) {
1477  exc_caught = true;
1478  lua_pushstring(tolua_S, e.what());
1479  }
1480  if (exc_caught) lua_error(tolua_S);
1481 
1482  }
1483  return 0;
1484 #ifndef TOLUA_RELEASE
1485  tolua_lerror:
1486  tolua_error(tolua_S,"#ferror in function 'set_int'.",&tolua_err);
1487  return 0;
1488 #endif
1489 }
1490 #endif //#ifndef TOLUA_DISABLE
1491 
1492 /* method: set_bool of class fawkes::Configuration */
1493 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_set_bool00
1494 static int tolua_fawkesconfig_fawkes_Configuration_set_bool00(lua_State* tolua_S)
1495 {
1496 #ifndef TOLUA_RELEASE
1497  tolua_Error tolua_err;
1498  if (
1499  !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1500  !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1501  !tolua_isboolean(tolua_S,3,0,&tolua_err) ||
1502  !tolua_isnoobj(tolua_S,4,&tolua_err)
1503  )
1504  goto tolua_lerror;
1505  else
1506 #endif
1507  {
1508  fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1509  const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
1510  bool b = ((bool) tolua_toboolean(tolua_S,3,0));
1511 #ifndef TOLUA_RELEASE
1512  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_bool'", NULL);
1513 #endif
1514  bool exc_caught = false;
1515  try {
1516  {
1517  self->set_bool(path,b);
1518  }
1519  } catch (fawkes::Exception &e) {
1520  exc_caught = true;
1521  lua_pushstring(tolua_S, e.what_no_backtrace());
1522  }
1523  catch (std::exception &e) {
1524  exc_caught = true;
1525  lua_pushstring(tolua_S, e.what());
1526  }
1527  if (exc_caught) lua_error(tolua_S);
1528 
1529  }
1530  return 0;
1531 #ifndef TOLUA_RELEASE
1532  tolua_lerror:
1533  tolua_error(tolua_S,"#ferror in function 'set_bool'.",&tolua_err);
1534  return 0;
1535 #endif
1536 }
1537 #endif //#ifndef TOLUA_DISABLE
1538 
1539 /* method: set_string of class fawkes::Configuration */
1540 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_set_string00
1541 static int tolua_fawkesconfig_fawkes_Configuration_set_string00(lua_State* tolua_S)
1542 {
1543 #ifndef TOLUA_RELEASE
1544  tolua_Error tolua_err;
1545  if (
1546  !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1547  !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1548  !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
1549  !tolua_isnoobj(tolua_S,4,&tolua_err)
1550  )
1551  goto tolua_lerror;
1552  else
1553 #endif
1554  {
1555  fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1556  const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
1557  std::string s = ((std::string) tolua_tocppstring(tolua_S,3,0));
1558 #ifndef TOLUA_RELEASE
1559  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_string'", NULL);
1560 #endif
1561  bool exc_caught = false;
1562  try {
1563  {
1564  self->set_string(path,s);
1565  }
1566  } catch (fawkes::Exception &e) {
1567  exc_caught = true;
1568  lua_pushstring(tolua_S, e.what_no_backtrace());
1569  }
1570  catch (std::exception &e) {
1571  exc_caught = true;
1572  lua_pushstring(tolua_S, e.what());
1573  }
1574  if (exc_caught) lua_error(tolua_S);
1575 
1576  }
1577  return 0;
1578 #ifndef TOLUA_RELEASE
1579  tolua_lerror:
1580  tolua_error(tolua_S,"#ferror in function 'set_string'.",&tolua_err);
1581  return 0;
1582 #endif
1583 }
1584 #endif //#ifndef TOLUA_DISABLE
1585 
1586 /* method: set_string of class fawkes::Configuration */
1587 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_set_string01
1588 static int tolua_fawkesconfig_fawkes_Configuration_set_string01(lua_State* tolua_S)
1589 {
1590  tolua_Error tolua_err;
1591  if (
1592  !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1593  !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1594  !tolua_isstring(tolua_S,3,0,&tolua_err) ||
1595  !tolua_isnoobj(tolua_S,4,&tolua_err)
1596  )
1597  goto tolua_lerror;
1598  else
1599  {
1600  fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1601  const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
1602  const char* s = ((const char*) tolua_tostring(tolua_S,3,0));
1603 #ifndef TOLUA_RELEASE
1604  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_string'", NULL);
1605 #endif
1606  bool exc_caught = false;
1607  try {
1608  {
1609  self->set_string(path,s);
1610  }
1611  } catch (fawkes::Exception &e) {
1612  exc_caught = true;
1613  lua_pushstring(tolua_S, e.what_no_backtrace());
1614  }
1615  catch (std::exception &e) {
1616  exc_caught = true;
1617  lua_pushstring(tolua_S, e.what());
1618  }
1619  if (exc_caught) lua_error(tolua_S);
1620 
1621  }
1622  return 0;
1623 tolua_lerror:
1624  return tolua_fawkesconfig_fawkes_Configuration_set_string00(tolua_S);
1625 }
1626 #endif //#ifndef TOLUA_DISABLE
1627 
1628 /* method: erase of class fawkes::Configuration */
1629 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_erase00
1630 static int tolua_fawkesconfig_fawkes_Configuration_erase00(lua_State* tolua_S)
1631 {
1632 #ifndef TOLUA_RELEASE
1633  tolua_Error tolua_err;
1634  if (
1635  !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1636  !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1637  !tolua_isnoobj(tolua_S,3,&tolua_err)
1638  )
1639  goto tolua_lerror;
1640  else
1641 #endif
1642  {
1643  fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1644  const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
1645 #ifndef TOLUA_RELEASE
1646  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'erase'", NULL);
1647 #endif
1648  bool exc_caught = false;
1649  try {
1650  {
1651  self->erase(path);
1652  }
1653  } catch (fawkes::Exception &e) {
1654  exc_caught = true;
1655  lua_pushstring(tolua_S, e.what_no_backtrace());
1656  }
1657  catch (std::exception &e) {
1658  exc_caught = true;
1659  lua_pushstring(tolua_S, e.what());
1660  }
1661  if (exc_caught) lua_error(tolua_S);
1662 
1663  }
1664  return 0;
1665 #ifndef TOLUA_RELEASE
1666  tolua_lerror:
1667  tolua_error(tolua_S,"#ferror in function 'erase'.",&tolua_err);
1668  return 0;
1669 #endif
1670 }
1671 #endif //#ifndef TOLUA_DISABLE
1672 
1673 /* method: set_default_float of class fawkes::Configuration */
1674 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_set_default_float00
1675 static int tolua_fawkesconfig_fawkes_Configuration_set_default_float00(lua_State* tolua_S)
1676 {
1677 #ifndef TOLUA_RELEASE
1678  tolua_Error tolua_err;
1679  if (
1680  !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1681  !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1682  !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
1683  !tolua_isnoobj(tolua_S,4,&tolua_err)
1684  )
1685  goto tolua_lerror;
1686  else
1687 #endif
1688  {
1689  fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1690  const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
1691  float f = ((float) tolua_tonumber(tolua_S,3,0));
1692 #ifndef TOLUA_RELEASE
1693  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_default_float'", NULL);
1694 #endif
1695  bool exc_caught = false;
1696  try {
1697  {
1698  self->set_default_float(path,f);
1699  }
1700  } catch (fawkes::Exception &e) {
1701  exc_caught = true;
1702  lua_pushstring(tolua_S, e.what_no_backtrace());
1703  }
1704  catch (std::exception &e) {
1705  exc_caught = true;
1706  lua_pushstring(tolua_S, e.what());
1707  }
1708  if (exc_caught) lua_error(tolua_S);
1709 
1710  }
1711  return 0;
1712 #ifndef TOLUA_RELEASE
1713  tolua_lerror:
1714  tolua_error(tolua_S,"#ferror in function 'set_default_float'.",&tolua_err);
1715  return 0;
1716 #endif
1717 }
1718 #endif //#ifndef TOLUA_DISABLE
1719 
1720 /* method: set_default_uint of class fawkes::Configuration */
1721 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_set_default_uint00
1722 static int tolua_fawkesconfig_fawkes_Configuration_set_default_uint00(lua_State* tolua_S)
1723 {
1724 #ifndef TOLUA_RELEASE
1725  tolua_Error tolua_err;
1726  if (
1727  !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1728  !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1729  !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
1730  !tolua_isnoobj(tolua_S,4,&tolua_err)
1731  )
1732  goto tolua_lerror;
1733  else
1734 #endif
1735  {
1736  fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1737  const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
1738  unsigned int uint = ((unsigned int) tolua_tonumber(tolua_S,3,0));
1739 #ifndef TOLUA_RELEASE
1740  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_default_uint'", NULL);
1741 #endif
1742  bool exc_caught = false;
1743  try {
1744  {
1745  self->set_default_uint(path,uint);
1746  }
1747  } catch (fawkes::Exception &e) {
1748  exc_caught = true;
1749  lua_pushstring(tolua_S, e.what_no_backtrace());
1750  }
1751  catch (std::exception &e) {
1752  exc_caught = true;
1753  lua_pushstring(tolua_S, e.what());
1754  }
1755  if (exc_caught) lua_error(tolua_S);
1756 
1757  }
1758  return 0;
1759 #ifndef TOLUA_RELEASE
1760  tolua_lerror:
1761  tolua_error(tolua_S,"#ferror in function 'set_default_uint'.",&tolua_err);
1762  return 0;
1763 #endif
1764 }
1765 #endif //#ifndef TOLUA_DISABLE
1766 
1767 /* method: set_default_int of class fawkes::Configuration */
1768 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_set_default_int00
1769 static int tolua_fawkesconfig_fawkes_Configuration_set_default_int00(lua_State* tolua_S)
1770 {
1771 #ifndef TOLUA_RELEASE
1772  tolua_Error tolua_err;
1773  if (
1774  !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1775  !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1776  !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
1777  !tolua_isnoobj(tolua_S,4,&tolua_err)
1778  )
1779  goto tolua_lerror;
1780  else
1781 #endif
1782  {
1783  fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1784  const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
1785  int i = ((int) tolua_tonumber(tolua_S,3,0));
1786 #ifndef TOLUA_RELEASE
1787  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_default_int'", NULL);
1788 #endif
1789  bool exc_caught = false;
1790  try {
1791  {
1792  self->set_default_int(path,i);
1793  }
1794  } catch (fawkes::Exception &e) {
1795  exc_caught = true;
1796  lua_pushstring(tolua_S, e.what_no_backtrace());
1797  }
1798  catch (std::exception &e) {
1799  exc_caught = true;
1800  lua_pushstring(tolua_S, e.what());
1801  }
1802  if (exc_caught) lua_error(tolua_S);
1803 
1804  }
1805  return 0;
1806 #ifndef TOLUA_RELEASE
1807  tolua_lerror:
1808  tolua_error(tolua_S,"#ferror in function 'set_default_int'.",&tolua_err);
1809  return 0;
1810 #endif
1811 }
1812 #endif //#ifndef TOLUA_DISABLE
1813 
1814 /* method: set_default_bool of class fawkes::Configuration */
1815 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_set_default_bool00
1816 static int tolua_fawkesconfig_fawkes_Configuration_set_default_bool00(lua_State* tolua_S)
1817 {
1818 #ifndef TOLUA_RELEASE
1819  tolua_Error tolua_err;
1820  if (
1821  !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1822  !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1823  !tolua_isboolean(tolua_S,3,0,&tolua_err) ||
1824  !tolua_isnoobj(tolua_S,4,&tolua_err)
1825  )
1826  goto tolua_lerror;
1827  else
1828 #endif
1829  {
1830  fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1831  const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
1832  bool b = ((bool) tolua_toboolean(tolua_S,3,0));
1833 #ifndef TOLUA_RELEASE
1834  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_default_bool'", NULL);
1835 #endif
1836  bool exc_caught = false;
1837  try {
1838  {
1839  self->set_default_bool(path,b);
1840  }
1841  } catch (fawkes::Exception &e) {
1842  exc_caught = true;
1843  lua_pushstring(tolua_S, e.what_no_backtrace());
1844  }
1845  catch (std::exception &e) {
1846  exc_caught = true;
1847  lua_pushstring(tolua_S, e.what());
1848  }
1849  if (exc_caught) lua_error(tolua_S);
1850 
1851  }
1852  return 0;
1853 #ifndef TOLUA_RELEASE
1854  tolua_lerror:
1855  tolua_error(tolua_S,"#ferror in function 'set_default_bool'.",&tolua_err);
1856  return 0;
1857 #endif
1858 }
1859 #endif //#ifndef TOLUA_DISABLE
1860 
1861 /* method: set_default_string of class fawkes::Configuration */
1862 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_set_default_string00
1863 static int tolua_fawkesconfig_fawkes_Configuration_set_default_string00(lua_State* tolua_S)
1864 {
1865 #ifndef TOLUA_RELEASE
1866  tolua_Error tolua_err;
1867  if (
1868  !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1869  !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1870  !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
1871  !tolua_isnoobj(tolua_S,4,&tolua_err)
1872  )
1873  goto tolua_lerror;
1874  else
1875 #endif
1876  {
1877  fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1878  const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
1879  std::string s = ((std::string) tolua_tocppstring(tolua_S,3,0));
1880 #ifndef TOLUA_RELEASE
1881  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_default_string'", NULL);
1882 #endif
1883  bool exc_caught = false;
1884  try {
1885  {
1886  self->set_default_string(path,s);
1887  }
1888  } catch (fawkes::Exception &e) {
1889  exc_caught = true;
1890  lua_pushstring(tolua_S, e.what_no_backtrace());
1891  }
1892  catch (std::exception &e) {
1893  exc_caught = true;
1894  lua_pushstring(tolua_S, e.what());
1895  }
1896  if (exc_caught) lua_error(tolua_S);
1897 
1898  }
1899  return 0;
1900 #ifndef TOLUA_RELEASE
1901  tolua_lerror:
1902  tolua_error(tolua_S,"#ferror in function 'set_default_string'.",&tolua_err);
1903  return 0;
1904 #endif
1905 }
1906 #endif //#ifndef TOLUA_DISABLE
1907 
1908 /* method: set_default_string of class fawkes::Configuration */
1909 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_set_default_string01
1910 static int tolua_fawkesconfig_fawkes_Configuration_set_default_string01(lua_State* tolua_S)
1911 {
1912  tolua_Error tolua_err;
1913  if (
1914  !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1915  !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1916  !tolua_isstring(tolua_S,3,0,&tolua_err) ||
1917  !tolua_isnoobj(tolua_S,4,&tolua_err)
1918  )
1919  goto tolua_lerror;
1920  else
1921  {
1922  fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1923  const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
1924  const char* s = ((const char*) tolua_tostring(tolua_S,3,0));
1925 #ifndef TOLUA_RELEASE
1926  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_default_string'", NULL);
1927 #endif
1928  bool exc_caught = false;
1929  try {
1930  {
1931  self->set_default_string(path,s);
1932  }
1933  } catch (fawkes::Exception &e) {
1934  exc_caught = true;
1935  lua_pushstring(tolua_S, e.what_no_backtrace());
1936  }
1937  catch (std::exception &e) {
1938  exc_caught = true;
1939  lua_pushstring(tolua_S, e.what());
1940  }
1941  if (exc_caught) lua_error(tolua_S);
1942 
1943  }
1944  return 0;
1945 tolua_lerror:
1946  return tolua_fawkesconfig_fawkes_Configuration_set_default_string00(tolua_S);
1947 }
1948 #endif //#ifndef TOLUA_DISABLE
1949 
1950 /* method: erase_default of class fawkes::Configuration */
1951 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_erase_default00
1952 static int tolua_fawkesconfig_fawkes_Configuration_erase_default00(lua_State* tolua_S)
1953 {
1954 #ifndef TOLUA_RELEASE
1955  tolua_Error tolua_err;
1956  if (
1957  !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1958  !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1959  !tolua_isnoobj(tolua_S,3,&tolua_err)
1960  )
1961  goto tolua_lerror;
1962  else
1963 #endif
1964  {
1965  fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1966  const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
1967 #ifndef TOLUA_RELEASE
1968  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'erase_default'", NULL);
1969 #endif
1970  bool exc_caught = false;
1971  try {
1972  {
1973  self->erase_default(path);
1974  }
1975  } catch (fawkes::Exception &e) {
1976  exc_caught = true;
1977  lua_pushstring(tolua_S, e.what_no_backtrace());
1978  }
1979  catch (std::exception &e) {
1980  exc_caught = true;
1981  lua_pushstring(tolua_S, e.what());
1982  }
1983  if (exc_caught) lua_error(tolua_S);
1984 
1985  }
1986  return 0;
1987 #ifndef TOLUA_RELEASE
1988  tolua_lerror:
1989  tolua_error(tolua_S,"#ferror in function 'erase_default'.",&tolua_err);
1990  return 0;
1991 #endif
1992 }
1993 #endif //#ifndef TOLUA_DISABLE
1994 
1995 /* method: iterator of class fawkes::Configuration */
1996 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_iterator00
1997 static int tolua_fawkesconfig_fawkes_Configuration_iterator00(lua_State* tolua_S)
1998 {
1999 #ifndef TOLUA_RELEASE
2000  tolua_Error tolua_err;
2001  if (
2002  !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
2003  !tolua_isnoobj(tolua_S,2,&tolua_err)
2004  )
2005  goto tolua_lerror;
2006  else
2007 #endif
2008  {
2009  fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
2010 #ifndef TOLUA_RELEASE
2011  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'iterator'", NULL);
2012 #endif
2013  bool exc_caught = false;
2014  try {
2015  {
2017  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Configuration::ValueIterator");
2018  }
2019  } catch (fawkes::Exception &e) {
2020  exc_caught = true;
2021  lua_pushstring(tolua_S, e.what_no_backtrace());
2022  }
2023  catch (std::exception &e) {
2024  exc_caught = true;
2025  lua_pushstring(tolua_S, e.what());
2026  }
2027  if (exc_caught) lua_error(tolua_S);
2028 
2029  }
2030  return 1;
2031 #ifndef TOLUA_RELEASE
2032  tolua_lerror:
2033  tolua_error(tolua_S,"#ferror in function 'iterator'.",&tolua_err);
2034  return 0;
2035 #endif
2036 }
2037 #endif //#ifndef TOLUA_DISABLE
2038 
2039 /* method: search of class fawkes::Configuration */
2040 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_search00
2041 static int tolua_fawkesconfig_fawkes_Configuration_search00(lua_State* tolua_S)
2042 {
2043 #ifndef TOLUA_RELEASE
2044  tolua_Error tolua_err;
2045  if (
2046  !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
2047  !tolua_isstring(tolua_S,2,0,&tolua_err) ||
2048  !tolua_isnoobj(tolua_S,3,&tolua_err)
2049  )
2050  goto tolua_lerror;
2051  else
2052 #endif
2053  {
2054  fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
2055  const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
2056 #ifndef TOLUA_RELEASE
2057  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'search'", NULL);
2058 #endif
2059  bool exc_caught = false;
2060  try {
2061  {
2063  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Configuration::ValueIterator");
2064  }
2065  } catch (fawkes::Exception &e) {
2066  exc_caught = true;
2067  lua_pushstring(tolua_S, e.what_no_backtrace());
2068  }
2069  catch (std::exception &e) {
2070  exc_caught = true;
2071  lua_pushstring(tolua_S, e.what());
2072  }
2073  if (exc_caught) lua_error(tolua_S);
2074 
2075  }
2076  return 1;
2077 #ifndef TOLUA_RELEASE
2078  tolua_lerror:
2079  tolua_error(tolua_S,"#ferror in function 'search'.",&tolua_err);
2080  return 0;
2081 #endif
2082 }
2083 #endif //#ifndef TOLUA_DISABLE
2084 
2085 /* method: lock of class fawkes::Configuration */
2086 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_lock00
2087 static int tolua_fawkesconfig_fawkes_Configuration_lock00(lua_State* tolua_S)
2088 {
2089 #ifndef TOLUA_RELEASE
2090  tolua_Error tolua_err;
2091  if (
2092  !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
2093  !tolua_isnoobj(tolua_S,2,&tolua_err)
2094  )
2095  goto tolua_lerror;
2096  else
2097 #endif
2098  {
2099  fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
2100 #ifndef TOLUA_RELEASE
2101  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'lock'", NULL);
2102 #endif
2103  bool exc_caught = false;
2104  try {
2105  {
2106  self->lock();
2107  }
2108  } catch (fawkes::Exception &e) {
2109  exc_caught = true;
2110  lua_pushstring(tolua_S, e.what_no_backtrace());
2111  }
2112  catch (std::exception &e) {
2113  exc_caught = true;
2114  lua_pushstring(tolua_S, e.what());
2115  }
2116  if (exc_caught) lua_error(tolua_S);
2117 
2118  }
2119  return 0;
2120 #ifndef TOLUA_RELEASE
2121  tolua_lerror:
2122  tolua_error(tolua_S,"#ferror in function 'lock'.",&tolua_err);
2123  return 0;
2124 #endif
2125 }
2126 #endif //#ifndef TOLUA_DISABLE
2127 
2128 /* method: try_lock of class fawkes::Configuration */
2129 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_try_lock00
2130 static int tolua_fawkesconfig_fawkes_Configuration_try_lock00(lua_State* tolua_S)
2131 {
2132 #ifndef TOLUA_RELEASE
2133  tolua_Error tolua_err;
2134  if (
2135  !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
2136  !tolua_isnoobj(tolua_S,2,&tolua_err)
2137  )
2138  goto tolua_lerror;
2139  else
2140 #endif
2141  {
2142  fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
2143 #ifndef TOLUA_RELEASE
2144  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'try_lock'", NULL);
2145 #endif
2146  bool exc_caught = false;
2147  try {
2148  {
2149  bool tolua_ret = (bool) self->try_lock();
2150  tolua_pushboolean(tolua_S,(bool)tolua_ret);
2151  }
2152  } catch (fawkes::Exception &e) {
2153  exc_caught = true;
2154  lua_pushstring(tolua_S, e.what_no_backtrace());
2155  }
2156  catch (std::exception &e) {
2157  exc_caught = true;
2158  lua_pushstring(tolua_S, e.what());
2159  }
2160  if (exc_caught) lua_error(tolua_S);
2161 
2162  }
2163  return 1;
2164 #ifndef TOLUA_RELEASE
2165  tolua_lerror:
2166  tolua_error(tolua_S,"#ferror in function 'try_lock'.",&tolua_err);
2167  return 0;
2168 #endif
2169 }
2170 #endif //#ifndef TOLUA_DISABLE
2171 
2172 /* method: unlock of class fawkes::Configuration */
2173 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_unlock00
2174 static int tolua_fawkesconfig_fawkes_Configuration_unlock00(lua_State* tolua_S)
2175 {
2176 #ifndef TOLUA_RELEASE
2177  tolua_Error tolua_err;
2178  if (
2179  !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
2180  !tolua_isnoobj(tolua_S,2,&tolua_err)
2181  )
2182  goto tolua_lerror;
2183  else
2184 #endif
2185  {
2186  fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
2187 #ifndef TOLUA_RELEASE
2188  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'unlock'", NULL);
2189 #endif
2190  bool exc_caught = false;
2191  try {
2192  {
2193  self->unlock();
2194  }
2195  } catch (fawkes::Exception &e) {
2196  exc_caught = true;
2197  lua_pushstring(tolua_S, e.what_no_backtrace());
2198  }
2199  catch (std::exception &e) {
2200  exc_caught = true;
2201  lua_pushstring(tolua_S, e.what());
2202  }
2203  if (exc_caught) lua_error(tolua_S);
2204 
2205  }
2206  return 0;
2207 #ifndef TOLUA_RELEASE
2208  tolua_lerror:
2209  tolua_error(tolua_S,"#ferror in function 'unlock'.",&tolua_err);
2210  return 0;
2211 #endif
2212 }
2213 #endif //#ifndef TOLUA_DISABLE
2214 
2215 /* Open function */
2216 TOLUA_API int tolua_fawkesconfig_open (lua_State* tolua_S)
2217 {
2218  tolua_open(tolua_S);
2219  tolua_reg_types(tolua_S);
2220  tolua_module(tolua_S,NULL,0);
2221  tolua_beginmodule(tolua_S,NULL);
2222  tolua_module(tolua_S,"fawkes",0);
2223  tolua_beginmodule(tolua_S,"fawkes");
2224  tolua_cclass(tolua_S,"Configuration","fawkes::Configuration","",NULL);
2225  tolua_beginmodule(tolua_S,"Configuration");
2226  #ifdef __cplusplus
2227  tolua_cclass(tolua_S,"ValueIterator","fawkes::Configuration::ValueIterator","",tolua_collect_fawkes__Configuration__ValueIterator);
2228  #else
2229  tolua_cclass(tolua_S,"ValueIterator","fawkes::Configuration::ValueIterator","",NULL);
2230  #endif
2231  tolua_beginmodule(tolua_S,"ValueIterator");
2232  tolua_function(tolua_S,"delete",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_delete00);
2233  tolua_function(tolua_S,"next",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_next00);
2234  tolua_function(tolua_S,"valid",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_valid00);
2235  tolua_function(tolua_S,"path",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_path00);
2236  tolua_function(tolua_S,"type",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_type00);
2237  tolua_function(tolua_S,"is_float",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_is_float00);
2238  tolua_function(tolua_S,"is_uint",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_is_uint00);
2239  tolua_function(tolua_S,"is_int",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_is_int00);
2240  tolua_function(tolua_S,"is_bool",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_is_bool00);
2241  tolua_function(tolua_S,"is_string",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_is_string00);
2242  tolua_function(tolua_S,"get_float",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_get_float00);
2243  tolua_function(tolua_S,"get_uint",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_get_uint00);
2244  tolua_function(tolua_S,"get_int",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_get_int00);
2245  tolua_function(tolua_S,"get_bool",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_get_bool00);
2246  tolua_function(tolua_S,"get_string",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_get_string00);
2247  tolua_function(tolua_S,"is_default",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_is_default00);
2248  tolua_endmodule(tolua_S);
2249  tolua_function(tolua_S,"exists",tolua_fawkesconfig_fawkes_Configuration_exists00);
2250  tolua_function(tolua_S,"is_float",tolua_fawkesconfig_fawkes_Configuration_is_float00);
2251  tolua_function(tolua_S,"is_uint",tolua_fawkesconfig_fawkes_Configuration_is_uint00);
2252  tolua_function(tolua_S,"is_int",tolua_fawkesconfig_fawkes_Configuration_is_int00);
2253  tolua_function(tolua_S,"is_bool",tolua_fawkesconfig_fawkes_Configuration_is_bool00);
2254  tolua_function(tolua_S,"is_string",tolua_fawkesconfig_fawkes_Configuration_is_string00);
2255  tolua_function(tolua_S,"is_default",tolua_fawkesconfig_fawkes_Configuration_is_default00);
2256  tolua_function(tolua_S,"get_float",tolua_fawkesconfig_fawkes_Configuration_get_float00);
2257  tolua_function(tolua_S,"get_uint",tolua_fawkesconfig_fawkes_Configuration_get_uint00);
2258  tolua_function(tolua_S,"get_int",tolua_fawkesconfig_fawkes_Configuration_get_int00);
2259  tolua_function(tolua_S,"get_bool",tolua_fawkesconfig_fawkes_Configuration_get_bool00);
2260  tolua_function(tolua_S,"get_string",tolua_fawkesconfig_fawkes_Configuration_get_string00);
2261  tolua_function(tolua_S,"get_value",tolua_fawkesconfig_fawkes_Configuration_get_value00);
2262  tolua_function(tolua_S,"set_float",tolua_fawkesconfig_fawkes_Configuration_set_float00);
2263  tolua_function(tolua_S,"set_uint",tolua_fawkesconfig_fawkes_Configuration_set_uint00);
2264  tolua_function(tolua_S,"set_int",tolua_fawkesconfig_fawkes_Configuration_set_int00);
2265  tolua_function(tolua_S,"set_bool",tolua_fawkesconfig_fawkes_Configuration_set_bool00);
2266  tolua_function(tolua_S,"set_string",tolua_fawkesconfig_fawkes_Configuration_set_string00);
2267  tolua_function(tolua_S,"set_string",tolua_fawkesconfig_fawkes_Configuration_set_string01);
2268  tolua_function(tolua_S,"erase",tolua_fawkesconfig_fawkes_Configuration_erase00);
2269  tolua_function(tolua_S,"set_default_float",tolua_fawkesconfig_fawkes_Configuration_set_default_float00);
2270  tolua_function(tolua_S,"set_default_uint",tolua_fawkesconfig_fawkes_Configuration_set_default_uint00);
2271  tolua_function(tolua_S,"set_default_int",tolua_fawkesconfig_fawkes_Configuration_set_default_int00);
2272  tolua_function(tolua_S,"set_default_bool",tolua_fawkesconfig_fawkes_Configuration_set_default_bool00);
2273  tolua_function(tolua_S,"set_default_string",tolua_fawkesconfig_fawkes_Configuration_set_default_string00);
2274  tolua_function(tolua_S,"set_default_string",tolua_fawkesconfig_fawkes_Configuration_set_default_string01);
2275  tolua_function(tolua_S,"erase_default",tolua_fawkesconfig_fawkes_Configuration_erase_default00);
2276  tolua_function(tolua_S,"iterator",tolua_fawkesconfig_fawkes_Configuration_iterator00);
2277  tolua_function(tolua_S,"search",tolua_fawkesconfig_fawkes_Configuration_search00);
2278  tolua_function(tolua_S,"lock",tolua_fawkesconfig_fawkes_Configuration_lock00);
2279  tolua_function(tolua_S,"try_lock",tolua_fawkesconfig_fawkes_Configuration_try_lock00);
2280  tolua_function(tolua_S,"unlock",tolua_fawkesconfig_fawkes_Configuration_unlock00);
2281  tolua_endmodule(tolua_S);
2282  tolua_endmodule(tolua_S);
2283  tolua_endmodule(tolua_S);
2284  return 1;
2285 }
2286 
2287 
2288 extern "C" {
2289 #if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501
2290  TOLUA_API int luaopen_fawkesconfig (lua_State* tolua_S) {
2291  return tolua_fawkesconfig_open(tolua_S);
2292 };
2293 #endif
2294 }
2295 
2296 
Base class for exceptions in Fawkes.
Definition: exception.h:36
virtual const char * what_no_backtrace() const
Get primary string (does not implicitly print the back trace).
Definition: exception.cpp:686
Iterator interface to iterate over config values.
Definition: config.h:72
Interface for configuration handling.
Definition: config.h:67