Fawkes API  Fawkes Development Version
fawkestf_tolua.cpp
1 /*
2 ** Lua binding: fawkestf
3 ** Generated automatically by tolua++-1.0.92
4 */
5 /* This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 2 of the License, or
8  * (at your option) any later version. A runtime exception applies to
9  * this software (see LICENSE.GPL_WRE file mentioned below for details).
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14  * GNU Library General Public License for more details.
15  *
16  * Read the full text in the LICENSE.GPL_WRE file in the doc directory.
17  */
18 
19 #include <core/exception.h>
20 
21 #ifndef __cplusplus
22 #include "stdlib.h"
23 #endif
24 #include "string.h"
25 
26 #include "tolua++.h"
27 
28 /* Exported function */
29 TOLUA_API int tolua_fawkestf_open (lua_State* tolua_S);
30 
31 #include <tf/types_lua.h>
32 #include <tf/transformer.h>
33 #include <tf/types.h>
34 #include <tf/utils.h>
35 
36 /* function to release collected object via destructor */
37 #ifdef __cplusplus
38 
39 static int tolua_collect_fawkes__tf__StampedTransform (lua_State* tolua_S)
40 {
41  fawkes::tf::StampedTransform* self = (fawkes::tf::StampedTransform*) tolua_tousertype(tolua_S,1,0);
42  Mtolua_delete(self);
43  return 0;
44 }
45 
46 static int tolua_collect_fawkes__tf__Quaternion (lua_State* tolua_S)
47 {
48  fawkes::tf::Quaternion* self = (fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,1,0);
49  Mtolua_delete(self);
50  return 0;
51 }
52 
53 static int tolua_collect_fawkes__tf__Stamped_fawkes__tf__Quaternion_ (lua_State* tolua_S)
54 {
56  Mtolua_delete(self);
57  return 0;
58 }
59 
60 static int tolua_collect_fawkes__tf__Point (lua_State* tolua_S)
61 {
62  fawkes::tf::Point* self = (fawkes::tf::Point*) tolua_tousertype(tolua_S,1,0);
63  Mtolua_delete(self);
64  return 0;
65 }
66 
67 static int tolua_collect_fawkes__tf__Pose (lua_State* tolua_S)
68 {
69  fawkes::tf::Pose* self = (fawkes::tf::Pose*) tolua_tousertype(tolua_S,1,0);
70  Mtolua_delete(self);
71  return 0;
72 }
73 
74 static int tolua_collect_fawkes__tf__Stamped_fawkes__tf__Pose_ (lua_State* tolua_S)
75 {
77  Mtolua_delete(self);
78  return 0;
79 }
80 
81 static int tolua_collect_fawkes__tf__Vector3 (lua_State* tolua_S)
82 {
83  fawkes::tf::Vector3* self = (fawkes::tf::Vector3*) tolua_tousertype(tolua_S,1,0);
84  Mtolua_delete(self);
85  return 0;
86 }
87 
88 static int tolua_collect_fawkes__tf__StampedPose (lua_State* tolua_S)
89 {
90  fawkes::tf::StampedPose* self = (fawkes::tf::StampedPose*) tolua_tousertype(tolua_S,1,0);
91  Mtolua_delete(self);
92  return 0;
93 }
94 
95 static int tolua_collect_fawkes__tf__StampedVector3 (lua_State* tolua_S)
96 {
97  fawkes::tf::StampedVector3* self = (fawkes::tf::StampedVector3*) tolua_tousertype(tolua_S,1,0);
98  Mtolua_delete(self);
99  return 0;
100 }
101 
102 static int tolua_collect_fawkes__tf__Stamped_fawkes__tf__Point_ (lua_State* tolua_S)
103 {
105  Mtolua_delete(self);
106  return 0;
107 }
108 
109 static int tolua_collect_fawkes__tf__StampedPoint (lua_State* tolua_S)
110 {
111  fawkes::tf::StampedPoint* self = (fawkes::tf::StampedPoint*) tolua_tousertype(tolua_S,1,0);
112  Mtolua_delete(self);
113  return 0;
114 }
115 
116 static int tolua_collect_fawkes__tf__Transform (lua_State* tolua_S)
117 {
118  fawkes::tf::Transform* self = (fawkes::tf::Transform*) tolua_tousertype(tolua_S,1,0);
119  Mtolua_delete(self);
120  return 0;
121 }
122 
123 static int tolua_collect_fawkes__tf__StampedQuaternion (lua_State* tolua_S)
124 {
125  fawkes::tf::StampedQuaternion* self = (fawkes::tf::StampedQuaternion*) tolua_tousertype(tolua_S,1,0);
126  Mtolua_delete(self);
127  return 0;
128 }
129 
130 static int tolua_collect_fawkes__tf__Stamped_fawkes__tf__Vector3_ (lua_State* tolua_S)
131 {
133  Mtolua_delete(self);
134  return 0;
135 }
136 #endif
137 
138 
139 /* function to register type */
140 static void tolua_reg_types (lua_State* tolua_S)
141 {
142  tolua_usertype(tolua_S,"fawkes::tf::StampedTransform");
143  tolua_usertype(tolua_S,"fawkes::tf::Quaternion");
144  tolua_usertype(tolua_S,"fawkes::tf::Stamped<fawkes::tf::Quaternion>");
145  tolua_usertype(tolua_S,"fawkes::tf::Point");
146  tolua_usertype(tolua_S,"fawkes::tf::Transformer");
147  tolua_usertype(tolua_S,"fawkes::tf::Pose");
148  tolua_usertype(tolua_S,"fawkes::tf::Stamped<fawkes::tf::Pose>");
149  tolua_usertype(tolua_S,"fawkes::tf::Vector3");
150  tolua_usertype(tolua_S,"fawkes::tf::StampedPose");
151  tolua_usertype(tolua_S,"fawkes::tf::StampedQuaternion");
152  tolua_usertype(tolua_S,"fawkes::tf::StampedVector3");
153  tolua_usertype(tolua_S,"fawkes::tf::Stamped<fawkes::tf::Point>");
154  tolua_usertype(tolua_S,"fawkes::tf::StampedPoint");
155  tolua_usertype(tolua_S,"fawkes::tf::Transform");
156  tolua_usertype(tolua_S,"fawkes::Time");
157  tolua_usertype(tolua_S,"fawkes::tf::Stamped<fawkes::tf::Vector3>");
158 }
159 
160 /* function: fawkes::tf::get_yaw */
161 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_get_yaw00
162 static int tolua_fawkestf_fawkes_tf_get_yaw00(lua_State* tolua_S)
163 {
164 #ifndef TOLUA_RELEASE
165  tolua_Error tolua_err;
166  if (
167  (tolua_isvaluenil(tolua_S,1,&tolua_err) || !tolua_isusertype(tolua_S,1,"const fawkes::tf::Quaternion",0,&tolua_err)) ||
168  !tolua_isnoobj(tolua_S,2,&tolua_err)
169  )
170  goto tolua_lerror;
171  else
172 #endif
173  {
174  const fawkes::tf::Quaternion* bt_q = ((const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,1,0));
175  bool exc_caught = false;
176  try {
177  {
178  double tolua_ret = (double) fawkes::tf::get_yaw(*bt_q);
179  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
180  }
181  } catch (fawkes::Exception &e) {
182  exc_caught = true;
183  lua_pushstring(tolua_S, e.what_no_backtrace());
184  }
185  catch (std::exception &e) {
186  exc_caught = true;
187  lua_pushstring(tolua_S, e.what());
188  }
189  if (exc_caught) lua_error(tolua_S);
190 
191  }
192  return 1;
193 #ifndef TOLUA_RELEASE
194  tolua_lerror:
195  tolua_error(tolua_S,"#ferror in function 'get_yaw'.",&tolua_err);
196  return 0;
197 #endif
198 }
199 #endif //#ifndef TOLUA_DISABLE
200 
201 /* function: fawkes::tf::create_quaternion_from_rpy */
202 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_create_quaternion_from_rpy00
203 static int tolua_fawkestf_fawkes_tf_create_quaternion_from_rpy00(lua_State* tolua_S)
204 {
205 #ifndef TOLUA_RELEASE
206  tolua_Error tolua_err;
207  if (
208  !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
209  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
210  !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
211  !tolua_isnoobj(tolua_S,4,&tolua_err)
212  )
213  goto tolua_lerror;
214  else
215 #endif
216  {
217  double roll = ((double) tolua_tonumber(tolua_S,1,0));
218  double pitch = ((double) tolua_tonumber(tolua_S,2,0));
219  double yaw = ((double) tolua_tonumber(tolua_S,3,0));
220  bool exc_caught = false;
221  try {
222  {
223  fawkes::tf::Quaternion tolua_ret = (fawkes::tf::Quaternion) fawkes::tf::create_quaternion_from_rpy(roll,pitch,yaw);
224  {
225 #ifdef __cplusplus
226  void* tolua_obj = Mtolua_new((fawkes::tf::Quaternion)(tolua_ret));
227  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::tf::Quaternion");
228  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
229 #else
230  void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::tf::Quaternion));
231  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::tf::Quaternion");
232  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
233 #endif
234  }
235  }
236  } catch (fawkes::Exception &e) {
237  exc_caught = true;
238  lua_pushstring(tolua_S, e.what_no_backtrace());
239  }
240  catch (std::exception &e) {
241  exc_caught = true;
242  lua_pushstring(tolua_S, e.what());
243  }
244  if (exc_caught) lua_error(tolua_S);
245 
246  }
247  return 1;
248 #ifndef TOLUA_RELEASE
249  tolua_lerror:
250  tolua_error(tolua_S,"#ferror in function 'create_quaternion_from_rpy'.",&tolua_err);
251  return 0;
252 #endif
253 }
254 #endif //#ifndef TOLUA_DISABLE
255 
256 /* function: fawkes::tf::create_quaternion_from_yaw */
257 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_create_quaternion_from_yaw00
258 static int tolua_fawkestf_fawkes_tf_create_quaternion_from_yaw00(lua_State* tolua_S)
259 {
260 #ifndef TOLUA_RELEASE
261  tolua_Error tolua_err;
262  if (
263  !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
264  !tolua_isnoobj(tolua_S,2,&tolua_err)
265  )
266  goto tolua_lerror;
267  else
268 #endif
269  {
270  double yaw = ((double) tolua_tonumber(tolua_S,1,0));
271  bool exc_caught = false;
272  try {
273  {
274  fawkes::tf::Quaternion tolua_ret = (fawkes::tf::Quaternion) fawkes::tf::create_quaternion_from_yaw(yaw);
275  {
276 #ifdef __cplusplus
277  void* tolua_obj = Mtolua_new((fawkes::tf::Quaternion)(tolua_ret));
278  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::tf::Quaternion");
279  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
280 #else
281  void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::tf::Quaternion));
282  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::tf::Quaternion");
283  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
284 #endif
285  }
286  }
287  } catch (fawkes::Exception &e) {
288  exc_caught = true;
289  lua_pushstring(tolua_S, e.what_no_backtrace());
290  }
291  catch (std::exception &e) {
292  exc_caught = true;
293  lua_pushstring(tolua_S, e.what());
294  }
295  if (exc_caught) lua_error(tolua_S);
296 
297  }
298  return 1;
299 #ifndef TOLUA_RELEASE
300  tolua_lerror:
301  tolua_error(tolua_S,"#ferror in function 'create_quaternion_from_yaw'.",&tolua_err);
302  return 0;
303 #endif
304 }
305 #endif //#ifndef TOLUA_DISABLE
306 
307 /* function: fawkes::tf::resize_vector */
308 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_resize_vector00
309 static int tolua_fawkestf_fawkes_tf_resize_vector00(lua_State* tolua_S)
310 {
311 #ifndef TOLUA_RELEASE
312  tolua_Error tolua_err;
313  if (
314  (tolua_isvaluenil(tolua_S,1,&tolua_err) || !tolua_isusertype(tolua_S,1,"const fawkes::tf::Vector3",0,&tolua_err)) ||
315  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
316  !tolua_isnoobj(tolua_S,3,&tolua_err)
317  )
318  goto tolua_lerror;
319  else
320 #endif
321  {
322  const fawkes::tf::Vector3* v = ((const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,1,0));
323  double s = ((double) tolua_tonumber(tolua_S,2,0));
324  bool exc_caught = false;
325  try {
326  {
327  fawkes::tf::Vector3 tolua_ret = (fawkes::tf::Vector3) fawkes::tf::resize_vector(*v,s);
328  {
329 #ifdef __cplusplus
330  void* tolua_obj = Mtolua_new((fawkes::tf::Vector3)(tolua_ret));
331  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::tf::Vector3");
332  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
333 #else
334  void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::tf::Vector3));
335  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::tf::Vector3");
336  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
337 #endif
338  }
339  }
340  } catch (fawkes::Exception &e) {
341  exc_caught = true;
342  lua_pushstring(tolua_S, e.what_no_backtrace());
343  }
344  catch (std::exception &e) {
345  exc_caught = true;
346  lua_pushstring(tolua_S, e.what());
347  }
348  if (exc_caught) lua_error(tolua_S);
349 
350  }
351  return 1;
352 #ifndef TOLUA_RELEASE
353  tolua_lerror:
354  tolua_error(tolua_S,"#ferror in function 'resize_vector'.",&tolua_err);
355  return 0;
356 #endif
357 }
358 #endif //#ifndef TOLUA_DISABLE
359 
360 /* method: new of class fawkes::tf::Vector3 */
361 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_new00
362 static int tolua_fawkestf_fawkes_tf_Vector3_new00(lua_State* tolua_S)
363 {
364 #ifndef TOLUA_RELEASE
365  tolua_Error tolua_err;
366  if (
367  !tolua_isusertable(tolua_S,1,"fawkes::tf::Vector3",0,&tolua_err) ||
368  !tolua_isnoobj(tolua_S,2,&tolua_err)
369  )
370  goto tolua_lerror;
371  else
372 #endif
373  {
374  bool exc_caught = false;
375  try {
376  {
377  fawkes::tf::Vector3* tolua_ret = (fawkes::tf::Vector3*) Mtolua_new((fawkes::tf::Vector3)());
378  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Vector3");
379  }
380  } catch (fawkes::Exception &e) {
381  exc_caught = true;
382  lua_pushstring(tolua_S, e.what_no_backtrace());
383  }
384  catch (std::exception &e) {
385  exc_caught = true;
386  lua_pushstring(tolua_S, e.what());
387  }
388  if (exc_caught) lua_error(tolua_S);
389 
390  }
391  return 1;
392 #ifndef TOLUA_RELEASE
393  tolua_lerror:
394  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
395  return 0;
396 #endif
397 }
398 #endif //#ifndef TOLUA_DISABLE
399 
400 /* method: new_local of class fawkes::tf::Vector3 */
401 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_new00_local
402 static int tolua_fawkestf_fawkes_tf_Vector3_new00_local(lua_State* tolua_S)
403 {
404 #ifndef TOLUA_RELEASE
405  tolua_Error tolua_err;
406  if (
407  !tolua_isusertable(tolua_S,1,"fawkes::tf::Vector3",0,&tolua_err) ||
408  !tolua_isnoobj(tolua_S,2,&tolua_err)
409  )
410  goto tolua_lerror;
411  else
412 #endif
413  {
414  bool exc_caught = false;
415  try {
416  {
417  fawkes::tf::Vector3* tolua_ret = (fawkes::tf::Vector3*) Mtolua_new((fawkes::tf::Vector3)());
418  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Vector3");
419  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
420  }
421  } catch (fawkes::Exception &e) {
422  exc_caught = true;
423  lua_pushstring(tolua_S, e.what_no_backtrace());
424  }
425  catch (std::exception &e) {
426  exc_caught = true;
427  lua_pushstring(tolua_S, e.what());
428  }
429  if (exc_caught) lua_error(tolua_S);
430 
431  }
432  return 1;
433 #ifndef TOLUA_RELEASE
434  tolua_lerror:
435  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
436  return 0;
437 #endif
438 }
439 #endif //#ifndef TOLUA_DISABLE
440 
441 /* method: new of class fawkes::tf::Vector3 */
442 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_new01
443 static int tolua_fawkestf_fawkes_tf_Vector3_new01(lua_State* tolua_S)
444 {
445  tolua_Error tolua_err;
446  if (
447  !tolua_isusertable(tolua_S,1,"fawkes::tf::Vector3",0,&tolua_err) ||
448  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
449  !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
450  !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
451  !tolua_isnoobj(tolua_S,5,&tolua_err)
452  )
453  goto tolua_lerror;
454  else
455  {
456  double x = ((double) tolua_tonumber(tolua_S,2,0));
457  double y = ((double) tolua_tonumber(tolua_S,3,0));
458  double z = ((double) tolua_tonumber(tolua_S,4,0));
459  bool exc_caught = false;
460  try {
461  {
462  fawkes::tf::Vector3* tolua_ret = (fawkes::tf::Vector3*) Mtolua_new((fawkes::tf::Vector3)(x,y,z));
463  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Vector3");
464  }
465  } catch (fawkes::Exception &e) {
466  exc_caught = true;
467  lua_pushstring(tolua_S, e.what_no_backtrace());
468  }
469  catch (std::exception &e) {
470  exc_caught = true;
471  lua_pushstring(tolua_S, e.what());
472  }
473  if (exc_caught) lua_error(tolua_S);
474 
475  }
476  return 1;
477 tolua_lerror:
478  return tolua_fawkestf_fawkes_tf_Vector3_new00(tolua_S);
479 }
480 #endif //#ifndef TOLUA_DISABLE
481 
482 /* method: new_local of class fawkes::tf::Vector3 */
483 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_new01_local
484 static int tolua_fawkestf_fawkes_tf_Vector3_new01_local(lua_State* tolua_S)
485 {
486  tolua_Error tolua_err;
487  if (
488  !tolua_isusertable(tolua_S,1,"fawkes::tf::Vector3",0,&tolua_err) ||
489  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
490  !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
491  !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
492  !tolua_isnoobj(tolua_S,5,&tolua_err)
493  )
494  goto tolua_lerror;
495  else
496  {
497  double x = ((double) tolua_tonumber(tolua_S,2,0));
498  double y = ((double) tolua_tonumber(tolua_S,3,0));
499  double z = ((double) tolua_tonumber(tolua_S,4,0));
500  bool exc_caught = false;
501  try {
502  {
503  fawkes::tf::Vector3* tolua_ret = (fawkes::tf::Vector3*) Mtolua_new((fawkes::tf::Vector3)(x,y,z));
504  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Vector3");
505  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
506  }
507  } catch (fawkes::Exception &e) {
508  exc_caught = true;
509  lua_pushstring(tolua_S, e.what_no_backtrace());
510  }
511  catch (std::exception &e) {
512  exc_caught = true;
513  lua_pushstring(tolua_S, e.what());
514  }
515  if (exc_caught) lua_error(tolua_S);
516 
517  }
518  return 1;
519 tolua_lerror:
520  return tolua_fawkestf_fawkes_tf_Vector3_new00_local(tolua_S);
521 }
522 #endif //#ifndef TOLUA_DISABLE
523 
524 /* method: dot of class fawkes::tf::Vector3 */
525 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_dot00
526 static int tolua_fawkestf_fawkes_tf_Vector3_dot00(lua_State* tolua_S)
527 {
528 #ifndef TOLUA_RELEASE
529  tolua_Error tolua_err;
530  if (
531  !tolua_isusertype(tolua_S,1,"const fawkes::tf::Vector3",0,&tolua_err) ||
532  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Vector3",0,&tolua_err)) ||
533  !tolua_isnoobj(tolua_S,3,&tolua_err)
534  )
535  goto tolua_lerror;
536  else
537 #endif
538  {
539  const fawkes::tf::Vector3* self = (const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,1,0);
540  const fawkes::tf::Vector3* q = ((const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,2,0));
541 #ifndef TOLUA_RELEASE
542  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'dot'", NULL);
543 #endif
544  bool exc_caught = false;
545  try {
546  {
547  double tolua_ret = (double) self->dot(*q);
548  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
549  }
550  } catch (fawkes::Exception &e) {
551  exc_caught = true;
552  lua_pushstring(tolua_S, e.what_no_backtrace());
553  }
554  catch (std::exception &e) {
555  exc_caught = true;
556  lua_pushstring(tolua_S, e.what());
557  }
558  if (exc_caught) lua_error(tolua_S);
559 
560  }
561  return 1;
562 #ifndef TOLUA_RELEASE
563  tolua_lerror:
564  tolua_error(tolua_S,"#ferror in function 'dot'.",&tolua_err);
565  return 0;
566 #endif
567 }
568 #endif //#ifndef TOLUA_DISABLE
569 
570 /* method: length2 of class fawkes::tf::Vector3 */
571 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_length200
572 static int tolua_fawkestf_fawkes_tf_Vector3_length200(lua_State* tolua_S)
573 {
574 #ifndef TOLUA_RELEASE
575  tolua_Error tolua_err;
576  if (
577  !tolua_isusertype(tolua_S,1,"const fawkes::tf::Vector3",0,&tolua_err) ||
578  !tolua_isnoobj(tolua_S,2,&tolua_err)
579  )
580  goto tolua_lerror;
581  else
582 #endif
583  {
584  const fawkes::tf::Vector3* self = (const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,1,0);
585 #ifndef TOLUA_RELEASE
586  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'length2'", NULL);
587 #endif
588  bool exc_caught = false;
589  try {
590  {
591  double tolua_ret = (double) self->length2();
592  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
593  }
594  } catch (fawkes::Exception &e) {
595  exc_caught = true;
596  lua_pushstring(tolua_S, e.what_no_backtrace());
597  }
598  catch (std::exception &e) {
599  exc_caught = true;
600  lua_pushstring(tolua_S, e.what());
601  }
602  if (exc_caught) lua_error(tolua_S);
603 
604  }
605  return 1;
606 #ifndef TOLUA_RELEASE
607  tolua_lerror:
608  tolua_error(tolua_S,"#ferror in function 'length2'.",&tolua_err);
609  return 0;
610 #endif
611 }
612 #endif //#ifndef TOLUA_DISABLE
613 
614 /* method: length of class fawkes::tf::Vector3 */
615 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_length00
616 static int tolua_fawkestf_fawkes_tf_Vector3_length00(lua_State* tolua_S)
617 {
618 #ifndef TOLUA_RELEASE
619  tolua_Error tolua_err;
620  if (
621  !tolua_isusertype(tolua_S,1,"const fawkes::tf::Vector3",0,&tolua_err) ||
622  !tolua_isnoobj(tolua_S,2,&tolua_err)
623  )
624  goto tolua_lerror;
625  else
626 #endif
627  {
628  const fawkes::tf::Vector3* self = (const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,1,0);
629 #ifndef TOLUA_RELEASE
630  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'length'", NULL);
631 #endif
632  bool exc_caught = false;
633  try {
634  {
635  double tolua_ret = (double) self->length();
636  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
637  }
638  } catch (fawkes::Exception &e) {
639  exc_caught = true;
640  lua_pushstring(tolua_S, e.what_no_backtrace());
641  }
642  catch (std::exception &e) {
643  exc_caught = true;
644  lua_pushstring(tolua_S, e.what());
645  }
646  if (exc_caught) lua_error(tolua_S);
647 
648  }
649  return 1;
650 #ifndef TOLUA_RELEASE
651  tolua_lerror:
652  tolua_error(tolua_S,"#ferror in function 'length'.",&tolua_err);
653  return 0;
654 #endif
655 }
656 #endif //#ifndef TOLUA_DISABLE
657 
658 /* method: distance2 of class fawkes::tf::Vector3 */
659 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_distance200
660 static int tolua_fawkestf_fawkes_tf_Vector3_distance200(lua_State* tolua_S)
661 {
662 #ifndef TOLUA_RELEASE
663  tolua_Error tolua_err;
664  if (
665  !tolua_isusertype(tolua_S,1,"const fawkes::tf::Vector3",0,&tolua_err) ||
666  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Vector3",0,&tolua_err)) ||
667  !tolua_isnoobj(tolua_S,3,&tolua_err)
668  )
669  goto tolua_lerror;
670  else
671 #endif
672  {
673  const fawkes::tf::Vector3* self = (const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,1,0);
674  const fawkes::tf::Vector3* v = ((const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,2,0));
675 #ifndef TOLUA_RELEASE
676  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'distance2'", NULL);
677 #endif
678  bool exc_caught = false;
679  try {
680  {
681  double tolua_ret = (double) self->distance2(*v);
682  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
683  }
684  } catch (fawkes::Exception &e) {
685  exc_caught = true;
686  lua_pushstring(tolua_S, e.what_no_backtrace());
687  }
688  catch (std::exception &e) {
689  exc_caught = true;
690  lua_pushstring(tolua_S, e.what());
691  }
692  if (exc_caught) lua_error(tolua_S);
693 
694  }
695  return 1;
696 #ifndef TOLUA_RELEASE
697  tolua_lerror:
698  tolua_error(tolua_S,"#ferror in function 'distance2'.",&tolua_err);
699  return 0;
700 #endif
701 }
702 #endif //#ifndef TOLUA_DISABLE
703 
704 /* method: distance of class fawkes::tf::Vector3 */
705 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_distance00
706 static int tolua_fawkestf_fawkes_tf_Vector3_distance00(lua_State* tolua_S)
707 {
708 #ifndef TOLUA_RELEASE
709  tolua_Error tolua_err;
710  if (
711  !tolua_isusertype(tolua_S,1,"const fawkes::tf::Vector3",0,&tolua_err) ||
712  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Vector3",0,&tolua_err)) ||
713  !tolua_isnoobj(tolua_S,3,&tolua_err)
714  )
715  goto tolua_lerror;
716  else
717 #endif
718  {
719  const fawkes::tf::Vector3* self = (const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,1,0);
720  const fawkes::tf::Vector3* v = ((const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,2,0));
721 #ifndef TOLUA_RELEASE
722  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'distance'", NULL);
723 #endif
724  bool exc_caught = false;
725  try {
726  {
727  double tolua_ret = (double) self->distance(*v);
728  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
729  }
730  } catch (fawkes::Exception &e) {
731  exc_caught = true;
732  lua_pushstring(tolua_S, e.what_no_backtrace());
733  }
734  catch (std::exception &e) {
735  exc_caught = true;
736  lua_pushstring(tolua_S, e.what());
737  }
738  if (exc_caught) lua_error(tolua_S);
739 
740  }
741  return 1;
742 #ifndef TOLUA_RELEASE
743  tolua_lerror:
744  tolua_error(tolua_S,"#ferror in function 'distance'.",&tolua_err);
745  return 0;
746 #endif
747 }
748 #endif //#ifndef TOLUA_DISABLE
749 
750 /* method: normalize of class fawkes::tf::Vector3 */
751 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_normalize00
752 static int tolua_fawkestf_fawkes_tf_Vector3_normalize00(lua_State* tolua_S)
753 {
754 #ifndef TOLUA_RELEASE
755  tolua_Error tolua_err;
756  if (
757  !tolua_isusertype(tolua_S,1,"fawkes::tf::Vector3",0,&tolua_err) ||
758  !tolua_isnoobj(tolua_S,2,&tolua_err)
759  )
760  goto tolua_lerror;
761  else
762 #endif
763  {
764  fawkes::tf::Vector3* self = (fawkes::tf::Vector3*) tolua_tousertype(tolua_S,1,0);
765 #ifndef TOLUA_RELEASE
766  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'normalize'", NULL);
767 #endif
768  bool exc_caught = false;
769  try {
770  {
771  fawkes::tf::Vector3& tolua_ret = (fawkes::tf::Vector3&) self->normalize();
772  tolua_pushusertype(tolua_S,(void*)&tolua_ret,"fawkes::tf::Vector3");
773  }
774  } catch (fawkes::Exception &e) {
775  exc_caught = true;
776  lua_pushstring(tolua_S, e.what_no_backtrace());
777  }
778  catch (std::exception &e) {
779  exc_caught = true;
780  lua_pushstring(tolua_S, e.what());
781  }
782  if (exc_caught) lua_error(tolua_S);
783 
784  }
785  return 1;
786 #ifndef TOLUA_RELEASE
787  tolua_lerror:
788  tolua_error(tolua_S,"#ferror in function 'normalize'.",&tolua_err);
789  return 0;
790 #endif
791 }
792 #endif //#ifndef TOLUA_DISABLE
793 
794 /* method: normalized of class fawkes::tf::Vector3 */
795 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_normalized00
796 static int tolua_fawkestf_fawkes_tf_Vector3_normalized00(lua_State* tolua_S)
797 {
798 #ifndef TOLUA_RELEASE
799  tolua_Error tolua_err;
800  if (
801  !tolua_isusertype(tolua_S,1,"fawkes::tf::Vector3",0,&tolua_err) ||
802  !tolua_isnoobj(tolua_S,2,&tolua_err)
803  )
804  goto tolua_lerror;
805  else
806 #endif
807  {
808  fawkes::tf::Vector3* self = (fawkes::tf::Vector3*) tolua_tousertype(tolua_S,1,0);
809 #ifndef TOLUA_RELEASE
810  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'normalized'", NULL);
811 #endif
812  bool exc_caught = false;
813  try {
814  {
815  fawkes::tf::Vector3 tolua_ret = (fawkes::tf::Vector3) self->normalized();
816  {
817 #ifdef __cplusplus
818  void* tolua_obj = Mtolua_new((fawkes::tf::Vector3)(tolua_ret));
819  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::tf::Vector3");
820  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
821 #else
822  void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::tf::Vector3));
823  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::tf::Vector3");
824  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
825 #endif
826  }
827  }
828  } catch (fawkes::Exception &e) {
829  exc_caught = true;
830  lua_pushstring(tolua_S, e.what_no_backtrace());
831  }
832  catch (std::exception &e) {
833  exc_caught = true;
834  lua_pushstring(tolua_S, e.what());
835  }
836  if (exc_caught) lua_error(tolua_S);
837 
838  }
839  return 1;
840 #ifndef TOLUA_RELEASE
841  tolua_lerror:
842  tolua_error(tolua_S,"#ferror in function 'normalized'.",&tolua_err);
843  return 0;
844 #endif
845 }
846 #endif //#ifndef TOLUA_DISABLE
847 
848 /* method: rotate of class fawkes::tf::Vector3 */
849 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_rotate00
850 static int tolua_fawkestf_fawkes_tf_Vector3_rotate00(lua_State* tolua_S)
851 {
852 #ifndef TOLUA_RELEASE
853  tolua_Error tolua_err;
854  if (
855  !tolua_isusertype(tolua_S,1,"fawkes::tf::Vector3",0,&tolua_err) ||
856  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Vector3",0,&tolua_err)) ||
857  !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
858  !tolua_isnoobj(tolua_S,4,&tolua_err)
859  )
860  goto tolua_lerror;
861  else
862 #endif
863  {
864  fawkes::tf::Vector3* self = (fawkes::tf::Vector3*) tolua_tousertype(tolua_S,1,0);
865  const fawkes::tf::Vector3* wAxis = ((const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,2,0));
866  double angle = ((double) tolua_tonumber(tolua_S,3,0));
867 #ifndef TOLUA_RELEASE
868  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'rotate'", NULL);
869 #endif
870  bool exc_caught = false;
871  try {
872  {
873  fawkes::tf::Vector3 tolua_ret = (fawkes::tf::Vector3) self->rotate(*wAxis,angle);
874  {
875 #ifdef __cplusplus
876  void* tolua_obj = Mtolua_new((fawkes::tf::Vector3)(tolua_ret));
877  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::tf::Vector3");
878  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
879 #else
880  void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::tf::Vector3));
881  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::tf::Vector3");
882  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
883 #endif
884  }
885  }
886  } catch (fawkes::Exception &e) {
887  exc_caught = true;
888  lua_pushstring(tolua_S, e.what_no_backtrace());
889  }
890  catch (std::exception &e) {
891  exc_caught = true;
892  lua_pushstring(tolua_S, e.what());
893  }
894  if (exc_caught) lua_error(tolua_S);
895 
896  }
897  return 1;
898 #ifndef TOLUA_RELEASE
899  tolua_lerror:
900  tolua_error(tolua_S,"#ferror in function 'rotate'.",&tolua_err);
901  return 0;
902 #endif
903 }
904 #endif //#ifndef TOLUA_DISABLE
905 
906 /* method: angle of class fawkes::tf::Vector3 */
907 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_angle00
908 static int tolua_fawkestf_fawkes_tf_Vector3_angle00(lua_State* tolua_S)
909 {
910 #ifndef TOLUA_RELEASE
911  tolua_Error tolua_err;
912  if (
913  !tolua_isusertype(tolua_S,1,"const fawkes::tf::Vector3",0,&tolua_err) ||
914  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Vector3",0,&tolua_err)) ||
915  !tolua_isnoobj(tolua_S,3,&tolua_err)
916  )
917  goto tolua_lerror;
918  else
919 #endif
920  {
921  const fawkes::tf::Vector3* self = (const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,1,0);
922  const fawkes::tf::Vector3* v = ((const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,2,0));
923 #ifndef TOLUA_RELEASE
924  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'angle'", NULL);
925 #endif
926  bool exc_caught = false;
927  try {
928  {
929  double tolua_ret = (double) self->angle(*v);
930  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
931  }
932  } catch (fawkes::Exception &e) {
933  exc_caught = true;
934  lua_pushstring(tolua_S, e.what_no_backtrace());
935  }
936  catch (std::exception &e) {
937  exc_caught = true;
938  lua_pushstring(tolua_S, e.what());
939  }
940  if (exc_caught) lua_error(tolua_S);
941 
942  }
943  return 1;
944 #ifndef TOLUA_RELEASE
945  tolua_lerror:
946  tolua_error(tolua_S,"#ferror in function 'angle'.",&tolua_err);
947  return 0;
948 #endif
949 }
950 #endif //#ifndef TOLUA_DISABLE
951 
952 /* method: absolute of class fawkes::tf::Vector3 */
953 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_absolute00
954 static int tolua_fawkestf_fawkes_tf_Vector3_absolute00(lua_State* tolua_S)
955 {
956 #ifndef TOLUA_RELEASE
957  tolua_Error tolua_err;
958  if (
959  !tolua_isusertype(tolua_S,1,"const fawkes::tf::Vector3",0,&tolua_err) ||
960  !tolua_isnoobj(tolua_S,2,&tolua_err)
961  )
962  goto tolua_lerror;
963  else
964 #endif
965  {
966  const fawkes::tf::Vector3* self = (const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,1,0);
967 #ifndef TOLUA_RELEASE
968  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'absolute'", NULL);
969 #endif
970  bool exc_caught = false;
971  try {
972  {
973  fawkes::tf::Vector3 tolua_ret = (fawkes::tf::Vector3) self->absolute();
974  {
975 #ifdef __cplusplus
976  void* tolua_obj = Mtolua_new((fawkes::tf::Vector3)(tolua_ret));
977  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::tf::Vector3");
978  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
979 #else
980  void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::tf::Vector3));
981  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::tf::Vector3");
982  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
983 #endif
984  }
985  }
986  } catch (fawkes::Exception &e) {
987  exc_caught = true;
988  lua_pushstring(tolua_S, e.what_no_backtrace());
989  }
990  catch (std::exception &e) {
991  exc_caught = true;
992  lua_pushstring(tolua_S, e.what());
993  }
994  if (exc_caught) lua_error(tolua_S);
995 
996  }
997  return 1;
998 #ifndef TOLUA_RELEASE
999  tolua_lerror:
1000  tolua_error(tolua_S,"#ferror in function 'absolute'.",&tolua_err);
1001  return 0;
1002 #endif
1003 }
1004 #endif //#ifndef TOLUA_DISABLE
1005 
1006 /* method: cross of class fawkes::tf::Vector3 */
1007 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_cross00
1008 static int tolua_fawkestf_fawkes_tf_Vector3_cross00(lua_State* tolua_S)
1009 {
1010 #ifndef TOLUA_RELEASE
1011  tolua_Error tolua_err;
1012  if (
1013  !tolua_isusertype(tolua_S,1,"const fawkes::tf::Vector3",0,&tolua_err) ||
1014  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Vector3",0,&tolua_err)) ||
1015  !tolua_isnoobj(tolua_S,3,&tolua_err)
1016  )
1017  goto tolua_lerror;
1018  else
1019 #endif
1020  {
1021  const fawkes::tf::Vector3* self = (const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,1,0);
1022  const fawkes::tf::Vector3* v = ((const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,2,0));
1023 #ifndef TOLUA_RELEASE
1024  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'cross'", NULL);
1025 #endif
1026  bool exc_caught = false;
1027  try {
1028  {
1029  fawkes::tf::Vector3 tolua_ret = (fawkes::tf::Vector3) self->cross(*v);
1030  {
1031 #ifdef __cplusplus
1032  void* tolua_obj = Mtolua_new((fawkes::tf::Vector3)(tolua_ret));
1033  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::tf::Vector3");
1034  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1035 #else
1036  void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::tf::Vector3));
1037  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::tf::Vector3");
1038  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1039 #endif
1040  }
1041  }
1042  } catch (fawkes::Exception &e) {
1043  exc_caught = true;
1044  lua_pushstring(tolua_S, e.what_no_backtrace());
1045  }
1046  catch (std::exception &e) {
1047  exc_caught = true;
1048  lua_pushstring(tolua_S, e.what());
1049  }
1050  if (exc_caught) lua_error(tolua_S);
1051 
1052  }
1053  return 1;
1054 #ifndef TOLUA_RELEASE
1055  tolua_lerror:
1056  tolua_error(tolua_S,"#ferror in function 'cross'.",&tolua_err);
1057  return 0;
1058 #endif
1059 }
1060 #endif //#ifndef TOLUA_DISABLE
1061 
1062 /* method: triple of class fawkes::tf::Vector3 */
1063 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_triple00
1064 static int tolua_fawkestf_fawkes_tf_Vector3_triple00(lua_State* tolua_S)
1065 {
1066 #ifndef TOLUA_RELEASE
1067  tolua_Error tolua_err;
1068  if (
1069  !tolua_isusertype(tolua_S,1,"const fawkes::tf::Vector3",0,&tolua_err) ||
1070  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Vector3",0,&tolua_err)) ||
1071  (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"fawkes::tf::Vector3",0,&tolua_err)) ||
1072  !tolua_isnoobj(tolua_S,4,&tolua_err)
1073  )
1074  goto tolua_lerror;
1075  else
1076 #endif
1077  {
1078  const fawkes::tf::Vector3* self = (const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,1,0);
1079  const fawkes::tf::Vector3* v1 = ((const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,2,0));
1080  fawkes::tf::Vector3* v2 = ((fawkes::tf::Vector3*) tolua_tousertype(tolua_S,3,0));
1081 #ifndef TOLUA_RELEASE
1082  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'triple'", NULL);
1083 #endif
1084  bool exc_caught = false;
1085  try {
1086  {
1087  double tolua_ret = (double) self->triple(*v1,*v2);
1088  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1089  }
1090  } catch (fawkes::Exception &e) {
1091  exc_caught = true;
1092  lua_pushstring(tolua_S, e.what_no_backtrace());
1093  }
1094  catch (std::exception &e) {
1095  exc_caught = true;
1096  lua_pushstring(tolua_S, e.what());
1097  }
1098  if (exc_caught) lua_error(tolua_S);
1099 
1100  }
1101  return 1;
1102 #ifndef TOLUA_RELEASE
1103  tolua_lerror:
1104  tolua_error(tolua_S,"#ferror in function 'triple'.",&tolua_err);
1105  return 0;
1106 #endif
1107 }
1108 #endif //#ifndef TOLUA_DISABLE
1109 
1110 /* method: minAxis of class fawkes::tf::Vector3 */
1111 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_minAxis00
1112 static int tolua_fawkestf_fawkes_tf_Vector3_minAxis00(lua_State* tolua_S)
1113 {
1114 #ifndef TOLUA_RELEASE
1115  tolua_Error tolua_err;
1116  if (
1117  !tolua_isusertype(tolua_S,1,"const fawkes::tf::Vector3",0,&tolua_err) ||
1118  !tolua_isnoobj(tolua_S,2,&tolua_err)
1119  )
1120  goto tolua_lerror;
1121  else
1122 #endif
1123  {
1124  const fawkes::tf::Vector3* self = (const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,1,0);
1125 #ifndef TOLUA_RELEASE
1126  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'minAxis'", NULL);
1127 #endif
1128  bool exc_caught = false;
1129  try {
1130  {
1131  int tolua_ret = (int) self->minAxis();
1132  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1133  }
1134  } catch (fawkes::Exception &e) {
1135  exc_caught = true;
1136  lua_pushstring(tolua_S, e.what_no_backtrace());
1137  }
1138  catch (std::exception &e) {
1139  exc_caught = true;
1140  lua_pushstring(tolua_S, e.what());
1141  }
1142  if (exc_caught) lua_error(tolua_S);
1143 
1144  }
1145  return 1;
1146 #ifndef TOLUA_RELEASE
1147  tolua_lerror:
1148  tolua_error(tolua_S,"#ferror in function 'minAxis'.",&tolua_err);
1149  return 0;
1150 #endif
1151 }
1152 #endif //#ifndef TOLUA_DISABLE
1153 
1154 /* method: maxAxis of class fawkes::tf::Vector3 */
1155 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_maxAxis00
1156 static int tolua_fawkestf_fawkes_tf_Vector3_maxAxis00(lua_State* tolua_S)
1157 {
1158 #ifndef TOLUA_RELEASE
1159  tolua_Error tolua_err;
1160  if (
1161  !tolua_isusertype(tolua_S,1,"const fawkes::tf::Vector3",0,&tolua_err) ||
1162  !tolua_isnoobj(tolua_S,2,&tolua_err)
1163  )
1164  goto tolua_lerror;
1165  else
1166 #endif
1167  {
1168  const fawkes::tf::Vector3* self = (const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,1,0);
1169 #ifndef TOLUA_RELEASE
1170  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxAxis'", NULL);
1171 #endif
1172  bool exc_caught = false;
1173  try {
1174  {
1175  int tolua_ret = (int) self->maxAxis();
1176  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1177  }
1178  } catch (fawkes::Exception &e) {
1179  exc_caught = true;
1180  lua_pushstring(tolua_S, e.what_no_backtrace());
1181  }
1182  catch (std::exception &e) {
1183  exc_caught = true;
1184  lua_pushstring(tolua_S, e.what());
1185  }
1186  if (exc_caught) lua_error(tolua_S);
1187 
1188  }
1189  return 1;
1190 #ifndef TOLUA_RELEASE
1191  tolua_lerror:
1192  tolua_error(tolua_S,"#ferror in function 'maxAxis'.",&tolua_err);
1193  return 0;
1194 #endif
1195 }
1196 #endif //#ifndef TOLUA_DISABLE
1197 
1198 /* method: furthestAxis of class fawkes::tf::Vector3 */
1199 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_furthestAxis00
1200 static int tolua_fawkestf_fawkes_tf_Vector3_furthestAxis00(lua_State* tolua_S)
1201 {
1202 #ifndef TOLUA_RELEASE
1203  tolua_Error tolua_err;
1204  if (
1205  !tolua_isusertype(tolua_S,1,"const fawkes::tf::Vector3",0,&tolua_err) ||
1206  !tolua_isnoobj(tolua_S,2,&tolua_err)
1207  )
1208  goto tolua_lerror;
1209  else
1210 #endif
1211  {
1212  const fawkes::tf::Vector3* self = (const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,1,0);
1213 #ifndef TOLUA_RELEASE
1214  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'furthestAxis'", NULL);
1215 #endif
1216  bool exc_caught = false;
1217  try {
1218  {
1219  int tolua_ret = (int) self->furthestAxis();
1220  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1221  }
1222  } catch (fawkes::Exception &e) {
1223  exc_caught = true;
1224  lua_pushstring(tolua_S, e.what_no_backtrace());
1225  }
1226  catch (std::exception &e) {
1227  exc_caught = true;
1228  lua_pushstring(tolua_S, e.what());
1229  }
1230  if (exc_caught) lua_error(tolua_S);
1231 
1232  }
1233  return 1;
1234 #ifndef TOLUA_RELEASE
1235  tolua_lerror:
1236  tolua_error(tolua_S,"#ferror in function 'furthestAxis'.",&tolua_err);
1237  return 0;
1238 #endif
1239 }
1240 #endif //#ifndef TOLUA_DISABLE
1241 
1242 /* method: closestAxis of class fawkes::tf::Vector3 */
1243 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_closestAxis00
1244 static int tolua_fawkestf_fawkes_tf_Vector3_closestAxis00(lua_State* tolua_S)
1245 {
1246 #ifndef TOLUA_RELEASE
1247  tolua_Error tolua_err;
1248  if (
1249  !tolua_isusertype(tolua_S,1,"const fawkes::tf::Vector3",0,&tolua_err) ||
1250  !tolua_isnoobj(tolua_S,2,&tolua_err)
1251  )
1252  goto tolua_lerror;
1253  else
1254 #endif
1255  {
1256  const fawkes::tf::Vector3* self = (const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,1,0);
1257 #ifndef TOLUA_RELEASE
1258  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'closestAxis'", NULL);
1259 #endif
1260  bool exc_caught = false;
1261  try {
1262  {
1263  int tolua_ret = (int) self->closestAxis();
1264  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1265  }
1266  } catch (fawkes::Exception &e) {
1267  exc_caught = true;
1268  lua_pushstring(tolua_S, e.what_no_backtrace());
1269  }
1270  catch (std::exception &e) {
1271  exc_caught = true;
1272  lua_pushstring(tolua_S, e.what());
1273  }
1274  if (exc_caught) lua_error(tolua_S);
1275 
1276  }
1277  return 1;
1278 #ifndef TOLUA_RELEASE
1279  tolua_lerror:
1280  tolua_error(tolua_S,"#ferror in function 'closestAxis'.",&tolua_err);
1281  return 0;
1282 #endif
1283 }
1284 #endif //#ifndef TOLUA_DISABLE
1285 
1286 /* method: setInterpolate3 of class fawkes::tf::Vector3 */
1287 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_setInterpolate300
1288 static int tolua_fawkestf_fawkes_tf_Vector3_setInterpolate300(lua_State* tolua_S)
1289 {
1290 #ifndef TOLUA_RELEASE
1291  tolua_Error tolua_err;
1292  if (
1293  !tolua_isusertype(tolua_S,1,"fawkes::tf::Vector3",0,&tolua_err) ||
1294  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Vector3",0,&tolua_err)) ||
1295  (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::tf::Vector3",0,&tolua_err)) ||
1296  !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
1297  !tolua_isnoobj(tolua_S,5,&tolua_err)
1298  )
1299  goto tolua_lerror;
1300  else
1301 #endif
1302  {
1303  fawkes::tf::Vector3* self = (fawkes::tf::Vector3*) tolua_tousertype(tolua_S,1,0);
1304  const fawkes::tf::Vector3* v0 = ((const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,2,0));
1305  const fawkes::tf::Vector3* v1 = ((const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,3,0));
1306  double rt = ((double) tolua_tonumber(tolua_S,4,0));
1307 #ifndef TOLUA_RELEASE
1308  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setInterpolate3'", NULL);
1309 #endif
1310  bool exc_caught = false;
1311  try {
1312  {
1313  self->setInterpolate3(*v0,*v1,rt);
1314  }
1315  } catch (fawkes::Exception &e) {
1316  exc_caught = true;
1317  lua_pushstring(tolua_S, e.what_no_backtrace());
1318  }
1319  catch (std::exception &e) {
1320  exc_caught = true;
1321  lua_pushstring(tolua_S, e.what());
1322  }
1323  if (exc_caught) lua_error(tolua_S);
1324 
1325  }
1326  return 0;
1327 #ifndef TOLUA_RELEASE
1328  tolua_lerror:
1329  tolua_error(tolua_S,"#ferror in function 'setInterpolate3'.",&tolua_err);
1330  return 0;
1331 #endif
1332 }
1333 #endif //#ifndef TOLUA_DISABLE
1334 
1335 /* method: lerp of class fawkes::tf::Vector3 */
1336 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_lerp00
1337 static int tolua_fawkestf_fawkes_tf_Vector3_lerp00(lua_State* tolua_S)
1338 {
1339 #ifndef TOLUA_RELEASE
1340  tolua_Error tolua_err;
1341  if (
1342  !tolua_isusertype(tolua_S,1,"const fawkes::tf::Vector3",0,&tolua_err) ||
1343  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Vector3",0,&tolua_err)) ||
1344  !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
1345  !tolua_isnoobj(tolua_S,4,&tolua_err)
1346  )
1347  goto tolua_lerror;
1348  else
1349 #endif
1350  {
1351  const fawkes::tf::Vector3* self = (const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,1,0);
1352  const fawkes::tf::Vector3* v = ((const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,2,0));
1353  const double t = ((const double) tolua_tonumber(tolua_S,3,0));
1354 #ifndef TOLUA_RELEASE
1355  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'lerp'", NULL);
1356 #endif
1357  bool exc_caught = false;
1358  try {
1359  {
1360  fawkes::tf::Vector3 tolua_ret = (fawkes::tf::Vector3) self->lerp(*v,t);
1361  {
1362 #ifdef __cplusplus
1363  void* tolua_obj = Mtolua_new((fawkes::tf::Vector3)(tolua_ret));
1364  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::tf::Vector3");
1365  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1366 #else
1367  void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::tf::Vector3));
1368  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::tf::Vector3");
1369  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1370 #endif
1371  }
1372  tolua_pushnumber(tolua_S,(lua_Number)t);
1373  }
1374  } catch (fawkes::Exception &e) {
1375  exc_caught = true;
1376  lua_pushstring(tolua_S, e.what_no_backtrace());
1377  }
1378  catch (std::exception &e) {
1379  exc_caught = true;
1380  lua_pushstring(tolua_S, e.what());
1381  }
1382  if (exc_caught) lua_error(tolua_S);
1383 
1384  }
1385  return 2;
1386 #ifndef TOLUA_RELEASE
1387  tolua_lerror:
1388  tolua_error(tolua_S,"#ferror in function 'lerp'.",&tolua_err);
1389  return 0;
1390 #endif
1391 }
1392 #endif //#ifndef TOLUA_DISABLE
1393 
1394 /* method: x of class fawkes::tf::Vector3 */
1395 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_x00
1396 static int tolua_fawkestf_fawkes_tf_Vector3_x00(lua_State* tolua_S)
1397 {
1398 #ifndef TOLUA_RELEASE
1399  tolua_Error tolua_err;
1400  if (
1401  !tolua_isusertype(tolua_S,1,"fawkes::tf::Vector3",0,&tolua_err) ||
1402  !tolua_isnoobj(tolua_S,2,&tolua_err)
1403  )
1404  goto tolua_lerror;
1405  else
1406 #endif
1407  {
1408  fawkes::tf::Vector3* self = (fawkes::tf::Vector3*) tolua_tousertype(tolua_S,1,0);
1409 #ifndef TOLUA_RELEASE
1410  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'x'", NULL);
1411 #endif
1412  bool exc_caught = false;
1413  try {
1414  {
1415  const double tolua_ret = (const double) self->x();
1416  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1417  }
1418  } catch (fawkes::Exception &e) {
1419  exc_caught = true;
1420  lua_pushstring(tolua_S, e.what_no_backtrace());
1421  }
1422  catch (std::exception &e) {
1423  exc_caught = true;
1424  lua_pushstring(tolua_S, e.what());
1425  }
1426  if (exc_caught) lua_error(tolua_S);
1427 
1428  }
1429  return 1;
1430 #ifndef TOLUA_RELEASE
1431  tolua_lerror:
1432  tolua_error(tolua_S,"#ferror in function 'x'.",&tolua_err);
1433  return 0;
1434 #endif
1435 }
1436 #endif //#ifndef TOLUA_DISABLE
1437 
1438 /* method: y of class fawkes::tf::Vector3 */
1439 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_y00
1440 static int tolua_fawkestf_fawkes_tf_Vector3_y00(lua_State* tolua_S)
1441 {
1442 #ifndef TOLUA_RELEASE
1443  tolua_Error tolua_err;
1444  if (
1445  !tolua_isusertype(tolua_S,1,"fawkes::tf::Vector3",0,&tolua_err) ||
1446  !tolua_isnoobj(tolua_S,2,&tolua_err)
1447  )
1448  goto tolua_lerror;
1449  else
1450 #endif
1451  {
1452  fawkes::tf::Vector3* self = (fawkes::tf::Vector3*) tolua_tousertype(tolua_S,1,0);
1453 #ifndef TOLUA_RELEASE
1454  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'y'", NULL);
1455 #endif
1456  bool exc_caught = false;
1457  try {
1458  {
1459  const double tolua_ret = (const double) self->y();
1460  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1461  }
1462  } catch (fawkes::Exception &e) {
1463  exc_caught = true;
1464  lua_pushstring(tolua_S, e.what_no_backtrace());
1465  }
1466  catch (std::exception &e) {
1467  exc_caught = true;
1468  lua_pushstring(tolua_S, e.what());
1469  }
1470  if (exc_caught) lua_error(tolua_S);
1471 
1472  }
1473  return 1;
1474 #ifndef TOLUA_RELEASE
1475  tolua_lerror:
1476  tolua_error(tolua_S,"#ferror in function 'y'.",&tolua_err);
1477  return 0;
1478 #endif
1479 }
1480 #endif //#ifndef TOLUA_DISABLE
1481 
1482 /* method: z of class fawkes::tf::Vector3 */
1483 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_z00
1484 static int tolua_fawkestf_fawkes_tf_Vector3_z00(lua_State* tolua_S)
1485 {
1486 #ifndef TOLUA_RELEASE
1487  tolua_Error tolua_err;
1488  if (
1489  !tolua_isusertype(tolua_S,1,"fawkes::tf::Vector3",0,&tolua_err) ||
1490  !tolua_isnoobj(tolua_S,2,&tolua_err)
1491  )
1492  goto tolua_lerror;
1493  else
1494 #endif
1495  {
1496  fawkes::tf::Vector3* self = (fawkes::tf::Vector3*) tolua_tousertype(tolua_S,1,0);
1497 #ifndef TOLUA_RELEASE
1498  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'z'", NULL);
1499 #endif
1500  bool exc_caught = false;
1501  try {
1502  {
1503  const double tolua_ret = (const double) self->z();
1504  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1505  }
1506  } catch (fawkes::Exception &e) {
1507  exc_caught = true;
1508  lua_pushstring(tolua_S, e.what_no_backtrace());
1509  }
1510  catch (std::exception &e) {
1511  exc_caught = true;
1512  lua_pushstring(tolua_S, e.what());
1513  }
1514  if (exc_caught) lua_error(tolua_S);
1515 
1516  }
1517  return 1;
1518 #ifndef TOLUA_RELEASE
1519  tolua_lerror:
1520  tolua_error(tolua_S,"#ferror in function 'z'.",&tolua_err);
1521  return 0;
1522 #endif
1523 }
1524 #endif //#ifndef TOLUA_DISABLE
1525 
1526 /* method: setX of class fawkes::tf::Vector3 */
1527 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_setX00
1528 static int tolua_fawkestf_fawkes_tf_Vector3_setX00(lua_State* tolua_S)
1529 {
1530 #ifndef TOLUA_RELEASE
1531  tolua_Error tolua_err;
1532  if (
1533  !tolua_isusertype(tolua_S,1,"fawkes::tf::Vector3",0,&tolua_err) ||
1534  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
1535  !tolua_isnoobj(tolua_S,3,&tolua_err)
1536  )
1537  goto tolua_lerror;
1538  else
1539 #endif
1540  {
1541  fawkes::tf::Vector3* self = (fawkes::tf::Vector3*) tolua_tousertype(tolua_S,1,0);
1542  double x = ((double) tolua_tonumber(tolua_S,2,0));
1543 #ifndef TOLUA_RELEASE
1544  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setX'", NULL);
1545 #endif
1546  bool exc_caught = false;
1547  try {
1548  {
1549  self->setX(x);
1550  }
1551  } catch (fawkes::Exception &e) {
1552  exc_caught = true;
1553  lua_pushstring(tolua_S, e.what_no_backtrace());
1554  }
1555  catch (std::exception &e) {
1556  exc_caught = true;
1557  lua_pushstring(tolua_S, e.what());
1558  }
1559  if (exc_caught) lua_error(tolua_S);
1560 
1561  }
1562  return 0;
1563 #ifndef TOLUA_RELEASE
1564  tolua_lerror:
1565  tolua_error(tolua_S,"#ferror in function 'setX'.",&tolua_err);
1566  return 0;
1567 #endif
1568 }
1569 #endif //#ifndef TOLUA_DISABLE
1570 
1571 /* method: setY of class fawkes::tf::Vector3 */
1572 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_setY00
1573 static int tolua_fawkestf_fawkes_tf_Vector3_setY00(lua_State* tolua_S)
1574 {
1575 #ifndef TOLUA_RELEASE
1576  tolua_Error tolua_err;
1577  if (
1578  !tolua_isusertype(tolua_S,1,"fawkes::tf::Vector3",0,&tolua_err) ||
1579  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
1580  !tolua_isnoobj(tolua_S,3,&tolua_err)
1581  )
1582  goto tolua_lerror;
1583  else
1584 #endif
1585  {
1586  fawkes::tf::Vector3* self = (fawkes::tf::Vector3*) tolua_tousertype(tolua_S,1,0);
1587  double x = ((double) tolua_tonumber(tolua_S,2,0));
1588 #ifndef TOLUA_RELEASE
1589  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setY'", NULL);
1590 #endif
1591  bool exc_caught = false;
1592  try {
1593  {
1594  self->setY(x);
1595  }
1596  } catch (fawkes::Exception &e) {
1597  exc_caught = true;
1598  lua_pushstring(tolua_S, e.what_no_backtrace());
1599  }
1600  catch (std::exception &e) {
1601  exc_caught = true;
1602  lua_pushstring(tolua_S, e.what());
1603  }
1604  if (exc_caught) lua_error(tolua_S);
1605 
1606  }
1607  return 0;
1608 #ifndef TOLUA_RELEASE
1609  tolua_lerror:
1610  tolua_error(tolua_S,"#ferror in function 'setY'.",&tolua_err);
1611  return 0;
1612 #endif
1613 }
1614 #endif //#ifndef TOLUA_DISABLE
1615 
1616 /* method: setZ of class fawkes::tf::Vector3 */
1617 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_setZ00
1618 static int tolua_fawkestf_fawkes_tf_Vector3_setZ00(lua_State* tolua_S)
1619 {
1620 #ifndef TOLUA_RELEASE
1621  tolua_Error tolua_err;
1622  if (
1623  !tolua_isusertype(tolua_S,1,"fawkes::tf::Vector3",0,&tolua_err) ||
1624  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
1625  !tolua_isnoobj(tolua_S,3,&tolua_err)
1626  )
1627  goto tolua_lerror;
1628  else
1629 #endif
1630  {
1631  fawkes::tf::Vector3* self = (fawkes::tf::Vector3*) tolua_tousertype(tolua_S,1,0);
1632  double x = ((double) tolua_tonumber(tolua_S,2,0));
1633 #ifndef TOLUA_RELEASE
1634  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setZ'", NULL);
1635 #endif
1636  bool exc_caught = false;
1637  try {
1638  {
1639  self->setZ(x);
1640  }
1641  } catch (fawkes::Exception &e) {
1642  exc_caught = true;
1643  lua_pushstring(tolua_S, e.what_no_backtrace());
1644  }
1645  catch (std::exception &e) {
1646  exc_caught = true;
1647  lua_pushstring(tolua_S, e.what());
1648  }
1649  if (exc_caught) lua_error(tolua_S);
1650 
1651  }
1652  return 0;
1653 #ifndef TOLUA_RELEASE
1654  tolua_lerror:
1655  tolua_error(tolua_S,"#ferror in function 'setZ'.",&tolua_err);
1656  return 0;
1657 #endif
1658 }
1659 #endif //#ifndef TOLUA_DISABLE
1660 
1661 /* method: setValue of class fawkes::tf::Vector3 */
1662 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_setValue00
1663 static int tolua_fawkestf_fawkes_tf_Vector3_setValue00(lua_State* tolua_S)
1664 {
1665 #ifndef TOLUA_RELEASE
1666  tolua_Error tolua_err;
1667  if (
1668  !tolua_isusertype(tolua_S,1,"fawkes::tf::Vector3",0,&tolua_err) ||
1669  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
1670  !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
1671  !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
1672  !tolua_isnoobj(tolua_S,5,&tolua_err)
1673  )
1674  goto tolua_lerror;
1675  else
1676 #endif
1677  {
1678  fawkes::tf::Vector3* self = (fawkes::tf::Vector3*) tolua_tousertype(tolua_S,1,0);
1679  double x = ((double) tolua_tonumber(tolua_S,2,0));
1680  double y = ((double) tolua_tonumber(tolua_S,3,0));
1681  double z = ((double) tolua_tonumber(tolua_S,4,0));
1682 #ifndef TOLUA_RELEASE
1683  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setValue'", NULL);
1684 #endif
1685  bool exc_caught = false;
1686  try {
1687  {
1688  self->setValue(x,y,z);
1689  }
1690  } catch (fawkes::Exception &e) {
1691  exc_caught = true;
1692  lua_pushstring(tolua_S, e.what_no_backtrace());
1693  }
1694  catch (std::exception &e) {
1695  exc_caught = true;
1696  lua_pushstring(tolua_S, e.what());
1697  }
1698  if (exc_caught) lua_error(tolua_S);
1699 
1700  }
1701  return 0;
1702 #ifndef TOLUA_RELEASE
1703  tolua_lerror:
1704  tolua_error(tolua_S,"#ferror in function 'setValue'.",&tolua_err);
1705  return 0;
1706 #endif
1707 }
1708 #endif //#ifndef TOLUA_DISABLE
1709 
1710 /* method: setZero of class fawkes::tf::Vector3 */
1711 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_setZero00
1712 static int tolua_fawkestf_fawkes_tf_Vector3_setZero00(lua_State* tolua_S)
1713 {
1714 #ifndef TOLUA_RELEASE
1715  tolua_Error tolua_err;
1716  if (
1717  !tolua_isusertype(tolua_S,1,"fawkes::tf::Vector3",0,&tolua_err) ||
1718  !tolua_isnoobj(tolua_S,2,&tolua_err)
1719  )
1720  goto tolua_lerror;
1721  else
1722 #endif
1723  {
1724  fawkes::tf::Vector3* self = (fawkes::tf::Vector3*) tolua_tousertype(tolua_S,1,0);
1725 #ifndef TOLUA_RELEASE
1726  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setZero'", NULL);
1727 #endif
1728  bool exc_caught = false;
1729  try {
1730  {
1731  self->setZero();
1732  }
1733  } catch (fawkes::Exception &e) {
1734  exc_caught = true;
1735  lua_pushstring(tolua_S, e.what_no_backtrace());
1736  }
1737  catch (std::exception &e) {
1738  exc_caught = true;
1739  lua_pushstring(tolua_S, e.what());
1740  }
1741  if (exc_caught) lua_error(tolua_S);
1742 
1743  }
1744  return 0;
1745 #ifndef TOLUA_RELEASE
1746  tolua_lerror:
1747  tolua_error(tolua_S,"#ferror in function 'setZero'.",&tolua_err);
1748  return 0;
1749 #endif
1750 }
1751 #endif //#ifndef TOLUA_DISABLE
1752 
1753 /* method: isZero of class fawkes::tf::Vector3 */
1754 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_isZero00
1755 static int tolua_fawkestf_fawkes_tf_Vector3_isZero00(lua_State* tolua_S)
1756 {
1757 #ifndef TOLUA_RELEASE
1758  tolua_Error tolua_err;
1759  if (
1760  !tolua_isusertype(tolua_S,1,"const fawkes::tf::Vector3",0,&tolua_err) ||
1761  !tolua_isnoobj(tolua_S,2,&tolua_err)
1762  )
1763  goto tolua_lerror;
1764  else
1765 #endif
1766  {
1767  const fawkes::tf::Vector3* self = (const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,1,0);
1768 #ifndef TOLUA_RELEASE
1769  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isZero'", NULL);
1770 #endif
1771  bool exc_caught = false;
1772  try {
1773  {
1774  bool tolua_ret = (bool) self->isZero();
1775  tolua_pushboolean(tolua_S,(bool)tolua_ret);
1776  }
1777  } catch (fawkes::Exception &e) {
1778  exc_caught = true;
1779  lua_pushstring(tolua_S, e.what_no_backtrace());
1780  }
1781  catch (std::exception &e) {
1782  exc_caught = true;
1783  lua_pushstring(tolua_S, e.what());
1784  }
1785  if (exc_caught) lua_error(tolua_S);
1786 
1787  }
1788  return 1;
1789 #ifndef TOLUA_RELEASE
1790  tolua_lerror:
1791  tolua_error(tolua_S,"#ferror in function 'isZero'.",&tolua_err);
1792  return 0;
1793 #endif
1794 }
1795 #endif //#ifndef TOLUA_DISABLE
1796 
1797 /* method: fuzzyZero of class fawkes::tf::Vector3 */
1798 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_fuzzyZero00
1799 static int tolua_fawkestf_fawkes_tf_Vector3_fuzzyZero00(lua_State* tolua_S)
1800 {
1801 #ifndef TOLUA_RELEASE
1802  tolua_Error tolua_err;
1803  if (
1804  !tolua_isusertype(tolua_S,1,"const fawkes::tf::Vector3",0,&tolua_err) ||
1805  !tolua_isnoobj(tolua_S,2,&tolua_err)
1806  )
1807  goto tolua_lerror;
1808  else
1809 #endif
1810  {
1811  const fawkes::tf::Vector3* self = (const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,1,0);
1812 #ifndef TOLUA_RELEASE
1813  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'fuzzyZero'", NULL);
1814 #endif
1815  bool exc_caught = false;
1816  try {
1817  {
1818  bool tolua_ret = (bool) self->fuzzyZero();
1819  tolua_pushboolean(tolua_S,(bool)tolua_ret);
1820  }
1821  } catch (fawkes::Exception &e) {
1822  exc_caught = true;
1823  lua_pushstring(tolua_S, e.what_no_backtrace());
1824  }
1825  catch (std::exception &e) {
1826  exc_caught = true;
1827  lua_pushstring(tolua_S, e.what());
1828  }
1829  if (exc_caught) lua_error(tolua_S);
1830 
1831  }
1832  return 1;
1833 #ifndef TOLUA_RELEASE
1834  tolua_lerror:
1835  tolua_error(tolua_S,"#ferror in function 'fuzzyZero'.",&tolua_err);
1836  return 0;
1837 #endif
1838 }
1839 #endif //#ifndef TOLUA_DISABLE
1840 
1841 /* method: new of class fawkes::tf::Quaternion */
1842 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_new00
1843 static int tolua_fawkestf_fawkes_tf_Quaternion_new00(lua_State* tolua_S)
1844 {
1845 #ifndef TOLUA_RELEASE
1846  tolua_Error tolua_err;
1847  if (
1848  !tolua_isusertable(tolua_S,1,"fawkes::tf::Quaternion",0,&tolua_err) ||
1849  !tolua_isnoobj(tolua_S,2,&tolua_err)
1850  )
1851  goto tolua_lerror;
1852  else
1853 #endif
1854  {
1855  bool exc_caught = false;
1856  try {
1857  {
1858  fawkes::tf::Quaternion* tolua_ret = (fawkes::tf::Quaternion*) Mtolua_new((fawkes::tf::Quaternion)());
1859  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Quaternion");
1860  }
1861  } catch (fawkes::Exception &e) {
1862  exc_caught = true;
1863  lua_pushstring(tolua_S, e.what_no_backtrace());
1864  }
1865  catch (std::exception &e) {
1866  exc_caught = true;
1867  lua_pushstring(tolua_S, e.what());
1868  }
1869  if (exc_caught) lua_error(tolua_S);
1870 
1871  }
1872  return 1;
1873 #ifndef TOLUA_RELEASE
1874  tolua_lerror:
1875  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
1876  return 0;
1877 #endif
1878 }
1879 #endif //#ifndef TOLUA_DISABLE
1880 
1881 /* method: new_local of class fawkes::tf::Quaternion */
1882 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_new00_local
1883 static int tolua_fawkestf_fawkes_tf_Quaternion_new00_local(lua_State* tolua_S)
1884 {
1885 #ifndef TOLUA_RELEASE
1886  tolua_Error tolua_err;
1887  if (
1888  !tolua_isusertable(tolua_S,1,"fawkes::tf::Quaternion",0,&tolua_err) ||
1889  !tolua_isnoobj(tolua_S,2,&tolua_err)
1890  )
1891  goto tolua_lerror;
1892  else
1893 #endif
1894  {
1895  bool exc_caught = false;
1896  try {
1897  {
1898  fawkes::tf::Quaternion* tolua_ret = (fawkes::tf::Quaternion*) Mtolua_new((fawkes::tf::Quaternion)());
1899  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Quaternion");
1900  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1901  }
1902  } catch (fawkes::Exception &e) {
1903  exc_caught = true;
1904  lua_pushstring(tolua_S, e.what_no_backtrace());
1905  }
1906  catch (std::exception &e) {
1907  exc_caught = true;
1908  lua_pushstring(tolua_S, e.what());
1909  }
1910  if (exc_caught) lua_error(tolua_S);
1911 
1912  }
1913  return 1;
1914 #ifndef TOLUA_RELEASE
1915  tolua_lerror:
1916  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
1917  return 0;
1918 #endif
1919 }
1920 #endif //#ifndef TOLUA_DISABLE
1921 
1922 /* method: new of class fawkes::tf::Quaternion */
1923 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_new01
1924 static int tolua_fawkestf_fawkes_tf_Quaternion_new01(lua_State* tolua_S)
1925 {
1926  tolua_Error tolua_err;
1927  if (
1928  !tolua_isusertable(tolua_S,1,"fawkes::tf::Quaternion",0,&tolua_err) ||
1929  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
1930  !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
1931  !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
1932  !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
1933  !tolua_isnoobj(tolua_S,6,&tolua_err)
1934  )
1935  goto tolua_lerror;
1936  else
1937  {
1938  double x = ((double) tolua_tonumber(tolua_S,2,0));
1939  double y = ((double) tolua_tonumber(tolua_S,3,0));
1940  double z = ((double) tolua_tonumber(tolua_S,4,0));
1941  double w = ((double) tolua_tonumber(tolua_S,5,0));
1942  bool exc_caught = false;
1943  try {
1944  {
1945  fawkes::tf::Quaternion* tolua_ret = (fawkes::tf::Quaternion*) Mtolua_new((fawkes::tf::Quaternion)(x,y,z,w));
1946  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Quaternion");
1947  }
1948  } catch (fawkes::Exception &e) {
1949  exc_caught = true;
1950  lua_pushstring(tolua_S, e.what_no_backtrace());
1951  }
1952  catch (std::exception &e) {
1953  exc_caught = true;
1954  lua_pushstring(tolua_S, e.what());
1955  }
1956  if (exc_caught) lua_error(tolua_S);
1957 
1958  }
1959  return 1;
1960 tolua_lerror:
1961  return tolua_fawkestf_fawkes_tf_Quaternion_new00(tolua_S);
1962 }
1963 #endif //#ifndef TOLUA_DISABLE
1964 
1965 /* method: new_local of class fawkes::tf::Quaternion */
1966 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_new01_local
1967 static int tolua_fawkestf_fawkes_tf_Quaternion_new01_local(lua_State* tolua_S)
1968 {
1969  tolua_Error tolua_err;
1970  if (
1971  !tolua_isusertable(tolua_S,1,"fawkes::tf::Quaternion",0,&tolua_err) ||
1972  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
1973  !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
1974  !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
1975  !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
1976  !tolua_isnoobj(tolua_S,6,&tolua_err)
1977  )
1978  goto tolua_lerror;
1979  else
1980  {
1981  double x = ((double) tolua_tonumber(tolua_S,2,0));
1982  double y = ((double) tolua_tonumber(tolua_S,3,0));
1983  double z = ((double) tolua_tonumber(tolua_S,4,0));
1984  double w = ((double) tolua_tonumber(tolua_S,5,0));
1985  bool exc_caught = false;
1986  try {
1987  {
1988  fawkes::tf::Quaternion* tolua_ret = (fawkes::tf::Quaternion*) Mtolua_new((fawkes::tf::Quaternion)(x,y,z,w));
1989  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Quaternion");
1990  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1991  }
1992  } catch (fawkes::Exception &e) {
1993  exc_caught = true;
1994  lua_pushstring(tolua_S, e.what_no_backtrace());
1995  }
1996  catch (std::exception &e) {
1997  exc_caught = true;
1998  lua_pushstring(tolua_S, e.what());
1999  }
2000  if (exc_caught) lua_error(tolua_S);
2001 
2002  }
2003  return 1;
2004 tolua_lerror:
2005  return tolua_fawkestf_fawkes_tf_Quaternion_new00_local(tolua_S);
2006 }
2007 #endif //#ifndef TOLUA_DISABLE
2008 
2009 /* method: new of class fawkes::tf::Quaternion */
2010 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_new02
2011 static int tolua_fawkestf_fawkes_tf_Quaternion_new02(lua_State* tolua_S)
2012 {
2013  tolua_Error tolua_err;
2014  if (
2015  !tolua_isusertable(tolua_S,1,"fawkes::tf::Quaternion",0,&tolua_err) ||
2016  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"fawkes::tf::Vector3",0,&tolua_err)) ||
2017  !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
2018  !tolua_isnoobj(tolua_S,4,&tolua_err)
2019  )
2020  goto tolua_lerror;
2021  else
2022  {
2023  fawkes::tf::Vector3 axis = *((fawkes::tf::Vector3*) tolua_tousertype(tolua_S,2,0));
2024  const double angle = ((const double) tolua_tonumber(tolua_S,3,0));
2025  bool exc_caught = false;
2026  try {
2027  {
2028  fawkes::tf::Quaternion* tolua_ret = (fawkes::tf::Quaternion*) Mtolua_new((fawkes::tf::Quaternion)(axis,angle));
2029  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Quaternion");
2030  }
2031  } catch (fawkes::Exception &e) {
2032  exc_caught = true;
2033  lua_pushstring(tolua_S, e.what_no_backtrace());
2034  }
2035  catch (std::exception &e) {
2036  exc_caught = true;
2037  lua_pushstring(tolua_S, e.what());
2038  }
2039  if (exc_caught) lua_error(tolua_S);
2040 
2041  }
2042  return 1;
2043 tolua_lerror:
2044  return tolua_fawkestf_fawkes_tf_Quaternion_new01(tolua_S);
2045 }
2046 #endif //#ifndef TOLUA_DISABLE
2047 
2048 /* method: new_local of class fawkes::tf::Quaternion */
2049 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_new02_local
2050 static int tolua_fawkestf_fawkes_tf_Quaternion_new02_local(lua_State* tolua_S)
2051 {
2052  tolua_Error tolua_err;
2053  if (
2054  !tolua_isusertable(tolua_S,1,"fawkes::tf::Quaternion",0,&tolua_err) ||
2055  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"fawkes::tf::Vector3",0,&tolua_err)) ||
2056  !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
2057  !tolua_isnoobj(tolua_S,4,&tolua_err)
2058  )
2059  goto tolua_lerror;
2060  else
2061  {
2062  fawkes::tf::Vector3 axis = *((fawkes::tf::Vector3*) tolua_tousertype(tolua_S,2,0));
2063  const double angle = ((const double) tolua_tonumber(tolua_S,3,0));
2064  bool exc_caught = false;
2065  try {
2066  {
2067  fawkes::tf::Quaternion* tolua_ret = (fawkes::tf::Quaternion*) Mtolua_new((fawkes::tf::Quaternion)(axis,angle));
2068  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Quaternion");
2069  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
2070  }
2071  } catch (fawkes::Exception &e) {
2072  exc_caught = true;
2073  lua_pushstring(tolua_S, e.what_no_backtrace());
2074  }
2075  catch (std::exception &e) {
2076  exc_caught = true;
2077  lua_pushstring(tolua_S, e.what());
2078  }
2079  if (exc_caught) lua_error(tolua_S);
2080 
2081  }
2082  return 1;
2083 tolua_lerror:
2084  return tolua_fawkestf_fawkes_tf_Quaternion_new01_local(tolua_S);
2085 }
2086 #endif //#ifndef TOLUA_DISABLE
2087 
2088 /* method: new of class fawkes::tf::Quaternion */
2089 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_new03
2090 static int tolua_fawkestf_fawkes_tf_Quaternion_new03(lua_State* tolua_S)
2091 {
2092  tolua_Error tolua_err;
2093  if (
2094  !tolua_isusertable(tolua_S,1,"fawkes::tf::Quaternion",0,&tolua_err) ||
2095  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
2096  !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
2097  !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
2098  !tolua_isnoobj(tolua_S,5,&tolua_err)
2099  )
2100  goto tolua_lerror;
2101  else
2102  {
2103  const double yaw = ((const double) tolua_tonumber(tolua_S,2,0));
2104  const double pitch = ((const double) tolua_tonumber(tolua_S,3,0));
2105  const double roll = ((const double) tolua_tonumber(tolua_S,4,0));
2106  bool exc_caught = false;
2107  try {
2108  {
2109  fawkes::tf::Quaternion* tolua_ret = (fawkes::tf::Quaternion*) Mtolua_new((fawkes::tf::Quaternion)(yaw,pitch,roll));
2110  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Quaternion");
2111  }
2112  } catch (fawkes::Exception &e) {
2113  exc_caught = true;
2114  lua_pushstring(tolua_S, e.what_no_backtrace());
2115  }
2116  catch (std::exception &e) {
2117  exc_caught = true;
2118  lua_pushstring(tolua_S, e.what());
2119  }
2120  if (exc_caught) lua_error(tolua_S);
2121 
2122  }
2123  return 1;
2124 tolua_lerror:
2125  return tolua_fawkestf_fawkes_tf_Quaternion_new02(tolua_S);
2126 }
2127 #endif //#ifndef TOLUA_DISABLE
2128 
2129 /* method: new_local of class fawkes::tf::Quaternion */
2130 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_new03_local
2131 static int tolua_fawkestf_fawkes_tf_Quaternion_new03_local(lua_State* tolua_S)
2132 {
2133  tolua_Error tolua_err;
2134  if (
2135  !tolua_isusertable(tolua_S,1,"fawkes::tf::Quaternion",0,&tolua_err) ||
2136  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
2137  !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
2138  !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
2139  !tolua_isnoobj(tolua_S,5,&tolua_err)
2140  )
2141  goto tolua_lerror;
2142  else
2143  {
2144  const double yaw = ((const double) tolua_tonumber(tolua_S,2,0));
2145  const double pitch = ((const double) tolua_tonumber(tolua_S,3,0));
2146  const double roll = ((const double) tolua_tonumber(tolua_S,4,0));
2147  bool exc_caught = false;
2148  try {
2149  {
2150  fawkes::tf::Quaternion* tolua_ret = (fawkes::tf::Quaternion*) Mtolua_new((fawkes::tf::Quaternion)(yaw,pitch,roll));
2151  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Quaternion");
2152  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
2153  }
2154  } catch (fawkes::Exception &e) {
2155  exc_caught = true;
2156  lua_pushstring(tolua_S, e.what_no_backtrace());
2157  }
2158  catch (std::exception &e) {
2159  exc_caught = true;
2160  lua_pushstring(tolua_S, e.what());
2161  }
2162  if (exc_caught) lua_error(tolua_S);
2163 
2164  }
2165  return 1;
2166 tolua_lerror:
2167  return tolua_fawkestf_fawkes_tf_Quaternion_new02_local(tolua_S);
2168 }
2169 #endif //#ifndef TOLUA_DISABLE
2170 
2171 /* method: getIdentity of class fawkes::tf::Quaternion */
2172 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_getIdentity00
2173 static int tolua_fawkestf_fawkes_tf_Quaternion_getIdentity00(lua_State* tolua_S)
2174 {
2175 #ifndef TOLUA_RELEASE
2176  tolua_Error tolua_err;
2177  if (
2178  !tolua_isusertable(tolua_S,1,"fawkes::tf::Quaternion",0,&tolua_err) ||
2179  !tolua_isnoobj(tolua_S,2,&tolua_err)
2180  )
2181  goto tolua_lerror;
2182  else
2183 #endif
2184  {
2185  bool exc_caught = false;
2186  try {
2187  {
2188  const fawkes::tf::Quaternion& tolua_ret = (const fawkes::tf::Quaternion&) fawkes::tf::Quaternion::getIdentity();
2189  tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const fawkes::tf::Quaternion");
2190  }
2191  } catch (fawkes::Exception &e) {
2192  exc_caught = true;
2193  lua_pushstring(tolua_S, e.what_no_backtrace());
2194  }
2195  catch (std::exception &e) {
2196  exc_caught = true;
2197  lua_pushstring(tolua_S, e.what());
2198  }
2199  if (exc_caught) lua_error(tolua_S);
2200 
2201  }
2202  return 1;
2203 #ifndef TOLUA_RELEASE
2204  tolua_lerror:
2205  tolua_error(tolua_S,"#ferror in function 'getIdentity'.",&tolua_err);
2206  return 0;
2207 #endif
2208 }
2209 #endif //#ifndef TOLUA_DISABLE
2210 
2211 /* method: setRotation of class fawkes::tf::Quaternion */
2212 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_setRotation00
2213 static int tolua_fawkestf_fawkes_tf_Quaternion_setRotation00(lua_State* tolua_S)
2214 {
2215 #ifndef TOLUA_RELEASE
2216  tolua_Error tolua_err;
2217  if (
2218  !tolua_isusertype(tolua_S,1,"fawkes::tf::Quaternion",0,&tolua_err) ||
2219  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"fawkes::tf::Vector3",0,&tolua_err)) ||
2220  !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
2221  !tolua_isnoobj(tolua_S,4,&tolua_err)
2222  )
2223  goto tolua_lerror;
2224  else
2225 #endif
2226  {
2227  fawkes::tf::Quaternion* self = (fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,1,0);
2228  fawkes::tf::Vector3 axis = *((fawkes::tf::Vector3*) tolua_tousertype(tolua_S,2,0));
2229  const double angle = ((const double) tolua_tonumber(tolua_S,3,0));
2230 #ifndef TOLUA_RELEASE
2231  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setRotation'", NULL);
2232 #endif
2233  bool exc_caught = false;
2234  try {
2235  {
2236  self->setRotation(axis,angle);
2237  }
2238  } catch (fawkes::Exception &e) {
2239  exc_caught = true;
2240  lua_pushstring(tolua_S, e.what_no_backtrace());
2241  }
2242  catch (std::exception &e) {
2243  exc_caught = true;
2244  lua_pushstring(tolua_S, e.what());
2245  }
2246  if (exc_caught) lua_error(tolua_S);
2247 
2248  }
2249  return 0;
2250 #ifndef TOLUA_RELEASE
2251  tolua_lerror:
2252  tolua_error(tolua_S,"#ferror in function 'setRotation'.",&tolua_err);
2253  return 0;
2254 #endif
2255 }
2256 #endif //#ifndef TOLUA_DISABLE
2257 
2258 /* method: setEuler of class fawkes::tf::Quaternion */
2259 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_setEuler00
2260 static int tolua_fawkestf_fawkes_tf_Quaternion_setEuler00(lua_State* tolua_S)
2261 {
2262 #ifndef TOLUA_RELEASE
2263  tolua_Error tolua_err;
2264  if (
2265  !tolua_isusertype(tolua_S,1,"fawkes::tf::Quaternion",0,&tolua_err) ||
2266  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
2267  !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
2268  !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
2269  !tolua_isnoobj(tolua_S,5,&tolua_err)
2270  )
2271  goto tolua_lerror;
2272  else
2273 #endif
2274  {
2275  fawkes::tf::Quaternion* self = (fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,1,0);
2276  const double yaw = ((const double) tolua_tonumber(tolua_S,2,0));
2277  const double pitch = ((const double) tolua_tonumber(tolua_S,3,0));
2278  const double roll = ((const double) tolua_tonumber(tolua_S,4,0));
2279 #ifndef TOLUA_RELEASE
2280  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setEuler'", NULL);
2281 #endif
2282  bool exc_caught = false;
2283  try {
2284  {
2285  self->setEuler(yaw,pitch,roll);
2286  }
2287  } catch (fawkes::Exception &e) {
2288  exc_caught = true;
2289  lua_pushstring(tolua_S, e.what_no_backtrace());
2290  }
2291  catch (std::exception &e) {
2292  exc_caught = true;
2293  lua_pushstring(tolua_S, e.what());
2294  }
2295  if (exc_caught) lua_error(tolua_S);
2296 
2297  }
2298  return 0;
2299 #ifndef TOLUA_RELEASE
2300  tolua_lerror:
2301  tolua_error(tolua_S,"#ferror in function 'setEuler'.",&tolua_err);
2302  return 0;
2303 #endif
2304 }
2305 #endif //#ifndef TOLUA_DISABLE
2306 
2307 /* method: operator== of class fawkes::tf::Quaternion */
2308 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion__eq00
2309 static int tolua_fawkestf_fawkes_tf_Quaternion__eq00(lua_State* tolua_S)
2310 {
2311 #ifndef TOLUA_RELEASE
2312  tolua_Error tolua_err;
2313  if (
2314  !tolua_isusertype(tolua_S,1,"const fawkes::tf::Quaternion",0,&tolua_err) ||
2315  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Quaternion",0,&tolua_err)) ||
2316  !tolua_isnoobj(tolua_S,3,&tolua_err)
2317  )
2318  goto tolua_lerror;
2319  else
2320 #endif
2321  {
2322  const fawkes::tf::Quaternion* self = (const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,1,0);
2323  const fawkes::tf::Quaternion* q = ((const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,2,0));
2324 #ifndef TOLUA_RELEASE
2325  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='", NULL);
2326 #endif
2327  bool exc_caught = false;
2328  try {
2329  {
2330  bool tolua_ret = (bool) self->operator==(*q);
2331  tolua_pushboolean(tolua_S,(bool)tolua_ret);
2332  }
2333  } catch (fawkes::Exception &e) {
2334  exc_caught = true;
2335  lua_pushstring(tolua_S, e.what_no_backtrace());
2336  }
2337  catch (std::exception &e) {
2338  exc_caught = true;
2339  lua_pushstring(tolua_S, e.what());
2340  }
2341  if (exc_caught) lua_error(tolua_S);
2342 
2343  }
2344  return 1;
2345 #ifndef TOLUA_RELEASE
2346  tolua_lerror:
2347  tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err);
2348  return 0;
2349 #endif
2350 }
2351 #endif //#ifndef TOLUA_DISABLE
2352 
2353 /* method: dot of class fawkes::tf::Quaternion */
2354 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_dot00
2355 static int tolua_fawkestf_fawkes_tf_Quaternion_dot00(lua_State* tolua_S)
2356 {
2357 #ifndef TOLUA_RELEASE
2358  tolua_Error tolua_err;
2359  if (
2360  !tolua_isusertype(tolua_S,1,"const fawkes::tf::Quaternion",0,&tolua_err) ||
2361  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Quaternion",0,&tolua_err)) ||
2362  !tolua_isnoobj(tolua_S,3,&tolua_err)
2363  )
2364  goto tolua_lerror;
2365  else
2366 #endif
2367  {
2368  const fawkes::tf::Quaternion* self = (const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,1,0);
2369  const fawkes::tf::Quaternion* q = ((const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,2,0));
2370 #ifndef TOLUA_RELEASE
2371  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'dot'", NULL);
2372 #endif
2373  bool exc_caught = false;
2374  try {
2375  {
2376  double tolua_ret = (double) self->dot(*q);
2377  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
2378  }
2379  } catch (fawkes::Exception &e) {
2380  exc_caught = true;
2381  lua_pushstring(tolua_S, e.what_no_backtrace());
2382  }
2383  catch (std::exception &e) {
2384  exc_caught = true;
2385  lua_pushstring(tolua_S, e.what());
2386  }
2387  if (exc_caught) lua_error(tolua_S);
2388 
2389  }
2390  return 1;
2391 #ifndef TOLUA_RELEASE
2392  tolua_lerror:
2393  tolua_error(tolua_S,"#ferror in function 'dot'.",&tolua_err);
2394  return 0;
2395 #endif
2396 }
2397 #endif //#ifndef TOLUA_DISABLE
2398 
2399 /* method: length2 of class fawkes::tf::Quaternion */
2400 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_length200
2401 static int tolua_fawkestf_fawkes_tf_Quaternion_length200(lua_State* tolua_S)
2402 {
2403 #ifndef TOLUA_RELEASE
2404  tolua_Error tolua_err;
2405  if (
2406  !tolua_isusertype(tolua_S,1,"const fawkes::tf::Quaternion",0,&tolua_err) ||
2407  !tolua_isnoobj(tolua_S,2,&tolua_err)
2408  )
2409  goto tolua_lerror;
2410  else
2411 #endif
2412  {
2413  const fawkes::tf::Quaternion* self = (const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,1,0);
2414 #ifndef TOLUA_RELEASE
2415  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'length2'", NULL);
2416 #endif
2417  bool exc_caught = false;
2418  try {
2419  {
2420  double tolua_ret = (double) self->length2();
2421  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
2422  }
2423  } catch (fawkes::Exception &e) {
2424  exc_caught = true;
2425  lua_pushstring(tolua_S, e.what_no_backtrace());
2426  }
2427  catch (std::exception &e) {
2428  exc_caught = true;
2429  lua_pushstring(tolua_S, e.what());
2430  }
2431  if (exc_caught) lua_error(tolua_S);
2432 
2433  }
2434  return 1;
2435 #ifndef TOLUA_RELEASE
2436  tolua_lerror:
2437  tolua_error(tolua_S,"#ferror in function 'length2'.",&tolua_err);
2438  return 0;
2439 #endif
2440 }
2441 #endif //#ifndef TOLUA_DISABLE
2442 
2443 /* method: length of class fawkes::tf::Quaternion */
2444 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_length00
2445 static int tolua_fawkestf_fawkes_tf_Quaternion_length00(lua_State* tolua_S)
2446 {
2447 #ifndef TOLUA_RELEASE
2448  tolua_Error tolua_err;
2449  if (
2450  !tolua_isusertype(tolua_S,1,"const fawkes::tf::Quaternion",0,&tolua_err) ||
2451  !tolua_isnoobj(tolua_S,2,&tolua_err)
2452  )
2453  goto tolua_lerror;
2454  else
2455 #endif
2456  {
2457  const fawkes::tf::Quaternion* self = (const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,1,0);
2458 #ifndef TOLUA_RELEASE
2459  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'length'", NULL);
2460 #endif
2461  bool exc_caught = false;
2462  try {
2463  {
2464  double tolua_ret = (double) self->length();
2465  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
2466  }
2467  } catch (fawkes::Exception &e) {
2468  exc_caught = true;
2469  lua_pushstring(tolua_S, e.what_no_backtrace());
2470  }
2471  catch (std::exception &e) {
2472  exc_caught = true;
2473  lua_pushstring(tolua_S, e.what());
2474  }
2475  if (exc_caught) lua_error(tolua_S);
2476 
2477  }
2478  return 1;
2479 #ifndef TOLUA_RELEASE
2480  tolua_lerror:
2481  tolua_error(tolua_S,"#ferror in function 'length'.",&tolua_err);
2482  return 0;
2483 #endif
2484 }
2485 #endif //#ifndef TOLUA_DISABLE
2486 
2487 /* method: normalize of class fawkes::tf::Quaternion */
2488 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_normalize00
2489 static int tolua_fawkestf_fawkes_tf_Quaternion_normalize00(lua_State* tolua_S)
2490 {
2491 #ifndef TOLUA_RELEASE
2492  tolua_Error tolua_err;
2493  if (
2494  !tolua_isusertype(tolua_S,1,"fawkes::tf::Quaternion",0,&tolua_err) ||
2495  !tolua_isnoobj(tolua_S,2,&tolua_err)
2496  )
2497  goto tolua_lerror;
2498  else
2499 #endif
2500  {
2501  fawkes::tf::Quaternion* self = (fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,1,0);
2502 #ifndef TOLUA_RELEASE
2503  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'normalize'", NULL);
2504 #endif
2505  bool exc_caught = false;
2506  try {
2507  {
2508  fawkes::tf::Quaternion& tolua_ret = (fawkes::tf::Quaternion&) self->normalize();
2509  tolua_pushusertype(tolua_S,(void*)&tolua_ret,"fawkes::tf::Quaternion");
2510  }
2511  } catch (fawkes::Exception &e) {
2512  exc_caught = true;
2513  lua_pushstring(tolua_S, e.what_no_backtrace());
2514  }
2515  catch (std::exception &e) {
2516  exc_caught = true;
2517  lua_pushstring(tolua_S, e.what());
2518  }
2519  if (exc_caught) lua_error(tolua_S);
2520 
2521  }
2522  return 1;
2523 #ifndef TOLUA_RELEASE
2524  tolua_lerror:
2525  tolua_error(tolua_S,"#ferror in function 'normalize'.",&tolua_err);
2526  return 0;
2527 #endif
2528 }
2529 #endif //#ifndef TOLUA_DISABLE
2530 
2531 /* method: normalized of class fawkes::tf::Quaternion */
2532 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_normalized00
2533 static int tolua_fawkestf_fawkes_tf_Quaternion_normalized00(lua_State* tolua_S)
2534 {
2535 #ifndef TOLUA_RELEASE
2536  tolua_Error tolua_err;
2537  if (
2538  !tolua_isusertype(tolua_S,1,"fawkes::tf::Quaternion",0,&tolua_err) ||
2539  !tolua_isnoobj(tolua_S,2,&tolua_err)
2540  )
2541  goto tolua_lerror;
2542  else
2543 #endif
2544  {
2545  fawkes::tf::Quaternion* self = (fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,1,0);
2546 #ifndef TOLUA_RELEASE
2547  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'normalized'", NULL);
2548 #endif
2549  bool exc_caught = false;
2550  try {
2551  {
2552  fawkes::tf::Quaternion tolua_ret = (fawkes::tf::Quaternion) self->normalized();
2553  {
2554 #ifdef __cplusplus
2555  void* tolua_obj = Mtolua_new((fawkes::tf::Quaternion)(tolua_ret));
2556  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::tf::Quaternion");
2557  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
2558 #else
2559  void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::tf::Quaternion));
2560  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::tf::Quaternion");
2561  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
2562 #endif
2563  }
2564  }
2565  } catch (fawkes::Exception &e) {
2566  exc_caught = true;
2567  lua_pushstring(tolua_S, e.what_no_backtrace());
2568  }
2569  catch (std::exception &e) {
2570  exc_caught = true;
2571  lua_pushstring(tolua_S, e.what());
2572  }
2573  if (exc_caught) lua_error(tolua_S);
2574 
2575  }
2576  return 1;
2577 #ifndef TOLUA_RELEASE
2578  tolua_lerror:
2579  tolua_error(tolua_S,"#ferror in function 'normalized'.",&tolua_err);
2580  return 0;
2581 #endif
2582 }
2583 #endif //#ifndef TOLUA_DISABLE
2584 
2585 /* method: angle of class fawkes::tf::Quaternion */
2586 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_angle00
2587 static int tolua_fawkestf_fawkes_tf_Quaternion_angle00(lua_State* tolua_S)
2588 {
2589 #ifndef TOLUA_RELEASE
2590  tolua_Error tolua_err;
2591  if (
2592  !tolua_isusertype(tolua_S,1,"const fawkes::tf::Quaternion",0,&tolua_err) ||
2593  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Quaternion",0,&tolua_err)) ||
2594  !tolua_isnoobj(tolua_S,3,&tolua_err)
2595  )
2596  goto tolua_lerror;
2597  else
2598 #endif
2599  {
2600  const fawkes::tf::Quaternion* self = (const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,1,0);
2601  const fawkes::tf::Quaternion* q = ((const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,2,0));
2602 #ifndef TOLUA_RELEASE
2603  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'angle'", NULL);
2604 #endif
2605  bool exc_caught = false;
2606  try {
2607  {
2608  double tolua_ret = (double) self->angle(*q);
2609  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
2610  }
2611  } catch (fawkes::Exception &e) {
2612  exc_caught = true;
2613  lua_pushstring(tolua_S, e.what_no_backtrace());
2614  }
2615  catch (std::exception &e) {
2616  exc_caught = true;
2617  lua_pushstring(tolua_S, e.what());
2618  }
2619  if (exc_caught) lua_error(tolua_S);
2620 
2621  }
2622  return 1;
2623 #ifndef TOLUA_RELEASE
2624  tolua_lerror:
2625  tolua_error(tolua_S,"#ferror in function 'angle'.",&tolua_err);
2626  return 0;
2627 #endif
2628 }
2629 #endif //#ifndef TOLUA_DISABLE
2630 
2631 /* method: getAngle of class fawkes::tf::Quaternion */
2632 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_getAngle00
2633 static int tolua_fawkestf_fawkes_tf_Quaternion_getAngle00(lua_State* tolua_S)
2634 {
2635 #ifndef TOLUA_RELEASE
2636  tolua_Error tolua_err;
2637  if (
2638  !tolua_isusertype(tolua_S,1,"const fawkes::tf::Quaternion",0,&tolua_err) ||
2639  !tolua_isnoobj(tolua_S,2,&tolua_err)
2640  )
2641  goto tolua_lerror;
2642  else
2643 #endif
2644  {
2645  const fawkes::tf::Quaternion* self = (const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,1,0);
2646 #ifndef TOLUA_RELEASE
2647  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getAngle'", NULL);
2648 #endif
2649  bool exc_caught = false;
2650  try {
2651  {
2652  double tolua_ret = (double) self->getAngle();
2653  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
2654  }
2655  } catch (fawkes::Exception &e) {
2656  exc_caught = true;
2657  lua_pushstring(tolua_S, e.what_no_backtrace());
2658  }
2659  catch (std::exception &e) {
2660  exc_caught = true;
2661  lua_pushstring(tolua_S, e.what());
2662  }
2663  if (exc_caught) lua_error(tolua_S);
2664 
2665  }
2666  return 1;
2667 #ifndef TOLUA_RELEASE
2668  tolua_lerror:
2669  tolua_error(tolua_S,"#ferror in function 'getAngle'.",&tolua_err);
2670  return 0;
2671 #endif
2672 }
2673 #endif //#ifndef TOLUA_DISABLE
2674 
2675 /* method: getAxis of class fawkes::tf::Quaternion */
2676 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_getAxis00
2677 static int tolua_fawkestf_fawkes_tf_Quaternion_getAxis00(lua_State* tolua_S)
2678 {
2679 #ifndef TOLUA_RELEASE
2680  tolua_Error tolua_err;
2681  if (
2682  !tolua_isusertype(tolua_S,1,"const fawkes::tf::Quaternion",0,&tolua_err) ||
2683  !tolua_isnoobj(tolua_S,2,&tolua_err)
2684  )
2685  goto tolua_lerror;
2686  else
2687 #endif
2688  {
2689  const fawkes::tf::Quaternion* self = (const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,1,0);
2690 #ifndef TOLUA_RELEASE
2691  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getAxis'", NULL);
2692 #endif
2693  bool exc_caught = false;
2694  try {
2695  {
2696  fawkes::tf::Vector3 tolua_ret = (fawkes::tf::Vector3) self->getAxis();
2697  {
2698 #ifdef __cplusplus
2699  void* tolua_obj = Mtolua_new((fawkes::tf::Vector3)(tolua_ret));
2700  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::tf::Vector3");
2701  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
2702 #else
2703  void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::tf::Vector3));
2704  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::tf::Vector3");
2705  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
2706 #endif
2707  }
2708  }
2709  } catch (fawkes::Exception &e) {
2710  exc_caught = true;
2711  lua_pushstring(tolua_S, e.what_no_backtrace());
2712  }
2713  catch (std::exception &e) {
2714  exc_caught = true;
2715  lua_pushstring(tolua_S, e.what());
2716  }
2717  if (exc_caught) lua_error(tolua_S);
2718 
2719  }
2720  return 1;
2721 #ifndef TOLUA_RELEASE
2722  tolua_lerror:
2723  tolua_error(tolua_S,"#ferror in function 'getAxis'.",&tolua_err);
2724  return 0;
2725 #endif
2726 }
2727 #endif //#ifndef TOLUA_DISABLE
2728 
2729 /* method: inverse of class fawkes::tf::Quaternion */
2730 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_inverse00
2731 static int tolua_fawkestf_fawkes_tf_Quaternion_inverse00(lua_State* tolua_S)
2732 {
2733 #ifndef TOLUA_RELEASE
2734  tolua_Error tolua_err;
2735  if (
2736  !tolua_isusertype(tolua_S,1,"const fawkes::tf::Quaternion",0,&tolua_err) ||
2737  !tolua_isnoobj(tolua_S,2,&tolua_err)
2738  )
2739  goto tolua_lerror;
2740  else
2741 #endif
2742  {
2743  const fawkes::tf::Quaternion* self = (const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,1,0);
2744 #ifndef TOLUA_RELEASE
2745  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'inverse'", NULL);
2746 #endif
2747  bool exc_caught = false;
2748  try {
2749  {
2750  fawkes::tf::Quaternion tolua_ret = (fawkes::tf::Quaternion) self->inverse();
2751  {
2752 #ifdef __cplusplus
2753  void* tolua_obj = Mtolua_new((fawkes::tf::Quaternion)(tolua_ret));
2754  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::tf::Quaternion");
2755  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
2756 #else
2757  void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::tf::Quaternion));
2758  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::tf::Quaternion");
2759  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
2760 #endif
2761  }
2762  }
2763  } catch (fawkes::Exception &e) {
2764  exc_caught = true;
2765  lua_pushstring(tolua_S, e.what_no_backtrace());
2766  }
2767  catch (std::exception &e) {
2768  exc_caught = true;
2769  lua_pushstring(tolua_S, e.what());
2770  }
2771  if (exc_caught) lua_error(tolua_S);
2772 
2773  }
2774  return 1;
2775 #ifndef TOLUA_RELEASE
2776  tolua_lerror:
2777  tolua_error(tolua_S,"#ferror in function 'inverse'.",&tolua_err);
2778  return 0;
2779 #endif
2780 }
2781 #endif //#ifndef TOLUA_DISABLE
2782 
2783 /* method: slerp of class fawkes::tf::Quaternion */
2784 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_slerp00
2785 static int tolua_fawkestf_fawkes_tf_Quaternion_slerp00(lua_State* tolua_S)
2786 {
2787 #ifndef TOLUA_RELEASE
2788  tolua_Error tolua_err;
2789  if (
2790  !tolua_isusertype(tolua_S,1,"const fawkes::tf::Quaternion",0,&tolua_err) ||
2791  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Quaternion",0,&tolua_err)) ||
2792  !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
2793  !tolua_isnoobj(tolua_S,4,&tolua_err)
2794  )
2795  goto tolua_lerror;
2796  else
2797 #endif
2798  {
2799  const fawkes::tf::Quaternion* self = (const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,1,0);
2800  const fawkes::tf::Quaternion* q = ((const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,2,0));
2801  const double t = ((const double) tolua_tonumber(tolua_S,3,0));
2802 #ifndef TOLUA_RELEASE
2803  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'slerp'", NULL);
2804 #endif
2805  bool exc_caught = false;
2806  try {
2807  {
2808  fawkes::tf::Quaternion tolua_ret = (fawkes::tf::Quaternion) self->slerp(*q,t);
2809  {
2810 #ifdef __cplusplus
2811  void* tolua_obj = Mtolua_new((fawkes::tf::Quaternion)(tolua_ret));
2812  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::tf::Quaternion");
2813  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
2814 #else
2815  void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::tf::Quaternion));
2816  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::tf::Quaternion");
2817  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
2818 #endif
2819  }
2820  }
2821  } catch (fawkes::Exception &e) {
2822  exc_caught = true;
2823  lua_pushstring(tolua_S, e.what_no_backtrace());
2824  }
2825  catch (std::exception &e) {
2826  exc_caught = true;
2827  lua_pushstring(tolua_S, e.what());
2828  }
2829  if (exc_caught) lua_error(tolua_S);
2830 
2831  }
2832  return 1;
2833 #ifndef TOLUA_RELEASE
2834  tolua_lerror:
2835  tolua_error(tolua_S,"#ferror in function 'slerp'.",&tolua_err);
2836  return 0;
2837 #endif
2838 }
2839 #endif //#ifndef TOLUA_DISABLE
2840 
2841 /* method: x of class fawkes::tf::Quaternion */
2842 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_x00
2843 static int tolua_fawkestf_fawkes_tf_Quaternion_x00(lua_State* tolua_S)
2844 {
2845 #ifndef TOLUA_RELEASE
2846  tolua_Error tolua_err;
2847  if (
2848  !tolua_isusertype(tolua_S,1,"fawkes::tf::Quaternion",0,&tolua_err) ||
2849  !tolua_isnoobj(tolua_S,2,&tolua_err)
2850  )
2851  goto tolua_lerror;
2852  else
2853 #endif
2854  {
2855  fawkes::tf::Quaternion* self = (fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,1,0);
2856 #ifndef TOLUA_RELEASE
2857  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'x'", NULL);
2858 #endif
2859  bool exc_caught = false;
2860  try {
2861  {
2862  const double tolua_ret = (const double) self->x();
2863  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
2864  }
2865  } catch (fawkes::Exception &e) {
2866  exc_caught = true;
2867  lua_pushstring(tolua_S, e.what_no_backtrace());
2868  }
2869  catch (std::exception &e) {
2870  exc_caught = true;
2871  lua_pushstring(tolua_S, e.what());
2872  }
2873  if (exc_caught) lua_error(tolua_S);
2874 
2875  }
2876  return 1;
2877 #ifndef TOLUA_RELEASE
2878  tolua_lerror:
2879  tolua_error(tolua_S,"#ferror in function 'x'.",&tolua_err);
2880  return 0;
2881 #endif
2882 }
2883 #endif //#ifndef TOLUA_DISABLE
2884 
2885 /* method: y of class fawkes::tf::Quaternion */
2886 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_y00
2887 static int tolua_fawkestf_fawkes_tf_Quaternion_y00(lua_State* tolua_S)
2888 {
2889 #ifndef TOLUA_RELEASE
2890  tolua_Error tolua_err;
2891  if (
2892  !tolua_isusertype(tolua_S,1,"fawkes::tf::Quaternion",0,&tolua_err) ||
2893  !tolua_isnoobj(tolua_S,2,&tolua_err)
2894  )
2895  goto tolua_lerror;
2896  else
2897 #endif
2898  {
2899  fawkes::tf::Quaternion* self = (fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,1,0);
2900 #ifndef TOLUA_RELEASE
2901  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'y'", NULL);
2902 #endif
2903  bool exc_caught = false;
2904  try {
2905  {
2906  const double tolua_ret = (const double) self->y();
2907  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
2908  }
2909  } catch (fawkes::Exception &e) {
2910  exc_caught = true;
2911  lua_pushstring(tolua_S, e.what_no_backtrace());
2912  }
2913  catch (std::exception &e) {
2914  exc_caught = true;
2915  lua_pushstring(tolua_S, e.what());
2916  }
2917  if (exc_caught) lua_error(tolua_S);
2918 
2919  }
2920  return 1;
2921 #ifndef TOLUA_RELEASE
2922  tolua_lerror:
2923  tolua_error(tolua_S,"#ferror in function 'y'.",&tolua_err);
2924  return 0;
2925 #endif
2926 }
2927 #endif //#ifndef TOLUA_DISABLE
2928 
2929 /* method: z of class fawkes::tf::Quaternion */
2930 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_z00
2931 static int tolua_fawkestf_fawkes_tf_Quaternion_z00(lua_State* tolua_S)
2932 {
2933 #ifndef TOLUA_RELEASE
2934  tolua_Error tolua_err;
2935  if (
2936  !tolua_isusertype(tolua_S,1,"fawkes::tf::Quaternion",0,&tolua_err) ||
2937  !tolua_isnoobj(tolua_S,2,&tolua_err)
2938  )
2939  goto tolua_lerror;
2940  else
2941 #endif
2942  {
2943  fawkes::tf::Quaternion* self = (fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,1,0);
2944 #ifndef TOLUA_RELEASE
2945  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'z'", NULL);
2946 #endif
2947  bool exc_caught = false;
2948  try {
2949  {
2950  const double tolua_ret = (const double) self->z();
2951  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
2952  }
2953  } catch (fawkes::Exception &e) {
2954  exc_caught = true;
2955  lua_pushstring(tolua_S, e.what_no_backtrace());
2956  }
2957  catch (std::exception &e) {
2958  exc_caught = true;
2959  lua_pushstring(tolua_S, e.what());
2960  }
2961  if (exc_caught) lua_error(tolua_S);
2962 
2963  }
2964  return 1;
2965 #ifndef TOLUA_RELEASE
2966  tolua_lerror:
2967  tolua_error(tolua_S,"#ferror in function 'z'.",&tolua_err);
2968  return 0;
2969 #endif
2970 }
2971 #endif //#ifndef TOLUA_DISABLE
2972 
2973 /* method: w of class fawkes::tf::Quaternion */
2974 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_w00
2975 static int tolua_fawkestf_fawkes_tf_Quaternion_w00(lua_State* tolua_S)
2976 {
2977 #ifndef TOLUA_RELEASE
2978  tolua_Error tolua_err;
2979  if (
2980  !tolua_isusertype(tolua_S,1,"fawkes::tf::Quaternion",0,&tolua_err) ||
2981  !tolua_isnoobj(tolua_S,2,&tolua_err)
2982  )
2983  goto tolua_lerror;
2984  else
2985 #endif
2986  {
2987  fawkes::tf::Quaternion* self = (fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,1,0);
2988 #ifndef TOLUA_RELEASE
2989  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'w'", NULL);
2990 #endif
2991  bool exc_caught = false;
2992  try {
2993  {
2994  const double tolua_ret = (const double) self->w();
2995  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
2996  }
2997  } catch (fawkes::Exception &e) {
2998  exc_caught = true;
2999  lua_pushstring(tolua_S, e.what_no_backtrace());
3000  }
3001  catch (std::exception &e) {
3002  exc_caught = true;
3003  lua_pushstring(tolua_S, e.what());
3004  }
3005  if (exc_caught) lua_error(tolua_S);
3006 
3007  }
3008  return 1;
3009 #ifndef TOLUA_RELEASE
3010  tolua_lerror:
3011  tolua_error(tolua_S,"#ferror in function 'w'.",&tolua_err);
3012  return 0;
3013 #endif
3014 }
3015 #endif //#ifndef TOLUA_DISABLE
3016 
3017 /* method: setX of class fawkes::tf::Quaternion */
3018 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_setX00
3019 static int tolua_fawkestf_fawkes_tf_Quaternion_setX00(lua_State* tolua_S)
3020 {
3021 #ifndef TOLUA_RELEASE
3022  tolua_Error tolua_err;
3023  if (
3024  !tolua_isusertype(tolua_S,1,"fawkes::tf::Quaternion",0,&tolua_err) ||
3025  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
3026  !tolua_isnoobj(tolua_S,3,&tolua_err)
3027  )
3028  goto tolua_lerror;
3029  else
3030 #endif
3031  {
3032  fawkes::tf::Quaternion* self = (fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,1,0);
3033  double x = ((double) tolua_tonumber(tolua_S,2,0));
3034 #ifndef TOLUA_RELEASE
3035  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setX'", NULL);
3036 #endif
3037  bool exc_caught = false;
3038  try {
3039  {
3040  self->setX(x);
3041  }
3042  } catch (fawkes::Exception &e) {
3043  exc_caught = true;
3044  lua_pushstring(tolua_S, e.what_no_backtrace());
3045  }
3046  catch (std::exception &e) {
3047  exc_caught = true;
3048  lua_pushstring(tolua_S, e.what());
3049  }
3050  if (exc_caught) lua_error(tolua_S);
3051 
3052  }
3053  return 0;
3054 #ifndef TOLUA_RELEASE
3055  tolua_lerror:
3056  tolua_error(tolua_S,"#ferror in function 'setX'.",&tolua_err);
3057  return 0;
3058 #endif
3059 }
3060 #endif //#ifndef TOLUA_DISABLE
3061 
3062 /* method: setY of class fawkes::tf::Quaternion */
3063 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_setY00
3064 static int tolua_fawkestf_fawkes_tf_Quaternion_setY00(lua_State* tolua_S)
3065 {
3066 #ifndef TOLUA_RELEASE
3067  tolua_Error tolua_err;
3068  if (
3069  !tolua_isusertype(tolua_S,1,"fawkes::tf::Quaternion",0,&tolua_err) ||
3070  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
3071  !tolua_isnoobj(tolua_S,3,&tolua_err)
3072  )
3073  goto tolua_lerror;
3074  else
3075 #endif
3076  {
3077  fawkes::tf::Quaternion* self = (fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,1,0);
3078  double x = ((double) tolua_tonumber(tolua_S,2,0));
3079 #ifndef TOLUA_RELEASE
3080  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setY'", NULL);
3081 #endif
3082  bool exc_caught = false;
3083  try {
3084  {
3085  self->setY(x);
3086  }
3087  } catch (fawkes::Exception &e) {
3088  exc_caught = true;
3089  lua_pushstring(tolua_S, e.what_no_backtrace());
3090  }
3091  catch (std::exception &e) {
3092  exc_caught = true;
3093  lua_pushstring(tolua_S, e.what());
3094  }
3095  if (exc_caught) lua_error(tolua_S);
3096 
3097  }
3098  return 0;
3099 #ifndef TOLUA_RELEASE
3100  tolua_lerror:
3101  tolua_error(tolua_S,"#ferror in function 'setY'.",&tolua_err);
3102  return 0;
3103 #endif
3104 }
3105 #endif //#ifndef TOLUA_DISABLE
3106 
3107 /* method: setZ of class fawkes::tf::Quaternion */
3108 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_setZ00
3109 static int tolua_fawkestf_fawkes_tf_Quaternion_setZ00(lua_State* tolua_S)
3110 {
3111 #ifndef TOLUA_RELEASE
3112  tolua_Error tolua_err;
3113  if (
3114  !tolua_isusertype(tolua_S,1,"fawkes::tf::Quaternion",0,&tolua_err) ||
3115  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
3116  !tolua_isnoobj(tolua_S,3,&tolua_err)
3117  )
3118  goto tolua_lerror;
3119  else
3120 #endif
3121  {
3122  fawkes::tf::Quaternion* self = (fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,1,0);
3123  double x = ((double) tolua_tonumber(tolua_S,2,0));
3124 #ifndef TOLUA_RELEASE
3125  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setZ'", NULL);
3126 #endif
3127  bool exc_caught = false;
3128  try {
3129  {
3130  self->setZ(x);
3131  }
3132  } catch (fawkes::Exception &e) {
3133  exc_caught = true;
3134  lua_pushstring(tolua_S, e.what_no_backtrace());
3135  }
3136  catch (std::exception &e) {
3137  exc_caught = true;
3138  lua_pushstring(tolua_S, e.what());
3139  }
3140  if (exc_caught) lua_error(tolua_S);
3141 
3142  }
3143  return 0;
3144 #ifndef TOLUA_RELEASE
3145  tolua_lerror:
3146  tolua_error(tolua_S,"#ferror in function 'setZ'.",&tolua_err);
3147  return 0;
3148 #endif
3149 }
3150 #endif //#ifndef TOLUA_DISABLE
3151 
3152 /* method: setW of class fawkes::tf::Quaternion */
3153 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_setW00
3154 static int tolua_fawkestf_fawkes_tf_Quaternion_setW00(lua_State* tolua_S)
3155 {
3156 #ifndef TOLUA_RELEASE
3157  tolua_Error tolua_err;
3158  if (
3159  !tolua_isusertype(tolua_S,1,"fawkes::tf::Quaternion",0,&tolua_err) ||
3160  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
3161  !tolua_isnoobj(tolua_S,3,&tolua_err)
3162  )
3163  goto tolua_lerror;
3164  else
3165 #endif
3166  {
3167  fawkes::tf::Quaternion* self = (fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,1,0);
3168  double x = ((double) tolua_tonumber(tolua_S,2,0));
3169 #ifndef TOLUA_RELEASE
3170  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setW'", NULL);
3171 #endif
3172  bool exc_caught = false;
3173  try {
3174  {
3175  self->setW(x);
3176  }
3177  } catch (fawkes::Exception &e) {
3178  exc_caught = true;
3179  lua_pushstring(tolua_S, e.what_no_backtrace());
3180  }
3181  catch (std::exception &e) {
3182  exc_caught = true;
3183  lua_pushstring(tolua_S, e.what());
3184  }
3185  if (exc_caught) lua_error(tolua_S);
3186 
3187  }
3188  return 0;
3189 #ifndef TOLUA_RELEASE
3190  tolua_lerror:
3191  tolua_error(tolua_S,"#ferror in function 'setW'.",&tolua_err);
3192  return 0;
3193 #endif
3194 }
3195 #endif //#ifndef TOLUA_DISABLE
3196 
3197 /* method: setValue of class fawkes::tf::Quaternion */
3198 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_setValue00
3199 static int tolua_fawkestf_fawkes_tf_Quaternion_setValue00(lua_State* tolua_S)
3200 {
3201 #ifndef TOLUA_RELEASE
3202  tolua_Error tolua_err;
3203  if (
3204  !tolua_isusertype(tolua_S,1,"fawkes::tf::Quaternion",0,&tolua_err) ||
3205  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
3206  !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
3207  !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
3208  !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
3209  !tolua_isnoobj(tolua_S,6,&tolua_err)
3210  )
3211  goto tolua_lerror;
3212  else
3213 #endif
3214  {
3215  fawkes::tf::Quaternion* self = (fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,1,0);
3216  double x = ((double) tolua_tonumber(tolua_S,2,0));
3217  double y = ((double) tolua_tonumber(tolua_S,3,0));
3218  double z = ((double) tolua_tonumber(tolua_S,4,0));
3219  double w = ((double) tolua_tonumber(tolua_S,5,0));
3220 #ifndef TOLUA_RELEASE
3221  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setValue'", NULL);
3222 #endif
3223  bool exc_caught = false;
3224  try {
3225  {
3226  self->setValue(x,y,z,w);
3227  }
3228  } catch (fawkes::Exception &e) {
3229  exc_caught = true;
3230  lua_pushstring(tolua_S, e.what_no_backtrace());
3231  }
3232  catch (std::exception &e) {
3233  exc_caught = true;
3234  lua_pushstring(tolua_S, e.what());
3235  }
3236  if (exc_caught) lua_error(tolua_S);
3237 
3238  }
3239  return 0;
3240 #ifndef TOLUA_RELEASE
3241  tolua_lerror:
3242  tolua_error(tolua_S,"#ferror in function 'setValue'.",&tolua_err);
3243  return 0;
3244 #endif
3245 }
3246 #endif //#ifndef TOLUA_DISABLE
3247 
3248 /* method: new of class fawkes::tf::Transform */
3249 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform_new00
3250 static int tolua_fawkestf_fawkes_tf_Transform_new00(lua_State* tolua_S)
3251 {
3252 #ifndef TOLUA_RELEASE
3253  tolua_Error tolua_err;
3254  if (
3255  !tolua_isusertable(tolua_S,1,"fawkes::tf::Transform",0,&tolua_err) ||
3256  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Quaternion",0,&tolua_err)) ||
3257  !tolua_isnoobj(tolua_S,3,&tolua_err)
3258  )
3259  goto tolua_lerror;
3260  else
3261 #endif
3262  {
3263  const fawkes::tf::Quaternion* q = ((const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,2,0));
3264  bool exc_caught = false;
3265  try {
3266  {
3267  fawkes::tf::Transform* tolua_ret = (fawkes::tf::Transform*) Mtolua_new((fawkes::tf::Transform)(*q));
3268  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Transform");
3269  }
3270  } catch (fawkes::Exception &e) {
3271  exc_caught = true;
3272  lua_pushstring(tolua_S, e.what_no_backtrace());
3273  }
3274  catch (std::exception &e) {
3275  exc_caught = true;
3276  lua_pushstring(tolua_S, e.what());
3277  }
3278  if (exc_caught) lua_error(tolua_S);
3279 
3280  }
3281  return 1;
3282 #ifndef TOLUA_RELEASE
3283  tolua_lerror:
3284  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
3285  return 0;
3286 #endif
3287 }
3288 #endif //#ifndef TOLUA_DISABLE
3289 
3290 /* method: new_local of class fawkes::tf::Transform */
3291 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform_new00_local
3292 static int tolua_fawkestf_fawkes_tf_Transform_new00_local(lua_State* tolua_S)
3293 {
3294 #ifndef TOLUA_RELEASE
3295  tolua_Error tolua_err;
3296  if (
3297  !tolua_isusertable(tolua_S,1,"fawkes::tf::Transform",0,&tolua_err) ||
3298  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Quaternion",0,&tolua_err)) ||
3299  !tolua_isnoobj(tolua_S,3,&tolua_err)
3300  )
3301  goto tolua_lerror;
3302  else
3303 #endif
3304  {
3305  const fawkes::tf::Quaternion* q = ((const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,2,0));
3306  bool exc_caught = false;
3307  try {
3308  {
3309  fawkes::tf::Transform* tolua_ret = (fawkes::tf::Transform*) Mtolua_new((fawkes::tf::Transform)(*q));
3310  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Transform");
3311  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
3312  }
3313  } catch (fawkes::Exception &e) {
3314  exc_caught = true;
3315  lua_pushstring(tolua_S, e.what_no_backtrace());
3316  }
3317  catch (std::exception &e) {
3318  exc_caught = true;
3319  lua_pushstring(tolua_S, e.what());
3320  }
3321  if (exc_caught) lua_error(tolua_S);
3322 
3323  }
3324  return 1;
3325 #ifndef TOLUA_RELEASE
3326  tolua_lerror:
3327  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
3328  return 0;
3329 #endif
3330 }
3331 #endif //#ifndef TOLUA_DISABLE
3332 
3333 /* method: new of class fawkes::tf::Transform */
3334 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform_new01
3335 static int tolua_fawkestf_fawkes_tf_Transform_new01(lua_State* tolua_S)
3336 {
3337  tolua_Error tolua_err;
3338  if (
3339  !tolua_isusertable(tolua_S,1,"fawkes::tf::Transform",0,&tolua_err) ||
3340  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Quaternion",0,&tolua_err)) ||
3341  (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::tf::Vector3",0,&tolua_err)) ||
3342  !tolua_isnoobj(tolua_S,4,&tolua_err)
3343  )
3344  goto tolua_lerror;
3345  else
3346  {
3347  const fawkes::tf::Quaternion* q = ((const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,2,0));
3348  const fawkes::tf::Vector3* c = ((const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,3,0));
3349  bool exc_caught = false;
3350  try {
3351  {
3352  fawkes::tf::Transform* tolua_ret = (fawkes::tf::Transform*) Mtolua_new((fawkes::tf::Transform)(*q,*c));
3353  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Transform");
3354  }
3355  } catch (fawkes::Exception &e) {
3356  exc_caught = true;
3357  lua_pushstring(tolua_S, e.what_no_backtrace());
3358  }
3359  catch (std::exception &e) {
3360  exc_caught = true;
3361  lua_pushstring(tolua_S, e.what());
3362  }
3363  if (exc_caught) lua_error(tolua_S);
3364 
3365  }
3366  return 1;
3367 tolua_lerror:
3368  return tolua_fawkestf_fawkes_tf_Transform_new00(tolua_S);
3369 }
3370 #endif //#ifndef TOLUA_DISABLE
3371 
3372 /* method: new_local of class fawkes::tf::Transform */
3373 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform_new01_local
3374 static int tolua_fawkestf_fawkes_tf_Transform_new01_local(lua_State* tolua_S)
3375 {
3376  tolua_Error tolua_err;
3377  if (
3378  !tolua_isusertable(tolua_S,1,"fawkes::tf::Transform",0,&tolua_err) ||
3379  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Quaternion",0,&tolua_err)) ||
3380  (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::tf::Vector3",0,&tolua_err)) ||
3381  !tolua_isnoobj(tolua_S,4,&tolua_err)
3382  )
3383  goto tolua_lerror;
3384  else
3385  {
3386  const fawkes::tf::Quaternion* q = ((const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,2,0));
3387  const fawkes::tf::Vector3* c = ((const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,3,0));
3388  bool exc_caught = false;
3389  try {
3390  {
3391  fawkes::tf::Transform* tolua_ret = (fawkes::tf::Transform*) Mtolua_new((fawkes::tf::Transform)(*q,*c));
3392  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Transform");
3393  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
3394  }
3395  } catch (fawkes::Exception &e) {
3396  exc_caught = true;
3397  lua_pushstring(tolua_S, e.what_no_backtrace());
3398  }
3399  catch (std::exception &e) {
3400  exc_caught = true;
3401  lua_pushstring(tolua_S, e.what());
3402  }
3403  if (exc_caught) lua_error(tolua_S);
3404 
3405  }
3406  return 1;
3407 tolua_lerror:
3408  return tolua_fawkestf_fawkes_tf_Transform_new00_local(tolua_S);
3409 }
3410 #endif //#ifndef TOLUA_DISABLE
3411 
3412 /* method: new of class fawkes::tf::Transform */
3413 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform_new02
3414 static int tolua_fawkestf_fawkes_tf_Transform_new02(lua_State* tolua_S)
3415 {
3416  tolua_Error tolua_err;
3417  if (
3418  !tolua_isusertable(tolua_S,1,"fawkes::tf::Transform",0,&tolua_err) ||
3419  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Transform",0,&tolua_err)) ||
3420  !tolua_isnoobj(tolua_S,3,&tolua_err)
3421  )
3422  goto tolua_lerror;
3423  else
3424  {
3425  const fawkes::tf::Transform* other = ((const fawkes::tf::Transform*) tolua_tousertype(tolua_S,2,0));
3426  bool exc_caught = false;
3427  try {
3428  {
3429  fawkes::tf::Transform* tolua_ret = (fawkes::tf::Transform*) Mtolua_new((fawkes::tf::Transform)(*other));
3430  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Transform");
3431  }
3432  } catch (fawkes::Exception &e) {
3433  exc_caught = true;
3434  lua_pushstring(tolua_S, e.what_no_backtrace());
3435  }
3436  catch (std::exception &e) {
3437  exc_caught = true;
3438  lua_pushstring(tolua_S, e.what());
3439  }
3440  if (exc_caught) lua_error(tolua_S);
3441 
3442  }
3443  return 1;
3444 tolua_lerror:
3445  return tolua_fawkestf_fawkes_tf_Transform_new01(tolua_S);
3446 }
3447 #endif //#ifndef TOLUA_DISABLE
3448 
3449 /* method: new_local of class fawkes::tf::Transform */
3450 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform_new02_local
3451 static int tolua_fawkestf_fawkes_tf_Transform_new02_local(lua_State* tolua_S)
3452 {
3453  tolua_Error tolua_err;
3454  if (
3455  !tolua_isusertable(tolua_S,1,"fawkes::tf::Transform",0,&tolua_err) ||
3456  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Transform",0,&tolua_err)) ||
3457  !tolua_isnoobj(tolua_S,3,&tolua_err)
3458  )
3459  goto tolua_lerror;
3460  else
3461  {
3462  const fawkes::tf::Transform* other = ((const fawkes::tf::Transform*) tolua_tousertype(tolua_S,2,0));
3463  bool exc_caught = false;
3464  try {
3465  {
3466  fawkes::tf::Transform* tolua_ret = (fawkes::tf::Transform*) Mtolua_new((fawkes::tf::Transform)(*other));
3467  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Transform");
3468  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
3469  }
3470  } catch (fawkes::Exception &e) {
3471  exc_caught = true;
3472  lua_pushstring(tolua_S, e.what_no_backtrace());
3473  }
3474  catch (std::exception &e) {
3475  exc_caught = true;
3476  lua_pushstring(tolua_S, e.what());
3477  }
3478  if (exc_caught) lua_error(tolua_S);
3479 
3480  }
3481  return 1;
3482 tolua_lerror:
3483  return tolua_fawkestf_fawkes_tf_Transform_new01_local(tolua_S);
3484 }
3485 #endif //#ifndef TOLUA_DISABLE
3486 
3487 /* method: getIdentity of class fawkes::tf::Transform */
3488 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform_getIdentity00
3489 static int tolua_fawkestf_fawkes_tf_Transform_getIdentity00(lua_State* tolua_S)
3490 {
3491 #ifndef TOLUA_RELEASE
3492  tolua_Error tolua_err;
3493  if (
3494  !tolua_isusertable(tolua_S,1,"fawkes::tf::Transform",0,&tolua_err) ||
3495  !tolua_isnoobj(tolua_S,2,&tolua_err)
3496  )
3497  goto tolua_lerror;
3498  else
3499 #endif
3500  {
3501  bool exc_caught = false;
3502  try {
3503  {
3504  const fawkes::tf::Transform& tolua_ret = (const fawkes::tf::Transform&) fawkes::tf::Transform::getIdentity();
3505  tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const fawkes::tf::Transform");
3506  }
3507  } catch (fawkes::Exception &e) {
3508  exc_caught = true;
3509  lua_pushstring(tolua_S, e.what_no_backtrace());
3510  }
3511  catch (std::exception &e) {
3512  exc_caught = true;
3513  lua_pushstring(tolua_S, e.what());
3514  }
3515  if (exc_caught) lua_error(tolua_S);
3516 
3517  }
3518  return 1;
3519 #ifndef TOLUA_RELEASE
3520  tolua_lerror:
3521  tolua_error(tolua_S,"#ferror in function 'getIdentity'.",&tolua_err);
3522  return 0;
3523 #endif
3524 }
3525 #endif //#ifndef TOLUA_DISABLE
3526 
3527 /* method: mult of class fawkes::tf::Transform */
3528 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform_mult00
3529 static int tolua_fawkestf_fawkes_tf_Transform_mult00(lua_State* tolua_S)
3530 {
3531 #ifndef TOLUA_RELEASE
3532  tolua_Error tolua_err;
3533  if (
3534  !tolua_isusertype(tolua_S,1,"fawkes::tf::Transform",0,&tolua_err) ||
3535  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Transform",0,&tolua_err)) ||
3536  (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::tf::Transform",0,&tolua_err)) ||
3537  !tolua_isnoobj(tolua_S,4,&tolua_err)
3538  )
3539  goto tolua_lerror;
3540  else
3541 #endif
3542  {
3543  fawkes::tf::Transform* self = (fawkes::tf::Transform*) tolua_tousertype(tolua_S,1,0);
3544  const fawkes::tf::Transform* t1 = ((const fawkes::tf::Transform*) tolua_tousertype(tolua_S,2,0));
3545  const fawkes::tf::Transform* t2 = ((const fawkes::tf::Transform*) tolua_tousertype(tolua_S,3,0));
3546 #ifndef TOLUA_RELEASE
3547  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'mult'", NULL);
3548 #endif
3549  bool exc_caught = false;
3550  try {
3551  {
3552  self->mult(*t1,*t2);
3553  }
3554  } catch (fawkes::Exception &e) {
3555  exc_caught = true;
3556  lua_pushstring(tolua_S, e.what_no_backtrace());
3557  }
3558  catch (std::exception &e) {
3559  exc_caught = true;
3560  lua_pushstring(tolua_S, e.what());
3561  }
3562  if (exc_caught) lua_error(tolua_S);
3563 
3564  }
3565  return 0;
3566 #ifndef TOLUA_RELEASE
3567  tolua_lerror:
3568  tolua_error(tolua_S,"#ferror in function 'mult'.",&tolua_err);
3569  return 0;
3570 #endif
3571 }
3572 #endif //#ifndef TOLUA_DISABLE
3573 
3574 /* method: operator* of class fawkes::tf::Transform */
3575 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform__mul00
3576 static int tolua_fawkestf_fawkes_tf_Transform__mul00(lua_State* tolua_S)
3577 {
3578 #ifndef TOLUA_RELEASE
3579  tolua_Error tolua_err;
3580  if (
3581  !tolua_isusertype(tolua_S,1,"const fawkes::tf::Transform",0,&tolua_err) ||
3582  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Vector3",0,&tolua_err)) ||
3583  !tolua_isnoobj(tolua_S,3,&tolua_err)
3584  )
3585  goto tolua_lerror;
3586  else
3587 #endif
3588  {
3589  const fawkes::tf::Transform* self = (const fawkes::tf::Transform*) tolua_tousertype(tolua_S,1,0);
3590  const fawkes::tf::Vector3* x = ((const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,2,0));
3591 #ifndef TOLUA_RELEASE
3592  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator*'", NULL);
3593 #endif
3594  bool exc_caught = false;
3595  try {
3596  {
3597  fawkes::tf::Vector3 tolua_ret = (fawkes::tf::Vector3) self->operator*(*x);
3598  {
3599 #ifdef __cplusplus
3600  void* tolua_obj = Mtolua_new((fawkes::tf::Vector3)(tolua_ret));
3601  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::tf::Vector3");
3602  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
3603 #else
3604  void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::tf::Vector3));
3605  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::tf::Vector3");
3606  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
3607 #endif
3608  }
3609  }
3610  } catch (fawkes::Exception &e) {
3611  exc_caught = true;
3612  lua_pushstring(tolua_S, e.what_no_backtrace());
3613  }
3614  catch (std::exception &e) {
3615  exc_caught = true;
3616  lua_pushstring(tolua_S, e.what());
3617  }
3618  if (exc_caught) lua_error(tolua_S);
3619 
3620  }
3621  return 1;
3622 #ifndef TOLUA_RELEASE
3623  tolua_lerror:
3624  tolua_error(tolua_S,"#ferror in function '.mul'.",&tolua_err);
3625  return 0;
3626 #endif
3627 }
3628 #endif //#ifndef TOLUA_DISABLE
3629 
3630 /* method: operator* of class fawkes::tf::Transform */
3631 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform__mul01
3632 static int tolua_fawkestf_fawkes_tf_Transform__mul01(lua_State* tolua_S)
3633 {
3634  tolua_Error tolua_err;
3635  if (
3636  !tolua_isusertype(tolua_S,1,"const fawkes::tf::Transform",0,&tolua_err) ||
3637  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Quaternion",0,&tolua_err)) ||
3638  !tolua_isnoobj(tolua_S,3,&tolua_err)
3639  )
3640  goto tolua_lerror;
3641  else
3642  {
3643  const fawkes::tf::Transform* self = (const fawkes::tf::Transform*) tolua_tousertype(tolua_S,1,0);
3644  const fawkes::tf::Quaternion* q = ((const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,2,0));
3645 #ifndef TOLUA_RELEASE
3646  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator*'", NULL);
3647 #endif
3648  bool exc_caught = false;
3649  try {
3650  {
3651  fawkes::tf::Quaternion tolua_ret = (fawkes::tf::Quaternion) self->operator*(*q);
3652  {
3653 #ifdef __cplusplus
3654  void* tolua_obj = Mtolua_new((fawkes::tf::Quaternion)(tolua_ret));
3655  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::tf::Quaternion");
3656  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
3657 #else
3658  void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::tf::Quaternion));
3659  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::tf::Quaternion");
3660  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
3661 #endif
3662  }
3663  }
3664  } catch (fawkes::Exception &e) {
3665  exc_caught = true;
3666  lua_pushstring(tolua_S, e.what_no_backtrace());
3667  }
3668  catch (std::exception &e) {
3669  exc_caught = true;
3670  lua_pushstring(tolua_S, e.what());
3671  }
3672  if (exc_caught) lua_error(tolua_S);
3673 
3674  }
3675  return 1;
3676 tolua_lerror:
3677  return tolua_fawkestf_fawkes_tf_Transform__mul00(tolua_S);
3678 }
3679 #endif //#ifndef TOLUA_DISABLE
3680 
3681 /* method: getOrigin of class fawkes::tf::Transform */
3682 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform_getOrigin00
3683 static int tolua_fawkestf_fawkes_tf_Transform_getOrigin00(lua_State* tolua_S)
3684 {
3685 #ifndef TOLUA_RELEASE
3686  tolua_Error tolua_err;
3687  if (
3688  !tolua_isusertype(tolua_S,1,"fawkes::tf::Transform",0,&tolua_err) ||
3689  !tolua_isnoobj(tolua_S,2,&tolua_err)
3690  )
3691  goto tolua_lerror;
3692  else
3693 #endif
3694  {
3695  fawkes::tf::Transform* self = (fawkes::tf::Transform*) tolua_tousertype(tolua_S,1,0);
3696 #ifndef TOLUA_RELEASE
3697  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getOrigin'", NULL);
3698 #endif
3699  bool exc_caught = false;
3700  try {
3701  {
3702  fawkes::tf::Vector3& tolua_ret = (fawkes::tf::Vector3&) self->getOrigin();
3703  tolua_pushusertype(tolua_S,(void*)&tolua_ret,"fawkes::tf::Vector3");
3704  }
3705  } catch (fawkes::Exception &e) {
3706  exc_caught = true;
3707  lua_pushstring(tolua_S, e.what_no_backtrace());
3708  }
3709  catch (std::exception &e) {
3710  exc_caught = true;
3711  lua_pushstring(tolua_S, e.what());
3712  }
3713  if (exc_caught) lua_error(tolua_S);
3714 
3715  }
3716  return 1;
3717 #ifndef TOLUA_RELEASE
3718  tolua_lerror:
3719  tolua_error(tolua_S,"#ferror in function 'getOrigin'.",&tolua_err);
3720  return 0;
3721 #endif
3722 }
3723 #endif //#ifndef TOLUA_DISABLE
3724 
3725 /* method: getRotation of class fawkes::tf::Transform */
3726 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform_getRotation00
3727 static int tolua_fawkestf_fawkes_tf_Transform_getRotation00(lua_State* tolua_S)
3728 {
3729 #ifndef TOLUA_RELEASE
3730  tolua_Error tolua_err;
3731  if (
3732  !tolua_isusertype(tolua_S,1,"const fawkes::tf::Transform",0,&tolua_err) ||
3733  !tolua_isnoobj(tolua_S,2,&tolua_err)
3734  )
3735  goto tolua_lerror;
3736  else
3737 #endif
3738  {
3739  const fawkes::tf::Transform* self = (const fawkes::tf::Transform*) tolua_tousertype(tolua_S,1,0);
3740 #ifndef TOLUA_RELEASE
3741  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getRotation'", NULL);
3742 #endif
3743  bool exc_caught = false;
3744  try {
3745  {
3746  fawkes::tf::Quaternion tolua_ret = (fawkes::tf::Quaternion) self->getRotation();
3747  {
3748 #ifdef __cplusplus
3749  void* tolua_obj = Mtolua_new((fawkes::tf::Quaternion)(tolua_ret));
3750  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::tf::Quaternion");
3751  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
3752 #else
3753  void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::tf::Quaternion));
3754  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::tf::Quaternion");
3755  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
3756 #endif
3757  }
3758  }
3759  } catch (fawkes::Exception &e) {
3760  exc_caught = true;
3761  lua_pushstring(tolua_S, e.what_no_backtrace());
3762  }
3763  catch (std::exception &e) {
3764  exc_caught = true;
3765  lua_pushstring(tolua_S, e.what());
3766  }
3767  if (exc_caught) lua_error(tolua_S);
3768 
3769  }
3770  return 1;
3771 #ifndef TOLUA_RELEASE
3772  tolua_lerror:
3773  tolua_error(tolua_S,"#ferror in function 'getRotation'.",&tolua_err);
3774  return 0;
3775 #endif
3776 }
3777 #endif //#ifndef TOLUA_DISABLE
3778 
3779 /* method: setOrigin of class fawkes::tf::Transform */
3780 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform_setOrigin00
3781 static int tolua_fawkestf_fawkes_tf_Transform_setOrigin00(lua_State* tolua_S)
3782 {
3783 #ifndef TOLUA_RELEASE
3784  tolua_Error tolua_err;
3785  if (
3786  !tolua_isusertype(tolua_S,1,"fawkes::tf::Transform",0,&tolua_err) ||
3787  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Vector3",0,&tolua_err)) ||
3788  !tolua_isnoobj(tolua_S,3,&tolua_err)
3789  )
3790  goto tolua_lerror;
3791  else
3792 #endif
3793  {
3794  fawkes::tf::Transform* self = (fawkes::tf::Transform*) tolua_tousertype(tolua_S,1,0);
3795  const fawkes::tf::Vector3* origin = ((const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,2,0));
3796 #ifndef TOLUA_RELEASE
3797  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setOrigin'", NULL);
3798 #endif
3799  bool exc_caught = false;
3800  try {
3801  {
3802  self->setOrigin(*origin);
3803  }
3804  } catch (fawkes::Exception &e) {
3805  exc_caught = true;
3806  lua_pushstring(tolua_S, e.what_no_backtrace());
3807  }
3808  catch (std::exception &e) {
3809  exc_caught = true;
3810  lua_pushstring(tolua_S, e.what());
3811  }
3812  if (exc_caught) lua_error(tolua_S);
3813 
3814  }
3815  return 0;
3816 #ifndef TOLUA_RELEASE
3817  tolua_lerror:
3818  tolua_error(tolua_S,"#ferror in function 'setOrigin'.",&tolua_err);
3819  return 0;
3820 #endif
3821 }
3822 #endif //#ifndef TOLUA_DISABLE
3823 
3824 /* method: setRotation of class fawkes::tf::Transform */
3825 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform_setRotation00
3826 static int tolua_fawkestf_fawkes_tf_Transform_setRotation00(lua_State* tolua_S)
3827 {
3828 #ifndef TOLUA_RELEASE
3829  tolua_Error tolua_err;
3830  if (
3831  !tolua_isusertype(tolua_S,1,"fawkes::tf::Transform",0,&tolua_err) ||
3832  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Quaternion",0,&tolua_err)) ||
3833  !tolua_isnoobj(tolua_S,3,&tolua_err)
3834  )
3835  goto tolua_lerror;
3836  else
3837 #endif
3838  {
3839  fawkes::tf::Transform* self = (fawkes::tf::Transform*) tolua_tousertype(tolua_S,1,0);
3840  const fawkes::tf::Quaternion* q = ((const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,2,0));
3841 #ifndef TOLUA_RELEASE
3842  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setRotation'", NULL);
3843 #endif
3844  bool exc_caught = false;
3845  try {
3846  {
3847  self->setRotation(*q);
3848  }
3849  } catch (fawkes::Exception &e) {
3850  exc_caught = true;
3851  lua_pushstring(tolua_S, e.what_no_backtrace());
3852  }
3853  catch (std::exception &e) {
3854  exc_caught = true;
3855  lua_pushstring(tolua_S, e.what());
3856  }
3857  if (exc_caught) lua_error(tolua_S);
3858 
3859  }
3860  return 0;
3861 #ifndef TOLUA_RELEASE
3862  tolua_lerror:
3863  tolua_error(tolua_S,"#ferror in function 'setRotation'.",&tolua_err);
3864  return 0;
3865 #endif
3866 }
3867 #endif //#ifndef TOLUA_DISABLE
3868 
3869 /* method: setIdentity of class fawkes::tf::Transform */
3870 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform_setIdentity00
3871 static int tolua_fawkestf_fawkes_tf_Transform_setIdentity00(lua_State* tolua_S)
3872 {
3873 #ifndef TOLUA_RELEASE
3874  tolua_Error tolua_err;
3875  if (
3876  !tolua_isusertype(tolua_S,1,"fawkes::tf::Transform",0,&tolua_err) ||
3877  !tolua_isnoobj(tolua_S,2,&tolua_err)
3878  )
3879  goto tolua_lerror;
3880  else
3881 #endif
3882  {
3883  fawkes::tf::Transform* self = (fawkes::tf::Transform*) tolua_tousertype(tolua_S,1,0);
3884 #ifndef TOLUA_RELEASE
3885  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setIdentity'", NULL);
3886 #endif
3887  bool exc_caught = false;
3888  try {
3889  {
3890  self->setIdentity();
3891  }
3892  } catch (fawkes::Exception &e) {
3893  exc_caught = true;
3894  lua_pushstring(tolua_S, e.what_no_backtrace());
3895  }
3896  catch (std::exception &e) {
3897  exc_caught = true;
3898  lua_pushstring(tolua_S, e.what());
3899  }
3900  if (exc_caught) lua_error(tolua_S);
3901 
3902  }
3903  return 0;
3904 #ifndef TOLUA_RELEASE
3905  tolua_lerror:
3906  tolua_error(tolua_S,"#ferror in function 'setIdentity'.",&tolua_err);
3907  return 0;
3908 #endif
3909 }
3910 #endif //#ifndef TOLUA_DISABLE
3911 
3912 /* method: inverse of class fawkes::tf::Transform */
3913 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform_inverse00
3914 static int tolua_fawkestf_fawkes_tf_Transform_inverse00(lua_State* tolua_S)
3915 {
3916 #ifndef TOLUA_RELEASE
3917  tolua_Error tolua_err;
3918  if (
3919  !tolua_isusertype(tolua_S,1,"const fawkes::tf::Transform",0,&tolua_err) ||
3920  !tolua_isnoobj(tolua_S,2,&tolua_err)
3921  )
3922  goto tolua_lerror;
3923  else
3924 #endif
3925  {
3926  const fawkes::tf::Transform* self = (const fawkes::tf::Transform*) tolua_tousertype(tolua_S,1,0);
3927 #ifndef TOLUA_RELEASE
3928  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'inverse'", NULL);
3929 #endif
3930  bool exc_caught = false;
3931  try {
3932  {
3933  fawkes::tf::Transform tolua_ret = (fawkes::tf::Transform) self->inverse();
3934  {
3935 #ifdef __cplusplus
3936  void* tolua_obj = Mtolua_new((fawkes::tf::Transform)(tolua_ret));
3937  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::tf::Transform");
3938  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
3939 #else
3940  void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::tf::Transform));
3941  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::tf::Transform");
3942  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
3943 #endif
3944  }
3945  }
3946  } catch (fawkes::Exception &e) {
3947  exc_caught = true;
3948  lua_pushstring(tolua_S, e.what_no_backtrace());
3949  }
3950  catch (std::exception &e) {
3951  exc_caught = true;
3952  lua_pushstring(tolua_S, e.what());
3953  }
3954  if (exc_caught) lua_error(tolua_S);
3955 
3956  }
3957  return 1;
3958 #ifndef TOLUA_RELEASE
3959  tolua_lerror:
3960  tolua_error(tolua_S,"#ferror in function 'inverse'.",&tolua_err);
3961  return 0;
3962 #endif
3963 }
3964 #endif //#ifndef TOLUA_DISABLE
3965 
3966 /* method: inverseTimes of class fawkes::tf::Transform */
3967 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform_inverseTimes00
3968 static int tolua_fawkestf_fawkes_tf_Transform_inverseTimes00(lua_State* tolua_S)
3969 {
3970 #ifndef TOLUA_RELEASE
3971  tolua_Error tolua_err;
3972  if (
3973  !tolua_isusertype(tolua_S,1,"const fawkes::tf::Transform",0,&tolua_err) ||
3974  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Transform",0,&tolua_err)) ||
3975  !tolua_isnoobj(tolua_S,3,&tolua_err)
3976  )
3977  goto tolua_lerror;
3978  else
3979 #endif
3980  {
3981  const fawkes::tf::Transform* self = (const fawkes::tf::Transform*) tolua_tousertype(tolua_S,1,0);
3982  const fawkes::tf::Transform* t = ((const fawkes::tf::Transform*) tolua_tousertype(tolua_S,2,0));
3983 #ifndef TOLUA_RELEASE
3984  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'inverseTimes'", NULL);
3985 #endif
3986  bool exc_caught = false;
3987  try {
3988  {
3989  fawkes::tf::Transform tolua_ret = (fawkes::tf::Transform) self->inverseTimes(*t);
3990  {
3991 #ifdef __cplusplus
3992  void* tolua_obj = Mtolua_new((fawkes::tf::Transform)(tolua_ret));
3993  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::tf::Transform");
3994  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
3995 #else
3996  void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::tf::Transform));
3997  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::tf::Transform");
3998  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
3999 #endif
4000  }
4001  }
4002  } catch (fawkes::Exception &e) {
4003  exc_caught = true;
4004  lua_pushstring(tolua_S, e.what_no_backtrace());
4005  }
4006  catch (std::exception &e) {
4007  exc_caught = true;
4008  lua_pushstring(tolua_S, e.what());
4009  }
4010  if (exc_caught) lua_error(tolua_S);
4011 
4012  }
4013  return 1;
4014 #ifndef TOLUA_RELEASE
4015  tolua_lerror:
4016  tolua_error(tolua_S,"#ferror in function 'inverseTimes'.",&tolua_err);
4017  return 0;
4018 #endif
4019 }
4020 #endif //#ifndef TOLUA_DISABLE
4021 
4022 /* method: new of class fawkes::tf::Point */
4023 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Point_new00
4024 static int tolua_fawkestf_fawkes_tf_Point_new00(lua_State* tolua_S)
4025 {
4026 #ifndef TOLUA_RELEASE
4027  tolua_Error tolua_err;
4028  if (
4029  !tolua_isusertable(tolua_S,1,"fawkes::tf::Point",0,&tolua_err) ||
4030  !tolua_isnoobj(tolua_S,2,&tolua_err)
4031  )
4032  goto tolua_lerror;
4033  else
4034 #endif
4035  {
4036  bool exc_caught = false;
4037  try {
4038  {
4039  fawkes::tf::Point* tolua_ret = (fawkes::tf::Point*) Mtolua_new((fawkes::tf::Point)());
4040  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Point");
4041  }
4042  } catch (fawkes::Exception &e) {
4043  exc_caught = true;
4044  lua_pushstring(tolua_S, e.what_no_backtrace());
4045  }
4046  catch (std::exception &e) {
4047  exc_caught = true;
4048  lua_pushstring(tolua_S, e.what());
4049  }
4050  if (exc_caught) lua_error(tolua_S);
4051 
4052  }
4053  return 1;
4054 #ifndef TOLUA_RELEASE
4055  tolua_lerror:
4056  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
4057  return 0;
4058 #endif
4059 }
4060 #endif //#ifndef TOLUA_DISABLE
4061 
4062 /* method: new_local of class fawkes::tf::Point */
4063 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Point_new00_local
4064 static int tolua_fawkestf_fawkes_tf_Point_new00_local(lua_State* tolua_S)
4065 {
4066 #ifndef TOLUA_RELEASE
4067  tolua_Error tolua_err;
4068  if (
4069  !tolua_isusertable(tolua_S,1,"fawkes::tf::Point",0,&tolua_err) ||
4070  !tolua_isnoobj(tolua_S,2,&tolua_err)
4071  )
4072  goto tolua_lerror;
4073  else
4074 #endif
4075  {
4076  bool exc_caught = false;
4077  try {
4078  {
4079  fawkes::tf::Point* tolua_ret = (fawkes::tf::Point*) Mtolua_new((fawkes::tf::Point)());
4080  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Point");
4081  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
4082  }
4083  } catch (fawkes::Exception &e) {
4084  exc_caught = true;
4085  lua_pushstring(tolua_S, e.what_no_backtrace());
4086  }
4087  catch (std::exception &e) {
4088  exc_caught = true;
4089  lua_pushstring(tolua_S, e.what());
4090  }
4091  if (exc_caught) lua_error(tolua_S);
4092 
4093  }
4094  return 1;
4095 #ifndef TOLUA_RELEASE
4096  tolua_lerror:
4097  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
4098  return 0;
4099 #endif
4100 }
4101 #endif //#ifndef TOLUA_DISABLE
4102 
4103 /* method: new of class fawkes::tf::Point */
4104 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Point_new01
4105 static int tolua_fawkestf_fawkes_tf_Point_new01(lua_State* tolua_S)
4106 {
4107  tolua_Error tolua_err;
4108  if (
4109  !tolua_isusertable(tolua_S,1,"fawkes::tf::Point",0,&tolua_err) ||
4110  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
4111  !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
4112  !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
4113  !tolua_isnoobj(tolua_S,5,&tolua_err)
4114  )
4115  goto tolua_lerror;
4116  else
4117  {
4118  double x = ((double) tolua_tonumber(tolua_S,2,0));
4119  double y = ((double) tolua_tonumber(tolua_S,3,0));
4120  double z = ((double) tolua_tonumber(tolua_S,4,0));
4121  bool exc_caught = false;
4122  try {
4123  {
4124  fawkes::tf::Point* tolua_ret = (fawkes::tf::Point*) Mtolua_new((fawkes::tf::Point)(x,y,z));
4125  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Point");
4126  }
4127  } catch (fawkes::Exception &e) {
4128  exc_caught = true;
4129  lua_pushstring(tolua_S, e.what_no_backtrace());
4130  }
4131  catch (std::exception &e) {
4132  exc_caught = true;
4133  lua_pushstring(tolua_S, e.what());
4134  }
4135  if (exc_caught) lua_error(tolua_S);
4136 
4137  }
4138  return 1;
4139 tolua_lerror:
4140  return tolua_fawkestf_fawkes_tf_Point_new00(tolua_S);
4141 }
4142 #endif //#ifndef TOLUA_DISABLE
4143 
4144 /* method: new_local of class fawkes::tf::Point */
4145 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Point_new01_local
4146 static int tolua_fawkestf_fawkes_tf_Point_new01_local(lua_State* tolua_S)
4147 {
4148  tolua_Error tolua_err;
4149  if (
4150  !tolua_isusertable(tolua_S,1,"fawkes::tf::Point",0,&tolua_err) ||
4151  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
4152  !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
4153  !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
4154  !tolua_isnoobj(tolua_S,5,&tolua_err)
4155  )
4156  goto tolua_lerror;
4157  else
4158  {
4159  double x = ((double) tolua_tonumber(tolua_S,2,0));
4160  double y = ((double) tolua_tonumber(tolua_S,3,0));
4161  double z = ((double) tolua_tonumber(tolua_S,4,0));
4162  bool exc_caught = false;
4163  try {
4164  {
4165  fawkes::tf::Point* tolua_ret = (fawkes::tf::Point*) Mtolua_new((fawkes::tf::Point)(x,y,z));
4166  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Point");
4167  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
4168  }
4169  } catch (fawkes::Exception &e) {
4170  exc_caught = true;
4171  lua_pushstring(tolua_S, e.what_no_backtrace());
4172  }
4173  catch (std::exception &e) {
4174  exc_caught = true;
4175  lua_pushstring(tolua_S, e.what());
4176  }
4177  if (exc_caught) lua_error(tolua_S);
4178 
4179  }
4180  return 1;
4181 tolua_lerror:
4182  return tolua_fawkestf_fawkes_tf_Point_new00_local(tolua_S);
4183 }
4184 #endif //#ifndef TOLUA_DISABLE
4185 
4186 /* method: new of class fawkes::tf::Pose */
4187 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Pose_new00
4188 static int tolua_fawkestf_fawkes_tf_Pose_new00(lua_State* tolua_S)
4189 {
4190 #ifndef TOLUA_RELEASE
4191  tolua_Error tolua_err;
4192  if (
4193  !tolua_isusertable(tolua_S,1,"fawkes::tf::Pose",0,&tolua_err) ||
4194  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Quaternion",0,&tolua_err)) ||
4195  !tolua_isnoobj(tolua_S,3,&tolua_err)
4196  )
4197  goto tolua_lerror;
4198  else
4199 #endif
4200  {
4201  const fawkes::tf::Quaternion* q = ((const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,2,0));
4202  bool exc_caught = false;
4203  try {
4204  {
4205  fawkes::tf::Pose* tolua_ret = (fawkes::tf::Pose*) Mtolua_new((fawkes::tf::Pose)(*q));
4206  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Pose");
4207  }
4208  } catch (fawkes::Exception &e) {
4209  exc_caught = true;
4210  lua_pushstring(tolua_S, e.what_no_backtrace());
4211  }
4212  catch (std::exception &e) {
4213  exc_caught = true;
4214  lua_pushstring(tolua_S, e.what());
4215  }
4216  if (exc_caught) lua_error(tolua_S);
4217 
4218  }
4219  return 1;
4220 #ifndef TOLUA_RELEASE
4221  tolua_lerror:
4222  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
4223  return 0;
4224 #endif
4225 }
4226 #endif //#ifndef TOLUA_DISABLE
4227 
4228 /* method: new_local of class fawkes::tf::Pose */
4229 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Pose_new00_local
4230 static int tolua_fawkestf_fawkes_tf_Pose_new00_local(lua_State* tolua_S)
4231 {
4232 #ifndef TOLUA_RELEASE
4233  tolua_Error tolua_err;
4234  if (
4235  !tolua_isusertable(tolua_S,1,"fawkes::tf::Pose",0,&tolua_err) ||
4236  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Quaternion",0,&tolua_err)) ||
4237  !tolua_isnoobj(tolua_S,3,&tolua_err)
4238  )
4239  goto tolua_lerror;
4240  else
4241 #endif
4242  {
4243  const fawkes::tf::Quaternion* q = ((const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,2,0));
4244  bool exc_caught = false;
4245  try {
4246  {
4247  fawkes::tf::Pose* tolua_ret = (fawkes::tf::Pose*) Mtolua_new((fawkes::tf::Pose)(*q));
4248  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Pose");
4249  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
4250  }
4251  } catch (fawkes::Exception &e) {
4252  exc_caught = true;
4253  lua_pushstring(tolua_S, e.what_no_backtrace());
4254  }
4255  catch (std::exception &e) {
4256  exc_caught = true;
4257  lua_pushstring(tolua_S, e.what());
4258  }
4259  if (exc_caught) lua_error(tolua_S);
4260 
4261  }
4262  return 1;
4263 #ifndef TOLUA_RELEASE
4264  tolua_lerror:
4265  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
4266  return 0;
4267 #endif
4268 }
4269 #endif //#ifndef TOLUA_DISABLE
4270 
4271 /* method: new of class fawkes::tf::Pose */
4272 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Pose_new01
4273 static int tolua_fawkestf_fawkes_tf_Pose_new01(lua_State* tolua_S)
4274 {
4275  tolua_Error tolua_err;
4276  if (
4277  !tolua_isusertable(tolua_S,1,"fawkes::tf::Pose",0,&tolua_err) ||
4278  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Quaternion",0,&tolua_err)) ||
4279  (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::tf::Vector3",0,&tolua_err)) ||
4280  !tolua_isnoobj(tolua_S,4,&tolua_err)
4281  )
4282  goto tolua_lerror;
4283  else
4284  {
4285  const fawkes::tf::Quaternion* q = ((const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,2,0));
4286  const fawkes::tf::Vector3* c = ((const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,3,0));
4287  bool exc_caught = false;
4288  try {
4289  {
4290  fawkes::tf::Pose* tolua_ret = (fawkes::tf::Pose*) Mtolua_new((fawkes::tf::Pose)(*q,*c));
4291  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Pose");
4292  }
4293  } catch (fawkes::Exception &e) {
4294  exc_caught = true;
4295  lua_pushstring(tolua_S, e.what_no_backtrace());
4296  }
4297  catch (std::exception &e) {
4298  exc_caught = true;
4299  lua_pushstring(tolua_S, e.what());
4300  }
4301  if (exc_caught) lua_error(tolua_S);
4302 
4303  }
4304  return 1;
4305 tolua_lerror:
4306  return tolua_fawkestf_fawkes_tf_Pose_new00(tolua_S);
4307 }
4308 #endif //#ifndef TOLUA_DISABLE
4309 
4310 /* method: new_local of class fawkes::tf::Pose */
4311 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Pose_new01_local
4312 static int tolua_fawkestf_fawkes_tf_Pose_new01_local(lua_State* tolua_S)
4313 {
4314  tolua_Error tolua_err;
4315  if (
4316  !tolua_isusertable(tolua_S,1,"fawkes::tf::Pose",0,&tolua_err) ||
4317  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Quaternion",0,&tolua_err)) ||
4318  (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::tf::Vector3",0,&tolua_err)) ||
4319  !tolua_isnoobj(tolua_S,4,&tolua_err)
4320  )
4321  goto tolua_lerror;
4322  else
4323  {
4324  const fawkes::tf::Quaternion* q = ((const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,2,0));
4325  const fawkes::tf::Vector3* c = ((const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,3,0));
4326  bool exc_caught = false;
4327  try {
4328  {
4329  fawkes::tf::Pose* tolua_ret = (fawkes::tf::Pose*) Mtolua_new((fawkes::tf::Pose)(*q,*c));
4330  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Pose");
4331  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
4332  }
4333  } catch (fawkes::Exception &e) {
4334  exc_caught = true;
4335  lua_pushstring(tolua_S, e.what_no_backtrace());
4336  }
4337  catch (std::exception &e) {
4338  exc_caught = true;
4339  lua_pushstring(tolua_S, e.what());
4340  }
4341  if (exc_caught) lua_error(tolua_S);
4342 
4343  }
4344  return 1;
4345 tolua_lerror:
4346  return tolua_fawkestf_fawkes_tf_Pose_new00_local(tolua_S);
4347 }
4348 #endif //#ifndef TOLUA_DISABLE
4349 
4350 /* method: new of class fawkes::tf::Pose */
4351 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Pose_new02
4352 static int tolua_fawkestf_fawkes_tf_Pose_new02(lua_State* tolua_S)
4353 {
4354  tolua_Error tolua_err;
4355  if (
4356  !tolua_isusertable(tolua_S,1,"fawkes::tf::Pose",0,&tolua_err) ||
4357  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Pose",0,&tolua_err)) ||
4358  !tolua_isnoobj(tolua_S,3,&tolua_err)
4359  )
4360  goto tolua_lerror;
4361  else
4362  {
4363  const fawkes::tf::Pose* other = ((const fawkes::tf::Pose*) tolua_tousertype(tolua_S,2,0));
4364  bool exc_caught = false;
4365  try {
4366  {
4367  fawkes::tf::Pose* tolua_ret = (fawkes::tf::Pose*) Mtolua_new((fawkes::tf::Pose)(*other));
4368  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Pose");
4369  }
4370  } catch (fawkes::Exception &e) {
4371  exc_caught = true;
4372  lua_pushstring(tolua_S, e.what_no_backtrace());
4373  }
4374  catch (std::exception &e) {
4375  exc_caught = true;
4376  lua_pushstring(tolua_S, e.what());
4377  }
4378  if (exc_caught) lua_error(tolua_S);
4379 
4380  }
4381  return 1;
4382 tolua_lerror:
4383  return tolua_fawkestf_fawkes_tf_Pose_new01(tolua_S);
4384 }
4385 #endif //#ifndef TOLUA_DISABLE
4386 
4387 /* method: new_local of class fawkes::tf::Pose */
4388 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Pose_new02_local
4389 static int tolua_fawkestf_fawkes_tf_Pose_new02_local(lua_State* tolua_S)
4390 {
4391  tolua_Error tolua_err;
4392  if (
4393  !tolua_isusertable(tolua_S,1,"fawkes::tf::Pose",0,&tolua_err) ||
4394  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Pose",0,&tolua_err)) ||
4395  !tolua_isnoobj(tolua_S,3,&tolua_err)
4396  )
4397  goto tolua_lerror;
4398  else
4399  {
4400  const fawkes::tf::Pose* other = ((const fawkes::tf::Pose*) tolua_tousertype(tolua_S,2,0));
4401  bool exc_caught = false;
4402  try {
4403  {
4404  fawkes::tf::Pose* tolua_ret = (fawkes::tf::Pose*) Mtolua_new((fawkes::tf::Pose)(*other));
4405  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Pose");
4406  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
4407  }
4408  } catch (fawkes::Exception &e) {
4409  exc_caught = true;
4410  lua_pushstring(tolua_S, e.what_no_backtrace());
4411  }
4412  catch (std::exception &e) {
4413  exc_caught = true;
4414  lua_pushstring(tolua_S, e.what());
4415  }
4416  if (exc_caught) lua_error(tolua_S);
4417 
4418  }
4419  return 1;
4420 tolua_lerror:
4421  return tolua_fawkestf_fawkes_tf_Pose_new01_local(tolua_S);
4422 }
4423 #endif //#ifndef TOLUA_DISABLE
4424 
4425 /* method: getIdentity of class fawkes::tf::Pose */
4426 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Pose_getIdentity00
4427 static int tolua_fawkestf_fawkes_tf_Pose_getIdentity00(lua_State* tolua_S)
4428 {
4429 #ifndef TOLUA_RELEASE
4430  tolua_Error tolua_err;
4431  if (
4432  !tolua_isusertable(tolua_S,1,"fawkes::tf::Pose",0,&tolua_err) ||
4433  !tolua_isnoobj(tolua_S,2,&tolua_err)
4434  )
4435  goto tolua_lerror;
4436  else
4437 #endif
4438  {
4439  bool exc_caught = false;
4440  try {
4441  {
4442  const fawkes::tf::Pose& tolua_ret = (const fawkes::tf::Pose&) fawkes::tf::Pose::getIdentity();
4443  tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const fawkes::tf::Pose");
4444  }
4445  } catch (fawkes::Exception &e) {
4446  exc_caught = true;
4447  lua_pushstring(tolua_S, e.what_no_backtrace());
4448  }
4449  catch (std::exception &e) {
4450  exc_caught = true;
4451  lua_pushstring(tolua_S, e.what());
4452  }
4453  if (exc_caught) lua_error(tolua_S);
4454 
4455  }
4456  return 1;
4457 #ifndef TOLUA_RELEASE
4458  tolua_lerror:
4459  tolua_error(tolua_S,"#ferror in function 'getIdentity'.",&tolua_err);
4460  return 0;
4461 #endif
4462 }
4463 #endif //#ifndef TOLUA_DISABLE
4464 
4465 /* get function: stamp of class fawkes::tf::StampedTransform */
4466 #ifndef TOLUA_DISABLE_tolua_get_fawkes__tf__StampedTransform_stamp
4467 static int tolua_get_fawkes__tf__StampedTransform_stamp(lua_State* tolua_S)
4468 {
4469  fawkes::tf::StampedTransform* self = (fawkes::tf::StampedTransform*) tolua_tousertype(tolua_S,1,0);
4470 #ifndef TOLUA_RELEASE
4471  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'stamp'",NULL);
4472 #endif
4473  tolua_pushusertype(tolua_S,(void*)&self->stamp,"fawkes::Time");
4474  return 1;
4475 }
4476 #endif //#ifndef TOLUA_DISABLE
4477 
4478 /* set function: stamp of class fawkes::tf::StampedTransform */
4479 #ifndef TOLUA_DISABLE_tolua_set_fawkes__tf__StampedTransform_stamp
4480 static int tolua_set_fawkes__tf__StampedTransform_stamp(lua_State* tolua_S)
4481 {
4482  fawkes::tf::StampedTransform* self = (fawkes::tf::StampedTransform*) tolua_tousertype(tolua_S,1,0);
4483 #ifndef TOLUA_RELEASE
4484  tolua_Error tolua_err;
4485  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'stamp'",NULL);
4486  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"fawkes::Time",0,&tolua_err)))
4487  tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
4488 #endif
4489  self->stamp = *((fawkes::Time*) tolua_tousertype(tolua_S,2,0))
4490 ;
4491  return 0;
4492 }
4493 #endif //#ifndef TOLUA_DISABLE
4494 
4495 /* get function: frame_id of class fawkes::tf::StampedTransform */
4496 #ifndef TOLUA_DISABLE_tolua_get_fawkes__tf__StampedTransform_frame_id
4497 static int tolua_get_fawkes__tf__StampedTransform_frame_id(lua_State* tolua_S)
4498 {
4499  fawkes::tf::StampedTransform* self = (fawkes::tf::StampedTransform*) tolua_tousertype(tolua_S,1,0);
4500 #ifndef TOLUA_RELEASE
4501  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'frame_id'",NULL);
4502 #endif
4503  tolua_pushcppstring(tolua_S,(const char*)self->frame_id);
4504  return 1;
4505 }
4506 #endif //#ifndef TOLUA_DISABLE
4507 
4508 /* set function: frame_id of class fawkes::tf::StampedTransform */
4509 #ifndef TOLUA_DISABLE_tolua_set_fawkes__tf__StampedTransform_frame_id
4510 static int tolua_set_fawkes__tf__StampedTransform_frame_id(lua_State* tolua_S)
4511 {
4512  fawkes::tf::StampedTransform* self = (fawkes::tf::StampedTransform*) tolua_tousertype(tolua_S,1,0);
4513 #ifndef TOLUA_RELEASE
4514  tolua_Error tolua_err;
4515  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'frame_id'",NULL);
4516  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
4517  tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
4518 #endif
4519  self->frame_id = ((std::string) tolua_tocppstring(tolua_S,2,0))
4520 ;
4521  return 0;
4522 }
4523 #endif //#ifndef TOLUA_DISABLE
4524 
4525 /* get function: child_frame_id of class fawkes::tf::StampedTransform */
4526 #ifndef TOLUA_DISABLE_tolua_get_fawkes__tf__StampedTransform_child_frame_id
4527 static int tolua_get_fawkes__tf__StampedTransform_child_frame_id(lua_State* tolua_S)
4528 {
4529  fawkes::tf::StampedTransform* self = (fawkes::tf::StampedTransform*) tolua_tousertype(tolua_S,1,0);
4530 #ifndef TOLUA_RELEASE
4531  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'child_frame_id'",NULL);
4532 #endif
4533  tolua_pushcppstring(tolua_S,(const char*)self->child_frame_id);
4534  return 1;
4535 }
4536 #endif //#ifndef TOLUA_DISABLE
4537 
4538 /* set function: child_frame_id of class fawkes::tf::StampedTransform */
4539 #ifndef TOLUA_DISABLE_tolua_set_fawkes__tf__StampedTransform_child_frame_id
4540 static int tolua_set_fawkes__tf__StampedTransform_child_frame_id(lua_State* tolua_S)
4541 {
4542  fawkes::tf::StampedTransform* self = (fawkes::tf::StampedTransform*) tolua_tousertype(tolua_S,1,0);
4543 #ifndef TOLUA_RELEASE
4544  tolua_Error tolua_err;
4545  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'child_frame_id'",NULL);
4546  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
4547  tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
4548 #endif
4549  self->child_frame_id = ((std::string) tolua_tocppstring(tolua_S,2,0))
4550 ;
4551  return 0;
4552 }
4553 #endif //#ifndef TOLUA_DISABLE
4554 
4555 /* method: new of class fawkes::tf::StampedTransform */
4556 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedTransform_new00
4557 static int tolua_fawkestf_fawkes_tf_StampedTransform_new00(lua_State* tolua_S)
4558 {
4559 #ifndef TOLUA_RELEASE
4560  tolua_Error tolua_err;
4561  if (
4562  !tolua_isusertable(tolua_S,1,"fawkes::tf::StampedTransform",0,&tolua_err) ||
4563  !tolua_isnoobj(tolua_S,2,&tolua_err)
4564  )
4565  goto tolua_lerror;
4566  else
4567 #endif
4568  {
4569  bool exc_caught = false;
4570  try {
4571  {
4573  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::StampedTransform");
4574  }
4575  } catch (fawkes::Exception &e) {
4576  exc_caught = true;
4577  lua_pushstring(tolua_S, e.what_no_backtrace());
4578  }
4579  catch (std::exception &e) {
4580  exc_caught = true;
4581  lua_pushstring(tolua_S, e.what());
4582  }
4583  if (exc_caught) lua_error(tolua_S);
4584 
4585  }
4586  return 1;
4587 #ifndef TOLUA_RELEASE
4588  tolua_lerror:
4589  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
4590  return 0;
4591 #endif
4592 }
4593 #endif //#ifndef TOLUA_DISABLE
4594 
4595 /* method: new_local of class fawkes::tf::StampedTransform */
4596 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedTransform_new00_local
4597 static int tolua_fawkestf_fawkes_tf_StampedTransform_new00_local(lua_State* tolua_S)
4598 {
4599 #ifndef TOLUA_RELEASE
4600  tolua_Error tolua_err;
4601  if (
4602  !tolua_isusertable(tolua_S,1,"fawkes::tf::StampedTransform",0,&tolua_err) ||
4603  !tolua_isnoobj(tolua_S,2,&tolua_err)
4604  )
4605  goto tolua_lerror;
4606  else
4607 #endif
4608  {
4609  bool exc_caught = false;
4610  try {
4611  {
4613  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::StampedTransform");
4614  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
4615  }
4616  } catch (fawkes::Exception &e) {
4617  exc_caught = true;
4618  lua_pushstring(tolua_S, e.what_no_backtrace());
4619  }
4620  catch (std::exception &e) {
4621  exc_caught = true;
4622  lua_pushstring(tolua_S, e.what());
4623  }
4624  if (exc_caught) lua_error(tolua_S);
4625 
4626  }
4627  return 1;
4628 #ifndef TOLUA_RELEASE
4629  tolua_lerror:
4630  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
4631  return 0;
4632 #endif
4633 }
4634 #endif //#ifndef TOLUA_DISABLE
4635 
4636 /* method: new of class fawkes::tf::StampedTransform */
4637 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedTransform_new01
4638 static int tolua_fawkestf_fawkes_tf_StampedTransform_new01(lua_State* tolua_S)
4639 {
4640  tolua_Error tolua_err;
4641  if (
4642  !tolua_isusertable(tolua_S,1,"fawkes::tf::StampedTransform",0,&tolua_err) ||
4643  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Transform",0,&tolua_err)) ||
4644  (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::Time",0,&tolua_err)) ||
4645  !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
4646  !tolua_iscppstring(tolua_S,5,0,&tolua_err) ||
4647  !tolua_isnoobj(tolua_S,6,&tolua_err)
4648  )
4649  goto tolua_lerror;
4650  else
4651  {
4652  const fawkes::tf::Transform* input = ((const fawkes::tf::Transform*) tolua_tousertype(tolua_S,2,0));
4653  const fawkes::Time* timestamp = ((const fawkes::Time*) tolua_tousertype(tolua_S,3,0));
4654  const std::string frame_id = ((const std::string) tolua_tocppstring(tolua_S,4,0));
4655  const std::string child_frame_id = ((const std::string) tolua_tocppstring(tolua_S,5,0));
4656  bool exc_caught = false;
4657  try {
4658  {
4659  fawkes::tf::StampedTransform* tolua_ret = (fawkes::tf::StampedTransform*) Mtolua_new((fawkes::tf::StampedTransform)(*input,*timestamp,frame_id,child_frame_id));
4660  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::StampedTransform");
4661  tolua_pushcppstring(tolua_S,(const char*)frame_id);
4662  tolua_pushcppstring(tolua_S,(const char*)child_frame_id);
4663  }
4664  } catch (fawkes::Exception &e) {
4665  exc_caught = true;
4666  lua_pushstring(tolua_S, e.what_no_backtrace());
4667  }
4668  catch (std::exception &e) {
4669  exc_caught = true;
4670  lua_pushstring(tolua_S, e.what());
4671  }
4672  if (exc_caught) lua_error(tolua_S);
4673 
4674  }
4675  return 3;
4676 tolua_lerror:
4677  return tolua_fawkestf_fawkes_tf_StampedTransform_new00(tolua_S);
4678 }
4679 #endif //#ifndef TOLUA_DISABLE
4680 
4681 /* method: new_local of class fawkes::tf::StampedTransform */
4682 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedTransform_new01_local
4683 static int tolua_fawkestf_fawkes_tf_StampedTransform_new01_local(lua_State* tolua_S)
4684 {
4685  tolua_Error tolua_err;
4686  if (
4687  !tolua_isusertable(tolua_S,1,"fawkes::tf::StampedTransform",0,&tolua_err) ||
4688  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Transform",0,&tolua_err)) ||
4689  (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::Time",0,&tolua_err)) ||
4690  !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
4691  !tolua_iscppstring(tolua_S,5,0,&tolua_err) ||
4692  !tolua_isnoobj(tolua_S,6,&tolua_err)
4693  )
4694  goto tolua_lerror;
4695  else
4696  {
4697  const fawkes::tf::Transform* input = ((const fawkes::tf::Transform*) tolua_tousertype(tolua_S,2,0));
4698  const fawkes::Time* timestamp = ((const fawkes::Time*) tolua_tousertype(tolua_S,3,0));
4699  const std::string frame_id = ((const std::string) tolua_tocppstring(tolua_S,4,0));
4700  const std::string child_frame_id = ((const std::string) tolua_tocppstring(tolua_S,5,0));
4701  bool exc_caught = false;
4702  try {
4703  {
4704  fawkes::tf::StampedTransform* tolua_ret = (fawkes::tf::StampedTransform*) Mtolua_new((fawkes::tf::StampedTransform)(*input,*timestamp,frame_id,child_frame_id));
4705  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::StampedTransform");
4706  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
4707  tolua_pushcppstring(tolua_S,(const char*)frame_id);
4708  tolua_pushcppstring(tolua_S,(const char*)child_frame_id);
4709  }
4710  } catch (fawkes::Exception &e) {
4711  exc_caught = true;
4712  lua_pushstring(tolua_S, e.what_no_backtrace());
4713  }
4714  catch (std::exception &e) {
4715  exc_caught = true;
4716  lua_pushstring(tolua_S, e.what());
4717  }
4718  if (exc_caught) lua_error(tolua_S);
4719 
4720  }
4721  return 3;
4722 tolua_lerror:
4723  return tolua_fawkestf_fawkes_tf_StampedTransform_new00_local(tolua_S);
4724 }
4725 #endif //#ifndef TOLUA_DISABLE
4726 
4727 /* method: set_data of class fawkes::tf::StampedTransform */
4728 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedTransform_set_data00
4729 static int tolua_fawkestf_fawkes_tf_StampedTransform_set_data00(lua_State* tolua_S)
4730 {
4731 #ifndef TOLUA_RELEASE
4732  tolua_Error tolua_err;
4733  if (
4734  !tolua_isusertype(tolua_S,1,"fawkes::tf::StampedTransform",0,&tolua_err) ||
4735  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Transform",0,&tolua_err)) ||
4736  !tolua_isnoobj(tolua_S,3,&tolua_err)
4737  )
4738  goto tolua_lerror;
4739  else
4740 #endif
4741  {
4742  fawkes::tf::StampedTransform* self = (fawkes::tf::StampedTransform*) tolua_tousertype(tolua_S,1,0);
4743  const fawkes::tf::Transform* input = ((const fawkes::tf::Transform*) tolua_tousertype(tolua_S,2,0));
4744 #ifndef TOLUA_RELEASE
4745  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_data'", NULL);
4746 #endif
4747  bool exc_caught = false;
4748  try {
4749  {
4750  self->set_data(*input);
4751  }
4752  } catch (fawkes::Exception &e) {
4753  exc_caught = true;
4754  lua_pushstring(tolua_S, e.what_no_backtrace());
4755  }
4756  catch (std::exception &e) {
4757  exc_caught = true;
4758  lua_pushstring(tolua_S, e.what());
4759  }
4760  if (exc_caught) lua_error(tolua_S);
4761 
4762  }
4763  return 0;
4764 #ifndef TOLUA_RELEASE
4765  tolua_lerror:
4766  tolua_error(tolua_S,"#ferror in function 'set_data'.",&tolua_err);
4767  return 0;
4768 #endif
4769 }
4770 #endif //#ifndef TOLUA_DISABLE
4771 
4772 /* get function: stamp of class fawkes::tf::Stamped<fawkes::tf::Quaternion> */
4773 #ifndef TOLUA_DISABLE_tolua_get_fawkes__tf__Stamped_fawkes__tf__Quaternion__stamp
4774 static int tolua_get_fawkes__tf__Stamped_fawkes__tf__Quaternion__stamp(lua_State* tolua_S)
4775 {
4777 #ifndef TOLUA_RELEASE
4778  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'stamp'",NULL);
4779 #endif
4780  tolua_pushusertype(tolua_S,(void*)&self->stamp,"fawkes::Time");
4781  return 1;
4782 }
4783 #endif //#ifndef TOLUA_DISABLE
4784 
4785 /* set function: stamp of class fawkes::tf::Stamped<fawkes::tf::Quaternion> */
4786 #ifndef TOLUA_DISABLE_tolua_set_fawkes__tf__Stamped_fawkes__tf__Quaternion__stamp
4787 static int tolua_set_fawkes__tf__Stamped_fawkes__tf__Quaternion__stamp(lua_State* tolua_S)
4788 {
4790 #ifndef TOLUA_RELEASE
4791  tolua_Error tolua_err;
4792  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'stamp'",NULL);
4793  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"fawkes::Time",0,&tolua_err)))
4794  tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
4795 #endif
4796  self->stamp = *((fawkes::Time*) tolua_tousertype(tolua_S,2,0))
4797 ;
4798  return 0;
4799 }
4800 #endif //#ifndef TOLUA_DISABLE
4801 
4802 /* get function: frame_id of class fawkes::tf::Stamped<fawkes::tf::Quaternion> */
4803 #ifndef TOLUA_DISABLE_tolua_get_fawkes__tf__Stamped_fawkes__tf__Quaternion__frame_id
4804 static int tolua_get_fawkes__tf__Stamped_fawkes__tf__Quaternion__frame_id(lua_State* tolua_S)
4805 {
4807 #ifndef TOLUA_RELEASE
4808  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'frame_id'",NULL);
4809 #endif
4810  tolua_pushcppstring(tolua_S,(const char*)self->frame_id);
4811  return 1;
4812 }
4813 #endif //#ifndef TOLUA_DISABLE
4814 
4815 /* set function: frame_id of class fawkes::tf::Stamped<fawkes::tf::Quaternion> */
4816 #ifndef TOLUA_DISABLE_tolua_set_fawkes__tf__Stamped_fawkes__tf__Quaternion__frame_id
4817 static int tolua_set_fawkes__tf__Stamped_fawkes__tf__Quaternion__frame_id(lua_State* tolua_S)
4818 {
4820 #ifndef TOLUA_RELEASE
4821  tolua_Error tolua_err;
4822  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'frame_id'",NULL);
4823  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
4824  tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
4825 #endif
4826  self->frame_id = ((std::string) tolua_tocppstring(tolua_S,2,0))
4827 ;
4828  return 0;
4829 }
4830 #endif //#ifndef TOLUA_DISABLE
4831 
4832 /* method: new of class fawkes::tf::Stamped<fawkes::tf::Quaternion> */
4833 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__new00
4834 static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__new00(lua_State* tolua_S)
4835 {
4836 #ifndef TOLUA_RELEASE
4837  tolua_Error tolua_err;
4838  if (
4839  !tolua_isusertable(tolua_S,1,"fawkes::tf::Stamped<fawkes::tf::Quaternion>",0,&tolua_err) ||
4840  !tolua_isnoobj(tolua_S,2,&tolua_err)
4841  )
4842  goto tolua_lerror;
4843  else
4844 #endif
4845  {
4846  bool exc_caught = false;
4847  try {
4848  {
4850  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Stamped<fawkes::tf::Quaternion>");
4851  }
4852  } catch (fawkes::Exception &e) {
4853  exc_caught = true;
4854  lua_pushstring(tolua_S, e.what_no_backtrace());
4855  }
4856  catch (std::exception &e) {
4857  exc_caught = true;
4858  lua_pushstring(tolua_S, e.what());
4859  }
4860  if (exc_caught) lua_error(tolua_S);
4861 
4862  }
4863  return 1;
4864 #ifndef TOLUA_RELEASE
4865  tolua_lerror:
4866  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
4867  return 0;
4868 #endif
4869 }
4870 #endif //#ifndef TOLUA_DISABLE
4871 
4872 /* method: new_local of class fawkes::tf::Stamped<fawkes::tf::Quaternion> */
4873 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__new00_local
4874 static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__new00_local(lua_State* tolua_S)
4875 {
4876 #ifndef TOLUA_RELEASE
4877  tolua_Error tolua_err;
4878  if (
4879  !tolua_isusertable(tolua_S,1,"fawkes::tf::Stamped<fawkes::tf::Quaternion>",0,&tolua_err) ||
4880  !tolua_isnoobj(tolua_S,2,&tolua_err)
4881  )
4882  goto tolua_lerror;
4883  else
4884 #endif
4885  {
4886  bool exc_caught = false;
4887  try {
4888  {
4890  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Stamped<fawkes::tf::Quaternion>");
4891  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
4892  }
4893  } catch (fawkes::Exception &e) {
4894  exc_caught = true;
4895  lua_pushstring(tolua_S, e.what_no_backtrace());
4896  }
4897  catch (std::exception &e) {
4898  exc_caught = true;
4899  lua_pushstring(tolua_S, e.what());
4900  }
4901  if (exc_caught) lua_error(tolua_S);
4902 
4903  }
4904  return 1;
4905 #ifndef TOLUA_RELEASE
4906  tolua_lerror:
4907  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
4908  return 0;
4909 #endif
4910 }
4911 #endif //#ifndef TOLUA_DISABLE
4912 
4913 /* method: new of class fawkes::tf::Stamped<fawkes::tf::Quaternion> */
4914 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__new01
4915 static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__new01(lua_State* tolua_S)
4916 {
4917  tolua_Error tolua_err;
4918  if (
4919  !tolua_isusertable(tolua_S,1,"fawkes::tf::Stamped<fawkes::tf::Quaternion>",0,&tolua_err) ||
4920  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Quaternion",0,&tolua_err)) ||
4921  (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::Time",0,&tolua_err)) ||
4922  !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
4923  !tolua_isnoobj(tolua_S,5,&tolua_err)
4924  )
4925  goto tolua_lerror;
4926  else
4927  {
4928  const fawkes::tf::Quaternion* input = ((const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,2,0));
4929  const fawkes::Time* timestamp = ((const fawkes::Time*) tolua_tousertype(tolua_S,3,0));
4930  const std::string frame_id = ((const std::string) tolua_tocppstring(tolua_S,4,0));
4931  bool exc_caught = false;
4932  try {
4933  {
4935  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Stamped<fawkes::tf::Quaternion>");
4936  tolua_pushcppstring(tolua_S,(const char*)frame_id);
4937  }
4938  } catch (fawkes::Exception &e) {
4939  exc_caught = true;
4940  lua_pushstring(tolua_S, e.what_no_backtrace());
4941  }
4942  catch (std::exception &e) {
4943  exc_caught = true;
4944  lua_pushstring(tolua_S, e.what());
4945  }
4946  if (exc_caught) lua_error(tolua_S);
4947 
4948  }
4949  return 2;
4950 tolua_lerror:
4951  return tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__new00(tolua_S);
4952 }
4953 #endif //#ifndef TOLUA_DISABLE
4954 
4955 /* method: new_local of class fawkes::tf::Stamped<fawkes::tf::Quaternion> */
4956 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__new01_local
4957 static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__new01_local(lua_State* tolua_S)
4958 {
4959  tolua_Error tolua_err;
4960  if (
4961  !tolua_isusertable(tolua_S,1,"fawkes::tf::Stamped<fawkes::tf::Quaternion>",0,&tolua_err) ||
4962  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Quaternion",0,&tolua_err)) ||
4963  (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::Time",0,&tolua_err)) ||
4964  !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
4965  !tolua_isnoobj(tolua_S,5,&tolua_err)
4966  )
4967  goto tolua_lerror;
4968  else
4969  {
4970  const fawkes::tf::Quaternion* input = ((const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,2,0));
4971  const fawkes::Time* timestamp = ((const fawkes::Time*) tolua_tousertype(tolua_S,3,0));
4972  const std::string frame_id = ((const std::string) tolua_tocppstring(tolua_S,4,0));
4973  bool exc_caught = false;
4974  try {
4975  {
4977  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Stamped<fawkes::tf::Quaternion>");
4978  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
4979  tolua_pushcppstring(tolua_S,(const char*)frame_id);
4980  }
4981  } catch (fawkes::Exception &e) {
4982  exc_caught = true;
4983  lua_pushstring(tolua_S, e.what_no_backtrace());
4984  }
4985  catch (std::exception &e) {
4986  exc_caught = true;
4987  lua_pushstring(tolua_S, e.what());
4988  }
4989  if (exc_caught) lua_error(tolua_S);
4990 
4991  }
4992  return 2;
4993 tolua_lerror:
4994  return tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__new00_local(tolua_S);
4995 }
4996 #endif //#ifndef TOLUA_DISABLE
4997 
4998 /* method: set_data of class fawkes::tf::Stamped<fawkes::tf::Quaternion> */
4999 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__set_data00
5000 static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__set_data00(lua_State* tolua_S)
5001 {
5002 #ifndef TOLUA_RELEASE
5003  tolua_Error tolua_err;
5004  if (
5005  !tolua_isusertype(tolua_S,1,"fawkes::tf::Stamped<fawkes::tf::Quaternion>",0,&tolua_err) ||
5006  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Quaternion",0,&tolua_err)) ||
5007  !tolua_isnoobj(tolua_S,3,&tolua_err)
5008  )
5009  goto tolua_lerror;
5010  else
5011 #endif
5012  {
5014  const fawkes::tf::Quaternion* input = ((const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,2,0));
5015 #ifndef TOLUA_RELEASE
5016  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_data'", NULL);
5017 #endif
5018  bool exc_caught = false;
5019  try {
5020  {
5021  self->set_data(*input);
5022  }
5023  } catch (fawkes::Exception &e) {
5024  exc_caught = true;
5025  lua_pushstring(tolua_S, e.what_no_backtrace());
5026  }
5027  catch (std::exception &e) {
5028  exc_caught = true;
5029  lua_pushstring(tolua_S, e.what());
5030  }
5031  if (exc_caught) lua_error(tolua_S);
5032 
5033  }
5034  return 0;
5035 #ifndef TOLUA_RELEASE
5036  tolua_lerror:
5037  tolua_error(tolua_S,"#ferror in function 'set_data'.",&tolua_err);
5038  return 0;
5039 #endif
5040 }
5041 #endif //#ifndef TOLUA_DISABLE
5042 
5043 /* get function: stamp of class fawkes::tf::Stamped<fawkes::tf::Vector3> */
5044 #ifndef TOLUA_DISABLE_tolua_get_fawkes__tf__Stamped_fawkes__tf__Vector3__stamp
5045 static int tolua_get_fawkes__tf__Stamped_fawkes__tf__Vector3__stamp(lua_State* tolua_S)
5046 {
5048 #ifndef TOLUA_RELEASE
5049  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'stamp'",NULL);
5050 #endif
5051  tolua_pushusertype(tolua_S,(void*)&self->stamp,"fawkes::Time");
5052  return 1;
5053 }
5054 #endif //#ifndef TOLUA_DISABLE
5055 
5056 /* set function: stamp of class fawkes::tf::Stamped<fawkes::tf::Vector3> */
5057 #ifndef TOLUA_DISABLE_tolua_set_fawkes__tf__Stamped_fawkes__tf__Vector3__stamp
5058 static int tolua_set_fawkes__tf__Stamped_fawkes__tf__Vector3__stamp(lua_State* tolua_S)
5059 {
5061 #ifndef TOLUA_RELEASE
5062  tolua_Error tolua_err;
5063  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'stamp'",NULL);
5064  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"fawkes::Time",0,&tolua_err)))
5065  tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
5066 #endif
5067  self->stamp = *((fawkes::Time*) tolua_tousertype(tolua_S,2,0))
5068 ;
5069  return 0;
5070 }
5071 #endif //#ifndef TOLUA_DISABLE
5072 
5073 /* get function: frame_id of class fawkes::tf::Stamped<fawkes::tf::Vector3> */
5074 #ifndef TOLUA_DISABLE_tolua_get_fawkes__tf__Stamped_fawkes__tf__Vector3__frame_id
5075 static int tolua_get_fawkes__tf__Stamped_fawkes__tf__Vector3__frame_id(lua_State* tolua_S)
5076 {
5078 #ifndef TOLUA_RELEASE
5079  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'frame_id'",NULL);
5080 #endif
5081  tolua_pushcppstring(tolua_S,(const char*)self->frame_id);
5082  return 1;
5083 }
5084 #endif //#ifndef TOLUA_DISABLE
5085 
5086 /* set function: frame_id of class fawkes::tf::Stamped<fawkes::tf::Vector3> */
5087 #ifndef TOLUA_DISABLE_tolua_set_fawkes__tf__Stamped_fawkes__tf__Vector3__frame_id
5088 static int tolua_set_fawkes__tf__Stamped_fawkes__tf__Vector3__frame_id(lua_State* tolua_S)
5089 {
5091 #ifndef TOLUA_RELEASE
5092  tolua_Error tolua_err;
5093  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'frame_id'",NULL);
5094  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
5095  tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
5096 #endif
5097  self->frame_id = ((std::string) tolua_tocppstring(tolua_S,2,0))
5098 ;
5099  return 0;
5100 }
5101 #endif //#ifndef TOLUA_DISABLE
5102 
5103 /* method: new of class fawkes::tf::Stamped<fawkes::tf::Vector3> */
5104 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__new00
5105 static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__new00(lua_State* tolua_S)
5106 {
5107 #ifndef TOLUA_RELEASE
5108  tolua_Error tolua_err;
5109  if (
5110  !tolua_isusertable(tolua_S,1,"fawkes::tf::Stamped<fawkes::tf::Vector3>",0,&tolua_err) ||
5111  !tolua_isnoobj(tolua_S,2,&tolua_err)
5112  )
5113  goto tolua_lerror;
5114  else
5115 #endif
5116  {
5117  bool exc_caught = false;
5118  try {
5119  {
5121  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Stamped<fawkes::tf::Vector3>");
5122  }
5123  } catch (fawkes::Exception &e) {
5124  exc_caught = true;
5125  lua_pushstring(tolua_S, e.what_no_backtrace());
5126  }
5127  catch (std::exception &e) {
5128  exc_caught = true;
5129  lua_pushstring(tolua_S, e.what());
5130  }
5131  if (exc_caught) lua_error(tolua_S);
5132 
5133  }
5134  return 1;
5135 #ifndef TOLUA_RELEASE
5136  tolua_lerror:
5137  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
5138  return 0;
5139 #endif
5140 }
5141 #endif //#ifndef TOLUA_DISABLE
5142 
5143 /* method: new_local of class fawkes::tf::Stamped<fawkes::tf::Vector3> */
5144 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__new00_local
5145 static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__new00_local(lua_State* tolua_S)
5146 {
5147 #ifndef TOLUA_RELEASE
5148  tolua_Error tolua_err;
5149  if (
5150  !tolua_isusertable(tolua_S,1,"fawkes::tf::Stamped<fawkes::tf::Vector3>",0,&tolua_err) ||
5151  !tolua_isnoobj(tolua_S,2,&tolua_err)
5152  )
5153  goto tolua_lerror;
5154  else
5155 #endif
5156  {
5157  bool exc_caught = false;
5158  try {
5159  {
5161  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Stamped<fawkes::tf::Vector3>");
5162  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
5163  }
5164  } catch (fawkes::Exception &e) {
5165  exc_caught = true;
5166  lua_pushstring(tolua_S, e.what_no_backtrace());
5167  }
5168  catch (std::exception &e) {
5169  exc_caught = true;
5170  lua_pushstring(tolua_S, e.what());
5171  }
5172  if (exc_caught) lua_error(tolua_S);
5173 
5174  }
5175  return 1;
5176 #ifndef TOLUA_RELEASE
5177  tolua_lerror:
5178  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
5179  return 0;
5180 #endif
5181 }
5182 #endif //#ifndef TOLUA_DISABLE
5183 
5184 /* method: new of class fawkes::tf::Stamped<fawkes::tf::Vector3> */
5185 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__new01
5186 static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__new01(lua_State* tolua_S)
5187 {
5188  tolua_Error tolua_err;
5189  if (
5190  !tolua_isusertable(tolua_S,1,"fawkes::tf::Stamped<fawkes::tf::Vector3>",0,&tolua_err) ||
5191  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Vector3",0,&tolua_err)) ||
5192  (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::Time",0,&tolua_err)) ||
5193  !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
5194  !tolua_isnoobj(tolua_S,5,&tolua_err)
5195  )
5196  goto tolua_lerror;
5197  else
5198  {
5199  const fawkes::tf::Vector3* input = ((const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,2,0));
5200  const fawkes::Time* timestamp = ((const fawkes::Time*) tolua_tousertype(tolua_S,3,0));
5201  const std::string frame_id = ((const std::string) tolua_tocppstring(tolua_S,4,0));
5202  bool exc_caught = false;
5203  try {
5204  {
5206  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Stamped<fawkes::tf::Vector3>");
5207  tolua_pushcppstring(tolua_S,(const char*)frame_id);
5208  }
5209  } catch (fawkes::Exception &e) {
5210  exc_caught = true;
5211  lua_pushstring(tolua_S, e.what_no_backtrace());
5212  }
5213  catch (std::exception &e) {
5214  exc_caught = true;
5215  lua_pushstring(tolua_S, e.what());
5216  }
5217  if (exc_caught) lua_error(tolua_S);
5218 
5219  }
5220  return 2;
5221 tolua_lerror:
5222  return tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__new00(tolua_S);
5223 }
5224 #endif //#ifndef TOLUA_DISABLE
5225 
5226 /* method: new_local of class fawkes::tf::Stamped<fawkes::tf::Vector3> */
5227 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__new01_local
5228 static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__new01_local(lua_State* tolua_S)
5229 {
5230  tolua_Error tolua_err;
5231  if (
5232  !tolua_isusertable(tolua_S,1,"fawkes::tf::Stamped<fawkes::tf::Vector3>",0,&tolua_err) ||
5233  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Vector3",0,&tolua_err)) ||
5234  (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::Time",0,&tolua_err)) ||
5235  !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
5236  !tolua_isnoobj(tolua_S,5,&tolua_err)
5237  )
5238  goto tolua_lerror;
5239  else
5240  {
5241  const fawkes::tf::Vector3* input = ((const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,2,0));
5242  const fawkes::Time* timestamp = ((const fawkes::Time*) tolua_tousertype(tolua_S,3,0));
5243  const std::string frame_id = ((const std::string) tolua_tocppstring(tolua_S,4,0));
5244  bool exc_caught = false;
5245  try {
5246  {
5248  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Stamped<fawkes::tf::Vector3>");
5249  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
5250  tolua_pushcppstring(tolua_S,(const char*)frame_id);
5251  }
5252  } catch (fawkes::Exception &e) {
5253  exc_caught = true;
5254  lua_pushstring(tolua_S, e.what_no_backtrace());
5255  }
5256  catch (std::exception &e) {
5257  exc_caught = true;
5258  lua_pushstring(tolua_S, e.what());
5259  }
5260  if (exc_caught) lua_error(tolua_S);
5261 
5262  }
5263  return 2;
5264 tolua_lerror:
5265  return tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__new00_local(tolua_S);
5266 }
5267 #endif //#ifndef TOLUA_DISABLE
5268 
5269 /* method: set_data of class fawkes::tf::Stamped<fawkes::tf::Vector3> */
5270 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__set_data00
5271 static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__set_data00(lua_State* tolua_S)
5272 {
5273 #ifndef TOLUA_RELEASE
5274  tolua_Error tolua_err;
5275  if (
5276  !tolua_isusertype(tolua_S,1,"fawkes::tf::Stamped<fawkes::tf::Vector3>",0,&tolua_err) ||
5277  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Vector3",0,&tolua_err)) ||
5278  !tolua_isnoobj(tolua_S,3,&tolua_err)
5279  )
5280  goto tolua_lerror;
5281  else
5282 #endif
5283  {
5285  const fawkes::tf::Vector3* input = ((const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,2,0));
5286 #ifndef TOLUA_RELEASE
5287  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_data'", NULL);
5288 #endif
5289  bool exc_caught = false;
5290  try {
5291  {
5292  self->set_data(*input);
5293  }
5294  } catch (fawkes::Exception &e) {
5295  exc_caught = true;
5296  lua_pushstring(tolua_S, e.what_no_backtrace());
5297  }
5298  catch (std::exception &e) {
5299  exc_caught = true;
5300  lua_pushstring(tolua_S, e.what());
5301  }
5302  if (exc_caught) lua_error(tolua_S);
5303 
5304  }
5305  return 0;
5306 #ifndef TOLUA_RELEASE
5307  tolua_lerror:
5308  tolua_error(tolua_S,"#ferror in function 'set_data'.",&tolua_err);
5309  return 0;
5310 #endif
5311 }
5312 #endif //#ifndef TOLUA_DISABLE
5313 
5314 /* get function: stamp of class fawkes::tf::Stamped<fawkes::tf::Point> */
5315 #ifndef TOLUA_DISABLE_tolua_get_fawkes__tf__Stamped_fawkes__tf__Point__stamp
5316 static int tolua_get_fawkes__tf__Stamped_fawkes__tf__Point__stamp(lua_State* tolua_S)
5317 {
5318  fawkes::tf::Stamped<fawkes::tf::Point>* self = (fawkes::tf::Stamped<fawkes::tf::Point>*) tolua_tousertype(tolua_S,1,0);
5319 #ifndef TOLUA_RELEASE
5320  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'stamp'",NULL);
5321 #endif
5322  tolua_pushusertype(tolua_S,(void*)&self->stamp,"fawkes::Time");
5323  return 1;
5324 }
5325 #endif //#ifndef TOLUA_DISABLE
5326 
5327 /* set function: stamp of class fawkes::tf::Stamped<fawkes::tf::Point> */
5328 #ifndef TOLUA_DISABLE_tolua_set_fawkes__tf__Stamped_fawkes__tf__Point__stamp
5329 static int tolua_set_fawkes__tf__Stamped_fawkes__tf__Point__stamp(lua_State* tolua_S)
5330 {
5331  fawkes::tf::Stamped<fawkes::tf::Point>* self = (fawkes::tf::Stamped<fawkes::tf::Point>*) tolua_tousertype(tolua_S,1,0);
5332 #ifndef TOLUA_RELEASE
5333  tolua_Error tolua_err;
5334  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'stamp'",NULL);
5335  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"fawkes::Time",0,&tolua_err)))
5336  tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
5337 #endif
5338  self->stamp = *((fawkes::Time*) tolua_tousertype(tolua_S,2,0))
5339 ;
5340  return 0;
5341 }
5342 #endif //#ifndef TOLUA_DISABLE
5343 
5344 /* get function: frame_id of class fawkes::tf::Stamped<fawkes::tf::Point> */
5345 #ifndef TOLUA_DISABLE_tolua_get_fawkes__tf__Stamped_fawkes__tf__Point__frame_id
5346 static int tolua_get_fawkes__tf__Stamped_fawkes__tf__Point__frame_id(lua_State* tolua_S)
5347 {
5348  fawkes::tf::Stamped<fawkes::tf::Point>* self = (fawkes::tf::Stamped<fawkes::tf::Point>*) tolua_tousertype(tolua_S,1,0);
5349 #ifndef TOLUA_RELEASE
5350  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'frame_id'",NULL);
5351 #endif
5352  tolua_pushcppstring(tolua_S,(const char*)self->frame_id);
5353  return 1;
5354 }
5355 #endif //#ifndef TOLUA_DISABLE
5356 
5357 /* set function: frame_id of class fawkes::tf::Stamped<fawkes::tf::Point> */
5358 #ifndef TOLUA_DISABLE_tolua_set_fawkes__tf__Stamped_fawkes__tf__Point__frame_id
5359 static int tolua_set_fawkes__tf__Stamped_fawkes__tf__Point__frame_id(lua_State* tolua_S)
5360 {
5361  fawkes::tf::Stamped<fawkes::tf::Point>* self = (fawkes::tf::Stamped<fawkes::tf::Point>*) tolua_tousertype(tolua_S,1,0);
5362 #ifndef TOLUA_RELEASE
5363  tolua_Error tolua_err;
5364  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'frame_id'",NULL);
5365  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
5366  tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
5367 #endif
5368  self->frame_id = ((std::string) tolua_tocppstring(tolua_S,2,0))
5369 ;
5370  return 0;
5371 }
5372 #endif //#ifndef TOLUA_DISABLE
5373 
5374 /* method: new of class fawkes::tf::Stamped<fawkes::tf::Point> */
5375 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__new00
5376 static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__new00(lua_State* tolua_S)
5377 {
5378 #ifndef TOLUA_RELEASE
5379  tolua_Error tolua_err;
5380  if (
5381  !tolua_isusertable(tolua_S,1,"fawkes::tf::Stamped<fawkes::tf::Point>",0,&tolua_err) ||
5382  !tolua_isnoobj(tolua_S,2,&tolua_err)
5383  )
5384  goto tolua_lerror;
5385  else
5386 #endif
5387  {
5388  bool exc_caught = false;
5389  try {
5390  {
5392  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Stamped<fawkes::tf::Point>");
5393  }
5394  } catch (fawkes::Exception &e) {
5395  exc_caught = true;
5396  lua_pushstring(tolua_S, e.what_no_backtrace());
5397  }
5398  catch (std::exception &e) {
5399  exc_caught = true;
5400  lua_pushstring(tolua_S, e.what());
5401  }
5402  if (exc_caught) lua_error(tolua_S);
5403 
5404  }
5405  return 1;
5406 #ifndef TOLUA_RELEASE
5407  tolua_lerror:
5408  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
5409  return 0;
5410 #endif
5411 }
5412 #endif //#ifndef TOLUA_DISABLE
5413 
5414 /* method: new_local of class fawkes::tf::Stamped<fawkes::tf::Point> */
5415 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__new00_local
5416 static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__new00_local(lua_State* tolua_S)
5417 {
5418 #ifndef TOLUA_RELEASE
5419  tolua_Error tolua_err;
5420  if (
5421  !tolua_isusertable(tolua_S,1,"fawkes::tf::Stamped<fawkes::tf::Point>",0,&tolua_err) ||
5422  !tolua_isnoobj(tolua_S,2,&tolua_err)
5423  )
5424  goto tolua_lerror;
5425  else
5426 #endif
5427  {
5428  bool exc_caught = false;
5429  try {
5430  {
5432  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Stamped<fawkes::tf::Point>");
5433  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
5434  }
5435  } catch (fawkes::Exception &e) {
5436  exc_caught = true;
5437  lua_pushstring(tolua_S, e.what_no_backtrace());
5438  }
5439  catch (std::exception &e) {
5440  exc_caught = true;
5441  lua_pushstring(tolua_S, e.what());
5442  }
5443  if (exc_caught) lua_error(tolua_S);
5444 
5445  }
5446  return 1;
5447 #ifndef TOLUA_RELEASE
5448  tolua_lerror:
5449  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
5450  return 0;
5451 #endif
5452 }
5453 #endif //#ifndef TOLUA_DISABLE
5454 
5455 /* method: new of class fawkes::tf::Stamped<fawkes::tf::Point> */
5456 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__new01
5457 static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__new01(lua_State* tolua_S)
5458 {
5459  tolua_Error tolua_err;
5460  if (
5461  !tolua_isusertable(tolua_S,1,"fawkes::tf::Stamped<fawkes::tf::Point>",0,&tolua_err) ||
5462  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Point",0,&tolua_err)) ||
5463  (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::Time",0,&tolua_err)) ||
5464  !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
5465  !tolua_isnoobj(tolua_S,5,&tolua_err)
5466  )
5467  goto tolua_lerror;
5468  else
5469  {
5470  const fawkes::tf::Point* input = ((const fawkes::tf::Point*) tolua_tousertype(tolua_S,2,0));
5471  const fawkes::Time* timestamp = ((const fawkes::Time*) tolua_tousertype(tolua_S,3,0));
5472  const std::string frame_id = ((const std::string) tolua_tocppstring(tolua_S,4,0));
5473  bool exc_caught = false;
5474  try {
5475  {
5477  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Stamped<fawkes::tf::Point>");
5478  tolua_pushcppstring(tolua_S,(const char*)frame_id);
5479  }
5480  } catch (fawkes::Exception &e) {
5481  exc_caught = true;
5482  lua_pushstring(tolua_S, e.what_no_backtrace());
5483  }
5484  catch (std::exception &e) {
5485  exc_caught = true;
5486  lua_pushstring(tolua_S, e.what());
5487  }
5488  if (exc_caught) lua_error(tolua_S);
5489 
5490  }
5491  return 2;
5492 tolua_lerror:
5493  return tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__new00(tolua_S);
5494 }
5495 #endif //#ifndef TOLUA_DISABLE
5496 
5497 /* method: new_local of class fawkes::tf::Stamped<fawkes::tf::Point> */
5498 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__new01_local
5499 static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__new01_local(lua_State* tolua_S)
5500 {
5501  tolua_Error tolua_err;
5502  if (
5503  !tolua_isusertable(tolua_S,1,"fawkes::tf::Stamped<fawkes::tf::Point>",0,&tolua_err) ||
5504  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Point",0,&tolua_err)) ||
5505  (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::Time",0,&tolua_err)) ||
5506  !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
5507  !tolua_isnoobj(tolua_S,5,&tolua_err)
5508  )
5509  goto tolua_lerror;
5510  else
5511  {
5512  const fawkes::tf::Point* input = ((const fawkes::tf::Point*) tolua_tousertype(tolua_S,2,0));
5513  const fawkes::Time* timestamp = ((const fawkes::Time*) tolua_tousertype(tolua_S,3,0));
5514  const std::string frame_id = ((const std::string) tolua_tocppstring(tolua_S,4,0));
5515  bool exc_caught = false;
5516  try {
5517  {
5519  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Stamped<fawkes::tf::Point>");
5520  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
5521  tolua_pushcppstring(tolua_S,(const char*)frame_id);
5522  }
5523  } catch (fawkes::Exception &e) {
5524  exc_caught = true;
5525  lua_pushstring(tolua_S, e.what_no_backtrace());
5526  }
5527  catch (std::exception &e) {
5528  exc_caught = true;
5529  lua_pushstring(tolua_S, e.what());
5530  }
5531  if (exc_caught) lua_error(tolua_S);
5532 
5533  }
5534  return 2;
5535 tolua_lerror:
5536  return tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__new00_local(tolua_S);
5537 }
5538 #endif //#ifndef TOLUA_DISABLE
5539 
5540 /* method: set_data of class fawkes::tf::Stamped<fawkes::tf::Point> */
5541 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__set_data00
5542 static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__set_data00(lua_State* tolua_S)
5543 {
5544 #ifndef TOLUA_RELEASE
5545  tolua_Error tolua_err;
5546  if (
5547  !tolua_isusertype(tolua_S,1,"fawkes::tf::Stamped<fawkes::tf::Point>",0,&tolua_err) ||
5548  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Point",0,&tolua_err)) ||
5549  !tolua_isnoobj(tolua_S,3,&tolua_err)
5550  )
5551  goto tolua_lerror;
5552  else
5553 #endif
5554  {
5555  fawkes::tf::Stamped<fawkes::tf::Point>* self = (fawkes::tf::Stamped<fawkes::tf::Point>*) tolua_tousertype(tolua_S,1,0);
5556  const fawkes::tf::Point* input = ((const fawkes::tf::Point*) tolua_tousertype(tolua_S,2,0));
5557 #ifndef TOLUA_RELEASE
5558  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_data'", NULL);
5559 #endif
5560  bool exc_caught = false;
5561  try {
5562  {
5563  self->set_data(*input);
5564  }
5565  } catch (fawkes::Exception &e) {
5566  exc_caught = true;
5567  lua_pushstring(tolua_S, e.what_no_backtrace());
5568  }
5569  catch (std::exception &e) {
5570  exc_caught = true;
5571  lua_pushstring(tolua_S, e.what());
5572  }
5573  if (exc_caught) lua_error(tolua_S);
5574 
5575  }
5576  return 0;
5577 #ifndef TOLUA_RELEASE
5578  tolua_lerror:
5579  tolua_error(tolua_S,"#ferror in function 'set_data'.",&tolua_err);
5580  return 0;
5581 #endif
5582 }
5583 #endif //#ifndef TOLUA_DISABLE
5584 
5585 /* get function: stamp of class fawkes::tf::Stamped<fawkes::tf::Pose> */
5586 #ifndef TOLUA_DISABLE_tolua_get_fawkes__tf__Stamped_fawkes__tf__Pose__stamp
5587 static int tolua_get_fawkes__tf__Stamped_fawkes__tf__Pose__stamp(lua_State* tolua_S)
5588 {
5589  fawkes::tf::Stamped<fawkes::tf::Pose>* self = (fawkes::tf::Stamped<fawkes::tf::Pose>*) tolua_tousertype(tolua_S,1,0);
5590 #ifndef TOLUA_RELEASE
5591  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'stamp'",NULL);
5592 #endif
5593  tolua_pushusertype(tolua_S,(void*)&self->stamp,"fawkes::Time");
5594  return 1;
5595 }
5596 #endif //#ifndef TOLUA_DISABLE
5597 
5598 /* set function: stamp of class fawkes::tf::Stamped<fawkes::tf::Pose> */
5599 #ifndef TOLUA_DISABLE_tolua_set_fawkes__tf__Stamped_fawkes__tf__Pose__stamp
5600 static int tolua_set_fawkes__tf__Stamped_fawkes__tf__Pose__stamp(lua_State* tolua_S)
5601 {
5602  fawkes::tf::Stamped<fawkes::tf::Pose>* self = (fawkes::tf::Stamped<fawkes::tf::Pose>*) tolua_tousertype(tolua_S,1,0);
5603 #ifndef TOLUA_RELEASE
5604  tolua_Error tolua_err;
5605  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'stamp'",NULL);
5606  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"fawkes::Time",0,&tolua_err)))
5607  tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
5608 #endif
5609  self->stamp = *((fawkes::Time*) tolua_tousertype(tolua_S,2,0))
5610 ;
5611  return 0;
5612 }
5613 #endif //#ifndef TOLUA_DISABLE
5614 
5615 /* get function: frame_id of class fawkes::tf::Stamped<fawkes::tf::Pose> */
5616 #ifndef TOLUA_DISABLE_tolua_get_fawkes__tf__Stamped_fawkes__tf__Pose__frame_id
5617 static int tolua_get_fawkes__tf__Stamped_fawkes__tf__Pose__frame_id(lua_State* tolua_S)
5618 {
5619  fawkes::tf::Stamped<fawkes::tf::Pose>* self = (fawkes::tf::Stamped<fawkes::tf::Pose>*) tolua_tousertype(tolua_S,1,0);
5620 #ifndef TOLUA_RELEASE
5621  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'frame_id'",NULL);
5622 #endif
5623  tolua_pushcppstring(tolua_S,(const char*)self->frame_id);
5624  return 1;
5625 }
5626 #endif //#ifndef TOLUA_DISABLE
5627 
5628 /* set function: frame_id of class fawkes::tf::Stamped<fawkes::tf::Pose> */
5629 #ifndef TOLUA_DISABLE_tolua_set_fawkes__tf__Stamped_fawkes__tf__Pose__frame_id
5630 static int tolua_set_fawkes__tf__Stamped_fawkes__tf__Pose__frame_id(lua_State* tolua_S)
5631 {
5632  fawkes::tf::Stamped<fawkes::tf::Pose>* self = (fawkes::tf::Stamped<fawkes::tf::Pose>*) tolua_tousertype(tolua_S,1,0);
5633 #ifndef TOLUA_RELEASE
5634  tolua_Error tolua_err;
5635  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'frame_id'",NULL);
5636  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
5637  tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
5638 #endif
5639  self->frame_id = ((std::string) tolua_tocppstring(tolua_S,2,0))
5640 ;
5641  return 0;
5642 }
5643 #endif //#ifndef TOLUA_DISABLE
5644 
5645 /* method: new of class fawkes::tf::Stamped<fawkes::tf::Pose> */
5646 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__new00
5647 static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__new00(lua_State* tolua_S)
5648 {
5649 #ifndef TOLUA_RELEASE
5650  tolua_Error tolua_err;
5651  if (
5652  !tolua_isusertable(tolua_S,1,"fawkes::tf::Stamped<fawkes::tf::Pose>",0,&tolua_err) ||
5653  !tolua_isnoobj(tolua_S,2,&tolua_err)
5654  )
5655  goto tolua_lerror;
5656  else
5657 #endif
5658  {
5659  bool exc_caught = false;
5660  try {
5661  {
5663  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Stamped<fawkes::tf::Pose>");
5664  }
5665  } catch (fawkes::Exception &e) {
5666  exc_caught = true;
5667  lua_pushstring(tolua_S, e.what_no_backtrace());
5668  }
5669  catch (std::exception &e) {
5670  exc_caught = true;
5671  lua_pushstring(tolua_S, e.what());
5672  }
5673  if (exc_caught) lua_error(tolua_S);
5674 
5675  }
5676  return 1;
5677 #ifndef TOLUA_RELEASE
5678  tolua_lerror:
5679  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
5680  return 0;
5681 #endif
5682 }
5683 #endif //#ifndef TOLUA_DISABLE
5684 
5685 /* method: new_local of class fawkes::tf::Stamped<fawkes::tf::Pose> */
5686 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__new00_local
5687 static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__new00_local(lua_State* tolua_S)
5688 {
5689 #ifndef TOLUA_RELEASE
5690  tolua_Error tolua_err;
5691  if (
5692  !tolua_isusertable(tolua_S,1,"fawkes::tf::Stamped<fawkes::tf::Pose>",0,&tolua_err) ||
5693  !tolua_isnoobj(tolua_S,2,&tolua_err)
5694  )
5695  goto tolua_lerror;
5696  else
5697 #endif
5698  {
5699  bool exc_caught = false;
5700  try {
5701  {
5703  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Stamped<fawkes::tf::Pose>");
5704  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
5705  }
5706  } catch (fawkes::Exception &e) {
5707  exc_caught = true;
5708  lua_pushstring(tolua_S, e.what_no_backtrace());
5709  }
5710  catch (std::exception &e) {
5711  exc_caught = true;
5712  lua_pushstring(tolua_S, e.what());
5713  }
5714  if (exc_caught) lua_error(tolua_S);
5715 
5716  }
5717  return 1;
5718 #ifndef TOLUA_RELEASE
5719  tolua_lerror:
5720  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
5721  return 0;
5722 #endif
5723 }
5724 #endif //#ifndef TOLUA_DISABLE
5725 
5726 /* method: new of class fawkes::tf::Stamped<fawkes::tf::Pose> */
5727 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__new01
5728 static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__new01(lua_State* tolua_S)
5729 {
5730  tolua_Error tolua_err;
5731  if (
5732  !tolua_isusertable(tolua_S,1,"fawkes::tf::Stamped<fawkes::tf::Pose>",0,&tolua_err) ||
5733  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Pose",0,&tolua_err)) ||
5734  (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::Time",0,&tolua_err)) ||
5735  !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
5736  !tolua_isnoobj(tolua_S,5,&tolua_err)
5737  )
5738  goto tolua_lerror;
5739  else
5740  {
5741  const fawkes::tf::Pose* input = ((const fawkes::tf::Pose*) tolua_tousertype(tolua_S,2,0));
5742  const fawkes::Time* timestamp = ((const fawkes::Time*) tolua_tousertype(tolua_S,3,0));
5743  const std::string frame_id = ((const std::string) tolua_tocppstring(tolua_S,4,0));
5744  bool exc_caught = false;
5745  try {
5746  {
5748  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Stamped<fawkes::tf::Pose>");
5749  tolua_pushcppstring(tolua_S,(const char*)frame_id);
5750  }
5751  } catch (fawkes::Exception &e) {
5752  exc_caught = true;
5753  lua_pushstring(tolua_S, e.what_no_backtrace());
5754  }
5755  catch (std::exception &e) {
5756  exc_caught = true;
5757  lua_pushstring(tolua_S, e.what());
5758  }
5759  if (exc_caught) lua_error(tolua_S);
5760 
5761  }
5762  return 2;
5763 tolua_lerror:
5764  return tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__new00(tolua_S);
5765 }
5766 #endif //#ifndef TOLUA_DISABLE
5767 
5768 /* method: new_local of class fawkes::tf::Stamped<fawkes::tf::Pose> */
5769 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__new01_local
5770 static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__new01_local(lua_State* tolua_S)
5771 {
5772  tolua_Error tolua_err;
5773  if (
5774  !tolua_isusertable(tolua_S,1,"fawkes::tf::Stamped<fawkes::tf::Pose>",0,&tolua_err) ||
5775  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Pose",0,&tolua_err)) ||
5776  (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::Time",0,&tolua_err)) ||
5777  !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
5778  !tolua_isnoobj(tolua_S,5,&tolua_err)
5779  )
5780  goto tolua_lerror;
5781  else
5782  {
5783  const fawkes::tf::Pose* input = ((const fawkes::tf::Pose*) tolua_tousertype(tolua_S,2,0));
5784  const fawkes::Time* timestamp = ((const fawkes::Time*) tolua_tousertype(tolua_S,3,0));
5785  const std::string frame_id = ((const std::string) tolua_tocppstring(tolua_S,4,0));
5786  bool exc_caught = false;
5787  try {
5788  {
5790  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Stamped<fawkes::tf::Pose>");
5791  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
5792  tolua_pushcppstring(tolua_S,(const char*)frame_id);
5793  }
5794  } catch (fawkes::Exception &e) {
5795  exc_caught = true;
5796  lua_pushstring(tolua_S, e.what_no_backtrace());
5797  }
5798  catch (std::exception &e) {
5799  exc_caught = true;
5800  lua_pushstring(tolua_S, e.what());
5801  }
5802  if (exc_caught) lua_error(tolua_S);
5803 
5804  }
5805  return 2;
5806 tolua_lerror:
5807  return tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__new00_local(tolua_S);
5808 }
5809 #endif //#ifndef TOLUA_DISABLE
5810 
5811 /* method: set_data of class fawkes::tf::Stamped<fawkes::tf::Pose> */
5812 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__set_data00
5813 static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__set_data00(lua_State* tolua_S)
5814 {
5815 #ifndef TOLUA_RELEASE
5816  tolua_Error tolua_err;
5817  if (
5818  !tolua_isusertype(tolua_S,1,"fawkes::tf::Stamped<fawkes::tf::Pose>",0,&tolua_err) ||
5819  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Pose",0,&tolua_err)) ||
5820  !tolua_isnoobj(tolua_S,3,&tolua_err)
5821  )
5822  goto tolua_lerror;
5823  else
5824 #endif
5825  {
5826  fawkes::tf::Stamped<fawkes::tf::Pose>* self = (fawkes::tf::Stamped<fawkes::tf::Pose>*) tolua_tousertype(tolua_S,1,0);
5827  const fawkes::tf::Pose* input = ((const fawkes::tf::Pose*) tolua_tousertype(tolua_S,2,0));
5828 #ifndef TOLUA_RELEASE
5829  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_data'", NULL);
5830 #endif
5831  bool exc_caught = false;
5832  try {
5833  {
5834  self->set_data(*input);
5835  }
5836  } catch (fawkes::Exception &e) {
5837  exc_caught = true;
5838  lua_pushstring(tolua_S, e.what_no_backtrace());
5839  }
5840  catch (std::exception &e) {
5841  exc_caught = true;
5842  lua_pushstring(tolua_S, e.what());
5843  }
5844  if (exc_caught) lua_error(tolua_S);
5845 
5846  }
5847  return 0;
5848 #ifndef TOLUA_RELEASE
5849  tolua_lerror:
5850  tolua_error(tolua_S,"#ferror in function 'set_data'.",&tolua_err);
5851  return 0;
5852 #endif
5853 }
5854 #endif //#ifndef TOLUA_DISABLE
5855 
5856 /* method: new of class fawkes::tf::StampedQuaternion */
5857 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedQuaternion_new00
5858 static int tolua_fawkestf_fawkes_tf_StampedQuaternion_new00(lua_State* tolua_S)
5859 {
5860 #ifndef TOLUA_RELEASE
5861  tolua_Error tolua_err;
5862  if (
5863  !tolua_isusertable(tolua_S,1,"fawkes::tf::StampedQuaternion",0,&tolua_err) ||
5864  !tolua_isnoobj(tolua_S,2,&tolua_err)
5865  )
5866  goto tolua_lerror;
5867  else
5868 #endif
5869  {
5870  bool exc_caught = false;
5871  try {
5872  {
5873  fawkes::tf::StampedQuaternion* tolua_ret = (fawkes::tf::StampedQuaternion*) Mtolua_new((fawkes::tf::StampedQuaternion)());
5874  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::StampedQuaternion");
5875  }
5876  } catch (fawkes::Exception &e) {
5877  exc_caught = true;
5878  lua_pushstring(tolua_S, e.what_no_backtrace());
5879  }
5880  catch (std::exception &e) {
5881  exc_caught = true;
5882  lua_pushstring(tolua_S, e.what());
5883  }
5884  if (exc_caught) lua_error(tolua_S);
5885 
5886  }
5887  return 1;
5888 #ifndef TOLUA_RELEASE
5889  tolua_lerror:
5890  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
5891  return 0;
5892 #endif
5893 }
5894 #endif //#ifndef TOLUA_DISABLE
5895 
5896 /* method: new_local of class fawkes::tf::StampedQuaternion */
5897 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedQuaternion_new00_local
5898 static int tolua_fawkestf_fawkes_tf_StampedQuaternion_new00_local(lua_State* tolua_S)
5899 {
5900 #ifndef TOLUA_RELEASE
5901  tolua_Error tolua_err;
5902  if (
5903  !tolua_isusertable(tolua_S,1,"fawkes::tf::StampedQuaternion",0,&tolua_err) ||
5904  !tolua_isnoobj(tolua_S,2,&tolua_err)
5905  )
5906  goto tolua_lerror;
5907  else
5908 #endif
5909  {
5910  bool exc_caught = false;
5911  try {
5912  {
5913  fawkes::tf::StampedQuaternion* tolua_ret = (fawkes::tf::StampedQuaternion*) Mtolua_new((fawkes::tf::StampedQuaternion)());
5914  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::StampedQuaternion");
5915  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
5916  }
5917  } catch (fawkes::Exception &e) {
5918  exc_caught = true;
5919  lua_pushstring(tolua_S, e.what_no_backtrace());
5920  }
5921  catch (std::exception &e) {
5922  exc_caught = true;
5923  lua_pushstring(tolua_S, e.what());
5924  }
5925  if (exc_caught) lua_error(tolua_S);
5926 
5927  }
5928  return 1;
5929 #ifndef TOLUA_RELEASE
5930  tolua_lerror:
5931  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
5932  return 0;
5933 #endif
5934 }
5935 #endif //#ifndef TOLUA_DISABLE
5936 
5937 /* method: new of class fawkes::tf::StampedQuaternion */
5938 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedQuaternion_new01
5939 static int tolua_fawkestf_fawkes_tf_StampedQuaternion_new01(lua_State* tolua_S)
5940 {
5941  tolua_Error tolua_err;
5942  if (
5943  !tolua_isusertable(tolua_S,1,"fawkes::tf::StampedQuaternion",0,&tolua_err) ||
5944  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Quaternion",0,&tolua_err)) ||
5945  (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::Time",0,&tolua_err)) ||
5946  !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
5947  !tolua_isnoobj(tolua_S,5,&tolua_err)
5948  )
5949  goto tolua_lerror;
5950  else
5951  {
5952  const fawkes::tf::Quaternion* input = ((const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,2,0));
5953  const fawkes::Time* timestamp = ((const fawkes::Time*) tolua_tousertype(tolua_S,3,0));
5954  const std::string frame_id = ((const std::string) tolua_tocppstring(tolua_S,4,0));
5955  bool exc_caught = false;
5956  try {
5957  {
5958  fawkes::tf::StampedQuaternion* tolua_ret = (fawkes::tf::StampedQuaternion*) Mtolua_new((fawkes::tf::StampedQuaternion)(*input,*timestamp,frame_id));
5959  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::StampedQuaternion");
5960  tolua_pushcppstring(tolua_S,(const char*)frame_id);
5961  }
5962  } catch (fawkes::Exception &e) {
5963  exc_caught = true;
5964  lua_pushstring(tolua_S, e.what_no_backtrace());
5965  }
5966  catch (std::exception &e) {
5967  exc_caught = true;
5968  lua_pushstring(tolua_S, e.what());
5969  }
5970  if (exc_caught) lua_error(tolua_S);
5971 
5972  }
5973  return 2;
5974 tolua_lerror:
5975  return tolua_fawkestf_fawkes_tf_StampedQuaternion_new00(tolua_S);
5976 }
5977 #endif //#ifndef TOLUA_DISABLE
5978 
5979 /* method: new_local of class fawkes::tf::StampedQuaternion */
5980 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedQuaternion_new01_local
5981 static int tolua_fawkestf_fawkes_tf_StampedQuaternion_new01_local(lua_State* tolua_S)
5982 {
5983  tolua_Error tolua_err;
5984  if (
5985  !tolua_isusertable(tolua_S,1,"fawkes::tf::StampedQuaternion",0,&tolua_err) ||
5986  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Quaternion",0,&tolua_err)) ||
5987  (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::Time",0,&tolua_err)) ||
5988  !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
5989  !tolua_isnoobj(tolua_S,5,&tolua_err)
5990  )
5991  goto tolua_lerror;
5992  else
5993  {
5994  const fawkes::tf::Quaternion* input = ((const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,2,0));
5995  const fawkes::Time* timestamp = ((const fawkes::Time*) tolua_tousertype(tolua_S,3,0));
5996  const std::string frame_id = ((const std::string) tolua_tocppstring(tolua_S,4,0));
5997  bool exc_caught = false;
5998  try {
5999  {
6000  fawkes::tf::StampedQuaternion* tolua_ret = (fawkes::tf::StampedQuaternion*) Mtolua_new((fawkes::tf::StampedQuaternion)(*input,*timestamp,frame_id));
6001  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::StampedQuaternion");
6002  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
6003  tolua_pushcppstring(tolua_S,(const char*)frame_id);
6004  }
6005  } catch (fawkes::Exception &e) {
6006  exc_caught = true;
6007  lua_pushstring(tolua_S, e.what_no_backtrace());
6008  }
6009  catch (std::exception &e) {
6010  exc_caught = true;
6011  lua_pushstring(tolua_S, e.what());
6012  }
6013  if (exc_caught) lua_error(tolua_S);
6014 
6015  }
6016  return 2;
6017 tolua_lerror:
6018  return tolua_fawkestf_fawkes_tf_StampedQuaternion_new00_local(tolua_S);
6019 }
6020 #endif //#ifndef TOLUA_DISABLE
6021 
6022 /* method: new of class fawkes::tf::StampedVector3 */
6023 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedVector3_new00
6024 static int tolua_fawkestf_fawkes_tf_StampedVector3_new00(lua_State* tolua_S)
6025 {
6026 #ifndef TOLUA_RELEASE
6027  tolua_Error tolua_err;
6028  if (
6029  !tolua_isusertable(tolua_S,1,"fawkes::tf::StampedVector3",0,&tolua_err) ||
6030  !tolua_isnoobj(tolua_S,2,&tolua_err)
6031  )
6032  goto tolua_lerror;
6033  else
6034 #endif
6035  {
6036  bool exc_caught = false;
6037  try {
6038  {
6039  fawkes::tf::StampedVector3* tolua_ret = (fawkes::tf::StampedVector3*) Mtolua_new((fawkes::tf::StampedVector3)());
6040  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::StampedVector3");
6041  }
6042  } catch (fawkes::Exception &e) {
6043  exc_caught = true;
6044  lua_pushstring(tolua_S, e.what_no_backtrace());
6045  }
6046  catch (std::exception &e) {
6047  exc_caught = true;
6048  lua_pushstring(tolua_S, e.what());
6049  }
6050  if (exc_caught) lua_error(tolua_S);
6051 
6052  }
6053  return 1;
6054 #ifndef TOLUA_RELEASE
6055  tolua_lerror:
6056  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
6057  return 0;
6058 #endif
6059 }
6060 #endif //#ifndef TOLUA_DISABLE
6061 
6062 /* method: new_local of class fawkes::tf::StampedVector3 */
6063 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedVector3_new00_local
6064 static int tolua_fawkestf_fawkes_tf_StampedVector3_new00_local(lua_State* tolua_S)
6065 {
6066 #ifndef TOLUA_RELEASE
6067  tolua_Error tolua_err;
6068  if (
6069  !tolua_isusertable(tolua_S,1,"fawkes::tf::StampedVector3",0,&tolua_err) ||
6070  !tolua_isnoobj(tolua_S,2,&tolua_err)
6071  )
6072  goto tolua_lerror;
6073  else
6074 #endif
6075  {
6076  bool exc_caught = false;
6077  try {
6078  {
6079  fawkes::tf::StampedVector3* tolua_ret = (fawkes::tf::StampedVector3*) Mtolua_new((fawkes::tf::StampedVector3)());
6080  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::StampedVector3");
6081  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
6082  }
6083  } catch (fawkes::Exception &e) {
6084  exc_caught = true;
6085  lua_pushstring(tolua_S, e.what_no_backtrace());
6086  }
6087  catch (std::exception &e) {
6088  exc_caught = true;
6089  lua_pushstring(tolua_S, e.what());
6090  }
6091  if (exc_caught) lua_error(tolua_S);
6092 
6093  }
6094  return 1;
6095 #ifndef TOLUA_RELEASE
6096  tolua_lerror:
6097  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
6098  return 0;
6099 #endif
6100 }
6101 #endif //#ifndef TOLUA_DISABLE
6102 
6103 /* method: new of class fawkes::tf::StampedVector3 */
6104 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedVector3_new01
6105 static int tolua_fawkestf_fawkes_tf_StampedVector3_new01(lua_State* tolua_S)
6106 {
6107  tolua_Error tolua_err;
6108  if (
6109  !tolua_isusertable(tolua_S,1,"fawkes::tf::StampedVector3",0,&tolua_err) ||
6110  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Vector3",0,&tolua_err)) ||
6111  (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::Time",0,&tolua_err)) ||
6112  !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
6113  !tolua_isnoobj(tolua_S,5,&tolua_err)
6114  )
6115  goto tolua_lerror;
6116  else
6117  {
6118  const fawkes::tf::Vector3* input = ((const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,2,0));
6119  const fawkes::Time* timestamp = ((const fawkes::Time*) tolua_tousertype(tolua_S,3,0));
6120  const std::string frame_id = ((const std::string) tolua_tocppstring(tolua_S,4,0));
6121  bool exc_caught = false;
6122  try {
6123  {
6124  fawkes::tf::StampedVector3* tolua_ret = (fawkes::tf::StampedVector3*) Mtolua_new((fawkes::tf::StampedVector3)(*input,*timestamp,frame_id));
6125  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::StampedVector3");
6126  tolua_pushcppstring(tolua_S,(const char*)frame_id);
6127  }
6128  } catch (fawkes::Exception &e) {
6129  exc_caught = true;
6130  lua_pushstring(tolua_S, e.what_no_backtrace());
6131  }
6132  catch (std::exception &e) {
6133  exc_caught = true;
6134  lua_pushstring(tolua_S, e.what());
6135  }
6136  if (exc_caught) lua_error(tolua_S);
6137 
6138  }
6139  return 2;
6140 tolua_lerror:
6141  return tolua_fawkestf_fawkes_tf_StampedVector3_new00(tolua_S);
6142 }
6143 #endif //#ifndef TOLUA_DISABLE
6144 
6145 /* method: new_local of class fawkes::tf::StampedVector3 */
6146 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedVector3_new01_local
6147 static int tolua_fawkestf_fawkes_tf_StampedVector3_new01_local(lua_State* tolua_S)
6148 {
6149  tolua_Error tolua_err;
6150  if (
6151  !tolua_isusertable(tolua_S,1,"fawkes::tf::StampedVector3",0,&tolua_err) ||
6152  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Vector3",0,&tolua_err)) ||
6153  (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::Time",0,&tolua_err)) ||
6154  !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
6155  !tolua_isnoobj(tolua_S,5,&tolua_err)
6156  )
6157  goto tolua_lerror;
6158  else
6159  {
6160  const fawkes::tf::Vector3* input = ((const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,2,0));
6161  const fawkes::Time* timestamp = ((const fawkes::Time*) tolua_tousertype(tolua_S,3,0));
6162  const std::string frame_id = ((const std::string) tolua_tocppstring(tolua_S,4,0));
6163  bool exc_caught = false;
6164  try {
6165  {
6166  fawkes::tf::StampedVector3* tolua_ret = (fawkes::tf::StampedVector3*) Mtolua_new((fawkes::tf::StampedVector3)(*input,*timestamp,frame_id));
6167  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::StampedVector3");
6168  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
6169  tolua_pushcppstring(tolua_S,(const char*)frame_id);
6170  }
6171  } catch (fawkes::Exception &e) {
6172  exc_caught = true;
6173  lua_pushstring(tolua_S, e.what_no_backtrace());
6174  }
6175  catch (std::exception &e) {
6176  exc_caught = true;
6177  lua_pushstring(tolua_S, e.what());
6178  }
6179  if (exc_caught) lua_error(tolua_S);
6180 
6181  }
6182  return 2;
6183 tolua_lerror:
6184  return tolua_fawkestf_fawkes_tf_StampedVector3_new00_local(tolua_S);
6185 }
6186 #endif //#ifndef TOLUA_DISABLE
6187 
6188 /* method: new of class fawkes::tf::StampedPoint */
6189 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedPoint_new00
6190 static int tolua_fawkestf_fawkes_tf_StampedPoint_new00(lua_State* tolua_S)
6191 {
6192 #ifndef TOLUA_RELEASE
6193  tolua_Error tolua_err;
6194  if (
6195  !tolua_isusertable(tolua_S,1,"fawkes::tf::StampedPoint",0,&tolua_err) ||
6196  !tolua_isnoobj(tolua_S,2,&tolua_err)
6197  )
6198  goto tolua_lerror;
6199  else
6200 #endif
6201  {
6202  bool exc_caught = false;
6203  try {
6204  {
6205  fawkes::tf::StampedPoint* tolua_ret = (fawkes::tf::StampedPoint*) Mtolua_new((fawkes::tf::StampedPoint)());
6206  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::StampedPoint");
6207  }
6208  } catch (fawkes::Exception &e) {
6209  exc_caught = true;
6210  lua_pushstring(tolua_S, e.what_no_backtrace());
6211  }
6212  catch (std::exception &e) {
6213  exc_caught = true;
6214  lua_pushstring(tolua_S, e.what());
6215  }
6216  if (exc_caught) lua_error(tolua_S);
6217 
6218  }
6219  return 1;
6220 #ifndef TOLUA_RELEASE
6221  tolua_lerror:
6222  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
6223  return 0;
6224 #endif
6225 }
6226 #endif //#ifndef TOLUA_DISABLE
6227 
6228 /* method: new_local of class fawkes::tf::StampedPoint */
6229 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedPoint_new00_local
6230 static int tolua_fawkestf_fawkes_tf_StampedPoint_new00_local(lua_State* tolua_S)
6231 {
6232 #ifndef TOLUA_RELEASE
6233  tolua_Error tolua_err;
6234  if (
6235  !tolua_isusertable(tolua_S,1,"fawkes::tf::StampedPoint",0,&tolua_err) ||
6236  !tolua_isnoobj(tolua_S,2,&tolua_err)
6237  )
6238  goto tolua_lerror;
6239  else
6240 #endif
6241  {
6242  bool exc_caught = false;
6243  try {
6244  {
6245  fawkes::tf::StampedPoint* tolua_ret = (fawkes::tf::StampedPoint*) Mtolua_new((fawkes::tf::StampedPoint)());
6246  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::StampedPoint");
6247  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
6248  }
6249  } catch (fawkes::Exception &e) {
6250  exc_caught = true;
6251  lua_pushstring(tolua_S, e.what_no_backtrace());
6252  }
6253  catch (std::exception &e) {
6254  exc_caught = true;
6255  lua_pushstring(tolua_S, e.what());
6256  }
6257  if (exc_caught) lua_error(tolua_S);
6258 
6259  }
6260  return 1;
6261 #ifndef TOLUA_RELEASE
6262  tolua_lerror:
6263  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
6264  return 0;
6265 #endif
6266 }
6267 #endif //#ifndef TOLUA_DISABLE
6268 
6269 /* method: new of class fawkes::tf::StampedPoint */
6270 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedPoint_new01
6271 static int tolua_fawkestf_fawkes_tf_StampedPoint_new01(lua_State* tolua_S)
6272 {
6273  tolua_Error tolua_err;
6274  if (
6275  !tolua_isusertable(tolua_S,1,"fawkes::tf::StampedPoint",0,&tolua_err) ||
6276  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Point",0,&tolua_err)) ||
6277  (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::Time",0,&tolua_err)) ||
6278  !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
6279  !tolua_isnoobj(tolua_S,5,&tolua_err)
6280  )
6281  goto tolua_lerror;
6282  else
6283  {
6284  const fawkes::tf::Point* input = ((const fawkes::tf::Point*) tolua_tousertype(tolua_S,2,0));
6285  const fawkes::Time* timestamp = ((const fawkes::Time*) tolua_tousertype(tolua_S,3,0));
6286  const std::string frame_id = ((const std::string) tolua_tocppstring(tolua_S,4,0));
6287  bool exc_caught = false;
6288  try {
6289  {
6290  fawkes::tf::StampedPoint* tolua_ret = (fawkes::tf::StampedPoint*) Mtolua_new((fawkes::tf::StampedPoint)(*input,*timestamp,frame_id));
6291  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::StampedPoint");
6292  tolua_pushcppstring(tolua_S,(const char*)frame_id);
6293  }
6294  } catch (fawkes::Exception &e) {
6295  exc_caught = true;
6296  lua_pushstring(tolua_S, e.what_no_backtrace());
6297  }
6298  catch (std::exception &e) {
6299  exc_caught = true;
6300  lua_pushstring(tolua_S, e.what());
6301  }
6302  if (exc_caught) lua_error(tolua_S);
6303 
6304  }
6305  return 2;
6306 tolua_lerror:
6307  return tolua_fawkestf_fawkes_tf_StampedPoint_new00(tolua_S);
6308 }
6309 #endif //#ifndef TOLUA_DISABLE
6310 
6311 /* method: new_local of class fawkes::tf::StampedPoint */
6312 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedPoint_new01_local
6313 static int tolua_fawkestf_fawkes_tf_StampedPoint_new01_local(lua_State* tolua_S)
6314 {
6315  tolua_Error tolua_err;
6316  if (
6317  !tolua_isusertable(tolua_S,1,"fawkes::tf::StampedPoint",0,&tolua_err) ||
6318  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Point",0,&tolua_err)) ||
6319  (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::Time",0,&tolua_err)) ||
6320  !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
6321  !tolua_isnoobj(tolua_S,5,&tolua_err)
6322  )
6323  goto tolua_lerror;
6324  else
6325  {
6326  const fawkes::tf::Point* input = ((const fawkes::tf::Point*) tolua_tousertype(tolua_S,2,0));
6327  const fawkes::Time* timestamp = ((const fawkes::Time*) tolua_tousertype(tolua_S,3,0));
6328  const std::string frame_id = ((const std::string) tolua_tocppstring(tolua_S,4,0));
6329  bool exc_caught = false;
6330  try {
6331  {
6332  fawkes::tf::StampedPoint* tolua_ret = (fawkes::tf::StampedPoint*) Mtolua_new((fawkes::tf::StampedPoint)(*input,*timestamp,frame_id));
6333  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::StampedPoint");
6334  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
6335  tolua_pushcppstring(tolua_S,(const char*)frame_id);
6336  }
6337  } catch (fawkes::Exception &e) {
6338  exc_caught = true;
6339  lua_pushstring(tolua_S, e.what_no_backtrace());
6340  }
6341  catch (std::exception &e) {
6342  exc_caught = true;
6343  lua_pushstring(tolua_S, e.what());
6344  }
6345  if (exc_caught) lua_error(tolua_S);
6346 
6347  }
6348  return 2;
6349 tolua_lerror:
6350  return tolua_fawkestf_fawkes_tf_StampedPoint_new00_local(tolua_S);
6351 }
6352 #endif //#ifndef TOLUA_DISABLE
6353 
6354 /* method: new of class fawkes::tf::StampedPose */
6355 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedPose_new00
6356 static int tolua_fawkestf_fawkes_tf_StampedPose_new00(lua_State* tolua_S)
6357 {
6358 #ifndef TOLUA_RELEASE
6359  tolua_Error tolua_err;
6360  if (
6361  !tolua_isusertable(tolua_S,1,"fawkes::tf::StampedPose",0,&tolua_err) ||
6362  !tolua_isnoobj(tolua_S,2,&tolua_err)
6363  )
6364  goto tolua_lerror;
6365  else
6366 #endif
6367  {
6368  bool exc_caught = false;
6369  try {
6370  {
6371  fawkes::tf::StampedPose* tolua_ret = (fawkes::tf::StampedPose*) Mtolua_new((fawkes::tf::StampedPose)());
6372  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::StampedPose");
6373  }
6374  } catch (fawkes::Exception &e) {
6375  exc_caught = true;
6376  lua_pushstring(tolua_S, e.what_no_backtrace());
6377  }
6378  catch (std::exception &e) {
6379  exc_caught = true;
6380  lua_pushstring(tolua_S, e.what());
6381  }
6382  if (exc_caught) lua_error(tolua_S);
6383 
6384  }
6385  return 1;
6386 #ifndef TOLUA_RELEASE
6387  tolua_lerror:
6388  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
6389  return 0;
6390 #endif
6391 }
6392 #endif //#ifndef TOLUA_DISABLE
6393 
6394 /* method: new_local of class fawkes::tf::StampedPose */
6395 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedPose_new00_local
6396 static int tolua_fawkestf_fawkes_tf_StampedPose_new00_local(lua_State* tolua_S)
6397 {
6398 #ifndef TOLUA_RELEASE
6399  tolua_Error tolua_err;
6400  if (
6401  !tolua_isusertable(tolua_S,1,"fawkes::tf::StampedPose",0,&tolua_err) ||
6402  !tolua_isnoobj(tolua_S,2,&tolua_err)
6403  )
6404  goto tolua_lerror;
6405  else
6406 #endif
6407  {
6408  bool exc_caught = false;
6409  try {
6410  {
6411  fawkes::tf::StampedPose* tolua_ret = (fawkes::tf::StampedPose*) Mtolua_new((fawkes::tf::StampedPose)());
6412  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::StampedPose");
6413  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
6414  }
6415  } catch (fawkes::Exception &e) {
6416  exc_caught = true;
6417  lua_pushstring(tolua_S, e.what_no_backtrace());
6418  }
6419  catch (std::exception &e) {
6420  exc_caught = true;
6421  lua_pushstring(tolua_S, e.what());
6422  }
6423  if (exc_caught) lua_error(tolua_S);
6424 
6425  }
6426  return 1;
6427 #ifndef TOLUA_RELEASE
6428  tolua_lerror:
6429  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
6430  return 0;
6431 #endif
6432 }
6433 #endif //#ifndef TOLUA_DISABLE
6434 
6435 /* method: new of class fawkes::tf::StampedPose */
6436 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedPose_new01
6437 static int tolua_fawkestf_fawkes_tf_StampedPose_new01(lua_State* tolua_S)
6438 {
6439  tolua_Error tolua_err;
6440  if (
6441  !tolua_isusertable(tolua_S,1,"fawkes::tf::StampedPose",0,&tolua_err) ||
6442  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Pose",0,&tolua_err)) ||
6443  (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::Time",0,&tolua_err)) ||
6444  !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
6445  !tolua_isnoobj(tolua_S,5,&tolua_err)
6446  )
6447  goto tolua_lerror;
6448  else
6449  {
6450  const fawkes::tf::Pose* input = ((const fawkes::tf::Pose*) tolua_tousertype(tolua_S,2,0));
6451  const fawkes::Time* timestamp = ((const fawkes::Time*) tolua_tousertype(tolua_S,3,0));
6452  const std::string frame_id = ((const std::string) tolua_tocppstring(tolua_S,4,0));
6453  bool exc_caught = false;
6454  try {
6455  {
6456  fawkes::tf::StampedPose* tolua_ret = (fawkes::tf::StampedPose*) Mtolua_new((fawkes::tf::StampedPose)(*input,*timestamp,frame_id));
6457  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::StampedPose");
6458  tolua_pushcppstring(tolua_S,(const char*)frame_id);
6459  }
6460  } catch (fawkes::Exception &e) {
6461  exc_caught = true;
6462  lua_pushstring(tolua_S, e.what_no_backtrace());
6463  }
6464  catch (std::exception &e) {
6465  exc_caught = true;
6466  lua_pushstring(tolua_S, e.what());
6467  }
6468  if (exc_caught) lua_error(tolua_S);
6469 
6470  }
6471  return 2;
6472 tolua_lerror:
6473  return tolua_fawkestf_fawkes_tf_StampedPose_new00(tolua_S);
6474 }
6475 #endif //#ifndef TOLUA_DISABLE
6476 
6477 /* method: new_local of class fawkes::tf::StampedPose */
6478 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedPose_new01_local
6479 static int tolua_fawkestf_fawkes_tf_StampedPose_new01_local(lua_State* tolua_S)
6480 {
6481  tolua_Error tolua_err;
6482  if (
6483  !tolua_isusertable(tolua_S,1,"fawkes::tf::StampedPose",0,&tolua_err) ||
6484  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Pose",0,&tolua_err)) ||
6485  (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::Time",0,&tolua_err)) ||
6486  !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
6487  !tolua_isnoobj(tolua_S,5,&tolua_err)
6488  )
6489  goto tolua_lerror;
6490  else
6491  {
6492  const fawkes::tf::Pose* input = ((const fawkes::tf::Pose*) tolua_tousertype(tolua_S,2,0));
6493  const fawkes::Time* timestamp = ((const fawkes::Time*) tolua_tousertype(tolua_S,3,0));
6494  const std::string frame_id = ((const std::string) tolua_tocppstring(tolua_S,4,0));
6495  bool exc_caught = false;
6496  try {
6497  {
6498  fawkes::tf::StampedPose* tolua_ret = (fawkes::tf::StampedPose*) Mtolua_new((fawkes::tf::StampedPose)(*input,*timestamp,frame_id));
6499  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::StampedPose");
6500  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
6501  tolua_pushcppstring(tolua_S,(const char*)frame_id);
6502  }
6503  } catch (fawkes::Exception &e) {
6504  exc_caught = true;
6505  lua_pushstring(tolua_S, e.what_no_backtrace());
6506  }
6507  catch (std::exception &e) {
6508  exc_caught = true;
6509  lua_pushstring(tolua_S, e.what());
6510  }
6511  if (exc_caught) lua_error(tolua_S);
6512 
6513  }
6514  return 2;
6515 tolua_lerror:
6516  return tolua_fawkestf_fawkes_tf_StampedPose_new00_local(tolua_S);
6517 }
6518 #endif //#ifndef TOLUA_DISABLE
6519 
6520 /* method: clear of class fawkes::tf::Transformer */
6521 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transformer_clear00
6522 static int tolua_fawkestf_fawkes_tf_Transformer_clear00(lua_State* tolua_S)
6523 {
6524 #ifndef TOLUA_RELEASE
6525  tolua_Error tolua_err;
6526  if (
6527  !tolua_isusertype(tolua_S,1,"fawkes::tf::Transformer",0,&tolua_err) ||
6528  !tolua_isnoobj(tolua_S,2,&tolua_err)
6529  )
6530  goto tolua_lerror;
6531  else
6532 #endif
6533  {
6534  fawkes::tf::Transformer* self = (fawkes::tf::Transformer*) tolua_tousertype(tolua_S,1,0);
6535 #ifndef TOLUA_RELEASE
6536  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'clear'", NULL);
6537 #endif
6538  bool exc_caught = false;
6539  try {
6540  {
6541  self->clear();
6542  }
6543  } catch (fawkes::Exception &e) {
6544  exc_caught = true;
6545  lua_pushstring(tolua_S, e.what_no_backtrace());
6546  }
6547  catch (std::exception &e) {
6548  exc_caught = true;
6549  lua_pushstring(tolua_S, e.what());
6550  }
6551  if (exc_caught) lua_error(tolua_S);
6552 
6553  }
6554  return 0;
6555 #ifndef TOLUA_RELEASE
6556  tolua_lerror:
6557  tolua_error(tolua_S,"#ferror in function 'clear'.",&tolua_err);
6558  return 0;
6559 #endif
6560 }
6561 #endif //#ifndef TOLUA_DISABLE
6562 
6563 /* method: frame_exists of class fawkes::tf::Transformer */
6564 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transformer_frame_exists00
6565 static int tolua_fawkestf_fawkes_tf_Transformer_frame_exists00(lua_State* tolua_S)
6566 {
6567 #ifndef TOLUA_RELEASE
6568  tolua_Error tolua_err;
6569  if (
6570  !tolua_isusertype(tolua_S,1,"const fawkes::tf::Transformer",0,&tolua_err) ||
6571  !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
6572  !tolua_isnoobj(tolua_S,3,&tolua_err)
6573  )
6574  goto tolua_lerror;
6575  else
6576 #endif
6577  {
6578  const fawkes::tf::Transformer* self = (const fawkes::tf::Transformer*) tolua_tousertype(tolua_S,1,0);
6579  const std::string frame_id_str = ((const std::string) tolua_tocppstring(tolua_S,2,0));
6580 #ifndef TOLUA_RELEASE
6581  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'frame_exists'", NULL);
6582 #endif
6583  bool exc_caught = false;
6584  try {
6585  {
6586  bool tolua_ret = (bool) self->frame_exists(frame_id_str);
6587  tolua_pushboolean(tolua_S,(bool)tolua_ret);
6588  tolua_pushcppstring(tolua_S,(const char*)frame_id_str);
6589  }
6590  } catch (fawkes::Exception &e) {
6591  exc_caught = true;
6592  lua_pushstring(tolua_S, e.what_no_backtrace());
6593  }
6594  catch (std::exception &e) {
6595  exc_caught = true;
6596  lua_pushstring(tolua_S, e.what());
6597  }
6598  if (exc_caught) lua_error(tolua_S);
6599 
6600  }
6601  return 2;
6602 #ifndef TOLUA_RELEASE
6603  tolua_lerror:
6604  tolua_error(tolua_S,"#ferror in function 'frame_exists'.",&tolua_err);
6605  return 0;
6606 #endif
6607 }
6608 #endif //#ifndef TOLUA_DISABLE
6609 
6610 /* method: lookup_transform of class fawkes::tf::Transformer */
6611 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transformer_lookup_transform00
6612 static int tolua_fawkestf_fawkes_tf_Transformer_lookup_transform00(lua_State* tolua_S)
6613 {
6614 #ifndef TOLUA_RELEASE
6615  tolua_Error tolua_err;
6616  if (
6617  !tolua_isusertype(tolua_S,1,"const fawkes::tf::Transformer",0,&tolua_err) ||
6618  !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
6619  !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
6620  (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"const fawkes::Time",0,&tolua_err)) ||
6621  (tolua_isvaluenil(tolua_S,5,&tolua_err) || !tolua_isusertype(tolua_S,5,"fawkes::tf::StampedTransform",0,&tolua_err)) ||
6622  !tolua_isnoobj(tolua_S,6,&tolua_err)
6623  )
6624  goto tolua_lerror;
6625  else
6626 #endif
6627  {
6628  const fawkes::tf::Transformer* self = (const fawkes::tf::Transformer*) tolua_tousertype(tolua_S,1,0);
6629  const std::string target_frame = ((const std::string) tolua_tocppstring(tolua_S,2,0));
6630  const std::string source_frame = ((const std::string) tolua_tocppstring(tolua_S,3,0));
6631  const fawkes::Time* time = ((const fawkes::Time*) tolua_tousertype(tolua_S,4,0));
6632  fawkes::tf::StampedTransform* transform = ((fawkes::tf::StampedTransform*) tolua_tousertype(tolua_S,5,0));
6633 #ifndef TOLUA_RELEASE
6634  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'lookup_transform'", NULL);
6635 #endif
6636  bool exc_caught = false;
6637  try {
6638  {
6639  self->lookup_transform(target_frame,source_frame,*time,*transform);
6640  tolua_pushcppstring(tolua_S,(const char*)target_frame);
6641  tolua_pushcppstring(tolua_S,(const char*)source_frame);
6642  }
6643  } catch (fawkes::Exception &e) {
6644  exc_caught = true;
6645  lua_pushstring(tolua_S, e.what_no_backtrace());
6646  }
6647  catch (std::exception &e) {
6648  exc_caught = true;
6649  lua_pushstring(tolua_S, e.what());
6650  }
6651  if (exc_caught) lua_error(tolua_S);
6652 
6653  }
6654  return 2;
6655 #ifndef TOLUA_RELEASE
6656  tolua_lerror:
6657  tolua_error(tolua_S,"#ferror in function 'lookup_transform'.",&tolua_err);
6658  return 0;
6659 #endif
6660 }
6661 #endif //#ifndef TOLUA_DISABLE
6662 
6663 /* method: lookup_transform of class fawkes::tf::Transformer */
6664 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transformer_lookup_transform01
6665 static int tolua_fawkestf_fawkes_tf_Transformer_lookup_transform01(lua_State* tolua_S)
6666 {
6667  tolua_Error tolua_err;
6668  if (
6669  !tolua_isusertype(tolua_S,1,"const fawkes::tf::Transformer",0,&tolua_err) ||
6670  !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
6671  !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
6672  (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"fawkes::tf::StampedTransform",0,&tolua_err)) ||
6673  !tolua_isnoobj(tolua_S,5,&tolua_err)
6674  )
6675  goto tolua_lerror;
6676  else
6677  {
6678  const fawkes::tf::Transformer* self = (const fawkes::tf::Transformer*) tolua_tousertype(tolua_S,1,0);
6679  const std::string target_frame = ((const std::string) tolua_tocppstring(tolua_S,2,0));
6680  const std::string source_frame = ((const std::string) tolua_tocppstring(tolua_S,3,0));
6681  fawkes::tf::StampedTransform* transform = ((fawkes::tf::StampedTransform*) tolua_tousertype(tolua_S,4,0));
6682 #ifndef TOLUA_RELEASE
6683  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'lookup_transform'", NULL);
6684 #endif
6685  bool exc_caught = false;
6686  try {
6687  {
6688  self->lookup_transform(target_frame,source_frame,*transform);
6689  tolua_pushcppstring(tolua_S,(const char*)target_frame);
6690  tolua_pushcppstring(tolua_S,(const char*)source_frame);
6691  }
6692  } catch (fawkes::Exception &e) {
6693  exc_caught = true;
6694  lua_pushstring(tolua_S, e.what_no_backtrace());
6695  }
6696  catch (std::exception &e) {
6697  exc_caught = true;
6698  lua_pushstring(tolua_S, e.what());
6699  }
6700  if (exc_caught) lua_error(tolua_S);
6701 
6702  }
6703  return 2;
6704 tolua_lerror:
6705  return tolua_fawkestf_fawkes_tf_Transformer_lookup_transform00(tolua_S);
6706 }
6707 #endif //#ifndef TOLUA_DISABLE
6708 
6709 /* method: lookup_transform of class fawkes::tf::Transformer */
6710 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transformer_lookup_transform02
6711 static int tolua_fawkestf_fawkes_tf_Transformer_lookup_transform02(lua_State* tolua_S)
6712 {
6713  tolua_Error tolua_err;
6714  if (
6715  !tolua_isusertype(tolua_S,1,"const fawkes::tf::Transformer",0,&tolua_err) ||
6716  !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
6717  (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::Time",0,&tolua_err)) ||
6718  !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
6719  (tolua_isvaluenil(tolua_S,5,&tolua_err) || !tolua_isusertype(tolua_S,5,"const fawkes::Time",0,&tolua_err)) ||
6720  !tolua_iscppstring(tolua_S,6,0,&tolua_err) ||
6721  (tolua_isvaluenil(tolua_S,7,&tolua_err) || !tolua_isusertype(tolua_S,7,"fawkes::tf::StampedTransform",0,&tolua_err)) ||
6722  !tolua_isnoobj(tolua_S,8,&tolua_err)
6723  )
6724  goto tolua_lerror;
6725  else
6726  {
6727  const fawkes::tf::Transformer* self = (const fawkes::tf::Transformer*) tolua_tousertype(tolua_S,1,0);
6728  const std::string target_frame = ((const std::string) tolua_tocppstring(tolua_S,2,0));
6729  const fawkes::Time* target_time = ((const fawkes::Time*) tolua_tousertype(tolua_S,3,0));
6730  const std::string source_frame = ((const std::string) tolua_tocppstring(tolua_S,4,0));
6731  const fawkes::Time* source_time = ((const fawkes::Time*) tolua_tousertype(tolua_S,5,0));
6732  const std::string fixed_frame = ((const std::string) tolua_tocppstring(tolua_S,6,0));
6733  fawkes::tf::StampedTransform* transform = ((fawkes::tf::StampedTransform*) tolua_tousertype(tolua_S,7,0));
6734 #ifndef TOLUA_RELEASE
6735  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'lookup_transform'", NULL);
6736 #endif
6737  bool exc_caught = false;
6738  try {
6739  {
6740  self->lookup_transform(target_frame,*target_time,source_frame,*source_time,fixed_frame,*transform);
6741  tolua_pushcppstring(tolua_S,(const char*)target_frame);
6742  tolua_pushcppstring(tolua_S,(const char*)source_frame);
6743  tolua_pushcppstring(tolua_S,(const char*)fixed_frame);
6744  }
6745  } catch (fawkes::Exception &e) {
6746  exc_caught = true;
6747  lua_pushstring(tolua_S, e.what_no_backtrace());
6748  }
6749  catch (std::exception &e) {
6750  exc_caught = true;
6751  lua_pushstring(tolua_S, e.what());
6752  }
6753  if (exc_caught) lua_error(tolua_S);
6754 
6755  }
6756  return 3;
6757 tolua_lerror:
6758  return tolua_fawkestf_fawkes_tf_Transformer_lookup_transform01(tolua_S);
6759 }
6760 #endif //#ifndef TOLUA_DISABLE
6761 
6762 /* method: can_transform of class fawkes::tf::Transformer */
6763 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transformer_can_transform00
6764 static int tolua_fawkestf_fawkes_tf_Transformer_can_transform00(lua_State* tolua_S)
6765 {
6766 #ifndef TOLUA_RELEASE
6767  tolua_Error tolua_err;
6768  if (
6769  !tolua_isusertype(tolua_S,1,"const fawkes::tf::Transformer",0,&tolua_err) ||
6770  !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
6771  !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
6772  (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"const fawkes::Time",0,&tolua_err)) ||
6773  !tolua_isnoobj(tolua_S,5,&tolua_err)
6774  )
6775  goto tolua_lerror;
6776  else
6777 #endif
6778  {
6779  const fawkes::tf::Transformer* self = (const fawkes::tf::Transformer*) tolua_tousertype(tolua_S,1,0);
6780  const std::string target_frame = ((const std::string) tolua_tocppstring(tolua_S,2,0));
6781  const std::string source_frame = ((const std::string) tolua_tocppstring(tolua_S,3,0));
6782  const fawkes::Time* time = ((const fawkes::Time*) tolua_tousertype(tolua_S,4,0));
6783 #ifndef TOLUA_RELEASE
6784  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'can_transform'", NULL);
6785 #endif
6786  bool exc_caught = false;
6787  try {
6788  {
6789  bool tolua_ret = (bool) self->can_transform(target_frame,source_frame,*time);
6790  tolua_pushboolean(tolua_S,(bool)tolua_ret);
6791  tolua_pushcppstring(tolua_S,(const char*)target_frame);
6792  tolua_pushcppstring(tolua_S,(const char*)source_frame);
6793  }
6794  } catch (fawkes::Exception &e) {
6795  exc_caught = true;
6796  lua_pushstring(tolua_S, e.what_no_backtrace());
6797  }
6798  catch (std::exception &e) {
6799  exc_caught = true;
6800  lua_pushstring(tolua_S, e.what());
6801  }
6802  if (exc_caught) lua_error(tolua_S);
6803 
6804  }
6805  return 3;
6806 #ifndef TOLUA_RELEASE
6807  tolua_lerror:
6808  tolua_error(tolua_S,"#ferror in function 'can_transform'.",&tolua_err);
6809  return 0;
6810 #endif
6811 }
6812 #endif //#ifndef TOLUA_DISABLE
6813 
6814 /* method: can_transform of class fawkes::tf::Transformer */
6815 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transformer_can_transform01
6816 static int tolua_fawkestf_fawkes_tf_Transformer_can_transform01(lua_State* tolua_S)
6817 {
6818  tolua_Error tolua_err;
6819  if (
6820  !tolua_isusertype(tolua_S,1,"const fawkes::tf::Transformer",0,&tolua_err) ||
6821  !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
6822  (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::Time",0,&tolua_err)) ||
6823  !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
6824  (tolua_isvaluenil(tolua_S,5,&tolua_err) || !tolua_isusertype(tolua_S,5,"const fawkes::Time",0,&tolua_err)) ||
6825  !tolua_iscppstring(tolua_S,6,0,&tolua_err) ||
6826  !tolua_isnoobj(tolua_S,7,&tolua_err)
6827  )
6828  goto tolua_lerror;
6829  else
6830  {
6831  const fawkes::tf::Transformer* self = (const fawkes::tf::Transformer*) tolua_tousertype(tolua_S,1,0);
6832  const std::string target_frame = ((const std::string) tolua_tocppstring(tolua_S,2,0));
6833  const fawkes::Time* target_time = ((const fawkes::Time*) tolua_tousertype(tolua_S,3,0));
6834  const std::string source_frame = ((const std::string) tolua_tocppstring(tolua_S,4,0));
6835  const fawkes::Time* source_time = ((const fawkes::Time*) tolua_tousertype(tolua_S,5,0));
6836  const std::string fixed_frame = ((const std::string) tolua_tocppstring(tolua_S,6,0));
6837 #ifndef TOLUA_RELEASE
6838  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'can_transform'", NULL);
6839 #endif
6840  bool exc_caught = false;
6841  try {
6842  {
6843  bool tolua_ret = (bool) self->can_transform(target_frame,*target_time,source_frame,*source_time,fixed_frame);
6844  tolua_pushboolean(tolua_S,(bool)tolua_ret);
6845  tolua_pushcppstring(tolua_S,(const char*)target_frame);
6846  tolua_pushcppstring(tolua_S,(const char*)source_frame);
6847  tolua_pushcppstring(tolua_S,(const char*)fixed_frame);
6848  }
6849  } catch (fawkes::Exception &e) {
6850  exc_caught = true;
6851  lua_pushstring(tolua_S, e.what_no_backtrace());
6852  }
6853  catch (std::exception &e) {
6854  exc_caught = true;
6855  lua_pushstring(tolua_S, e.what());
6856  }
6857  if (exc_caught) lua_error(tolua_S);
6858 
6859  }
6860  return 4;
6861 tolua_lerror:
6862  return tolua_fawkestf_fawkes_tf_Transformer_can_transform00(tolua_S);
6863 }
6864 #endif //#ifndef TOLUA_DISABLE
6865 
6866 /* method: transform_quaternion of class fawkes::tf::Transformer */
6867 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transformer_transform_quaternion00
6868 static int tolua_fawkestf_fawkes_tf_Transformer_transform_quaternion00(lua_State* tolua_S)
6869 {
6870 #ifndef TOLUA_RELEASE
6871  tolua_Error tolua_err;
6872  if (
6873  !tolua_isusertype(tolua_S,1,"const fawkes::tf::Transformer",0,&tolua_err) ||
6874  !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
6875  (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::tf::StampedQuaternion",0,&tolua_err)) ||
6876  (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"fawkes::tf::StampedQuaternion",0,&tolua_err)) ||
6877  !tolua_isnoobj(tolua_S,5,&tolua_err)
6878  )
6879  goto tolua_lerror;
6880  else
6881 #endif
6882  {
6883  const fawkes::tf::Transformer* self = (const fawkes::tf::Transformer*) tolua_tousertype(tolua_S,1,0);
6884  const std::string target_frame = ((const std::string) tolua_tocppstring(tolua_S,2,0));
6885  const fawkes::tf::StampedQuaternion* stamped_in = ((const fawkes::tf::StampedQuaternion*) tolua_tousertype(tolua_S,3,0));
6886  fawkes::tf::StampedQuaternion* stamped_out = ((fawkes::tf::StampedQuaternion*) tolua_tousertype(tolua_S,4,0));
6887 #ifndef TOLUA_RELEASE
6888  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'transform_quaternion'", NULL);
6889 #endif
6890  bool exc_caught = false;
6891  try {
6892  {
6893  self->transform_quaternion(target_frame,*stamped_in,*stamped_out);
6894  tolua_pushcppstring(tolua_S,(const char*)target_frame);
6895  }
6896  } catch (fawkes::Exception &e) {
6897  exc_caught = true;
6898  lua_pushstring(tolua_S, e.what_no_backtrace());
6899  }
6900  catch (std::exception &e) {
6901  exc_caught = true;
6902  lua_pushstring(tolua_S, e.what());
6903  }
6904  if (exc_caught) lua_error(tolua_S);
6905 
6906  }
6907  return 1;
6908 #ifndef TOLUA_RELEASE
6909  tolua_lerror:
6910  tolua_error(tolua_S,"#ferror in function 'transform_quaternion'.",&tolua_err);
6911  return 0;
6912 #endif
6913 }
6914 #endif //#ifndef TOLUA_DISABLE
6915 
6916 /* method: transform_vector of class fawkes::tf::Transformer */
6917 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transformer_transform_vector00
6918 static int tolua_fawkestf_fawkes_tf_Transformer_transform_vector00(lua_State* tolua_S)
6919 {
6920 #ifndef TOLUA_RELEASE
6921  tolua_Error tolua_err;
6922  if (
6923  !tolua_isusertype(tolua_S,1,"const fawkes::tf::Transformer",0,&tolua_err) ||
6924  !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
6925  (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::tf::StampedVector3",0,&tolua_err)) ||
6926  (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"fawkes::tf::StampedVector3",0,&tolua_err)) ||
6927  !tolua_isnoobj(tolua_S,5,&tolua_err)
6928  )
6929  goto tolua_lerror;
6930  else
6931 #endif
6932  {
6933  const fawkes::tf::Transformer* self = (const fawkes::tf::Transformer*) tolua_tousertype(tolua_S,1,0);
6934  const std::string target_frame = ((const std::string) tolua_tocppstring(tolua_S,2,0));
6935  const fawkes::tf::StampedVector3* stamped_in = ((const fawkes::tf::StampedVector3*) tolua_tousertype(tolua_S,3,0));
6936  fawkes::tf::StampedVector3* stamped_out = ((fawkes::tf::StampedVector3*) tolua_tousertype(tolua_S,4,0));
6937 #ifndef TOLUA_RELEASE
6938  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'transform_vector'", NULL);
6939 #endif
6940  bool exc_caught = false;
6941  try {
6942  {
6943  self->transform_vector(target_frame,*stamped_in,*stamped_out);
6944  tolua_pushcppstring(tolua_S,(const char*)target_frame);
6945  }
6946  } catch (fawkes::Exception &e) {
6947  exc_caught = true;
6948  lua_pushstring(tolua_S, e.what_no_backtrace());
6949  }
6950  catch (std::exception &e) {
6951  exc_caught = true;
6952  lua_pushstring(tolua_S, e.what());
6953  }
6954  if (exc_caught) lua_error(tolua_S);
6955 
6956  }
6957  return 1;
6958 #ifndef TOLUA_RELEASE
6959  tolua_lerror:
6960  tolua_error(tolua_S,"#ferror in function 'transform_vector'.",&tolua_err);
6961  return 0;
6962 #endif
6963 }
6964 #endif //#ifndef TOLUA_DISABLE
6965 
6966 /* method: transform_point of class fawkes::tf::Transformer */
6967 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transformer_transform_point00
6968 static int tolua_fawkestf_fawkes_tf_Transformer_transform_point00(lua_State* tolua_S)
6969 {
6970 #ifndef TOLUA_RELEASE
6971  tolua_Error tolua_err;
6972  if (
6973  !tolua_isusertype(tolua_S,1,"const fawkes::tf::Transformer",0,&tolua_err) ||
6974  !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
6975  (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::tf::StampedPoint",0,&tolua_err)) ||
6976  (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"fawkes::tf::StampedPoint",0,&tolua_err)) ||
6977  !tolua_isnoobj(tolua_S,5,&tolua_err)
6978  )
6979  goto tolua_lerror;
6980  else
6981 #endif
6982  {
6983  const fawkes::tf::Transformer* self = (const fawkes::tf::Transformer*) tolua_tousertype(tolua_S,1,0);
6984  const std::string target_frame = ((const std::string) tolua_tocppstring(tolua_S,2,0));
6985  const fawkes::tf::StampedPoint* stamped_in = ((const fawkes::tf::StampedPoint*) tolua_tousertype(tolua_S,3,0));
6986  fawkes::tf::StampedPoint* stamped_out = ((fawkes::tf::StampedPoint*) tolua_tousertype(tolua_S,4,0));
6987 #ifndef TOLUA_RELEASE
6988  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'transform_point'", NULL);
6989 #endif
6990  bool exc_caught = false;
6991  try {
6992  {
6993  self->transform_point(target_frame,*stamped_in,*stamped_out);
6994  tolua_pushcppstring(tolua_S,(const char*)target_frame);
6995  }
6996  } catch (fawkes::Exception &e) {
6997  exc_caught = true;
6998  lua_pushstring(tolua_S, e.what_no_backtrace());
6999  }
7000  catch (std::exception &e) {
7001  exc_caught = true;
7002  lua_pushstring(tolua_S, e.what());
7003  }
7004  if (exc_caught) lua_error(tolua_S);
7005 
7006  }
7007  return 1;
7008 #ifndef TOLUA_RELEASE
7009  tolua_lerror:
7010  tolua_error(tolua_S,"#ferror in function 'transform_point'.",&tolua_err);
7011  return 0;
7012 #endif
7013 }
7014 #endif //#ifndef TOLUA_DISABLE
7015 
7016 /* method: transform_pose of class fawkes::tf::Transformer */
7017 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transformer_transform_pose00
7018 static int tolua_fawkestf_fawkes_tf_Transformer_transform_pose00(lua_State* tolua_S)
7019 {
7020 #ifndef TOLUA_RELEASE
7021  tolua_Error tolua_err;
7022  if (
7023  !tolua_isusertype(tolua_S,1,"const fawkes::tf::Transformer",0,&tolua_err) ||
7024  !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
7025  (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::tf::StampedPose",0,&tolua_err)) ||
7026  (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"fawkes::tf::StampedPose",0,&tolua_err)) ||
7027  !tolua_isnoobj(tolua_S,5,&tolua_err)
7028  )
7029  goto tolua_lerror;
7030  else
7031 #endif
7032  {
7033  const fawkes::tf::Transformer* self = (const fawkes::tf::Transformer*) tolua_tousertype(tolua_S,1,0);
7034  const std::string target_frame = ((const std::string) tolua_tocppstring(tolua_S,2,0));
7035  const fawkes::tf::StampedPose* stamped_in = ((const fawkes::tf::StampedPose*) tolua_tousertype(tolua_S,3,0));
7036  fawkes::tf::StampedPose* stamped_out = ((fawkes::tf::StampedPose*) tolua_tousertype(tolua_S,4,0));
7037 #ifndef TOLUA_RELEASE
7038  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'transform_pose'", NULL);
7039 #endif
7040  bool exc_caught = false;
7041  try {
7042  {
7043  self->transform_pose(target_frame,*stamped_in,*stamped_out);
7044  tolua_pushcppstring(tolua_S,(const char*)target_frame);
7045  }
7046  } catch (fawkes::Exception &e) {
7047  exc_caught = true;
7048  lua_pushstring(tolua_S, e.what_no_backtrace());
7049  }
7050  catch (std::exception &e) {
7051  exc_caught = true;
7052  lua_pushstring(tolua_S, e.what());
7053  }
7054  if (exc_caught) lua_error(tolua_S);
7055 
7056  }
7057  return 1;
7058 #ifndef TOLUA_RELEASE
7059  tolua_lerror:
7060  tolua_error(tolua_S,"#ferror in function 'transform_pose'.",&tolua_err);
7061  return 0;
7062 #endif
7063 }
7064 #endif //#ifndef TOLUA_DISABLE
7065 
7066 /* method: transform_quaternion of class fawkes::tf::Transformer */
7067 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transformer_transform_quaternion01
7068 static int tolua_fawkestf_fawkes_tf_Transformer_transform_quaternion01(lua_State* tolua_S)
7069 {
7070  tolua_Error tolua_err;
7071  if (
7072  !tolua_isusertype(tolua_S,1,"const fawkes::tf::Transformer",0,&tolua_err) ||
7073  !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
7074  (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::Time",0,&tolua_err)) ||
7075  (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"const fawkes::tf::StampedQuaternion",0,&tolua_err)) ||
7076  !tolua_iscppstring(tolua_S,5,0,&tolua_err) ||
7077  (tolua_isvaluenil(tolua_S,6,&tolua_err) || !tolua_isusertype(tolua_S,6,"fawkes::tf::StampedQuaternion",0,&tolua_err)) ||
7078  !tolua_isnoobj(tolua_S,7,&tolua_err)
7079  )
7080  goto tolua_lerror;
7081  else
7082  {
7083  const fawkes::tf::Transformer* self = (const fawkes::tf::Transformer*) tolua_tousertype(tolua_S,1,0);
7084  const std::string target_frame = ((const std::string) tolua_tocppstring(tolua_S,2,0));
7085  const fawkes::Time* target_time = ((const fawkes::Time*) tolua_tousertype(tolua_S,3,0));
7086  const fawkes::tf::StampedQuaternion* stamped_in = ((const fawkes::tf::StampedQuaternion*) tolua_tousertype(tolua_S,4,0));
7087  const std::string fixed_frame = ((const std::string) tolua_tocppstring(tolua_S,5,0));
7088  fawkes::tf::StampedQuaternion* stamped_out = ((fawkes::tf::StampedQuaternion*) tolua_tousertype(tolua_S,6,0));
7089 #ifndef TOLUA_RELEASE
7090  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'transform_quaternion'", NULL);
7091 #endif
7092  bool exc_caught = false;
7093  try {
7094  {
7095  self->transform_quaternion(target_frame,*target_time,*stamped_in,fixed_frame,*stamped_out);
7096  tolua_pushcppstring(tolua_S,(const char*)target_frame);
7097  tolua_pushcppstring(tolua_S,(const char*)fixed_frame);
7098  }
7099  } catch (fawkes::Exception &e) {
7100  exc_caught = true;
7101  lua_pushstring(tolua_S, e.what_no_backtrace());
7102  }
7103  catch (std::exception &e) {
7104  exc_caught = true;
7105  lua_pushstring(tolua_S, e.what());
7106  }
7107  if (exc_caught) lua_error(tolua_S);
7108 
7109  }
7110  return 2;
7111 tolua_lerror:
7112  return tolua_fawkestf_fawkes_tf_Transformer_transform_quaternion00(tolua_S);
7113 }
7114 #endif //#ifndef TOLUA_DISABLE
7115 
7116 /* method: transform_vector of class fawkes::tf::Transformer */
7117 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transformer_transform_vector01
7118 static int tolua_fawkestf_fawkes_tf_Transformer_transform_vector01(lua_State* tolua_S)
7119 {
7120  tolua_Error tolua_err;
7121  if (
7122  !tolua_isusertype(tolua_S,1,"const fawkes::tf::Transformer",0,&tolua_err) ||
7123  !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
7124  (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::Time",0,&tolua_err)) ||
7125  (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"const fawkes::tf::StampedVector3",0,&tolua_err)) ||
7126  !tolua_iscppstring(tolua_S,5,0,&tolua_err) ||
7127  (tolua_isvaluenil(tolua_S,6,&tolua_err) || !tolua_isusertype(tolua_S,6,"fawkes::tf::StampedVector3",0,&tolua_err)) ||
7128  !tolua_isnoobj(tolua_S,7,&tolua_err)
7129  )
7130  goto tolua_lerror;
7131  else
7132  {
7133  const fawkes::tf::Transformer* self = (const fawkes::tf::Transformer*) tolua_tousertype(tolua_S,1,0);
7134  const std::string target_frame = ((const std::string) tolua_tocppstring(tolua_S,2,0));
7135  const fawkes::Time* target_time = ((const fawkes::Time*) tolua_tousertype(tolua_S,3,0));
7136  const fawkes::tf::StampedVector3* stamped_in = ((const fawkes::tf::StampedVector3*) tolua_tousertype(tolua_S,4,0));
7137  const std::string fixed_frame = ((const std::string) tolua_tocppstring(tolua_S,5,0));
7138  fawkes::tf::StampedVector3* stamped_out = ((fawkes::tf::StampedVector3*) tolua_tousertype(tolua_S,6,0));
7139 #ifndef TOLUA_RELEASE
7140  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'transform_vector'", NULL);
7141 #endif
7142  bool exc_caught = false;
7143  try {
7144  {
7145  self->transform_vector(target_frame,*target_time,*stamped_in,fixed_frame,*stamped_out);
7146  tolua_pushcppstring(tolua_S,(const char*)target_frame);
7147  tolua_pushcppstring(tolua_S,(const char*)fixed_frame);
7148  }
7149  } catch (fawkes::Exception &e) {
7150  exc_caught = true;
7151  lua_pushstring(tolua_S, e.what_no_backtrace());
7152  }
7153  catch (std::exception &e) {
7154  exc_caught = true;
7155  lua_pushstring(tolua_S, e.what());
7156  }
7157  if (exc_caught) lua_error(tolua_S);
7158 
7159  }
7160  return 2;
7161 tolua_lerror:
7162  return tolua_fawkestf_fawkes_tf_Transformer_transform_vector00(tolua_S);
7163 }
7164 #endif //#ifndef TOLUA_DISABLE
7165 
7166 /* method: transform_point of class fawkes::tf::Transformer */
7167 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transformer_transform_point01
7168 static int tolua_fawkestf_fawkes_tf_Transformer_transform_point01(lua_State* tolua_S)
7169 {
7170  tolua_Error tolua_err;
7171  if (
7172  !tolua_isusertype(tolua_S,1,"const fawkes::tf::Transformer",0,&tolua_err) ||
7173  !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
7174  (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::Time",0,&tolua_err)) ||
7175  (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"const fawkes::tf::StampedPoint",0,&tolua_err)) ||
7176  !tolua_iscppstring(tolua_S,5,0,&tolua_err) ||
7177  (tolua_isvaluenil(tolua_S,6,&tolua_err) || !tolua_isusertype(tolua_S,6,"fawkes::tf::StampedPoint",0,&tolua_err)) ||
7178  !tolua_isnoobj(tolua_S,7,&tolua_err)
7179  )
7180  goto tolua_lerror;
7181  else
7182  {
7183  const fawkes::tf::Transformer* self = (const fawkes::tf::Transformer*) tolua_tousertype(tolua_S,1,0);
7184  const std::string target_frame = ((const std::string) tolua_tocppstring(tolua_S,2,0));
7185  const fawkes::Time* target_time = ((const fawkes::Time*) tolua_tousertype(tolua_S,3,0));
7186  const fawkes::tf::StampedPoint* stamped_in = ((const fawkes::tf::StampedPoint*) tolua_tousertype(tolua_S,4,0));
7187  const std::string fixed_frame = ((const std::string) tolua_tocppstring(tolua_S,5,0));
7188  fawkes::tf::StampedPoint* stamped_out = ((fawkes::tf::StampedPoint*) tolua_tousertype(tolua_S,6,0));
7189 #ifndef TOLUA_RELEASE
7190  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'transform_point'", NULL);
7191 #endif
7192  bool exc_caught = false;
7193  try {
7194  {
7195  self->transform_point(target_frame,*target_time,*stamped_in,fixed_frame,*stamped_out);
7196  tolua_pushcppstring(tolua_S,(const char*)target_frame);
7197  tolua_pushcppstring(tolua_S,(const char*)fixed_frame);
7198  }
7199  } catch (fawkes::Exception &e) {
7200  exc_caught = true;
7201  lua_pushstring(tolua_S, e.what_no_backtrace());
7202  }
7203  catch (std::exception &e) {
7204  exc_caught = true;
7205  lua_pushstring(tolua_S, e.what());
7206  }
7207  if (exc_caught) lua_error(tolua_S);
7208 
7209  }
7210  return 2;
7211 tolua_lerror:
7212  return tolua_fawkestf_fawkes_tf_Transformer_transform_point00(tolua_S);
7213 }
7214 #endif //#ifndef TOLUA_DISABLE
7215 
7216 /* method: transform_pose of class fawkes::tf::Transformer */
7217 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transformer_transform_pose01
7218 static int tolua_fawkestf_fawkes_tf_Transformer_transform_pose01(lua_State* tolua_S)
7219 {
7220  tolua_Error tolua_err;
7221  if (
7222  !tolua_isusertype(tolua_S,1,"const fawkes::tf::Transformer",0,&tolua_err) ||
7223  !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
7224  (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::Time",0,&tolua_err)) ||
7225  (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"const fawkes::tf::StampedPose",0,&tolua_err)) ||
7226  !tolua_iscppstring(tolua_S,5,0,&tolua_err) ||
7227  (tolua_isvaluenil(tolua_S,6,&tolua_err) || !tolua_isusertype(tolua_S,6,"fawkes::tf::StampedPose",0,&tolua_err)) ||
7228  !tolua_isnoobj(tolua_S,7,&tolua_err)
7229  )
7230  goto tolua_lerror;
7231  else
7232  {
7233  const fawkes::tf::Transformer* self = (const fawkes::tf::Transformer*) tolua_tousertype(tolua_S,1,0);
7234  const std::string target_frame = ((const std::string) tolua_tocppstring(tolua_S,2,0));
7235  const fawkes::Time* target_time = ((const fawkes::Time*) tolua_tousertype(tolua_S,3,0));
7236  const fawkes::tf::StampedPose* stamped_in = ((const fawkes::tf::StampedPose*) tolua_tousertype(tolua_S,4,0));
7237  const std::string fixed_frame = ((const std::string) tolua_tocppstring(tolua_S,5,0));
7238  fawkes::tf::StampedPose* stamped_out = ((fawkes::tf::StampedPose*) tolua_tousertype(tolua_S,6,0));
7239 #ifndef TOLUA_RELEASE
7240  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'transform_pose'", NULL);
7241 #endif
7242  bool exc_caught = false;
7243  try {
7244  {
7245  self->transform_pose(target_frame,*target_time,*stamped_in,fixed_frame,*stamped_out);
7246  tolua_pushcppstring(tolua_S,(const char*)target_frame);
7247  tolua_pushcppstring(tolua_S,(const char*)fixed_frame);
7248  }
7249  } catch (fawkes::Exception &e) {
7250  exc_caught = true;
7251  lua_pushstring(tolua_S, e.what_no_backtrace());
7252  }
7253  catch (std::exception &e) {
7254  exc_caught = true;
7255  lua_pushstring(tolua_S, e.what());
7256  }
7257  if (exc_caught) lua_error(tolua_S);
7258 
7259  }
7260  return 2;
7261 tolua_lerror:
7262  return tolua_fawkestf_fawkes_tf_Transformer_transform_pose00(tolua_S);
7263 }
7264 #endif //#ifndef TOLUA_DISABLE
7265 
7266 /* Open function */
7267 TOLUA_API int tolua_fawkestf_open (lua_State* tolua_S)
7268 {
7269  tolua_open(tolua_S);
7270  tolua_reg_types(tolua_S);
7271  tolua_module(tolua_S,NULL,0);
7272  tolua_beginmodule(tolua_S,NULL);
7273  tolua_module(tolua_S,"fawkes",0);
7274  tolua_beginmodule(tolua_S,"fawkes");
7275  tolua_module(tolua_S,"tf",0);
7276  tolua_beginmodule(tolua_S,"tf");
7277  tolua_function(tolua_S,"get_yaw",tolua_fawkestf_fawkes_tf_get_yaw00);
7278  tolua_function(tolua_S,"create_quaternion_from_rpy",tolua_fawkestf_fawkes_tf_create_quaternion_from_rpy00);
7279  tolua_function(tolua_S,"create_quaternion_from_yaw",tolua_fawkestf_fawkes_tf_create_quaternion_from_yaw00);
7280  tolua_function(tolua_S,"resize_vector",tolua_fawkestf_fawkes_tf_resize_vector00);
7281  #ifdef __cplusplus
7282  tolua_cclass(tolua_S,"Vector3","fawkes::tf::Vector3","",tolua_collect_fawkes__tf__Vector3);
7283  #else
7284  tolua_cclass(tolua_S,"Vector3","fawkes::tf::Vector3","",NULL);
7285  #endif
7286  tolua_beginmodule(tolua_S,"Vector3");
7287  tolua_function(tolua_S,"new",tolua_fawkestf_fawkes_tf_Vector3_new00);
7288  tolua_function(tolua_S,"new_local",tolua_fawkestf_fawkes_tf_Vector3_new00_local);
7289  tolua_function(tolua_S,".call",tolua_fawkestf_fawkes_tf_Vector3_new00_local);
7290  tolua_function(tolua_S,"new",tolua_fawkestf_fawkes_tf_Vector3_new01);
7291  tolua_function(tolua_S,"new_local",tolua_fawkestf_fawkes_tf_Vector3_new01_local);
7292  tolua_function(tolua_S,".call",tolua_fawkestf_fawkes_tf_Vector3_new01_local);
7293  tolua_function(tolua_S,"dot",tolua_fawkestf_fawkes_tf_Vector3_dot00);
7294  tolua_function(tolua_S,"length2",tolua_fawkestf_fawkes_tf_Vector3_length200);
7295  tolua_function(tolua_S,"length",tolua_fawkestf_fawkes_tf_Vector3_length00);
7296  tolua_function(tolua_S,"distance2",tolua_fawkestf_fawkes_tf_Vector3_distance200);
7297  tolua_function(tolua_S,"distance",tolua_fawkestf_fawkes_tf_Vector3_distance00);
7298  tolua_function(tolua_S,"normalize",tolua_fawkestf_fawkes_tf_Vector3_normalize00);
7299  tolua_function(tolua_S,"normalized",tolua_fawkestf_fawkes_tf_Vector3_normalized00);
7300  tolua_function(tolua_S,"rotate",tolua_fawkestf_fawkes_tf_Vector3_rotate00);
7301  tolua_function(tolua_S,"angle",tolua_fawkestf_fawkes_tf_Vector3_angle00);
7302  tolua_function(tolua_S,"absolute",tolua_fawkestf_fawkes_tf_Vector3_absolute00);
7303  tolua_function(tolua_S,"cross",tolua_fawkestf_fawkes_tf_Vector3_cross00);
7304  tolua_function(tolua_S,"triple",tolua_fawkestf_fawkes_tf_Vector3_triple00);
7305  tolua_function(tolua_S,"minAxis",tolua_fawkestf_fawkes_tf_Vector3_minAxis00);
7306  tolua_function(tolua_S,"maxAxis",tolua_fawkestf_fawkes_tf_Vector3_maxAxis00);
7307  tolua_function(tolua_S,"furthestAxis",tolua_fawkestf_fawkes_tf_Vector3_furthestAxis00);
7308  tolua_function(tolua_S,"closestAxis",tolua_fawkestf_fawkes_tf_Vector3_closestAxis00);
7309  tolua_function(tolua_S,"setInterpolate3",tolua_fawkestf_fawkes_tf_Vector3_setInterpolate300);
7310  tolua_function(tolua_S,"lerp",tolua_fawkestf_fawkes_tf_Vector3_lerp00);
7311  tolua_function(tolua_S,"x",tolua_fawkestf_fawkes_tf_Vector3_x00);
7312  tolua_function(tolua_S,"y",tolua_fawkestf_fawkes_tf_Vector3_y00);
7313  tolua_function(tolua_S,"z",tolua_fawkestf_fawkes_tf_Vector3_z00);
7314  tolua_function(tolua_S,"setX",tolua_fawkestf_fawkes_tf_Vector3_setX00);
7315  tolua_function(tolua_S,"setY",tolua_fawkestf_fawkes_tf_Vector3_setY00);
7316  tolua_function(tolua_S,"setZ",tolua_fawkestf_fawkes_tf_Vector3_setZ00);
7317  tolua_function(tolua_S,"setValue",tolua_fawkestf_fawkes_tf_Vector3_setValue00);
7318  tolua_function(tolua_S,"setZero",tolua_fawkestf_fawkes_tf_Vector3_setZero00);
7319  tolua_function(tolua_S,"isZero",tolua_fawkestf_fawkes_tf_Vector3_isZero00);
7320  tolua_function(tolua_S,"fuzzyZero",tolua_fawkestf_fawkes_tf_Vector3_fuzzyZero00);
7321  tolua_endmodule(tolua_S);
7322  #ifdef __cplusplus
7323  tolua_cclass(tolua_S,"Quaternion","fawkes::tf::Quaternion","",tolua_collect_fawkes__tf__Quaternion);
7324  #else
7325  tolua_cclass(tolua_S,"Quaternion","fawkes::tf::Quaternion","",NULL);
7326  #endif
7327  tolua_beginmodule(tolua_S,"Quaternion");
7328  tolua_function(tolua_S,"new",tolua_fawkestf_fawkes_tf_Quaternion_new00);
7329  tolua_function(tolua_S,"new_local",tolua_fawkestf_fawkes_tf_Quaternion_new00_local);
7330  tolua_function(tolua_S,".call",tolua_fawkestf_fawkes_tf_Quaternion_new00_local);
7331  tolua_function(tolua_S,"new",tolua_fawkestf_fawkes_tf_Quaternion_new01);
7332  tolua_function(tolua_S,"new_local",tolua_fawkestf_fawkes_tf_Quaternion_new01_local);
7333  tolua_function(tolua_S,".call",tolua_fawkestf_fawkes_tf_Quaternion_new01_local);
7334  tolua_function(tolua_S,"new",tolua_fawkestf_fawkes_tf_Quaternion_new02);
7335  tolua_function(tolua_S,"new_local",tolua_fawkestf_fawkes_tf_Quaternion_new02_local);
7336  tolua_function(tolua_S,".call",tolua_fawkestf_fawkes_tf_Quaternion_new02_local);
7337  tolua_function(tolua_S,"new",tolua_fawkestf_fawkes_tf_Quaternion_new03);
7338  tolua_function(tolua_S,"new_local",tolua_fawkestf_fawkes_tf_Quaternion_new03_local);
7339  tolua_function(tolua_S,".call",tolua_fawkestf_fawkes_tf_Quaternion_new03_local);
7340  tolua_function(tolua_S,"getIdentity",tolua_fawkestf_fawkes_tf_Quaternion_getIdentity00);
7341  tolua_function(tolua_S,"setRotation",tolua_fawkestf_fawkes_tf_Quaternion_setRotation00);
7342  tolua_function(tolua_S,"setEuler",tolua_fawkestf_fawkes_tf_Quaternion_setEuler00);
7343  tolua_function(tolua_S,".eq",tolua_fawkestf_fawkes_tf_Quaternion__eq00);
7344  tolua_function(tolua_S,"dot",tolua_fawkestf_fawkes_tf_Quaternion_dot00);
7345  tolua_function(tolua_S,"length2",tolua_fawkestf_fawkes_tf_Quaternion_length200);
7346  tolua_function(tolua_S,"length",tolua_fawkestf_fawkes_tf_Quaternion_length00);
7347  tolua_function(tolua_S,"normalize",tolua_fawkestf_fawkes_tf_Quaternion_normalize00);
7348  tolua_function(tolua_S,"normalized",tolua_fawkestf_fawkes_tf_Quaternion_normalized00);
7349  tolua_function(tolua_S,"angle",tolua_fawkestf_fawkes_tf_Quaternion_angle00);
7350  tolua_function(tolua_S,"getAngle",tolua_fawkestf_fawkes_tf_Quaternion_getAngle00);
7351  tolua_function(tolua_S,"getAxis",tolua_fawkestf_fawkes_tf_Quaternion_getAxis00);
7352  tolua_function(tolua_S,"inverse",tolua_fawkestf_fawkes_tf_Quaternion_inverse00);
7353  tolua_function(tolua_S,"slerp",tolua_fawkestf_fawkes_tf_Quaternion_slerp00);
7354  tolua_function(tolua_S,"x",tolua_fawkestf_fawkes_tf_Quaternion_x00);
7355  tolua_function(tolua_S,"y",tolua_fawkestf_fawkes_tf_Quaternion_y00);
7356  tolua_function(tolua_S,"z",tolua_fawkestf_fawkes_tf_Quaternion_z00);
7357  tolua_function(tolua_S,"w",tolua_fawkestf_fawkes_tf_Quaternion_w00);
7358  tolua_function(tolua_S,"setX",tolua_fawkestf_fawkes_tf_Quaternion_setX00);
7359  tolua_function(tolua_S,"setY",tolua_fawkestf_fawkes_tf_Quaternion_setY00);
7360  tolua_function(tolua_S,"setZ",tolua_fawkestf_fawkes_tf_Quaternion_setZ00);
7361  tolua_function(tolua_S,"setW",tolua_fawkestf_fawkes_tf_Quaternion_setW00);
7362  tolua_function(tolua_S,"setValue",tolua_fawkestf_fawkes_tf_Quaternion_setValue00);
7363  tolua_endmodule(tolua_S);
7364  #ifdef __cplusplus
7365  tolua_cclass(tolua_S,"Transform","fawkes::tf::Transform","",tolua_collect_fawkes__tf__Transform);
7366  #else
7367  tolua_cclass(tolua_S,"Transform","fawkes::tf::Transform","",NULL);
7368  #endif
7369  tolua_beginmodule(tolua_S,"Transform");
7370  tolua_function(tolua_S,"new",tolua_fawkestf_fawkes_tf_Transform_new00);
7371  tolua_function(tolua_S,"new_local",tolua_fawkestf_fawkes_tf_Transform_new00_local);
7372  tolua_function(tolua_S,".call",tolua_fawkestf_fawkes_tf_Transform_new00_local);
7373  tolua_function(tolua_S,"new",tolua_fawkestf_fawkes_tf_Transform_new01);
7374  tolua_function(tolua_S,"new_local",tolua_fawkestf_fawkes_tf_Transform_new01_local);
7375  tolua_function(tolua_S,".call",tolua_fawkestf_fawkes_tf_Transform_new01_local);
7376  tolua_function(tolua_S,"new",tolua_fawkestf_fawkes_tf_Transform_new02);
7377  tolua_function(tolua_S,"new_local",tolua_fawkestf_fawkes_tf_Transform_new02_local);
7378  tolua_function(tolua_S,".call",tolua_fawkestf_fawkes_tf_Transform_new02_local);
7379  tolua_function(tolua_S,"getIdentity",tolua_fawkestf_fawkes_tf_Transform_getIdentity00);
7380  tolua_function(tolua_S,"mult",tolua_fawkestf_fawkes_tf_Transform_mult00);
7381  tolua_function(tolua_S,".mul",tolua_fawkestf_fawkes_tf_Transform__mul00);
7382  tolua_function(tolua_S,".mul",tolua_fawkestf_fawkes_tf_Transform__mul01);
7383  tolua_function(tolua_S,"getOrigin",tolua_fawkestf_fawkes_tf_Transform_getOrigin00);
7384  tolua_function(tolua_S,"getRotation",tolua_fawkestf_fawkes_tf_Transform_getRotation00);
7385  tolua_function(tolua_S,"setOrigin",tolua_fawkestf_fawkes_tf_Transform_setOrigin00);
7386  tolua_function(tolua_S,"setRotation",tolua_fawkestf_fawkes_tf_Transform_setRotation00);
7387  tolua_function(tolua_S,"setIdentity",tolua_fawkestf_fawkes_tf_Transform_setIdentity00);
7388  tolua_function(tolua_S,"inverse",tolua_fawkestf_fawkes_tf_Transform_inverse00);
7389  tolua_function(tolua_S,"inverseTimes",tolua_fawkestf_fawkes_tf_Transform_inverseTimes00);
7390  tolua_endmodule(tolua_S);
7391  #ifdef __cplusplus
7392  tolua_cclass(tolua_S,"Point","fawkes::tf::Point","fawkes::tf::Vector3",tolua_collect_fawkes__tf__Point);
7393  #else
7394  tolua_cclass(tolua_S,"Point","fawkes::tf::Point","fawkes::tf::Vector3",NULL);
7395  #endif
7396  tolua_beginmodule(tolua_S,"Point");
7397  tolua_function(tolua_S,"new",tolua_fawkestf_fawkes_tf_Point_new00);
7398  tolua_function(tolua_S,"new_local",tolua_fawkestf_fawkes_tf_Point_new00_local);
7399  tolua_function(tolua_S,".call",tolua_fawkestf_fawkes_tf_Point_new00_local);
7400  tolua_function(tolua_S,"new",tolua_fawkestf_fawkes_tf_Point_new01);
7401  tolua_function(tolua_S,"new_local",tolua_fawkestf_fawkes_tf_Point_new01_local);
7402  tolua_function(tolua_S,".call",tolua_fawkestf_fawkes_tf_Point_new01_local);
7403  tolua_endmodule(tolua_S);
7404  #ifdef __cplusplus
7405  tolua_cclass(tolua_S,"Pose","fawkes::tf::Pose","fawkes::tf::Transform",tolua_collect_fawkes__tf__Pose);
7406  #else
7407  tolua_cclass(tolua_S,"Pose","fawkes::tf::Pose","fawkes::tf::Transform",NULL);
7408  #endif
7409  tolua_beginmodule(tolua_S,"Pose");
7410  tolua_function(tolua_S,"new",tolua_fawkestf_fawkes_tf_Pose_new00);
7411  tolua_function(tolua_S,"new_local",tolua_fawkestf_fawkes_tf_Pose_new00_local);
7412  tolua_function(tolua_S,".call",tolua_fawkestf_fawkes_tf_Pose_new00_local);
7413  tolua_function(tolua_S,"new",tolua_fawkestf_fawkes_tf_Pose_new01);
7414  tolua_function(tolua_S,"new_local",tolua_fawkestf_fawkes_tf_Pose_new01_local);
7415  tolua_function(tolua_S,".call",tolua_fawkestf_fawkes_tf_Pose_new01_local);
7416  tolua_function(tolua_S,"new",tolua_fawkestf_fawkes_tf_Pose_new02);
7417  tolua_function(tolua_S,"new_local",tolua_fawkestf_fawkes_tf_Pose_new02_local);
7418  tolua_function(tolua_S,".call",tolua_fawkestf_fawkes_tf_Pose_new02_local);
7419  tolua_function(tolua_S,"getIdentity",tolua_fawkestf_fawkes_tf_Pose_getIdentity00);
7420  tolua_endmodule(tolua_S);
7421  #ifdef __cplusplus
7422  tolua_cclass(tolua_S,"StampedTransform","fawkes::tf::StampedTransform","fawkes::tf::Transform",tolua_collect_fawkes__tf__StampedTransform);
7423  #else
7424  tolua_cclass(tolua_S,"StampedTransform","fawkes::tf::StampedTransform","fawkes::tf::Transform",NULL);
7425  #endif
7426  tolua_beginmodule(tolua_S,"StampedTransform");
7427  tolua_variable(tolua_S,"stamp",tolua_get_fawkes__tf__StampedTransform_stamp,tolua_set_fawkes__tf__StampedTransform_stamp);
7428  tolua_variable(tolua_S,"frame_id",tolua_get_fawkes__tf__StampedTransform_frame_id,tolua_set_fawkes__tf__StampedTransform_frame_id);
7429  tolua_variable(tolua_S,"child_frame_id",tolua_get_fawkes__tf__StampedTransform_child_frame_id,tolua_set_fawkes__tf__StampedTransform_child_frame_id);
7430  tolua_function(tolua_S,"new",tolua_fawkestf_fawkes_tf_StampedTransform_new00);
7431  tolua_function(tolua_S,"new_local",tolua_fawkestf_fawkes_tf_StampedTransform_new00_local);
7432  tolua_function(tolua_S,".call",tolua_fawkestf_fawkes_tf_StampedTransform_new00_local);
7433  tolua_function(tolua_S,"new",tolua_fawkestf_fawkes_tf_StampedTransform_new01);
7434  tolua_function(tolua_S,"new_local",tolua_fawkestf_fawkes_tf_StampedTransform_new01_local);
7435  tolua_function(tolua_S,".call",tolua_fawkestf_fawkes_tf_StampedTransform_new01_local);
7436  tolua_function(tolua_S,"set_data",tolua_fawkestf_fawkes_tf_StampedTransform_set_data00);
7437  tolua_endmodule(tolua_S);
7438  #ifdef __cplusplus
7439  tolua_cclass(tolua_S,"Stamped_fawkes__tf__Quaternion_","fawkes::tf::Stamped<fawkes::tf::Quaternion>","fawkes::tf::Quaternion",tolua_collect_fawkes__tf__Stamped_fawkes__tf__Quaternion_);
7440  #else
7441  tolua_cclass(tolua_S,"Stamped_fawkes__tf__Quaternion_","fawkes::tf::Stamped<fawkes::tf::Quaternion>","fawkes::tf::Quaternion",NULL);
7442  #endif
7443  tolua_beginmodule(tolua_S,"Stamped_fawkes__tf__Quaternion_");
7444  tolua_variable(tolua_S,"stamp",tolua_get_fawkes__tf__Stamped_fawkes__tf__Quaternion__stamp,tolua_set_fawkes__tf__Stamped_fawkes__tf__Quaternion__stamp);
7445  tolua_variable(tolua_S,"frame_id",tolua_get_fawkes__tf__Stamped_fawkes__tf__Quaternion__frame_id,tolua_set_fawkes__tf__Stamped_fawkes__tf__Quaternion__frame_id);
7446  tolua_function(tolua_S,"new",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__new00);
7447  tolua_function(tolua_S,"new_local",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__new00_local);
7448  tolua_function(tolua_S,".call",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__new00_local);
7449  tolua_function(tolua_S,"new",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__new01);
7450  tolua_function(tolua_S,"new_local",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__new01_local);
7451  tolua_function(tolua_S,".call",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__new01_local);
7452  tolua_function(tolua_S,"set_data",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__set_data00);
7453  tolua_endmodule(tolua_S);
7454  #ifdef __cplusplus
7455  tolua_cclass(tolua_S,"Stamped_fawkes__tf__Vector3_","fawkes::tf::Stamped<fawkes::tf::Vector3>","fawkes::tf::Vector3",tolua_collect_fawkes__tf__Stamped_fawkes__tf__Vector3_);
7456  #else
7457  tolua_cclass(tolua_S,"Stamped_fawkes__tf__Vector3_","fawkes::tf::Stamped<fawkes::tf::Vector3>","fawkes::tf::Vector3",NULL);
7458  #endif
7459  tolua_beginmodule(tolua_S,"Stamped_fawkes__tf__Vector3_");
7460  tolua_variable(tolua_S,"stamp",tolua_get_fawkes__tf__Stamped_fawkes__tf__Vector3__stamp,tolua_set_fawkes__tf__Stamped_fawkes__tf__Vector3__stamp);
7461  tolua_variable(tolua_S,"frame_id",tolua_get_fawkes__tf__Stamped_fawkes__tf__Vector3__frame_id,tolua_set_fawkes__tf__Stamped_fawkes__tf__Vector3__frame_id);
7462  tolua_function(tolua_S,"new",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__new00);
7463  tolua_function(tolua_S,"new_local",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__new00_local);
7464  tolua_function(tolua_S,".call",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__new00_local);
7465  tolua_function(tolua_S,"new",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__new01);
7466  tolua_function(tolua_S,"new_local",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__new01_local);
7467  tolua_function(tolua_S,".call",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__new01_local);
7468  tolua_function(tolua_S,"set_data",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__set_data00);
7469  tolua_endmodule(tolua_S);
7470  #ifdef __cplusplus
7471  tolua_cclass(tolua_S,"Stamped_fawkes__tf__Point_","fawkes::tf::Stamped<fawkes::tf::Point>","fawkes::tf::Point",tolua_collect_fawkes__tf__Stamped_fawkes__tf__Point_);
7472  #else
7473  tolua_cclass(tolua_S,"Stamped_fawkes__tf__Point_","fawkes::tf::Stamped<fawkes::tf::Point>","fawkes::tf::Point",NULL);
7474  #endif
7475  tolua_beginmodule(tolua_S,"Stamped_fawkes__tf__Point_");
7476  tolua_variable(tolua_S,"stamp",tolua_get_fawkes__tf__Stamped_fawkes__tf__Point__stamp,tolua_set_fawkes__tf__Stamped_fawkes__tf__Point__stamp);
7477  tolua_variable(tolua_S,"frame_id",tolua_get_fawkes__tf__Stamped_fawkes__tf__Point__frame_id,tolua_set_fawkes__tf__Stamped_fawkes__tf__Point__frame_id);
7478  tolua_function(tolua_S,"new",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__new00);
7479  tolua_function(tolua_S,"new_local",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__new00_local);
7480  tolua_function(tolua_S,".call",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__new00_local);
7481  tolua_function(tolua_S,"new",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__new01);
7482  tolua_function(tolua_S,"new_local",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__new01_local);
7483  tolua_function(tolua_S,".call",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__new01_local);
7484  tolua_function(tolua_S,"set_data",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__set_data00);
7485  tolua_endmodule(tolua_S);
7486  #ifdef __cplusplus
7487  tolua_cclass(tolua_S,"Stamped_fawkes__tf__Pose_","fawkes::tf::Stamped<fawkes::tf::Pose>","fawkes::tf::Pose",tolua_collect_fawkes__tf__Stamped_fawkes__tf__Pose_);
7488  #else
7489  tolua_cclass(tolua_S,"Stamped_fawkes__tf__Pose_","fawkes::tf::Stamped<fawkes::tf::Pose>","fawkes::tf::Pose",NULL);
7490  #endif
7491  tolua_beginmodule(tolua_S,"Stamped_fawkes__tf__Pose_");
7492  tolua_variable(tolua_S,"stamp",tolua_get_fawkes__tf__Stamped_fawkes__tf__Pose__stamp,tolua_set_fawkes__tf__Stamped_fawkes__tf__Pose__stamp);
7493  tolua_variable(tolua_S,"frame_id",tolua_get_fawkes__tf__Stamped_fawkes__tf__Pose__frame_id,tolua_set_fawkes__tf__Stamped_fawkes__tf__Pose__frame_id);
7494  tolua_function(tolua_S,"new",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__new00);
7495  tolua_function(tolua_S,"new_local",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__new00_local);
7496  tolua_function(tolua_S,".call",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__new00_local);
7497  tolua_function(tolua_S,"new",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__new01);
7498  tolua_function(tolua_S,"new_local",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__new01_local);
7499  tolua_function(tolua_S,".call",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__new01_local);
7500  tolua_function(tolua_S,"set_data",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__set_data00);
7501  tolua_endmodule(tolua_S);
7502  #ifdef __cplusplus
7503  tolua_cclass(tolua_S,"StampedQuaternion","fawkes::tf::StampedQuaternion","fawkes::tf::Stamped<fawkes::tf::Quaternion>",tolua_collect_fawkes__tf__StampedQuaternion);
7504  #else
7505  tolua_cclass(tolua_S,"StampedQuaternion","fawkes::tf::StampedQuaternion","fawkes::tf::Stamped<fawkes::tf::Quaternion>",NULL);
7506  #endif
7507  tolua_beginmodule(tolua_S,"StampedQuaternion");
7508  tolua_function(tolua_S,"new",tolua_fawkestf_fawkes_tf_StampedQuaternion_new00);
7509  tolua_function(tolua_S,"new_local",tolua_fawkestf_fawkes_tf_StampedQuaternion_new00_local);
7510  tolua_function(tolua_S,".call",tolua_fawkestf_fawkes_tf_StampedQuaternion_new00_local);
7511  tolua_function(tolua_S,"new",tolua_fawkestf_fawkes_tf_StampedQuaternion_new01);
7512  tolua_function(tolua_S,"new_local",tolua_fawkestf_fawkes_tf_StampedQuaternion_new01_local);
7513  tolua_function(tolua_S,".call",tolua_fawkestf_fawkes_tf_StampedQuaternion_new01_local);
7514  tolua_endmodule(tolua_S);
7515  #ifdef __cplusplus
7516  tolua_cclass(tolua_S,"StampedVector3","fawkes::tf::StampedVector3","fawkes::tf::Stamped<fawkes::tf::Vector3>",tolua_collect_fawkes__tf__StampedVector3);
7517  #else
7518  tolua_cclass(tolua_S,"StampedVector3","fawkes::tf::StampedVector3","fawkes::tf::Stamped<fawkes::tf::Vector3>",NULL);
7519  #endif
7520  tolua_beginmodule(tolua_S,"StampedVector3");
7521  tolua_function(tolua_S,"new",tolua_fawkestf_fawkes_tf_StampedVector3_new00);
7522  tolua_function(tolua_S,"new_local",tolua_fawkestf_fawkes_tf_StampedVector3_new00_local);
7523  tolua_function(tolua_S,".call",tolua_fawkestf_fawkes_tf_StampedVector3_new00_local);
7524  tolua_function(tolua_S,"new",tolua_fawkestf_fawkes_tf_StampedVector3_new01);
7525  tolua_function(tolua_S,"new_local",tolua_fawkestf_fawkes_tf_StampedVector3_new01_local);
7526  tolua_function(tolua_S,".call",tolua_fawkestf_fawkes_tf_StampedVector3_new01_local);
7527  tolua_endmodule(tolua_S);
7528  #ifdef __cplusplus
7529  tolua_cclass(tolua_S,"StampedPoint","fawkes::tf::StampedPoint","fawkes::tf::Stamped<fawkes::tf::Point>",tolua_collect_fawkes__tf__StampedPoint);
7530  #else
7531  tolua_cclass(tolua_S,"StampedPoint","fawkes::tf::StampedPoint","fawkes::tf::Stamped<fawkes::tf::Point>",NULL);
7532  #endif
7533  tolua_beginmodule(tolua_S,"StampedPoint");
7534  tolua_function(tolua_S,"new",tolua_fawkestf_fawkes_tf_StampedPoint_new00);
7535  tolua_function(tolua_S,"new_local",tolua_fawkestf_fawkes_tf_StampedPoint_new00_local);
7536  tolua_function(tolua_S,".call",tolua_fawkestf_fawkes_tf_StampedPoint_new00_local);
7537  tolua_function(tolua_S,"new",tolua_fawkestf_fawkes_tf_StampedPoint_new01);
7538  tolua_function(tolua_S,"new_local",tolua_fawkestf_fawkes_tf_StampedPoint_new01_local);
7539  tolua_function(tolua_S,".call",tolua_fawkestf_fawkes_tf_StampedPoint_new01_local);
7540  tolua_endmodule(tolua_S);
7541  #ifdef __cplusplus
7542  tolua_cclass(tolua_S,"StampedPose","fawkes::tf::StampedPose","fawkes::tf::Stamped<fawkes::tf::Pose>",tolua_collect_fawkes__tf__StampedPose);
7543  #else
7544  tolua_cclass(tolua_S,"StampedPose","fawkes::tf::StampedPose","fawkes::tf::Stamped<fawkes::tf::Pose>",NULL);
7545  #endif
7546  tolua_beginmodule(tolua_S,"StampedPose");
7547  tolua_function(tolua_S,"new",tolua_fawkestf_fawkes_tf_StampedPose_new00);
7548  tolua_function(tolua_S,"new_local",tolua_fawkestf_fawkes_tf_StampedPose_new00_local);
7549  tolua_function(tolua_S,".call",tolua_fawkestf_fawkes_tf_StampedPose_new00_local);
7550  tolua_function(tolua_S,"new",tolua_fawkestf_fawkes_tf_StampedPose_new01);
7551  tolua_function(tolua_S,"new_local",tolua_fawkestf_fawkes_tf_StampedPose_new01_local);
7552  tolua_function(tolua_S,".call",tolua_fawkestf_fawkes_tf_StampedPose_new01_local);
7553  tolua_endmodule(tolua_S);
7554  tolua_cclass(tolua_S,"Transformer","fawkes::tf::Transformer","",NULL);
7555  tolua_beginmodule(tolua_S,"Transformer");
7556  tolua_function(tolua_S,"clear",tolua_fawkestf_fawkes_tf_Transformer_clear00);
7557  tolua_function(tolua_S,"frame_exists",tolua_fawkestf_fawkes_tf_Transformer_frame_exists00);
7558  tolua_function(tolua_S,"lookup_transform",tolua_fawkestf_fawkes_tf_Transformer_lookup_transform00);
7559  tolua_function(tolua_S,"lookup_transform",tolua_fawkestf_fawkes_tf_Transformer_lookup_transform01);
7560  tolua_function(tolua_S,"lookup_transform",tolua_fawkestf_fawkes_tf_Transformer_lookup_transform02);
7561  tolua_function(tolua_S,"can_transform",tolua_fawkestf_fawkes_tf_Transformer_can_transform00);
7562  tolua_function(tolua_S,"can_transform",tolua_fawkestf_fawkes_tf_Transformer_can_transform01);
7563  tolua_function(tolua_S,"transform_quaternion",tolua_fawkestf_fawkes_tf_Transformer_transform_quaternion00);
7564  tolua_function(tolua_S,"transform_vector",tolua_fawkestf_fawkes_tf_Transformer_transform_vector00);
7565  tolua_function(tolua_S,"transform_point",tolua_fawkestf_fawkes_tf_Transformer_transform_point00);
7566  tolua_function(tolua_S,"transform_pose",tolua_fawkestf_fawkes_tf_Transformer_transform_pose00);
7567  tolua_function(tolua_S,"transform_quaternion",tolua_fawkestf_fawkes_tf_Transformer_transform_quaternion01);
7568  tolua_function(tolua_S,"transform_vector",tolua_fawkestf_fawkes_tf_Transformer_transform_vector01);
7569  tolua_function(tolua_S,"transform_point",tolua_fawkestf_fawkes_tf_Transformer_transform_point01);
7570  tolua_function(tolua_S,"transform_pose",tolua_fawkestf_fawkes_tf_Transformer_transform_pose01);
7571  tolua_endmodule(tolua_S);
7572  tolua_endmodule(tolua_S);
7573  tolua_endmodule(tolua_S);
7574  tolua_endmodule(tolua_S);
7575  return 1;
7576 }
7577 
7578 
7579 extern "C" {
7580 #if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501
7581  TOLUA_API int luaopen_fawkestf (lua_State* tolua_S) {
7582  return tolua_fawkestf_open(tolua_S);
7583 };
7584 #endif
7585 }
7586 
7587 
A class for handling time.
Definition: time.h:91
Base class for exceptions in Fawkes.
Definition: exception.h:36
Transform that contains a timestamp and frame IDs.
Definition: types.h:96
virtual const char * what_no_backtrace() const
Get primary string (does not implicitly print the back trace).
Definition: exception.cpp:686
Wrapper class to add time stamp and frame ID to base types.
Definition: types.h:133
Coordinate transforms between any two frames in a system.
Definition: transformer.h:68