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