FacialExpressionInterface_tolua.cpp

00001 /*
00002 ** Lua binding: interfaces_FacialExpressionInterface
00003 ** Generated automatically by tolua++-1.0.92
00004 */
00005 /*  This program is free software; you can redistribute it and/or modify
00006  *  it under the terms of the GNU General Public License as published by
00007  *  the Free Software Foundation; either version 2 of the License, or
00008  *  (at your option) any later version. A runtime exception applies to
00009  *  this software (see LICENSE.GPL_WRE file mentioned below for details).
00010  *
00011  *  This program is distributed in the hope that it will be useful,
00012  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
00013  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00014  *  GNU Library General Public License for more details.
00015  *
00016  *  Read the full text in the LICENSE.GPL_WRE file in the doc directory.
00017  */
00018 
00019 #ifndef __cplusplus
00020 #include "stdlib.h"
00021 #endif
00022 #include "string.h"
00023 
00024 #include "tolua++.h"
00025 
00026 /* Exported function */
00027 TOLUA_API int  tolua_interfaces_FacialExpressionInterface_open (lua_State* tolua_S);
00028 
00029 #include <interfaces/FacialExpressionInterface.h>
00030 using namespace fawkes;
00031 
00032 /* function to release collected object via destructor */
00033 #ifdef __cplusplus
00034 
00035 static int tolua_collect_fawkes__FacialExpressionInterface__MoveEyesMessage (lua_State* tolua_S)
00036 {
00037  fawkes::FacialExpressionInterface::MoveEyesMessage* self = (fawkes::FacialExpressionInterface::MoveEyesMessage*) tolua_tousertype(tolua_S,1,0);
00038         Mtolua_delete(self);
00039         return 0;
00040 }
00041 
00042 static int tolua_collect_fawkes__FacialExpressionInterface__MoveJowlMessage (lua_State* tolua_S)
00043 {
00044  fawkes::FacialExpressionInterface::MoveJowlMessage* self = (fawkes::FacialExpressionInterface::MoveJowlMessage*) tolua_tousertype(tolua_S,1,0);
00045         Mtolua_delete(self);
00046         return 0;
00047 }
00048 
00049 static int tolua_collect_fawkes__FacialExpressionInterface__MoveMouthMessage (lua_State* tolua_S)
00050 {
00051  fawkes::FacialExpressionInterface::MoveMouthMessage* self = (fawkes::FacialExpressionInterface::MoveMouthMessage*) tolua_tousertype(tolua_S,1,0);
00052         Mtolua_delete(self);
00053         return 0;
00054 }
00055 
00056 static int tolua_collect_fawkes__FacialExpressionInterface__MoveBrowsMessage (lua_State* tolua_S)
00057 {
00058  fawkes::FacialExpressionInterface::MoveBrowsMessage* self = (fawkes::FacialExpressionInterface::MoveBrowsMessage*) tolua_tousertype(tolua_S,1,0);
00059         Mtolua_delete(self);
00060         return 0;
00061 }
00062 #endif
00063 
00064 
00065 /* function to register type */
00066 static void tolua_reg_types (lua_State* tolua_S)
00067 {
00068  tolua_usertype(tolua_S,"fawkes::FacialExpressionInterface::MoveBrowsMessage");
00069  tolua_usertype(tolua_S,"fawkes::FacialExpressionInterface::MoveJowlMessage");
00070  tolua_usertype(tolua_S,"fawkes::FacialExpressionInterface::MoveMouthMessage");
00071  tolua_usertype(tolua_S,"fawkes::FacialExpressionInterface");
00072  tolua_usertype(tolua_S,"fawkes::FacialExpressionInterface::MoveEyesMessage");
00073  tolua_usertype(tolua_S,"Message");
00074  tolua_usertype(tolua_S,"Interface");
00075 }
00076 
00077 /* method: new of class  MoveBrowsMessage */
00078 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveBrowsMessage_new00
00079 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveBrowsMessage_new00(lua_State* tolua_S)
00080 {
00081 #ifndef TOLUA_RELEASE
00082  tolua_Error tolua_err;
00083  if (
00084      !tolua_isusertable(tolua_S,1,"fawkes::FacialExpressionInterface::MoveBrowsMessage",0,&tolua_err) ||
00085      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00086      !tolua_isnoobj(tolua_S,3,&tolua_err)
00087  )
00088   goto tolua_lerror;
00089  else
00090 #endif
00091  {
00092   fawkes::FacialExpressionInterface::brows_t ini_brows_action = ((fawkes::FacialExpressionInterface::brows_t) (int)  tolua_tonumber(tolua_S,2,0));
00093   {
00094    fawkes::FacialExpressionInterface::MoveBrowsMessage* tolua_ret = (fawkes::FacialExpressionInterface::MoveBrowsMessage*)  Mtolua_new((fawkes::FacialExpressionInterface::MoveBrowsMessage)(ini_brows_action));
00095     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::FacialExpressionInterface::MoveBrowsMessage");
00096   }
00097  }
00098  return 1;
00099 #ifndef TOLUA_RELEASE
00100  tolua_lerror:
00101  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00102  return 0;
00103 #endif
00104 }
00105 #endif //#ifndef TOLUA_DISABLE
00106 
00107 /* method: new_local of class  MoveBrowsMessage */
00108 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveBrowsMessage_new00_local
00109 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveBrowsMessage_new00_local(lua_State* tolua_S)
00110 {
00111 #ifndef TOLUA_RELEASE
00112  tolua_Error tolua_err;
00113  if (
00114      !tolua_isusertable(tolua_S,1,"fawkes::FacialExpressionInterface::MoveBrowsMessage",0,&tolua_err) ||
00115      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00116      !tolua_isnoobj(tolua_S,3,&tolua_err)
00117  )
00118   goto tolua_lerror;
00119  else
00120 #endif
00121  {
00122   fawkes::FacialExpressionInterface::brows_t ini_brows_action = ((fawkes::FacialExpressionInterface::brows_t) (int)  tolua_tonumber(tolua_S,2,0));
00123   {
00124    fawkes::FacialExpressionInterface::MoveBrowsMessage* tolua_ret = (fawkes::FacialExpressionInterface::MoveBrowsMessage*)  Mtolua_new((fawkes::FacialExpressionInterface::MoveBrowsMessage)(ini_brows_action));
00125     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::FacialExpressionInterface::MoveBrowsMessage");
00126     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00127   }
00128  }
00129  return 1;
00130 #ifndef TOLUA_RELEASE
00131  tolua_lerror:
00132  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00133  return 0;
00134 #endif
00135 }
00136 #endif //#ifndef TOLUA_DISABLE
00137 
00138 /* method: new of class  MoveBrowsMessage */
00139 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveBrowsMessage_new01
00140 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveBrowsMessage_new01(lua_State* tolua_S)
00141 {
00142  tolua_Error tolua_err;
00143  if (
00144      !tolua_isusertable(tolua_S,1,"fawkes::FacialExpressionInterface::MoveBrowsMessage",0,&tolua_err) ||
00145      !tolua_isnoobj(tolua_S,2,&tolua_err)
00146  )
00147   goto tolua_lerror;
00148  else
00149  {
00150   {
00151    fawkes::FacialExpressionInterface::MoveBrowsMessage* tolua_ret = (fawkes::FacialExpressionInterface::MoveBrowsMessage*)  Mtolua_new((fawkes::FacialExpressionInterface::MoveBrowsMessage)());
00152     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::FacialExpressionInterface::MoveBrowsMessage");
00153   }
00154  }
00155  return 1;
00156 tolua_lerror:
00157  return tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveBrowsMessage_new00(tolua_S);
00158 }
00159 #endif //#ifndef TOLUA_DISABLE
00160 
00161 /* method: new_local of class  MoveBrowsMessage */
00162 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveBrowsMessage_new01_local
00163 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveBrowsMessage_new01_local(lua_State* tolua_S)
00164 {
00165  tolua_Error tolua_err;
00166  if (
00167      !tolua_isusertable(tolua_S,1,"fawkes::FacialExpressionInterface::MoveBrowsMessage",0,&tolua_err) ||
00168      !tolua_isnoobj(tolua_S,2,&tolua_err)
00169  )
00170   goto tolua_lerror;
00171  else
00172  {
00173   {
00174    fawkes::FacialExpressionInterface::MoveBrowsMessage* tolua_ret = (fawkes::FacialExpressionInterface::MoveBrowsMessage*)  Mtolua_new((fawkes::FacialExpressionInterface::MoveBrowsMessage)());
00175     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::FacialExpressionInterface::MoveBrowsMessage");
00176     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00177   }
00178  }
00179  return 1;
00180 tolua_lerror:
00181  return tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveBrowsMessage_new00_local(tolua_S);
00182 }
00183 #endif //#ifndef TOLUA_DISABLE
00184 
00185 /* method: delete of class  MoveBrowsMessage */
00186 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveBrowsMessage_delete00
00187 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveBrowsMessage_delete00(lua_State* tolua_S)
00188 {
00189 #ifndef TOLUA_RELEASE
00190  tolua_Error tolua_err;
00191  if (
00192      !tolua_isusertype(tolua_S,1,"fawkes::FacialExpressionInterface::MoveBrowsMessage",0,&tolua_err) ||
00193      !tolua_isnoobj(tolua_S,2,&tolua_err)
00194  )
00195   goto tolua_lerror;
00196  else
00197 #endif
00198  {
00199   fawkes::FacialExpressionInterface::MoveBrowsMessage* self = (fawkes::FacialExpressionInterface::MoveBrowsMessage*)  tolua_tousertype(tolua_S,1,0);
00200 #ifndef TOLUA_RELEASE
00201   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
00202 #endif
00203   Mtolua_delete(self);
00204  }
00205  return 0;
00206 #ifndef TOLUA_RELEASE
00207  tolua_lerror:
00208  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
00209  return 0;
00210 #endif
00211 }
00212 #endif //#ifndef TOLUA_DISABLE
00213 
00214 /* method: brows_action of class  MoveBrowsMessage */
00215 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveBrowsMessage_brows_action00
00216 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveBrowsMessage_brows_action00(lua_State* tolua_S)
00217 {
00218 #ifndef TOLUA_RELEASE
00219  tolua_Error tolua_err;
00220  if (
00221      !tolua_isusertype(tolua_S,1,"fawkes::FacialExpressionInterface::MoveBrowsMessage",0,&tolua_err) ||
00222      !tolua_isnoobj(tolua_S,2,&tolua_err)
00223  )
00224   goto tolua_lerror;
00225  else
00226 #endif
00227  {
00228   fawkes::FacialExpressionInterface::MoveBrowsMessage* self = (fawkes::FacialExpressionInterface::MoveBrowsMessage*)  tolua_tousertype(tolua_S,1,0);
00229 #ifndef TOLUA_RELEASE
00230   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'brows_action'", NULL);
00231 #endif
00232   {
00233    fawkes::FacialExpressionInterface::brows_t tolua_ret = (fawkes::FacialExpressionInterface::brows_t)  self->brows_action();
00234    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00235   }
00236  }
00237  return 1;
00238 #ifndef TOLUA_RELEASE
00239  tolua_lerror:
00240  tolua_error(tolua_S,"#ferror in function 'brows_action'.",&tolua_err);
00241  return 0;
00242 #endif
00243 }
00244 #endif //#ifndef TOLUA_DISABLE
00245 
00246 /* method: set_brows_action of class  MoveBrowsMessage */
00247 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveBrowsMessage_set_brows_action00
00248 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveBrowsMessage_set_brows_action00(lua_State* tolua_S)
00249 {
00250 #ifndef TOLUA_RELEASE
00251  tolua_Error tolua_err;
00252  if (
00253      !tolua_isusertype(tolua_S,1,"fawkes::FacialExpressionInterface::MoveBrowsMessage",0,&tolua_err) ||
00254      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00255      !tolua_isnoobj(tolua_S,3,&tolua_err)
00256  )
00257   goto tolua_lerror;
00258  else
00259 #endif
00260  {
00261   fawkes::FacialExpressionInterface::MoveBrowsMessage* self = (fawkes::FacialExpressionInterface::MoveBrowsMessage*)  tolua_tousertype(tolua_S,1,0);
00262   const fawkes::FacialExpressionInterface::brows_t new_brows_action = ((const fawkes::FacialExpressionInterface::brows_t) (int)  tolua_tonumber(tolua_S,2,0));
00263 #ifndef TOLUA_RELEASE
00264   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_brows_action'", NULL);
00265 #endif
00266   {
00267    self->set_brows_action(new_brows_action);
00268   }
00269  }
00270  return 0;
00271 #ifndef TOLUA_RELEASE
00272  tolua_lerror:
00273  tolua_error(tolua_S,"#ferror in function 'set_brows_action'.",&tolua_err);
00274  return 0;
00275 #endif
00276 }
00277 #endif //#ifndef TOLUA_DISABLE
00278 
00279 /* method: maxlenof_brows_action of class  MoveBrowsMessage */
00280 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveBrowsMessage_maxlenof_brows_action00
00281 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveBrowsMessage_maxlenof_brows_action00(lua_State* tolua_S)
00282 {
00283 #ifndef TOLUA_RELEASE
00284  tolua_Error tolua_err;
00285  if (
00286      !tolua_isusertype(tolua_S,1,"const fawkes::FacialExpressionInterface::MoveBrowsMessage",0,&tolua_err) ||
00287      !tolua_isnoobj(tolua_S,2,&tolua_err)
00288  )
00289   goto tolua_lerror;
00290  else
00291 #endif
00292  {
00293   const fawkes::FacialExpressionInterface::MoveBrowsMessage* self = (const fawkes::FacialExpressionInterface::MoveBrowsMessage*)  tolua_tousertype(tolua_S,1,0);
00294 #ifndef TOLUA_RELEASE
00295   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_brows_action'", NULL);
00296 #endif
00297   {
00298    int tolua_ret = (int)  self->maxlenof_brows_action();
00299    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00300   }
00301  }
00302  return 1;
00303 #ifndef TOLUA_RELEASE
00304  tolua_lerror:
00305  tolua_error(tolua_S,"#ferror in function 'maxlenof_brows_action'.",&tolua_err);
00306  return 0;
00307 #endif
00308 }
00309 #endif //#ifndef TOLUA_DISABLE
00310 
00311 /* method: new of class  MoveEyesMessage */
00312 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveEyesMessage_new00
00313 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveEyesMessage_new00(lua_State* tolua_S)
00314 {
00315 #ifndef TOLUA_RELEASE
00316  tolua_Error tolua_err;
00317  if (
00318      !tolua_isusertable(tolua_S,1,"fawkes::FacialExpressionInterface::MoveEyesMessage",0,&tolua_err) ||
00319      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00320      !tolua_isnoobj(tolua_S,3,&tolua_err)
00321  )
00322   goto tolua_lerror;
00323  else
00324 #endif
00325  {
00326   fawkes::FacialExpressionInterface::eyes_t ini_eyes_action = ((fawkes::FacialExpressionInterface::eyes_t) (int)  tolua_tonumber(tolua_S,2,0));
00327   {
00328    fawkes::FacialExpressionInterface::MoveEyesMessage* tolua_ret = (fawkes::FacialExpressionInterface::MoveEyesMessage*)  Mtolua_new((fawkes::FacialExpressionInterface::MoveEyesMessage)(ini_eyes_action));
00329     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::FacialExpressionInterface::MoveEyesMessage");
00330   }
00331  }
00332  return 1;
00333 #ifndef TOLUA_RELEASE
00334  tolua_lerror:
00335  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00336  return 0;
00337 #endif
00338 }
00339 #endif //#ifndef TOLUA_DISABLE
00340 
00341 /* method: new_local of class  MoveEyesMessage */
00342 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveEyesMessage_new00_local
00343 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveEyesMessage_new00_local(lua_State* tolua_S)
00344 {
00345 #ifndef TOLUA_RELEASE
00346  tolua_Error tolua_err;
00347  if (
00348      !tolua_isusertable(tolua_S,1,"fawkes::FacialExpressionInterface::MoveEyesMessage",0,&tolua_err) ||
00349      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00350      !tolua_isnoobj(tolua_S,3,&tolua_err)
00351  )
00352   goto tolua_lerror;
00353  else
00354 #endif
00355  {
00356   fawkes::FacialExpressionInterface::eyes_t ini_eyes_action = ((fawkes::FacialExpressionInterface::eyes_t) (int)  tolua_tonumber(tolua_S,2,0));
00357   {
00358    fawkes::FacialExpressionInterface::MoveEyesMessage* tolua_ret = (fawkes::FacialExpressionInterface::MoveEyesMessage*)  Mtolua_new((fawkes::FacialExpressionInterface::MoveEyesMessage)(ini_eyes_action));
00359     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::FacialExpressionInterface::MoveEyesMessage");
00360     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00361   }
00362  }
00363  return 1;
00364 #ifndef TOLUA_RELEASE
00365  tolua_lerror:
00366  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00367  return 0;
00368 #endif
00369 }
00370 #endif //#ifndef TOLUA_DISABLE
00371 
00372 /* method: new of class  MoveEyesMessage */
00373 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveEyesMessage_new01
00374 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveEyesMessage_new01(lua_State* tolua_S)
00375 {
00376  tolua_Error tolua_err;
00377  if (
00378      !tolua_isusertable(tolua_S,1,"fawkes::FacialExpressionInterface::MoveEyesMessage",0,&tolua_err) ||
00379      !tolua_isnoobj(tolua_S,2,&tolua_err)
00380  )
00381   goto tolua_lerror;
00382  else
00383  {
00384   {
00385    fawkes::FacialExpressionInterface::MoveEyesMessage* tolua_ret = (fawkes::FacialExpressionInterface::MoveEyesMessage*)  Mtolua_new((fawkes::FacialExpressionInterface::MoveEyesMessage)());
00386     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::FacialExpressionInterface::MoveEyesMessage");
00387   }
00388  }
00389  return 1;
00390 tolua_lerror:
00391  return tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveEyesMessage_new00(tolua_S);
00392 }
00393 #endif //#ifndef TOLUA_DISABLE
00394 
00395 /* method: new_local of class  MoveEyesMessage */
00396 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveEyesMessage_new01_local
00397 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveEyesMessage_new01_local(lua_State* tolua_S)
00398 {
00399  tolua_Error tolua_err;
00400  if (
00401      !tolua_isusertable(tolua_S,1,"fawkes::FacialExpressionInterface::MoveEyesMessage",0,&tolua_err) ||
00402      !tolua_isnoobj(tolua_S,2,&tolua_err)
00403  )
00404   goto tolua_lerror;
00405  else
00406  {
00407   {
00408    fawkes::FacialExpressionInterface::MoveEyesMessage* tolua_ret = (fawkes::FacialExpressionInterface::MoveEyesMessage*)  Mtolua_new((fawkes::FacialExpressionInterface::MoveEyesMessage)());
00409     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::FacialExpressionInterface::MoveEyesMessage");
00410     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00411   }
00412  }
00413  return 1;
00414 tolua_lerror:
00415  return tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveEyesMessage_new00_local(tolua_S);
00416 }
00417 #endif //#ifndef TOLUA_DISABLE
00418 
00419 /* method: delete of class  MoveEyesMessage */
00420 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveEyesMessage_delete00
00421 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveEyesMessage_delete00(lua_State* tolua_S)
00422 {
00423 #ifndef TOLUA_RELEASE
00424  tolua_Error tolua_err;
00425  if (
00426      !tolua_isusertype(tolua_S,1,"fawkes::FacialExpressionInterface::MoveEyesMessage",0,&tolua_err) ||
00427      !tolua_isnoobj(tolua_S,2,&tolua_err)
00428  )
00429   goto tolua_lerror;
00430  else
00431 #endif
00432  {
00433   fawkes::FacialExpressionInterface::MoveEyesMessage* self = (fawkes::FacialExpressionInterface::MoveEyesMessage*)  tolua_tousertype(tolua_S,1,0);
00434 #ifndef TOLUA_RELEASE
00435   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
00436 #endif
00437   Mtolua_delete(self);
00438  }
00439  return 0;
00440 #ifndef TOLUA_RELEASE
00441  tolua_lerror:
00442  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
00443  return 0;
00444 #endif
00445 }
00446 #endif //#ifndef TOLUA_DISABLE
00447 
00448 /* method: eyes_action of class  MoveEyesMessage */
00449 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveEyesMessage_eyes_action00
00450 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveEyesMessage_eyes_action00(lua_State* tolua_S)
00451 {
00452 #ifndef TOLUA_RELEASE
00453  tolua_Error tolua_err;
00454  if (
00455      !tolua_isusertype(tolua_S,1,"fawkes::FacialExpressionInterface::MoveEyesMessage",0,&tolua_err) ||
00456      !tolua_isnoobj(tolua_S,2,&tolua_err)
00457  )
00458   goto tolua_lerror;
00459  else
00460 #endif
00461  {
00462   fawkes::FacialExpressionInterface::MoveEyesMessage* self = (fawkes::FacialExpressionInterface::MoveEyesMessage*)  tolua_tousertype(tolua_S,1,0);
00463 #ifndef TOLUA_RELEASE
00464   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'eyes_action'", NULL);
00465 #endif
00466   {
00467    fawkes::FacialExpressionInterface::eyes_t tolua_ret = (fawkes::FacialExpressionInterface::eyes_t)  self->eyes_action();
00468    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00469   }
00470  }
00471  return 1;
00472 #ifndef TOLUA_RELEASE
00473  tolua_lerror:
00474  tolua_error(tolua_S,"#ferror in function 'eyes_action'.",&tolua_err);
00475  return 0;
00476 #endif
00477 }
00478 #endif //#ifndef TOLUA_DISABLE
00479 
00480 /* method: set_eyes_action of class  MoveEyesMessage */
00481 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveEyesMessage_set_eyes_action00
00482 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveEyesMessage_set_eyes_action00(lua_State* tolua_S)
00483 {
00484 #ifndef TOLUA_RELEASE
00485  tolua_Error tolua_err;
00486  if (
00487      !tolua_isusertype(tolua_S,1,"fawkes::FacialExpressionInterface::MoveEyesMessage",0,&tolua_err) ||
00488      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00489      !tolua_isnoobj(tolua_S,3,&tolua_err)
00490  )
00491   goto tolua_lerror;
00492  else
00493 #endif
00494  {
00495   fawkes::FacialExpressionInterface::MoveEyesMessage* self = (fawkes::FacialExpressionInterface::MoveEyesMessage*)  tolua_tousertype(tolua_S,1,0);
00496   const fawkes::FacialExpressionInterface::eyes_t new_eyes_action = ((const fawkes::FacialExpressionInterface::eyes_t) (int)  tolua_tonumber(tolua_S,2,0));
00497 #ifndef TOLUA_RELEASE
00498   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_eyes_action'", NULL);
00499 #endif
00500   {
00501    self->set_eyes_action(new_eyes_action);
00502   }
00503  }
00504  return 0;
00505 #ifndef TOLUA_RELEASE
00506  tolua_lerror:
00507  tolua_error(tolua_S,"#ferror in function 'set_eyes_action'.",&tolua_err);
00508  return 0;
00509 #endif
00510 }
00511 #endif //#ifndef TOLUA_DISABLE
00512 
00513 /* method: maxlenof_eyes_action of class  MoveEyesMessage */
00514 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveEyesMessage_maxlenof_eyes_action00
00515 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveEyesMessage_maxlenof_eyes_action00(lua_State* tolua_S)
00516 {
00517 #ifndef TOLUA_RELEASE
00518  tolua_Error tolua_err;
00519  if (
00520      !tolua_isusertype(tolua_S,1,"const fawkes::FacialExpressionInterface::MoveEyesMessage",0,&tolua_err) ||
00521      !tolua_isnoobj(tolua_S,2,&tolua_err)
00522  )
00523   goto tolua_lerror;
00524  else
00525 #endif
00526  {
00527   const fawkes::FacialExpressionInterface::MoveEyesMessage* self = (const fawkes::FacialExpressionInterface::MoveEyesMessage*)  tolua_tousertype(tolua_S,1,0);
00528 #ifndef TOLUA_RELEASE
00529   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_eyes_action'", NULL);
00530 #endif
00531   {
00532    int tolua_ret = (int)  self->maxlenof_eyes_action();
00533    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00534   }
00535  }
00536  return 1;
00537 #ifndef TOLUA_RELEASE
00538  tolua_lerror:
00539  tolua_error(tolua_S,"#ferror in function 'maxlenof_eyes_action'.",&tolua_err);
00540  return 0;
00541 #endif
00542 }
00543 #endif //#ifndef TOLUA_DISABLE
00544 
00545 /* method: new of class  MoveJowlMessage */
00546 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveJowlMessage_new00
00547 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveJowlMessage_new00(lua_State* tolua_S)
00548 {
00549 #ifndef TOLUA_RELEASE
00550  tolua_Error tolua_err;
00551  if (
00552      !tolua_isusertable(tolua_S,1,"fawkes::FacialExpressionInterface::MoveJowlMessage",0,&tolua_err) ||
00553      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00554      !tolua_isnoobj(tolua_S,3,&tolua_err)
00555  )
00556   goto tolua_lerror;
00557  else
00558 #endif
00559  {
00560   fawkes::FacialExpressionInterface::jowl_t ini_jowl_action = ((fawkes::FacialExpressionInterface::jowl_t) (int)  tolua_tonumber(tolua_S,2,0));
00561   {
00562    fawkes::FacialExpressionInterface::MoveJowlMessage* tolua_ret = (fawkes::FacialExpressionInterface::MoveJowlMessage*)  Mtolua_new((fawkes::FacialExpressionInterface::MoveJowlMessage)(ini_jowl_action));
00563     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::FacialExpressionInterface::MoveJowlMessage");
00564   }
00565  }
00566  return 1;
00567 #ifndef TOLUA_RELEASE
00568  tolua_lerror:
00569  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00570  return 0;
00571 #endif
00572 }
00573 #endif //#ifndef TOLUA_DISABLE
00574 
00575 /* method: new_local of class  MoveJowlMessage */
00576 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveJowlMessage_new00_local
00577 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveJowlMessage_new00_local(lua_State* tolua_S)
00578 {
00579 #ifndef TOLUA_RELEASE
00580  tolua_Error tolua_err;
00581  if (
00582      !tolua_isusertable(tolua_S,1,"fawkes::FacialExpressionInterface::MoveJowlMessage",0,&tolua_err) ||
00583      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00584      !tolua_isnoobj(tolua_S,3,&tolua_err)
00585  )
00586   goto tolua_lerror;
00587  else
00588 #endif
00589  {
00590   fawkes::FacialExpressionInterface::jowl_t ini_jowl_action = ((fawkes::FacialExpressionInterface::jowl_t) (int)  tolua_tonumber(tolua_S,2,0));
00591   {
00592    fawkes::FacialExpressionInterface::MoveJowlMessage* tolua_ret = (fawkes::FacialExpressionInterface::MoveJowlMessage*)  Mtolua_new((fawkes::FacialExpressionInterface::MoveJowlMessage)(ini_jowl_action));
00593     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::FacialExpressionInterface::MoveJowlMessage");
00594     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00595   }
00596  }
00597  return 1;
00598 #ifndef TOLUA_RELEASE
00599  tolua_lerror:
00600  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00601  return 0;
00602 #endif
00603 }
00604 #endif //#ifndef TOLUA_DISABLE
00605 
00606 /* method: new of class  MoveJowlMessage */
00607 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveJowlMessage_new01
00608 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveJowlMessage_new01(lua_State* tolua_S)
00609 {
00610  tolua_Error tolua_err;
00611  if (
00612      !tolua_isusertable(tolua_S,1,"fawkes::FacialExpressionInterface::MoveJowlMessage",0,&tolua_err) ||
00613      !tolua_isnoobj(tolua_S,2,&tolua_err)
00614  )
00615   goto tolua_lerror;
00616  else
00617  {
00618   {
00619    fawkes::FacialExpressionInterface::MoveJowlMessage* tolua_ret = (fawkes::FacialExpressionInterface::MoveJowlMessage*)  Mtolua_new((fawkes::FacialExpressionInterface::MoveJowlMessage)());
00620     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::FacialExpressionInterface::MoveJowlMessage");
00621   }
00622  }
00623  return 1;
00624 tolua_lerror:
00625  return tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveJowlMessage_new00(tolua_S);
00626 }
00627 #endif //#ifndef TOLUA_DISABLE
00628 
00629 /* method: new_local of class  MoveJowlMessage */
00630 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveJowlMessage_new01_local
00631 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveJowlMessage_new01_local(lua_State* tolua_S)
00632 {
00633  tolua_Error tolua_err;
00634  if (
00635      !tolua_isusertable(tolua_S,1,"fawkes::FacialExpressionInterface::MoveJowlMessage",0,&tolua_err) ||
00636      !tolua_isnoobj(tolua_S,2,&tolua_err)
00637  )
00638   goto tolua_lerror;
00639  else
00640  {
00641   {
00642    fawkes::FacialExpressionInterface::MoveJowlMessage* tolua_ret = (fawkes::FacialExpressionInterface::MoveJowlMessage*)  Mtolua_new((fawkes::FacialExpressionInterface::MoveJowlMessage)());
00643     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::FacialExpressionInterface::MoveJowlMessage");
00644     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00645   }
00646  }
00647  return 1;
00648 tolua_lerror:
00649  return tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveJowlMessage_new00_local(tolua_S);
00650 }
00651 #endif //#ifndef TOLUA_DISABLE
00652 
00653 /* method: delete of class  MoveJowlMessage */
00654 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveJowlMessage_delete00
00655 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveJowlMessage_delete00(lua_State* tolua_S)
00656 {
00657 #ifndef TOLUA_RELEASE
00658  tolua_Error tolua_err;
00659  if (
00660      !tolua_isusertype(tolua_S,1,"fawkes::FacialExpressionInterface::MoveJowlMessage",0,&tolua_err) ||
00661      !tolua_isnoobj(tolua_S,2,&tolua_err)
00662  )
00663   goto tolua_lerror;
00664  else
00665 #endif
00666  {
00667   fawkes::FacialExpressionInterface::MoveJowlMessage* self = (fawkes::FacialExpressionInterface::MoveJowlMessage*)  tolua_tousertype(tolua_S,1,0);
00668 #ifndef TOLUA_RELEASE
00669   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
00670 #endif
00671   Mtolua_delete(self);
00672  }
00673  return 0;
00674 #ifndef TOLUA_RELEASE
00675  tolua_lerror:
00676  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
00677  return 0;
00678 #endif
00679 }
00680 #endif //#ifndef TOLUA_DISABLE
00681 
00682 /* method: jowl_action of class  MoveJowlMessage */
00683 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveJowlMessage_jowl_action00
00684 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveJowlMessage_jowl_action00(lua_State* tolua_S)
00685 {
00686 #ifndef TOLUA_RELEASE
00687  tolua_Error tolua_err;
00688  if (
00689      !tolua_isusertype(tolua_S,1,"fawkes::FacialExpressionInterface::MoveJowlMessage",0,&tolua_err) ||
00690      !tolua_isnoobj(tolua_S,2,&tolua_err)
00691  )
00692   goto tolua_lerror;
00693  else
00694 #endif
00695  {
00696   fawkes::FacialExpressionInterface::MoveJowlMessage* self = (fawkes::FacialExpressionInterface::MoveJowlMessage*)  tolua_tousertype(tolua_S,1,0);
00697 #ifndef TOLUA_RELEASE
00698   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'jowl_action'", NULL);
00699 #endif
00700   {
00701    fawkes::FacialExpressionInterface::jowl_t tolua_ret = (fawkes::FacialExpressionInterface::jowl_t)  self->jowl_action();
00702    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00703   }
00704  }
00705  return 1;
00706 #ifndef TOLUA_RELEASE
00707  tolua_lerror:
00708  tolua_error(tolua_S,"#ferror in function 'jowl_action'.",&tolua_err);
00709  return 0;
00710 #endif
00711 }
00712 #endif //#ifndef TOLUA_DISABLE
00713 
00714 /* method: set_jowl_action of class  MoveJowlMessage */
00715 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveJowlMessage_set_jowl_action00
00716 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveJowlMessage_set_jowl_action00(lua_State* tolua_S)
00717 {
00718 #ifndef TOLUA_RELEASE
00719  tolua_Error tolua_err;
00720  if (
00721      !tolua_isusertype(tolua_S,1,"fawkes::FacialExpressionInterface::MoveJowlMessage",0,&tolua_err) ||
00722      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00723      !tolua_isnoobj(tolua_S,3,&tolua_err)
00724  )
00725   goto tolua_lerror;
00726  else
00727 #endif
00728  {
00729   fawkes::FacialExpressionInterface::MoveJowlMessage* self = (fawkes::FacialExpressionInterface::MoveJowlMessage*)  tolua_tousertype(tolua_S,1,0);
00730   const fawkes::FacialExpressionInterface::jowl_t new_jowl_action = ((const fawkes::FacialExpressionInterface::jowl_t) (int)  tolua_tonumber(tolua_S,2,0));
00731 #ifndef TOLUA_RELEASE
00732   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_jowl_action'", NULL);
00733 #endif
00734   {
00735    self->set_jowl_action(new_jowl_action);
00736   }
00737  }
00738  return 0;
00739 #ifndef TOLUA_RELEASE
00740  tolua_lerror:
00741  tolua_error(tolua_S,"#ferror in function 'set_jowl_action'.",&tolua_err);
00742  return 0;
00743 #endif
00744 }
00745 #endif //#ifndef TOLUA_DISABLE
00746 
00747 /* method: maxlenof_jowl_action of class  MoveJowlMessage */
00748 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveJowlMessage_maxlenof_jowl_action00
00749 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveJowlMessage_maxlenof_jowl_action00(lua_State* tolua_S)
00750 {
00751 #ifndef TOLUA_RELEASE
00752  tolua_Error tolua_err;
00753  if (
00754      !tolua_isusertype(tolua_S,1,"const fawkes::FacialExpressionInterface::MoveJowlMessage",0,&tolua_err) ||
00755      !tolua_isnoobj(tolua_S,2,&tolua_err)
00756  )
00757   goto tolua_lerror;
00758  else
00759 #endif
00760  {
00761   const fawkes::FacialExpressionInterface::MoveJowlMessage* self = (const fawkes::FacialExpressionInterface::MoveJowlMessage*)  tolua_tousertype(tolua_S,1,0);
00762 #ifndef TOLUA_RELEASE
00763   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_jowl_action'", NULL);
00764 #endif
00765   {
00766    int tolua_ret = (int)  self->maxlenof_jowl_action();
00767    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00768   }
00769  }
00770  return 1;
00771 #ifndef TOLUA_RELEASE
00772  tolua_lerror:
00773  tolua_error(tolua_S,"#ferror in function 'maxlenof_jowl_action'.",&tolua_err);
00774  return 0;
00775 #endif
00776 }
00777 #endif //#ifndef TOLUA_DISABLE
00778 
00779 /* method: new of class  MoveMouthMessage */
00780 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveMouthMessage_new00
00781 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveMouthMessage_new00(lua_State* tolua_S)
00782 {
00783 #ifndef TOLUA_RELEASE
00784  tolua_Error tolua_err;
00785  if (
00786      !tolua_isusertable(tolua_S,1,"fawkes::FacialExpressionInterface::MoveMouthMessage",0,&tolua_err) ||
00787      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00788      !tolua_isnoobj(tolua_S,3,&tolua_err)
00789  )
00790   goto tolua_lerror;
00791  else
00792 #endif
00793  {
00794   fawkes::FacialExpressionInterface::mouth_t ini_mouth_action = ((fawkes::FacialExpressionInterface::mouth_t) (int)  tolua_tonumber(tolua_S,2,0));
00795   {
00796    fawkes::FacialExpressionInterface::MoveMouthMessage* tolua_ret = (fawkes::FacialExpressionInterface::MoveMouthMessage*)  Mtolua_new((fawkes::FacialExpressionInterface::MoveMouthMessage)(ini_mouth_action));
00797     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::FacialExpressionInterface::MoveMouthMessage");
00798   }
00799  }
00800  return 1;
00801 #ifndef TOLUA_RELEASE
00802  tolua_lerror:
00803  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00804  return 0;
00805 #endif
00806 }
00807 #endif //#ifndef TOLUA_DISABLE
00808 
00809 /* method: new_local of class  MoveMouthMessage */
00810 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveMouthMessage_new00_local
00811 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveMouthMessage_new00_local(lua_State* tolua_S)
00812 {
00813 #ifndef TOLUA_RELEASE
00814  tolua_Error tolua_err;
00815  if (
00816      !tolua_isusertable(tolua_S,1,"fawkes::FacialExpressionInterface::MoveMouthMessage",0,&tolua_err) ||
00817      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00818      !tolua_isnoobj(tolua_S,3,&tolua_err)
00819  )
00820   goto tolua_lerror;
00821  else
00822 #endif
00823  {
00824   fawkes::FacialExpressionInterface::mouth_t ini_mouth_action = ((fawkes::FacialExpressionInterface::mouth_t) (int)  tolua_tonumber(tolua_S,2,0));
00825   {
00826    fawkes::FacialExpressionInterface::MoveMouthMessage* tolua_ret = (fawkes::FacialExpressionInterface::MoveMouthMessage*)  Mtolua_new((fawkes::FacialExpressionInterface::MoveMouthMessage)(ini_mouth_action));
00827     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::FacialExpressionInterface::MoveMouthMessage");
00828     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00829   }
00830  }
00831  return 1;
00832 #ifndef TOLUA_RELEASE
00833  tolua_lerror:
00834  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00835  return 0;
00836 #endif
00837 }
00838 #endif //#ifndef TOLUA_DISABLE
00839 
00840 /* method: new of class  MoveMouthMessage */
00841 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveMouthMessage_new01
00842 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveMouthMessage_new01(lua_State* tolua_S)
00843 {
00844  tolua_Error tolua_err;
00845  if (
00846      !tolua_isusertable(tolua_S,1,"fawkes::FacialExpressionInterface::MoveMouthMessage",0,&tolua_err) ||
00847      !tolua_isnoobj(tolua_S,2,&tolua_err)
00848  )
00849   goto tolua_lerror;
00850  else
00851  {
00852   {
00853    fawkes::FacialExpressionInterface::MoveMouthMessage* tolua_ret = (fawkes::FacialExpressionInterface::MoveMouthMessage*)  Mtolua_new((fawkes::FacialExpressionInterface::MoveMouthMessage)());
00854     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::FacialExpressionInterface::MoveMouthMessage");
00855   }
00856  }
00857  return 1;
00858 tolua_lerror:
00859  return tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveMouthMessage_new00(tolua_S);
00860 }
00861 #endif //#ifndef TOLUA_DISABLE
00862 
00863 /* method: new_local of class  MoveMouthMessage */
00864 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveMouthMessage_new01_local
00865 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveMouthMessage_new01_local(lua_State* tolua_S)
00866 {
00867  tolua_Error tolua_err;
00868  if (
00869      !tolua_isusertable(tolua_S,1,"fawkes::FacialExpressionInterface::MoveMouthMessage",0,&tolua_err) ||
00870      !tolua_isnoobj(tolua_S,2,&tolua_err)
00871  )
00872   goto tolua_lerror;
00873  else
00874  {
00875   {
00876    fawkes::FacialExpressionInterface::MoveMouthMessage* tolua_ret = (fawkes::FacialExpressionInterface::MoveMouthMessage*)  Mtolua_new((fawkes::FacialExpressionInterface::MoveMouthMessage)());
00877     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::FacialExpressionInterface::MoveMouthMessage");
00878     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00879   }
00880  }
00881  return 1;
00882 tolua_lerror:
00883  return tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveMouthMessage_new00_local(tolua_S);
00884 }
00885 #endif //#ifndef TOLUA_DISABLE
00886 
00887 /* method: delete of class  MoveMouthMessage */
00888 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveMouthMessage_delete00
00889 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveMouthMessage_delete00(lua_State* tolua_S)
00890 {
00891 #ifndef TOLUA_RELEASE
00892  tolua_Error tolua_err;
00893  if (
00894      !tolua_isusertype(tolua_S,1,"fawkes::FacialExpressionInterface::MoveMouthMessage",0,&tolua_err) ||
00895      !tolua_isnoobj(tolua_S,2,&tolua_err)
00896  )
00897   goto tolua_lerror;
00898  else
00899 #endif
00900  {
00901   fawkes::FacialExpressionInterface::MoveMouthMessage* self = (fawkes::FacialExpressionInterface::MoveMouthMessage*)  tolua_tousertype(tolua_S,1,0);
00902 #ifndef TOLUA_RELEASE
00903   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
00904 #endif
00905   Mtolua_delete(self);
00906  }
00907  return 0;
00908 #ifndef TOLUA_RELEASE
00909  tolua_lerror:
00910  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
00911  return 0;
00912 #endif
00913 }
00914 #endif //#ifndef TOLUA_DISABLE
00915 
00916 /* method: mouth_action of class  MoveMouthMessage */
00917 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveMouthMessage_mouth_action00
00918 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveMouthMessage_mouth_action00(lua_State* tolua_S)
00919 {
00920 #ifndef TOLUA_RELEASE
00921  tolua_Error tolua_err;
00922  if (
00923      !tolua_isusertype(tolua_S,1,"fawkes::FacialExpressionInterface::MoveMouthMessage",0,&tolua_err) ||
00924      !tolua_isnoobj(tolua_S,2,&tolua_err)
00925  )
00926   goto tolua_lerror;
00927  else
00928 #endif
00929  {
00930   fawkes::FacialExpressionInterface::MoveMouthMessage* self = (fawkes::FacialExpressionInterface::MoveMouthMessage*)  tolua_tousertype(tolua_S,1,0);
00931 #ifndef TOLUA_RELEASE
00932   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'mouth_action'", NULL);
00933 #endif
00934   {
00935    fawkes::FacialExpressionInterface::mouth_t tolua_ret = (fawkes::FacialExpressionInterface::mouth_t)  self->mouth_action();
00936    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00937   }
00938  }
00939  return 1;
00940 #ifndef TOLUA_RELEASE
00941  tolua_lerror:
00942  tolua_error(tolua_S,"#ferror in function 'mouth_action'.",&tolua_err);
00943  return 0;
00944 #endif
00945 }
00946 #endif //#ifndef TOLUA_DISABLE
00947 
00948 /* method: set_mouth_action of class  MoveMouthMessage */
00949 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveMouthMessage_set_mouth_action00
00950 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveMouthMessage_set_mouth_action00(lua_State* tolua_S)
00951 {
00952 #ifndef TOLUA_RELEASE
00953  tolua_Error tolua_err;
00954  if (
00955      !tolua_isusertype(tolua_S,1,"fawkes::FacialExpressionInterface::MoveMouthMessage",0,&tolua_err) ||
00956      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00957      !tolua_isnoobj(tolua_S,3,&tolua_err)
00958  )
00959   goto tolua_lerror;
00960  else
00961 #endif
00962  {
00963   fawkes::FacialExpressionInterface::MoveMouthMessage* self = (fawkes::FacialExpressionInterface::MoveMouthMessage*)  tolua_tousertype(tolua_S,1,0);
00964   const fawkes::FacialExpressionInterface::mouth_t new_mouth_action = ((const fawkes::FacialExpressionInterface::mouth_t) (int)  tolua_tonumber(tolua_S,2,0));
00965 #ifndef TOLUA_RELEASE
00966   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_mouth_action'", NULL);
00967 #endif
00968   {
00969    self->set_mouth_action(new_mouth_action);
00970   }
00971  }
00972  return 0;
00973 #ifndef TOLUA_RELEASE
00974  tolua_lerror:
00975  tolua_error(tolua_S,"#ferror in function 'set_mouth_action'.",&tolua_err);
00976  return 0;
00977 #endif
00978 }
00979 #endif //#ifndef TOLUA_DISABLE
00980 
00981 /* method: maxlenof_mouth_action of class  MoveMouthMessage */
00982 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveMouthMessage_maxlenof_mouth_action00
00983 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveMouthMessage_maxlenof_mouth_action00(lua_State* tolua_S)
00984 {
00985 #ifndef TOLUA_RELEASE
00986  tolua_Error tolua_err;
00987  if (
00988      !tolua_isusertype(tolua_S,1,"const fawkes::FacialExpressionInterface::MoveMouthMessage",0,&tolua_err) ||
00989      !tolua_isnoobj(tolua_S,2,&tolua_err)
00990  )
00991   goto tolua_lerror;
00992  else
00993 #endif
00994  {
00995   const fawkes::FacialExpressionInterface::MoveMouthMessage* self = (const fawkes::FacialExpressionInterface::MoveMouthMessage*)  tolua_tousertype(tolua_S,1,0);
00996 #ifndef TOLUA_RELEASE
00997   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_mouth_action'", NULL);
00998 #endif
00999   {
01000    int tolua_ret = (int)  self->maxlenof_mouth_action();
01001    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01002   }
01003  }
01004  return 1;
01005 #ifndef TOLUA_RELEASE
01006  tolua_lerror:
01007  tolua_error(tolua_S,"#ferror in function 'maxlenof_mouth_action'.",&tolua_err);
01008  return 0;
01009 #endif
01010 }
01011 #endif //#ifndef TOLUA_DISABLE
01012 
01013 /* method: brows_action of class  fawkes::FacialExpressionInterface */
01014 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_brows_action00
01015 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_brows_action00(lua_State* tolua_S)
01016 {
01017 #ifndef TOLUA_RELEASE
01018  tolua_Error tolua_err;
01019  if (
01020      !tolua_isusertype(tolua_S,1,"fawkes::FacialExpressionInterface",0,&tolua_err) ||
01021      !tolua_isnoobj(tolua_S,2,&tolua_err)
01022  )
01023   goto tolua_lerror;
01024  else
01025 #endif
01026  {
01027   fawkes::FacialExpressionInterface* self = (fawkes::FacialExpressionInterface*)  tolua_tousertype(tolua_S,1,0);
01028 #ifndef TOLUA_RELEASE
01029   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'brows_action'", NULL);
01030 #endif
01031   {
01032    fawkes::FacialExpressionInterface::brows_t tolua_ret = (fawkes::FacialExpressionInterface::brows_t)  self->brows_action();
01033    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01034   }
01035  }
01036  return 1;
01037 #ifndef TOLUA_RELEASE
01038  tolua_lerror:
01039  tolua_error(tolua_S,"#ferror in function 'brows_action'.",&tolua_err);
01040  return 0;
01041 #endif
01042 }
01043 #endif //#ifndef TOLUA_DISABLE
01044 
01045 /* method: set_brows_action of class  fawkes::FacialExpressionInterface */
01046 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_set_brows_action00
01047 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_set_brows_action00(lua_State* tolua_S)
01048 {
01049 #ifndef TOLUA_RELEASE
01050  tolua_Error tolua_err;
01051  if (
01052      !tolua_isusertype(tolua_S,1,"fawkes::FacialExpressionInterface",0,&tolua_err) ||
01053      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01054      !tolua_isnoobj(tolua_S,3,&tolua_err)
01055  )
01056   goto tolua_lerror;
01057  else
01058 #endif
01059  {
01060   fawkes::FacialExpressionInterface* self = (fawkes::FacialExpressionInterface*)  tolua_tousertype(tolua_S,1,0);
01061   const fawkes::FacialExpressionInterface::brows_t new_brows_action = ((const fawkes::FacialExpressionInterface::brows_t) (int)  tolua_tonumber(tolua_S,2,0));
01062 #ifndef TOLUA_RELEASE
01063   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_brows_action'", NULL);
01064 #endif
01065   {
01066    self->set_brows_action(new_brows_action);
01067   }
01068  }
01069  return 0;
01070 #ifndef TOLUA_RELEASE
01071  tolua_lerror:
01072  tolua_error(tolua_S,"#ferror in function 'set_brows_action'.",&tolua_err);
01073  return 0;
01074 #endif
01075 }
01076 #endif //#ifndef TOLUA_DISABLE
01077 
01078 /* method: maxlenof_brows_action of class  fawkes::FacialExpressionInterface */
01079 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_maxlenof_brows_action00
01080 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_maxlenof_brows_action00(lua_State* tolua_S)
01081 {
01082 #ifndef TOLUA_RELEASE
01083  tolua_Error tolua_err;
01084  if (
01085      !tolua_isusertype(tolua_S,1,"const fawkes::FacialExpressionInterface",0,&tolua_err) ||
01086      !tolua_isnoobj(tolua_S,2,&tolua_err)
01087  )
01088   goto tolua_lerror;
01089  else
01090 #endif
01091  {
01092   const fawkes::FacialExpressionInterface* self = (const fawkes::FacialExpressionInterface*)  tolua_tousertype(tolua_S,1,0);
01093 #ifndef TOLUA_RELEASE
01094   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_brows_action'", NULL);
01095 #endif
01096   {
01097    int tolua_ret = (int)  self->maxlenof_brows_action();
01098    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01099   }
01100  }
01101  return 1;
01102 #ifndef TOLUA_RELEASE
01103  tolua_lerror:
01104  tolua_error(tolua_S,"#ferror in function 'maxlenof_brows_action'.",&tolua_err);
01105  return 0;
01106 #endif
01107 }
01108 #endif //#ifndef TOLUA_DISABLE
01109 
01110 /* method: eyes_action of class  fawkes::FacialExpressionInterface */
01111 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_eyes_action00
01112 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_eyes_action00(lua_State* tolua_S)
01113 {
01114 #ifndef TOLUA_RELEASE
01115  tolua_Error tolua_err;
01116  if (
01117      !tolua_isusertype(tolua_S,1,"fawkes::FacialExpressionInterface",0,&tolua_err) ||
01118      !tolua_isnoobj(tolua_S,2,&tolua_err)
01119  )
01120   goto tolua_lerror;
01121  else
01122 #endif
01123  {
01124   fawkes::FacialExpressionInterface* self = (fawkes::FacialExpressionInterface*)  tolua_tousertype(tolua_S,1,0);
01125 #ifndef TOLUA_RELEASE
01126   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'eyes_action'", NULL);
01127 #endif
01128   {
01129    fawkes::FacialExpressionInterface::eyes_t tolua_ret = (fawkes::FacialExpressionInterface::eyes_t)  self->eyes_action();
01130    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01131   }
01132  }
01133  return 1;
01134 #ifndef TOLUA_RELEASE
01135  tolua_lerror:
01136  tolua_error(tolua_S,"#ferror in function 'eyes_action'.",&tolua_err);
01137  return 0;
01138 #endif
01139 }
01140 #endif //#ifndef TOLUA_DISABLE
01141 
01142 /* method: set_eyes_action of class  fawkes::FacialExpressionInterface */
01143 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_set_eyes_action00
01144 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_set_eyes_action00(lua_State* tolua_S)
01145 {
01146 #ifndef TOLUA_RELEASE
01147  tolua_Error tolua_err;
01148  if (
01149      !tolua_isusertype(tolua_S,1,"fawkes::FacialExpressionInterface",0,&tolua_err) ||
01150      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01151      !tolua_isnoobj(tolua_S,3,&tolua_err)
01152  )
01153   goto tolua_lerror;
01154  else
01155 #endif
01156  {
01157   fawkes::FacialExpressionInterface* self = (fawkes::FacialExpressionInterface*)  tolua_tousertype(tolua_S,1,0);
01158   const fawkes::FacialExpressionInterface::eyes_t new_eyes_action = ((const fawkes::FacialExpressionInterface::eyes_t) (int)  tolua_tonumber(tolua_S,2,0));
01159 #ifndef TOLUA_RELEASE
01160   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_eyes_action'", NULL);
01161 #endif
01162   {
01163    self->set_eyes_action(new_eyes_action);
01164   }
01165  }
01166  return 0;
01167 #ifndef TOLUA_RELEASE
01168  tolua_lerror:
01169  tolua_error(tolua_S,"#ferror in function 'set_eyes_action'.",&tolua_err);
01170  return 0;
01171 #endif
01172 }
01173 #endif //#ifndef TOLUA_DISABLE
01174 
01175 /* method: maxlenof_eyes_action of class  fawkes::FacialExpressionInterface */
01176 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_maxlenof_eyes_action00
01177 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_maxlenof_eyes_action00(lua_State* tolua_S)
01178 {
01179 #ifndef TOLUA_RELEASE
01180  tolua_Error tolua_err;
01181  if (
01182      !tolua_isusertype(tolua_S,1,"const fawkes::FacialExpressionInterface",0,&tolua_err) ||
01183      !tolua_isnoobj(tolua_S,2,&tolua_err)
01184  )
01185   goto tolua_lerror;
01186  else
01187 #endif
01188  {
01189   const fawkes::FacialExpressionInterface* self = (const fawkes::FacialExpressionInterface*)  tolua_tousertype(tolua_S,1,0);
01190 #ifndef TOLUA_RELEASE
01191   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_eyes_action'", NULL);
01192 #endif
01193   {
01194    int tolua_ret = (int)  self->maxlenof_eyes_action();
01195    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01196   }
01197  }
01198  return 1;
01199 #ifndef TOLUA_RELEASE
01200  tolua_lerror:
01201  tolua_error(tolua_S,"#ferror in function 'maxlenof_eyes_action'.",&tolua_err);
01202  return 0;
01203 #endif
01204 }
01205 #endif //#ifndef TOLUA_DISABLE
01206 
01207 /* method: jowl_action of class  fawkes::FacialExpressionInterface */
01208 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_jowl_action00
01209 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_jowl_action00(lua_State* tolua_S)
01210 {
01211 #ifndef TOLUA_RELEASE
01212  tolua_Error tolua_err;
01213  if (
01214      !tolua_isusertype(tolua_S,1,"fawkes::FacialExpressionInterface",0,&tolua_err) ||
01215      !tolua_isnoobj(tolua_S,2,&tolua_err)
01216  )
01217   goto tolua_lerror;
01218  else
01219 #endif
01220  {
01221   fawkes::FacialExpressionInterface* self = (fawkes::FacialExpressionInterface*)  tolua_tousertype(tolua_S,1,0);
01222 #ifndef TOLUA_RELEASE
01223   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'jowl_action'", NULL);
01224 #endif
01225   {
01226    fawkes::FacialExpressionInterface::jowl_t tolua_ret = (fawkes::FacialExpressionInterface::jowl_t)  self->jowl_action();
01227    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01228   }
01229  }
01230  return 1;
01231 #ifndef TOLUA_RELEASE
01232  tolua_lerror:
01233  tolua_error(tolua_S,"#ferror in function 'jowl_action'.",&tolua_err);
01234  return 0;
01235 #endif
01236 }
01237 #endif //#ifndef TOLUA_DISABLE
01238 
01239 /* method: set_jowl_action of class  fawkes::FacialExpressionInterface */
01240 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_set_jowl_action00
01241 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_set_jowl_action00(lua_State* tolua_S)
01242 {
01243 #ifndef TOLUA_RELEASE
01244  tolua_Error tolua_err;
01245  if (
01246      !tolua_isusertype(tolua_S,1,"fawkes::FacialExpressionInterface",0,&tolua_err) ||
01247      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01248      !tolua_isnoobj(tolua_S,3,&tolua_err)
01249  )
01250   goto tolua_lerror;
01251  else
01252 #endif
01253  {
01254   fawkes::FacialExpressionInterface* self = (fawkes::FacialExpressionInterface*)  tolua_tousertype(tolua_S,1,0);
01255   const fawkes::FacialExpressionInterface::jowl_t new_jowl_action = ((const fawkes::FacialExpressionInterface::jowl_t) (int)  tolua_tonumber(tolua_S,2,0));
01256 #ifndef TOLUA_RELEASE
01257   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_jowl_action'", NULL);
01258 #endif
01259   {
01260    self->set_jowl_action(new_jowl_action);
01261   }
01262  }
01263  return 0;
01264 #ifndef TOLUA_RELEASE
01265  tolua_lerror:
01266  tolua_error(tolua_S,"#ferror in function 'set_jowl_action'.",&tolua_err);
01267  return 0;
01268 #endif
01269 }
01270 #endif //#ifndef TOLUA_DISABLE
01271 
01272 /* method: maxlenof_jowl_action of class  fawkes::FacialExpressionInterface */
01273 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_maxlenof_jowl_action00
01274 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_maxlenof_jowl_action00(lua_State* tolua_S)
01275 {
01276 #ifndef TOLUA_RELEASE
01277  tolua_Error tolua_err;
01278  if (
01279      !tolua_isusertype(tolua_S,1,"const fawkes::FacialExpressionInterface",0,&tolua_err) ||
01280      !tolua_isnoobj(tolua_S,2,&tolua_err)
01281  )
01282   goto tolua_lerror;
01283  else
01284 #endif
01285  {
01286   const fawkes::FacialExpressionInterface* self = (const fawkes::FacialExpressionInterface*)  tolua_tousertype(tolua_S,1,0);
01287 #ifndef TOLUA_RELEASE
01288   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_jowl_action'", NULL);
01289 #endif
01290   {
01291    int tolua_ret = (int)  self->maxlenof_jowl_action();
01292    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01293   }
01294  }
01295  return 1;
01296 #ifndef TOLUA_RELEASE
01297  tolua_lerror:
01298  tolua_error(tolua_S,"#ferror in function 'maxlenof_jowl_action'.",&tolua_err);
01299  return 0;
01300 #endif
01301 }
01302 #endif //#ifndef TOLUA_DISABLE
01303 
01304 /* method: mouth_action of class  fawkes::FacialExpressionInterface */
01305 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_mouth_action00
01306 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_mouth_action00(lua_State* tolua_S)
01307 {
01308 #ifndef TOLUA_RELEASE
01309  tolua_Error tolua_err;
01310  if (
01311      !tolua_isusertype(tolua_S,1,"fawkes::FacialExpressionInterface",0,&tolua_err) ||
01312      !tolua_isnoobj(tolua_S,2,&tolua_err)
01313  )
01314   goto tolua_lerror;
01315  else
01316 #endif
01317  {
01318   fawkes::FacialExpressionInterface* self = (fawkes::FacialExpressionInterface*)  tolua_tousertype(tolua_S,1,0);
01319 #ifndef TOLUA_RELEASE
01320   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'mouth_action'", NULL);
01321 #endif
01322   {
01323    fawkes::FacialExpressionInterface::mouth_t tolua_ret = (fawkes::FacialExpressionInterface::mouth_t)  self->mouth_action();
01324    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01325   }
01326  }
01327  return 1;
01328 #ifndef TOLUA_RELEASE
01329  tolua_lerror:
01330  tolua_error(tolua_S,"#ferror in function 'mouth_action'.",&tolua_err);
01331  return 0;
01332 #endif
01333 }
01334 #endif //#ifndef TOLUA_DISABLE
01335 
01336 /* method: set_mouth_action of class  fawkes::FacialExpressionInterface */
01337 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_set_mouth_action00
01338 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_set_mouth_action00(lua_State* tolua_S)
01339 {
01340 #ifndef TOLUA_RELEASE
01341  tolua_Error tolua_err;
01342  if (
01343      !tolua_isusertype(tolua_S,1,"fawkes::FacialExpressionInterface",0,&tolua_err) ||
01344      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01345      !tolua_isnoobj(tolua_S,3,&tolua_err)
01346  )
01347   goto tolua_lerror;
01348  else
01349 #endif
01350  {
01351   fawkes::FacialExpressionInterface* self = (fawkes::FacialExpressionInterface*)  tolua_tousertype(tolua_S,1,0);
01352   const fawkes::FacialExpressionInterface::mouth_t new_mouth_action = ((const fawkes::FacialExpressionInterface::mouth_t) (int)  tolua_tonumber(tolua_S,2,0));
01353 #ifndef TOLUA_RELEASE
01354   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_mouth_action'", NULL);
01355 #endif
01356   {
01357    self->set_mouth_action(new_mouth_action);
01358   }
01359  }
01360  return 0;
01361 #ifndef TOLUA_RELEASE
01362  tolua_lerror:
01363  tolua_error(tolua_S,"#ferror in function 'set_mouth_action'.",&tolua_err);
01364  return 0;
01365 #endif
01366 }
01367 #endif //#ifndef TOLUA_DISABLE
01368 
01369 /* method: maxlenof_mouth_action of class  fawkes::FacialExpressionInterface */
01370 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_maxlenof_mouth_action00
01371 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_maxlenof_mouth_action00(lua_State* tolua_S)
01372 {
01373 #ifndef TOLUA_RELEASE
01374  tolua_Error tolua_err;
01375  if (
01376      !tolua_isusertype(tolua_S,1,"const fawkes::FacialExpressionInterface",0,&tolua_err) ||
01377      !tolua_isnoobj(tolua_S,2,&tolua_err)
01378  )
01379   goto tolua_lerror;
01380  else
01381 #endif
01382  {
01383   const fawkes::FacialExpressionInterface* self = (const fawkes::FacialExpressionInterface*)  tolua_tousertype(tolua_S,1,0);
01384 #ifndef TOLUA_RELEASE
01385   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_mouth_action'", NULL);
01386 #endif
01387   {
01388    int tolua_ret = (int)  self->maxlenof_mouth_action();
01389    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01390   }
01391  }
01392  return 1;
01393 #ifndef TOLUA_RELEASE
01394  tolua_lerror:
01395  tolua_error(tolua_S,"#ferror in function 'maxlenof_mouth_action'.",&tolua_err);
01396  return 0;
01397 #endif
01398 }
01399 #endif //#ifndef TOLUA_DISABLE
01400 
01401 /* method: oftype of class  fawkes::FacialExpressionInterface */
01402 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_oftype00
01403 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_oftype00(lua_State* tolua_S)
01404 {
01405 #ifndef TOLUA_RELEASE
01406  tolua_Error tolua_err;
01407  if (
01408      !tolua_isusertype(tolua_S,1,"const fawkes::FacialExpressionInterface",0,&tolua_err) ||
01409      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
01410      !tolua_isnoobj(tolua_S,3,&tolua_err)
01411  )
01412   goto tolua_lerror;
01413  else
01414 #endif
01415  {
01416   const fawkes::FacialExpressionInterface* self = (const fawkes::FacialExpressionInterface*)  tolua_tousertype(tolua_S,1,0);
01417   const char* interface_type = ((const char*)  tolua_tostring(tolua_S,2,0));
01418 #ifndef TOLUA_RELEASE
01419   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'oftype'", NULL);
01420 #endif
01421   {
01422    bool tolua_ret = (bool)  self->oftype(interface_type);
01423    tolua_pushboolean(tolua_S,(bool)tolua_ret);
01424   }
01425  }
01426  return 1;
01427 #ifndef TOLUA_RELEASE
01428  tolua_lerror:
01429  tolua_error(tolua_S,"#ferror in function 'oftype'.",&tolua_err);
01430  return 0;
01431 #endif
01432 }
01433 #endif //#ifndef TOLUA_DISABLE
01434 
01435 /* method: datachunk of class  fawkes::FacialExpressionInterface */
01436 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_datachunk00
01437 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_datachunk00(lua_State* tolua_S)
01438 {
01439 #ifndef TOLUA_RELEASE
01440  tolua_Error tolua_err;
01441  if (
01442      !tolua_isusertype(tolua_S,1,"const fawkes::FacialExpressionInterface",0,&tolua_err) ||
01443      !tolua_isnoobj(tolua_S,2,&tolua_err)
01444  )
01445   goto tolua_lerror;
01446  else
01447 #endif
01448  {
01449   const fawkes::FacialExpressionInterface* self = (const fawkes::FacialExpressionInterface*)  tolua_tousertype(tolua_S,1,0);
01450 #ifndef TOLUA_RELEASE
01451   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datachunk'", NULL);
01452 #endif
01453   {
01454    const void* tolua_ret = (const void*)  self->datachunk();
01455    tolua_pushuserdata(tolua_S,(void*)tolua_ret);
01456   }
01457  }
01458  return 1;
01459 #ifndef TOLUA_RELEASE
01460  tolua_lerror:
01461  tolua_error(tolua_S,"#ferror in function 'datachunk'.",&tolua_err);
01462  return 0;
01463 #endif
01464 }
01465 #endif //#ifndef TOLUA_DISABLE
01466 
01467 /* method: datasize of class  fawkes::FacialExpressionInterface */
01468 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_datasize00
01469 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_datasize00(lua_State* tolua_S)
01470 {
01471 #ifndef TOLUA_RELEASE
01472  tolua_Error tolua_err;
01473  if (
01474      !tolua_isusertype(tolua_S,1,"const fawkes::FacialExpressionInterface",0,&tolua_err) ||
01475      !tolua_isnoobj(tolua_S,2,&tolua_err)
01476  )
01477   goto tolua_lerror;
01478  else
01479 #endif
01480  {
01481   const fawkes::FacialExpressionInterface* self = (const fawkes::FacialExpressionInterface*)  tolua_tousertype(tolua_S,1,0);
01482 #ifndef TOLUA_RELEASE
01483   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datasize'", NULL);
01484 #endif
01485   {
01486    unsigned int tolua_ret = (unsigned int)  self->datasize();
01487    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01488   }
01489  }
01490  return 1;
01491 #ifndef TOLUA_RELEASE
01492  tolua_lerror:
01493  tolua_error(tolua_S,"#ferror in function 'datasize'.",&tolua_err);
01494  return 0;
01495 #endif
01496 }
01497 #endif //#ifndef TOLUA_DISABLE
01498 
01499 /* method: type of class  fawkes::FacialExpressionInterface */
01500 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_type00
01501 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_type00(lua_State* tolua_S)
01502 {
01503 #ifndef TOLUA_RELEASE
01504  tolua_Error tolua_err;
01505  if (
01506      !tolua_isusertype(tolua_S,1,"const fawkes::FacialExpressionInterface",0,&tolua_err) ||
01507      !tolua_isnoobj(tolua_S,2,&tolua_err)
01508  )
01509   goto tolua_lerror;
01510  else
01511 #endif
01512  {
01513   const fawkes::FacialExpressionInterface* self = (const fawkes::FacialExpressionInterface*)  tolua_tousertype(tolua_S,1,0);
01514 #ifndef TOLUA_RELEASE
01515   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'type'", NULL);
01516 #endif
01517   {
01518    const char* tolua_ret = (const char*)  self->type();
01519    tolua_pushstring(tolua_S,(const char*)tolua_ret);
01520   }
01521  }
01522  return 1;
01523 #ifndef TOLUA_RELEASE
01524  tolua_lerror:
01525  tolua_error(tolua_S,"#ferror in function 'type'.",&tolua_err);
01526  return 0;
01527 #endif
01528 }
01529 #endif //#ifndef TOLUA_DISABLE
01530 
01531 /* method: id of class  fawkes::FacialExpressionInterface */
01532 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_id00
01533 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_id00(lua_State* tolua_S)
01534 {
01535 #ifndef TOLUA_RELEASE
01536  tolua_Error tolua_err;
01537  if (
01538      !tolua_isusertype(tolua_S,1,"const fawkes::FacialExpressionInterface",0,&tolua_err) ||
01539      !tolua_isnoobj(tolua_S,2,&tolua_err)
01540  )
01541   goto tolua_lerror;
01542  else
01543 #endif
01544  {
01545   const fawkes::FacialExpressionInterface* self = (const fawkes::FacialExpressionInterface*)  tolua_tousertype(tolua_S,1,0);
01546 #ifndef TOLUA_RELEASE
01547   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'id'", NULL);
01548 #endif
01549   {
01550    const char* tolua_ret = (const char*)  self->id();
01551    tolua_pushstring(tolua_S,(const char*)tolua_ret);
01552   }
01553  }
01554  return 1;
01555 #ifndef TOLUA_RELEASE
01556  tolua_lerror:
01557  tolua_error(tolua_S,"#ferror in function 'id'.",&tolua_err);
01558  return 0;
01559 #endif
01560 }
01561 #endif //#ifndef TOLUA_DISABLE
01562 
01563 /* method: uid of class  fawkes::FacialExpressionInterface */
01564 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_uid00
01565 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_uid00(lua_State* tolua_S)
01566 {
01567 #ifndef TOLUA_RELEASE
01568  tolua_Error tolua_err;
01569  if (
01570      !tolua_isusertype(tolua_S,1,"const fawkes::FacialExpressionInterface",0,&tolua_err) ||
01571      !tolua_isnoobj(tolua_S,2,&tolua_err)
01572  )
01573   goto tolua_lerror;
01574  else
01575 #endif
01576  {
01577   const fawkes::FacialExpressionInterface* self = (const fawkes::FacialExpressionInterface*)  tolua_tousertype(tolua_S,1,0);
01578 #ifndef TOLUA_RELEASE
01579   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'uid'", NULL);
01580 #endif
01581   {
01582    const char* tolua_ret = (const char*)  self->uid();
01583    tolua_pushstring(tolua_S,(const char*)tolua_ret);
01584   }
01585  }
01586  return 1;
01587 #ifndef TOLUA_RELEASE
01588  tolua_lerror:
01589  tolua_error(tolua_S,"#ferror in function 'uid'.",&tolua_err);
01590  return 0;
01591 #endif
01592 }
01593 #endif //#ifndef TOLUA_DISABLE
01594 
01595 /* method: serial of class  fawkes::FacialExpressionInterface */
01596 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_serial00
01597 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_serial00(lua_State* tolua_S)
01598 {
01599 #ifndef TOLUA_RELEASE
01600  tolua_Error tolua_err;
01601  if (
01602      !tolua_isusertype(tolua_S,1,"const fawkes::FacialExpressionInterface",0,&tolua_err) ||
01603      !tolua_isnoobj(tolua_S,2,&tolua_err)
01604  )
01605   goto tolua_lerror;
01606  else
01607 #endif
01608  {
01609   const fawkes::FacialExpressionInterface* self = (const fawkes::FacialExpressionInterface*)  tolua_tousertype(tolua_S,1,0);
01610 #ifndef TOLUA_RELEASE
01611   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'serial'", NULL);
01612 #endif
01613   {
01614    unsigned int tolua_ret = (unsigned int)  self->serial();
01615    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01616   }
01617  }
01618  return 1;
01619 #ifndef TOLUA_RELEASE
01620  tolua_lerror:
01621  tolua_error(tolua_S,"#ferror in function 'serial'.",&tolua_err);
01622  return 0;
01623 #endif
01624 }
01625 #endif //#ifndef TOLUA_DISABLE
01626 
01627 /* method: mem_serial of class  fawkes::FacialExpressionInterface */
01628 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_mem_serial00
01629 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_mem_serial00(lua_State* tolua_S)
01630 {
01631 #ifndef TOLUA_RELEASE
01632  tolua_Error tolua_err;
01633  if (
01634      !tolua_isusertype(tolua_S,1,"const fawkes::FacialExpressionInterface",0,&tolua_err) ||
01635      !tolua_isnoobj(tolua_S,2,&tolua_err)
01636  )
01637   goto tolua_lerror;
01638  else
01639 #endif
01640  {
01641   const fawkes::FacialExpressionInterface* self = (const fawkes::FacialExpressionInterface*)  tolua_tousertype(tolua_S,1,0);
01642 #ifndef TOLUA_RELEASE
01643   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'mem_serial'", NULL);
01644 #endif
01645   {
01646    unsigned int tolua_ret = (unsigned int)  self->mem_serial();
01647    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01648   }
01649  }
01650  return 1;
01651 #ifndef TOLUA_RELEASE
01652  tolua_lerror:
01653  tolua_error(tolua_S,"#ferror in function 'mem_serial'.",&tolua_err);
01654  return 0;
01655 #endif
01656 }
01657 #endif //#ifndef TOLUA_DISABLE
01658 
01659 /* method: operator== of class  fawkes::FacialExpressionInterface */
01660 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface__eq00
01661 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface__eq00(lua_State* tolua_S)
01662 {
01663 #ifndef TOLUA_RELEASE
01664  tolua_Error tolua_err;
01665  if (
01666      !tolua_isusertype(tolua_S,1,"const fawkes::FacialExpressionInterface",0,&tolua_err) ||
01667      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Interface",0,&tolua_err)) ||
01668      !tolua_isnoobj(tolua_S,3,&tolua_err)
01669  )
01670   goto tolua_lerror;
01671  else
01672 #endif
01673  {
01674   const fawkes::FacialExpressionInterface* self = (const fawkes::FacialExpressionInterface*)  tolua_tousertype(tolua_S,1,0);
01675   Interface* comp = ((Interface*)  tolua_tousertype(tolua_S,2,0));
01676 #ifndef TOLUA_RELEASE
01677   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='", NULL);
01678 #endif
01679   {
01680    bool tolua_ret = (bool)  self->operator==(*comp);
01681    tolua_pushboolean(tolua_S,(bool)tolua_ret);
01682   }
01683  }
01684  return 1;
01685 #ifndef TOLUA_RELEASE
01686  tolua_lerror:
01687  tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err);
01688  return 0;
01689 #endif
01690 }
01691 #endif //#ifndef TOLUA_DISABLE
01692 
01693 /* method: hash of class  fawkes::FacialExpressionInterface */
01694 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_hash00
01695 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_hash00(lua_State* tolua_S)
01696 {
01697 #ifndef TOLUA_RELEASE
01698  tolua_Error tolua_err;
01699  if (
01700      !tolua_isusertype(tolua_S,1,"const fawkes::FacialExpressionInterface",0,&tolua_err) ||
01701      !tolua_isnoobj(tolua_S,2,&tolua_err)
01702  )
01703   goto tolua_lerror;
01704  else
01705 #endif
01706  {
01707   const fawkes::FacialExpressionInterface* self = (const fawkes::FacialExpressionInterface*)  tolua_tousertype(tolua_S,1,0);
01708 #ifndef TOLUA_RELEASE
01709   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash'", NULL);
01710 #endif
01711   {
01712    unsigned const char* tolua_ret = ( unsigned const char*)  self->hash();
01713    tolua_pushstring(tolua_S,(const char*)tolua_ret);
01714   }
01715  }
01716  return 1;
01717 #ifndef TOLUA_RELEASE
01718  tolua_lerror:
01719  tolua_error(tolua_S,"#ferror in function 'hash'.",&tolua_err);
01720  return 0;
01721 #endif
01722 }
01723 #endif //#ifndef TOLUA_DISABLE
01724 
01725 /* method: hash_size of class  fawkes::FacialExpressionInterface */
01726 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_hash_size00
01727 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_hash_size00(lua_State* tolua_S)
01728 {
01729 #ifndef TOLUA_RELEASE
01730  tolua_Error tolua_err;
01731  if (
01732      !tolua_isusertype(tolua_S,1,"const fawkes::FacialExpressionInterface",0,&tolua_err) ||
01733      !tolua_isnoobj(tolua_S,2,&tolua_err)
01734  )
01735   goto tolua_lerror;
01736  else
01737 #endif
01738  {
01739   const fawkes::FacialExpressionInterface* self = (const fawkes::FacialExpressionInterface*)  tolua_tousertype(tolua_S,1,0);
01740 #ifndef TOLUA_RELEASE
01741   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash_size'", NULL);
01742 #endif
01743   {
01744    int tolua_ret = (int)  self->hash_size();
01745    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01746   }
01747  }
01748  return 1;
01749 #ifndef TOLUA_RELEASE
01750  tolua_lerror:
01751  tolua_error(tolua_S,"#ferror in function 'hash_size'.",&tolua_err);
01752  return 0;
01753 #endif
01754 }
01755 #endif //#ifndef TOLUA_DISABLE
01756 
01757 /* method: hash_printable of class  fawkes::FacialExpressionInterface */
01758 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_hash_printable00
01759 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_hash_printable00(lua_State* tolua_S)
01760 {
01761 #ifndef TOLUA_RELEASE
01762  tolua_Error tolua_err;
01763  if (
01764      !tolua_isusertype(tolua_S,1,"const fawkes::FacialExpressionInterface",0,&tolua_err) ||
01765      !tolua_isnoobj(tolua_S,2,&tolua_err)
01766  )
01767   goto tolua_lerror;
01768  else
01769 #endif
01770  {
01771   const fawkes::FacialExpressionInterface* self = (const fawkes::FacialExpressionInterface*)  tolua_tousertype(tolua_S,1,0);
01772 #ifndef TOLUA_RELEASE
01773   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash_printable'", NULL);
01774 #endif
01775   {
01776    const char* tolua_ret = (const char*)  self->hash_printable();
01777    tolua_pushstring(tolua_S,(const char*)tolua_ret);
01778   }
01779  }
01780  return 1;
01781 #ifndef TOLUA_RELEASE
01782  tolua_lerror:
01783  tolua_error(tolua_S,"#ferror in function 'hash_printable'.",&tolua_err);
01784  return 0;
01785 #endif
01786 }
01787 #endif //#ifndef TOLUA_DISABLE
01788 
01789 /* method: is_writer of class  fawkes::FacialExpressionInterface */
01790 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_is_writer00
01791 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_is_writer00(lua_State* tolua_S)
01792 {
01793 #ifndef TOLUA_RELEASE
01794  tolua_Error tolua_err;
01795  if (
01796      !tolua_isusertype(tolua_S,1,"const fawkes::FacialExpressionInterface",0,&tolua_err) ||
01797      !tolua_isnoobj(tolua_S,2,&tolua_err)
01798  )
01799   goto tolua_lerror;
01800  else
01801 #endif
01802  {
01803   const fawkes::FacialExpressionInterface* self = (const fawkes::FacialExpressionInterface*)  tolua_tousertype(tolua_S,1,0);
01804 #ifndef TOLUA_RELEASE
01805   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_writer'", NULL);
01806 #endif
01807   {
01808    bool tolua_ret = (bool)  self->is_writer();
01809    tolua_pushboolean(tolua_S,(bool)tolua_ret);
01810   }
01811  }
01812  return 1;
01813 #ifndef TOLUA_RELEASE
01814  tolua_lerror:
01815  tolua_error(tolua_S,"#ferror in function 'is_writer'.",&tolua_err);
01816  return 0;
01817 #endif
01818 }
01819 #endif //#ifndef TOLUA_DISABLE
01820 
01821 /* method: set_from_chunk of class  fawkes::FacialExpressionInterface */
01822 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_set_from_chunk00
01823 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_set_from_chunk00(lua_State* tolua_S)
01824 {
01825 #ifndef TOLUA_RELEASE
01826  tolua_Error tolua_err;
01827  if (
01828      !tolua_isusertype(tolua_S,1,"fawkes::FacialExpressionInterface",0,&tolua_err) ||
01829      !tolua_isuserdata(tolua_S,2,0,&tolua_err) ||
01830      !tolua_isnoobj(tolua_S,3,&tolua_err)
01831  )
01832   goto tolua_lerror;
01833  else
01834 #endif
01835  {
01836   fawkes::FacialExpressionInterface* self = (fawkes::FacialExpressionInterface*)  tolua_tousertype(tolua_S,1,0);
01837   void* chunk = ((void*)  tolua_touserdata(tolua_S,2,0));
01838 #ifndef TOLUA_RELEASE
01839   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_from_chunk'", NULL);
01840 #endif
01841   {
01842    self->set_from_chunk(chunk);
01843   }
01844  }
01845  return 0;
01846 #ifndef TOLUA_RELEASE
01847  tolua_lerror:
01848  tolua_error(tolua_S,"#ferror in function 'set_from_chunk'.",&tolua_err);
01849  return 0;
01850 #endif
01851 }
01852 #endif //#ifndef TOLUA_DISABLE
01853 
01854 /* method: create_message of class  fawkes::FacialExpressionInterface */
01855 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_create_message00
01856 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_create_message00(lua_State* tolua_S)
01857 {
01858 #ifndef TOLUA_RELEASE
01859  tolua_Error tolua_err;
01860  if (
01861      !tolua_isusertype(tolua_S,1,"const fawkes::FacialExpressionInterface",0,&tolua_err) ||
01862      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
01863      !tolua_isnoobj(tolua_S,3,&tolua_err)
01864  )
01865   goto tolua_lerror;
01866  else
01867 #endif
01868  {
01869   const fawkes::FacialExpressionInterface* self = (const fawkes::FacialExpressionInterface*)  tolua_tousertype(tolua_S,1,0);
01870   const char* type = ((const char*)  tolua_tostring(tolua_S,2,0));
01871 #ifndef TOLUA_RELEASE
01872   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'create_message'", NULL);
01873 #endif
01874   {
01875    Message* tolua_ret = (Message*)  self->create_message(type);
01876     tolua_pushusertype(tolua_S,(void*)tolua_ret,"Message");
01877   }
01878  }
01879  return 1;
01880 #ifndef TOLUA_RELEASE
01881  tolua_lerror:
01882  tolua_error(tolua_S,"#ferror in function 'create_message'.",&tolua_err);
01883  return 0;
01884 #endif
01885 }
01886 #endif //#ifndef TOLUA_DISABLE
01887 
01888 /* method: read of class  fawkes::FacialExpressionInterface */
01889 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_read00
01890 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_read00(lua_State* tolua_S)
01891 {
01892 #ifndef TOLUA_RELEASE
01893  tolua_Error tolua_err;
01894  if (
01895      !tolua_isusertype(tolua_S,1,"fawkes::FacialExpressionInterface",0,&tolua_err) ||
01896      !tolua_isnoobj(tolua_S,2,&tolua_err)
01897  )
01898   goto tolua_lerror;
01899  else
01900 #endif
01901  {
01902   fawkes::FacialExpressionInterface* self = (fawkes::FacialExpressionInterface*)  tolua_tousertype(tolua_S,1,0);
01903 #ifndef TOLUA_RELEASE
01904   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'read'", NULL);
01905 #endif
01906   {
01907    self->read();
01908   }
01909  }
01910  return 0;
01911 #ifndef TOLUA_RELEASE
01912  tolua_lerror:
01913  tolua_error(tolua_S,"#ferror in function 'read'.",&tolua_err);
01914  return 0;
01915 #endif
01916 }
01917 #endif //#ifndef TOLUA_DISABLE
01918 
01919 /* method: write of class  fawkes::FacialExpressionInterface */
01920 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_write00
01921 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_write00(lua_State* tolua_S)
01922 {
01923 #ifndef TOLUA_RELEASE
01924  tolua_Error tolua_err;
01925  if (
01926      !tolua_isusertype(tolua_S,1,"fawkes::FacialExpressionInterface",0,&tolua_err) ||
01927      !tolua_isnoobj(tolua_S,2,&tolua_err)
01928  )
01929   goto tolua_lerror;
01930  else
01931 #endif
01932  {
01933   fawkes::FacialExpressionInterface* self = (fawkes::FacialExpressionInterface*)  tolua_tousertype(tolua_S,1,0);
01934 #ifndef TOLUA_RELEASE
01935   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'write'", NULL);
01936 #endif
01937   {
01938    self->write();
01939   }
01940  }
01941  return 0;
01942 #ifndef TOLUA_RELEASE
01943  tolua_lerror:
01944  tolua_error(tolua_S,"#ferror in function 'write'.",&tolua_err);
01945  return 0;
01946 #endif
01947 }
01948 #endif //#ifndef TOLUA_DISABLE
01949 
01950 /* method: has_writer of class  fawkes::FacialExpressionInterface */
01951 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_has_writer00
01952 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_has_writer00(lua_State* tolua_S)
01953 {
01954 #ifndef TOLUA_RELEASE
01955  tolua_Error tolua_err;
01956  if (
01957      !tolua_isusertype(tolua_S,1,"const fawkes::FacialExpressionInterface",0,&tolua_err) ||
01958      !tolua_isnoobj(tolua_S,2,&tolua_err)
01959  )
01960   goto tolua_lerror;
01961  else
01962 #endif
01963  {
01964   const fawkes::FacialExpressionInterface* self = (const fawkes::FacialExpressionInterface*)  tolua_tousertype(tolua_S,1,0);
01965 #ifndef TOLUA_RELEASE
01966   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'has_writer'", NULL);
01967 #endif
01968   {
01969    bool tolua_ret = (bool)  self->has_writer();
01970    tolua_pushboolean(tolua_S,(bool)tolua_ret);
01971   }
01972  }
01973  return 1;
01974 #ifndef TOLUA_RELEASE
01975  tolua_lerror:
01976  tolua_error(tolua_S,"#ferror in function 'has_writer'.",&tolua_err);
01977  return 0;
01978 #endif
01979 }
01980 #endif //#ifndef TOLUA_DISABLE
01981 
01982 /* method: num_readers of class  fawkes::FacialExpressionInterface */
01983 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_num_readers00
01984 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_num_readers00(lua_State* tolua_S)
01985 {
01986 #ifndef TOLUA_RELEASE
01987  tolua_Error tolua_err;
01988  if (
01989      !tolua_isusertype(tolua_S,1,"const fawkes::FacialExpressionInterface",0,&tolua_err) ||
01990      !tolua_isnoobj(tolua_S,2,&tolua_err)
01991  )
01992   goto tolua_lerror;
01993  else
01994 #endif
01995  {
01996   const fawkes::FacialExpressionInterface* self = (const fawkes::FacialExpressionInterface*)  tolua_tousertype(tolua_S,1,0);
01997 #ifndef TOLUA_RELEASE
01998   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'num_readers'", NULL);
01999 #endif
02000   {
02001    unsigned int tolua_ret = (unsigned int)  self->num_readers();
02002    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02003   }
02004  }
02005  return 1;
02006 #ifndef TOLUA_RELEASE
02007  tolua_lerror:
02008  tolua_error(tolua_S,"#ferror in function 'num_readers'.",&tolua_err);
02009  return 0;
02010 #endif
02011 }
02012 #endif //#ifndef TOLUA_DISABLE
02013 
02014 /* method: msgq_enqueue_copy of class  fawkes::FacialExpressionInterface */
02015 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_msgq_enqueue_copy00
02016 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_msgq_enqueue_copy00(lua_State* tolua_S)
02017 {
02018 #ifndef TOLUA_RELEASE
02019  tolua_Error tolua_err;
02020  if (
02021      !tolua_isusertype(tolua_S,1,"fawkes::FacialExpressionInterface",0,&tolua_err) ||
02022      !tolua_isusertype(tolua_S,2,"Message",0,&tolua_err) ||
02023      !tolua_isnoobj(tolua_S,3,&tolua_err)
02024  )
02025   goto tolua_lerror;
02026  else
02027 #endif
02028  {
02029   fawkes::FacialExpressionInterface* self = (fawkes::FacialExpressionInterface*)  tolua_tousertype(tolua_S,1,0);
02030   Message* message = ((Message*)  tolua_tousertype(tolua_S,2,0));
02031 #ifndef TOLUA_RELEASE
02032   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_enqueue_copy'", NULL);
02033 #endif
02034   {
02035    unsigned int tolua_ret = (unsigned int)  self->msgq_enqueue_copy(message);
02036    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02037   }
02038  }
02039  return 1;
02040 #ifndef TOLUA_RELEASE
02041  tolua_lerror:
02042  tolua_error(tolua_S,"#ferror in function 'msgq_enqueue_copy'.",&tolua_err);
02043  return 0;
02044 #endif
02045 }
02046 #endif //#ifndef TOLUA_DISABLE
02047 
02048 /* method: msgq_remove of class  fawkes::FacialExpressionInterface */
02049 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_msgq_remove00
02050 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_msgq_remove00(lua_State* tolua_S)
02051 {
02052 #ifndef TOLUA_RELEASE
02053  tolua_Error tolua_err;
02054  if (
02055      !tolua_isusertype(tolua_S,1,"fawkes::FacialExpressionInterface",0,&tolua_err) ||
02056      !tolua_isusertype(tolua_S,2,"Message",0,&tolua_err) ||
02057      !tolua_isnoobj(tolua_S,3,&tolua_err)
02058  )
02059   goto tolua_lerror;
02060  else
02061 #endif
02062  {
02063   fawkes::FacialExpressionInterface* self = (fawkes::FacialExpressionInterface*)  tolua_tousertype(tolua_S,1,0);
02064   Message* message = ((Message*)  tolua_tousertype(tolua_S,2,0));
02065 #ifndef TOLUA_RELEASE
02066   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_remove'", NULL);
02067 #endif
02068   {
02069    self->msgq_remove(message);
02070   }
02071  }
02072  return 0;
02073 #ifndef TOLUA_RELEASE
02074  tolua_lerror:
02075  tolua_error(tolua_S,"#ferror in function 'msgq_remove'.",&tolua_err);
02076  return 0;
02077 #endif
02078 }
02079 #endif //#ifndef TOLUA_DISABLE
02080 
02081 /* method: msgq_remove of class  fawkes::FacialExpressionInterface */
02082 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_msgq_remove01
02083 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_msgq_remove01(lua_State* tolua_S)
02084 {
02085  tolua_Error tolua_err;
02086  if (
02087      !tolua_isusertype(tolua_S,1,"fawkes::FacialExpressionInterface",0,&tolua_err) ||
02088      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02089      !tolua_isnoobj(tolua_S,3,&tolua_err)
02090  )
02091   goto tolua_lerror;
02092  else
02093  {
02094   fawkes::FacialExpressionInterface* self = (fawkes::FacialExpressionInterface*)  tolua_tousertype(tolua_S,1,0);
02095   unsigned int message_id = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
02096 #ifndef TOLUA_RELEASE
02097   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_remove'", NULL);
02098 #endif
02099   {
02100    self->msgq_remove(message_id);
02101   }
02102  }
02103  return 0;
02104 tolua_lerror:
02105  return tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_msgq_remove00(tolua_S);
02106 }
02107 #endif //#ifndef TOLUA_DISABLE
02108 
02109 /* method: msgq_size of class  fawkes::FacialExpressionInterface */
02110 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_msgq_size00
02111 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_msgq_size00(lua_State* tolua_S)
02112 {
02113 #ifndef TOLUA_RELEASE
02114  tolua_Error tolua_err;
02115  if (
02116      !tolua_isusertype(tolua_S,1,"fawkes::FacialExpressionInterface",0,&tolua_err) ||
02117      !tolua_isnoobj(tolua_S,2,&tolua_err)
02118  )
02119   goto tolua_lerror;
02120  else
02121 #endif
02122  {
02123   fawkes::FacialExpressionInterface* self = (fawkes::FacialExpressionInterface*)  tolua_tousertype(tolua_S,1,0);
02124 #ifndef TOLUA_RELEASE
02125   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_size'", NULL);
02126 #endif
02127   {
02128    unsigned int tolua_ret = (unsigned int)  self->msgq_size();
02129    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02130   }
02131  }
02132  return 1;
02133 #ifndef TOLUA_RELEASE
02134  tolua_lerror:
02135  tolua_error(tolua_S,"#ferror in function 'msgq_size'.",&tolua_err);
02136  return 0;
02137 #endif
02138 }
02139 #endif //#ifndef TOLUA_DISABLE
02140 
02141 /* method: msgq_flush of class  fawkes::FacialExpressionInterface */
02142 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_msgq_flush00
02143 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_msgq_flush00(lua_State* tolua_S)
02144 {
02145 #ifndef TOLUA_RELEASE
02146  tolua_Error tolua_err;
02147  if (
02148      !tolua_isusertype(tolua_S,1,"fawkes::FacialExpressionInterface",0,&tolua_err) ||
02149      !tolua_isnoobj(tolua_S,2,&tolua_err)
02150  )
02151   goto tolua_lerror;
02152  else
02153 #endif
02154  {
02155   fawkes::FacialExpressionInterface* self = (fawkes::FacialExpressionInterface*)  tolua_tousertype(tolua_S,1,0);
02156 #ifndef TOLUA_RELEASE
02157   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_flush'", NULL);
02158 #endif
02159   {
02160    self->msgq_flush();
02161   }
02162  }
02163  return 0;
02164 #ifndef TOLUA_RELEASE
02165  tolua_lerror:
02166  tolua_error(tolua_S,"#ferror in function 'msgq_flush'.",&tolua_err);
02167  return 0;
02168 #endif
02169 }
02170 #endif //#ifndef TOLUA_DISABLE
02171 
02172 /* method: msgq_lock of class  fawkes::FacialExpressionInterface */
02173 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_msgq_lock00
02174 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_msgq_lock00(lua_State* tolua_S)
02175 {
02176 #ifndef TOLUA_RELEASE
02177  tolua_Error tolua_err;
02178  if (
02179      !tolua_isusertype(tolua_S,1,"fawkes::FacialExpressionInterface",0,&tolua_err) ||
02180      !tolua_isnoobj(tolua_S,2,&tolua_err)
02181  )
02182   goto tolua_lerror;
02183  else
02184 #endif
02185  {
02186   fawkes::FacialExpressionInterface* self = (fawkes::FacialExpressionInterface*)  tolua_tousertype(tolua_S,1,0);
02187 #ifndef TOLUA_RELEASE
02188   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_lock'", NULL);
02189 #endif
02190   {
02191    self->msgq_lock();
02192   }
02193  }
02194  return 0;
02195 #ifndef TOLUA_RELEASE
02196  tolua_lerror:
02197  tolua_error(tolua_S,"#ferror in function 'msgq_lock'.",&tolua_err);
02198  return 0;
02199 #endif
02200 }
02201 #endif //#ifndef TOLUA_DISABLE
02202 
02203 /* method: msgq_try_lock of class  fawkes::FacialExpressionInterface */
02204 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_msgq_try_lock00
02205 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_msgq_try_lock00(lua_State* tolua_S)
02206 {
02207 #ifndef TOLUA_RELEASE
02208  tolua_Error tolua_err;
02209  if (
02210      !tolua_isusertype(tolua_S,1,"fawkes::FacialExpressionInterface",0,&tolua_err) ||
02211      !tolua_isnoobj(tolua_S,2,&tolua_err)
02212  )
02213   goto tolua_lerror;
02214  else
02215 #endif
02216  {
02217   fawkes::FacialExpressionInterface* self = (fawkes::FacialExpressionInterface*)  tolua_tousertype(tolua_S,1,0);
02218 #ifndef TOLUA_RELEASE
02219   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_try_lock'", NULL);
02220 #endif
02221   {
02222    bool tolua_ret = (bool)  self->msgq_try_lock();
02223    tolua_pushboolean(tolua_S,(bool)tolua_ret);
02224   }
02225  }
02226  return 1;
02227 #ifndef TOLUA_RELEASE
02228  tolua_lerror:
02229  tolua_error(tolua_S,"#ferror in function 'msgq_try_lock'.",&tolua_err);
02230  return 0;
02231 #endif
02232 }
02233 #endif //#ifndef TOLUA_DISABLE
02234 
02235 /* method: msgq_unlock of class  fawkes::FacialExpressionInterface */
02236 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_msgq_unlock00
02237 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_msgq_unlock00(lua_State* tolua_S)
02238 {
02239 #ifndef TOLUA_RELEASE
02240  tolua_Error tolua_err;
02241  if (
02242      !tolua_isusertype(tolua_S,1,"fawkes::FacialExpressionInterface",0,&tolua_err) ||
02243      !tolua_isnoobj(tolua_S,2,&tolua_err)
02244  )
02245   goto tolua_lerror;
02246  else
02247 #endif
02248  {
02249   fawkes::FacialExpressionInterface* self = (fawkes::FacialExpressionInterface*)  tolua_tousertype(tolua_S,1,0);
02250 #ifndef TOLUA_RELEASE
02251   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_unlock'", NULL);
02252 #endif
02253   {
02254    self->msgq_unlock();
02255   }
02256  }
02257  return 0;
02258 #ifndef TOLUA_RELEASE
02259  tolua_lerror:
02260  tolua_error(tolua_S,"#ferror in function 'msgq_unlock'.",&tolua_err);
02261  return 0;
02262 #endif
02263 }
02264 #endif //#ifndef TOLUA_DISABLE
02265 
02266 /* method: msgq_pop of class  fawkes::FacialExpressionInterface */
02267 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_msgq_pop00
02268 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_msgq_pop00(lua_State* tolua_S)
02269 {
02270 #ifndef TOLUA_RELEASE
02271  tolua_Error tolua_err;
02272  if (
02273      !tolua_isusertype(tolua_S,1,"fawkes::FacialExpressionInterface",0,&tolua_err) ||
02274      !tolua_isnoobj(tolua_S,2,&tolua_err)
02275  )
02276   goto tolua_lerror;
02277  else
02278 #endif
02279  {
02280   fawkes::FacialExpressionInterface* self = (fawkes::FacialExpressionInterface*)  tolua_tousertype(tolua_S,1,0);
02281 #ifndef TOLUA_RELEASE
02282   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_pop'", NULL);
02283 #endif
02284   {
02285    self->msgq_pop();
02286   }
02287  }
02288  return 0;
02289 #ifndef TOLUA_RELEASE
02290  tolua_lerror:
02291  tolua_error(tolua_S,"#ferror in function 'msgq_pop'.",&tolua_err);
02292  return 0;
02293 #endif
02294 }
02295 #endif //#ifndef TOLUA_DISABLE
02296 
02297 /* method: msgq_first of class  fawkes::FacialExpressionInterface */
02298 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_msgq_first00
02299 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_msgq_first00(lua_State* tolua_S)
02300 {
02301 #ifndef TOLUA_RELEASE
02302  tolua_Error tolua_err;
02303  if (
02304      !tolua_isusertype(tolua_S,1,"fawkes::FacialExpressionInterface",0,&tolua_err) ||
02305      !tolua_isnoobj(tolua_S,2,&tolua_err)
02306  )
02307   goto tolua_lerror;
02308  else
02309 #endif
02310  {
02311   fawkes::FacialExpressionInterface* self = (fawkes::FacialExpressionInterface*)  tolua_tousertype(tolua_S,1,0);
02312 #ifndef TOLUA_RELEASE
02313   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_first'", NULL);
02314 #endif
02315   {
02316    Message* tolua_ret = (Message*)  self->msgq_first();
02317     tolua_pushusertype(tolua_S,(void*)tolua_ret,"Message");
02318   }
02319  }
02320  return 1;
02321 #ifndef TOLUA_RELEASE
02322  tolua_lerror:
02323  tolua_error(tolua_S,"#ferror in function 'msgq_first'.",&tolua_err);
02324  return 0;
02325 #endif
02326 }
02327 #endif //#ifndef TOLUA_DISABLE
02328 
02329 /* method: msgq_empty of class  fawkes::FacialExpressionInterface */
02330 #ifndef TOLUA_DISABLE_tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_msgq_empty00
02331 static int tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_msgq_empty00(lua_State* tolua_S)
02332 {
02333 #ifndef TOLUA_RELEASE
02334  tolua_Error tolua_err;
02335  if (
02336      !tolua_isusertype(tolua_S,1,"fawkes::FacialExpressionInterface",0,&tolua_err) ||
02337      !tolua_isnoobj(tolua_S,2,&tolua_err)
02338  )
02339   goto tolua_lerror;
02340  else
02341 #endif
02342  {
02343   fawkes::FacialExpressionInterface* self = (fawkes::FacialExpressionInterface*)  tolua_tousertype(tolua_S,1,0);
02344 #ifndef TOLUA_RELEASE
02345   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_empty'", NULL);
02346 #endif
02347   {
02348    bool tolua_ret = (bool)  self->msgq_empty();
02349    tolua_pushboolean(tolua_S,(bool)tolua_ret);
02350   }
02351  }
02352  return 1;
02353 #ifndef TOLUA_RELEASE
02354  tolua_lerror:
02355  tolua_error(tolua_S,"#ferror in function 'msgq_empty'.",&tolua_err);
02356  return 0;
02357 #endif
02358 }
02359 #endif //#ifndef TOLUA_DISABLE
02360 
02361 /* Open function */
02362 TOLUA_API int tolua_interfaces_FacialExpressionInterface_open (lua_State* tolua_S)
02363 {
02364  tolua_open(tolua_S);
02365  tolua_reg_types(tolua_S);
02366  tolua_module(tolua_S,NULL,0);
02367  tolua_beginmodule(tolua_S,NULL);
02368   tolua_module(tolua_S,"fawkes",0);
02369   tolua_beginmodule(tolua_S,"fawkes");
02370    tolua_cclass(tolua_S,"FacialExpressionInterface","fawkes::FacialExpressionInterface","Interface",NULL);
02371    tolua_beginmodule(tolua_S,"FacialExpressionInterface");
02372     tolua_constant(tolua_S,"BROWS_DEFAULT",fawkes::FacialExpressionInterface::BROWS_DEFAULT);
02373     tolua_constant(tolua_S,"BROWS_FROWN",fawkes::FacialExpressionInterface::BROWS_FROWN);
02374     tolua_constant(tolua_S,"BROWS_LIFT",fawkes::FacialExpressionInterface::BROWS_LIFT);
02375     tolua_constant(tolua_S,"EYES_DEFAULT",fawkes::FacialExpressionInterface::EYES_DEFAULT);
02376     tolua_constant(tolua_S,"EYES_UP",fawkes::FacialExpressionInterface::EYES_UP);
02377     tolua_constant(tolua_S,"EYES_DOWN",fawkes::FacialExpressionInterface::EYES_DOWN);
02378     tolua_constant(tolua_S,"EYES_LEFT",fawkes::FacialExpressionInterface::EYES_LEFT);
02379     tolua_constant(tolua_S,"EYES_RIGHT",fawkes::FacialExpressionInterface::EYES_RIGHT);
02380     tolua_constant(tolua_S,"EYES_COOL",fawkes::FacialExpressionInterface::EYES_COOL);
02381     tolua_constant(tolua_S,"EYES_CROSS",fawkes::FacialExpressionInterface::EYES_CROSS);
02382     tolua_constant(tolua_S,"EYES_HEART",fawkes::FacialExpressionInterface::EYES_HEART);
02383     tolua_constant(tolua_S,"EYES_DOLLAR",fawkes::FacialExpressionInterface::EYES_DOLLAR);
02384     tolua_constant(tolua_S,"JOWL_DEFAULT",fawkes::FacialExpressionInterface::JOWL_DEFAULT);
02385     tolua_constant(tolua_S,"JOWL_BLUSH",fawkes::FacialExpressionInterface::JOWL_BLUSH);
02386     tolua_constant(tolua_S,"JOWL_TEARS",fawkes::FacialExpressionInterface::JOWL_TEARS);
02387     tolua_constant(tolua_S,"MOUTH_DEFAULT",fawkes::FacialExpressionInterface::MOUTH_DEFAULT);
02388     tolua_constant(tolua_S,"MOUTH_OPEN",fawkes::FacialExpressionInterface::MOUTH_OPEN);
02389     tolua_constant(tolua_S,"MOUTH_CLOSE",fawkes::FacialExpressionInterface::MOUTH_CLOSE);
02390     tolua_constant(tolua_S,"MOUTH_SMILE",fawkes::FacialExpressionInterface::MOUTH_SMILE);
02391     tolua_constant(tolua_S,"MOUTH_SCOWL",fawkes::FacialExpressionInterface::MOUTH_SCOWL);
02392     #ifdef __cplusplus
02393     tolua_cclass(tolua_S,"MoveBrowsMessage","fawkes::FacialExpressionInterface::MoveBrowsMessage","Message",tolua_collect_fawkes__FacialExpressionInterface__MoveBrowsMessage);
02394     #else
02395     tolua_cclass(tolua_S,"MoveBrowsMessage","fawkes::FacialExpressionInterface::MoveBrowsMessage","Message",NULL);
02396     #endif
02397     tolua_beginmodule(tolua_S,"MoveBrowsMessage");
02398      tolua_function(tolua_S,"new",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveBrowsMessage_new00);
02399      tolua_function(tolua_S,"new_local",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveBrowsMessage_new00_local);
02400      tolua_function(tolua_S,".call",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveBrowsMessage_new00_local);
02401      tolua_function(tolua_S,"new",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveBrowsMessage_new01);
02402      tolua_function(tolua_S,"new_local",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveBrowsMessage_new01_local);
02403      tolua_function(tolua_S,".call",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveBrowsMessage_new01_local);
02404      tolua_function(tolua_S,"delete",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveBrowsMessage_delete00);
02405      tolua_function(tolua_S,"brows_action",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveBrowsMessage_brows_action00);
02406      tolua_function(tolua_S,"set_brows_action",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveBrowsMessage_set_brows_action00);
02407      tolua_function(tolua_S,"maxlenof_brows_action",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveBrowsMessage_maxlenof_brows_action00);
02408     tolua_endmodule(tolua_S);
02409     #ifdef __cplusplus
02410     tolua_cclass(tolua_S,"MoveEyesMessage","fawkes::FacialExpressionInterface::MoveEyesMessage","Message",tolua_collect_fawkes__FacialExpressionInterface__MoveEyesMessage);
02411     #else
02412     tolua_cclass(tolua_S,"MoveEyesMessage","fawkes::FacialExpressionInterface::MoveEyesMessage","Message",NULL);
02413     #endif
02414     tolua_beginmodule(tolua_S,"MoveEyesMessage");
02415      tolua_function(tolua_S,"new",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveEyesMessage_new00);
02416      tolua_function(tolua_S,"new_local",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveEyesMessage_new00_local);
02417      tolua_function(tolua_S,".call",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveEyesMessage_new00_local);
02418      tolua_function(tolua_S,"new",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveEyesMessage_new01);
02419      tolua_function(tolua_S,"new_local",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveEyesMessage_new01_local);
02420      tolua_function(tolua_S,".call",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveEyesMessage_new01_local);
02421      tolua_function(tolua_S,"delete",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveEyesMessage_delete00);
02422      tolua_function(tolua_S,"eyes_action",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveEyesMessage_eyes_action00);
02423      tolua_function(tolua_S,"set_eyes_action",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveEyesMessage_set_eyes_action00);
02424      tolua_function(tolua_S,"maxlenof_eyes_action",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveEyesMessage_maxlenof_eyes_action00);
02425     tolua_endmodule(tolua_S);
02426     #ifdef __cplusplus
02427     tolua_cclass(tolua_S,"MoveJowlMessage","fawkes::FacialExpressionInterface::MoveJowlMessage","Message",tolua_collect_fawkes__FacialExpressionInterface__MoveJowlMessage);
02428     #else
02429     tolua_cclass(tolua_S,"MoveJowlMessage","fawkes::FacialExpressionInterface::MoveJowlMessage","Message",NULL);
02430     #endif
02431     tolua_beginmodule(tolua_S,"MoveJowlMessage");
02432      tolua_function(tolua_S,"new",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveJowlMessage_new00);
02433      tolua_function(tolua_S,"new_local",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveJowlMessage_new00_local);
02434      tolua_function(tolua_S,".call",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveJowlMessage_new00_local);
02435      tolua_function(tolua_S,"new",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveJowlMessage_new01);
02436      tolua_function(tolua_S,"new_local",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveJowlMessage_new01_local);
02437      tolua_function(tolua_S,".call",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveJowlMessage_new01_local);
02438      tolua_function(tolua_S,"delete",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveJowlMessage_delete00);
02439      tolua_function(tolua_S,"jowl_action",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveJowlMessage_jowl_action00);
02440      tolua_function(tolua_S,"set_jowl_action",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveJowlMessage_set_jowl_action00);
02441      tolua_function(tolua_S,"maxlenof_jowl_action",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveJowlMessage_maxlenof_jowl_action00);
02442     tolua_endmodule(tolua_S);
02443     #ifdef __cplusplus
02444     tolua_cclass(tolua_S,"MoveMouthMessage","fawkes::FacialExpressionInterface::MoveMouthMessage","Message",tolua_collect_fawkes__FacialExpressionInterface__MoveMouthMessage);
02445     #else
02446     tolua_cclass(tolua_S,"MoveMouthMessage","fawkes::FacialExpressionInterface::MoveMouthMessage","Message",NULL);
02447     #endif
02448     tolua_beginmodule(tolua_S,"MoveMouthMessage");
02449      tolua_function(tolua_S,"new",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveMouthMessage_new00);
02450      tolua_function(tolua_S,"new_local",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveMouthMessage_new00_local);
02451      tolua_function(tolua_S,".call",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveMouthMessage_new00_local);
02452      tolua_function(tolua_S,"new",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveMouthMessage_new01);
02453      tolua_function(tolua_S,"new_local",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveMouthMessage_new01_local);
02454      tolua_function(tolua_S,".call",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveMouthMessage_new01_local);
02455      tolua_function(tolua_S,"delete",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveMouthMessage_delete00);
02456      tolua_function(tolua_S,"mouth_action",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveMouthMessage_mouth_action00);
02457      tolua_function(tolua_S,"set_mouth_action",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveMouthMessage_set_mouth_action00);
02458      tolua_function(tolua_S,"maxlenof_mouth_action",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_MoveMouthMessage_maxlenof_mouth_action00);
02459     tolua_endmodule(tolua_S);
02460     tolua_function(tolua_S,"brows_action",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_brows_action00);
02461     tolua_function(tolua_S,"set_brows_action",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_set_brows_action00);
02462     tolua_function(tolua_S,"maxlenof_brows_action",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_maxlenof_brows_action00);
02463     tolua_function(tolua_S,"eyes_action",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_eyes_action00);
02464     tolua_function(tolua_S,"set_eyes_action",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_set_eyes_action00);
02465     tolua_function(tolua_S,"maxlenof_eyes_action",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_maxlenof_eyes_action00);
02466     tolua_function(tolua_S,"jowl_action",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_jowl_action00);
02467     tolua_function(tolua_S,"set_jowl_action",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_set_jowl_action00);
02468     tolua_function(tolua_S,"maxlenof_jowl_action",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_maxlenof_jowl_action00);
02469     tolua_function(tolua_S,"mouth_action",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_mouth_action00);
02470     tolua_function(tolua_S,"set_mouth_action",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_set_mouth_action00);
02471     tolua_function(tolua_S,"maxlenof_mouth_action",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_maxlenof_mouth_action00);
02472     tolua_function(tolua_S,"oftype",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_oftype00);
02473     tolua_function(tolua_S,"datachunk",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_datachunk00);
02474     tolua_function(tolua_S,"datasize",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_datasize00);
02475     tolua_function(tolua_S,"type",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_type00);
02476     tolua_function(tolua_S,"id",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_id00);
02477     tolua_function(tolua_S,"uid",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_uid00);
02478     tolua_function(tolua_S,"serial",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_serial00);
02479     tolua_function(tolua_S,"mem_serial",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_mem_serial00);
02480     tolua_function(tolua_S,".eq",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface__eq00);
02481     tolua_function(tolua_S,"hash",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_hash00);
02482     tolua_function(tolua_S,"hash_size",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_hash_size00);
02483     tolua_function(tolua_S,"hash_printable",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_hash_printable00);
02484     tolua_function(tolua_S,"is_writer",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_is_writer00);
02485     tolua_function(tolua_S,"set_from_chunk",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_set_from_chunk00);
02486     tolua_function(tolua_S,"create_message",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_create_message00);
02487     tolua_function(tolua_S,"read",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_read00);
02488     tolua_function(tolua_S,"write",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_write00);
02489     tolua_function(tolua_S,"has_writer",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_has_writer00);
02490     tolua_function(tolua_S,"num_readers",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_num_readers00);
02491     tolua_function(tolua_S,"msgq_enqueue_copy",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_msgq_enqueue_copy00);
02492     tolua_function(tolua_S,"msgq_remove",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_msgq_remove00);
02493     tolua_function(tolua_S,"msgq_remove",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_msgq_remove01);
02494     tolua_function(tolua_S,"msgq_size",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_msgq_size00);
02495     tolua_function(tolua_S,"msgq_flush",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_msgq_flush00);
02496     tolua_function(tolua_S,"msgq_lock",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_msgq_lock00);
02497     tolua_function(tolua_S,"msgq_try_lock",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_msgq_try_lock00);
02498     tolua_function(tolua_S,"msgq_unlock",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_msgq_unlock00);
02499     tolua_function(tolua_S,"msgq_pop",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_msgq_pop00);
02500     tolua_function(tolua_S,"msgq_first",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_msgq_first00);
02501     tolua_function(tolua_S,"msgq_empty",tolua_interfaces_FacialExpressionInterface_fawkes_FacialExpressionInterface_msgq_empty00);
02502    tolua_endmodule(tolua_S);
02503   tolua_endmodule(tolua_S);
02504  tolua_endmodule(tolua_S);
02505  return 1;
02506 }
02507 
02508 
02509 extern "C" {
02510 #if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501
02511  TOLUA_API int luaopen_interfaces_FacialExpressionInterface (lua_State* tolua_S) {
02512  return tolua_interfaces_FacialExpressionInterface_open(tolua_S);
02513 };
02514 #endif
02515 }
02516 
02517