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