Fawkes API  Fawkes Development Version
 All Classes Namespaces Functions Variables Typedefs Enumerations Enumerator Friends Groups Pages
fawkesutils_tolua.cpp
1 /*
2 ** Lua binding: fawkesutils
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_fawkesutils_open (lua_State* tolua_S);
28 
29 #include <utils/graph/rcsoft_map_node.h>
30 #include <string>
31 #include <vector>
32 using namespace std;
33 #include <utils/graph/rcsoft_map_node.h>
34 #include <utils/graph/rcsoft_map_graph.h>
35 #include <vector>
36 #include <string>
37 using namespace std;
38 using namespace fawkes;
39 #include <utils/kalman/kalman_1d.h>
40 #include <utils/time/time.h>
41 #include <utils/time/clock.h>
42 
43 /* function to release collected object via destructor */
44 #ifdef __cplusplus
45 
46 static int tolua_collect_fawkes__KalmanFilter1D (lua_State* tolua_S)
47 {
48  fawkes::KalmanFilter1D* self = (fawkes::KalmanFilter1D*) tolua_tousertype(tolua_S,1,0);
49  Mtolua_delete(self);
50  return 0;
51 }
52 
53 static int tolua_collect_vector_string_ (lua_State* tolua_S)
54 {
55  vector<string>* self = (vector<string>*) tolua_tousertype(tolua_S,1,0);
56  Mtolua_delete(self);
57  return 0;
58 }
59 
60 static int tolua_collect_fawkes__RCSoftMapNode (lua_State* tolua_S)
61 {
62  fawkes::RCSoftMapNode* self = (fawkes::RCSoftMapNode*) tolua_tousertype(tolua_S,1,0);
63  Mtolua_delete(self);
64  return 0;
65 }
66 
67 static int tolua_collect_fawkes__RCSoftMapGraph (lua_State* tolua_S)
68 {
69  fawkes::RCSoftMapGraph* self = (fawkes::RCSoftMapGraph*) tolua_tousertype(tolua_S,1,0);
70  Mtolua_delete(self);
71  return 0;
72 }
73 
74 static int tolua_collect_fawkes__Time (lua_State* tolua_S)
75 {
76  fawkes::Time* self = (fawkes::Time*) tolua_tousertype(tolua_S,1,0);
77  Mtolua_delete(self);
78  return 0;
79 }
80 
81 static int tolua_collect_vector_fawkes__RCSoftMapNode_ (lua_State* tolua_S)
82 {
83  vector<fawkes::RCSoftMapNode>* self = (vector<fawkes::RCSoftMapNode>*) tolua_tousertype(tolua_S,1,0);
84  Mtolua_delete(self);
85  return 0;
86 }
87 #endif
88 
89 
90 /* function to register type */
91 static void tolua_reg_types (lua_State* tolua_S)
92 {
93  tolua_usertype(tolua_S,"fawkes::KalmanFilter1D");
94  tolua_usertype(tolua_S,"timeval");
95  tolua_usertype(tolua_S,"vector<string>");
96  tolua_usertype(tolua_S,"fawkes::Clock");
97  tolua_usertype(tolua_S,"fawkes::RCSoftMapNode");
98  tolua_usertype(tolua_S,"fawkes::RCSoftMapGraph");
99  tolua_usertype(tolua_S,"fawkes::Time");
100  tolua_usertype(tolua_S,"vector<fawkes::RCSoftMapNode>");
101 }
102 
103 /* method: clear of class vector<string> */
104 #ifndef TOLUA_DISABLE_tolua_fawkesutils_vector_string__clear00
105 static int tolua_fawkesutils_vector_string__clear00(lua_State* tolua_S)
106 {
107 #ifndef TOLUA_RELEASE
108  tolua_Error tolua_err;
109  if (
110  !tolua_isusertype(tolua_S,1,"vector<string>",0,&tolua_err) ||
111  !tolua_isnoobj(tolua_S,2,&tolua_err)
112  )
113  goto tolua_lerror;
114  else
115 #endif
116  {
117  vector<string>* self = (vector<string>*) tolua_tousertype(tolua_S,1,0);
118 #ifndef TOLUA_RELEASE
119  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'clear'", NULL);
120 #endif
121  {
122  self->clear();
123  }
124  }
125  return 0;
126 #ifndef TOLUA_RELEASE
127  tolua_lerror:
128  tolua_error(tolua_S,"#ferror in function 'clear'.",&tolua_err);
129  return 0;
130 #endif
131 }
132 #endif //#ifndef TOLUA_DISABLE
133 
134 /* method: size of class vector<string> */
135 #ifndef TOLUA_DISABLE_tolua_fawkesutils_vector_string__size00
136 static int tolua_fawkesutils_vector_string__size00(lua_State* tolua_S)
137 {
138 #ifndef TOLUA_RELEASE
139  tolua_Error tolua_err;
140  if (
141  !tolua_isusertype(tolua_S,1,"const vector<string>",0,&tolua_err) ||
142  !tolua_isnoobj(tolua_S,2,&tolua_err)
143  )
144  goto tolua_lerror;
145  else
146 #endif
147  {
148  const vector<string>* self = (const vector<string>*) tolua_tousertype(tolua_S,1,0);
149 #ifndef TOLUA_RELEASE
150  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'size'", NULL);
151 #endif
152  {
153  int tolua_ret = (int) self->size();
154  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
155  }
156  }
157  return 1;
158 #ifndef TOLUA_RELEASE
159  tolua_lerror:
160  tolua_error(tolua_S,"#ferror in function 'size'.",&tolua_err);
161  return 0;
162 #endif
163 }
164 #endif //#ifndef TOLUA_DISABLE
165 
166 /* method: operator[] of class vector<string> */
167 #ifndef TOLUA_DISABLE_tolua_fawkesutils_vector_string___geti00
168 static int tolua_fawkesutils_vector_string___geti00(lua_State* tolua_S)
169 {
170 #ifndef TOLUA_RELEASE
171  tolua_Error tolua_err;
172  if (
173  !tolua_isusertype(tolua_S,1,"const vector<string>",0,&tolua_err) ||
174  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
175  !tolua_isnoobj(tolua_S,3,&tolua_err)
176  )
177  goto tolua_lerror;
178  else
179 #endif
180  {
181  const vector<string>* self = (const vector<string>*) tolua_tousertype(tolua_S,1,0);
182  int index = ((int) tolua_tonumber(tolua_S,2,0));
183 #ifndef TOLUA_RELEASE
184  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'", NULL);
185 #endif
186  {
187  const string tolua_ret = (const string) self->operator[](index);
188  tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
189  }
190  }
191  return 1;
192 #ifndef TOLUA_RELEASE
193  tolua_lerror:
194  tolua_error(tolua_S,"#ferror in function '.geti'.",&tolua_err);
195  return 0;
196 #endif
197 }
198 #endif //#ifndef TOLUA_DISABLE
199 
200 /* method: operator&[] of class vector<string> */
201 #ifndef TOLUA_DISABLE_tolua_fawkesutils_vector_string___seti00
202 static int tolua_fawkesutils_vector_string___seti00(lua_State* tolua_S)
203 {
204 #ifndef TOLUA_RELEASE
205  tolua_Error tolua_err;
206  if (
207  !tolua_isusertype(tolua_S,1,"vector<string>",0,&tolua_err) ||
208  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
209  !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
210  !tolua_isnoobj(tolua_S,4,&tolua_err)
211  )
212  goto tolua_lerror;
213  else
214 #endif
215  {
216  vector<string>* self = (vector<string>*) tolua_tousertype(tolua_S,1,0);
217  int index = ((int) tolua_tonumber(tolua_S,2,0));
218  string tolua_value = ((string) tolua_tocppstring(tolua_S,3,0));
219 #ifndef TOLUA_RELEASE
220  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator&[]'", NULL);
221 #endif
222  self->operator[](index) = tolua_value;
223  }
224  return 0;
225 #ifndef TOLUA_RELEASE
226  tolua_lerror:
227  tolua_error(tolua_S,"#ferror in function '.seti'.",&tolua_err);
228  return 0;
229 #endif
230 }
231 #endif //#ifndef TOLUA_DISABLE
232 
233 /* method: operator[] of class vector<string> */
234 #ifndef TOLUA_DISABLE_tolua_fawkesutils_vector_string___geti01
235 static int tolua_fawkesutils_vector_string___geti01(lua_State* tolua_S)
236 {
237  tolua_Error tolua_err;
238  if (
239  !tolua_isusertype(tolua_S,1,"vector<string>",0,&tolua_err) ||
240  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
241  !tolua_isnoobj(tolua_S,3,&tolua_err)
242  )
243  goto tolua_lerror;
244  else
245  {
246  vector<string>* self = (vector<string>*) tolua_tousertype(tolua_S,1,0);
247  int index = ((int) tolua_tonumber(tolua_S,2,0));
248 #ifndef TOLUA_RELEASE
249  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'", NULL);
250 #endif
251  {
252  string tolua_ret = (string) self->operator[](index);
253  tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
254  }
255  }
256  return 1;
257 tolua_lerror:
258  return tolua_fawkesutils_vector_string___geti00(tolua_S);
259 }
260 #endif //#ifndef TOLUA_DISABLE
261 
262 /* method: push_back of class vector<string> */
263 #ifndef TOLUA_DISABLE_tolua_fawkesutils_vector_string__push_back00
264 static int tolua_fawkesutils_vector_string__push_back00(lua_State* tolua_S)
265 {
266 #ifndef TOLUA_RELEASE
267  tolua_Error tolua_err;
268  if (
269  !tolua_isusertype(tolua_S,1,"vector<string>",0,&tolua_err) ||
270  !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
271  !tolua_isnoobj(tolua_S,3,&tolua_err)
272  )
273  goto tolua_lerror;
274  else
275 #endif
276  {
277  vector<string>* self = (vector<string>*) tolua_tousertype(tolua_S,1,0);
278  string val = ((string) tolua_tocppstring(tolua_S,2,0));
279 #ifndef TOLUA_RELEASE
280  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'push_back'", NULL);
281 #endif
282  {
283  self->push_back(val);
284  }
285  }
286  return 0;
287 #ifndef TOLUA_RELEASE
288  tolua_lerror:
289  tolua_error(tolua_S,"#ferror in function 'push_back'.",&tolua_err);
290  return 0;
291 #endif
292 }
293 #endif //#ifndef TOLUA_DISABLE
294 
295 /* method: new of class vector<string> */
296 #ifndef TOLUA_DISABLE_tolua_fawkesutils_vector_string__new00
297 static int tolua_fawkesutils_vector_string__new00(lua_State* tolua_S)
298 {
299 #ifndef TOLUA_RELEASE
300  tolua_Error tolua_err;
301  if (
302  !tolua_isusertable(tolua_S,1,"vector<string>",0,&tolua_err) ||
303  !tolua_isnoobj(tolua_S,2,&tolua_err)
304  )
305  goto tolua_lerror;
306  else
307 #endif
308  {
309  {
310  vector<string>* tolua_ret = (vector<string>*) Mtolua_new((vector<string>)());
311  tolua_pushusertype(tolua_S,(void*)tolua_ret,"vector<string>");
312  }
313  }
314  return 1;
315 #ifndef TOLUA_RELEASE
316  tolua_lerror:
317  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
318  return 0;
319 #endif
320 }
321 #endif //#ifndef TOLUA_DISABLE
322 
323 /* method: new_local of class vector<string> */
324 #ifndef TOLUA_DISABLE_tolua_fawkesutils_vector_string__new00_local
325 static int tolua_fawkesutils_vector_string__new00_local(lua_State* tolua_S)
326 {
327 #ifndef TOLUA_RELEASE
328  tolua_Error tolua_err;
329  if (
330  !tolua_isusertable(tolua_S,1,"vector<string>",0,&tolua_err) ||
331  !tolua_isnoobj(tolua_S,2,&tolua_err)
332  )
333  goto tolua_lerror;
334  else
335 #endif
336  {
337  {
338  vector<string>* tolua_ret = (vector<string>*) Mtolua_new((vector<string>)());
339  tolua_pushusertype(tolua_S,(void*)tolua_ret,"vector<string>");
340  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
341  }
342  }
343  return 1;
344 #ifndef TOLUA_RELEASE
345  tolua_lerror:
346  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
347  return 0;
348 #endif
349 }
350 #endif //#ifndef TOLUA_DISABLE
351 
352 /* method: delete of class vector<string> */
353 #ifndef TOLUA_DISABLE_tolua_fawkesutils_vector_string__delete00
354 static int tolua_fawkesutils_vector_string__delete00(lua_State* tolua_S)
355 {
356 #ifndef TOLUA_RELEASE
357  tolua_Error tolua_err;
358  if (
359  !tolua_isusertype(tolua_S,1,"vector<string>",0,&tolua_err) ||
360  !tolua_isnoobj(tolua_S,2,&tolua_err)
361  )
362  goto tolua_lerror;
363  else
364 #endif
365  {
366  vector<string>* self = (vector<string>*) tolua_tousertype(tolua_S,1,0);
367 #ifndef TOLUA_RELEASE
368  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
369 #endif
370  Mtolua_delete(self);
371  }
372  return 0;
373 #ifndef TOLUA_RELEASE
374  tolua_lerror:
375  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
376  return 0;
377 #endif
378 }
379 #endif //#ifndef TOLUA_DISABLE
380 
381 /* method: clear of class vector<fawkes::RCSoftMapNode> */
382 #ifndef TOLUA_DISABLE_tolua_fawkesutils_vector_fawkes__RCSoftMapNode__clear00
383 static int tolua_fawkesutils_vector_fawkes__RCSoftMapNode__clear00(lua_State* tolua_S)
384 {
385 #ifndef TOLUA_RELEASE
386  tolua_Error tolua_err;
387  if (
388  !tolua_isusertype(tolua_S,1,"vector<fawkes::RCSoftMapNode>",0,&tolua_err) ||
389  !tolua_isnoobj(tolua_S,2,&tolua_err)
390  )
391  goto tolua_lerror;
392  else
393 #endif
394  {
395  vector<fawkes::RCSoftMapNode>* self = (vector<fawkes::RCSoftMapNode>*) tolua_tousertype(tolua_S,1,0);
396 #ifndef TOLUA_RELEASE
397  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'clear'", NULL);
398 #endif
399  {
400  self->clear();
401  }
402  }
403  return 0;
404 #ifndef TOLUA_RELEASE
405  tolua_lerror:
406  tolua_error(tolua_S,"#ferror in function 'clear'.",&tolua_err);
407  return 0;
408 #endif
409 }
410 #endif //#ifndef TOLUA_DISABLE
411 
412 /* method: size of class vector<fawkes::RCSoftMapNode> */
413 #ifndef TOLUA_DISABLE_tolua_fawkesutils_vector_fawkes__RCSoftMapNode__size00
414 static int tolua_fawkesutils_vector_fawkes__RCSoftMapNode__size00(lua_State* tolua_S)
415 {
416 #ifndef TOLUA_RELEASE
417  tolua_Error tolua_err;
418  if (
419  !tolua_isusertype(tolua_S,1,"const vector<fawkes::RCSoftMapNode>",0,&tolua_err) ||
420  !tolua_isnoobj(tolua_S,2,&tolua_err)
421  )
422  goto tolua_lerror;
423  else
424 #endif
425  {
426  const vector<fawkes::RCSoftMapNode>* self = (const vector<fawkes::RCSoftMapNode>*) tolua_tousertype(tolua_S,1,0);
427 #ifndef TOLUA_RELEASE
428  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'size'", NULL);
429 #endif
430  {
431  int tolua_ret = (int) self->size();
432  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
433  }
434  }
435  return 1;
436 #ifndef TOLUA_RELEASE
437  tolua_lerror:
438  tolua_error(tolua_S,"#ferror in function 'size'.",&tolua_err);
439  return 0;
440 #endif
441 }
442 #endif //#ifndef TOLUA_DISABLE
443 
444 /* method: operator[] of class vector<fawkes::RCSoftMapNode> */
445 #ifndef TOLUA_DISABLE_tolua_fawkesutils_vector_fawkes__RCSoftMapNode___geti00
446 static int tolua_fawkesutils_vector_fawkes__RCSoftMapNode___geti00(lua_State* tolua_S)
447 {
448 #ifndef TOLUA_RELEASE
449  tolua_Error tolua_err;
450  if (
451  !tolua_isusertype(tolua_S,1,"const vector<fawkes::RCSoftMapNode>",0,&tolua_err) ||
452  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
453  !tolua_isnoobj(tolua_S,3,&tolua_err)
454  )
455  goto tolua_lerror;
456  else
457 #endif
458  {
459  const vector<fawkes::RCSoftMapNode>* self = (const vector<fawkes::RCSoftMapNode>*) tolua_tousertype(tolua_S,1,0);
460  int index = ((int) tolua_tonumber(tolua_S,2,0));
461 #ifndef TOLUA_RELEASE
462  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'", NULL);
463 #endif
464  {
465  const fawkes::RCSoftMapNode tolua_ret = (const fawkes::RCSoftMapNode) self->operator[](index);
466  {
467 #ifdef __cplusplus
468  void* tolua_obj = Mtolua_new((fawkes::RCSoftMapNode)(tolua_ret));
469  tolua_pushusertype(tolua_S,tolua_obj,"const fawkes::RCSoftMapNode");
470  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
471 #else
472  void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(const fawkes::RCSoftMapNode));
473  tolua_pushusertype(tolua_S,tolua_obj,"const fawkes::RCSoftMapNode");
474  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
475 #endif
476  }
477  }
478  }
479  return 1;
480 #ifndef TOLUA_RELEASE
481  tolua_lerror:
482  tolua_error(tolua_S,"#ferror in function '.geti'.",&tolua_err);
483  return 0;
484 #endif
485 }
486 #endif //#ifndef TOLUA_DISABLE
487 
488 /* method: operator&[] of class vector<fawkes::RCSoftMapNode> */
489 #ifndef TOLUA_DISABLE_tolua_fawkesutils_vector_fawkes__RCSoftMapNode___seti00
490 static int tolua_fawkesutils_vector_fawkes__RCSoftMapNode___seti00(lua_State* tolua_S)
491 {
492 #ifndef TOLUA_RELEASE
493  tolua_Error tolua_err;
494  if (
495  !tolua_isusertype(tolua_S,1,"vector<fawkes::RCSoftMapNode>",0,&tolua_err) ||
496  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
497  (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"fawkes::RCSoftMapNode",0,&tolua_err)) ||
498  !tolua_isnoobj(tolua_S,4,&tolua_err)
499  )
500  goto tolua_lerror;
501  else
502 #endif
503  {
504  vector<fawkes::RCSoftMapNode>* self = (vector<fawkes::RCSoftMapNode>*) tolua_tousertype(tolua_S,1,0);
505  int index = ((int) tolua_tonumber(tolua_S,2,0));
506  fawkes::RCSoftMapNode tolua_value = *((fawkes::RCSoftMapNode*) tolua_tousertype(tolua_S,3,0));
507 #ifndef TOLUA_RELEASE
508  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator&[]'", NULL);
509 #endif
510  self->operator[](index) = tolua_value;
511  }
512  return 0;
513 #ifndef TOLUA_RELEASE
514  tolua_lerror:
515  tolua_error(tolua_S,"#ferror in function '.seti'.",&tolua_err);
516  return 0;
517 #endif
518 }
519 #endif //#ifndef TOLUA_DISABLE
520 
521 /* method: operator[] of class vector<fawkes::RCSoftMapNode> */
522 #ifndef TOLUA_DISABLE_tolua_fawkesutils_vector_fawkes__RCSoftMapNode___geti01
523 static int tolua_fawkesutils_vector_fawkes__RCSoftMapNode___geti01(lua_State* tolua_S)
524 {
525  tolua_Error tolua_err;
526  if (
527  !tolua_isusertype(tolua_S,1,"vector<fawkes::RCSoftMapNode>",0,&tolua_err) ||
528  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
529  !tolua_isnoobj(tolua_S,3,&tolua_err)
530  )
531  goto tolua_lerror;
532  else
533  {
534  vector<fawkes::RCSoftMapNode>* self = (vector<fawkes::RCSoftMapNode>*) tolua_tousertype(tolua_S,1,0);
535  int index = ((int) tolua_tonumber(tolua_S,2,0));
536 #ifndef TOLUA_RELEASE
537  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'", NULL);
538 #endif
539  {
540  fawkes::RCSoftMapNode tolua_ret = (fawkes::RCSoftMapNode) self->operator[](index);
541  {
542 #ifdef __cplusplus
543  void* tolua_obj = Mtolua_new((fawkes::RCSoftMapNode)(tolua_ret));
544  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::RCSoftMapNode");
545  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
546 #else
547  void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::RCSoftMapNode));
548  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::RCSoftMapNode");
549  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
550 #endif
551  }
552  }
553  }
554  return 1;
555 tolua_lerror:
556  return tolua_fawkesutils_vector_fawkes__RCSoftMapNode___geti00(tolua_S);
557 }
558 #endif //#ifndef TOLUA_DISABLE
559 
560 /* method: push_back of class vector<fawkes::RCSoftMapNode> */
561 #ifndef TOLUA_DISABLE_tolua_fawkesutils_vector_fawkes__RCSoftMapNode__push_back00
562 static int tolua_fawkesutils_vector_fawkes__RCSoftMapNode__push_back00(lua_State* tolua_S)
563 {
564 #ifndef TOLUA_RELEASE
565  tolua_Error tolua_err;
566  if (
567  !tolua_isusertype(tolua_S,1,"vector<fawkes::RCSoftMapNode>",0,&tolua_err) ||
568  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"fawkes::RCSoftMapNode",0,&tolua_err)) ||
569  !tolua_isnoobj(tolua_S,3,&tolua_err)
570  )
571  goto tolua_lerror;
572  else
573 #endif
574  {
575  vector<fawkes::RCSoftMapNode>* self = (vector<fawkes::RCSoftMapNode>*) tolua_tousertype(tolua_S,1,0);
576  fawkes::RCSoftMapNode val = *((fawkes::RCSoftMapNode*) tolua_tousertype(tolua_S,2,0));
577 #ifndef TOLUA_RELEASE
578  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'push_back'", NULL);
579 #endif
580  {
581  self->push_back(val);
582  }
583  }
584  return 0;
585 #ifndef TOLUA_RELEASE
586  tolua_lerror:
587  tolua_error(tolua_S,"#ferror in function 'push_back'.",&tolua_err);
588  return 0;
589 #endif
590 }
591 #endif //#ifndef TOLUA_DISABLE
592 
593 /* method: new of class vector<fawkes::RCSoftMapNode> */
594 #ifndef TOLUA_DISABLE_tolua_fawkesutils_vector_fawkes__RCSoftMapNode__new00
595 static int tolua_fawkesutils_vector_fawkes__RCSoftMapNode__new00(lua_State* tolua_S)
596 {
597 #ifndef TOLUA_RELEASE
598  tolua_Error tolua_err;
599  if (
600  !tolua_isusertable(tolua_S,1,"vector<fawkes::RCSoftMapNode>",0,&tolua_err) ||
601  !tolua_isnoobj(tolua_S,2,&tolua_err)
602  )
603  goto tolua_lerror;
604  else
605 #endif
606  {
607  {
608  vector<fawkes::RCSoftMapNode>* tolua_ret = (vector<fawkes::RCSoftMapNode>*) Mtolua_new((vector<fawkes::RCSoftMapNode>)());
609  tolua_pushusertype(tolua_S,(void*)tolua_ret,"vector<fawkes::RCSoftMapNode>");
610  }
611  }
612  return 1;
613 #ifndef TOLUA_RELEASE
614  tolua_lerror:
615  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
616  return 0;
617 #endif
618 }
619 #endif //#ifndef TOLUA_DISABLE
620 
621 /* method: new_local of class vector<fawkes::RCSoftMapNode> */
622 #ifndef TOLUA_DISABLE_tolua_fawkesutils_vector_fawkes__RCSoftMapNode__new00_local
623 static int tolua_fawkesutils_vector_fawkes__RCSoftMapNode__new00_local(lua_State* tolua_S)
624 {
625 #ifndef TOLUA_RELEASE
626  tolua_Error tolua_err;
627  if (
628  !tolua_isusertable(tolua_S,1,"vector<fawkes::RCSoftMapNode>",0,&tolua_err) ||
629  !tolua_isnoobj(tolua_S,2,&tolua_err)
630  )
631  goto tolua_lerror;
632  else
633 #endif
634  {
635  {
636  vector<fawkes::RCSoftMapNode>* tolua_ret = (vector<fawkes::RCSoftMapNode>*) Mtolua_new((vector<fawkes::RCSoftMapNode>)());
637  tolua_pushusertype(tolua_S,(void*)tolua_ret,"vector<fawkes::RCSoftMapNode>");
638  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
639  }
640  }
641  return 1;
642 #ifndef TOLUA_RELEASE
643  tolua_lerror:
644  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
645  return 0;
646 #endif
647 }
648 #endif //#ifndef TOLUA_DISABLE
649 
650 /* method: delete of class vector<fawkes::RCSoftMapNode> */
651 #ifndef TOLUA_DISABLE_tolua_fawkesutils_vector_fawkes__RCSoftMapNode__delete00
652 static int tolua_fawkesutils_vector_fawkes__RCSoftMapNode__delete00(lua_State* tolua_S)
653 {
654 #ifndef TOLUA_RELEASE
655  tolua_Error tolua_err;
656  if (
657  !tolua_isusertype(tolua_S,1,"vector<fawkes::RCSoftMapNode>",0,&tolua_err) ||
658  !tolua_isnoobj(tolua_S,2,&tolua_err)
659  )
660  goto tolua_lerror;
661  else
662 #endif
663  {
664  vector<fawkes::RCSoftMapNode>* self = (vector<fawkes::RCSoftMapNode>*) tolua_tousertype(tolua_S,1,0);
665 #ifndef TOLUA_RELEASE
666  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
667 #endif
668  Mtolua_delete(self);
669  }
670  return 0;
671 #ifndef TOLUA_RELEASE
672  tolua_lerror:
673  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
674  return 0;
675 #endif
676 }
677 #endif //#ifndef TOLUA_DISABLE
678 
679 /* method: new of class fawkes::RCSoftMapNode */
680 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_RCSoftMapNode_new00
681 static int tolua_fawkesutils_fawkes_RCSoftMapNode_new00(lua_State* tolua_S)
682 {
683 #ifndef TOLUA_RELEASE
684  tolua_Error tolua_err;
685  if (
686  !tolua_isusertable(tolua_S,1,"fawkes::RCSoftMapNode",0,&tolua_err) ||
687  !tolua_isnoobj(tolua_S,2,&tolua_err)
688  )
689  goto tolua_lerror;
690  else
691 #endif
692  {
693  {
694  fawkes::RCSoftMapNode* tolua_ret = (fawkes::RCSoftMapNode*) Mtolua_new((fawkes::RCSoftMapNode)());
695  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::RCSoftMapNode");
696  }
697  }
698  return 1;
699 #ifndef TOLUA_RELEASE
700  tolua_lerror:
701  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
702  return 0;
703 #endif
704 }
705 #endif //#ifndef TOLUA_DISABLE
706 
707 /* method: new_local of class fawkes::RCSoftMapNode */
708 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_RCSoftMapNode_new00_local
709 static int tolua_fawkesutils_fawkes_RCSoftMapNode_new00_local(lua_State* tolua_S)
710 {
711 #ifndef TOLUA_RELEASE
712  tolua_Error tolua_err;
713  if (
714  !tolua_isusertable(tolua_S,1,"fawkes::RCSoftMapNode",0,&tolua_err) ||
715  !tolua_isnoobj(tolua_S,2,&tolua_err)
716  )
717  goto tolua_lerror;
718  else
719 #endif
720  {
721  {
722  fawkes::RCSoftMapNode* tolua_ret = (fawkes::RCSoftMapNode*) Mtolua_new((fawkes::RCSoftMapNode)());
723  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::RCSoftMapNode");
724  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
725  }
726  }
727  return 1;
728 #ifndef TOLUA_RELEASE
729  tolua_lerror:
730  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
731  return 0;
732 #endif
733 }
734 #endif //#ifndef TOLUA_DISABLE
735 
736 /* method: new of class fawkes::RCSoftMapNode */
737 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_RCSoftMapNode_new01
738 static int tolua_fawkesutils_fawkes_RCSoftMapNode_new01(lua_State* tolua_S)
739 {
740  tolua_Error tolua_err;
741  if (
742  !tolua_isusertable(tolua_S,1,"fawkes::RCSoftMapNode",0,&tolua_err) ||
743  !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
744  !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
745  !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
746  (tolua_isvaluenil(tolua_S,5,&tolua_err) || !tolua_isusertype(tolua_S,5,"vector<string>",0,&tolua_err)) ||
747  (tolua_isvaluenil(tolua_S,6,&tolua_err) || !tolua_isusertype(tolua_S,6,"vector<string>",0,&tolua_err)) ||
748  (tolua_isvaluenil(tolua_S,7,&tolua_err) || !tolua_isusertype(tolua_S,7,"vector<string>",0,&tolua_err)) ||
749  !tolua_isnoobj(tolua_S,8,&tolua_err)
750  )
751  goto tolua_lerror;
752  else
753  {
754  string name = ((string) tolua_tocppstring(tolua_S,2,0));
755  double x = ((double) tolua_tonumber(tolua_S,3,0));
756  double y = ((double) tolua_tonumber(tolua_S,4,0));
757  vector<string> children = *((vector<string>*) tolua_tousertype(tolua_S,5,0));
758  vector<string> properties = *((vector<string>*) tolua_tousertype(tolua_S,6,0));
759  vector<string> aliases = *((vector<string>*) tolua_tousertype(tolua_S,7,0));
760  {
761  fawkes::RCSoftMapNode* tolua_ret = (fawkes::RCSoftMapNode*) Mtolua_new((fawkes::RCSoftMapNode)(name,x,y,children,properties,aliases));
762  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::RCSoftMapNode");
763  }
764  }
765  return 1;
766 tolua_lerror:
767  return tolua_fawkesutils_fawkes_RCSoftMapNode_new00(tolua_S);
768 }
769 #endif //#ifndef TOLUA_DISABLE
770 
771 /* method: new_local of class fawkes::RCSoftMapNode */
772 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_RCSoftMapNode_new01_local
773 static int tolua_fawkesutils_fawkes_RCSoftMapNode_new01_local(lua_State* tolua_S)
774 {
775  tolua_Error tolua_err;
776  if (
777  !tolua_isusertable(tolua_S,1,"fawkes::RCSoftMapNode",0,&tolua_err) ||
778  !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
779  !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
780  !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
781  (tolua_isvaluenil(tolua_S,5,&tolua_err) || !tolua_isusertype(tolua_S,5,"vector<string>",0,&tolua_err)) ||
782  (tolua_isvaluenil(tolua_S,6,&tolua_err) || !tolua_isusertype(tolua_S,6,"vector<string>",0,&tolua_err)) ||
783  (tolua_isvaluenil(tolua_S,7,&tolua_err) || !tolua_isusertype(tolua_S,7,"vector<string>",0,&tolua_err)) ||
784  !tolua_isnoobj(tolua_S,8,&tolua_err)
785  )
786  goto tolua_lerror;
787  else
788  {
789  string name = ((string) tolua_tocppstring(tolua_S,2,0));
790  double x = ((double) tolua_tonumber(tolua_S,3,0));
791  double y = ((double) tolua_tonumber(tolua_S,4,0));
792  vector<string> children = *((vector<string>*) tolua_tousertype(tolua_S,5,0));
793  vector<string> properties = *((vector<string>*) tolua_tousertype(tolua_S,6,0));
794  vector<string> aliases = *((vector<string>*) tolua_tousertype(tolua_S,7,0));
795  {
796  fawkes::RCSoftMapNode* tolua_ret = (fawkes::RCSoftMapNode*) Mtolua_new((fawkes::RCSoftMapNode)(name,x,y,children,properties,aliases));
797  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::RCSoftMapNode");
798  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
799  }
800  }
801  return 1;
802 tolua_lerror:
803  return tolua_fawkesutils_fawkes_RCSoftMapNode_new00_local(tolua_S);
804 }
805 #endif //#ifndef TOLUA_DISABLE
806 
807 /* method: name of class fawkes::RCSoftMapNode */
808 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_RCSoftMapNode_name00
809 static int tolua_fawkesutils_fawkes_RCSoftMapNode_name00(lua_State* tolua_S)
810 {
811 #ifndef TOLUA_RELEASE
812  tolua_Error tolua_err;
813  if (
814  !tolua_isusertype(tolua_S,1,"const fawkes::RCSoftMapNode",0,&tolua_err) ||
815  !tolua_isnoobj(tolua_S,2,&tolua_err)
816  )
817  goto tolua_lerror;
818  else
819 #endif
820  {
821  const fawkes::RCSoftMapNode* self = (const fawkes::RCSoftMapNode*) tolua_tousertype(tolua_S,1,0);
822 #ifndef TOLUA_RELEASE
823  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'name'", NULL);
824 #endif
825  {
826  string tolua_ret = (string) self->name();
827  tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
828  }
829  }
830  return 1;
831 #ifndef TOLUA_RELEASE
832  tolua_lerror:
833  tolua_error(tolua_S,"#ferror in function 'name'.",&tolua_err);
834  return 0;
835 #endif
836 }
837 #endif //#ifndef TOLUA_DISABLE
838 
839 /* method: x of class fawkes::RCSoftMapNode */
840 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_RCSoftMapNode_x00
841 static int tolua_fawkesutils_fawkes_RCSoftMapNode_x00(lua_State* tolua_S)
842 {
843 #ifndef TOLUA_RELEASE
844  tolua_Error tolua_err;
845  if (
846  !tolua_isusertype(tolua_S,1,"const fawkes::RCSoftMapNode",0,&tolua_err) ||
847  !tolua_isnoobj(tolua_S,2,&tolua_err)
848  )
849  goto tolua_lerror;
850  else
851 #endif
852  {
853  const fawkes::RCSoftMapNode* self = (const fawkes::RCSoftMapNode*) tolua_tousertype(tolua_S,1,0);
854 #ifndef TOLUA_RELEASE
855  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'x'", NULL);
856 #endif
857  {
858  float tolua_ret = (float) self->x();
859  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
860  }
861  }
862  return 1;
863 #ifndef TOLUA_RELEASE
864  tolua_lerror:
865  tolua_error(tolua_S,"#ferror in function 'x'.",&tolua_err);
866  return 0;
867 #endif
868 }
869 #endif //#ifndef TOLUA_DISABLE
870 
871 /* method: y of class fawkes::RCSoftMapNode */
872 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_RCSoftMapNode_y00
873 static int tolua_fawkesutils_fawkes_RCSoftMapNode_y00(lua_State* tolua_S)
874 {
875 #ifndef TOLUA_RELEASE
876  tolua_Error tolua_err;
877  if (
878  !tolua_isusertype(tolua_S,1,"const fawkes::RCSoftMapNode",0,&tolua_err) ||
879  !tolua_isnoobj(tolua_S,2,&tolua_err)
880  )
881  goto tolua_lerror;
882  else
883 #endif
884  {
885  const fawkes::RCSoftMapNode* self = (const fawkes::RCSoftMapNode*) tolua_tousertype(tolua_S,1,0);
886 #ifndef TOLUA_RELEASE
887  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'y'", NULL);
888 #endif
889  {
890  float tolua_ret = (float) self->y();
891  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
892  }
893  }
894  return 1;
895 #ifndef TOLUA_RELEASE
896  tolua_lerror:
897  tolua_error(tolua_S,"#ferror in function 'y'.",&tolua_err);
898  return 0;
899 #endif
900 }
901 #endif //#ifndef TOLUA_DISABLE
902 
903 /* method: properties of class fawkes::RCSoftMapNode */
904 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_RCSoftMapNode_properties00
905 static int tolua_fawkesutils_fawkes_RCSoftMapNode_properties00(lua_State* tolua_S)
906 {
907 #ifndef TOLUA_RELEASE
908  tolua_Error tolua_err;
909  if (
910  !tolua_isusertype(tolua_S,1,"fawkes::RCSoftMapNode",0,&tolua_err) ||
911  !tolua_isnoobj(tolua_S,2,&tolua_err)
912  )
913  goto tolua_lerror;
914  else
915 #endif
916  {
917  fawkes::RCSoftMapNode* self = (fawkes::RCSoftMapNode*) tolua_tousertype(tolua_S,1,0);
918 #ifndef TOLUA_RELEASE
919  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'properties'", NULL);
920 #endif
921  {
922  vector<string>& tolua_ret = (vector<string>&) self->properties();
923  tolua_pushusertype(tolua_S,(void*)&tolua_ret,"vector<string>");
924  }
925  }
926  return 1;
927 #ifndef TOLUA_RELEASE
928  tolua_lerror:
929  tolua_error(tolua_S,"#ferror in function 'properties'.",&tolua_err);
930  return 0;
931 #endif
932 }
933 #endif //#ifndef TOLUA_DISABLE
934 
935 /* method: aliases of class fawkes::RCSoftMapNode */
936 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_RCSoftMapNode_aliases00
937 static int tolua_fawkesutils_fawkes_RCSoftMapNode_aliases00(lua_State* tolua_S)
938 {
939 #ifndef TOLUA_RELEASE
940  tolua_Error tolua_err;
941  if (
942  !tolua_isusertype(tolua_S,1,"fawkes::RCSoftMapNode",0,&tolua_err) ||
943  !tolua_isnoobj(tolua_S,2,&tolua_err)
944  )
945  goto tolua_lerror;
946  else
947 #endif
948  {
949  fawkes::RCSoftMapNode* self = (fawkes::RCSoftMapNode*) tolua_tousertype(tolua_S,1,0);
950 #ifndef TOLUA_RELEASE
951  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'aliases'", NULL);
952 #endif
953  {
954  vector<string>& tolua_ret = (vector<string>&) self->aliases();
955  tolua_pushusertype(tolua_S,(void*)&tolua_ret,"vector<string>");
956  }
957  }
958  return 1;
959 #ifndef TOLUA_RELEASE
960  tolua_lerror:
961  tolua_error(tolua_S,"#ferror in function 'aliases'.",&tolua_err);
962  return 0;
963 #endif
964 }
965 #endif //#ifndef TOLUA_DISABLE
966 
967 /* method: children of class fawkes::RCSoftMapNode */
968 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_RCSoftMapNode_children00
969 static int tolua_fawkesutils_fawkes_RCSoftMapNode_children00(lua_State* tolua_S)
970 {
971 #ifndef TOLUA_RELEASE
972  tolua_Error tolua_err;
973  if (
974  !tolua_isusertype(tolua_S,1,"fawkes::RCSoftMapNode",0,&tolua_err) ||
975  !tolua_isnoobj(tolua_S,2,&tolua_err)
976  )
977  goto tolua_lerror;
978  else
979 #endif
980  {
981  fawkes::RCSoftMapNode* self = (fawkes::RCSoftMapNode*) tolua_tousertype(tolua_S,1,0);
982 #ifndef TOLUA_RELEASE
983  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'children'", NULL);
984 #endif
985  {
986  vector<string>& tolua_ret = (vector<string>&) self->children();
987  tolua_pushusertype(tolua_S,(void*)&tolua_ret,"vector<string>");
988  }
989  }
990  return 1;
991 #ifndef TOLUA_RELEASE
992  tolua_lerror:
993  tolua_error(tolua_S,"#ferror in function 'children'.",&tolua_err);
994  return 0;
995 #endif
996 }
997 #endif //#ifndef TOLUA_DISABLE
998 
999 /* method: has_property of class fawkes::RCSoftMapNode */
1000 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_RCSoftMapNode_has_property00
1001 static int tolua_fawkesutils_fawkes_RCSoftMapNode_has_property00(lua_State* tolua_S)
1002 {
1003 #ifndef TOLUA_RELEASE
1004  tolua_Error tolua_err;
1005  if (
1006  !tolua_isusertype(tolua_S,1,"fawkes::RCSoftMapNode",0,&tolua_err) ||
1007  !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
1008  !tolua_isnoobj(tolua_S,3,&tolua_err)
1009  )
1010  goto tolua_lerror;
1011  else
1012 #endif
1013  {
1014  fawkes::RCSoftMapNode* self = (fawkes::RCSoftMapNode*) tolua_tousertype(tolua_S,1,0);
1015  string property = ((string) tolua_tocppstring(tolua_S,2,0));
1016 #ifndef TOLUA_RELEASE
1017  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'has_property'", NULL);
1018 #endif
1019  {
1020  bool tolua_ret = (bool) self->has_property(property);
1021  tolua_pushboolean(tolua_S,(bool)tolua_ret);
1022  }
1023  }
1024  return 1;
1025 #ifndef TOLUA_RELEASE
1026  tolua_lerror:
1027  tolua_error(tolua_S,"#ferror in function 'has_property'.",&tolua_err);
1028  return 0;
1029 #endif
1030 }
1031 #endif //#ifndef TOLUA_DISABLE
1032 
1033 /* method: has_alias of class fawkes::RCSoftMapNode */
1034 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_RCSoftMapNode_has_alias00
1035 static int tolua_fawkesutils_fawkes_RCSoftMapNode_has_alias00(lua_State* tolua_S)
1036 {
1037 #ifndef TOLUA_RELEASE
1038  tolua_Error tolua_err;
1039  if (
1040  !tolua_isusertype(tolua_S,1,"fawkes::RCSoftMapNode",0,&tolua_err) ||
1041  !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
1042  !tolua_isnoobj(tolua_S,3,&tolua_err)
1043  )
1044  goto tolua_lerror;
1045  else
1046 #endif
1047  {
1048  fawkes::RCSoftMapNode* self = (fawkes::RCSoftMapNode*) tolua_tousertype(tolua_S,1,0);
1049  string property = ((string) tolua_tocppstring(tolua_S,2,0));
1050 #ifndef TOLUA_RELEASE
1051  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'has_alias'", NULL);
1052 #endif
1053  {
1054  bool tolua_ret = (bool) self->has_alias(property);
1055  tolua_pushboolean(tolua_S,(bool)tolua_ret);
1056  }
1057  }
1058  return 1;
1059 #ifndef TOLUA_RELEASE
1060  tolua_lerror:
1061  tolua_error(tolua_S,"#ferror in function 'has_alias'.",&tolua_err);
1062  return 0;
1063 #endif
1064 }
1065 #endif //#ifndef TOLUA_DISABLE
1066 
1067 /* method: new of class fawkes::RCSoftMapGraph */
1068 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_RCSoftMapGraph_new00
1069 static int tolua_fawkesutils_fawkes_RCSoftMapGraph_new00(lua_State* tolua_S)
1070 {
1071 #ifndef TOLUA_RELEASE
1072  tolua_Error tolua_err;
1073  if (
1074  !tolua_isusertable(tolua_S,1,"fawkes::RCSoftMapGraph",0,&tolua_err) ||
1075  !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
1076  !tolua_isnoobj(tolua_S,3,&tolua_err)
1077  )
1078  goto tolua_lerror;
1079  else
1080 #endif
1081  {
1082  string filename = ((string) tolua_tocppstring(tolua_S,2,0));
1083  {
1084  fawkes::RCSoftMapGraph* tolua_ret = (fawkes::RCSoftMapGraph*) Mtolua_new((fawkes::RCSoftMapGraph)(filename));
1085  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::RCSoftMapGraph");
1086  }
1087  }
1088  return 1;
1089 #ifndef TOLUA_RELEASE
1090  tolua_lerror:
1091  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
1092  return 0;
1093 #endif
1094 }
1095 #endif //#ifndef TOLUA_DISABLE
1096 
1097 /* method: new_local of class fawkes::RCSoftMapGraph */
1098 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_RCSoftMapGraph_new00_local
1099 static int tolua_fawkesutils_fawkes_RCSoftMapGraph_new00_local(lua_State* tolua_S)
1100 {
1101 #ifndef TOLUA_RELEASE
1102  tolua_Error tolua_err;
1103  if (
1104  !tolua_isusertable(tolua_S,1,"fawkes::RCSoftMapGraph",0,&tolua_err) ||
1105  !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
1106  !tolua_isnoobj(tolua_S,3,&tolua_err)
1107  )
1108  goto tolua_lerror;
1109  else
1110 #endif
1111  {
1112  string filename = ((string) tolua_tocppstring(tolua_S,2,0));
1113  {
1114  fawkes::RCSoftMapGraph* tolua_ret = (fawkes::RCSoftMapGraph*) Mtolua_new((fawkes::RCSoftMapGraph)(filename));
1115  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::RCSoftMapGraph");
1116  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1117  }
1118  }
1119  return 1;
1120 #ifndef TOLUA_RELEASE
1121  tolua_lerror:
1122  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
1123  return 0;
1124 #endif
1125 }
1126 #endif //#ifndef TOLUA_DISABLE
1127 
1128 /* method: delete of class fawkes::RCSoftMapGraph */
1129 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_RCSoftMapGraph_delete00
1130 static int tolua_fawkesutils_fawkes_RCSoftMapGraph_delete00(lua_State* tolua_S)
1131 {
1132 #ifndef TOLUA_RELEASE
1133  tolua_Error tolua_err;
1134  if (
1135  !tolua_isusertype(tolua_S,1,"fawkes::RCSoftMapGraph",0,&tolua_err) ||
1136  !tolua_isnoobj(tolua_S,2,&tolua_err)
1137  )
1138  goto tolua_lerror;
1139  else
1140 #endif
1141  {
1142  fawkes::RCSoftMapGraph* self = (fawkes::RCSoftMapGraph*) tolua_tousertype(tolua_S,1,0);
1143 #ifndef TOLUA_RELEASE
1144  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
1145 #endif
1146  Mtolua_delete(self);
1147  }
1148  return 0;
1149 #ifndef TOLUA_RELEASE
1150  tolua_lerror:
1151  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
1152  return 0;
1153 #endif
1154 }
1155 #endif //#ifndef TOLUA_DISABLE
1156 
1157 /* method: graph_name of class fawkes::RCSoftMapGraph */
1158 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_RCSoftMapGraph_graph_name00
1159 static int tolua_fawkesutils_fawkes_RCSoftMapGraph_graph_name00(lua_State* tolua_S)
1160 {
1161 #ifndef TOLUA_RELEASE
1162  tolua_Error tolua_err;
1163  if (
1164  !tolua_isusertype(tolua_S,1,"fawkes::RCSoftMapGraph",0,&tolua_err) ||
1165  !tolua_isnoobj(tolua_S,2,&tolua_err)
1166  )
1167  goto tolua_lerror;
1168  else
1169 #endif
1170  {
1171  fawkes::RCSoftMapGraph* self = (fawkes::RCSoftMapGraph*) tolua_tousertype(tolua_S,1,0);
1172 #ifndef TOLUA_RELEASE
1173  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'graph_name'", NULL);
1174 #endif
1175  {
1176  string tolua_ret = (string) self->graph_name();
1177  tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
1178  }
1179  }
1180  return 1;
1181 #ifndef TOLUA_RELEASE
1182  tolua_lerror:
1183  tolua_error(tolua_S,"#ferror in function 'graph_name'.",&tolua_err);
1184  return 0;
1185 #endif
1186 }
1187 #endif //#ifndef TOLUA_DISABLE
1188 
1189 /* method: nodes of class fawkes::RCSoftMapGraph */
1190 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_RCSoftMapGraph_nodes00
1191 static int tolua_fawkesutils_fawkes_RCSoftMapGraph_nodes00(lua_State* tolua_S)
1192 {
1193 #ifndef TOLUA_RELEASE
1194  tolua_Error tolua_err;
1195  if (
1196  !tolua_isusertype(tolua_S,1,"fawkes::RCSoftMapGraph",0,&tolua_err) ||
1197  !tolua_isnoobj(tolua_S,2,&tolua_err)
1198  )
1199  goto tolua_lerror;
1200  else
1201 #endif
1202  {
1203  fawkes::RCSoftMapGraph* self = (fawkes::RCSoftMapGraph*) tolua_tousertype(tolua_S,1,0);
1204 #ifndef TOLUA_RELEASE
1205  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'nodes'", NULL);
1206 #endif
1207  {
1208  vector<fawkes::RCSoftMapNode> tolua_ret = (vector<fawkes::RCSoftMapNode>) self->nodes();
1209  {
1210 #ifdef __cplusplus
1211  void* tolua_obj = Mtolua_new((vector<fawkes::RCSoftMapNode>)(tolua_ret));
1212  tolua_pushusertype(tolua_S,tolua_obj,"vector<fawkes::RCSoftMapNode>");
1213  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1214 #else
1215  void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(vector<fawkes::RCSoftMapNode>));
1216  tolua_pushusertype(tolua_S,tolua_obj,"vector<fawkes::RCSoftMapNode>");
1217  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1218 #endif
1219  }
1220  }
1221  }
1222  return 1;
1223 #ifndef TOLUA_RELEASE
1224  tolua_lerror:
1225  tolua_error(tolua_S,"#ferror in function 'nodes'.",&tolua_err);
1226  return 0;
1227 #endif
1228 }
1229 #endif //#ifndef TOLUA_DISABLE
1230 
1231 /* method: node of class fawkes::RCSoftMapGraph */
1232 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_RCSoftMapGraph_node00
1233 static int tolua_fawkesutils_fawkes_RCSoftMapGraph_node00(lua_State* tolua_S)
1234 {
1235 #ifndef TOLUA_RELEASE
1236  tolua_Error tolua_err;
1237  if (
1238  !tolua_isusertype(tolua_S,1,"fawkes::RCSoftMapGraph",0,&tolua_err) ||
1239  !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
1240  !tolua_isnoobj(tolua_S,3,&tolua_err)
1241  )
1242  goto tolua_lerror;
1243  else
1244 #endif
1245  {
1246  fawkes::RCSoftMapGraph* self = (fawkes::RCSoftMapGraph*) tolua_tousertype(tolua_S,1,0);
1247  string name_or_alias = ((string) tolua_tocppstring(tolua_S,2,0));
1248 #ifndef TOLUA_RELEASE
1249  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'node'", NULL);
1250 #endif
1251  {
1252  fawkes::RCSoftMapNode tolua_ret = (fawkes::RCSoftMapNode) self->node(name_or_alias);
1253  {
1254 #ifdef __cplusplus
1255  void* tolua_obj = Mtolua_new((fawkes::RCSoftMapNode)(tolua_ret));
1256  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::RCSoftMapNode");
1257  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1258 #else
1259  void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::RCSoftMapNode));
1260  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::RCSoftMapNode");
1261  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1262 #endif
1263  }
1264  }
1265  }
1266  return 1;
1267 #ifndef TOLUA_RELEASE
1268  tolua_lerror:
1269  tolua_error(tolua_S,"#ferror in function 'node'.",&tolua_err);
1270  return 0;
1271 #endif
1272 }
1273 #endif //#ifndef TOLUA_DISABLE
1274 
1275 /* method: root_node of class fawkes::RCSoftMapGraph */
1276 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_RCSoftMapGraph_root_node00
1277 static int tolua_fawkesutils_fawkes_RCSoftMapGraph_root_node00(lua_State* tolua_S)
1278 {
1279 #ifndef TOLUA_RELEASE
1280  tolua_Error tolua_err;
1281  if (
1282  !tolua_isusertype(tolua_S,1,"fawkes::RCSoftMapGraph",0,&tolua_err) ||
1283  !tolua_isnoobj(tolua_S,2,&tolua_err)
1284  )
1285  goto tolua_lerror;
1286  else
1287 #endif
1288  {
1289  fawkes::RCSoftMapGraph* self = (fawkes::RCSoftMapGraph*) tolua_tousertype(tolua_S,1,0);
1290 #ifndef TOLUA_RELEASE
1291  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'root_node'", NULL);
1292 #endif
1293  {
1294  fawkes::RCSoftMapNode tolua_ret = (fawkes::RCSoftMapNode) self->root_node();
1295  {
1296 #ifdef __cplusplus
1297  void* tolua_obj = Mtolua_new((fawkes::RCSoftMapNode)(tolua_ret));
1298  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::RCSoftMapNode");
1299  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1300 #else
1301  void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::RCSoftMapNode));
1302  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::RCSoftMapNode");
1303  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1304 #endif
1305  }
1306  }
1307  }
1308  return 1;
1309 #ifndef TOLUA_RELEASE
1310  tolua_lerror:
1311  tolua_error(tolua_S,"#ferror in function 'root_node'.",&tolua_err);
1312  return 0;
1313 #endif
1314 }
1315 #endif //#ifndef TOLUA_DISABLE
1316 
1317 /* method: closest_node of class fawkes::RCSoftMapGraph */
1318 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_RCSoftMapGraph_closest_node00
1319 static int tolua_fawkesutils_fawkes_RCSoftMapGraph_closest_node00(lua_State* tolua_S)
1320 {
1321 #ifndef TOLUA_RELEASE
1322  tolua_Error tolua_err;
1323  if (
1324  !tolua_isusertype(tolua_S,1,"fawkes::RCSoftMapGraph",0,&tolua_err) ||
1325  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
1326  !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
1327  !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
1328  !tolua_isnoobj(tolua_S,5,&tolua_err)
1329  )
1330  goto tolua_lerror;
1331  else
1332 #endif
1333  {
1334  fawkes::RCSoftMapGraph* self = (fawkes::RCSoftMapGraph*) tolua_tousertype(tolua_S,1,0);
1335  float pos_x = ((float) tolua_tonumber(tolua_S,2,0));
1336  float pos_y = ((float) tolua_tonumber(tolua_S,3,0));
1337  string property = ((string) tolua_tocppstring(tolua_S,4,0));
1338 #ifndef TOLUA_RELEASE
1339  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'closest_node'", NULL);
1340 #endif
1341  {
1342  fawkes::RCSoftMapNode tolua_ret = (fawkes::RCSoftMapNode) self->closest_node(pos_x,pos_y,property);
1343  {
1344 #ifdef __cplusplus
1345  void* tolua_obj = Mtolua_new((fawkes::RCSoftMapNode)(tolua_ret));
1346  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::RCSoftMapNode");
1347  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1348 #else
1349  void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::RCSoftMapNode));
1350  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::RCSoftMapNode");
1351  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1352 #endif
1353  }
1354  }
1355  }
1356  return 1;
1357 #ifndef TOLUA_RELEASE
1358  tolua_lerror:
1359  tolua_error(tolua_S,"#ferror in function 'closest_node'.",&tolua_err);
1360  return 0;
1361 #endif
1362 }
1363 #endif //#ifndef TOLUA_DISABLE
1364 
1365 /* method: search_nodes of class fawkes::RCSoftMapGraph */
1366 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_RCSoftMapGraph_search_nodes00
1367 static int tolua_fawkesutils_fawkes_RCSoftMapGraph_search_nodes00(lua_State* tolua_S)
1368 {
1369 #ifndef TOLUA_RELEASE
1370  tolua_Error tolua_err;
1371  if (
1372  !tolua_isusertype(tolua_S,1,"fawkes::RCSoftMapGraph",0,&tolua_err) ||
1373  !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
1374  !tolua_isnoobj(tolua_S,3,&tolua_err)
1375  )
1376  goto tolua_lerror;
1377  else
1378 #endif
1379  {
1380  fawkes::RCSoftMapGraph* self = (fawkes::RCSoftMapGraph*) tolua_tousertype(tolua_S,1,0);
1381  string property = ((string) tolua_tocppstring(tolua_S,2,0));
1382 #ifndef TOLUA_RELEASE
1383  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'search_nodes'", NULL);
1384 #endif
1385  {
1386  vector<fawkes::RCSoftMapNode> tolua_ret = (vector<fawkes::RCSoftMapNode>) self->search_nodes(property);
1387  {
1388 #ifdef __cplusplus
1389  void* tolua_obj = Mtolua_new((vector<fawkes::RCSoftMapNode>)(tolua_ret));
1390  tolua_pushusertype(tolua_S,tolua_obj,"vector<fawkes::RCSoftMapNode>");
1391  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1392 #else
1393  void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(vector<fawkes::RCSoftMapNode>));
1394  tolua_pushusertype(tolua_S,tolua_obj,"vector<fawkes::RCSoftMapNode>");
1395  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1396 #endif
1397  }
1398  }
1399  }
1400  return 1;
1401 #ifndef TOLUA_RELEASE
1402  tolua_lerror:
1403  tolua_error(tolua_S,"#ferror in function 'search_nodes'.",&tolua_err);
1404  return 0;
1405 #endif
1406 }
1407 #endif //#ifndef TOLUA_DISABLE
1408 
1409 /* method: new of class fawkes::KalmanFilter1D */
1410 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_KalmanFilter1D_new00
1411 static int tolua_fawkesutils_fawkes_KalmanFilter1D_new00(lua_State* tolua_S)
1412 {
1413 #ifndef TOLUA_RELEASE
1414  tolua_Error tolua_err;
1415  if (
1416  !tolua_isusertable(tolua_S,1,"fawkes::KalmanFilter1D",0,&tolua_err) ||
1417  !tolua_isnumber(tolua_S,2,1,&tolua_err) ||
1418  !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
1419  !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
1420  !tolua_isnumber(tolua_S,5,1,&tolua_err) ||
1421  !tolua_isnoobj(tolua_S,6,&tolua_err)
1422  )
1423  goto tolua_lerror;
1424  else
1425 #endif
1426  {
1427  float noise_x = ((float) tolua_tonumber(tolua_S,2,1.0));
1428  float noise_z = ((float) tolua_tonumber(tolua_S,3,1.0));
1429  float mu = ((float) tolua_tonumber(tolua_S,4,0.0));
1430  float sig = ((float) tolua_tonumber(tolua_S,5,1.0));
1431  {
1432  fawkes::KalmanFilter1D* tolua_ret = (fawkes::KalmanFilter1D*) Mtolua_new((fawkes::KalmanFilter1D)(noise_x,noise_z,mu,sig));
1433  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::KalmanFilter1D");
1434  }
1435  }
1436  return 1;
1437 #ifndef TOLUA_RELEASE
1438  tolua_lerror:
1439  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
1440  return 0;
1441 #endif
1442 }
1443 #endif //#ifndef TOLUA_DISABLE
1444 
1445 /* method: new_local of class fawkes::KalmanFilter1D */
1446 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_KalmanFilter1D_new00_local
1447 static int tolua_fawkesutils_fawkes_KalmanFilter1D_new00_local(lua_State* tolua_S)
1448 {
1449 #ifndef TOLUA_RELEASE
1450  tolua_Error tolua_err;
1451  if (
1452  !tolua_isusertable(tolua_S,1,"fawkes::KalmanFilter1D",0,&tolua_err) ||
1453  !tolua_isnumber(tolua_S,2,1,&tolua_err) ||
1454  !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
1455  !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
1456  !tolua_isnumber(tolua_S,5,1,&tolua_err) ||
1457  !tolua_isnoobj(tolua_S,6,&tolua_err)
1458  )
1459  goto tolua_lerror;
1460  else
1461 #endif
1462  {
1463  float noise_x = ((float) tolua_tonumber(tolua_S,2,1.0));
1464  float noise_z = ((float) tolua_tonumber(tolua_S,3,1.0));
1465  float mu = ((float) tolua_tonumber(tolua_S,4,0.0));
1466  float sig = ((float) tolua_tonumber(tolua_S,5,1.0));
1467  {
1468  fawkes::KalmanFilter1D* tolua_ret = (fawkes::KalmanFilter1D*) Mtolua_new((fawkes::KalmanFilter1D)(noise_x,noise_z,mu,sig));
1469  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::KalmanFilter1D");
1470  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1471  }
1472  }
1473  return 1;
1474 #ifndef TOLUA_RELEASE
1475  tolua_lerror:
1476  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
1477  return 0;
1478 #endif
1479 }
1480 #endif //#ifndef TOLUA_DISABLE
1481 
1482 /* method: delete of class fawkes::KalmanFilter1D */
1483 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_KalmanFilter1D_delete00
1484 static int tolua_fawkesutils_fawkes_KalmanFilter1D_delete00(lua_State* tolua_S)
1485 {
1486 #ifndef TOLUA_RELEASE
1487  tolua_Error tolua_err;
1488  if (
1489  !tolua_isusertype(tolua_S,1,"fawkes::KalmanFilter1D",0,&tolua_err) ||
1490  !tolua_isnoobj(tolua_S,2,&tolua_err)
1491  )
1492  goto tolua_lerror;
1493  else
1494 #endif
1495  {
1496  fawkes::KalmanFilter1D* self = (fawkes::KalmanFilter1D*) tolua_tousertype(tolua_S,1,0);
1497 #ifndef TOLUA_RELEASE
1498  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
1499 #endif
1500  Mtolua_delete(self);
1501  }
1502  return 0;
1503 #ifndef TOLUA_RELEASE
1504  tolua_lerror:
1505  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
1506  return 0;
1507 #endif
1508 }
1509 #endif //#ifndef TOLUA_DISABLE
1510 
1511 /* method: filter of class fawkes::KalmanFilter1D */
1512 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_KalmanFilter1D_filter00
1513 static int tolua_fawkesutils_fawkes_KalmanFilter1D_filter00(lua_State* tolua_S)
1514 {
1515 #ifndef TOLUA_RELEASE
1516  tolua_Error tolua_err;
1517  if (
1518  !tolua_isusertype(tolua_S,1,"fawkes::KalmanFilter1D",0,&tolua_err) ||
1519  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
1520  !tolua_isnoobj(tolua_S,3,&tolua_err)
1521  )
1522  goto tolua_lerror;
1523  else
1524 #endif
1525  {
1526  fawkes::KalmanFilter1D* self = (fawkes::KalmanFilter1D*) tolua_tousertype(tolua_S,1,0);
1527  float observe = ((float) tolua_tonumber(tolua_S,2,0));
1528 #ifndef TOLUA_RELEASE
1529  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'filter'", NULL);
1530 #endif
1531  {
1532  self->filter(observe);
1533  }
1534  }
1535  return 0;
1536 #ifndef TOLUA_RELEASE
1537  tolua_lerror:
1538  tolua_error(tolua_S,"#ferror in function 'filter'.",&tolua_err);
1539  return 0;
1540 #endif
1541 }
1542 #endif //#ifndef TOLUA_DISABLE
1543 
1544 /* method: filter of class fawkes::KalmanFilter1D */
1545 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_KalmanFilter1D_filter01
1546 static int tolua_fawkesutils_fawkes_KalmanFilter1D_filter01(lua_State* tolua_S)
1547 {
1548  tolua_Error tolua_err;
1549  if (
1550  !tolua_isusertype(tolua_S,1,"fawkes::KalmanFilter1D",0,&tolua_err) ||
1551  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
1552  !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
1553  !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
1554  !tolua_isnoobj(tolua_S,5,&tolua_err)
1555  )
1556  goto tolua_lerror;
1557  else
1558  {
1559  fawkes::KalmanFilter1D* self = (fawkes::KalmanFilter1D*) tolua_tousertype(tolua_S,1,0);
1560  float observe = ((float) tolua_tonumber(tolua_S,2,0));
1561  float mu = ((float) tolua_tonumber(tolua_S,3,0));
1562  float sig = ((float) tolua_tonumber(tolua_S,4,0));
1563 #ifndef TOLUA_RELEASE
1564  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'filter'", NULL);
1565 #endif
1566  {
1567  self->filter(observe,mu,sig);
1568  tolua_pushnumber(tolua_S,(lua_Number)mu);
1569  tolua_pushnumber(tolua_S,(lua_Number)sig);
1570  }
1571  }
1572  return 2;
1573 tolua_lerror:
1574  return tolua_fawkesutils_fawkes_KalmanFilter1D_filter00(tolua_S);
1575 }
1576 #endif //#ifndef TOLUA_DISABLE
1577 
1578 /* method: predict of class fawkes::KalmanFilter1D */
1579 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_KalmanFilter1D_predict00
1580 static int tolua_fawkesutils_fawkes_KalmanFilter1D_predict00(lua_State* tolua_S)
1581 {
1582 #ifndef TOLUA_RELEASE
1583  tolua_Error tolua_err;
1584  if (
1585  !tolua_isusertype(tolua_S,1,"const fawkes::KalmanFilter1D",0,&tolua_err) ||
1586  !tolua_isnoobj(tolua_S,2,&tolua_err)
1587  )
1588  goto tolua_lerror;
1589  else
1590 #endif
1591  {
1592  const fawkes::KalmanFilter1D* self = (const fawkes::KalmanFilter1D*) tolua_tousertype(tolua_S,1,0);
1593 #ifndef TOLUA_RELEASE
1594  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'predict'", NULL);
1595 #endif
1596  {
1597  float tolua_ret = (float) self->predict();
1598  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1599  }
1600  }
1601  return 1;
1602 #ifndef TOLUA_RELEASE
1603  tolua_lerror:
1604  tolua_error(tolua_S,"#ferror in function 'predict'.",&tolua_err);
1605  return 0;
1606 #endif
1607 }
1608 #endif //#ifndef TOLUA_DISABLE
1609 
1610 /* method: predict of class fawkes::KalmanFilter1D */
1611 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_KalmanFilter1D_predict01
1612 static int tolua_fawkesutils_fawkes_KalmanFilter1D_predict01(lua_State* tolua_S)
1613 {
1614  tolua_Error tolua_err;
1615  if (
1616  !tolua_isusertype(tolua_S,1,"const fawkes::KalmanFilter1D",0,&tolua_err) ||
1617  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
1618  !tolua_isnoobj(tolua_S,3,&tolua_err)
1619  )
1620  goto tolua_lerror;
1621  else
1622  {
1623  const fawkes::KalmanFilter1D* self = (const fawkes::KalmanFilter1D*) tolua_tousertype(tolua_S,1,0);
1624  float vel = ((float) tolua_tonumber(tolua_S,2,0));
1625 #ifndef TOLUA_RELEASE
1626  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'predict'", NULL);
1627 #endif
1628  {
1629  float tolua_ret = (float) self->predict(vel);
1630  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1631  }
1632  }
1633  return 1;
1634 tolua_lerror:
1635  return tolua_fawkesutils_fawkes_KalmanFilter1D_predict00(tolua_S);
1636 }
1637 #endif //#ifndef TOLUA_DISABLE
1638 
1639 /* method: predict of class fawkes::KalmanFilter1D */
1640 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_KalmanFilter1D_predict02
1641 static int tolua_fawkesutils_fawkes_KalmanFilter1D_predict02(lua_State* tolua_S)
1642 {
1643  tolua_Error tolua_err;
1644  if (
1645  !tolua_isusertype(tolua_S,1,"const fawkes::KalmanFilter1D",0,&tolua_err) ||
1646  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
1647  !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
1648  !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
1649  !tolua_isnoobj(tolua_S,5,&tolua_err)
1650  )
1651  goto tolua_lerror;
1652  else
1653  {
1654  const fawkes::KalmanFilter1D* self = (const fawkes::KalmanFilter1D*) tolua_tousertype(tolua_S,1,0);
1655  float vel = ((float) tolua_tonumber(tolua_S,2,0));
1656  int steps = ((int) tolua_tonumber(tolua_S,3,0));
1657  float noise_z = ((float) tolua_tonumber(tolua_S,4,0));
1658 #ifndef TOLUA_RELEASE
1659  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'predict'", NULL);
1660 #endif
1661  {
1662  float tolua_ret = (float) self->predict(vel,steps,noise_z);
1663  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1664  }
1665  }
1666  return 1;
1667 tolua_lerror:
1668  return tolua_fawkesutils_fawkes_KalmanFilter1D_predict01(tolua_S);
1669 }
1670 #endif //#ifndef TOLUA_DISABLE
1671 
1672 /* method: predict of class fawkes::KalmanFilter1D */
1673 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_KalmanFilter1D_predict03
1674 static int tolua_fawkesutils_fawkes_KalmanFilter1D_predict03(lua_State* tolua_S)
1675 {
1676  tolua_Error tolua_err;
1677  if (
1678  !tolua_isusertype(tolua_S,1,"const fawkes::KalmanFilter1D",0,&tolua_err) ||
1679  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
1680  !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
1681  !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
1682  !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
1683  !tolua_isnoobj(tolua_S,6,&tolua_err)
1684  )
1685  goto tolua_lerror;
1686  else
1687  {
1688  const fawkes::KalmanFilter1D* self = (const fawkes::KalmanFilter1D*) tolua_tousertype(tolua_S,1,0);
1689  float mu = ((float) tolua_tonumber(tolua_S,2,0));
1690  float vel = ((float) tolua_tonumber(tolua_S,3,0));
1691  int steps = ((int) tolua_tonumber(tolua_S,4,0));
1692  float noise_z = ((float) tolua_tonumber(tolua_S,5,0));
1693 #ifndef TOLUA_RELEASE
1694  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'predict'", NULL);
1695 #endif
1696  {
1697  float tolua_ret = (float) self->predict(mu,vel,steps,noise_z);
1698  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1699  }
1700  }
1701  return 1;
1702 tolua_lerror:
1703  return tolua_fawkesutils_fawkes_KalmanFilter1D_predict02(tolua_S);
1704 }
1705 #endif //#ifndef TOLUA_DISABLE
1706 
1707 /* get function: tv_sec of class timeval */
1708 #ifndef TOLUA_DISABLE_tolua_get_timeval_tv_sec
1709 static int tolua_get_timeval_tv_sec(lua_State* tolua_S)
1710 {
1711  timeval* self = (timeval*) tolua_tousertype(tolua_S,1,0);
1712 #ifndef TOLUA_RELEASE
1713  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'tv_sec'",NULL);
1714 #endif
1715  tolua_pushnumber(tolua_S,(lua_Number)self->tv_sec);
1716  return 1;
1717 }
1718 #endif //#ifndef TOLUA_DISABLE
1719 
1720 /* set function: tv_sec of class timeval */
1721 #ifndef TOLUA_DISABLE_tolua_set_timeval_tv_sec
1722 static int tolua_set_timeval_tv_sec(lua_State* tolua_S)
1723 {
1724  timeval* self = (timeval*) tolua_tousertype(tolua_S,1,0);
1725 #ifndef TOLUA_RELEASE
1726  tolua_Error tolua_err;
1727  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'tv_sec'",NULL);
1728  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
1729  tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
1730 #endif
1731  self->tv_sec = ((long int) tolua_tonumber(tolua_S,2,0))
1732 ;
1733  return 0;
1734 }
1735 #endif //#ifndef TOLUA_DISABLE
1736 
1737 /* get function: tv_usec of class timeval */
1738 #ifndef TOLUA_DISABLE_tolua_get_timeval_tv_usec
1739 static int tolua_get_timeval_tv_usec(lua_State* tolua_S)
1740 {
1741  timeval* self = (timeval*) tolua_tousertype(tolua_S,1,0);
1742 #ifndef TOLUA_RELEASE
1743  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'tv_usec'",NULL);
1744 #endif
1745  tolua_pushnumber(tolua_S,(lua_Number)self->tv_usec);
1746  return 1;
1747 }
1748 #endif //#ifndef TOLUA_DISABLE
1749 
1750 /* set function: tv_usec of class timeval */
1751 #ifndef TOLUA_DISABLE_tolua_set_timeval_tv_usec
1752 static int tolua_set_timeval_tv_usec(lua_State* tolua_S)
1753 {
1754  timeval* self = (timeval*) tolua_tousertype(tolua_S,1,0);
1755 #ifndef TOLUA_RELEASE
1756  tolua_Error tolua_err;
1757  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'tv_usec'",NULL);
1758  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
1759  tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
1760 #endif
1761  self->tv_usec = ((long int) tolua_tonumber(tolua_S,2,0))
1762 ;
1763  return 0;
1764 }
1765 #endif //#ifndef TOLUA_DISABLE
1766 
1767 /* method: new of class fawkes::Time */
1768 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new00
1769 static int tolua_fawkesutils_fawkes_Time_new00(lua_State* tolua_S)
1770 {
1771 #ifndef TOLUA_RELEASE
1772  tolua_Error tolua_err;
1773  if (
1774  !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
1775  !tolua_isnoobj(tolua_S,2,&tolua_err)
1776  )
1777  goto tolua_lerror;
1778  else
1779 #endif
1780  {
1781  {
1782  fawkes::Time* tolua_ret = (fawkes::Time*) Mtolua_new((fawkes::Time)());
1783  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
1784  }
1785  }
1786  return 1;
1787 #ifndef TOLUA_RELEASE
1788  tolua_lerror:
1789  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
1790  return 0;
1791 #endif
1792 }
1793 #endif //#ifndef TOLUA_DISABLE
1794 
1795 /* method: new_local of class fawkes::Time */
1796 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new00_local
1797 static int tolua_fawkesutils_fawkes_Time_new00_local(lua_State* tolua_S)
1798 {
1799 #ifndef TOLUA_RELEASE
1800  tolua_Error tolua_err;
1801  if (
1802  !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
1803  !tolua_isnoobj(tolua_S,2,&tolua_err)
1804  )
1805  goto tolua_lerror;
1806  else
1807 #endif
1808  {
1809  {
1810  fawkes::Time* tolua_ret = (fawkes::Time*) Mtolua_new((fawkes::Time)());
1811  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
1812  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1813  }
1814  }
1815  return 1;
1816 #ifndef TOLUA_RELEASE
1817  tolua_lerror:
1818  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
1819  return 0;
1820 #endif
1821 }
1822 #endif //#ifndef TOLUA_DISABLE
1823 
1824 /* method: new of class fawkes::Time */
1825 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new01
1826 static int tolua_fawkesutils_fawkes_Time_new01(lua_State* tolua_S)
1827 {
1828  tolua_Error tolua_err;
1829  if (
1830  !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
1831  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
1832  !tolua_isnoobj(tolua_S,3,&tolua_err)
1833  )
1834  goto tolua_lerror;
1835  else
1836  {
1837  long ms = ((long) tolua_tonumber(tolua_S,2,0));
1838  {
1839  fawkes::Time* tolua_ret = (fawkes::Time*) Mtolua_new((fawkes::Time)(ms));
1840  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
1841  }
1842  }
1843  return 1;
1844 tolua_lerror:
1845  return tolua_fawkesutils_fawkes_Time_new00(tolua_S);
1846 }
1847 #endif //#ifndef TOLUA_DISABLE
1848 
1849 /* method: new_local of class fawkes::Time */
1850 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new01_local
1851 static int tolua_fawkesutils_fawkes_Time_new01_local(lua_State* tolua_S)
1852 {
1853  tolua_Error tolua_err;
1854  if (
1855  !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
1856  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
1857  !tolua_isnoobj(tolua_S,3,&tolua_err)
1858  )
1859  goto tolua_lerror;
1860  else
1861  {
1862  long ms = ((long) tolua_tonumber(tolua_S,2,0));
1863  {
1864  fawkes::Time* tolua_ret = (fawkes::Time*) Mtolua_new((fawkes::Time)(ms));
1865  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
1866  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1867  }
1868  }
1869  return 1;
1870 tolua_lerror:
1871  return tolua_fawkesutils_fawkes_Time_new00_local(tolua_S);
1872 }
1873 #endif //#ifndef TOLUA_DISABLE
1874 
1875 /* method: new of class fawkes::Time */
1876 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new02
1877 static int tolua_fawkesutils_fawkes_Time_new02(lua_State* tolua_S)
1878 {
1879  tolua_Error tolua_err;
1880  if (
1881  !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
1882  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
1883  !tolua_isnoobj(tolua_S,3,&tolua_err)
1884  )
1885  goto tolua_lerror;
1886  else
1887  {
1888  float sec = ((float) tolua_tonumber(tolua_S,2,0));
1889  {
1890  fawkes::Time* tolua_ret = (fawkes::Time*) Mtolua_new((fawkes::Time)(sec));
1891  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
1892  }
1893  }
1894  return 1;
1895 tolua_lerror:
1896  return tolua_fawkesutils_fawkes_Time_new01(tolua_S);
1897 }
1898 #endif //#ifndef TOLUA_DISABLE
1899 
1900 /* method: new_local of class fawkes::Time */
1901 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new02_local
1902 static int tolua_fawkesutils_fawkes_Time_new02_local(lua_State* tolua_S)
1903 {
1904  tolua_Error tolua_err;
1905  if (
1906  !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
1907  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
1908  !tolua_isnoobj(tolua_S,3,&tolua_err)
1909  )
1910  goto tolua_lerror;
1911  else
1912  {
1913  float sec = ((float) tolua_tonumber(tolua_S,2,0));
1914  {
1915  fawkes::Time* tolua_ret = (fawkes::Time*) Mtolua_new((fawkes::Time)(sec));
1916  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
1917  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1918  }
1919  }
1920  return 1;
1921 tolua_lerror:
1922  return tolua_fawkesutils_fawkes_Time_new01_local(tolua_S);
1923 }
1924 #endif //#ifndef TOLUA_DISABLE
1925 
1926 /* method: new of class fawkes::Time */
1927 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new03
1928 static int tolua_fawkesutils_fawkes_Time_new03(lua_State* tolua_S)
1929 {
1930  tolua_Error tolua_err;
1931  if (
1932  !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
1933  !tolua_isusertype(tolua_S,2,"fawkes::Clock",0,&tolua_err) ||
1934  !tolua_isnoobj(tolua_S,3,&tolua_err)
1935  )
1936  goto tolua_lerror;
1937  else
1938  {
1939  fawkes::Clock* clock = ((fawkes::Clock*) tolua_tousertype(tolua_S,2,0));
1940  {
1941  fawkes::Time* tolua_ret = (fawkes::Time*) Mtolua_new((fawkes::Time)(clock));
1942  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
1943  }
1944  }
1945  return 1;
1946 tolua_lerror:
1947  return tolua_fawkesutils_fawkes_Time_new02(tolua_S);
1948 }
1949 #endif //#ifndef TOLUA_DISABLE
1950 
1951 /* method: new_local of class fawkes::Time */
1952 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new03_local
1953 static int tolua_fawkesutils_fawkes_Time_new03_local(lua_State* tolua_S)
1954 {
1955  tolua_Error tolua_err;
1956  if (
1957  !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
1958  !tolua_isusertype(tolua_S,2,"fawkes::Clock",0,&tolua_err) ||
1959  !tolua_isnoobj(tolua_S,3,&tolua_err)
1960  )
1961  goto tolua_lerror;
1962  else
1963  {
1964  fawkes::Clock* clock = ((fawkes::Clock*) tolua_tousertype(tolua_S,2,0));
1965  {
1966  fawkes::Time* tolua_ret = (fawkes::Time*) Mtolua_new((fawkes::Time)(clock));
1967  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
1968  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1969  }
1970  }
1971  return 1;
1972 tolua_lerror:
1973  return tolua_fawkesutils_fawkes_Time_new02_local(tolua_S);
1974 }
1975 #endif //#ifndef TOLUA_DISABLE
1976 
1977 /* method: new of class fawkes::Time */
1978 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new04
1979 static int tolua_fawkesutils_fawkes_Time_new04(lua_State* tolua_S)
1980 {
1981  tolua_Error tolua_err;
1982  if (
1983  !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
1984  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::Time",0,&tolua_err)) ||
1985  !tolua_isnoobj(tolua_S,3,&tolua_err)
1986  )
1987  goto tolua_lerror;
1988  else
1989  {
1990  const fawkes::Time* t = ((const fawkes::Time*) tolua_tousertype(tolua_S,2,0));
1991  {
1992  fawkes::Time* tolua_ret = (fawkes::Time*) Mtolua_new((fawkes::Time)(*t));
1993  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
1994  }
1995  }
1996  return 1;
1997 tolua_lerror:
1998  return tolua_fawkesutils_fawkes_Time_new03(tolua_S);
1999 }
2000 #endif //#ifndef TOLUA_DISABLE
2001 
2002 /* method: new_local of class fawkes::Time */
2003 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new04_local
2004 static int tolua_fawkesutils_fawkes_Time_new04_local(lua_State* tolua_S)
2005 {
2006  tolua_Error tolua_err;
2007  if (
2008  !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
2009  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::Time",0,&tolua_err)) ||
2010  !tolua_isnoobj(tolua_S,3,&tolua_err)
2011  )
2012  goto tolua_lerror;
2013  else
2014  {
2015  const fawkes::Time* t = ((const fawkes::Time*) tolua_tousertype(tolua_S,2,0));
2016  {
2017  fawkes::Time* tolua_ret = (fawkes::Time*) Mtolua_new((fawkes::Time)(*t));
2018  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
2019  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
2020  }
2021  }
2022  return 1;
2023 tolua_lerror:
2024  return tolua_fawkesutils_fawkes_Time_new03_local(tolua_S);
2025 }
2026 #endif //#ifndef TOLUA_DISABLE
2027 
2028 /* method: new of class fawkes::Time */
2029 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new05
2030 static int tolua_fawkesutils_fawkes_Time_new05(lua_State* tolua_S)
2031 {
2032  tolua_Error tolua_err;
2033  if (
2034  !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
2035  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
2036  !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
2037  !tolua_isnoobj(tolua_S,4,&tolua_err)
2038  )
2039  goto tolua_lerror;
2040  else
2041  {
2042  long sec = ((long) tolua_tonumber(tolua_S,2,0));
2043  long usec = ((long) tolua_tonumber(tolua_S,3,0));
2044  {
2045  fawkes::Time* tolua_ret = (fawkes::Time*) Mtolua_new((fawkes::Time)(sec,usec));
2046  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
2047  }
2048  }
2049  return 1;
2050 tolua_lerror:
2051  return tolua_fawkesutils_fawkes_Time_new04(tolua_S);
2052 }
2053 #endif //#ifndef TOLUA_DISABLE
2054 
2055 /* method: new_local of class fawkes::Time */
2056 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new05_local
2057 static int tolua_fawkesutils_fawkes_Time_new05_local(lua_State* tolua_S)
2058 {
2059  tolua_Error tolua_err;
2060  if (
2061  !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
2062  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
2063  !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
2064  !tolua_isnoobj(tolua_S,4,&tolua_err)
2065  )
2066  goto tolua_lerror;
2067  else
2068  {
2069  long sec = ((long) tolua_tonumber(tolua_S,2,0));
2070  long usec = ((long) tolua_tonumber(tolua_S,3,0));
2071  {
2072  fawkes::Time* tolua_ret = (fawkes::Time*) Mtolua_new((fawkes::Time)(sec,usec));
2073  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
2074  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
2075  }
2076  }
2077  return 1;
2078 tolua_lerror:
2079  return tolua_fawkesutils_fawkes_Time_new04_local(tolua_S);
2080 }
2081 #endif //#ifndef TOLUA_DISABLE
2082 
2083 /* method: new of class fawkes::Time */
2084 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new06
2085 static int tolua_fawkesutils_fawkes_Time_new06(lua_State* tolua_S)
2086 {
2087  tolua_Error tolua_err;
2088  if (
2089  !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
2090  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
2091  !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
2092  !tolua_isusertype(tolua_S,4,"fawkes::Clock",0,&tolua_err) ||
2093  !tolua_isnoobj(tolua_S,5,&tolua_err)
2094  )
2095  goto tolua_lerror;
2096  else
2097  {
2098  long sec = ((long) tolua_tonumber(tolua_S,2,0));
2099  long usec = ((long) tolua_tonumber(tolua_S,3,0));
2100  fawkes::Clock* clock = ((fawkes::Clock*) tolua_tousertype(tolua_S,4,0));
2101  {
2102  fawkes::Time* tolua_ret = (fawkes::Time*) Mtolua_new((fawkes::Time)(sec,usec,clock));
2103  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
2104  }
2105  }
2106  return 1;
2107 tolua_lerror:
2108  return tolua_fawkesutils_fawkes_Time_new05(tolua_S);
2109 }
2110 #endif //#ifndef TOLUA_DISABLE
2111 
2112 /* method: new_local of class fawkes::Time */
2113 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_new06_local
2114 static int tolua_fawkesutils_fawkes_Time_new06_local(lua_State* tolua_S)
2115 {
2116  tolua_Error tolua_err;
2117  if (
2118  !tolua_isusertable(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
2119  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
2120  !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
2121  !tolua_isusertype(tolua_S,4,"fawkes::Clock",0,&tolua_err) ||
2122  !tolua_isnoobj(tolua_S,5,&tolua_err)
2123  )
2124  goto tolua_lerror;
2125  else
2126  {
2127  long sec = ((long) tolua_tonumber(tolua_S,2,0));
2128  long usec = ((long) tolua_tonumber(tolua_S,3,0));
2129  fawkes::Clock* clock = ((fawkes::Clock*) tolua_tousertype(tolua_S,4,0));
2130  {
2131  fawkes::Time* tolua_ret = (fawkes::Time*) Mtolua_new((fawkes::Time)(sec,usec,clock));
2132  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Time");
2133  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
2134  }
2135  }
2136  return 1;
2137 tolua_lerror:
2138  return tolua_fawkesutils_fawkes_Time_new05_local(tolua_S);
2139 }
2140 #endif //#ifndef TOLUA_DISABLE
2141 
2142 /* method: delete of class fawkes::Time */
2143 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_delete00
2144 static int tolua_fawkesutils_fawkes_Time_delete00(lua_State* tolua_S)
2145 {
2146 #ifndef TOLUA_RELEASE
2147  tolua_Error tolua_err;
2148  if (
2149  !tolua_isusertype(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
2150  !tolua_isnoobj(tolua_S,2,&tolua_err)
2151  )
2152  goto tolua_lerror;
2153  else
2154 #endif
2155  {
2156  fawkes::Time* self = (fawkes::Time*) tolua_tousertype(tolua_S,1,0);
2157 #ifndef TOLUA_RELEASE
2158  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
2159 #endif
2160  Mtolua_delete(self);
2161  }
2162  return 0;
2163 #ifndef TOLUA_RELEASE
2164  tolua_lerror:
2165  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
2166  return 0;
2167 #endif
2168 }
2169 #endif //#ifndef TOLUA_DISABLE
2170 
2171 /* method: in_sec of class fawkes::Time */
2172 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_in_sec00
2173 static int tolua_fawkesutils_fawkes_Time_in_sec00(lua_State* tolua_S)
2174 {
2175 #ifndef TOLUA_RELEASE
2176  tolua_Error tolua_err;
2177  if (
2178  !tolua_isusertype(tolua_S,1,"const fawkes::Time",0,&tolua_err) ||
2179  !tolua_isnoobj(tolua_S,2,&tolua_err)
2180  )
2181  goto tolua_lerror;
2182  else
2183 #endif
2184  {
2185  const fawkes::Time* self = (const fawkes::Time*) tolua_tousertype(tolua_S,1,0);
2186 #ifndef TOLUA_RELEASE
2187  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'in_sec'", NULL);
2188 #endif
2189  {
2190  float tolua_ret = (float) self->in_sec();
2191  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
2192  }
2193  }
2194  return 1;
2195 #ifndef TOLUA_RELEASE
2196  tolua_lerror:
2197  tolua_error(tolua_S,"#ferror in function 'in_sec'.",&tolua_err);
2198  return 0;
2199 #endif
2200 }
2201 #endif //#ifndef TOLUA_DISABLE
2202 
2203 /* method: in_msec of class fawkes::Time */
2204 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_in_msec00
2205 static int tolua_fawkesutils_fawkes_Time_in_msec00(lua_State* tolua_S)
2206 {
2207 #ifndef TOLUA_RELEASE
2208  tolua_Error tolua_err;
2209  if (
2210  !tolua_isusertype(tolua_S,1,"const fawkes::Time",0,&tolua_err) ||
2211  !tolua_isnoobj(tolua_S,2,&tolua_err)
2212  )
2213  goto tolua_lerror;
2214  else
2215 #endif
2216  {
2217  const fawkes::Time* self = (const fawkes::Time*) tolua_tousertype(tolua_S,1,0);
2218 #ifndef TOLUA_RELEASE
2219  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'in_msec'", NULL);
2220 #endif
2221  {
2222  long tolua_ret = (long) self->in_msec();
2223  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
2224  }
2225  }
2226  return 1;
2227 #ifndef TOLUA_RELEASE
2228  tolua_lerror:
2229  tolua_error(tolua_S,"#ferror in function 'in_msec'.",&tolua_err);
2230  return 0;
2231 #endif
2232 }
2233 #endif //#ifndef TOLUA_DISABLE
2234 
2235 /* method: in_usec of class fawkes::Time */
2236 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_in_usec00
2237 static int tolua_fawkesutils_fawkes_Time_in_usec00(lua_State* tolua_S)
2238 {
2239 #ifndef TOLUA_RELEASE
2240  tolua_Error tolua_err;
2241  if (
2242  !tolua_isusertype(tolua_S,1,"const fawkes::Time",0,&tolua_err) ||
2243  !tolua_isnoobj(tolua_S,2,&tolua_err)
2244  )
2245  goto tolua_lerror;
2246  else
2247 #endif
2248  {
2249  const fawkes::Time* self = (const fawkes::Time*) tolua_tousertype(tolua_S,1,0);
2250 #ifndef TOLUA_RELEASE
2251  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'in_usec'", NULL);
2252 #endif
2253  {
2254  long tolua_ret = (long) self->in_usec();
2255  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
2256  }
2257  }
2258  return 1;
2259 #ifndef TOLUA_RELEASE
2260  tolua_lerror:
2261  tolua_error(tolua_S,"#ferror in function 'in_usec'.",&tolua_err);
2262  return 0;
2263 #endif
2264 }
2265 #endif //#ifndef TOLUA_DISABLE
2266 
2267 /* method: get_timeval of class fawkes::Time */
2268 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_get_timeval00
2269 static int tolua_fawkesutils_fawkes_Time_get_timeval00(lua_State* tolua_S)
2270 {
2271 #ifndef TOLUA_RELEASE
2272  tolua_Error tolua_err;
2273  if (
2274  !tolua_isusertype(tolua_S,1,"const fawkes::Time",0,&tolua_err) ||
2275  !tolua_isnoobj(tolua_S,2,&tolua_err)
2276  )
2277  goto tolua_lerror;
2278  else
2279 #endif
2280  {
2281  const fawkes::Time* self = (const fawkes::Time*) tolua_tousertype(tolua_S,1,0);
2282 #ifndef TOLUA_RELEASE
2283  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_timeval'", NULL);
2284 #endif
2285  {
2286  const timeval* tolua_ret = (const timeval*) self->get_timeval();
2287  tolua_pushusertype(tolua_S,(void*)tolua_ret,"const timeval");
2288  }
2289  }
2290  return 1;
2291 #ifndef TOLUA_RELEASE
2292  tolua_lerror:
2293  tolua_error(tolua_S,"#ferror in function 'get_timeval'.",&tolua_err);
2294  return 0;
2295 #endif
2296 }
2297 #endif //#ifndef TOLUA_DISABLE
2298 
2299 /* method: set_time of class fawkes::Time */
2300 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_set_time00
2301 static int tolua_fawkesutils_fawkes_Time_set_time00(lua_State* tolua_S)
2302 {
2303 #ifndef TOLUA_RELEASE
2304  tolua_Error tolua_err;
2305  if (
2306  !tolua_isusertype(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
2307  !tolua_isusertype(tolua_S,2,"const timeval",0,&tolua_err) ||
2308  !tolua_isnoobj(tolua_S,3,&tolua_err)
2309  )
2310  goto tolua_lerror;
2311  else
2312 #endif
2313  {
2314  fawkes::Time* self = (fawkes::Time*) tolua_tousertype(tolua_S,1,0);
2315  const timeval* tv = ((const timeval*) tolua_tousertype(tolua_S,2,0));
2316 #ifndef TOLUA_RELEASE
2317  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_time'", NULL);
2318 #endif
2319  {
2320  self->set_time(tv);
2321  }
2322  }
2323  return 0;
2324 #ifndef TOLUA_RELEASE
2325  tolua_lerror:
2326  tolua_error(tolua_S,"#ferror in function 'set_time'.",&tolua_err);
2327  return 0;
2328 #endif
2329 }
2330 #endif //#ifndef TOLUA_DISABLE
2331 
2332 /* method: set_time of class fawkes::Time */
2333 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_set_time01
2334 static int tolua_fawkesutils_fawkes_Time_set_time01(lua_State* tolua_S)
2335 {
2336  tolua_Error tolua_err;
2337  if (
2338  !tolua_isusertype(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
2339  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
2340  !tolua_isnoobj(tolua_S,3,&tolua_err)
2341  )
2342  goto tolua_lerror;
2343  else
2344  {
2345  fawkes::Time* self = (fawkes::Time*) tolua_tousertype(tolua_S,1,0);
2346  long ms = ((long) tolua_tonumber(tolua_S,2,0));
2347 #ifndef TOLUA_RELEASE
2348  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_time'", NULL);
2349 #endif
2350  {
2351  self->set_time(ms);
2352  }
2353  }
2354  return 0;
2355 tolua_lerror:
2356  return tolua_fawkesutils_fawkes_Time_set_time00(tolua_S);
2357 }
2358 #endif //#ifndef TOLUA_DISABLE
2359 
2360 /* method: set_time of class fawkes::Time */
2361 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_set_time02
2362 static int tolua_fawkesutils_fawkes_Time_set_time02(lua_State* tolua_S)
2363 {
2364  tolua_Error tolua_err;
2365  if (
2366  !tolua_isusertype(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
2367  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
2368  !tolua_isnoobj(tolua_S,3,&tolua_err)
2369  )
2370  goto tolua_lerror;
2371  else
2372  {
2373  fawkes::Time* self = (fawkes::Time*) tolua_tousertype(tolua_S,1,0);
2374  float sec = ((float) tolua_tonumber(tolua_S,2,0));
2375 #ifndef TOLUA_RELEASE
2376  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_time'", NULL);
2377 #endif
2378  {
2379  self->set_time(sec);
2380  }
2381  }
2382  return 0;
2383 tolua_lerror:
2384  return tolua_fawkesutils_fawkes_Time_set_time01(tolua_S);
2385 }
2386 #endif //#ifndef TOLUA_DISABLE
2387 
2388 /* method: set_time of class fawkes::Time */
2389 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_set_time03
2390 static int tolua_fawkesutils_fawkes_Time_set_time03(lua_State* tolua_S)
2391 {
2392  tolua_Error tolua_err;
2393  if (
2394  !tolua_isusertype(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
2395  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::Time",0,&tolua_err)) ||
2396  !tolua_isnoobj(tolua_S,3,&tolua_err)
2397  )
2398  goto tolua_lerror;
2399  else
2400  {
2401  fawkes::Time* self = (fawkes::Time*) tolua_tousertype(tolua_S,1,0);
2402  const fawkes::Time* t = ((const fawkes::Time*) tolua_tousertype(tolua_S,2,0));
2403 #ifndef TOLUA_RELEASE
2404  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_time'", NULL);
2405 #endif
2406  {
2407  self->set_time(*t);
2408  }
2409  }
2410  return 0;
2411 tolua_lerror:
2412  return tolua_fawkesutils_fawkes_Time_set_time02(tolua_S);
2413 }
2414 #endif //#ifndef TOLUA_DISABLE
2415 
2416 /* method: add of class fawkes::Time */
2417 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_add00
2418 static int tolua_fawkesutils_fawkes_Time_add00(lua_State* tolua_S)
2419 {
2420 #ifndef TOLUA_RELEASE
2421  tolua_Error tolua_err;
2422  if (
2423  !tolua_isusertype(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
2424  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
2425  !tolua_isnoobj(tolua_S,3,&tolua_err)
2426  )
2427  goto tolua_lerror;
2428  else
2429 #endif
2430  {
2431  fawkes::Time* self = (fawkes::Time*) tolua_tousertype(tolua_S,1,0);
2432  float seconds = ((float) tolua_tonumber(tolua_S,2,0));
2433 #ifndef TOLUA_RELEASE
2434  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'add'", NULL);
2435 #endif
2436  {
2437  self->add(seconds);
2438  }
2439  }
2440  return 0;
2441 #ifndef TOLUA_RELEASE
2442  tolua_lerror:
2443  tolua_error(tolua_S,"#ferror in function 'add'.",&tolua_err);
2444  return 0;
2445 #endif
2446 }
2447 #endif //#ifndef TOLUA_DISABLE
2448 
2449 /* method: stamp of class fawkes::Time */
2450 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_stamp00
2451 static int tolua_fawkesutils_fawkes_Time_stamp00(lua_State* tolua_S)
2452 {
2453 #ifndef TOLUA_RELEASE
2454  tolua_Error tolua_err;
2455  if (
2456  !tolua_isusertype(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
2457  !tolua_isnoobj(tolua_S,2,&tolua_err)
2458  )
2459  goto tolua_lerror;
2460  else
2461 #endif
2462  {
2463  fawkes::Time* self = (fawkes::Time*) tolua_tousertype(tolua_S,1,0);
2464 #ifndef TOLUA_RELEASE
2465  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'stamp'", NULL);
2466 #endif
2467  {
2468  fawkes::Time& tolua_ret = (fawkes::Time&) self->stamp();
2469  tolua_pushusertype(tolua_S,(void*)&tolua_ret,"fawkes::Time");
2470  }
2471  }
2472  return 1;
2473 #ifndef TOLUA_RELEASE
2474  tolua_lerror:
2475  tolua_error(tolua_S,"#ferror in function 'stamp'.",&tolua_err);
2476  return 0;
2477 #endif
2478 }
2479 #endif //#ifndef TOLUA_DISABLE
2480 
2481 /* method: operator+ of class fawkes::Time */
2482 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time__add00
2483 static int tolua_fawkesutils_fawkes_Time__add00(lua_State* tolua_S)
2484 {
2485 #ifndef TOLUA_RELEASE
2486  tolua_Error tolua_err;
2487  if (
2488  !tolua_isusertype(tolua_S,1,"const fawkes::Time",0,&tolua_err) ||
2489  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::Time",0,&tolua_err)) ||
2490  !tolua_isnoobj(tolua_S,3,&tolua_err)
2491  )
2492  goto tolua_lerror;
2493  else
2494 #endif
2495  {
2496  const fawkes::Time* self = (const fawkes::Time*) tolua_tousertype(tolua_S,1,0);
2497  const fawkes::Time* t = ((const fawkes::Time*) tolua_tousertype(tolua_S,2,0));
2498 #ifndef TOLUA_RELEASE
2499  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator+'", NULL);
2500 #endif
2501  {
2502  fawkes::Time tolua_ret = (fawkes::Time) self->operator+(*t);
2503  {
2504 #ifdef __cplusplus
2505  void* tolua_obj = Mtolua_new((fawkes::Time)(tolua_ret));
2506  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::Time");
2507  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
2508 #else
2509  void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::Time));
2510  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::Time");
2511  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
2512 #endif
2513  }
2514  }
2515  }
2516  return 1;
2517 #ifndef TOLUA_RELEASE
2518  tolua_lerror:
2519  tolua_error(tolua_S,"#ferror in function '.add'.",&tolua_err);
2520  return 0;
2521 #endif
2522 }
2523 #endif //#ifndef TOLUA_DISABLE
2524 
2525 /* method: operator- of class fawkes::Time */
2526 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time__sub00
2527 static int tolua_fawkesutils_fawkes_Time__sub00(lua_State* tolua_S)
2528 {
2529 #ifndef TOLUA_RELEASE
2530  tolua_Error tolua_err;
2531  if (
2532  !tolua_isusertype(tolua_S,1,"const fawkes::Time",0,&tolua_err) ||
2533  !tolua_isusertype(tolua_S,2,"const fawkes::Time",0,&tolua_err) ||
2534  !tolua_isnoobj(tolua_S,3,&tolua_err)
2535  )
2536  goto tolua_lerror;
2537  else
2538 #endif
2539  {
2540  const fawkes::Time* self = (const fawkes::Time*) tolua_tousertype(tolua_S,1,0);
2541  const fawkes::Time* t = ((const fawkes::Time*) tolua_tousertype(tolua_S,2,0));
2542 #ifndef TOLUA_RELEASE
2543  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator-'", NULL);
2544 #endif
2545  {
2546  float tolua_ret = (float) self->operator-(t);
2547  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
2548  }
2549  }
2550  return 1;
2551 #ifndef TOLUA_RELEASE
2552  tolua_lerror:
2553  tolua_error(tolua_S,"#ferror in function '.sub'.",&tolua_err);
2554  return 0;
2555 #endif
2556 }
2557 #endif //#ifndef TOLUA_DISABLE
2558 
2559 /* method: str of class fawkes::Time */
2560 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_str00
2561 static int tolua_fawkesutils_fawkes_Time_str00(lua_State* tolua_S)
2562 {
2563 #ifndef TOLUA_RELEASE
2564  tolua_Error tolua_err;
2565  if (
2566  !tolua_isusertype(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
2567  !tolua_isnoobj(tolua_S,2,&tolua_err)
2568  )
2569  goto tolua_lerror;
2570  else
2571 #endif
2572  {
2573  fawkes::Time* self = (fawkes::Time*) tolua_tousertype(tolua_S,1,0);
2574 #ifndef TOLUA_RELEASE
2575  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'str'", NULL);
2576 #endif
2577  {
2578  const char* tolua_ret = (const char*) self->str();
2579  tolua_pushstring(tolua_S,(const char*)tolua_ret);
2580  }
2581  }
2582  return 1;
2583 #ifndef TOLUA_RELEASE
2584  tolua_lerror:
2585  tolua_error(tolua_S,"#ferror in function 'str'.",&tolua_err);
2586  return 0;
2587 #endif
2588 }
2589 #endif //#ifndef TOLUA_DISABLE
2590 
2591 /* method: str_r of class fawkes::Time */
2592 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Time_str_r00
2593 static int tolua_fawkesutils_fawkes_Time_str_r00(lua_State* tolua_S)
2594 {
2595 #ifndef TOLUA_RELEASE
2596  tolua_Error tolua_err;
2597  if (
2598  !tolua_isusertype(tolua_S,1,"fawkes::Time",0,&tolua_err) ||
2599  !tolua_isstring(tolua_S,2,0,&tolua_err) ||
2600  !tolua_isnoobj(tolua_S,3,&tolua_err)
2601  )
2602  goto tolua_lerror;
2603  else
2604 #endif
2605  {
2606  fawkes::Time* self = (fawkes::Time*) tolua_tousertype(tolua_S,1,0);
2607  char* s = ((char*) tolua_tostring(tolua_S,2,0));
2608 #ifndef TOLUA_RELEASE
2609  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'str_r'", NULL);
2610 #endif
2611  {
2612  self->str_r(s);
2613  }
2614  }
2615  return 0;
2616 #ifndef TOLUA_RELEASE
2617  tolua_lerror:
2618  tolua_error(tolua_S,"#ferror in function 'str_r'.",&tolua_err);
2619  return 0;
2620 #endif
2621 }
2622 #endif //#ifndef TOLUA_DISABLE
2623 
2624 /* method: instance of class fawkes::Clock */
2625 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_instance00
2626 static int tolua_fawkesutils_fawkes_Clock_instance00(lua_State* tolua_S)
2627 {
2628 #ifndef TOLUA_RELEASE
2629  tolua_Error tolua_err;
2630  if (
2631  !tolua_isusertable(tolua_S,1,"fawkes::Clock",0,&tolua_err) ||
2632  !tolua_isnoobj(tolua_S,2,&tolua_err)
2633  )
2634  goto tolua_lerror;
2635  else
2636 #endif
2637  {
2638  {
2640  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::Clock");
2641  }
2642  }
2643  return 1;
2644 #ifndef TOLUA_RELEASE
2645  tolua_lerror:
2646  tolua_error(tolua_S,"#ferror in function 'instance'.",&tolua_err);
2647  return 0;
2648 #endif
2649 }
2650 #endif //#ifndef TOLUA_DISABLE
2651 
2652 /* method: finalize of class fawkes::Clock */
2653 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_finalize00
2654 static int tolua_fawkesutils_fawkes_Clock_finalize00(lua_State* tolua_S)
2655 {
2656 #ifndef TOLUA_RELEASE
2657  tolua_Error tolua_err;
2658  if (
2659  !tolua_isusertable(tolua_S,1,"fawkes::Clock",0,&tolua_err) ||
2660  !tolua_isnoobj(tolua_S,2,&tolua_err)
2661  )
2662  goto tolua_lerror;
2663  else
2664 #endif
2665  {
2666  {
2668  }
2669  }
2670  return 0;
2671 #ifndef TOLUA_RELEASE
2672  tolua_lerror:
2673  tolua_error(tolua_S,"#ferror in function 'finalize'.",&tolua_err);
2674  return 0;
2675 #endif
2676 }
2677 #endif //#ifndef TOLUA_DISABLE
2678 
2679 /* method: is_ext_default_timesource of class fawkes::Clock */
2680 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_is_ext_default_timesource00
2681 static int tolua_fawkesutils_fawkes_Clock_is_ext_default_timesource00(lua_State* tolua_S)
2682 {
2683 #ifndef TOLUA_RELEASE
2684  tolua_Error tolua_err;
2685  if (
2686  !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
2687  !tolua_isnoobj(tolua_S,2,&tolua_err)
2688  )
2689  goto tolua_lerror;
2690  else
2691 #endif
2692  {
2693  const fawkes::Clock* self = (const fawkes::Clock*) tolua_tousertype(tolua_S,1,0);
2694 #ifndef TOLUA_RELEASE
2695  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_ext_default_timesource'", NULL);
2696 #endif
2697  {
2698  bool tolua_ret = (bool) self->is_ext_default_timesource();
2699  tolua_pushboolean(tolua_S,(bool)tolua_ret);
2700  }
2701  }
2702  return 1;
2703 #ifndef TOLUA_RELEASE
2704  tolua_lerror:
2705  tolua_error(tolua_S,"#ferror in function 'is_ext_default_timesource'.",&tolua_err);
2706  return 0;
2707 #endif
2708 }
2709 #endif //#ifndef TOLUA_DISABLE
2710 
2711 /* method: has_ext_timesource of class fawkes::Clock */
2712 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_has_ext_timesource00
2713 static int tolua_fawkesutils_fawkes_Clock_has_ext_timesource00(lua_State* tolua_S)
2714 {
2715 #ifndef TOLUA_RELEASE
2716  tolua_Error tolua_err;
2717  if (
2718  !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
2719  !tolua_isnoobj(tolua_S,2,&tolua_err)
2720  )
2721  goto tolua_lerror;
2722  else
2723 #endif
2724  {
2725  const fawkes::Clock* self = (const fawkes::Clock*) tolua_tousertype(tolua_S,1,0);
2726 #ifndef TOLUA_RELEASE
2727  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'has_ext_timesource'", NULL);
2728 #endif
2729  {
2730  bool tolua_ret = (bool) self->has_ext_timesource();
2731  tolua_pushboolean(tolua_S,(bool)tolua_ret);
2732  }
2733  }
2734  return 1;
2735 #ifndef TOLUA_RELEASE
2736  tolua_lerror:
2737  tolua_error(tolua_S,"#ferror in function 'has_ext_timesource'.",&tolua_err);
2738  return 0;
2739 #endif
2740 }
2741 #endif //#ifndef TOLUA_DISABLE
2742 
2743 /* method: ext_to_realtime of class fawkes::Clock */
2744 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_ext_to_realtime00
2745 static int tolua_fawkesutils_fawkes_Clock_ext_to_realtime00(lua_State* tolua_S)
2746 {
2747 #ifndef TOLUA_RELEASE
2748  tolua_Error tolua_err;
2749  if (
2750  !tolua_isusertype(tolua_S,1,"fawkes::Clock",0,&tolua_err) ||
2751  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::Time",0,&tolua_err)) ||
2752  !tolua_isnoobj(tolua_S,3,&tolua_err)
2753  )
2754  goto tolua_lerror;
2755  else
2756 #endif
2757  {
2758  fawkes::Clock* self = (fawkes::Clock*) tolua_tousertype(tolua_S,1,0);
2759  const fawkes::Time* t = ((const fawkes::Time*) tolua_tousertype(tolua_S,2,0));
2760 #ifndef TOLUA_RELEASE
2761  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ext_to_realtime'", NULL);
2762 #endif
2763  {
2764  fawkes::Time tolua_ret = (fawkes::Time) self->ext_to_realtime(*t);
2765  {
2766 #ifdef __cplusplus
2767  void* tolua_obj = Mtolua_new((fawkes::Time)(tolua_ret));
2768  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::Time");
2769  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
2770 #else
2771  void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::Time));
2772  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::Time");
2773  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
2774 #endif
2775  }
2776  }
2777  }
2778  return 1;
2779 #ifndef TOLUA_RELEASE
2780  tolua_lerror:
2781  tolua_error(tolua_S,"#ferror in function 'ext_to_realtime'.",&tolua_err);
2782  return 0;
2783 #endif
2784 }
2785 #endif //#ifndef TOLUA_DISABLE
2786 
2787 /* method: get_time of class fawkes::Clock */
2788 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_get_time00
2789 static int tolua_fawkesutils_fawkes_Clock_get_time00(lua_State* tolua_S)
2790 {
2791 #ifndef TOLUA_RELEASE
2792  tolua_Error tolua_err;
2793  if (
2794  !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
2795  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"fawkes::Time",0,&tolua_err)) ||
2796  !tolua_isnoobj(tolua_S,3,&tolua_err)
2797  )
2798  goto tolua_lerror;
2799  else
2800 #endif
2801  {
2802  const fawkes::Clock* self = (const fawkes::Clock*) tolua_tousertype(tolua_S,1,0);
2803  fawkes::Time* time = ((fawkes::Time*) tolua_tousertype(tolua_S,2,0));
2804 #ifndef TOLUA_RELEASE
2805  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_time'", NULL);
2806 #endif
2807  {
2808  self->get_time(*time);
2809  }
2810  }
2811  return 0;
2812 #ifndef TOLUA_RELEASE
2813  tolua_lerror:
2814  tolua_error(tolua_S,"#ferror in function 'get_time'.",&tolua_err);
2815  return 0;
2816 #endif
2817 }
2818 #endif //#ifndef TOLUA_DISABLE
2819 
2820 /* method: get_time of class fawkes::Clock */
2821 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_get_time01
2822 static int tolua_fawkesutils_fawkes_Clock_get_time01(lua_State* tolua_S)
2823 {
2824  tolua_Error tolua_err;
2825  if (
2826  !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
2827  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"fawkes::Time",0,&tolua_err)) ||
2828  !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
2829  !tolua_isnoobj(tolua_S,4,&tolua_err)
2830  )
2831  goto tolua_lerror;
2832  else
2833  {
2834  const fawkes::Clock* self = (const fawkes::Clock*) tolua_tousertype(tolua_S,1,0);
2835  fawkes::Time* time = ((fawkes::Time*) tolua_tousertype(tolua_S,2,0));
2836  fawkes::Clock::TimesourceSelector sel = ((fawkes::Clock::TimesourceSelector) (int) tolua_tonumber(tolua_S,3,0));
2837 #ifndef TOLUA_RELEASE
2838  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_time'", NULL);
2839 #endif
2840  {
2841  self->get_time(*time,sel);
2842  }
2843  }
2844  return 0;
2845 tolua_lerror:
2846  return tolua_fawkesutils_fawkes_Clock_get_time00(tolua_S);
2847 }
2848 #endif //#ifndef TOLUA_DISABLE
2849 
2850 /* method: get_time of class fawkes::Clock */
2851 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_get_time02
2852 static int tolua_fawkesutils_fawkes_Clock_get_time02(lua_State* tolua_S)
2853 {
2854  tolua_Error tolua_err;
2855  if (
2856  !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
2857  !tolua_isusertype(tolua_S,2,"fawkes::Time",0,&tolua_err) ||
2858  !tolua_isnoobj(tolua_S,3,&tolua_err)
2859  )
2860  goto tolua_lerror;
2861  else
2862  {
2863  const fawkes::Clock* self = (const fawkes::Clock*) tolua_tousertype(tolua_S,1,0);
2864  fawkes::Time* time = ((fawkes::Time*) tolua_tousertype(tolua_S,2,0));
2865 #ifndef TOLUA_RELEASE
2866  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_time'", NULL);
2867 #endif
2868  {
2869  self->get_time(time);
2870  }
2871  }
2872  return 0;
2873 tolua_lerror:
2874  return tolua_fawkesutils_fawkes_Clock_get_time01(tolua_S);
2875 }
2876 #endif //#ifndef TOLUA_DISABLE
2877 
2878 /* method: get_time of class fawkes::Clock */
2879 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_get_time03
2880 static int tolua_fawkesutils_fawkes_Clock_get_time03(lua_State* tolua_S)
2881 {
2882  tolua_Error tolua_err;
2883  if (
2884  !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
2885  !tolua_isusertype(tolua_S,2,"fawkes::Time",0,&tolua_err) ||
2886  !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
2887  !tolua_isnoobj(tolua_S,4,&tolua_err)
2888  )
2889  goto tolua_lerror;
2890  else
2891  {
2892  const fawkes::Clock* self = (const fawkes::Clock*) tolua_tousertype(tolua_S,1,0);
2893  fawkes::Time* time = ((fawkes::Time*) tolua_tousertype(tolua_S,2,0));
2894  fawkes::Clock::TimesourceSelector sel = ((fawkes::Clock::TimesourceSelector) (int) tolua_tonumber(tolua_S,3,0));
2895 #ifndef TOLUA_RELEASE
2896  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_time'", NULL);
2897 #endif
2898  {
2899  self->get_time(time,sel);
2900  }
2901  }
2902  return 0;
2903 tolua_lerror:
2904  return tolua_fawkesutils_fawkes_Clock_get_time02(tolua_S);
2905 }
2906 #endif //#ifndef TOLUA_DISABLE
2907 
2908 /* method: get_time of class fawkes::Clock */
2909 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_get_time04
2910 static int tolua_fawkesutils_fawkes_Clock_get_time04(lua_State* tolua_S)
2911 {
2912  tolua_Error tolua_err;
2913  if (
2914  !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
2915  !tolua_isusertype(tolua_S,2,"timeval",0,&tolua_err) ||
2916  !tolua_isnoobj(tolua_S,3,&tolua_err)
2917  )
2918  goto tolua_lerror;
2919  else
2920  {
2921  const fawkes::Clock* self = (const fawkes::Clock*) tolua_tousertype(tolua_S,1,0);
2922  struct timeval* tv = ((struct timeval*) tolua_tousertype(tolua_S,2,0));
2923 #ifndef TOLUA_RELEASE
2924  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_time'", NULL);
2925 #endif
2926  {
2927  self->get_time(tv);
2928  }
2929  }
2930  return 0;
2931 tolua_lerror:
2932  return tolua_fawkesutils_fawkes_Clock_get_time03(tolua_S);
2933 }
2934 #endif //#ifndef TOLUA_DISABLE
2935 
2936 /* method: get_time of class fawkes::Clock */
2937 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_get_time05
2938 static int tolua_fawkesutils_fawkes_Clock_get_time05(lua_State* tolua_S)
2939 {
2940  tolua_Error tolua_err;
2941  if (
2942  !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
2943  !tolua_isusertype(tolua_S,2,"timeval",0,&tolua_err) ||
2944  !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
2945  !tolua_isnoobj(tolua_S,4,&tolua_err)
2946  )
2947  goto tolua_lerror;
2948  else
2949  {
2950  const fawkes::Clock* self = (const fawkes::Clock*) tolua_tousertype(tolua_S,1,0);
2951  struct timeval* tv = ((struct timeval*) tolua_tousertype(tolua_S,2,0));
2952  fawkes::Clock::TimesourceSelector sel = ((fawkes::Clock::TimesourceSelector) (int) tolua_tonumber(tolua_S,3,0));
2953 #ifndef TOLUA_RELEASE
2954  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_time'", NULL);
2955 #endif
2956  {
2957  self->get_time(tv,sel);
2958  }
2959  }
2960  return 0;
2961 tolua_lerror:
2962  return tolua_fawkesutils_fawkes_Clock_get_time04(tolua_S);
2963 }
2964 #endif //#ifndef TOLUA_DISABLE
2965 
2966 /* method: get_systime of class fawkes::Clock */
2967 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_get_systime00
2968 static int tolua_fawkesutils_fawkes_Clock_get_systime00(lua_State* tolua_S)
2969 {
2970 #ifndef TOLUA_RELEASE
2971  tolua_Error tolua_err;
2972  if (
2973  !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
2974  !tolua_isusertype(tolua_S,2,"timeval",0,&tolua_err) ||
2975  !tolua_isnoobj(tolua_S,3,&tolua_err)
2976  )
2977  goto tolua_lerror;
2978  else
2979 #endif
2980  {
2981  const fawkes::Clock* self = (const fawkes::Clock*) tolua_tousertype(tolua_S,1,0);
2982  struct timeval* tv = ((struct timeval*) tolua_tousertype(tolua_S,2,0));
2983 #ifndef TOLUA_RELEASE
2984  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_systime'", NULL);
2985 #endif
2986  {
2987  self->get_systime(tv);
2988  }
2989  }
2990  return 0;
2991 #ifndef TOLUA_RELEASE
2992  tolua_lerror:
2993  tolua_error(tolua_S,"#ferror in function 'get_systime'.",&tolua_err);
2994  return 0;
2995 #endif
2996 }
2997 #endif //#ifndef TOLUA_DISABLE
2998 
2999 /* method: get_systime of class fawkes::Clock */
3000 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_get_systime01
3001 static int tolua_fawkesutils_fawkes_Clock_get_systime01(lua_State* tolua_S)
3002 {
3003  tolua_Error tolua_err;
3004  if (
3005  !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
3006  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"fawkes::Time",0,&tolua_err)) ||
3007  !tolua_isnoobj(tolua_S,3,&tolua_err)
3008  )
3009  goto tolua_lerror;
3010  else
3011  {
3012  const fawkes::Clock* self = (const fawkes::Clock*) tolua_tousertype(tolua_S,1,0);
3013  fawkes::Time* time = ((fawkes::Time*) tolua_tousertype(tolua_S,2,0));
3014 #ifndef TOLUA_RELEASE
3015  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_systime'", NULL);
3016 #endif
3017  {
3018  self->get_systime(*time);
3019  }
3020  }
3021  return 0;
3022 tolua_lerror:
3023  return tolua_fawkesutils_fawkes_Clock_get_systime00(tolua_S);
3024 }
3025 #endif //#ifndef TOLUA_DISABLE
3026 
3027 /* method: get_systime of class fawkes::Clock */
3028 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_get_systime02
3029 static int tolua_fawkesutils_fawkes_Clock_get_systime02(lua_State* tolua_S)
3030 {
3031  tolua_Error tolua_err;
3032  if (
3033  !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
3034  !tolua_isusertype(tolua_S,2,"fawkes::Time",0,&tolua_err) ||
3035  !tolua_isnoobj(tolua_S,3,&tolua_err)
3036  )
3037  goto tolua_lerror;
3038  else
3039  {
3040  const fawkes::Clock* self = (const fawkes::Clock*) tolua_tousertype(tolua_S,1,0);
3041  fawkes::Time* time = ((fawkes::Time*) tolua_tousertype(tolua_S,2,0));
3042 #ifndef TOLUA_RELEASE
3043  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_systime'", NULL);
3044 #endif
3045  {
3046  self->get_systime(time);
3047  }
3048  }
3049  return 0;
3050 tolua_lerror:
3051  return tolua_fawkesutils_fawkes_Clock_get_systime01(tolua_S);
3052 }
3053 #endif //#ifndef TOLUA_DISABLE
3054 
3055 /* method: now of class fawkes::Clock */
3056 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_now00
3057 static int tolua_fawkesutils_fawkes_Clock_now00(lua_State* tolua_S)
3058 {
3059 #ifndef TOLUA_RELEASE
3060  tolua_Error tolua_err;
3061  if (
3062  !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
3063  !tolua_isnoobj(tolua_S,2,&tolua_err)
3064  )
3065  goto tolua_lerror;
3066  else
3067 #endif
3068  {
3069  const fawkes::Clock* self = (const fawkes::Clock*) tolua_tousertype(tolua_S,1,0);
3070 #ifndef TOLUA_RELEASE
3071  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'now'", NULL);
3072 #endif
3073  {
3074  fawkes::Time tolua_ret = (fawkes::Time) self->now();
3075  {
3076 #ifdef __cplusplus
3077  void* tolua_obj = Mtolua_new((fawkes::Time)(tolua_ret));
3078  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::Time");
3079  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
3080 #else
3081  void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::Time));
3082  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::Time");
3083  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
3084 #endif
3085  }
3086  }
3087  }
3088  return 1;
3089 #ifndef TOLUA_RELEASE
3090  tolua_lerror:
3091  tolua_error(tolua_S,"#ferror in function 'now'.",&tolua_err);
3092  return 0;
3093 #endif
3094 }
3095 #endif //#ifndef TOLUA_DISABLE
3096 
3097 /* method: elapsed of class fawkes::Clock */
3098 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_elapsed00
3099 static int tolua_fawkesutils_fawkes_Clock_elapsed00(lua_State* tolua_S)
3100 {
3101 #ifndef TOLUA_RELEASE
3102  tolua_Error tolua_err;
3103  if (
3104  !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
3105  !tolua_isusertype(tolua_S,2,"fawkes::Time",0,&tolua_err) ||
3106  !tolua_isnoobj(tolua_S,3,&tolua_err)
3107  )
3108  goto tolua_lerror;
3109  else
3110 #endif
3111  {
3112  const fawkes::Clock* self = (const fawkes::Clock*) tolua_tousertype(tolua_S,1,0);
3113  fawkes::Time* t = ((fawkes::Time*) tolua_tousertype(tolua_S,2,0));
3114 #ifndef TOLUA_RELEASE
3115  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'elapsed'", NULL);
3116 #endif
3117  {
3118  float tolua_ret = (float) self->elapsed(t);
3119  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
3120  }
3121  }
3122  return 1;
3123 #ifndef TOLUA_RELEASE
3124  tolua_lerror:
3125  tolua_error(tolua_S,"#ferror in function 'elapsed'.",&tolua_err);
3126  return 0;
3127 #endif
3128 }
3129 #endif //#ifndef TOLUA_DISABLE
3130 
3131 /* method: sys_elapsed of class fawkes::Clock */
3132 #ifndef TOLUA_DISABLE_tolua_fawkesutils_fawkes_Clock_sys_elapsed00
3133 static int tolua_fawkesutils_fawkes_Clock_sys_elapsed00(lua_State* tolua_S)
3134 {
3135 #ifndef TOLUA_RELEASE
3136  tolua_Error tolua_err;
3137  if (
3138  !tolua_isusertype(tolua_S,1,"const fawkes::Clock",0,&tolua_err) ||
3139  !tolua_isusertype(tolua_S,2,"fawkes::Time",0,&tolua_err) ||
3140  !tolua_isnoobj(tolua_S,3,&tolua_err)
3141  )
3142  goto tolua_lerror;
3143  else
3144 #endif
3145  {
3146  const fawkes::Clock* self = (const fawkes::Clock*) tolua_tousertype(tolua_S,1,0);
3147  fawkes::Time* t = ((fawkes::Time*) tolua_tousertype(tolua_S,2,0));
3148 #ifndef TOLUA_RELEASE
3149  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'sys_elapsed'", NULL);
3150 #endif
3151  {
3152  float tolua_ret = (float) self->sys_elapsed(t);
3153  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
3154  }
3155  }
3156  return 1;
3157 #ifndef TOLUA_RELEASE
3158  tolua_lerror:
3159  tolua_error(tolua_S,"#ferror in function 'sys_elapsed'.",&tolua_err);
3160  return 0;
3161 #endif
3162 }
3163 #endif //#ifndef TOLUA_DISABLE
3164 
3165 /* Open function */
3166 TOLUA_API int tolua_fawkesutils_open (lua_State* tolua_S)
3167 {
3168  tolua_open(tolua_S);
3169  tolua_reg_types(tolua_S);
3170  tolua_module(tolua_S,NULL,0);
3171  tolua_beginmodule(tolua_S,NULL);
3172  #ifdef __cplusplus
3173  tolua_cclass(tolua_S,"vector_string_","vector<string>","",tolua_collect_vector_string_);
3174  #else
3175  tolua_cclass(tolua_S,"vector_string_","vector<string>","",NULL);
3176  #endif
3177  tolua_beginmodule(tolua_S,"vector_string_");
3178  tolua_function(tolua_S,"clear",tolua_fawkesutils_vector_string__clear00);
3179  tolua_function(tolua_S,"size",tolua_fawkesutils_vector_string__size00);
3180  tolua_function(tolua_S,".geti",tolua_fawkesutils_vector_string___geti00);
3181  tolua_function(tolua_S,".seti",tolua_fawkesutils_vector_string___seti00);
3182  tolua_function(tolua_S,".geti",tolua_fawkesutils_vector_string___geti01);
3183  tolua_function(tolua_S,"push_back",tolua_fawkesutils_vector_string__push_back00);
3184  tolua_function(tolua_S,"new",tolua_fawkesutils_vector_string__new00);
3185  tolua_function(tolua_S,"new_local",tolua_fawkesutils_vector_string__new00_local);
3186  tolua_function(tolua_S,".call",tolua_fawkesutils_vector_string__new00_local);
3187  tolua_function(tolua_S,"delete",tolua_fawkesutils_vector_string__delete00);
3188  tolua_endmodule(tolua_S);
3189  #ifdef __cplusplus
3190  tolua_cclass(tolua_S,"vector_fawkes__RCSoftMapNode_","vector<fawkes::RCSoftMapNode>","",tolua_collect_vector_fawkes__RCSoftMapNode_);
3191  #else
3192  tolua_cclass(tolua_S,"vector_fawkes__RCSoftMapNode_","vector<fawkes::RCSoftMapNode>","",NULL);
3193  #endif
3194  tolua_beginmodule(tolua_S,"vector_fawkes__RCSoftMapNode_");
3195  tolua_function(tolua_S,"clear",tolua_fawkesutils_vector_fawkes__RCSoftMapNode__clear00);
3196  tolua_function(tolua_S,"size",tolua_fawkesutils_vector_fawkes__RCSoftMapNode__size00);
3197  tolua_function(tolua_S,".geti",tolua_fawkesutils_vector_fawkes__RCSoftMapNode___geti00);
3198  tolua_function(tolua_S,".seti",tolua_fawkesutils_vector_fawkes__RCSoftMapNode___seti00);
3199  tolua_function(tolua_S,".geti",tolua_fawkesutils_vector_fawkes__RCSoftMapNode___geti01);
3200  tolua_function(tolua_S,"push_back",tolua_fawkesutils_vector_fawkes__RCSoftMapNode__push_back00);
3201  tolua_function(tolua_S,"new",tolua_fawkesutils_vector_fawkes__RCSoftMapNode__new00);
3202  tolua_function(tolua_S,"new_local",tolua_fawkesutils_vector_fawkes__RCSoftMapNode__new00_local);
3203  tolua_function(tolua_S,".call",tolua_fawkesutils_vector_fawkes__RCSoftMapNode__new00_local);
3204  tolua_function(tolua_S,"delete",tolua_fawkesutils_vector_fawkes__RCSoftMapNode__delete00);
3205  tolua_endmodule(tolua_S);
3206  tolua_module(tolua_S,"fawkes",0);
3207  tolua_beginmodule(tolua_S,"fawkes");
3208  #ifdef __cplusplus
3209  tolua_cclass(tolua_S,"RCSoftMapNode","fawkes::RCSoftMapNode","",tolua_collect_fawkes__RCSoftMapNode);
3210  #else
3211  tolua_cclass(tolua_S,"RCSoftMapNode","fawkes::RCSoftMapNode","",NULL);
3212  #endif
3213  tolua_beginmodule(tolua_S,"RCSoftMapNode");
3214  tolua_function(tolua_S,"new",tolua_fawkesutils_fawkes_RCSoftMapNode_new00);
3215  tolua_function(tolua_S,"new_local",tolua_fawkesutils_fawkes_RCSoftMapNode_new00_local);
3216  tolua_function(tolua_S,".call",tolua_fawkesutils_fawkes_RCSoftMapNode_new00_local);
3217  tolua_function(tolua_S,"new",tolua_fawkesutils_fawkes_RCSoftMapNode_new01);
3218  tolua_function(tolua_S,"new_local",tolua_fawkesutils_fawkes_RCSoftMapNode_new01_local);
3219  tolua_function(tolua_S,".call",tolua_fawkesutils_fawkes_RCSoftMapNode_new01_local);
3220  tolua_function(tolua_S,"name",tolua_fawkesutils_fawkes_RCSoftMapNode_name00);
3221  tolua_function(tolua_S,"x",tolua_fawkesutils_fawkes_RCSoftMapNode_x00);
3222  tolua_function(tolua_S,"y",tolua_fawkesutils_fawkes_RCSoftMapNode_y00);
3223  tolua_function(tolua_S,"properties",tolua_fawkesutils_fawkes_RCSoftMapNode_properties00);
3224  tolua_function(tolua_S,"aliases",tolua_fawkesutils_fawkes_RCSoftMapNode_aliases00);
3225  tolua_function(tolua_S,"children",tolua_fawkesutils_fawkes_RCSoftMapNode_children00);
3226  tolua_function(tolua_S,"has_property",tolua_fawkesutils_fawkes_RCSoftMapNode_has_property00);
3227  tolua_function(tolua_S,"has_alias",tolua_fawkesutils_fawkes_RCSoftMapNode_has_alias00);
3228  tolua_endmodule(tolua_S);
3229  tolua_endmodule(tolua_S);
3230  tolua_module(tolua_S,"fawkes",0);
3231  tolua_beginmodule(tolua_S,"fawkes");
3232  #ifdef __cplusplus
3233  tolua_cclass(tolua_S,"RCSoftMapGraph","fawkes::RCSoftMapGraph","",tolua_collect_fawkes__RCSoftMapGraph);
3234  #else
3235  tolua_cclass(tolua_S,"RCSoftMapGraph","fawkes::RCSoftMapGraph","",NULL);
3236  #endif
3237  tolua_beginmodule(tolua_S,"RCSoftMapGraph");
3238  tolua_function(tolua_S,"new",tolua_fawkesutils_fawkes_RCSoftMapGraph_new00);
3239  tolua_function(tolua_S,"new_local",tolua_fawkesutils_fawkes_RCSoftMapGraph_new00_local);
3240  tolua_function(tolua_S,".call",tolua_fawkesutils_fawkes_RCSoftMapGraph_new00_local);
3241  tolua_function(tolua_S,"delete",tolua_fawkesutils_fawkes_RCSoftMapGraph_delete00);
3242  tolua_function(tolua_S,"graph_name",tolua_fawkesutils_fawkes_RCSoftMapGraph_graph_name00);
3243  tolua_function(tolua_S,"nodes",tolua_fawkesutils_fawkes_RCSoftMapGraph_nodes00);
3244  tolua_function(tolua_S,"node",tolua_fawkesutils_fawkes_RCSoftMapGraph_node00);
3245  tolua_function(tolua_S,"root_node",tolua_fawkesutils_fawkes_RCSoftMapGraph_root_node00);
3246  tolua_function(tolua_S,"closest_node",tolua_fawkesutils_fawkes_RCSoftMapGraph_closest_node00);
3247  tolua_function(tolua_S,"search_nodes",tolua_fawkesutils_fawkes_RCSoftMapGraph_search_nodes00);
3248  tolua_endmodule(tolua_S);
3249  tolua_endmodule(tolua_S);
3250  tolua_module(tolua_S,"fawkes",0);
3251  tolua_beginmodule(tolua_S,"fawkes");
3252  #ifdef __cplusplus
3253  tolua_cclass(tolua_S,"KalmanFilter1D","fawkes::KalmanFilter1D","",tolua_collect_fawkes__KalmanFilter1D);
3254  #else
3255  tolua_cclass(tolua_S,"KalmanFilter1D","fawkes::KalmanFilter1D","",NULL);
3256  #endif
3257  tolua_beginmodule(tolua_S,"KalmanFilter1D");
3258  tolua_function(tolua_S,"new",tolua_fawkesutils_fawkes_KalmanFilter1D_new00);
3259  tolua_function(tolua_S,"new_local",tolua_fawkesutils_fawkes_KalmanFilter1D_new00_local);
3260  tolua_function(tolua_S,".call",tolua_fawkesutils_fawkes_KalmanFilter1D_new00_local);
3261  tolua_function(tolua_S,"delete",tolua_fawkesutils_fawkes_KalmanFilter1D_delete00);
3262  tolua_function(tolua_S,"filter",tolua_fawkesutils_fawkes_KalmanFilter1D_filter00);
3263  tolua_function(tolua_S,"filter",tolua_fawkesutils_fawkes_KalmanFilter1D_filter01);
3264  tolua_function(tolua_S,"predict",tolua_fawkesutils_fawkes_KalmanFilter1D_predict00);
3265  tolua_function(tolua_S,"predict",tolua_fawkesutils_fawkes_KalmanFilter1D_predict01);
3266  tolua_function(tolua_S,"predict",tolua_fawkesutils_fawkes_KalmanFilter1D_predict02);
3267  tolua_function(tolua_S,"predict",tolua_fawkesutils_fawkes_KalmanFilter1D_predict03);
3268  tolua_endmodule(tolua_S);
3269  tolua_endmodule(tolua_S);
3270  tolua_cclass(tolua_S,"timeval","timeval","",NULL);
3271  tolua_beginmodule(tolua_S,"timeval");
3272  tolua_variable(tolua_S,"tv_sec",tolua_get_timeval_tv_sec,tolua_set_timeval_tv_sec);
3273  tolua_variable(tolua_S,"tv_usec",tolua_get_timeval_tv_usec,tolua_set_timeval_tv_usec);
3274  tolua_endmodule(tolua_S);
3275  tolua_module(tolua_S,"fawkes",0);
3276  tolua_beginmodule(tolua_S,"fawkes");
3277  #ifdef __cplusplus
3278  tolua_cclass(tolua_S,"Time","fawkes::Time","",tolua_collect_fawkes__Time);
3279  #else
3280  tolua_cclass(tolua_S,"Time","fawkes::Time","",NULL);
3281  #endif
3282  tolua_beginmodule(tolua_S,"Time");
3283  tolua_function(tolua_S,"new",tolua_fawkesutils_fawkes_Time_new00);
3284  tolua_function(tolua_S,"new_local",tolua_fawkesutils_fawkes_Time_new00_local);
3285  tolua_function(tolua_S,".call",tolua_fawkesutils_fawkes_Time_new00_local);
3286  tolua_function(tolua_S,"new",tolua_fawkesutils_fawkes_Time_new01);
3287  tolua_function(tolua_S,"new_local",tolua_fawkesutils_fawkes_Time_new01_local);
3288  tolua_function(tolua_S,".call",tolua_fawkesutils_fawkes_Time_new01_local);
3289  tolua_function(tolua_S,"new",tolua_fawkesutils_fawkes_Time_new02);
3290  tolua_function(tolua_S,"new_local",tolua_fawkesutils_fawkes_Time_new02_local);
3291  tolua_function(tolua_S,".call",tolua_fawkesutils_fawkes_Time_new02_local);
3292  tolua_function(tolua_S,"new",tolua_fawkesutils_fawkes_Time_new03);
3293  tolua_function(tolua_S,"new_local",tolua_fawkesutils_fawkes_Time_new03_local);
3294  tolua_function(tolua_S,".call",tolua_fawkesutils_fawkes_Time_new03_local);
3295  tolua_function(tolua_S,"new",tolua_fawkesutils_fawkes_Time_new04);
3296  tolua_function(tolua_S,"new_local",tolua_fawkesutils_fawkes_Time_new04_local);
3297  tolua_function(tolua_S,".call",tolua_fawkesutils_fawkes_Time_new04_local);
3298  tolua_function(tolua_S,"new",tolua_fawkesutils_fawkes_Time_new05);
3299  tolua_function(tolua_S,"new_local",tolua_fawkesutils_fawkes_Time_new05_local);
3300  tolua_function(tolua_S,".call",tolua_fawkesutils_fawkes_Time_new05_local);
3301  tolua_function(tolua_S,"new",tolua_fawkesutils_fawkes_Time_new06);
3302  tolua_function(tolua_S,"new_local",tolua_fawkesutils_fawkes_Time_new06_local);
3303  tolua_function(tolua_S,".call",tolua_fawkesutils_fawkes_Time_new06_local);
3304  tolua_function(tolua_S,"delete",tolua_fawkesutils_fawkes_Time_delete00);
3305  tolua_function(tolua_S,"in_sec",tolua_fawkesutils_fawkes_Time_in_sec00);
3306  tolua_function(tolua_S,"in_msec",tolua_fawkesutils_fawkes_Time_in_msec00);
3307  tolua_function(tolua_S,"in_usec",tolua_fawkesutils_fawkes_Time_in_usec00);
3308  tolua_function(tolua_S,"get_timeval",tolua_fawkesutils_fawkes_Time_get_timeval00);
3309  tolua_function(tolua_S,"set_time",tolua_fawkesutils_fawkes_Time_set_time00);
3310  tolua_function(tolua_S,"set_time",tolua_fawkesutils_fawkes_Time_set_time01);
3311  tolua_function(tolua_S,"set_time",tolua_fawkesutils_fawkes_Time_set_time02);
3312  tolua_function(tolua_S,"set_time",tolua_fawkesutils_fawkes_Time_set_time03);
3313  tolua_function(tolua_S,"add",tolua_fawkesutils_fawkes_Time_add00);
3314  tolua_function(tolua_S,"stamp",tolua_fawkesutils_fawkes_Time_stamp00);
3315  tolua_function(tolua_S,".add",tolua_fawkesutils_fawkes_Time__add00);
3316  tolua_function(tolua_S,".sub",tolua_fawkesutils_fawkes_Time__sub00);
3317  tolua_function(tolua_S,"str",tolua_fawkesutils_fawkes_Time_str00);
3318  tolua_function(tolua_S,"str_r",tolua_fawkesutils_fawkes_Time_str_r00);
3319  tolua_endmodule(tolua_S);
3320  tolua_endmodule(tolua_S);
3321  tolua_module(tolua_S,"fawkes",0);
3322  tolua_beginmodule(tolua_S,"fawkes");
3323  tolua_cclass(tolua_S,"Clock","fawkes::Clock","",NULL);
3324  tolua_beginmodule(tolua_S,"Clock");
3325  tolua_constant(tolua_S,"DEFAULT",fawkes::Clock::DEFAULT);
3326  tolua_constant(tolua_S,"REALTIME",fawkes::Clock::REALTIME);
3327  tolua_constant(tolua_S,"EXTERNAL",fawkes::Clock::EXTERNAL);
3328  tolua_function(tolua_S,"instance",tolua_fawkesutils_fawkes_Clock_instance00);
3329  tolua_function(tolua_S,"finalize",tolua_fawkesutils_fawkes_Clock_finalize00);
3330  tolua_function(tolua_S,"is_ext_default_timesource",tolua_fawkesutils_fawkes_Clock_is_ext_default_timesource00);
3331  tolua_function(tolua_S,"has_ext_timesource",tolua_fawkesutils_fawkes_Clock_has_ext_timesource00);
3332  tolua_function(tolua_S,"ext_to_realtime",tolua_fawkesutils_fawkes_Clock_ext_to_realtime00);
3333  tolua_function(tolua_S,"get_time",tolua_fawkesutils_fawkes_Clock_get_time00);
3334  tolua_function(tolua_S,"get_time",tolua_fawkesutils_fawkes_Clock_get_time01);
3335  tolua_function(tolua_S,"get_time",tolua_fawkesutils_fawkes_Clock_get_time02);
3336  tolua_function(tolua_S,"get_time",tolua_fawkesutils_fawkes_Clock_get_time03);
3337  tolua_function(tolua_S,"get_time",tolua_fawkesutils_fawkes_Clock_get_time04);
3338  tolua_function(tolua_S,"get_time",tolua_fawkesutils_fawkes_Clock_get_time05);
3339  tolua_function(tolua_S,"get_systime",tolua_fawkesutils_fawkes_Clock_get_systime00);
3340  tolua_function(tolua_S,"get_systime",tolua_fawkesutils_fawkes_Clock_get_systime01);
3341  tolua_function(tolua_S,"get_systime",tolua_fawkesutils_fawkes_Clock_get_systime02);
3342  tolua_function(tolua_S,"now",tolua_fawkesutils_fawkes_Clock_now00);
3343  tolua_function(tolua_S,"elapsed",tolua_fawkesutils_fawkes_Clock_elapsed00);
3344  tolua_function(tolua_S,"sys_elapsed",tolua_fawkesutils_fawkes_Clock_sys_elapsed00);
3345  tolua_endmodule(tolua_S);
3346  tolua_endmodule(tolua_S);
3347  tolua_endmodule(tolua_S);
3348  return 1;
3349 }
3350 
3351 
3352 extern "C" {
3353 #if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501
3354  TOLUA_API int luaopen_fawkesutils (lua_State* tolua_S) {
3355  return tolua_fawkesutils_open(tolua_S);
3356 };
3357 #endif
3358 }
3359 
3360