Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
Sep 19, 2006, 9:35:11 PM (18 years ago)
Author:
bensch
Message:

orxonox/branches/new_class_id: even more templates (mostly to safe space)

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r9748 r9769  
    6868///////////
    6969//! @brief ExecutorClass, that can execute Functions without any parameters.
    70 template<class T, typename CallType, template<typename> class Evaluater = ExecutorEvaluater, class BaseClass = BaseObject>
     70template<class T, typename CallType, class BaseClass = BaseObject, template<typename> class Evaluater = ExecutorEvaluater>
    7171class __EXECUTOR_FUNCTIONAL_NAME(0,) :public Executor<CallType, BaseClass>
    7272{
    … …  
    8989   * @param eval the CallType to get the Parameters from.
    9090   */
    91   virtual void operator()(BaseObject* object, CallType& eval = Evaluater<CallType>::defaultValue()) const
     91  virtual void operator()(BaseClass* object, CallType& eval = Evaluater<CallType>::defaultValue()) const
    9292  {
    9393    (__EXECUTOR_FUNCTIONAL_FUNCTION_EXEC)();
    … …  
    100100  virtual Executor<CallType, BaseClass>* clone() const
    101101  {
    102     return new __EXECUTOR_FUNCTIONAL_NAME(0,)<T, CallType>(this->functionPointer);
     102    return new __EXECUTOR_FUNCTIONAL_NAME(0,)<T, CallType, BaseClass>(this->functionPointer);
    103103  };
    104104};
    … …  
    110110///////////
    111111//! @brief ExecutorClass, that can execute Functions with one parameter.
    112 template<class T, typename CallType, typename type0, template<typename> class Evaluater = ExecutorEvaluater, class BaseClass = BaseObject>
     112template<class T, typename CallType, typename type0, class BaseClass = BaseObject, template<typename> class Evaluater = ExecutorEvaluater>
    113113class __EXECUTOR_FUNCTIONAL_NAME(1,) : public Executor<CallType, BaseClass>
    114114{
    … …  
    131131   * @param eval the CallType to get the Parameters from.
    132132   */
    133   virtual void operator()(BaseObject* object, CallType& eval = Evaluater<CallType>::defaultValue()) const
     133  virtual void operator()(BaseClass* object, CallType& eval = Evaluater<CallType>::defaultValue()) const
    134134  {
    135135    (__EXECUTOR_FUNCTIONAL_FUNCTION_EXEC)(
    … …  
    143143  virtual Executor<CallType, BaseClass>* clone() const
    144144  {
    145     return  new __EXECUTOR_FUNCTIONAL_NAME(1,)<T, CallType, type0>(this->functionPointer);
     145    return  new __EXECUTOR_FUNCTIONAL_NAME(1,)<T, CallType, type0, BaseClass>(this->functionPointer);
    146146  };
    147147};
    … …  
    153153///////////
    154154//! @brief ExecutorClass, that can execute Functions with two parameters.
    155 template<class T, typename CallType, typename type0, typename type1, template<typename> class Evaluater = ExecutorEvaluater, class BaseClass = BaseObject>
     155template<class T, typename CallType, typename type0, typename type1, class BaseClass = BaseObject, template<typename> class Evaluater = ExecutorEvaluater>
    156156class __EXECUTOR_FUNCTIONAL_NAME(2,) : public Executor<CallType, BaseClass>
    157157{
    … …  
    174174   * @param eval the CallType to get the Parameters from.
    175175   */
    176   virtual void operator()(BaseObject* object, CallType& eval = Evaluater<CallType>::defaultValue()) const
     176  virtual void operator()(BaseClass* object, CallType& eval = Evaluater<CallType>::defaultValue()) const
    177177  {
    178178    (__EXECUTOR_FUNCTIONAL_FUNCTION_EXEC)(
    … …  
    187187  virtual Executor<CallType, BaseClass>* clone() const
    188188  {
    189     return new __EXECUTOR_FUNCTIONAL_NAME(2,)<T, CallType, type0, type1>(this->functionPointer);
     189    return new __EXECUTOR_FUNCTIONAL_NAME(2,)<T, CallType, type0, type1, BaseClass>(this->functionPointer);
    190190  };
    191191};
    … …  
    197197///////////
    198198//! @brief ExecutorClass, that can execute Functions with three parameters.
    199 template<class T, typename CallType, typename type0, typename type1, typename type2, template<typename> class Evaluater = ExecutorEvaluater, class BaseClass = BaseObject>
     199template<class T, typename CallType, typename type0, typename type1, typename type2, class BaseClass = BaseObject, template<typename> class Evaluater = ExecutorEvaluater>
    200200class __EXECUTOR_FUNCTIONAL_NAME(3,) : public Executor<CallType, BaseClass>
    201201{
    … …  
    218218   * @param eval the CallType to get the Parameters from.
    219219   */
    220   virtual void operator()(BaseObject* object, CallType& eval = Evaluater<CallType>::defaultValue()) const
     220  virtual void operator()(BaseClass* object, CallType& eval = Evaluater<CallType>::defaultValue()) const
    221221  {
    222222    (__EXECUTOR_FUNCTIONAL_FUNCTION_EXEC)(
    … …  
    232232  virtual Executor<CallType, BaseClass>* clone() const
    233233  {
    234     return new __EXECUTOR_FUNCTIONAL_NAME(3,)<T, CallType, type0, type1, type2>(this->functionPointer);
     234    return new __EXECUTOR_FUNCTIONAL_NAME(3,)<T, CallType, type0, type1, type2, BaseClass>(this->functionPointer);
    235235  };
    236236};
    … …  
    242242///////////
    243243//! @brief ExecutorClass, that can execute Functions with four parameters.
    244 template<class T, typename CallType, typename type0, typename type1, typename type2, typename type3, template<typename> class Evaluater = ExecutorEvaluater, class BaseClass = BaseObject>
     244template<class T, typename CallType, typename type0, typename type1, typename type2, typename type3, class BaseClass = BaseObject, template<typename> class Evaluater = ExecutorEvaluater>
    245245class __EXECUTOR_FUNCTIONAL_NAME(4,) : public Executor<CallType, BaseClass>
    246246{
    … …  
    263263  * @param eval the CallType to get the Parameters from.
    264264   */
    265   virtual void operator()(BaseObject* object, CallType& eval = Evaluater<CallType>::defaultValue()) const
     265  virtual void operator()(BaseClass* object, CallType& eval = Evaluater<CallType>::defaultValue()) const
    266266  {
    267267    (__EXECUTOR_FUNCTIONAL_FUNCTION_EXEC)(
    … …  
    278278  virtual Executor<CallType, BaseClass>* clone() const
    279279  {
    280     return new __EXECUTOR_FUNCTIONAL_NAME(4,)<T, CallType, type0, type1, type2, type3>(this->functionPointer);
     280    return new __EXECUTOR_FUNCTIONAL_NAME(4,)<T, CallType, type0, type1, type2, type3, BaseClass>(this->functionPointer);
    281281  };
    282282};
    … …  
    288288///////////
    289289//! @brief ExecutorClass, that can execute Functions with five parameters.
    290 template<class T, typename CallType, typename type0, typename type1, typename type2, typename type3, typename type4, template<typename> class Evaluater = ExecutorEvaluater, class BaseClass = BaseObject>
     290template<class T, typename CallType, typename type0, typename type1, typename type2, typename type3, typename type4, class BaseClass = BaseObject, template<typename> class Evaluater = ExecutorEvaluater>
    291291class __EXECUTOR_FUNCTIONAL_NAME(5,) : public Executor<CallType, BaseClass>
    292292{
    … …  
    309309  * @param eval the CallType to get the Parameters from.
    310310   */
    311   virtual void operator()(BaseObject* object, CallType& eval = Evaluater<CallType>::defaultValue()) const
     311  virtual void operator()(BaseClass* object, CallType& eval = Evaluater<CallType>::defaultValue()) const
    312312  {
    313313    (__EXECUTOR_FUNCTIONAL_FUNCTION_EXEC)(
    … …  
    325325  virtual Executor<CallType, BaseClass>* clone() const
    326326  {
    327     return new __EXECUTOR_FUNCTIONAL_NAME(5,)<T, CallType, type0, type1, type2, type3, type4>(this->functionPointer);
     327    return new __EXECUTOR_FUNCTIONAL_NAME(5,)<T, CallType, type0, type1, type2, type3, type4, BaseClass>(this->functionPointer);
    328328  };
    329329};
    … …  
    334334////////////////////
    335335//! @brief ExecutorClass, that can execute Functions with one parameter.
    336 template<class T, typename CallType, typename ReturnType, template<typename> class Evaluater = ExecutorEvaluater, class BaseClass = BaseObject>
     336template<class T, typename CallType, typename ReturnType, class BaseClass = BaseObject, template<typename> class Evaluater = ExecutorEvaluater>
    337337class __EXECUTOR_FUNCTIONAL_NAME(0,ret) : public Executor<CallType, BaseClass>
    338338{
    … …  
    355355     * @param eval the CallType to get the Parameters from.
    356356   */
    357   virtual void operator()(BaseObject* object, CallType& eval = Evaluater<CallType>::defaultValue()) const
     357  virtual void operator()(BaseClass* object, CallType& eval = Evaluater<CallType>::defaultValue()) const
    358358  {
    359359    Evaluater<CallType>::template storeRet<ReturnType>(eval, (__EXECUTOR_FUNCTIONAL_FUNCTION_EXEC)());
    … …  
    366366  virtual Executor<CallType, BaseClass>* clone() const
    367367  {
    368     return  new __EXECUTOR_FUNCTIONAL_NAME(0,ret)<T, CallType, ReturnType>(this->functionPointer);
     368    return  new __EXECUTOR_FUNCTIONAL_NAME(0,ret)<T, CallType, ReturnType, BaseClass>(this->functionPointer);
    369369  };
    370370};
    … …  
    374374////////////////////
    375375//! @brief ExecutorClass, that can execute Functions with one parameter.
    376 template<class T, typename CallType, typename ReturnType, typename type0, template<typename> class Evaluater = ExecutorEvaluater, class BaseClass = BaseObject>
     376template<class T, typename CallType, typename ReturnType, typename type0, class BaseClass = BaseObject, template<typename> class Evaluater = ExecutorEvaluater>
    377377class __EXECUTOR_FUNCTIONAL_NAME(1,ret) : public Executor<CallType, BaseClass>
    378378{
    … …  
    395395     * @param eval the CallType to get the Parameters from.
    396396   */
    397   virtual void operator()(BaseObject* object, CallType& eval = Evaluater<CallType>::defaultValue()) const
     397  virtual void operator()(BaseClass* object, CallType& eval = Evaluater<CallType>::defaultValue()) const
    398398  {
    399399    Evaluater<CallType>::template storeRet<ReturnType>(eval, (__EXECUTOR_FUNCTIONAL_FUNCTION_EXEC)(
    … …  
    407407  virtual Executor<CallType, BaseClass>* clone() const
    408408  {
    409     return  new __EXECUTOR_FUNCTIONAL_NAME(1,ret)<T, CallType, ReturnType, type0>(this->functionPointer);
     409    return  new __EXECUTOR_FUNCTIONAL_NAME(1,ret)<T, CallType, ReturnType, type0, BaseClass>(this->functionPointer);
    410410  };
    411411};
    … …  
    416416////////////////////
    417417//! @brief ExecutorClass, that can execute Functions with one parameter.
    418 template<class T, typename CallType, typename ReturnType, typename type0, typename type1, template<typename> class Evaluater = ExecutorEvaluater, class BaseClass = BaseObject>
     418template<class T, typename CallType, typename ReturnType, typename type0, typename type1, class BaseClass = BaseObject, template<typename> class Evaluater = ExecutorEvaluater>
    419419class __EXECUTOR_FUNCTIONAL_NAME(2,ret) : public Executor<CallType, BaseClass>
    420420{
    … …  
    437437     * @param eval the CallType to get the Parameters from.
    438438   */
    439   virtual void operator()(BaseObject* object, CallType& eval = Evaluater<CallType>::defaultValue()) const
     439  virtual void operator()(BaseClass* object, CallType& eval = Evaluater<CallType>::defaultValue()) const
    440440  {
    441441    Evaluater<CallType>::template storeRet<ReturnType>(eval, (__EXECUTOR_FUNCTIONAL_FUNCTION_EXEC)(
    … …  
    450450  virtual Executor<CallType, BaseClass>* clone() const
    451451  {
    452     return  new __EXECUTOR_FUNCTIONAL_NAME(2,ret)<T, CallType, ReturnType, type0, type1>(this->functionPointer);
     452    return  new __EXECUTOR_FUNCTIONAL_NAME(2,ret)<T, CallType, ReturnType, type0, type1, BaseClass>(this->functionPointer);
    453453  };
    454454};
Note: See TracChangeset for help on using the changeset viewer.