Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
Sep 14, 2006, 5:24:31 PM (18 years ago)
Author:
bensch
Message:

orxonox/new_class_id: new Executor construct, that is much more typesafe, faster, and easier to extend…

Also changed the LoadParam process, and adapted ScriptEngine calls

Then at the end, some missing headers appeared, and appended them to all the cc-files again.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • branches/new_class_id/src/lib/util/executor/executor_lua.h

    r9006 r9727  
    4040///////////
    4141//! Executes a Function with a lua_State* parameter.
    42 template<class T> class ExecutorLua0 : public Executor
    43 {
    44   public:
    45     /**
    46    * @brief Constructor of a ExecutorXML
    47    * @param function a Function to call
    48      */
    49     ExecutorLua0(void(T::*function)())
    50   : Executor()
    51     {
    52       this->functionPointer = function;
    53       this->functorType = Executor_Objective | Executor_NoLoadString;
    54     }
    55 
    56     /**
    57      * @brief executes the Command on BaseObject
    58      * @param object the BaseObject to execute this Executor on
    59      * @param loadString ignored in this case
    60      */
    61     virtual void operator()(BaseObject* object, const SubString& = SubString()) const
    62     {
    63       PRINTF(1)("no usefull executor\n");
    64     }
    65 
    66     virtual void operator()(BaseObject* object, int& count, void* values) const
    67     {
    68       (dynamic_cast<T*>(object)->*(functionPointer))();
    69       count = 0;
    70     }
    71 
    72     /**
    73      * @returns a _new_ Copy of this Executor
    74      */
    75     virtual Executor* clone () const
    76     {
    77       return new ExecutorLua0<T>(ExecutorLua0<T>(this->functionPointer));
    78     }
    79   private:
    80     void          (T::*functionPointer)();
     42template<class T> class ExecutorLua0 : public Executor<lua_State*>
     43{
     44public:
     45  /**
     46  * @brief Constructor of a ExecutorXML
     47  * @param function a Function to call
     48   */
     49  ExecutorLua0(void(T::*function)())
     50      : Executor<lua_State*>(false)
     51  {
     52    this->functionPointer = function;
     53    this->functorType = Executor_Objective;
     54  }
     55
     56
     57  virtual void operator()(BaseObject* object, lua_State*& state) const
     58  {
     59    (dynamic_cast<T*>(object)->*(functionPointer))();
     60  }
     61
     62  /**
     63   * @returns a _new_ Copy of this Executor
     64   */
     65  virtual Executor<lua_State*>* clone () const
     66  {
     67    return new ExecutorLua0<T>(ExecutorLua0<T>(this->functionPointer));
     68  }
     69private:
     70  void          (T::*functionPointer)();
    8171};
    8272
    … …  
    8777///////////
    8878//! Executes a Function with a lua_State* parameter.
    89 template<class T, typename type0> class ExecutorLua1 : public Executor
    90 {
    91   public:
    92     /**
    93    * @brief Constructor of a ExecutorXML
    94    * @param function a Function to call
    95      */
    96     ExecutorLua1(void(T::*function)(type0))
    97   : Executor(ExecutorParamType<type0>())
    98     {
    99       this->functionPointer = function;
    100       this->functorType = Executor_Objective | Executor_NoLoadString;
    101     }
    102 
    103     /**
    104      * @brief executes the Command on BaseObject
    105      * @param object the BaseObject to execute this Executor on
    106      * @param loadString ignored in this case
    107      */
    108     virtual void operator()(BaseObject* object, const SubString& = SubString()) const
    109     {
    110       PRINTF(1)("no usefull executor\n");
    111     }
    112 
    113     virtual void operator()(BaseObject* object, int& count, void* values) const
    114     {
    115       lua_State* state = (lua_State*)values;
    116       count = 0;
    117 
    118       (dynamic_cast<T*>(object)->*(functionPointer))(fromLua<type0>(state, 1));
    119     }
    120 
    121     /**
    122      * @returns a _new_ Copy of this Executor
    123      */
    124     virtual Executor* clone () const
    125     {
    126       return new ExecutorLua1<T, type0>((this->functionPointer));
    127     }
    128   private:
    129     void          (T::*functionPointer)(type0);
     79template<class T, typename type0> class ExecutorLua1 : public Executor<lua_State*>
     80{
     81public:
     82  /**
     83  * @brief Constructor of a ExecutorXML
     84  * @param function a Function to call
     85   */
     86  ExecutorLua1(void(T::*function)(type0))
     87      : Executor<lua_State*>(false, ExecutorParamType<type0>())
     88  {
     89    this->functionPointer = function;
     90    this->functorType = Executor_Objective;
     91  }
     92
     93  virtual void operator()(BaseObject* object, lua_State*& state) const
     94  {
     95    (dynamic_cast<T*>(object)->*(functionPointer))(fromLua<type0>(state, 1));
     96  }
     97
     98  /**
     99   * @returns a _new_ Copy of this Executor
     100   */
     101  virtual Executor<lua_State*>* clone () const
     102  {
     103    return new ExecutorLua1<T, type0>((this->functionPointer));
     104  }
     105private:
     106  void          (T::*functionPointer)(type0);
    130107};
    131108
    … …  
    136113///////////
    137114//! Executes a Function with a lua_State* parameter.
    138 template<class T, typename type0, typename type1> class ExecutorLua2 : public Executor
    139 {
    140   public:
    141     /**
    142    * @brief Constructor of a ExecutorXML
    143    * @param function a Function to call
    144      */
    145     ExecutorLua2(void(T::*function)(type0, type1))
    146   : Executor(ExecutorParamType<type0>(), ExecutorParamType<type1>())
    147     {
    148       this->functionPointer = function;
    149       this->functorType = Executor_Objective | Executor_NoLoadString;
    150     }
    151 
    152     /**
    153      * @brief executes the Command on BaseObject
    154      * @param object the BaseObject to execute this Executor on
    155      * @param loadString ignored in this case
    156      */
    157     virtual void operator()(BaseObject* object, const SubString& = SubString()) const
    158     {
    159       PRINTF(1)("no usefull executor\n");
    160     }
    161 
    162     virtual void operator()(BaseObject* object, int& count, void* values) const
    163     {
    164       lua_State* state = (lua_State*)values;
    165       count = 0;
    166 
    167       (dynamic_cast<T*>(object)->*(functionPointer))(
    168           fromLua<type0>(state, 1),
     115template<class T, typename type0, typename type1> class ExecutorLua2 : public Executor<lua_State*>
     116{
     117public:
     118  /**
     119  * @brief Constructor of a ExecutorXML
     120  * @param function a Function to call
     121   */
     122  ExecutorLua2(void(T::*function)(type0, type1))
     123      : Executor<lua_State*>(false, ExecutorParamType<type0>(), ExecutorParamType<type1>())
     124  {
     125    this->functionPointer = function;
     126    this->functorType = Executor_Objective;
     127  }
     128
     129  /**
     130   * @brief executes the Command on BaseObject
     131   * @param object the BaseObject to execute this Executor on
     132   * @param loadString ignored in this case
     133   */
     134  virtual void operator()(BaseObject* object, const SubString& = SubString()) const
     135  {
     136    PRINTF(1)("no usefull executor\n");
     137  }
     138
     139  virtual void operator()(BaseObject* object, lua_State*& state) const
     140  {
     141    (dynamic_cast<T*>(object)->*(functionPointer))(
     142      fromLua<type0>(state, 1),
    169143      fromLua<type1>(state, 2) );
    170     }
    171 
    172     /**
    173      * @returns a _new_ Copy of this Executor
    174      */
    175     virtual Executor* clone () const
    176     {
    177       return new ExecutorLua2<T, type0, type1>(this->functionPointer);
    178     }
    179   private:
    180     void          (T::*functionPointer)(type0, type1);
     144  }
     145
     146  /**
     147   * @returns a _new_ Copy of this Executor
     148   */
     149  virtual Executor<lua_State*>* clone () const
     150  {
     151    return new ExecutorLua2<T, type0, type1>(this->functionPointer);
     152  }
     153private:
     154  void          (T::*functionPointer)(type0, type1);
    181155};
    182156
    … …  
    186160///////////
    187161//! Executes a Function with a lua_State* parameter.
    188 template<class T, typename type0, typename type1, typename type2> class ExecutorLua3 : public Executor
    189 {
    190   public:
    191     /**
    192    * @brief Constructor of a ExecutorXML
    193    * @param function a Function to call
    194      */
    195     ExecutorLua3(void(T::*function)(type0, type1, type2))
    196   : Executor(ExecutorParamType<type0>(), ExecutorParamType<type1>(), ExecutorParamType<type2>())
    197     {
    198       this->functionPointer = function;
    199       this->functorType = Executor_Objective | Executor_NoLoadString;
    200     }
    201 
    202     /**
    203      * @brief executes the Command on BaseObject
    204      * @param object the BaseObject to execute this Executor on
    205      * @param loadString ignored in this case
    206      */
    207     virtual void operator()(BaseObject* object, const SubString& = SubString()) const
    208     {
    209       PRINTF(1)("no usefull executor\n");
    210     }
    211 
    212     virtual void operator()(BaseObject* object, int& count, void* values) const
    213     {
    214       lua_State* state = (lua_State*)values;
    215       count = 0;
    216 
    217       (dynamic_cast<T*>(object)->*(functionPointer))(
    218           fromLua<type0>(state, 1),
     162template<class T, typename type0, typename type1, typename type2> class ExecutorLua3 : public Executor<lua_State*>
     163{
     164public:
     165  /**
     166  * @brief Constructor of a ExecutorXML
     167  * @param function a Function to call
     168   */
     169  ExecutorLua3(void(T::*function)(type0, type1, type2))
     170      : Executor<lua_State*>(false, ExecutorParamType<type0>(), ExecutorParamType<type1>(), ExecutorParamType<type2>())
     171  {
     172    this->functionPointer = function;
     173    this->functorType = Executor_Objective;
     174  }
     175
     176  /**
     177   * @brief executes the Command on BaseObject
     178   * @param object the BaseObject to execute this Executor on
     179   * @param loadString ignored in this case
     180   */
     181  virtual void operator()(BaseObject* object, const SubString& = SubString()) const
     182  {
     183    PRINTF(1)("no usefull executor\n");
     184  }
     185
     186  virtual void operator()(BaseObject* object, lua_State*& state) const
     187  {
     188    (dynamic_cast<T*>(object)->*(functionPointer))(
     189      fromLua<type0>(state, 1),
    219190      fromLua<type1>(state, 2),
    220191      fromLua<type2>(state, 3) );
    221     }
    222 
    223     /**
    224      * @returns a _new_ Copy of this Executor
    225      */
    226     virtual Executor* clone () const
    227     {
    228       return new ExecutorLua3<T, type0, type1, type2>(this->functionPointer);
    229     }
    230   private:
    231     void          (T::*functionPointer)(type0, type1, type2);
     192  }
     193
     194  /**
     195   * @returns a _new_ Copy of this Executor
     196   */
     197  virtual Executor<lua_State*>* clone () const
     198  {
     199    return new ExecutorLua3<T, type0, type1, type2>(this->functionPointer);
     200  }
     201private:
     202  void          (T::*functionPointer)(type0, type1, type2);
    232203};
    233204
    … …  
    237208///////////
    238209//! Executes a Function with a lua_State* parameter.
    239 template<class T, typename type0, typename type1, typename type2, typename type3> class ExecutorLua4 : public Executor
    240 {
    241   public:
    242     /**
    243    * @brief Constructor of a ExecutorXML
    244    * @param function a Function to call
    245      */
    246     ExecutorLua4(void(T::*function)(type0, type1, type2, type3))
    247   : Executor(ExecutorParamType<type0>(), ExecutorParamType<type1>(), ExecutorParamType<type2>(), ExecutorParamType<type3>())
    248     {
    249       this->functionPointer = function;
    250       this->functorType = Executor_Objective | Executor_NoLoadString;
    251     }
    252 
    253     /**
    254      * @brief executes the Command on BaseObject
    255      * @param object the BaseObject to execute this Executor on
    256      * @param loadString ignored in this case
    257      */
    258     virtual void operator()(BaseObject* object, const SubString& = SubString()) const
    259     {
    260       PRINTF(1)("no usefull executor\n");
    261     }
    262 
    263     virtual void operator()(BaseObject* object, int& count, void* values) const
    264     {
    265       lua_State* state = (lua_State*)values;
    266       count = 0;
    267 
    268       (dynamic_cast<T*>(object)->*(functionPointer))(
    269           fromLua<type0>(state, 1),
     210template<class T, typename type0, typename type1, typename type2, typename type3> class ExecutorLua4 : public Executor<lua_State*>
     211{
     212public:
     213  /**
     214  * @brief Constructor of a ExecutorXML
     215  * @param function a Function to call
     216   */
     217  ExecutorLua4(void(T::*function)(type0, type1, type2, type3))
     218      : Executor<lua_State*>(false, ExecutorParamType<type0>(), ExecutorParamType<type1>(), ExecutorParamType<type2>(), ExecutorParamType<type3>())
     219  {
     220    this->functionPointer = function;
     221    this->functorType = Executor_Objective;
     222  }
     223
     224  virtual void operator()(BaseObject* object, lua_State*& state) const
     225  {
     226    (dynamic_cast<T*>(object)->*(functionPointer))(
     227      fromLua<type0>(state, 1),
    270228      fromLua<type1>(state, 2),
    271229      fromLua<type2>(state, 3),
    272230      fromLua<type3>(state, 4) );
    273     }
    274 
    275     /**
    276      * @returns a _new_ Copy of this Executor
    277      */
    278     virtual Executor* clone () const
    279     {
    280       return new ExecutorLua4<T, type0, type1, type2, type3>(this->functionPointer);
    281     }
    282   private:
    283     void          (T::*functionPointer)(type0, type1, type2, type3);
     231  }
     232
     233  /**
     234   * @returns a _new_ Copy of this Executor
     235   */
     236  virtual Executor<lua_State*>* clone () const
     237  {
     238    return new ExecutorLua4<T, type0, type1, type2, type3>(this->functionPointer);
     239  }
     240private:
     241  void          (T::*functionPointer)(type0, type1, type2, type3);
    284242};
    285243
    … …  
    296254///////////
    297255//! Executes a Function with a lua_State* parameter.
    298 template<class T, typename ret> class ExecutorLua0ret : public Executor
    299 {
    300   public:
    301     /**
    302    * @brief Constructor of a ExecutorXML
    303    * @param function a Function to call
    304      */
    305     ExecutorLua0ret(ret (T::*function)())
    306   : Executor()
    307     {
    308       this->functionPointer = function;
    309       this->functorType = Executor_Objective | Executor_NoLoadString;
    310     }
    311    
    312     /**
    313      * @brief executes the Command on BaseObject
    314      * @param object the BaseObject to execute this Executor on
    315      * @param loadString ignored in this case
    316      */
    317     virtual void operator()(BaseObject* object, const SubString& = SubString()) const
    318     {
    319       PRINTF(1)("no usefull executor\n");
    320     }
    321 
    322     virtual void operator()(BaseObject* object, int& count, void* values) const
    323     {
    324       lua_State* state = (lua_State*)values;
    325       count = 1;
    326 
    327       toLua<ret>(state, (dynamic_cast<T*>(object)->*(functionPointer))());
    328     }
    329 
    330     /**
    331      * @returns a _new_ Copy of this Executor
    332      */
    333     virtual Executor* clone () const
    334     {
    335       return new ExecutorLua0ret<T, ret>(this->functionPointer);
    336     }
    337   private:
    338     ret           (T::*functionPointer)();
     256template<class T, typename ret> class ExecutorLua0ret : public Executor<lua_State*>
     257{
     258public:
     259  /**
     260  * @brief Constructor of a ExecutorXML
     261  * @param function a Function to call
     262   */
     263  ExecutorLua0ret(ret (T::*function)())
     264      : Executor<lua_State*>(true)
     265  {
     266    this->functionPointer = function;
     267    this->functorType = Executor_Objective;
     268  }
     269
     270  virtual void operator()(BaseObject* object, lua_State*& state) const
     271  {
     272    toLua<ret>(state, (dynamic_cast<T*>(object)->*(functionPointer))());
     273  }
     274
     275  /**
     276   * @returns a _new_ Copy of this Executor
     277   */
     278  virtual Executor<lua_State*>* clone () const
     279  {
     280    return new ExecutorLua0ret<T, ret>(this->functionPointer);
     281  }
     282private:
     283  ret           (T::*functionPointer)();
    339284};
    340285
    … …  
    345290///////////
    346291//! Executes a Function with a lua_State* parameter.
    347 template<class T, typename ret, typename type0> class ExecutorLua1ret : public Executor
    348 {
    349   public:
    350     /**
    351    * @brief Constructor of a ExecutorXML
    352    * @param function a Function to call
    353      */
    354     ExecutorLua1ret(ret (T::*function)(type0))
    355   : Executor(ExecutorParamType<type0>())
    356     {
    357       this->functionPointer = function;
    358       this->functorType = Executor_Objective | Executor_NoLoadString;
    359     }
    360 
    361     /**
    362      * @brief executes the Command on BaseObject
    363      * @param object the BaseObject to execute this Executor on
    364      * @param loadString ignored in this case
    365      */
    366     virtual void operator()(BaseObject* object, const SubString& = SubString()) const
    367     {
    368       PRINTF(1)("no usefull executor\n");
    369     }
    370 
    371     virtual void operator()(BaseObject* object, int& count, void* values) const
    372     {
    373       lua_State* state = (lua_State*)values;
    374       count = 1;
    375 
    376       toLua<ret>(state, (dynamic_cast<T*>(object)->*(functionPointer))(
    377           fromLua<type0>(state, 1)));
    378     }
    379 
    380     /**
    381      * @returns a _new_ Copy of this Executor
    382      */
    383     virtual Executor* clone () const
    384     {
    385       return new ExecutorLua1ret<T, ret, type0>(this->functionPointer);
    386     }
    387   private:
    388     ret           (T::*functionPointer)(type0);
     292template<class T, typename ret, typename type0> class ExecutorLua1ret : public Executor<lua_State*>
     293{
     294public:
     295  /**
     296  * @brief Constructor of a ExecutorXML
     297  * @param function a Function to call
     298   */
     299  ExecutorLua1ret(ret (T::*function)(type0))
     300      : Executor<lua_State*>(true, ExecutorParamType<type0>())
     301  {
     302    this->functionPointer = function;
     303    this->functorType = Executor_Objective;
     304  }
     305
     306  virtual void operator()(BaseObject* object, lua_State*& state) const
     307  {
     308    toLua<ret>(state, (dynamic_cast<T*>(object)->*(functionPointer))(
     309                 fromLua<type0>(state, 1)));
     310  }
     311
     312  /**
     313   * @returns a _new_ Copy of this Executor
     314   */
     315  virtual Executor<lua_State*>* clone () const
     316  {
     317    return new ExecutorLua1ret<T, ret, type0>(this->functionPointer);
     318  }
     319private:
     320  ret           (T::*functionPointer)(type0);
    389321};
    390322
    … …  
    393325///////////
    394326//! Executes a Function with a lua_State* parameter.
    395 template<class T, typename ret, typename type0, typename type1> class ExecutorLua2ret : public Executor
    396 {
    397   public:
    398     /**
    399    * @brief Constructor of a ExecutorXML
    400    * @param function a Function to call
    401      */
    402     ExecutorLua2ret(ret (T::*function)(type0, type1))
    403   : Executor(ExecutorParamType<type0>(), ExecutorParamType<type1>())
    404     {
    405       this->functionPointer = function;
    406       this->functorType = Executor_Objective | Executor_NoLoadString;
    407     }
    408 
    409     /**
    410      * @brief executes the Command on BaseObject
    411      * @param object the BaseObject to execute this Executor on
    412      * @param loadString ignored in this case
    413      */
    414     virtual void operator()(BaseObject* object, const SubString& = SubString()) const
    415     {
    416       PRINTF(1)("no usefull executor\n");
    417     }
    418 
    419     virtual void operator()(BaseObject* object, int& count, void* values) const
    420     {
    421       lua_State* state = (lua_State*)values;
    422       count = 1;
    423 
    424       toLua<ret>(state, (dynamic_cast<T*>(object)->*(functionPointer))(
    425           fromLua<type0>(state, 1),
    426           fromLua<type1>(state, 2) ));
    427     }
    428 
    429     /**
    430      * @returns a _new_ Copy of this Executor
    431      */
    432     virtual Executor* clone () const
    433     {
    434       return new ExecutorLua2ret<T, ret, type0, type1>(this->functionPointer);
    435     }
    436   private:
    437     ret           (T::*functionPointer)(type0, type1);
     327template<class T, typename ret, typename type0, typename type1> class ExecutorLua2ret : public Executor<lua_State*>
     328{
     329public:
     330  /**
     331  * @brief Constructor of a ExecutorXML
     332  * @param function a Function to call
     333   */
     334  ExecutorLua2ret(ret (T::*function)(type0, type1))
     335      : Executor<lua_State*>(true, ExecutorParamType<type0>(), ExecutorParamType<type1>())
     336  {
     337    this->functionPointer = function;
     338    this->functorType = Executor_Objective;
     339  }
     340
     341  virtual void operator()(BaseObject* object, lua_State*& state) const
     342  {
     343    toLua<ret>(state, (dynamic_cast<T*>(object)->*(functionPointer))(
     344                 fromLua<type0>(state, 1),
     345                 fromLua<type1>(state, 2) ));
     346  }
     347
     348  /**
     349   * @returns a _new_ Copy of this Executor
     350   */
     351  virtual Executor<lua_State*>* clone () const
     352  {
     353    return new ExecutorLua2ret<T, ret, type0, type1>(this->functionPointer);
     354  }
     355private:
     356  ret           (T::*functionPointer)(type0, type1);
    438357};
    439358
    … …  
    443362///////////
    444363//! Executes a Function with a lua_State* parameter.
    445 template<class T, typename ret, typename type0, typename type1, typename type2> class ExecutorLua3ret : public Executor
    446 {
    447   public:
    448     /**
    449    * @brief Constructor of a ExecutorXML
    450    * @param function a Function to call
    451      */
    452     ExecutorLua3ret(ret (T::*function)(type0, type1, type2))
    453   : Executor(ExecutorParamType<type0>(), ExecutorParamType<type1>(), ExecutorParamType<type2>())
    454     {
    455       this->functionPointer = function;
    456       this->functorType = Executor_Objective | Executor_NoLoadString;
    457     }
    458 
    459     /**
    460      * @brief executes the Command on BaseObject
    461      * @param object the BaseObject to execute this Executor on
    462      * @param loadString ignored in this case
    463      */
    464     virtual void operator()(BaseObject* object, const SubString& = SubString()) const
    465     {
    466       PRINTF(1)("no usefull executor\n");
    467     }
    468 
    469     virtual void operator()(BaseObject* object, int& count, void* values) const
    470     {
    471       lua_State* state = (lua_State*)values;
    472       count = 1;
    473 
    474       toLua<ret>(state, (dynamic_cast<T*>(object)->*(functionPointer))(
    475           fromLua<type0>(state, 1),
    476           fromLua<type1>(state, 2),
    477           fromLua<type2>(state, 3) ));
    478     }
    479 
    480     /**
    481      * @returns a _new_ Copy of this Executor
    482      */
    483     virtual Executor* clone () const
    484     {
    485       return new ExecutorLua3ret<T, ret, type0, type1, type2>(this->functionPointer);
    486     }
    487   private:
    488     ret          (T::*functionPointer)(type0, type1, type2);
     364template<class T, typename ret, typename type0, typename type1, typename type2> class ExecutorLua3ret : public Executor<lua_State*>
     365{
     366public:
     367  /**
     368  * @brief Constructor of a ExecutorXML
     369  * @param function a Function to call
     370   */
     371  ExecutorLua3ret(ret (T::*function)(type0, type1, type2))
     372      : Executor<lua_State*>(true, ExecutorParamType<type0>(), ExecutorParamType<type1>(), ExecutorParamType<type2>())
     373  {
     374    this->functionPointer = function;
     375    this->functorType = Executor_Objective;
     376  }
     377
     378  /**
     379   * @brief executes the Command on BaseObject
     380   * @param object the BaseObject to execute this Executor on
     381   * @param loadString ignored in this case
     382   */
     383  virtual void operator()(BaseObject* object, const SubString& = SubString()) const
     384  {
     385    PRINTF(1)("no usefull executor\n");
     386  }
     387
     388  virtual void operator()(BaseObject* object, lua_State*& state) const
     389  {
     390    toLua<ret>(state, (dynamic_cast<T*>(object)->*(functionPointer))(
     391                 fromLua<type0>(state, 1),
     392                 fromLua<type1>(state, 2),
     393                 fromLua<type2>(state, 3) ));
     394  }
     395
     396  /**
     397   * @returns a _new_ Copy of this Executor
     398   */
     399  virtual Executor<lua_State*>* clone () const
     400  {
     401    return new ExecutorLua3ret<T, ret, type0, type1, type2>(this->functionPointer);
     402  }
     403private:
     404  ret          (T::*functionPointer)(type0, type1, type2);
    489405};
    490406
    … …  
    494410///////////
    495411//! Executes a Function with a lua_State* parameter.
    496 template<class T, typename ret, typename type0, typename type1, typename type2, typename type3> class ExecutorLua4ret : public Executor
    497 {
    498   public:
    499     /**
    500    * @brief Constructor of a ExecutorXML
    501    * @param function a Function to call
    502      */
    503     ExecutorLua4ret(ret (T::*function)(type0, type1, type2, type3))
    504   : Executor(ExecutorParamType<type0>(), ExecutorParamType<type1>(), ExecutorParamType<type2>(), ExecutorParamType<type3>())
    505     {
    506       this->functionPointer = function;
    507       this->functorType = Executor_Objective | Executor_NoLoadString;
    508     }
    509 
    510     /**
    511      * @brief executes the Command on BaseObject
    512      * @param object the BaseObject to execute this Executor on
    513      * @param loadString ignored in this case
    514      */
    515     virtual void operator()(BaseObject* object, const SubString& = SubString()) const
    516     {
    517       PRINTF(1)("no usefull executor\n");
    518     }
    519 
    520     virtual void operator()(BaseObject* object, int& count, void* values) const
    521     {
    522       lua_State* state = (lua_State*)values;
    523       count = 1;
    524 
    525       toLua<ret>(state, (dynamic_cast<T*>(object)->*(functionPointer))(
    526           fromLua<type0>(state, 1),
    527           fromLua<type1>(state, 2),
    528           fromLua<type2>(state, 3),
    529           fromLua<type3>(state, 4) ));
    530     }
    531 
    532     /**
    533      * @returns a _new_ Copy of this Executor
    534      */
    535     virtual Executor* clone () const
    536     {
    537       return new ExecutorLua4ret<T, ret, type0, type1, type2, type3>(this->functionPointer);
    538     }
    539   private:
    540     ret          (T::*functionPointer)(type0, type1, type2, type3);
     412template<class T, typename ret, typename type0, typename type1, typename type2, typename type3> class ExecutorLua4ret : public Executor<lua_State*>
     413{
     414public:
     415  /**
     416  * @brief Constructor of a ExecutorXML
     417  * @param function a Function to call
     418   */
     419  ExecutorLua4ret(ret (T::*function)(type0, type1, type2, type3))
     420      : Executor<lua_State*>(true, ExecutorParamType<type0>(), ExecutorParamType<type1>(), ExecutorParamType<type2>(), ExecutorParamType<type3>())
     421  {
     422    this->functionPointer = function;
     423    this->functorType = Executor_Objective;
     424  }
     425
     426  virtual void operator()(BaseObject* object, lua_State*& state) const
     427  {
     428    toLua<ret>(state, (dynamic_cast<T*>(object)->*(functionPointer))(
     429                 fromLua<type0>(state, 1),
     430                 fromLua<type1>(state, 2),
     431                 fromLua<type2>(state, 3),
     432                 fromLua<type3>(state, 4) ));
     433  }
     434
     435  /**
     436   * @returns a _new_ Copy of this Executor
     437   */
     438  virtual Executor<lua_State*>* clone () const
     439  {
     440    return new ExecutorLua4ret<T, ret, type0, type1, type2, type3>(this->functionPointer);
     441  }
     442private:
     443  ret          (T::*functionPointer)(type0, type1, type2, type3);
    541444};
    542445
    … …  
    545448///////////
    546449//! Executes a Function with a lua_State* parameter.
    547 template<class T, typename ret, typename type0, typename type1, typename type2, typename type3, typename type4> class ExecutorLua5ret : public Executor
    548 {
    549   public:
    550     /**
    551    * @brief Constructor of a ExecutorXML
    552    * @param function a Function to call
    553      */
    554     ExecutorLua5ret(ret (T::*function)(type0, type1, type2, type3, type4))
    555   : Executor(ExecutorParamType<type0>(), ExecutorParamType<type1>(), ExecutorParamType<type2>(), ExecutorParamType<type3>(), ExecutorParamType<type4>())
    556     {
    557       this->functionPointer = function;
    558       this->functorType = Executor_Objective | Executor_NoLoadString;
    559     }
    560 
    561     /**
    562      * @brief executes the Command on BaseObject
    563      * @param object the BaseObject to execute this Executor on
    564      * @param loadString ignored in this case
    565      */
    566     virtual void operator()(BaseObject* object, const SubString& = SubString()) const
    567     {
    568       PRINTF(1)("no usefull executor\n");
    569     }
    570 
    571     virtual void operator()(BaseObject* object, int& count, void* values) const
    572     {
    573       lua_State* state = (lua_State*)values;
    574       count = 1;
    575 
    576       toLua<ret>(state, (dynamic_cast<T*>(object)->*(functionPointer))(
    577           fromLua<type0>(state, 1),
    578           fromLua<type1>(state, 2),
    579           fromLua<type2>(state, 3),
    580           fromLua<type3>(state, 4),
    581           fromLua<type4>(state, 5) ));
    582     }
    583 
    584     /**
    585      * @returns a _new_ Copy of this Executor
    586      */
    587     virtual Executor* clone () const
    588     {
    589       return new ExecutorLua5ret<T, ret, type0, type1, type2, type3, type4>(this->functionPointer);
    590     }
    591   private:
    592     ret          (T::*functionPointer)(type0, type1, type2, type3, type4);
     450template<class T, typename ret, typename type0, typename type1, typename type2, typename type3, typename type4> class ExecutorLua5ret : public Executor<lua_State*>
     451{
     452public:
     453  /**
     454  * @brief Constructor of a ExecutorXML
     455  * @param function a Function to call
     456   */
     457  ExecutorLua5ret(ret (T::*function)(type0, type1, type2, type3, type4))
     458      : Executor<lua_State*>(true, ExecutorParamType<type0>(), ExecutorParamType<type1>(), ExecutorParamType<type2>(), ExecutorParamType<type3>(), ExecutorParamType<type4>())
     459  {
     460    this->functionPointer = function;
     461    this->functorType = Executor_Objective;
     462  }
     463
     464  virtual void operator()(BaseObject* object, lua_State*& state) const
     465  {
     466    toLua<ret>(state, (dynamic_cast<T*>(object)->*(functionPointer))(
     467                 fromLua<type0>(state, 1),
     468                 fromLua<type1>(state, 2),
     469                 fromLua<type2>(state, 3),
     470                 fromLua<type3>(state, 4),
     471                 fromLua<type4>(state, 5) ));
     472  }
     473
     474  /**
     475   * @returns a _new_ Copy of this Executor
     476   */
     477  virtual Executor<lua_State*>* clone () const
     478  {
     479    return new ExecutorLua5ret<T, ret, type0, type1, type2, type3, type4>(this->functionPointer);
     480  }
     481private:
     482  ret          (T::*functionPointer)(type0, type1, type2, type3, type4);
    593483};
    594484
    … …  
    597487///////////
    598488//! Executes a Function with a lua_State* parameter.
    599 template<class T, typename ret, typename type0, typename type1, typename type2, typename type3, typename type4, typename type5> class ExecutorLua6ret : public Executor
    600 {
    601   public:
    602     /**
    603    * @brief Constructor of a ExecutorXML
    604    * @param function a Function to call
    605      */
    606     ExecutorLua6ret(ret (T::*function)(type0, type1, type2, type3, type4, type5))
    607   : Executor(ExecutorParamType<type0>(), ExecutorParamType<type1>(),
    608              ExecutorParamType<type2>(), ExecutorParamType<type3>(),
    609              ExecutorParamType<type4>(), ExecutorParamType<type5>())
    610              {
    611                this->functionPointer = function;
    612                this->functorType = Executor_Objective | Executor_NoLoadString;
    613              }
    614 
    615     /**
    616               * @brief executes the Command on BaseObject
    617               * @param object the BaseObject to execute this Executor on
    618               * @param loadString ignored in this case
    619      */
    620              virtual void operator()(BaseObject* object, const SubString& = SubString()) const
    621              {
    622                PRINTF(1)("no usefull executor\n");
    623              }
    624 
    625              virtual void operator()(BaseObject* object, int& count, void* values) const
    626              {
    627                lua_State* state = (lua_State*)values;
    628                count = 1;
    629 
    630                toLua<ret>(state, (dynamic_cast<T*>(object)->*(functionPointer))(
    631                    fromLua<type0>(state, 1),
    632                    fromLua<type1>(state, 2),
    633                    fromLua<type2>(state, 3),
    634                    fromLua<type3>(state, 4),
    635                    fromLua<type4>(state, 5),
    636                    fromLua<type5>(state, 6) ));
    637              }
    638 
    639     /**
    640               * @returns a _new_ Copy of this Executor
    641      */
    642              virtual Executor* clone () const
    643              {
    644                return new ExecutorLua6ret<T, ret, type0, type1, type2, type3, type4, type5>(this->functionPointer);
    645              }
    646   private:
    647     ret           (T::*functionPointer)(type0, type1, type2, type3, type4, type5);
     489template<class T, typename ret, typename type0, typename type1, typename type2, typename type3, typename type4, typename type5> class ExecutorLua6ret : public Executor<lua_State*>
     490{
     491public:
     492  /**
     493  * @brief Constructor of a ExecutorXML
     494  * @param function a Function to call
     495   */
     496  ExecutorLua6ret(ret (T::*function)(type0, type1, type2, type3, type4, type5))
     497      : Executor<lua_State*>(true, ExecutorParamType<type0>(), ExecutorParamType<type1>(),
     498                             ExecutorParamType<type2>(), ExecutorParamType<type3>(),
     499                             ExecutorParamType<type4>(), ExecutorParamType<type5>())
     500  {
     501    this->functionPointer = function;
     502    this->functorType = Executor_Objective;
     503  }
     504
     505  virtual void operator()(BaseObject* object, lua_State*& state) const
     506  {
     507    toLua<ret>(state, (dynamic_cast<T*>(object)->*(functionPointer))(
     508                 fromLua<type0>(state, 1),
     509                 fromLua<type1>(state, 2),
     510                 fromLua<type2>(state, 3),
     511                 fromLua<type3>(state, 4),
     512                 fromLua<type4>(state, 5),
     513                 fromLua<type5>(state, 6) ));
     514  }
     515
     516  /**
     517            * @returns a _new_ Copy of this Executor
     518   */
     519  virtual Executor<lua_State*>* clone () const
     520  {
     521    return new ExecutorLua6ret<T, ret, type0, type1, type2, type3, type4, type5>(this->functionPointer);
     522  }
     523private:
     524  ret           (T::*functionPointer)(type0, type1, type2, type3, type4, type5);
    648525};
    649526
    … …  
    652529///////////
    653530//! Executes a Function with a lua_State* parameter.
    654 template<class T, typename ret, typename type0, typename type1, typename type2, typename type3, typename type4, typename type5, typename type6> class ExecutorLua7ret : public Executor
    655 {
    656   public:
    657     /**
    658    * @brief Constructor of a ExecutorXML
    659    * @param function a Function to call
    660      */
    661     ExecutorLua7ret(ret (T::*function)(type0, type1, type2, type3, type4, type5, type6))
    662   : Executor(ExecutorParamType<type0>(), ExecutorParamType<type1>(),
    663              ExecutorParamType<type2>(), ExecutorParamType<type3>(),
    664              ExecutorParamType<type4>(), ExecutorParamType<type5>(),
    665              ExecutorParamType<type6>())
    666              {
    667                this->functionPointer = function;
    668                this->functorType = Executor_Objective | Executor_NoLoadString;
    669              }
    670 
    671     /**
    672               * @brief executes the Command on BaseObject
    673               * @param object the BaseObject to execute this Executor on
    674               * @param loadString ignored in this case
    675      */
    676              virtual void operator()(BaseObject* object, const SubString& = SubString()) const
    677              {
    678                PRINTF(1)("no usefull executor\n");
    679              }
    680 
    681              virtual void operator()(BaseObject* object, int& count, void* values) const
    682              {
    683                lua_State* state = (lua_State*)values;
    684                count = 1;
    685 
    686                toLua<ret>(state, (dynamic_cast<T*>(object)->*(functionPointer))(
    687                    fromLua<type0>(state, 1),
    688                    fromLua<type1>(state, 2),
    689                    fromLua<type2>(state, 3),
    690                    fromLua<type3>(state, 4),
    691                    fromLua<type4>(state, 5),
    692                    fromLua<type5>(state, 6),
    693                    fromLua<type6>(state, 7) ));
    694              }
    695 
    696     /**
    697               * @returns a _new_ Copy of this Executor
    698      */
    699              virtual Executor* clone () const
    700              {
    701                return new ExecutorLua7ret<T, ret, type0, type1, type2, type3, type4, type5, type6>(this->functionPointer);
    702              }
    703   private:
    704     ret           (T::*functionPointer)(type0, type1, type2, type3, type4, type5, type6);
     531template<class T, typename ret, typename type0, typename type1, typename type2, typename type3, typename type4, typename type5, typename type6> class ExecutorLua7ret : public Executor<lua_State*>
     532{
     533public:
     534  /**
     535  * @brief Constructor of a ExecutorXML
     536  * @param function a Function to call
     537   */
     538  ExecutorLua7ret(ret (T::*function)(type0, type1, type2, type3, type4, type5, type6))
     539      : Executor<lua_State*>(true, ExecutorParamType<type0>(), ExecutorParamType<type1>(),
     540                             ExecutorParamType<type2>(), ExecutorParamType<type3>(),
     541                             ExecutorParamType<type4>(), ExecutorParamType<type5>(),
     542                             ExecutorParamType<type6>())
     543  {
     544    this->functionPointer = function;
     545    this->functorType = Executor_Objective;
     546  }
     547
     548  virtual void operator()(BaseObject* object, lua_State*& state) const
     549  {
     550    toLua<ret>(state, (dynamic_cast<T*>(object)->*(functionPointer))(
     551                 fromLua<type0>(state, 1),
     552                 fromLua<type1>(state, 2),
     553                 fromLua<type2>(state, 3),
     554                 fromLua<type3>(state, 4),
     555                 fromLua<type4>(state, 5),
     556                 fromLua<type5>(state, 6),
     557                 fromLua<type6>(state, 7) ));
     558  }
     559
     560  /**
     561            * @returns a _new_ Copy of this Executor
     562   */
     563  virtual Executor<lua_State*>* clone () const
     564  {
     565    return new ExecutorLua7ret<T, ret, type0, type1, type2, type3, type4, type5, type6>(this->functionPointer);
     566  }
     567private:
     568  ret           (T::*functionPointer)(type0, type1, type2, type3, type4, type5, type6);
    705569};
    706570
Note: See TracChangeset for help on using the changeset viewer.