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: get_float_or_default of class fawkes::Configuration */
1004 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_get_float_or_default00
1005 static int tolua_fawkesconfig_fawkes_Configuration_get_float_or_default00(lua_State* tolua_S)
1006 {
1007 #ifndef TOLUA_RELEASE
1008  tolua_Error tolua_err;
1009  if (
1010  !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1011  !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1012  !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
1013  !tolua_isnoobj(tolua_S,4,&tolua_err)
1014  )
1015  goto tolua_lerror;
1016  else
1017 #endif
1018  {
1019  fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1020  char* path = ((char*) tolua_tostring(tolua_S,2,0));
1021  float f = ((float) tolua_tonumber(tolua_S,3,0));
1022 #ifndef TOLUA_RELEASE
1023  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_float_or_default'",NULL);
1024 #endif
1025  {
1026  float tolua_ret = (float) self->get_float_or_default(path,f);
1027  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1028  }
1029  }
1030  return 1;
1031 #ifndef TOLUA_RELEASE
1032  tolua_lerror:
1033  tolua_error(tolua_S,"#ferror in function 'get_float_or_default'.",&tolua_err);
1034  return 0;
1035 #endif
1036 }
1037 #endif //#ifndef TOLUA_DISABLE
1038 
1039 /* method: get_int_or_default of class fawkes::Configuration */
1040 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_get_int_or_default00
1041 static int tolua_fawkesconfig_fawkes_Configuration_get_int_or_default00(lua_State* tolua_S)
1042 {
1043 #ifndef TOLUA_RELEASE
1044  tolua_Error tolua_err;
1045  if (
1046  !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1047  !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1048  !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
1049  !tolua_isnoobj(tolua_S,4,&tolua_err)
1050  )
1051  goto tolua_lerror;
1052  else
1053 #endif
1054  {
1055  fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1056  char* path = ((char*) tolua_tostring(tolua_S,2,0));
1057  int i = ((int) tolua_tonumber(tolua_S,3,0));
1058 #ifndef TOLUA_RELEASE
1059  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_int_or_default'",NULL);
1060 #endif
1061  {
1062  int tolua_ret = (int) self->get_int_or_default(path,i);
1063  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1064  }
1065  }
1066  return 1;
1067 #ifndef TOLUA_RELEASE
1068  tolua_lerror:
1069  tolua_error(tolua_S,"#ferror in function 'get_int_or_default'.",&tolua_err);
1070  return 0;
1071 #endif
1072 }
1073 #endif //#ifndef TOLUA_DISABLE
1074 
1075 /* method: set_float of class fawkes::Configuration */
1076 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_set_float00
1077 static int tolua_fawkesconfig_fawkes_Configuration_set_float00(lua_State* tolua_S)
1078 {
1079 #ifndef TOLUA_RELEASE
1080  tolua_Error tolua_err;
1081  if (
1082  !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1083  !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1084  !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
1085  !tolua_isnoobj(tolua_S,4,&tolua_err)
1086  )
1087  goto tolua_lerror;
1088  else
1089 #endif
1090  {
1091  fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1092  const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
1093  float f = ((float) tolua_tonumber(tolua_S,3,0));
1094 #ifndef TOLUA_RELEASE
1095  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_float'",NULL);
1096 #endif
1097  {
1098  self->set_float(path,f);
1099  }
1100  }
1101  return 0;
1102 #ifndef TOLUA_RELEASE
1103  tolua_lerror:
1104  tolua_error(tolua_S,"#ferror in function 'set_float'.",&tolua_err);
1105  return 0;
1106 #endif
1107 }
1108 #endif //#ifndef TOLUA_DISABLE
1109 
1110 /* method: set_uint of class fawkes::Configuration */
1111 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_set_uint00
1112 static int tolua_fawkesconfig_fawkes_Configuration_set_uint00(lua_State* tolua_S)
1113 {
1114 #ifndef TOLUA_RELEASE
1115  tolua_Error tolua_err;
1116  if (
1117  !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1118  !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1119  !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
1120  !tolua_isnoobj(tolua_S,4,&tolua_err)
1121  )
1122  goto tolua_lerror;
1123  else
1124 #endif
1125  {
1126  fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1127  const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
1128  unsigned int uint = ((unsigned int) tolua_tonumber(tolua_S,3,0));
1129 #ifndef TOLUA_RELEASE
1130  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_uint'",NULL);
1131 #endif
1132  {
1133  self->set_uint(path,uint);
1134  }
1135  }
1136  return 0;
1137 #ifndef TOLUA_RELEASE
1138  tolua_lerror:
1139  tolua_error(tolua_S,"#ferror in function 'set_uint'.",&tolua_err);
1140  return 0;
1141 #endif
1142 }
1143 #endif //#ifndef TOLUA_DISABLE
1144 
1145 /* method: set_int of class fawkes::Configuration */
1146 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_set_int00
1147 static int tolua_fawkesconfig_fawkes_Configuration_set_int00(lua_State* tolua_S)
1148 {
1149 #ifndef TOLUA_RELEASE
1150  tolua_Error tolua_err;
1151  if (
1152  !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1153  !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1154  !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
1155  !tolua_isnoobj(tolua_S,4,&tolua_err)
1156  )
1157  goto tolua_lerror;
1158  else
1159 #endif
1160  {
1161  fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1162  const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
1163  int i = ((int) tolua_tonumber(tolua_S,3,0));
1164 #ifndef TOLUA_RELEASE
1165  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_int'",NULL);
1166 #endif
1167  {
1168  self->set_int(path,i);
1169  }
1170  }
1171  return 0;
1172 #ifndef TOLUA_RELEASE
1173  tolua_lerror:
1174  tolua_error(tolua_S,"#ferror in function 'set_int'.",&tolua_err);
1175  return 0;
1176 #endif
1177 }
1178 #endif //#ifndef TOLUA_DISABLE
1179 
1180 /* method: set_bool of class fawkes::Configuration */
1181 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_set_bool00
1182 static int tolua_fawkesconfig_fawkes_Configuration_set_bool00(lua_State* tolua_S)
1183 {
1184 #ifndef TOLUA_RELEASE
1185  tolua_Error tolua_err;
1186  if (
1187  !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1188  !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1189  !tolua_isboolean(tolua_S,3,0,&tolua_err) ||
1190  !tolua_isnoobj(tolua_S,4,&tolua_err)
1191  )
1192  goto tolua_lerror;
1193  else
1194 #endif
1195  {
1196  fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1197  const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
1198  bool b = ((bool) tolua_toboolean(tolua_S,3,0));
1199 #ifndef TOLUA_RELEASE
1200  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_bool'",NULL);
1201 #endif
1202  {
1203  self->set_bool(path,b);
1204  }
1205  }
1206  return 0;
1207 #ifndef TOLUA_RELEASE
1208  tolua_lerror:
1209  tolua_error(tolua_S,"#ferror in function 'set_bool'.",&tolua_err);
1210  return 0;
1211 #endif
1212 }
1213 #endif //#ifndef TOLUA_DISABLE
1214 
1215 /* method: set_string of class fawkes::Configuration */
1216 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_set_string00
1217 static int tolua_fawkesconfig_fawkes_Configuration_set_string00(lua_State* tolua_S)
1218 {
1219 #ifndef TOLUA_RELEASE
1220  tolua_Error tolua_err;
1221  if (
1222  !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1223  !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1224  !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
1225  !tolua_isnoobj(tolua_S,4,&tolua_err)
1226  )
1227  goto tolua_lerror;
1228  else
1229 #endif
1230  {
1231  fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1232  const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
1233  std::string s = ((std::string) tolua_tocppstring(tolua_S,3,0));
1234 #ifndef TOLUA_RELEASE
1235  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_string'",NULL);
1236 #endif
1237  {
1238  self->set_string(path,s);
1239  }
1240  }
1241  return 0;
1242 #ifndef TOLUA_RELEASE
1243  tolua_lerror:
1244  tolua_error(tolua_S,"#ferror in function 'set_string'.",&tolua_err);
1245  return 0;
1246 #endif
1247 }
1248 #endif //#ifndef TOLUA_DISABLE
1249 
1250 /* method: set_string of class fawkes::Configuration */
1251 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_set_string01
1252 static int tolua_fawkesconfig_fawkes_Configuration_set_string01(lua_State* tolua_S)
1253 {
1254  tolua_Error tolua_err;
1255  if (
1256  !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1257  !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1258  !tolua_isstring(tolua_S,3,0,&tolua_err) ||
1259  !tolua_isnoobj(tolua_S,4,&tolua_err)
1260  )
1261  goto tolua_lerror;
1262  else
1263  {
1264  fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1265  const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
1266  const char* s = ((const char*) tolua_tostring(tolua_S,3,0));
1267 #ifndef TOLUA_RELEASE
1268  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_string'",NULL);
1269 #endif
1270  {
1271  self->set_string(path,s);
1272  }
1273  }
1274  return 0;
1275 tolua_lerror:
1276  return tolua_fawkesconfig_fawkes_Configuration_set_string00(tolua_S);
1277 }
1278 #endif //#ifndef TOLUA_DISABLE
1279 
1280 /* method: erase of class fawkes::Configuration */
1281 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_erase00
1282 static int tolua_fawkesconfig_fawkes_Configuration_erase00(lua_State* tolua_S)
1283 {
1284 #ifndef TOLUA_RELEASE
1285  tolua_Error tolua_err;
1286  if (
1287  !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1288  !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1289  !tolua_isnoobj(tolua_S,3,&tolua_err)
1290  )
1291  goto tolua_lerror;
1292  else
1293 #endif
1294  {
1295  fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1296  const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
1297 #ifndef TOLUA_RELEASE
1298  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'erase'",NULL);
1299 #endif
1300  {
1301  self->erase(path);
1302  }
1303  }
1304  return 0;
1305 #ifndef TOLUA_RELEASE
1306  tolua_lerror:
1307  tolua_error(tolua_S,"#ferror in function 'erase'.",&tolua_err);
1308  return 0;
1309 #endif
1310 }
1311 #endif //#ifndef TOLUA_DISABLE
1312 
1313 /* method: set_default_float of class fawkes::Configuration */
1314 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_set_default_float00
1315 static int tolua_fawkesconfig_fawkes_Configuration_set_default_float00(lua_State* tolua_S)
1316 {
1317 #ifndef TOLUA_RELEASE
1318  tolua_Error tolua_err;
1319  if (
1320  !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1321  !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1322  !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
1323  !tolua_isnoobj(tolua_S,4,&tolua_err)
1324  )
1325  goto tolua_lerror;
1326  else
1327 #endif
1328  {
1329  fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1330  const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
1331  float f = ((float) tolua_tonumber(tolua_S,3,0));
1332 #ifndef TOLUA_RELEASE
1333  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_default_float'",NULL);
1334 #endif
1335  {
1336  self->set_default_float(path,f);
1337  }
1338  }
1339  return 0;
1340 #ifndef TOLUA_RELEASE
1341  tolua_lerror:
1342  tolua_error(tolua_S,"#ferror in function 'set_default_float'.",&tolua_err);
1343  return 0;
1344 #endif
1345 }
1346 #endif //#ifndef TOLUA_DISABLE
1347 
1348 /* method: set_default_uint of class fawkes::Configuration */
1349 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_set_default_uint00
1350 static int tolua_fawkesconfig_fawkes_Configuration_set_default_uint00(lua_State* tolua_S)
1351 {
1352 #ifndef TOLUA_RELEASE
1353  tolua_Error tolua_err;
1354  if (
1355  !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1356  !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1357  !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
1358  !tolua_isnoobj(tolua_S,4,&tolua_err)
1359  )
1360  goto tolua_lerror;
1361  else
1362 #endif
1363  {
1364  fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1365  const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
1366  unsigned int uint = ((unsigned int) tolua_tonumber(tolua_S,3,0));
1367 #ifndef TOLUA_RELEASE
1368  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_default_uint'",NULL);
1369 #endif
1370  {
1371  self->set_default_uint(path,uint);
1372  }
1373  }
1374  return 0;
1375 #ifndef TOLUA_RELEASE
1376  tolua_lerror:
1377  tolua_error(tolua_S,"#ferror in function 'set_default_uint'.",&tolua_err);
1378  return 0;
1379 #endif
1380 }
1381 #endif //#ifndef TOLUA_DISABLE
1382 
1383 /* method: set_default_int of class fawkes::Configuration */
1384 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_set_default_int00
1385 static int tolua_fawkesconfig_fawkes_Configuration_set_default_int00(lua_State* tolua_S)
1386 {
1387 #ifndef TOLUA_RELEASE
1388  tolua_Error tolua_err;
1389  if (
1390  !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1391  !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1392  !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
1393  !tolua_isnoobj(tolua_S,4,&tolua_err)
1394  )
1395  goto tolua_lerror;
1396  else
1397 #endif
1398  {
1399  fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1400  const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
1401  int i = ((int) tolua_tonumber(tolua_S,3,0));
1402 #ifndef TOLUA_RELEASE
1403  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_default_int'",NULL);
1404 #endif
1405  {
1406  self->set_default_int(path,i);
1407  }
1408  }
1409  return 0;
1410 #ifndef TOLUA_RELEASE
1411  tolua_lerror:
1412  tolua_error(tolua_S,"#ferror in function 'set_default_int'.",&tolua_err);
1413  return 0;
1414 #endif
1415 }
1416 #endif //#ifndef TOLUA_DISABLE
1417 
1418 /* method: set_default_bool of class fawkes::Configuration */
1419 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_set_default_bool00
1420 static int tolua_fawkesconfig_fawkes_Configuration_set_default_bool00(lua_State* tolua_S)
1421 {
1422 #ifndef TOLUA_RELEASE
1423  tolua_Error tolua_err;
1424  if (
1425  !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1426  !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1427  !tolua_isboolean(tolua_S,3,0,&tolua_err) ||
1428  !tolua_isnoobj(tolua_S,4,&tolua_err)
1429  )
1430  goto tolua_lerror;
1431  else
1432 #endif
1433  {
1434  fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1435  const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
1436  bool b = ((bool) tolua_toboolean(tolua_S,3,0));
1437 #ifndef TOLUA_RELEASE
1438  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_default_bool'",NULL);
1439 #endif
1440  {
1441  self->set_default_bool(path,b);
1442  }
1443  }
1444  return 0;
1445 #ifndef TOLUA_RELEASE
1446  tolua_lerror:
1447  tolua_error(tolua_S,"#ferror in function 'set_default_bool'.",&tolua_err);
1448  return 0;
1449 #endif
1450 }
1451 #endif //#ifndef TOLUA_DISABLE
1452 
1453 /* method: set_default_string of class fawkes::Configuration */
1454 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_set_default_string00
1455 static int tolua_fawkesconfig_fawkes_Configuration_set_default_string00(lua_State* tolua_S)
1456 {
1457 #ifndef TOLUA_RELEASE
1458  tolua_Error tolua_err;
1459  if (
1460  !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1461  !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1462  !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
1463  !tolua_isnoobj(tolua_S,4,&tolua_err)
1464  )
1465  goto tolua_lerror;
1466  else
1467 #endif
1468  {
1469  fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1470  const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
1471  std::string s = ((std::string) tolua_tocppstring(tolua_S,3,0));
1472 #ifndef TOLUA_RELEASE
1473  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_default_string'",NULL);
1474 #endif
1475  {
1476  self->set_default_string(path,s);
1477  }
1478  }
1479  return 0;
1480 #ifndef TOLUA_RELEASE
1481  tolua_lerror:
1482  tolua_error(tolua_S,"#ferror in function 'set_default_string'.",&tolua_err);
1483  return 0;
1484 #endif
1485 }
1486 #endif //#ifndef TOLUA_DISABLE
1487 
1488 /* method: set_default_string of class fawkes::Configuration */
1489 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_set_default_string01
1490 static int tolua_fawkesconfig_fawkes_Configuration_set_default_string01(lua_State* tolua_S)
1491 {
1492  tolua_Error tolua_err;
1493  if (
1494  !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1495  !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1496  !tolua_isstring(tolua_S,3,0,&tolua_err) ||
1497  !tolua_isnoobj(tolua_S,4,&tolua_err)
1498  )
1499  goto tolua_lerror;
1500  else
1501  {
1502  fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1503  const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
1504  const char* s = ((const char*) tolua_tostring(tolua_S,3,0));
1505 #ifndef TOLUA_RELEASE
1506  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_default_string'",NULL);
1507 #endif
1508  {
1509  self->set_default_string(path,s);
1510  }
1511  }
1512  return 0;
1513 tolua_lerror:
1514  return tolua_fawkesconfig_fawkes_Configuration_set_default_string00(tolua_S);
1515 }
1516 #endif //#ifndef TOLUA_DISABLE
1517 
1518 /* method: erase_default of class fawkes::Configuration */
1519 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_erase_default00
1520 static int tolua_fawkesconfig_fawkes_Configuration_erase_default00(lua_State* tolua_S)
1521 {
1522 #ifndef TOLUA_RELEASE
1523  tolua_Error tolua_err;
1524  if (
1525  !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1526  !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1527  !tolua_isnoobj(tolua_S,3,&tolua_err)
1528  )
1529  goto tolua_lerror;
1530  else
1531 #endif
1532  {
1533  fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1534  const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
1535 #ifndef TOLUA_RELEASE
1536  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'erase_default'",NULL);
1537 #endif
1538  {
1539  self->erase_default(path);
1540  }
1541  }
1542  return 0;
1543 #ifndef TOLUA_RELEASE
1544  tolua_lerror:
1545  tolua_error(tolua_S,"#ferror in function 'erase_default'.",&tolua_err);
1546  return 0;
1547 #endif
1548 }
1549 #endif //#ifndef TOLUA_DISABLE
1550 
1551 /* method: iterator of class fawkes::Configuration */
1552 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_iterator00
1553 static int tolua_fawkesconfig_fawkes_Configuration_iterator00(lua_State* tolua_S)
1554 {
1555 #ifndef TOLUA_RELEASE
1556  tolua_Error tolua_err;
1557  if (
1558  !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1559  !tolua_isnoobj(tolua_S,2,&tolua_err)
1560  )
1561  goto tolua_lerror;
1562  else
1563 #endif
1564  {
1565  fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1566 #ifndef TOLUA_RELEASE
1567  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'iterator'",NULL);
1568 #endif
1569  {
1571  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Configuration::ValueIterator");
1572  }
1573  }
1574  return 1;
1575 #ifndef TOLUA_RELEASE
1576  tolua_lerror:
1577  tolua_error(tolua_S,"#ferror in function 'iterator'.",&tolua_err);
1578  return 0;
1579 #endif
1580 }
1581 #endif //#ifndef TOLUA_DISABLE
1582 
1583 /* method: search of class fawkes::Configuration */
1584 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_search00
1585 static int tolua_fawkesconfig_fawkes_Configuration_search00(lua_State* tolua_S)
1586 {
1587 #ifndef TOLUA_RELEASE
1588  tolua_Error tolua_err;
1589  if (
1590  !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1591  !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1592  !tolua_isnoobj(tolua_S,3,&tolua_err)
1593  )
1594  goto tolua_lerror;
1595  else
1596 #endif
1597  {
1598  fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1599  const char* path = ((const char*) tolua_tostring(tolua_S,2,0));
1600 #ifndef TOLUA_RELEASE
1601  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'search'",NULL);
1602 #endif
1603  {
1605  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Configuration::ValueIterator");
1606  }
1607  }
1608  return 1;
1609 #ifndef TOLUA_RELEASE
1610  tolua_lerror:
1611  tolua_error(tolua_S,"#ferror in function 'search'.",&tolua_err);
1612  return 0;
1613 #endif
1614 }
1615 #endif //#ifndef TOLUA_DISABLE
1616 
1617 /* method: lock of class fawkes::Configuration */
1618 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_lock00
1619 static int tolua_fawkesconfig_fawkes_Configuration_lock00(lua_State* tolua_S)
1620 {
1621 #ifndef TOLUA_RELEASE
1622  tolua_Error tolua_err;
1623  if (
1624  !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1625  !tolua_isnoobj(tolua_S,2,&tolua_err)
1626  )
1627  goto tolua_lerror;
1628  else
1629 #endif
1630  {
1631  fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1632 #ifndef TOLUA_RELEASE
1633  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'lock'",NULL);
1634 #endif
1635  {
1636  self->lock();
1637  }
1638  }
1639  return 0;
1640 #ifndef TOLUA_RELEASE
1641  tolua_lerror:
1642  tolua_error(tolua_S,"#ferror in function 'lock'.",&tolua_err);
1643  return 0;
1644 #endif
1645 }
1646 #endif //#ifndef TOLUA_DISABLE
1647 
1648 /* method: try_lock of class fawkes::Configuration */
1649 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_try_lock00
1650 static int tolua_fawkesconfig_fawkes_Configuration_try_lock00(lua_State* tolua_S)
1651 {
1652 #ifndef TOLUA_RELEASE
1653  tolua_Error tolua_err;
1654  if (
1655  !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1656  !tolua_isnoobj(tolua_S,2,&tolua_err)
1657  )
1658  goto tolua_lerror;
1659  else
1660 #endif
1661  {
1662  fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1663 #ifndef TOLUA_RELEASE
1664  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'try_lock'",NULL);
1665 #endif
1666  {
1667  bool tolua_ret = (bool) self->try_lock();
1668  tolua_pushboolean(tolua_S,(bool)tolua_ret);
1669  }
1670  }
1671  return 1;
1672 #ifndef TOLUA_RELEASE
1673  tolua_lerror:
1674  tolua_error(tolua_S,"#ferror in function 'try_lock'.",&tolua_err);
1675  return 0;
1676 #endif
1677 }
1678 #endif //#ifndef TOLUA_DISABLE
1679 
1680 /* method: unlock of class fawkes::Configuration */
1681 #ifndef TOLUA_DISABLE_tolua_fawkesconfig_fawkes_Configuration_unlock00
1682 static int tolua_fawkesconfig_fawkes_Configuration_unlock00(lua_State* tolua_S)
1683 {
1684 #ifndef TOLUA_RELEASE
1685  tolua_Error tolua_err;
1686  if (
1687  !tolua_isusertype(tolua_S,1,"fawkes::Configuration",0,&tolua_err) ||
1688  !tolua_isnoobj(tolua_S,2,&tolua_err)
1689  )
1690  goto tolua_lerror;
1691  else
1692 #endif
1693  {
1694  fawkes::Configuration* self = (fawkes::Configuration*) tolua_tousertype(tolua_S,1,0);
1695 #ifndef TOLUA_RELEASE
1696  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'unlock'",NULL);
1697 #endif
1698  {
1699  self->unlock();
1700  }
1701  }
1702  return 0;
1703 #ifndef TOLUA_RELEASE
1704  tolua_lerror:
1705  tolua_error(tolua_S,"#ferror in function 'unlock'.",&tolua_err);
1706  return 0;
1707 #endif
1708 }
1709 #endif //#ifndef TOLUA_DISABLE
1710 
1711 /* Open function */
1712 TOLUA_API int tolua_fawkesconfig_open (lua_State* tolua_S)
1713 {
1714  tolua_open(tolua_S);
1715  tolua_reg_types(tolua_S);
1716  tolua_module(tolua_S,NULL,0);
1717  tolua_beginmodule(tolua_S,NULL);
1718  tolua_module(tolua_S,"fawkes",0);
1719  tolua_beginmodule(tolua_S,"fawkes");
1720  tolua_cclass(tolua_S,"Configuration","fawkes::Configuration","",NULL);
1721  tolua_beginmodule(tolua_S,"Configuration");
1722  #ifdef __cplusplus
1723  tolua_cclass(tolua_S,"ValueIterator","fawkes::Configuration::ValueIterator","",tolua_collect_fawkes__Configuration__ValueIterator);
1724  #else
1725  tolua_cclass(tolua_S,"ValueIterator","fawkes::Configuration::ValueIterator","",NULL);
1726  #endif
1727  tolua_beginmodule(tolua_S,"ValueIterator");
1728  tolua_function(tolua_S,"delete",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_delete00);
1729  tolua_function(tolua_S,"next",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_next00);
1730  tolua_function(tolua_S,"valid",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_valid00);
1731  tolua_function(tolua_S,"path",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_path00);
1732  tolua_function(tolua_S,"type",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_type00);
1733  tolua_function(tolua_S,"is_float",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_is_float00);
1734  tolua_function(tolua_S,"is_uint",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_is_uint00);
1735  tolua_function(tolua_S,"is_int",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_is_int00);
1736  tolua_function(tolua_S,"is_bool",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_is_bool00);
1737  tolua_function(tolua_S,"is_string",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_is_string00);
1738  tolua_function(tolua_S,"get_float",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_get_float00);
1739  tolua_function(tolua_S,"get_uint",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_get_uint00);
1740  tolua_function(tolua_S,"get_int",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_get_int00);
1741  tolua_function(tolua_S,"get_bool",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_get_bool00);
1742  tolua_function(tolua_S,"get_string",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_get_string00);
1743  tolua_function(tolua_S,"is_default",tolua_fawkesconfig_fawkes_Configuration_ValueIterator_is_default00);
1744  tolua_endmodule(tolua_S);
1745  tolua_function(tolua_S,"exists",tolua_fawkesconfig_fawkes_Configuration_exists00);
1746  tolua_function(tolua_S,"is_float",tolua_fawkesconfig_fawkes_Configuration_is_float00);
1747  tolua_function(tolua_S,"is_uint",tolua_fawkesconfig_fawkes_Configuration_is_uint00);
1748  tolua_function(tolua_S,"is_int",tolua_fawkesconfig_fawkes_Configuration_is_int00);
1749  tolua_function(tolua_S,"is_bool",tolua_fawkesconfig_fawkes_Configuration_is_bool00);
1750  tolua_function(tolua_S,"is_string",tolua_fawkesconfig_fawkes_Configuration_is_string00);
1751  tolua_function(tolua_S,"is_default",tolua_fawkesconfig_fawkes_Configuration_is_default00);
1752  tolua_function(tolua_S,"get_float",tolua_fawkesconfig_fawkes_Configuration_get_float00);
1753  tolua_function(tolua_S,"get_uint",tolua_fawkesconfig_fawkes_Configuration_get_uint00);
1754  tolua_function(tolua_S,"get_int",tolua_fawkesconfig_fawkes_Configuration_get_int00);
1755  tolua_function(tolua_S,"get_bool",tolua_fawkesconfig_fawkes_Configuration_get_bool00);
1756  tolua_function(tolua_S,"get_string",tolua_fawkesconfig_fawkes_Configuration_get_string00);
1757  tolua_function(tolua_S,"get_value",tolua_fawkesconfig_fawkes_Configuration_get_value00);
1758  tolua_function(tolua_S,"get_float_or_default",tolua_fawkesconfig_fawkes_Configuration_get_float_or_default00);
1759  tolua_function(tolua_S,"get_int_or_default",tolua_fawkesconfig_fawkes_Configuration_get_int_or_default00);
1760  tolua_function(tolua_S,"set_float",tolua_fawkesconfig_fawkes_Configuration_set_float00);
1761  tolua_function(tolua_S,"set_uint",tolua_fawkesconfig_fawkes_Configuration_set_uint00);
1762  tolua_function(tolua_S,"set_int",tolua_fawkesconfig_fawkes_Configuration_set_int00);
1763  tolua_function(tolua_S,"set_bool",tolua_fawkesconfig_fawkes_Configuration_set_bool00);
1764  tolua_function(tolua_S,"set_string",tolua_fawkesconfig_fawkes_Configuration_set_string00);
1765  tolua_function(tolua_S,"set_string",tolua_fawkesconfig_fawkes_Configuration_set_string01);
1766  tolua_function(tolua_S,"erase",tolua_fawkesconfig_fawkes_Configuration_erase00);
1767  tolua_function(tolua_S,"set_default_float",tolua_fawkesconfig_fawkes_Configuration_set_default_float00);
1768  tolua_function(tolua_S,"set_default_uint",tolua_fawkesconfig_fawkes_Configuration_set_default_uint00);
1769  tolua_function(tolua_S,"set_default_int",tolua_fawkesconfig_fawkes_Configuration_set_default_int00);
1770  tolua_function(tolua_S,"set_default_bool",tolua_fawkesconfig_fawkes_Configuration_set_default_bool00);
1771  tolua_function(tolua_S,"set_default_string",tolua_fawkesconfig_fawkes_Configuration_set_default_string00);
1772  tolua_function(tolua_S,"set_default_string",tolua_fawkesconfig_fawkes_Configuration_set_default_string01);
1773  tolua_function(tolua_S,"erase_default",tolua_fawkesconfig_fawkes_Configuration_erase_default00);
1774  tolua_function(tolua_S,"iterator",tolua_fawkesconfig_fawkes_Configuration_iterator00);
1775  tolua_function(tolua_S,"search",tolua_fawkesconfig_fawkes_Configuration_search00);
1776  tolua_function(tolua_S,"lock",tolua_fawkesconfig_fawkes_Configuration_lock00);
1777  tolua_function(tolua_S,"try_lock",tolua_fawkesconfig_fawkes_Configuration_try_lock00);
1778  tolua_function(tolua_S,"unlock",tolua_fawkesconfig_fawkes_Configuration_unlock00);
1779  tolua_endmodule(tolua_S);
1780  tolua_endmodule(tolua_S);
1781  tolua_endmodule(tolua_S);
1782  return 1;
1783 }
1784 
1785 
1786 extern "C" {
1787 #if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501
1788  TOLUA_API int luaopen_fawkesconfig (lua_State* tolua_S) {
1789  return tolua_fawkesconfig_open(tolua_S);
1790 };
1791 #endif
1792 }
1793 
1794 
Iterator interface to iterate over config values.
Definition: config.h:75
Interface for configuration handling.
Definition: config.h:68