SoccerPenaltyInterface_tolua.cpp

00001 /*
00002 ** Lua binding: interfaces_SoccerPenaltyInterface
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_SoccerPenaltyInterface_open (lua_State* tolua_S);
00028 
00029 #include <interfaces/SoccerPenaltyInterface.h>
00030 using namespace fawkes;
00031 
00032 /* function to release collected object via destructor */
00033 #ifdef __cplusplus
00034 
00035 static int tolua_collect_fawkes__SoccerPenaltyInterface__SetPenaltyMessage (lua_State* tolua_S)
00036 {
00037  fawkes::SoccerPenaltyInterface::SetPenaltyMessage* self = (fawkes::SoccerPenaltyInterface::SetPenaltyMessage*) tolua_tousertype(tolua_S,1,0);
00038         Mtolua_delete(self);
00039         return 0;
00040 }
00041 #endif
00042 
00043 
00044 /* function to register type */
00045 static void tolua_reg_types (lua_State* tolua_S)
00046 {
00047  tolua_usertype(tolua_S,"Message");
00048  tolua_usertype(tolua_S,"fawkes::SoccerPenaltyInterface::SetPenaltyMessage");
00049  tolua_usertype(tolua_S,"fawkes::SoccerPenaltyInterface");
00050  tolua_usertype(tolua_S,"Interface");
00051 }
00052 
00053 /* get function: SPL_PENALTY_NONE of class  fawkes::SoccerPenaltyInterface */
00054 #ifndef TOLUA_DISABLE_tolua_get_fawkes__SoccerPenaltyInterface_unsigned_SPL_PENALTY_NONE
00055 static int tolua_get_fawkes__SoccerPenaltyInterface_unsigned_SPL_PENALTY_NONE(lua_State* tolua_S)
00056 {
00057   tolua_pushnumber(tolua_S,(lua_Number)fawkes::SoccerPenaltyInterface::SPL_PENALTY_NONE);
00058  return 1;
00059 }
00060 #endif //#ifndef TOLUA_DISABLE
00061 
00062 /* get function: SPL_PENALTY_BALL_HOLDING of class  fawkes::SoccerPenaltyInterface */
00063 #ifndef TOLUA_DISABLE_tolua_get_fawkes__SoccerPenaltyInterface_unsigned_SPL_PENALTY_BALL_HOLDING
00064 static int tolua_get_fawkes__SoccerPenaltyInterface_unsigned_SPL_PENALTY_BALL_HOLDING(lua_State* tolua_S)
00065 {
00066   tolua_pushnumber(tolua_S,(lua_Number)fawkes::SoccerPenaltyInterface::SPL_PENALTY_BALL_HOLDING);
00067  return 1;
00068 }
00069 #endif //#ifndef TOLUA_DISABLE
00070 
00071 /* get function: SPL_PENALTY_PLAYER_PUSHING of class  fawkes::SoccerPenaltyInterface */
00072 #ifndef TOLUA_DISABLE_tolua_get_fawkes__SoccerPenaltyInterface_unsigned_SPL_PENALTY_PLAYER_PUSHING
00073 static int tolua_get_fawkes__SoccerPenaltyInterface_unsigned_SPL_PENALTY_PLAYER_PUSHING(lua_State* tolua_S)
00074 {
00075   tolua_pushnumber(tolua_S,(lua_Number)fawkes::SoccerPenaltyInterface::SPL_PENALTY_PLAYER_PUSHING);
00076  return 1;
00077 }
00078 #endif //#ifndef TOLUA_DISABLE
00079 
00080 /* get function: SPL_PENALTY_OBSTRUCTION of class  fawkes::SoccerPenaltyInterface */
00081 #ifndef TOLUA_DISABLE_tolua_get_fawkes__SoccerPenaltyInterface_unsigned_SPL_PENALTY_OBSTRUCTION
00082 static int tolua_get_fawkes__SoccerPenaltyInterface_unsigned_SPL_PENALTY_OBSTRUCTION(lua_State* tolua_S)
00083 {
00084   tolua_pushnumber(tolua_S,(lua_Number)fawkes::SoccerPenaltyInterface::SPL_PENALTY_OBSTRUCTION);
00085  return 1;
00086 }
00087 #endif //#ifndef TOLUA_DISABLE
00088 
00089 /* get function: SPL_PENALTY_INACTIVE_PLAYER of class  fawkes::SoccerPenaltyInterface */
00090 #ifndef TOLUA_DISABLE_tolua_get_fawkes__SoccerPenaltyInterface_unsigned_SPL_PENALTY_INACTIVE_PLAYER
00091 static int tolua_get_fawkes__SoccerPenaltyInterface_unsigned_SPL_PENALTY_INACTIVE_PLAYER(lua_State* tolua_S)
00092 {
00093   tolua_pushnumber(tolua_S,(lua_Number)fawkes::SoccerPenaltyInterface::SPL_PENALTY_INACTIVE_PLAYER);
00094  return 1;
00095 }
00096 #endif //#ifndef TOLUA_DISABLE
00097 
00098 /* get function: SPL_PENALTY_ILLEGAL_DEFENDER of class  fawkes::SoccerPenaltyInterface */
00099 #ifndef TOLUA_DISABLE_tolua_get_fawkes__SoccerPenaltyInterface_unsigned_SPL_PENALTY_ILLEGAL_DEFENDER
00100 static int tolua_get_fawkes__SoccerPenaltyInterface_unsigned_SPL_PENALTY_ILLEGAL_DEFENDER(lua_State* tolua_S)
00101 {
00102   tolua_pushnumber(tolua_S,(lua_Number)fawkes::SoccerPenaltyInterface::SPL_PENALTY_ILLEGAL_DEFENDER);
00103  return 1;
00104 }
00105 #endif //#ifndef TOLUA_DISABLE
00106 
00107 /* get function: SPL_PENALTY_LEAVING_THE_FIELD of class  fawkes::SoccerPenaltyInterface */
00108 #ifndef TOLUA_DISABLE_tolua_get_fawkes__SoccerPenaltyInterface_unsigned_SPL_PENALTY_LEAVING_THE_FIELD
00109 static int tolua_get_fawkes__SoccerPenaltyInterface_unsigned_SPL_PENALTY_LEAVING_THE_FIELD(lua_State* tolua_S)
00110 {
00111   tolua_pushnumber(tolua_S,(lua_Number)fawkes::SoccerPenaltyInterface::SPL_PENALTY_LEAVING_THE_FIELD);
00112  return 1;
00113 }
00114 #endif //#ifndef TOLUA_DISABLE
00115 
00116 /* get function: SPL_PENALTY_PLAYING_WITH_HANDS of class  fawkes::SoccerPenaltyInterface */
00117 #ifndef TOLUA_DISABLE_tolua_get_fawkes__SoccerPenaltyInterface_unsigned_SPL_PENALTY_PLAYING_WITH_HANDS
00118 static int tolua_get_fawkes__SoccerPenaltyInterface_unsigned_SPL_PENALTY_PLAYING_WITH_HANDS(lua_State* tolua_S)
00119 {
00120   tolua_pushnumber(tolua_S,(lua_Number)fawkes::SoccerPenaltyInterface::SPL_PENALTY_PLAYING_WITH_HANDS);
00121  return 1;
00122 }
00123 #endif //#ifndef TOLUA_DISABLE
00124 
00125 /* get function: SPL_PENALTY_REQ_FOR_PICKUP of class  fawkes::SoccerPenaltyInterface */
00126 #ifndef TOLUA_DISABLE_tolua_get_fawkes__SoccerPenaltyInterface_unsigned_SPL_PENALTY_REQ_FOR_PICKUP
00127 static int tolua_get_fawkes__SoccerPenaltyInterface_unsigned_SPL_PENALTY_REQ_FOR_PICKUP(lua_State* tolua_S)
00128 {
00129   tolua_pushnumber(tolua_S,(lua_Number)fawkes::SoccerPenaltyInterface::SPL_PENALTY_REQ_FOR_PICKUP);
00130  return 1;
00131 }
00132 #endif //#ifndef TOLUA_DISABLE
00133 
00134 /* get function: SPL_PENALTY_MANUAL of class  fawkes::SoccerPenaltyInterface */
00135 #ifndef TOLUA_DISABLE_tolua_get_fawkes__SoccerPenaltyInterface_unsigned_SPL_PENALTY_MANUAL
00136 static int tolua_get_fawkes__SoccerPenaltyInterface_unsigned_SPL_PENALTY_MANUAL(lua_State* tolua_S)
00137 {
00138   tolua_pushnumber(tolua_S,(lua_Number)fawkes::SoccerPenaltyInterface::SPL_PENALTY_MANUAL);
00139  return 1;
00140 }
00141 #endif //#ifndef TOLUA_DISABLE
00142 
00143 /* method: new of class  SetPenaltyMessage */
00144 #ifndef TOLUA_DISABLE_tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_SetPenaltyMessage_new00
00145 static int tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_SetPenaltyMessage_new00(lua_State* tolua_S)
00146 {
00147 #ifndef TOLUA_RELEASE
00148  tolua_Error tolua_err;
00149  if (
00150      !tolua_isusertable(tolua_S,1,"fawkes::SoccerPenaltyInterface::SetPenaltyMessage",0,&tolua_err) ||
00151      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00152      !tolua_isnoobj(tolua_S,3,&tolua_err)
00153  )
00154   goto tolua_lerror;
00155  else
00156 #endif
00157  {
00158   unsigned short ini_penalty = ((unsigned short)  tolua_tonumber(tolua_S,2,0));
00159   {
00160    fawkes::SoccerPenaltyInterface::SetPenaltyMessage* tolua_ret = (fawkes::SoccerPenaltyInterface::SetPenaltyMessage*)  Mtolua_new((fawkes::SoccerPenaltyInterface::SetPenaltyMessage)(ini_penalty));
00161     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::SoccerPenaltyInterface::SetPenaltyMessage");
00162   }
00163  }
00164  return 1;
00165 #ifndef TOLUA_RELEASE
00166  tolua_lerror:
00167  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00168  return 0;
00169 #endif
00170 }
00171 #endif //#ifndef TOLUA_DISABLE
00172 
00173 /* method: new_local of class  SetPenaltyMessage */
00174 #ifndef TOLUA_DISABLE_tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_SetPenaltyMessage_new00_local
00175 static int tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_SetPenaltyMessage_new00_local(lua_State* tolua_S)
00176 {
00177 #ifndef TOLUA_RELEASE
00178  tolua_Error tolua_err;
00179  if (
00180      !tolua_isusertable(tolua_S,1,"fawkes::SoccerPenaltyInterface::SetPenaltyMessage",0,&tolua_err) ||
00181      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00182      !tolua_isnoobj(tolua_S,3,&tolua_err)
00183  )
00184   goto tolua_lerror;
00185  else
00186 #endif
00187  {
00188   unsigned short ini_penalty = ((unsigned short)  tolua_tonumber(tolua_S,2,0));
00189   {
00190    fawkes::SoccerPenaltyInterface::SetPenaltyMessage* tolua_ret = (fawkes::SoccerPenaltyInterface::SetPenaltyMessage*)  Mtolua_new((fawkes::SoccerPenaltyInterface::SetPenaltyMessage)(ini_penalty));
00191     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::SoccerPenaltyInterface::SetPenaltyMessage");
00192     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00193   }
00194  }
00195  return 1;
00196 #ifndef TOLUA_RELEASE
00197  tolua_lerror:
00198  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00199  return 0;
00200 #endif
00201 }
00202 #endif //#ifndef TOLUA_DISABLE
00203 
00204 /* method: new of class  SetPenaltyMessage */
00205 #ifndef TOLUA_DISABLE_tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_SetPenaltyMessage_new01
00206 static int tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_SetPenaltyMessage_new01(lua_State* tolua_S)
00207 {
00208  tolua_Error tolua_err;
00209  if (
00210      !tolua_isusertable(tolua_S,1,"fawkes::SoccerPenaltyInterface::SetPenaltyMessage",0,&tolua_err) ||
00211      !tolua_isnoobj(tolua_S,2,&tolua_err)
00212  )
00213   goto tolua_lerror;
00214  else
00215  {
00216   {
00217    fawkes::SoccerPenaltyInterface::SetPenaltyMessage* tolua_ret = (fawkes::SoccerPenaltyInterface::SetPenaltyMessage*)  Mtolua_new((fawkes::SoccerPenaltyInterface::SetPenaltyMessage)());
00218     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::SoccerPenaltyInterface::SetPenaltyMessage");
00219   }
00220  }
00221  return 1;
00222 tolua_lerror:
00223  return tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_SetPenaltyMessage_new00(tolua_S);
00224 }
00225 #endif //#ifndef TOLUA_DISABLE
00226 
00227 /* method: new_local of class  SetPenaltyMessage */
00228 #ifndef TOLUA_DISABLE_tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_SetPenaltyMessage_new01_local
00229 static int tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_SetPenaltyMessage_new01_local(lua_State* tolua_S)
00230 {
00231  tolua_Error tolua_err;
00232  if (
00233      !tolua_isusertable(tolua_S,1,"fawkes::SoccerPenaltyInterface::SetPenaltyMessage",0,&tolua_err) ||
00234      !tolua_isnoobj(tolua_S,2,&tolua_err)
00235  )
00236   goto tolua_lerror;
00237  else
00238  {
00239   {
00240    fawkes::SoccerPenaltyInterface::SetPenaltyMessage* tolua_ret = (fawkes::SoccerPenaltyInterface::SetPenaltyMessage*)  Mtolua_new((fawkes::SoccerPenaltyInterface::SetPenaltyMessage)());
00241     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::SoccerPenaltyInterface::SetPenaltyMessage");
00242     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00243   }
00244  }
00245  return 1;
00246 tolua_lerror:
00247  return tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_SetPenaltyMessage_new00_local(tolua_S);
00248 }
00249 #endif //#ifndef TOLUA_DISABLE
00250 
00251 /* method: delete of class  SetPenaltyMessage */
00252 #ifndef TOLUA_DISABLE_tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_SetPenaltyMessage_delete00
00253 static int tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_SetPenaltyMessage_delete00(lua_State* tolua_S)
00254 {
00255 #ifndef TOLUA_RELEASE
00256  tolua_Error tolua_err;
00257  if (
00258      !tolua_isusertype(tolua_S,1,"fawkes::SoccerPenaltyInterface::SetPenaltyMessage",0,&tolua_err) ||
00259      !tolua_isnoobj(tolua_S,2,&tolua_err)
00260  )
00261   goto tolua_lerror;
00262  else
00263 #endif
00264  {
00265   fawkes::SoccerPenaltyInterface::SetPenaltyMessage* self = (fawkes::SoccerPenaltyInterface::SetPenaltyMessage*)  tolua_tousertype(tolua_S,1,0);
00266 #ifndef TOLUA_RELEASE
00267   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
00268 #endif
00269   Mtolua_delete(self);
00270  }
00271  return 0;
00272 #ifndef TOLUA_RELEASE
00273  tolua_lerror:
00274  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
00275  return 0;
00276 #endif
00277 }
00278 #endif //#ifndef TOLUA_DISABLE
00279 
00280 /* method: penalty of class  SetPenaltyMessage */
00281 #ifndef TOLUA_DISABLE_tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_SetPenaltyMessage_penalty00
00282 static int tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_SetPenaltyMessage_penalty00(lua_State* tolua_S)
00283 {
00284 #ifndef TOLUA_RELEASE
00285  tolua_Error tolua_err;
00286  if (
00287      !tolua_isusertype(tolua_S,1,"fawkes::SoccerPenaltyInterface::SetPenaltyMessage",0,&tolua_err) ||
00288      !tolua_isnoobj(tolua_S,2,&tolua_err)
00289  )
00290   goto tolua_lerror;
00291  else
00292 #endif
00293  {
00294   fawkes::SoccerPenaltyInterface::SetPenaltyMessage* self = (fawkes::SoccerPenaltyInterface::SetPenaltyMessage*)  tolua_tousertype(tolua_S,1,0);
00295 #ifndef TOLUA_RELEASE
00296   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'penalty'", NULL);
00297 #endif
00298   {
00299    unsigned short tolua_ret = (unsigned short)  self->penalty();
00300    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00301   }
00302  }
00303  return 1;
00304 #ifndef TOLUA_RELEASE
00305  tolua_lerror:
00306  tolua_error(tolua_S,"#ferror in function 'penalty'.",&tolua_err);
00307  return 0;
00308 #endif
00309 }
00310 #endif //#ifndef TOLUA_DISABLE
00311 
00312 /* method: set_penalty of class  SetPenaltyMessage */
00313 #ifndef TOLUA_DISABLE_tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_SetPenaltyMessage_set_penalty00
00314 static int tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_SetPenaltyMessage_set_penalty00(lua_State* tolua_S)
00315 {
00316 #ifndef TOLUA_RELEASE
00317  tolua_Error tolua_err;
00318  if (
00319      !tolua_isusertype(tolua_S,1,"fawkes::SoccerPenaltyInterface::SetPenaltyMessage",0,&tolua_err) ||
00320      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00321      !tolua_isnoobj(tolua_S,3,&tolua_err)
00322  )
00323   goto tolua_lerror;
00324  else
00325 #endif
00326  {
00327   fawkes::SoccerPenaltyInterface::SetPenaltyMessage* self = (fawkes::SoccerPenaltyInterface::SetPenaltyMessage*)  tolua_tousertype(tolua_S,1,0);
00328   unsigned const short new_penalty = ((unsigned const short)  tolua_tonumber(tolua_S,2,0));
00329 #ifndef TOLUA_RELEASE
00330   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_penalty'", NULL);
00331 #endif
00332   {
00333    self->set_penalty(new_penalty);
00334   }
00335  }
00336  return 0;
00337 #ifndef TOLUA_RELEASE
00338  tolua_lerror:
00339  tolua_error(tolua_S,"#ferror in function 'set_penalty'.",&tolua_err);
00340  return 0;
00341 #endif
00342 }
00343 #endif //#ifndef TOLUA_DISABLE
00344 
00345 /* method: maxlenof_penalty of class  SetPenaltyMessage */
00346 #ifndef TOLUA_DISABLE_tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_SetPenaltyMessage_maxlenof_penalty00
00347 static int tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_SetPenaltyMessage_maxlenof_penalty00(lua_State* tolua_S)
00348 {
00349 #ifndef TOLUA_RELEASE
00350  tolua_Error tolua_err;
00351  if (
00352      !tolua_isusertype(tolua_S,1,"const fawkes::SoccerPenaltyInterface::SetPenaltyMessage",0,&tolua_err) ||
00353      !tolua_isnoobj(tolua_S,2,&tolua_err)
00354  )
00355   goto tolua_lerror;
00356  else
00357 #endif
00358  {
00359   const fawkes::SoccerPenaltyInterface::SetPenaltyMessage* self = (const fawkes::SoccerPenaltyInterface::SetPenaltyMessage*)  tolua_tousertype(tolua_S,1,0);
00360 #ifndef TOLUA_RELEASE
00361   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_penalty'", NULL);
00362 #endif
00363   {
00364    int tolua_ret = (int)  self->maxlenof_penalty();
00365    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00366   }
00367  }
00368  return 1;
00369 #ifndef TOLUA_RELEASE
00370  tolua_lerror:
00371  tolua_error(tolua_S,"#ferror in function 'maxlenof_penalty'.",&tolua_err);
00372  return 0;
00373 #endif
00374 }
00375 #endif //#ifndef TOLUA_DISABLE
00376 
00377 /* method: penalty of class  fawkes::SoccerPenaltyInterface */
00378 #ifndef TOLUA_DISABLE_tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_penalty00
00379 static int tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_penalty00(lua_State* tolua_S)
00380 {
00381 #ifndef TOLUA_RELEASE
00382  tolua_Error tolua_err;
00383  if (
00384      !tolua_isusertype(tolua_S,1,"fawkes::SoccerPenaltyInterface",0,&tolua_err) ||
00385      !tolua_isnoobj(tolua_S,2,&tolua_err)
00386  )
00387   goto tolua_lerror;
00388  else
00389 #endif
00390  {
00391   fawkes::SoccerPenaltyInterface* self = (fawkes::SoccerPenaltyInterface*)  tolua_tousertype(tolua_S,1,0);
00392 #ifndef TOLUA_RELEASE
00393   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'penalty'", NULL);
00394 #endif
00395   {
00396    unsigned short tolua_ret = (unsigned short)  self->penalty();
00397    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00398   }
00399  }
00400  return 1;
00401 #ifndef TOLUA_RELEASE
00402  tolua_lerror:
00403  tolua_error(tolua_S,"#ferror in function 'penalty'.",&tolua_err);
00404  return 0;
00405 #endif
00406 }
00407 #endif //#ifndef TOLUA_DISABLE
00408 
00409 /* method: set_penalty of class  fawkes::SoccerPenaltyInterface */
00410 #ifndef TOLUA_DISABLE_tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_set_penalty00
00411 static int tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_set_penalty00(lua_State* tolua_S)
00412 {
00413 #ifndef TOLUA_RELEASE
00414  tolua_Error tolua_err;
00415  if (
00416      !tolua_isusertype(tolua_S,1,"fawkes::SoccerPenaltyInterface",0,&tolua_err) ||
00417      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00418      !tolua_isnoobj(tolua_S,3,&tolua_err)
00419  )
00420   goto tolua_lerror;
00421  else
00422 #endif
00423  {
00424   fawkes::SoccerPenaltyInterface* self = (fawkes::SoccerPenaltyInterface*)  tolua_tousertype(tolua_S,1,0);
00425   unsigned const short new_penalty = ((unsigned const short)  tolua_tonumber(tolua_S,2,0));
00426 #ifndef TOLUA_RELEASE
00427   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_penalty'", NULL);
00428 #endif
00429   {
00430    self->set_penalty(new_penalty);
00431   }
00432  }
00433  return 0;
00434 #ifndef TOLUA_RELEASE
00435  tolua_lerror:
00436  tolua_error(tolua_S,"#ferror in function 'set_penalty'.",&tolua_err);
00437  return 0;
00438 #endif
00439 }
00440 #endif //#ifndef TOLUA_DISABLE
00441 
00442 /* method: maxlenof_penalty of class  fawkes::SoccerPenaltyInterface */
00443 #ifndef TOLUA_DISABLE_tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_maxlenof_penalty00
00444 static int tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_maxlenof_penalty00(lua_State* tolua_S)
00445 {
00446 #ifndef TOLUA_RELEASE
00447  tolua_Error tolua_err;
00448  if (
00449      !tolua_isusertype(tolua_S,1,"const fawkes::SoccerPenaltyInterface",0,&tolua_err) ||
00450      !tolua_isnoobj(tolua_S,2,&tolua_err)
00451  )
00452   goto tolua_lerror;
00453  else
00454 #endif
00455  {
00456   const fawkes::SoccerPenaltyInterface* self = (const fawkes::SoccerPenaltyInterface*)  tolua_tousertype(tolua_S,1,0);
00457 #ifndef TOLUA_RELEASE
00458   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_penalty'", NULL);
00459 #endif
00460   {
00461    int tolua_ret = (int)  self->maxlenof_penalty();
00462    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00463   }
00464  }
00465  return 1;
00466 #ifndef TOLUA_RELEASE
00467  tolua_lerror:
00468  tolua_error(tolua_S,"#ferror in function 'maxlenof_penalty'.",&tolua_err);
00469  return 0;
00470 #endif
00471 }
00472 #endif //#ifndef TOLUA_DISABLE
00473 
00474 /* method: remaining of class  fawkes::SoccerPenaltyInterface */
00475 #ifndef TOLUA_DISABLE_tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_remaining00
00476 static int tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_remaining00(lua_State* tolua_S)
00477 {
00478 #ifndef TOLUA_RELEASE
00479  tolua_Error tolua_err;
00480  if (
00481      !tolua_isusertype(tolua_S,1,"fawkes::SoccerPenaltyInterface",0,&tolua_err) ||
00482      !tolua_isnoobj(tolua_S,2,&tolua_err)
00483  )
00484   goto tolua_lerror;
00485  else
00486 #endif
00487  {
00488   fawkes::SoccerPenaltyInterface* self = (fawkes::SoccerPenaltyInterface*)  tolua_tousertype(tolua_S,1,0);
00489 #ifndef TOLUA_RELEASE
00490   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'remaining'", NULL);
00491 #endif
00492   {
00493    unsigned short tolua_ret = (unsigned short)  self->remaining();
00494    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00495   }
00496  }
00497  return 1;
00498 #ifndef TOLUA_RELEASE
00499  tolua_lerror:
00500  tolua_error(tolua_S,"#ferror in function 'remaining'.",&tolua_err);
00501  return 0;
00502 #endif
00503 }
00504 #endif //#ifndef TOLUA_DISABLE
00505 
00506 /* method: set_remaining of class  fawkes::SoccerPenaltyInterface */
00507 #ifndef TOLUA_DISABLE_tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_set_remaining00
00508 static int tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_set_remaining00(lua_State* tolua_S)
00509 {
00510 #ifndef TOLUA_RELEASE
00511  tolua_Error tolua_err;
00512  if (
00513      !tolua_isusertype(tolua_S,1,"fawkes::SoccerPenaltyInterface",0,&tolua_err) ||
00514      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00515      !tolua_isnoobj(tolua_S,3,&tolua_err)
00516  )
00517   goto tolua_lerror;
00518  else
00519 #endif
00520  {
00521   fawkes::SoccerPenaltyInterface* self = (fawkes::SoccerPenaltyInterface*)  tolua_tousertype(tolua_S,1,0);
00522   unsigned const short new_remaining = ((unsigned const short)  tolua_tonumber(tolua_S,2,0));
00523 #ifndef TOLUA_RELEASE
00524   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_remaining'", NULL);
00525 #endif
00526   {
00527    self->set_remaining(new_remaining);
00528   }
00529  }
00530  return 0;
00531 #ifndef TOLUA_RELEASE
00532  tolua_lerror:
00533  tolua_error(tolua_S,"#ferror in function 'set_remaining'.",&tolua_err);
00534  return 0;
00535 #endif
00536 }
00537 #endif //#ifndef TOLUA_DISABLE
00538 
00539 /* method: maxlenof_remaining of class  fawkes::SoccerPenaltyInterface */
00540 #ifndef TOLUA_DISABLE_tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_maxlenof_remaining00
00541 static int tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_maxlenof_remaining00(lua_State* tolua_S)
00542 {
00543 #ifndef TOLUA_RELEASE
00544  tolua_Error tolua_err;
00545  if (
00546      !tolua_isusertype(tolua_S,1,"const fawkes::SoccerPenaltyInterface",0,&tolua_err) ||
00547      !tolua_isnoobj(tolua_S,2,&tolua_err)
00548  )
00549   goto tolua_lerror;
00550  else
00551 #endif
00552  {
00553   const fawkes::SoccerPenaltyInterface* self = (const fawkes::SoccerPenaltyInterface*)  tolua_tousertype(tolua_S,1,0);
00554 #ifndef TOLUA_RELEASE
00555   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_remaining'", NULL);
00556 #endif
00557   {
00558    int tolua_ret = (int)  self->maxlenof_remaining();
00559    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00560   }
00561  }
00562  return 1;
00563 #ifndef TOLUA_RELEASE
00564  tolua_lerror:
00565  tolua_error(tolua_S,"#ferror in function 'maxlenof_remaining'.",&tolua_err);
00566  return 0;
00567 #endif
00568 }
00569 #endif //#ifndef TOLUA_DISABLE
00570 
00571 /* method: oftype of class  fawkes::SoccerPenaltyInterface */
00572 #ifndef TOLUA_DISABLE_tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_oftype00
00573 static int tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_oftype00(lua_State* tolua_S)
00574 {
00575 #ifndef TOLUA_RELEASE
00576  tolua_Error tolua_err;
00577  if (
00578      !tolua_isusertype(tolua_S,1,"const fawkes::SoccerPenaltyInterface",0,&tolua_err) ||
00579      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
00580      !tolua_isnoobj(tolua_S,3,&tolua_err)
00581  )
00582   goto tolua_lerror;
00583  else
00584 #endif
00585  {
00586   const fawkes::SoccerPenaltyInterface* self = (const fawkes::SoccerPenaltyInterface*)  tolua_tousertype(tolua_S,1,0);
00587   const char* interface_type = ((const char*)  tolua_tostring(tolua_S,2,0));
00588 #ifndef TOLUA_RELEASE
00589   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'oftype'", NULL);
00590 #endif
00591   {
00592    bool tolua_ret = (bool)  self->oftype(interface_type);
00593    tolua_pushboolean(tolua_S,(bool)tolua_ret);
00594   }
00595  }
00596  return 1;
00597 #ifndef TOLUA_RELEASE
00598  tolua_lerror:
00599  tolua_error(tolua_S,"#ferror in function 'oftype'.",&tolua_err);
00600  return 0;
00601 #endif
00602 }
00603 #endif //#ifndef TOLUA_DISABLE
00604 
00605 /* method: datachunk of class  fawkes::SoccerPenaltyInterface */
00606 #ifndef TOLUA_DISABLE_tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_datachunk00
00607 static int tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_datachunk00(lua_State* tolua_S)
00608 {
00609 #ifndef TOLUA_RELEASE
00610  tolua_Error tolua_err;
00611  if (
00612      !tolua_isusertype(tolua_S,1,"const fawkes::SoccerPenaltyInterface",0,&tolua_err) ||
00613      !tolua_isnoobj(tolua_S,2,&tolua_err)
00614  )
00615   goto tolua_lerror;
00616  else
00617 #endif
00618  {
00619   const fawkes::SoccerPenaltyInterface* self = (const fawkes::SoccerPenaltyInterface*)  tolua_tousertype(tolua_S,1,0);
00620 #ifndef TOLUA_RELEASE
00621   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datachunk'", NULL);
00622 #endif
00623   {
00624    const void* tolua_ret = (const void*)  self->datachunk();
00625    tolua_pushuserdata(tolua_S,(void*)tolua_ret);
00626   }
00627  }
00628  return 1;
00629 #ifndef TOLUA_RELEASE
00630  tolua_lerror:
00631  tolua_error(tolua_S,"#ferror in function 'datachunk'.",&tolua_err);
00632  return 0;
00633 #endif
00634 }
00635 #endif //#ifndef TOLUA_DISABLE
00636 
00637 /* method: datasize of class  fawkes::SoccerPenaltyInterface */
00638 #ifndef TOLUA_DISABLE_tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_datasize00
00639 static int tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_datasize00(lua_State* tolua_S)
00640 {
00641 #ifndef TOLUA_RELEASE
00642  tolua_Error tolua_err;
00643  if (
00644      !tolua_isusertype(tolua_S,1,"const fawkes::SoccerPenaltyInterface",0,&tolua_err) ||
00645      !tolua_isnoobj(tolua_S,2,&tolua_err)
00646  )
00647   goto tolua_lerror;
00648  else
00649 #endif
00650  {
00651   const fawkes::SoccerPenaltyInterface* self = (const fawkes::SoccerPenaltyInterface*)  tolua_tousertype(tolua_S,1,0);
00652 #ifndef TOLUA_RELEASE
00653   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datasize'", NULL);
00654 #endif
00655   {
00656    unsigned int tolua_ret = (unsigned int)  self->datasize();
00657    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00658   }
00659  }
00660  return 1;
00661 #ifndef TOLUA_RELEASE
00662  tolua_lerror:
00663  tolua_error(tolua_S,"#ferror in function 'datasize'.",&tolua_err);
00664  return 0;
00665 #endif
00666 }
00667 #endif //#ifndef TOLUA_DISABLE
00668 
00669 /* method: type of class  fawkes::SoccerPenaltyInterface */
00670 #ifndef TOLUA_DISABLE_tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_type00
00671 static int tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_type00(lua_State* tolua_S)
00672 {
00673 #ifndef TOLUA_RELEASE
00674  tolua_Error tolua_err;
00675  if (
00676      !tolua_isusertype(tolua_S,1,"const fawkes::SoccerPenaltyInterface",0,&tolua_err) ||
00677      !tolua_isnoobj(tolua_S,2,&tolua_err)
00678  )
00679   goto tolua_lerror;
00680  else
00681 #endif
00682  {
00683   const fawkes::SoccerPenaltyInterface* self = (const fawkes::SoccerPenaltyInterface*)  tolua_tousertype(tolua_S,1,0);
00684 #ifndef TOLUA_RELEASE
00685   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'type'", NULL);
00686 #endif
00687   {
00688    const char* tolua_ret = (const char*)  self->type();
00689    tolua_pushstring(tolua_S,(const char*)tolua_ret);
00690   }
00691  }
00692  return 1;
00693 #ifndef TOLUA_RELEASE
00694  tolua_lerror:
00695  tolua_error(tolua_S,"#ferror in function 'type'.",&tolua_err);
00696  return 0;
00697 #endif
00698 }
00699 #endif //#ifndef TOLUA_DISABLE
00700 
00701 /* method: id of class  fawkes::SoccerPenaltyInterface */
00702 #ifndef TOLUA_DISABLE_tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_id00
00703 static int tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_id00(lua_State* tolua_S)
00704 {
00705 #ifndef TOLUA_RELEASE
00706  tolua_Error tolua_err;
00707  if (
00708      !tolua_isusertype(tolua_S,1,"const fawkes::SoccerPenaltyInterface",0,&tolua_err) ||
00709      !tolua_isnoobj(tolua_S,2,&tolua_err)
00710  )
00711   goto tolua_lerror;
00712  else
00713 #endif
00714  {
00715   const fawkes::SoccerPenaltyInterface* self = (const fawkes::SoccerPenaltyInterface*)  tolua_tousertype(tolua_S,1,0);
00716 #ifndef TOLUA_RELEASE
00717   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'id'", NULL);
00718 #endif
00719   {
00720    const char* tolua_ret = (const char*)  self->id();
00721    tolua_pushstring(tolua_S,(const char*)tolua_ret);
00722   }
00723  }
00724  return 1;
00725 #ifndef TOLUA_RELEASE
00726  tolua_lerror:
00727  tolua_error(tolua_S,"#ferror in function 'id'.",&tolua_err);
00728  return 0;
00729 #endif
00730 }
00731 #endif //#ifndef TOLUA_DISABLE
00732 
00733 /* method: uid of class  fawkes::SoccerPenaltyInterface */
00734 #ifndef TOLUA_DISABLE_tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_uid00
00735 static int tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_uid00(lua_State* tolua_S)
00736 {
00737 #ifndef TOLUA_RELEASE
00738  tolua_Error tolua_err;
00739  if (
00740      !tolua_isusertype(tolua_S,1,"const fawkes::SoccerPenaltyInterface",0,&tolua_err) ||
00741      !tolua_isnoobj(tolua_S,2,&tolua_err)
00742  )
00743   goto tolua_lerror;
00744  else
00745 #endif
00746  {
00747   const fawkes::SoccerPenaltyInterface* self = (const fawkes::SoccerPenaltyInterface*)  tolua_tousertype(tolua_S,1,0);
00748 #ifndef TOLUA_RELEASE
00749   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'uid'", NULL);
00750 #endif
00751   {
00752    const char* tolua_ret = (const char*)  self->uid();
00753    tolua_pushstring(tolua_S,(const char*)tolua_ret);
00754   }
00755  }
00756  return 1;
00757 #ifndef TOLUA_RELEASE
00758  tolua_lerror:
00759  tolua_error(tolua_S,"#ferror in function 'uid'.",&tolua_err);
00760  return 0;
00761 #endif
00762 }
00763 #endif //#ifndef TOLUA_DISABLE
00764 
00765 /* method: serial of class  fawkes::SoccerPenaltyInterface */
00766 #ifndef TOLUA_DISABLE_tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_serial00
00767 static int tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_serial00(lua_State* tolua_S)
00768 {
00769 #ifndef TOLUA_RELEASE
00770  tolua_Error tolua_err;
00771  if (
00772      !tolua_isusertype(tolua_S,1,"const fawkes::SoccerPenaltyInterface",0,&tolua_err) ||
00773      !tolua_isnoobj(tolua_S,2,&tolua_err)
00774  )
00775   goto tolua_lerror;
00776  else
00777 #endif
00778  {
00779   const fawkes::SoccerPenaltyInterface* self = (const fawkes::SoccerPenaltyInterface*)  tolua_tousertype(tolua_S,1,0);
00780 #ifndef TOLUA_RELEASE
00781   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'serial'", NULL);
00782 #endif
00783   {
00784    unsigned int tolua_ret = (unsigned int)  self->serial();
00785    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00786   }
00787  }
00788  return 1;
00789 #ifndef TOLUA_RELEASE
00790  tolua_lerror:
00791  tolua_error(tolua_S,"#ferror in function 'serial'.",&tolua_err);
00792  return 0;
00793 #endif
00794 }
00795 #endif //#ifndef TOLUA_DISABLE
00796 
00797 /* method: mem_serial of class  fawkes::SoccerPenaltyInterface */
00798 #ifndef TOLUA_DISABLE_tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_mem_serial00
00799 static int tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_mem_serial00(lua_State* tolua_S)
00800 {
00801 #ifndef TOLUA_RELEASE
00802  tolua_Error tolua_err;
00803  if (
00804      !tolua_isusertype(tolua_S,1,"const fawkes::SoccerPenaltyInterface",0,&tolua_err) ||
00805      !tolua_isnoobj(tolua_S,2,&tolua_err)
00806  )
00807   goto tolua_lerror;
00808  else
00809 #endif
00810  {
00811   const fawkes::SoccerPenaltyInterface* self = (const fawkes::SoccerPenaltyInterface*)  tolua_tousertype(tolua_S,1,0);
00812 #ifndef TOLUA_RELEASE
00813   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'mem_serial'", NULL);
00814 #endif
00815   {
00816    unsigned int tolua_ret = (unsigned int)  self->mem_serial();
00817    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00818   }
00819  }
00820  return 1;
00821 #ifndef TOLUA_RELEASE
00822  tolua_lerror:
00823  tolua_error(tolua_S,"#ferror in function 'mem_serial'.",&tolua_err);
00824  return 0;
00825 #endif
00826 }
00827 #endif //#ifndef TOLUA_DISABLE
00828 
00829 /* method: operator== of class  fawkes::SoccerPenaltyInterface */
00830 #ifndef TOLUA_DISABLE_tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface__eq00
00831 static int tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface__eq00(lua_State* tolua_S)
00832 {
00833 #ifndef TOLUA_RELEASE
00834  tolua_Error tolua_err;
00835  if (
00836      !tolua_isusertype(tolua_S,1,"const fawkes::SoccerPenaltyInterface",0,&tolua_err) ||
00837      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Interface",0,&tolua_err)) ||
00838      !tolua_isnoobj(tolua_S,3,&tolua_err)
00839  )
00840   goto tolua_lerror;
00841  else
00842 #endif
00843  {
00844   const fawkes::SoccerPenaltyInterface* self = (const fawkes::SoccerPenaltyInterface*)  tolua_tousertype(tolua_S,1,0);
00845   Interface* comp = ((Interface*)  tolua_tousertype(tolua_S,2,0));
00846 #ifndef TOLUA_RELEASE
00847   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='", NULL);
00848 #endif
00849   {
00850    bool tolua_ret = (bool)  self->operator==(*comp);
00851    tolua_pushboolean(tolua_S,(bool)tolua_ret);
00852   }
00853  }
00854  return 1;
00855 #ifndef TOLUA_RELEASE
00856  tolua_lerror:
00857  tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err);
00858  return 0;
00859 #endif
00860 }
00861 #endif //#ifndef TOLUA_DISABLE
00862 
00863 /* method: hash of class  fawkes::SoccerPenaltyInterface */
00864 #ifndef TOLUA_DISABLE_tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_hash00
00865 static int tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_hash00(lua_State* tolua_S)
00866 {
00867 #ifndef TOLUA_RELEASE
00868  tolua_Error tolua_err;
00869  if (
00870      !tolua_isusertype(tolua_S,1,"const fawkes::SoccerPenaltyInterface",0,&tolua_err) ||
00871      !tolua_isnoobj(tolua_S,2,&tolua_err)
00872  )
00873   goto tolua_lerror;
00874  else
00875 #endif
00876  {
00877   const fawkes::SoccerPenaltyInterface* self = (const fawkes::SoccerPenaltyInterface*)  tolua_tousertype(tolua_S,1,0);
00878 #ifndef TOLUA_RELEASE
00879   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash'", NULL);
00880 #endif
00881   {
00882    unsigned const char* tolua_ret = ( unsigned const char*)  self->hash();
00883    tolua_pushstring(tolua_S,(const char*)tolua_ret);
00884   }
00885  }
00886  return 1;
00887 #ifndef TOLUA_RELEASE
00888  tolua_lerror:
00889  tolua_error(tolua_S,"#ferror in function 'hash'.",&tolua_err);
00890  return 0;
00891 #endif
00892 }
00893 #endif //#ifndef TOLUA_DISABLE
00894 
00895 /* method: hash_size of class  fawkes::SoccerPenaltyInterface */
00896 #ifndef TOLUA_DISABLE_tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_hash_size00
00897 static int tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_hash_size00(lua_State* tolua_S)
00898 {
00899 #ifndef TOLUA_RELEASE
00900  tolua_Error tolua_err;
00901  if (
00902      !tolua_isusertype(tolua_S,1,"const fawkes::SoccerPenaltyInterface",0,&tolua_err) ||
00903      !tolua_isnoobj(tolua_S,2,&tolua_err)
00904  )
00905   goto tolua_lerror;
00906  else
00907 #endif
00908  {
00909   const fawkes::SoccerPenaltyInterface* self = (const fawkes::SoccerPenaltyInterface*)  tolua_tousertype(tolua_S,1,0);
00910 #ifndef TOLUA_RELEASE
00911   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash_size'", NULL);
00912 #endif
00913   {
00914    int tolua_ret = (int)  self->hash_size();
00915    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00916   }
00917  }
00918  return 1;
00919 #ifndef TOLUA_RELEASE
00920  tolua_lerror:
00921  tolua_error(tolua_S,"#ferror in function 'hash_size'.",&tolua_err);
00922  return 0;
00923 #endif
00924 }
00925 #endif //#ifndef TOLUA_DISABLE
00926 
00927 /* method: hash_printable of class  fawkes::SoccerPenaltyInterface */
00928 #ifndef TOLUA_DISABLE_tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_hash_printable00
00929 static int tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_hash_printable00(lua_State* tolua_S)
00930 {
00931 #ifndef TOLUA_RELEASE
00932  tolua_Error tolua_err;
00933  if (
00934      !tolua_isusertype(tolua_S,1,"const fawkes::SoccerPenaltyInterface",0,&tolua_err) ||
00935      !tolua_isnoobj(tolua_S,2,&tolua_err)
00936  )
00937   goto tolua_lerror;
00938  else
00939 #endif
00940  {
00941   const fawkes::SoccerPenaltyInterface* self = (const fawkes::SoccerPenaltyInterface*)  tolua_tousertype(tolua_S,1,0);
00942 #ifndef TOLUA_RELEASE
00943   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash_printable'", NULL);
00944 #endif
00945   {
00946    const char* tolua_ret = (const char*)  self->hash_printable();
00947    tolua_pushstring(tolua_S,(const char*)tolua_ret);
00948   }
00949  }
00950  return 1;
00951 #ifndef TOLUA_RELEASE
00952  tolua_lerror:
00953  tolua_error(tolua_S,"#ferror in function 'hash_printable'.",&tolua_err);
00954  return 0;
00955 #endif
00956 }
00957 #endif //#ifndef TOLUA_DISABLE
00958 
00959 /* method: is_writer of class  fawkes::SoccerPenaltyInterface */
00960 #ifndef TOLUA_DISABLE_tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_is_writer00
00961 static int tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_is_writer00(lua_State* tolua_S)
00962 {
00963 #ifndef TOLUA_RELEASE
00964  tolua_Error tolua_err;
00965  if (
00966      !tolua_isusertype(tolua_S,1,"const fawkes::SoccerPenaltyInterface",0,&tolua_err) ||
00967      !tolua_isnoobj(tolua_S,2,&tolua_err)
00968  )
00969   goto tolua_lerror;
00970  else
00971 #endif
00972  {
00973   const fawkes::SoccerPenaltyInterface* self = (const fawkes::SoccerPenaltyInterface*)  tolua_tousertype(tolua_S,1,0);
00974 #ifndef TOLUA_RELEASE
00975   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_writer'", NULL);
00976 #endif
00977   {
00978    bool tolua_ret = (bool)  self->is_writer();
00979    tolua_pushboolean(tolua_S,(bool)tolua_ret);
00980   }
00981  }
00982  return 1;
00983 #ifndef TOLUA_RELEASE
00984  tolua_lerror:
00985  tolua_error(tolua_S,"#ferror in function 'is_writer'.",&tolua_err);
00986  return 0;
00987 #endif
00988 }
00989 #endif //#ifndef TOLUA_DISABLE
00990 
00991 /* method: set_from_chunk of class  fawkes::SoccerPenaltyInterface */
00992 #ifndef TOLUA_DISABLE_tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_set_from_chunk00
00993 static int tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_set_from_chunk00(lua_State* tolua_S)
00994 {
00995 #ifndef TOLUA_RELEASE
00996  tolua_Error tolua_err;
00997  if (
00998      !tolua_isusertype(tolua_S,1,"fawkes::SoccerPenaltyInterface",0,&tolua_err) ||
00999      !tolua_isuserdata(tolua_S,2,0,&tolua_err) ||
01000      !tolua_isnoobj(tolua_S,3,&tolua_err)
01001  )
01002   goto tolua_lerror;
01003  else
01004 #endif
01005  {
01006   fawkes::SoccerPenaltyInterface* self = (fawkes::SoccerPenaltyInterface*)  tolua_tousertype(tolua_S,1,0);
01007   void* chunk = ((void*)  tolua_touserdata(tolua_S,2,0));
01008 #ifndef TOLUA_RELEASE
01009   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_from_chunk'", NULL);
01010 #endif
01011   {
01012    self->set_from_chunk(chunk);
01013   }
01014  }
01015  return 0;
01016 #ifndef TOLUA_RELEASE
01017  tolua_lerror:
01018  tolua_error(tolua_S,"#ferror in function 'set_from_chunk'.",&tolua_err);
01019  return 0;
01020 #endif
01021 }
01022 #endif //#ifndef TOLUA_DISABLE
01023 
01024 /* method: create_message of class  fawkes::SoccerPenaltyInterface */
01025 #ifndef TOLUA_DISABLE_tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_create_message00
01026 static int tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_create_message00(lua_State* tolua_S)
01027 {
01028 #ifndef TOLUA_RELEASE
01029  tolua_Error tolua_err;
01030  if (
01031      !tolua_isusertype(tolua_S,1,"const fawkes::SoccerPenaltyInterface",0,&tolua_err) ||
01032      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
01033      !tolua_isnoobj(tolua_S,3,&tolua_err)
01034  )
01035   goto tolua_lerror;
01036  else
01037 #endif
01038  {
01039   const fawkes::SoccerPenaltyInterface* self = (const fawkes::SoccerPenaltyInterface*)  tolua_tousertype(tolua_S,1,0);
01040   const char* type = ((const char*)  tolua_tostring(tolua_S,2,0));
01041 #ifndef TOLUA_RELEASE
01042   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'create_message'", NULL);
01043 #endif
01044   {
01045    Message* tolua_ret = (Message*)  self->create_message(type);
01046     tolua_pushusertype(tolua_S,(void*)tolua_ret,"Message");
01047   }
01048  }
01049  return 1;
01050 #ifndef TOLUA_RELEASE
01051  tolua_lerror:
01052  tolua_error(tolua_S,"#ferror in function 'create_message'.",&tolua_err);
01053  return 0;
01054 #endif
01055 }
01056 #endif //#ifndef TOLUA_DISABLE
01057 
01058 /* method: read of class  fawkes::SoccerPenaltyInterface */
01059 #ifndef TOLUA_DISABLE_tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_read00
01060 static int tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_read00(lua_State* tolua_S)
01061 {
01062 #ifndef TOLUA_RELEASE
01063  tolua_Error tolua_err;
01064  if (
01065      !tolua_isusertype(tolua_S,1,"fawkes::SoccerPenaltyInterface",0,&tolua_err) ||
01066      !tolua_isnoobj(tolua_S,2,&tolua_err)
01067  )
01068   goto tolua_lerror;
01069  else
01070 #endif
01071  {
01072   fawkes::SoccerPenaltyInterface* self = (fawkes::SoccerPenaltyInterface*)  tolua_tousertype(tolua_S,1,0);
01073 #ifndef TOLUA_RELEASE
01074   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'read'", NULL);
01075 #endif
01076   {
01077    self->read();
01078   }
01079  }
01080  return 0;
01081 #ifndef TOLUA_RELEASE
01082  tolua_lerror:
01083  tolua_error(tolua_S,"#ferror in function 'read'.",&tolua_err);
01084  return 0;
01085 #endif
01086 }
01087 #endif //#ifndef TOLUA_DISABLE
01088 
01089 /* method: write of class  fawkes::SoccerPenaltyInterface */
01090 #ifndef TOLUA_DISABLE_tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_write00
01091 static int tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_write00(lua_State* tolua_S)
01092 {
01093 #ifndef TOLUA_RELEASE
01094  tolua_Error tolua_err;
01095  if (
01096      !tolua_isusertype(tolua_S,1,"fawkes::SoccerPenaltyInterface",0,&tolua_err) ||
01097      !tolua_isnoobj(tolua_S,2,&tolua_err)
01098  )
01099   goto tolua_lerror;
01100  else
01101 #endif
01102  {
01103   fawkes::SoccerPenaltyInterface* self = (fawkes::SoccerPenaltyInterface*)  tolua_tousertype(tolua_S,1,0);
01104 #ifndef TOLUA_RELEASE
01105   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'write'", NULL);
01106 #endif
01107   {
01108    self->write();
01109   }
01110  }
01111  return 0;
01112 #ifndef TOLUA_RELEASE
01113  tolua_lerror:
01114  tolua_error(tolua_S,"#ferror in function 'write'.",&tolua_err);
01115  return 0;
01116 #endif
01117 }
01118 #endif //#ifndef TOLUA_DISABLE
01119 
01120 /* method: has_writer of class  fawkes::SoccerPenaltyInterface */
01121 #ifndef TOLUA_DISABLE_tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_has_writer00
01122 static int tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_has_writer00(lua_State* tolua_S)
01123 {
01124 #ifndef TOLUA_RELEASE
01125  tolua_Error tolua_err;
01126  if (
01127      !tolua_isusertype(tolua_S,1,"const fawkes::SoccerPenaltyInterface",0,&tolua_err) ||
01128      !tolua_isnoobj(tolua_S,2,&tolua_err)
01129  )
01130   goto tolua_lerror;
01131  else
01132 #endif
01133  {
01134   const fawkes::SoccerPenaltyInterface* self = (const fawkes::SoccerPenaltyInterface*)  tolua_tousertype(tolua_S,1,0);
01135 #ifndef TOLUA_RELEASE
01136   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'has_writer'", NULL);
01137 #endif
01138   {
01139    bool tolua_ret = (bool)  self->has_writer();
01140    tolua_pushboolean(tolua_S,(bool)tolua_ret);
01141   }
01142  }
01143  return 1;
01144 #ifndef TOLUA_RELEASE
01145  tolua_lerror:
01146  tolua_error(tolua_S,"#ferror in function 'has_writer'.",&tolua_err);
01147  return 0;
01148 #endif
01149 }
01150 #endif //#ifndef TOLUA_DISABLE
01151 
01152 /* method: num_readers of class  fawkes::SoccerPenaltyInterface */
01153 #ifndef TOLUA_DISABLE_tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_num_readers00
01154 static int tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_num_readers00(lua_State* tolua_S)
01155 {
01156 #ifndef TOLUA_RELEASE
01157  tolua_Error tolua_err;
01158  if (
01159      !tolua_isusertype(tolua_S,1,"const fawkes::SoccerPenaltyInterface",0,&tolua_err) ||
01160      !tolua_isnoobj(tolua_S,2,&tolua_err)
01161  )
01162   goto tolua_lerror;
01163  else
01164 #endif
01165  {
01166   const fawkes::SoccerPenaltyInterface* self = (const fawkes::SoccerPenaltyInterface*)  tolua_tousertype(tolua_S,1,0);
01167 #ifndef TOLUA_RELEASE
01168   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'num_readers'", NULL);
01169 #endif
01170   {
01171    unsigned int tolua_ret = (unsigned int)  self->num_readers();
01172    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01173   }
01174  }
01175  return 1;
01176 #ifndef TOLUA_RELEASE
01177  tolua_lerror:
01178  tolua_error(tolua_S,"#ferror in function 'num_readers'.",&tolua_err);
01179  return 0;
01180 #endif
01181 }
01182 #endif //#ifndef TOLUA_DISABLE
01183 
01184 /* method: msgq_enqueue_copy of class  fawkes::SoccerPenaltyInterface */
01185 #ifndef TOLUA_DISABLE_tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_msgq_enqueue_copy00
01186 static int tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_msgq_enqueue_copy00(lua_State* tolua_S)
01187 {
01188 #ifndef TOLUA_RELEASE
01189  tolua_Error tolua_err;
01190  if (
01191      !tolua_isusertype(tolua_S,1,"fawkes::SoccerPenaltyInterface",0,&tolua_err) ||
01192      !tolua_isusertype(tolua_S,2,"Message",0,&tolua_err) ||
01193      !tolua_isnoobj(tolua_S,3,&tolua_err)
01194  )
01195   goto tolua_lerror;
01196  else
01197 #endif
01198  {
01199   fawkes::SoccerPenaltyInterface* self = (fawkes::SoccerPenaltyInterface*)  tolua_tousertype(tolua_S,1,0);
01200   Message* message = ((Message*)  tolua_tousertype(tolua_S,2,0));
01201 #ifndef TOLUA_RELEASE
01202   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_enqueue_copy'", NULL);
01203 #endif
01204   {
01205    unsigned int tolua_ret = (unsigned int)  self->msgq_enqueue_copy(message);
01206    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01207   }
01208  }
01209  return 1;
01210 #ifndef TOLUA_RELEASE
01211  tolua_lerror:
01212  tolua_error(tolua_S,"#ferror in function 'msgq_enqueue_copy'.",&tolua_err);
01213  return 0;
01214 #endif
01215 }
01216 #endif //#ifndef TOLUA_DISABLE
01217 
01218 /* method: msgq_remove of class  fawkes::SoccerPenaltyInterface */
01219 #ifndef TOLUA_DISABLE_tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_msgq_remove00
01220 static int tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_msgq_remove00(lua_State* tolua_S)
01221 {
01222 #ifndef TOLUA_RELEASE
01223  tolua_Error tolua_err;
01224  if (
01225      !tolua_isusertype(tolua_S,1,"fawkes::SoccerPenaltyInterface",0,&tolua_err) ||
01226      !tolua_isusertype(tolua_S,2,"Message",0,&tolua_err) ||
01227      !tolua_isnoobj(tolua_S,3,&tolua_err)
01228  )
01229   goto tolua_lerror;
01230  else
01231 #endif
01232  {
01233   fawkes::SoccerPenaltyInterface* self = (fawkes::SoccerPenaltyInterface*)  tolua_tousertype(tolua_S,1,0);
01234   Message* message = ((Message*)  tolua_tousertype(tolua_S,2,0));
01235 #ifndef TOLUA_RELEASE
01236   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_remove'", NULL);
01237 #endif
01238   {
01239    self->msgq_remove(message);
01240   }
01241  }
01242  return 0;
01243 #ifndef TOLUA_RELEASE
01244  tolua_lerror:
01245  tolua_error(tolua_S,"#ferror in function 'msgq_remove'.",&tolua_err);
01246  return 0;
01247 #endif
01248 }
01249 #endif //#ifndef TOLUA_DISABLE
01250 
01251 /* method: msgq_remove of class  fawkes::SoccerPenaltyInterface */
01252 #ifndef TOLUA_DISABLE_tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_msgq_remove01
01253 static int tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_msgq_remove01(lua_State* tolua_S)
01254 {
01255  tolua_Error tolua_err;
01256  if (
01257      !tolua_isusertype(tolua_S,1,"fawkes::SoccerPenaltyInterface",0,&tolua_err) ||
01258      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01259      !tolua_isnoobj(tolua_S,3,&tolua_err)
01260  )
01261   goto tolua_lerror;
01262  else
01263  {
01264   fawkes::SoccerPenaltyInterface* self = (fawkes::SoccerPenaltyInterface*)  tolua_tousertype(tolua_S,1,0);
01265   unsigned int message_id = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
01266 #ifndef TOLUA_RELEASE
01267   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_remove'", NULL);
01268 #endif
01269   {
01270    self->msgq_remove(message_id);
01271   }
01272  }
01273  return 0;
01274 tolua_lerror:
01275  return tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_msgq_remove00(tolua_S);
01276 }
01277 #endif //#ifndef TOLUA_DISABLE
01278 
01279 /* method: msgq_size of class  fawkes::SoccerPenaltyInterface */
01280 #ifndef TOLUA_DISABLE_tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_msgq_size00
01281 static int tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_msgq_size00(lua_State* tolua_S)
01282 {
01283 #ifndef TOLUA_RELEASE
01284  tolua_Error tolua_err;
01285  if (
01286      !tolua_isusertype(tolua_S,1,"fawkes::SoccerPenaltyInterface",0,&tolua_err) ||
01287      !tolua_isnoobj(tolua_S,2,&tolua_err)
01288  )
01289   goto tolua_lerror;
01290  else
01291 #endif
01292  {
01293   fawkes::SoccerPenaltyInterface* self = (fawkes::SoccerPenaltyInterface*)  tolua_tousertype(tolua_S,1,0);
01294 #ifndef TOLUA_RELEASE
01295   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_size'", NULL);
01296 #endif
01297   {
01298    unsigned int tolua_ret = (unsigned int)  self->msgq_size();
01299    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01300   }
01301  }
01302  return 1;
01303 #ifndef TOLUA_RELEASE
01304  tolua_lerror:
01305  tolua_error(tolua_S,"#ferror in function 'msgq_size'.",&tolua_err);
01306  return 0;
01307 #endif
01308 }
01309 #endif //#ifndef TOLUA_DISABLE
01310 
01311 /* method: msgq_flush of class  fawkes::SoccerPenaltyInterface */
01312 #ifndef TOLUA_DISABLE_tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_msgq_flush00
01313 static int tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_msgq_flush00(lua_State* tolua_S)
01314 {
01315 #ifndef TOLUA_RELEASE
01316  tolua_Error tolua_err;
01317  if (
01318      !tolua_isusertype(tolua_S,1,"fawkes::SoccerPenaltyInterface",0,&tolua_err) ||
01319      !tolua_isnoobj(tolua_S,2,&tolua_err)
01320  )
01321   goto tolua_lerror;
01322  else
01323 #endif
01324  {
01325   fawkes::SoccerPenaltyInterface* self = (fawkes::SoccerPenaltyInterface*)  tolua_tousertype(tolua_S,1,0);
01326 #ifndef TOLUA_RELEASE
01327   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_flush'", NULL);
01328 #endif
01329   {
01330    self->msgq_flush();
01331   }
01332  }
01333  return 0;
01334 #ifndef TOLUA_RELEASE
01335  tolua_lerror:
01336  tolua_error(tolua_S,"#ferror in function 'msgq_flush'.",&tolua_err);
01337  return 0;
01338 #endif
01339 }
01340 #endif //#ifndef TOLUA_DISABLE
01341 
01342 /* method: msgq_lock of class  fawkes::SoccerPenaltyInterface */
01343 #ifndef TOLUA_DISABLE_tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_msgq_lock00
01344 static int tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_msgq_lock00(lua_State* tolua_S)
01345 {
01346 #ifndef TOLUA_RELEASE
01347  tolua_Error tolua_err;
01348  if (
01349      !tolua_isusertype(tolua_S,1,"fawkes::SoccerPenaltyInterface",0,&tolua_err) ||
01350      !tolua_isnoobj(tolua_S,2,&tolua_err)
01351  )
01352   goto tolua_lerror;
01353  else
01354 #endif
01355  {
01356   fawkes::SoccerPenaltyInterface* self = (fawkes::SoccerPenaltyInterface*)  tolua_tousertype(tolua_S,1,0);
01357 #ifndef TOLUA_RELEASE
01358   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_lock'", NULL);
01359 #endif
01360   {
01361    self->msgq_lock();
01362   }
01363  }
01364  return 0;
01365 #ifndef TOLUA_RELEASE
01366  tolua_lerror:
01367  tolua_error(tolua_S,"#ferror in function 'msgq_lock'.",&tolua_err);
01368  return 0;
01369 #endif
01370 }
01371 #endif //#ifndef TOLUA_DISABLE
01372 
01373 /* method: msgq_try_lock of class  fawkes::SoccerPenaltyInterface */
01374 #ifndef TOLUA_DISABLE_tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_msgq_try_lock00
01375 static int tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_msgq_try_lock00(lua_State* tolua_S)
01376 {
01377 #ifndef TOLUA_RELEASE
01378  tolua_Error tolua_err;
01379  if (
01380      !tolua_isusertype(tolua_S,1,"fawkes::SoccerPenaltyInterface",0,&tolua_err) ||
01381      !tolua_isnoobj(tolua_S,2,&tolua_err)
01382  )
01383   goto tolua_lerror;
01384  else
01385 #endif
01386  {
01387   fawkes::SoccerPenaltyInterface* self = (fawkes::SoccerPenaltyInterface*)  tolua_tousertype(tolua_S,1,0);
01388 #ifndef TOLUA_RELEASE
01389   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_try_lock'", NULL);
01390 #endif
01391   {
01392    bool tolua_ret = (bool)  self->msgq_try_lock();
01393    tolua_pushboolean(tolua_S,(bool)tolua_ret);
01394   }
01395  }
01396  return 1;
01397 #ifndef TOLUA_RELEASE
01398  tolua_lerror:
01399  tolua_error(tolua_S,"#ferror in function 'msgq_try_lock'.",&tolua_err);
01400  return 0;
01401 #endif
01402 }
01403 #endif //#ifndef TOLUA_DISABLE
01404 
01405 /* method: msgq_unlock of class  fawkes::SoccerPenaltyInterface */
01406 #ifndef TOLUA_DISABLE_tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_msgq_unlock00
01407 static int tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_msgq_unlock00(lua_State* tolua_S)
01408 {
01409 #ifndef TOLUA_RELEASE
01410  tolua_Error tolua_err;
01411  if (
01412      !tolua_isusertype(tolua_S,1,"fawkes::SoccerPenaltyInterface",0,&tolua_err) ||
01413      !tolua_isnoobj(tolua_S,2,&tolua_err)
01414  )
01415   goto tolua_lerror;
01416  else
01417 #endif
01418  {
01419   fawkes::SoccerPenaltyInterface* self = (fawkes::SoccerPenaltyInterface*)  tolua_tousertype(tolua_S,1,0);
01420 #ifndef TOLUA_RELEASE
01421   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_unlock'", NULL);
01422 #endif
01423   {
01424    self->msgq_unlock();
01425   }
01426  }
01427  return 0;
01428 #ifndef TOLUA_RELEASE
01429  tolua_lerror:
01430  tolua_error(tolua_S,"#ferror in function 'msgq_unlock'.",&tolua_err);
01431  return 0;
01432 #endif
01433 }
01434 #endif //#ifndef TOLUA_DISABLE
01435 
01436 /* method: msgq_pop of class  fawkes::SoccerPenaltyInterface */
01437 #ifndef TOLUA_DISABLE_tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_msgq_pop00
01438 static int tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_msgq_pop00(lua_State* tolua_S)
01439 {
01440 #ifndef TOLUA_RELEASE
01441  tolua_Error tolua_err;
01442  if (
01443      !tolua_isusertype(tolua_S,1,"fawkes::SoccerPenaltyInterface",0,&tolua_err) ||
01444      !tolua_isnoobj(tolua_S,2,&tolua_err)
01445  )
01446   goto tolua_lerror;
01447  else
01448 #endif
01449  {
01450   fawkes::SoccerPenaltyInterface* self = (fawkes::SoccerPenaltyInterface*)  tolua_tousertype(tolua_S,1,0);
01451 #ifndef TOLUA_RELEASE
01452   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_pop'", NULL);
01453 #endif
01454   {
01455    self->msgq_pop();
01456   }
01457  }
01458  return 0;
01459 #ifndef TOLUA_RELEASE
01460  tolua_lerror:
01461  tolua_error(tolua_S,"#ferror in function 'msgq_pop'.",&tolua_err);
01462  return 0;
01463 #endif
01464 }
01465 #endif //#ifndef TOLUA_DISABLE
01466 
01467 /* method: msgq_first of class  fawkes::SoccerPenaltyInterface */
01468 #ifndef TOLUA_DISABLE_tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_msgq_first00
01469 static int tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_msgq_first00(lua_State* tolua_S)
01470 {
01471 #ifndef TOLUA_RELEASE
01472  tolua_Error tolua_err;
01473  if (
01474      !tolua_isusertype(tolua_S,1,"fawkes::SoccerPenaltyInterface",0,&tolua_err) ||
01475      !tolua_isnoobj(tolua_S,2,&tolua_err)
01476  )
01477   goto tolua_lerror;
01478  else
01479 #endif
01480  {
01481   fawkes::SoccerPenaltyInterface* self = (fawkes::SoccerPenaltyInterface*)  tolua_tousertype(tolua_S,1,0);
01482 #ifndef TOLUA_RELEASE
01483   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_first'", NULL);
01484 #endif
01485   {
01486    Message* tolua_ret = (Message*)  self->msgq_first();
01487     tolua_pushusertype(tolua_S,(void*)tolua_ret,"Message");
01488   }
01489  }
01490  return 1;
01491 #ifndef TOLUA_RELEASE
01492  tolua_lerror:
01493  tolua_error(tolua_S,"#ferror in function 'msgq_first'.",&tolua_err);
01494  return 0;
01495 #endif
01496 }
01497 #endif //#ifndef TOLUA_DISABLE
01498 
01499 /* method: msgq_empty of class  fawkes::SoccerPenaltyInterface */
01500 #ifndef TOLUA_DISABLE_tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_msgq_empty00
01501 static int tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_msgq_empty00(lua_State* tolua_S)
01502 {
01503 #ifndef TOLUA_RELEASE
01504  tolua_Error tolua_err;
01505  if (
01506      !tolua_isusertype(tolua_S,1,"fawkes::SoccerPenaltyInterface",0,&tolua_err) ||
01507      !tolua_isnoobj(tolua_S,2,&tolua_err)
01508  )
01509   goto tolua_lerror;
01510  else
01511 #endif
01512  {
01513   fawkes::SoccerPenaltyInterface* self = (fawkes::SoccerPenaltyInterface*)  tolua_tousertype(tolua_S,1,0);
01514 #ifndef TOLUA_RELEASE
01515   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_empty'", NULL);
01516 #endif
01517   {
01518    bool tolua_ret = (bool)  self->msgq_empty();
01519    tolua_pushboolean(tolua_S,(bool)tolua_ret);
01520   }
01521  }
01522  return 1;
01523 #ifndef TOLUA_RELEASE
01524  tolua_lerror:
01525  tolua_error(tolua_S,"#ferror in function 'msgq_empty'.",&tolua_err);
01526  return 0;
01527 #endif
01528 }
01529 #endif //#ifndef TOLUA_DISABLE
01530 
01531 /* Open function */
01532 TOLUA_API int tolua_interfaces_SoccerPenaltyInterface_open (lua_State* tolua_S)
01533 {
01534  tolua_open(tolua_S);
01535  tolua_reg_types(tolua_S);
01536  tolua_module(tolua_S,NULL,0);
01537  tolua_beginmodule(tolua_S,NULL);
01538   tolua_module(tolua_S,"fawkes",0);
01539   tolua_beginmodule(tolua_S,"fawkes");
01540    tolua_cclass(tolua_S,"SoccerPenaltyInterface","fawkes::SoccerPenaltyInterface","Interface",NULL);
01541    tolua_beginmodule(tolua_S,"SoccerPenaltyInterface");
01542     tolua_variable(tolua_S,"SPL_PENALTY_NONE",tolua_get_fawkes__SoccerPenaltyInterface_unsigned_SPL_PENALTY_NONE,NULL);
01543     tolua_variable(tolua_S,"SPL_PENALTY_BALL_HOLDING",tolua_get_fawkes__SoccerPenaltyInterface_unsigned_SPL_PENALTY_BALL_HOLDING,NULL);
01544     tolua_variable(tolua_S,"SPL_PENALTY_PLAYER_PUSHING",tolua_get_fawkes__SoccerPenaltyInterface_unsigned_SPL_PENALTY_PLAYER_PUSHING,NULL);
01545     tolua_variable(tolua_S,"SPL_PENALTY_OBSTRUCTION",tolua_get_fawkes__SoccerPenaltyInterface_unsigned_SPL_PENALTY_OBSTRUCTION,NULL);
01546     tolua_variable(tolua_S,"SPL_PENALTY_INACTIVE_PLAYER",tolua_get_fawkes__SoccerPenaltyInterface_unsigned_SPL_PENALTY_INACTIVE_PLAYER,NULL);
01547     tolua_variable(tolua_S,"SPL_PENALTY_ILLEGAL_DEFENDER",tolua_get_fawkes__SoccerPenaltyInterface_unsigned_SPL_PENALTY_ILLEGAL_DEFENDER,NULL);
01548     tolua_variable(tolua_S,"SPL_PENALTY_LEAVING_THE_FIELD",tolua_get_fawkes__SoccerPenaltyInterface_unsigned_SPL_PENALTY_LEAVING_THE_FIELD,NULL);
01549     tolua_variable(tolua_S,"SPL_PENALTY_PLAYING_WITH_HANDS",tolua_get_fawkes__SoccerPenaltyInterface_unsigned_SPL_PENALTY_PLAYING_WITH_HANDS,NULL);
01550     tolua_variable(tolua_S,"SPL_PENALTY_REQ_FOR_PICKUP",tolua_get_fawkes__SoccerPenaltyInterface_unsigned_SPL_PENALTY_REQ_FOR_PICKUP,NULL);
01551     tolua_variable(tolua_S,"SPL_PENALTY_MANUAL",tolua_get_fawkes__SoccerPenaltyInterface_unsigned_SPL_PENALTY_MANUAL,NULL);
01552     #ifdef __cplusplus
01553     tolua_cclass(tolua_S,"SetPenaltyMessage","fawkes::SoccerPenaltyInterface::SetPenaltyMessage","Message",tolua_collect_fawkes__SoccerPenaltyInterface__SetPenaltyMessage);
01554     #else
01555     tolua_cclass(tolua_S,"SetPenaltyMessage","fawkes::SoccerPenaltyInterface::SetPenaltyMessage","Message",NULL);
01556     #endif
01557     tolua_beginmodule(tolua_S,"SetPenaltyMessage");
01558      tolua_function(tolua_S,"new",tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_SetPenaltyMessage_new00);
01559      tolua_function(tolua_S,"new_local",tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_SetPenaltyMessage_new00_local);
01560      tolua_function(tolua_S,".call",tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_SetPenaltyMessage_new00_local);
01561      tolua_function(tolua_S,"new",tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_SetPenaltyMessage_new01);
01562      tolua_function(tolua_S,"new_local",tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_SetPenaltyMessage_new01_local);
01563      tolua_function(tolua_S,".call",tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_SetPenaltyMessage_new01_local);
01564      tolua_function(tolua_S,"delete",tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_SetPenaltyMessage_delete00);
01565      tolua_function(tolua_S,"penalty",tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_SetPenaltyMessage_penalty00);
01566      tolua_function(tolua_S,"set_penalty",tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_SetPenaltyMessage_set_penalty00);
01567      tolua_function(tolua_S,"maxlenof_penalty",tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_SetPenaltyMessage_maxlenof_penalty00);
01568     tolua_endmodule(tolua_S);
01569     tolua_function(tolua_S,"penalty",tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_penalty00);
01570     tolua_function(tolua_S,"set_penalty",tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_set_penalty00);
01571     tolua_function(tolua_S,"maxlenof_penalty",tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_maxlenof_penalty00);
01572     tolua_function(tolua_S,"remaining",tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_remaining00);
01573     tolua_function(tolua_S,"set_remaining",tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_set_remaining00);
01574     tolua_function(tolua_S,"maxlenof_remaining",tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_maxlenof_remaining00);
01575     tolua_function(tolua_S,"oftype",tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_oftype00);
01576     tolua_function(tolua_S,"datachunk",tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_datachunk00);
01577     tolua_function(tolua_S,"datasize",tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_datasize00);
01578     tolua_function(tolua_S,"type",tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_type00);
01579     tolua_function(tolua_S,"id",tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_id00);
01580     tolua_function(tolua_S,"uid",tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_uid00);
01581     tolua_function(tolua_S,"serial",tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_serial00);
01582     tolua_function(tolua_S,"mem_serial",tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_mem_serial00);
01583     tolua_function(tolua_S,".eq",tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface__eq00);
01584     tolua_function(tolua_S,"hash",tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_hash00);
01585     tolua_function(tolua_S,"hash_size",tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_hash_size00);
01586     tolua_function(tolua_S,"hash_printable",tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_hash_printable00);
01587     tolua_function(tolua_S,"is_writer",tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_is_writer00);
01588     tolua_function(tolua_S,"set_from_chunk",tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_set_from_chunk00);
01589     tolua_function(tolua_S,"create_message",tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_create_message00);
01590     tolua_function(tolua_S,"read",tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_read00);
01591     tolua_function(tolua_S,"write",tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_write00);
01592     tolua_function(tolua_S,"has_writer",tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_has_writer00);
01593     tolua_function(tolua_S,"num_readers",tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_num_readers00);
01594     tolua_function(tolua_S,"msgq_enqueue_copy",tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_msgq_enqueue_copy00);
01595     tolua_function(tolua_S,"msgq_remove",tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_msgq_remove00);
01596     tolua_function(tolua_S,"msgq_remove",tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_msgq_remove01);
01597     tolua_function(tolua_S,"msgq_size",tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_msgq_size00);
01598     tolua_function(tolua_S,"msgq_flush",tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_msgq_flush00);
01599     tolua_function(tolua_S,"msgq_lock",tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_msgq_lock00);
01600     tolua_function(tolua_S,"msgq_try_lock",tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_msgq_try_lock00);
01601     tolua_function(tolua_S,"msgq_unlock",tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_msgq_unlock00);
01602     tolua_function(tolua_S,"msgq_pop",tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_msgq_pop00);
01603     tolua_function(tolua_S,"msgq_first",tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_msgq_first00);
01604     tolua_function(tolua_S,"msgq_empty",tolua_interfaces_SoccerPenaltyInterface_fawkes_SoccerPenaltyInterface_msgq_empty00);
01605    tolua_endmodule(tolua_S);
01606   tolua_endmodule(tolua_S);
01607  tolua_endmodule(tolua_S);
01608  return 1;
01609 }
01610 
01611 
01612 extern "C" {
01613 #if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501
01614  TOLUA_API int luaopen_interfaces_SoccerPenaltyInterface (lua_State* tolua_S) {
01615  return tolua_interfaces_SoccerPenaltyInterface_open(tolua_S);
01616 };
01617 #endif
01618 }
01619 
01620 

Generated on Tue Feb 22 13:31:22 2011 for Fawkes API by  doxygen 1.4.7