Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Changeset 9869 in orxonox.OLD for trunk/src/lib/util/executor


Ignore:
Timestamp:
Oct 3, 2006, 12:19:30 AM (18 years ago)
Author:
bensch
Message:

orxonox/trunk: merged the new_class_id branche back to the trunk.
merged with command:
svn merge ​https://svn.orxonox.net/orxonox/branches/new_class_id trunk -r9683:HEAD
no conflicts… puh..

Location:
trunk/src/lib/util/executor
Files:
5 deleted
3 edited
10 copied

Legend:

Unmodified
Added
Removed

  • trunk/src/lib/util/executor/executor.h

    r8894 r9869  
    99#include "base_object.h"
    1010
    11 #include "helper_functions.h"
    1211#include "multi_type.h"
    13 #include "substring.h"
    14 #include "functor_list.h" //< MUST BE INCLUDED HERE AT LEAST ONCE.
    15 
    16 //! an enumerator for the definition of the Type.
    17 typedef enum {
    18   Executor_Objective         = 1,
    19   Executor_Static            = 2,
    20 
    21   Executor_NoLoadString      = 8,
    22 } Executor_Type;
     12
     13//! The maximum Count of Arguments of the Executor
     14/** This is Hardcoded, for each Executor. */
     15#define EXECUTOR_MAX_ARGUMENTS                7
     16
     17
     18/** @returns the Type of an Argument taken by the Executor */
     19template<typename type> inline MT_Type ExecutorParamType() { return MT_EXT1; };
     20/** @returns the Type of an Argument taken by the Executor in this case MT_BOOL */
     21template<> inline MT_Type ExecutorParamType<bool>() { return MT_BOOL; };
     22/** @returns the Type of an Argument taken by the Executor in this case MT_INT*/
     23template<> inline MT_Type ExecutorParamType<int>() { return MT_INT; };
     24/** @returns the Type of an Argument taken by the Executor in this case MT_UINT*/
     25template<> inline MT_Type ExecutorParamType<unsigned int>() { return MT_UINT; };
     26/** @returns the Type of an Argument taken by the Executor in this case MT_FLOAT*/
     27template<> inline MT_Type ExecutorParamType<float>() { return MT_FLOAT; };
     28/** @returns the Type of an Argument taken by the Executor in this case MT_CHAR*/
     29template<> inline MT_Type ExecutorParamType<char>() { return MT_CHAR; };
     30/** @returns the Type of an Argument taken by the Executor in this case MT_STRING*/
     31template<> inline MT_Type ExecutorParamType<const std::string&>() { return MT_STRING; };
    2332
    2433////////////////
    … …  
    3645 *  Functions with many types (@see functor_list.h)
    3746 */
    38 class Executor : public BaseObject
     47template <typename CallType, class BaseClass = BaseObject> class Executor
    3948{
    40   public:
    41     virtual ~Executor();
    42 
    43     virtual Executor* clone () const = 0;
    44 //    virtual bool operator==(const Executor* executor) const = 0;
    45 
    46     // SETTING up the EXECUTOR
    47     Executor* defaultValues(const MultiType& value0 = MT_NULL, const MultiType& value1 = MT_NULL,
    48                             const MultiType& value2 = MT_NULL, const MultiType& value3 = MT_NULL,
    49                             const MultiType& value4 = MT_NULL, const MultiType& param5 = MT_NULL,
    50                             const MultiType& param6 = MT_NULL);
    51     /** @param i the i'th defaultValue, @returns reference to the MultiType */
    52     inline MultiType& getDefaultValue(unsigned int i) { return defaultValue[i]; };
    53 
    54     // EXECUTE
    55     /** executes a Command. @param objec the Object, @param count how many values, @param values the Values */
    56     virtual void operator()(BaseObject* object, int& count, void* values) const = 0;
    57     /** executes a Command @param object the object to apply this to @param parameters the parameters the command takes */
    58     virtual void operator()(BaseObject* object, const SubString& sub = SubString()) const = 0;
    59 
    60     // RETRIEVE INFORMATION
    61     /** @returns the Type of this Function (either static or objective) */
    62     inline long getType() const { return this->functorType; };
    63     /** @returns the Count of Parameters this Executor takes */
    64     inline unsigned int getParamCount() const { return this->paramCount; };
    65 
    66     static void debug();
    67 
    68   protected:
    69     Executor(const MultiType& param0 = MT_NULL, const MultiType& param1 = MT_NULL,
    70              const MultiType& param2 = MT_NULL, const MultiType& param3 = MT_NULL,
    71              const MultiType& param4 = MT_NULL, const MultiType& param5 = MT_NULL,
    72              const MultiType& param6 = MT_NULL);
    73 
    74     void cloning(Executor* executor) const;
    75 
    76   protected:
    77     short                       functorType;      //!< The type of Function we've got (either static or objective).
    78     unsigned int                paramCount;       //!< the count of parameters.
    79     MultiType                   defaultValue[7];  //!< Default Values.
     49public:
     50  //! an enumerator for the definition of the Type.
     51  typedef enum {
     52    FunctionMember,      //!< The function is neither Static nor Constant
     53    FunctionStatic,      //!< The Function is Static and pointing to either a Static Member or a C-style function.
     54    FunctionConstMember, //!< The Function is Constant and pointing to a Member that does not change the Object.
     55  } FunctionType;
     56
     57public:
     58  virtual ~Executor() {};
     59
     60  // RETRIEVE INFORMATION
     61  /** @param i the i'th defaultValue, @returns reference to the MultiType */
     62  inline MultiType& getDefaultValue(unsigned int i) { return defaultValue[i]; };
     63  /** @returns the default Values as a List */
     64  inline const MultiType* const getDefaultValues() { return defaultValue; };
     65
     66  /** @returns the Type of this Function (either static or objective) */
     67  inline FunctionType getType() const { return this->functionType; };
     68
     69  /** @returns the Count of Parameters this Executor takes */
     70  inline unsigned int getParamCount() const { return this->paramCount; };
     71  /** @returns true if the Executor has a return Value. */
     72  inline bool hasRetVal() const { return bRetVal; };
     73
     74  /** executes a Command. @param object the Object, @param values The Value of type CallType to pass to the Executor. */
     75  virtual void operator()(BaseClass* object, CallType& values) const = 0;
     76
     77  /**
     78   * @brief set the default values of the executor
     79   * @param value0 the first default value
     80   * @param value1 the second default value
     81   * @param value2 the third default value
     82   * @param value3 the fourth default value
     83   * @param value4 the fifth default value
     84   * @param value5 the sixth default value
     85   * @param value6 the seventh default value
     86   * @returns itself
     87   * @note: THIS FUNCTION WILL BE REPLACED BY A CONFIGURATOR (most probably).
     88  */
     89  Executor* defaultValues(const MultiType& value0 = MT_NULL, const MultiType& value1 = MT_NULL,
     90                          const MultiType& value2 = MT_NULL, const MultiType& value3 = MT_NULL,
     91                          const MultiType& value4 = MT_NULL, const MultiType& value5 = MT_NULL,
     92                          const MultiType& value6 = MT_NULL)
     93  {
     94    const MultiType* value[5];
     95    value[0] = &value0;
     96    value[1] = &value1;
     97    value[2] = &value2;
     98    value[3] = &value3;
     99    value[4] = &value4;
     100    value[5] = &value5;
     101    value[6] = &value6;
     102    for (unsigned int i = 0; i < this->paramCount; i++)
     103    {
     104      if (*value[i] != MT_NULL)
     105      {
     106        this->defaultValue[i].setValueOf(*value[i]);
     107        this->defaultValue[i].storeString();
     108      }
     109    }
     110    return this;
     111  }
     112
     113  /** @returns the Clone as a new Copy of the Executor. */
     114  virtual Executor<CallType, BaseClass>* clone () const = 0;
     115
     116
     117protected:
     118  //! Now follows a List of Executor Constructors, to be fast in creating.
     119  //! Creates an Executor with no Argument.
     120  Executor(bool hasRetVal, FunctionType functionType = FunctionMember)
     121  : bRetVal(hasRetVal), paramCount(0), functionType(functionType)
     122  { };
     123
     124  //! Creates an Executor with 1 Argument.
     125  Executor(bool hasRetVal, const MultiType& param0,
     126           FunctionType functionType = FunctionMember)
     127  : bRetVal(hasRetVal), paramCount(1), functionType(functionType)
     128  {
     129    this->defaultValue[0] = param0;
     130  };
     131
     132  //! Creates an Executor with 2 Arguments.
     133  Executor(bool hasRetVal, const MultiType& param0, const MultiType& param1,
     134           FunctionType functionType = FunctionMember)
     135  : bRetVal(hasRetVal), paramCount(2), functionType(functionType)
     136  {
     137    this->defaultValue[0] = param0;
     138    this->defaultValue[1] = param1;
     139  };
     140
     141  //! Creates an Executor with 3 Arguments.
     142  Executor(bool hasRetVal, const MultiType& param0, const MultiType& param1,
     143           const MultiType& param2,
     144           FunctionType functionType = FunctionMember)
     145  : bRetVal(hasRetVal), paramCount(3), functionType(functionType)
     146  {
     147    this->defaultValue[0] = param0;
     148    this->defaultValue[1] = param1;
     149    this->defaultValue[2] = param2;
     150  };
     151
     152  //! Creates an Executor with 4 Arguments.
     153  Executor(bool hasRetVal, const MultiType& param0, const MultiType& param1,
     154           const MultiType& param2, const MultiType& param3,
     155           FunctionType functionType = FunctionMember)
     156  : bRetVal(hasRetVal), paramCount(4), functionType(functionType)
     157  {
     158    this->defaultValue[0] = param0;
     159    this->defaultValue[1] = param1;
     160    this->defaultValue[2] = param2;
     161    this->defaultValue[3] = param3;
     162  };
     163
     164  //! Creates an Executor with 5 Arguments.
     165  Executor(bool hasRetVal, const MultiType& param0, const MultiType& param1,
     166           const MultiType& param2, const MultiType& param3,
     167           const MultiType& param4,
     168           FunctionType functionType = FunctionMember)
     169  : bRetVal(hasRetVal), paramCount(5), functionType(functionType)
     170  {
     171    this->defaultValue[0] = param0;
     172    this->defaultValue[1] = param1;
     173    this->defaultValue[2] = param2;
     174    this->defaultValue[3] = param3;
     175    this->defaultValue[4] = param4;
     176  };
     177
     178  //! Creates an Executor with 6 Arguments.
     179  Executor(bool hasRetVal, const MultiType& param0, const MultiType& param1,
     180           const MultiType& param2, const MultiType& param3,
     181           const MultiType& param4, const MultiType& param5,
     182           FunctionType functionType = FunctionMember)
     183  : bRetVal(hasRetVal), paramCount(6), functionType(functionType)
     184  {
     185    this->defaultValue[0] = param0;
     186    this->defaultValue[1] = param1;
     187    this->defaultValue[2] = param2;
     188    this->defaultValue[3] = param3;
     189    this->defaultValue[4] = param4;
     190    this->defaultValue[5] = param5;
     191  };
     192
     193  //! Creates an Executor with 7 Arguments.
     194  Executor(bool hasRetVal, const MultiType& param0, const MultiType& param1,
     195           const MultiType& param2, const MultiType& param3,
     196           const MultiType& param4, const MultiType& param5,
     197           const MultiType& param6,
     198           FunctionType functionType = FunctionMember)
     199  : bRetVal(hasRetVal), paramCount(7), functionType(functionType)
     200  {
     201    this->defaultValue[0] = param0;
     202    this->defaultValue[1] = param1;
     203    this->defaultValue[2] = param2;
     204    this->defaultValue[3] = param3;
     205    this->defaultValue[4] = param4;
     206    this->defaultValue[5] = param5;
     207    this->defaultValue[6] = param6;
     208  };
     209
     210protected:
     211  const bool                  bRetVal;          //!< True if the Executor has a return Value.
     212  const unsigned int          paramCount;       //!< the count of parameters.
     213  MultiType                   defaultValue[7];  //!< Default Values.
     214
     215  const FunctionType          functionType;     //!< What Type of Function it is.
    80216};
    81217
    82 #include "executor/executor_functional.h"
    83 #define EXECUTOR_FUNCTIONAL_USE_CONST
    84 #include "executor/executor_functional.h"
    85 #define EXECUTOR_FUNCTIONAL_USE_STATIC
    86 #include "executor/executor_functional.h"
    87 
    88218#endif /* _EXECUTOR_H */

  • trunk/src/lib/util/executor/executor_xml.h

    r8362 r9869  
    1919 * What must be defined is a XML-root to search the ParameterName under an  a Function to call.
    2020 */
    21 template<class T> class ExecutorXML : public Executor
     21template<class T, class BaseClass = BaseObject> class ExecutorXML : public Executor<const TiXmlElement*>
    2222{
    23   public:
    24     /**
     23public:
     24  /**
    2525   * @brief Constructor of a ExecutorXML
    26      * @param function a Function to call
    27      * @param root The XML root to search paramName under
    28      * @param paramName the ParameterName the search in root, and lookup the TiXmlElement from
    29      */
    30     ExecutorXML(void(T::*function)(const TiXmlElement*), const TiXmlElement* root, const char* paramName)
    31       : Executor(MT_EXT1)
    32     {
    33       PRINTF(4)("Loading %s from XML-element %p\n", paramName, root);
     26   * @param function a Function to call
     27   * @param root The XML root to search paramName under
     28   * @param paramName the ParameterName the search in root, and lookup the TiXmlElement from
     29   */
     30  ExecutorXML(void(T::*function)(const TiXmlElement*), const TiXmlElement* root, const std::string& paramName)
     31      : Executor<const TiXmlElement*>(false, MT_EXT1)
     32  {
     33    PRINTF(4)("Loading %s from XML-element %p\n", paramName.c_str(), root);
    3434
    35       if (likely(root != NULL && paramName != NULL))
    36         this->element = root->FirstChildElement(paramName);
    37       else
    38         this->element = NULL;
     35    if (likely(root != NULL))
     36      this->element = root->FirstChildElement(paramName);
     37    else
     38      this->element = NULL;
    3939
    40       this->functionPointer = function;
    41       this->functorType = Executor_Objective | Executor_NoLoadString;
    42     }
     40    this->paramName = paramName;
     41    this->functionPointer = function;
     42  }
    4343
    44     /**
    45      * @brief clones an ExecutorXML, used to copy this Element.
    46      * @returns a _new_ Copy of this Executor
    47      */
    48     virtual Executor* clone () const
    49     {
    50       ExecutorXML<T>* executor = new ExecutorXML<T>();
    51       this->cloning(executor);
    52       executor->functionPointer = this->functionPointer;
    53       executor->element = this->element;
    54       return executor;
    55     }
     44  /**
     45   * @brief clones an ExecutorXML, used to copy this Element.
     46   * @returns a _new_ Copy of this Executor
     47   */
     48  virtual Executor<const TiXmlElement*>* clone () const
     49  {
     50    return new ExecutorXML<T>(functionPointer, element, paramName);
     51  }
    5652
    57     /**
    58      * @brief executes the Command on BaseObject
    59      * @param object the BaseObject to execute this Executor on
    60      * @param loadString ignored in this case
    61      */
    62     virtual void operator()(BaseObject* object, const SubString& = SubString()) const
    63     {
    64       if (object != NULL && this->element != NULL)
    65         (dynamic_cast<T*>(object)->*(functionPointer))(this->element);
    66     }
     53  /**
     54   * @brief executes the Command on BaseObject
     55   * @param object the BaseObject to execute this Executor on
     56   * @param element ignored in this case
     57   */
     58  virtual void operator()(BaseObject* object, const TiXmlElement*& element) const
     59  {
     60    assert (object != NULL);
     61    if (this->element != NULL)
     62      (dynamic_cast<T*>(object)->*(functionPointer))(this->element);
     63  }
    6764
    68     virtual void operator()(BaseObject* object, int& count, void* values) const
    69     {
    70       PRINTF(1)("missuse of XML-operator, OR IMPLEMENT.\n");
    71     }
    72 
    73   private:
    74     /**
    75    * @brief used for the copy-(Clone)-constructor
    76      */
    77     ExecutorXML() : Executor() { };
    78 
    79 
    80   private:
    81     void    (T::*functionPointer)(const TiXmlElement*);  //!< The functionPointer to the function to be called
    82     const   TiXmlElement* element;                       //!< The XML-element to call.
     65private:
     66  void    (T::*functionPointer)(const TiXmlElement*);  //!< The functionPointer to the function to be called.
     67  const   TiXmlElement* element;                       //!< The XML-element to call.
     68  std::string           paramName;                     //!< The Name of the Parameter this Executor should call.
    8369};
    8470

  • trunk/src/lib/util/executor/functor_list.h

    r9406 r9869  
     1/*!
     2 * @file functor_list.h
     3 * all the Different types of Functions one can include by using a simple createExecutor call
     4 * with a FunctionPointer as Argument
     5 */
    16/*
    27   orxonox - the future of 3D-vertical-scrollers
    … …  
    813   the Free Software Foundation; either version 2, or (at your option)
    914   any later version.
    10    */
    11 
    12 /*!
    13  * @file functors_list.h
    14  * all the Different types of Functions one can include
    1515*/
    16 
    17 /**
    18    useable FunctionParameters are:
    19    l_INT:       int
    20    l_LONG:      long
    21    l_SHORT:     short
    22    l_FLOAT:     float
    23    l_STRING:    const std::string&
    24    l_XML_ELEM:  TiXmlElement*
    25  */
    26 
    27 #ifndef __FUNCTOR_PARAMETERS__
    28 #define __FUNCTOR_PARAMETERS__
    29 
    30 //! defines the maximum count of arguments function pointers might have
    31 #define FUNCTOR_MAX_ARGUMENTS                7
    32 #include "multi_type.h"
    33 
    34 
    35 #define l_BOOL_TYPE        bool                 //!< The type of an BOOL
    36 #define l_BOOL_FUNC        isBool               //!< The function to call to parse BOOL
    37 #define l_BOOL_PARAM       MT_BOOL              //!< the type of the parameter BOOL
    38 #define l_BOOL_DEFAULT     false                //!< a default Value for an BOOL
    39 #define l_BOOL_DEFGRAB(i)  this->defaultValue[i].getBool()
    40 
    41 #define l_INT_TYPE         int                  //!< The type of an INT
    42 #define l_INT_FUNC         isInt                //!< The function to call to parse INT
    43 #define l_INT_PARAM        MT_INT               //!< the type of the parameter INT
    44 #define l_INT_DEFAULT      0                    //!< a default Value for an INT
    45 #define l_INT_DEFGRAB(i)   this->defaultValue[i].getInt()
    46 
    47 #define l_UINT_TYPE        unsigned int         //!< The type of an UINT
    48 #define l_UINT_FUNC        isInt                //!< The function to call to parse UINT
    49 #define l_UINT_PARAM       MT_INT        //!< the type of the parameter UINT
    50 #define l_UINT_DEFAULT     0                    //!< a default Value for an UINT
    51 #define l_UINT_DEFGRAB(i)  (unsigned int)this->defaultValue[i].getInt()
    52 
    53 #define l_LONG_TYPE        long                 //!< The type of a LONG
    54 #define l_LONG_FUNC        isInt                //!< The function to parse a LONG
    55 #define l_LONG_PARAM       MT_INT //!< the type of the parameter LONG
    56 #define l_LONG_DEFAULT     0                    //!< a default Value for a LONG
    57 #define l_LONG_DEFGRAB(i)  (long)this->defaultValue[i].getInt()
    58 
    59 // #define l_SHORT_TYPE       short                //!< The type of a SHORT
    60 // #define l_SHORT_FUNC       atoi                 //!< The function to parse a SHORT
    61 // #define l_SHORT_NAME       "short"              //!< The name of a SHORT
    62 // #define l_SHORT_PARAM      ParameterShort       //!< the type of the parameter SHORT
    63 // #define l_SHORT_DEFAULT    0                    //!< a default Value for a SHORT
    64 
    65 #define l_FLOAT_TYPE       float                //!< The type of a FLOAT
    66 #define l_FLOAT_FUNC       isFloat              //!< The function to parse a FLOAT
    67 #define l_FLOAT_PARAM      MT_FLOAT             //!< the type of the parameter FLOAT
    68 #define l_FLOAT_DEFAULT    0.0                  //!< a default Value for a FLOAT
    69 #define l_FLOAT_DEFGRAB(i) this->defaultValue[i].getFloat()
    70 
    71 //#define l_VECTOR_TYPE      const Vector&        //!< The type of a VECTOR
    72 //#define l_VECTOR_FUNC      isVector             //!< The function to parse a VECTOR
    73 //#define l_VECTOR_NAME      "Vector[x/y/z]"      //!< The name of a VECTOR
    74 //#define l_VECTOR_DEFAULT   Vector(0,0,0)        //!< Default value for a VECTOR
    75 
    76 #define l_STRING_TYPE      const std::string&   //!< The type of a STRING
    77 #define l_STRING_FUNC      isString             //!< The function to parse a STRING
    78 #define l_STRING_PARAM     MT_STRING            //!< the type of the parameter STRING
    79 #define l_STRING_DEFAULT   ""                   //!< a default Value for an STRING
    80 #define l_STRING_DEFGRAB(i) this->defaultValue[i].getString()
    81 
    82 #define l_XML_ELEM_TYPE    const TiXmlElement*  //!< The type of an XML_ELEM
    83 #define l_XML_ELEM_FUNC                         //!< The function to parse an XML_ELEM
    84 //#define l_XML_ELEM_PARAM   Parameter            //!< the type of the parameter XML_ELEM
    85 #define l_XML_ELEM_DEFAULT NULL                 //!< The dafault Value for an XML_ELEM
    86 
    87 #endif /* __FUNCTOR_PARAMETERS__ */
    8816
    8917
    9018#ifdef FUNCTOR_LIST
    91 
    92   FUNCTOR_LIST(0)();
     19  FUNCTOR_LIST(0)(FUNCTOR_CALL_TYPE);
    9320  //! makes functions with one string
    94   FUNCTOR_LIST(1)(l_STRING);
     21  FUNCTOR_LIST(1)(FUNCTOR_CALL_TYPE, const std::string&);
    9522  //! makes functions with two strings
    96   FUNCTOR_LIST(2)(l_STRING, l_STRING);
     23  FUNCTOR_LIST(2)(FUNCTOR_CALL_TYPE, const std::string&, const std::string&);
    9724  //! makes functions with three strings
    98   FUNCTOR_LIST(3)(l_STRING, l_STRING, l_STRING);
     25  FUNCTOR_LIST(3)(FUNCTOR_CALL_TYPE, const std::string&, const std::string&, const std::string&);
    9926  //! makes functions with four strings
    100   FUNCTOR_LIST(4)(l_STRING, l_STRING, l_STRING, l_STRING);
     27  FUNCTOR_LIST(4)(FUNCTOR_CALL_TYPE, const std::string&, const std::string&, const std::string&, const std::string&);
    10128
    10229
    10330  //! makes functions with one bool
    104   FUNCTOR_LIST(1)(l_BOOL);
     31  FUNCTOR_LIST(1)(FUNCTOR_CALL_TYPE, bool);
    10532
    10633  //! makes functions with one int
    107   FUNCTOR_LIST(1)(l_INT);
     34  FUNCTOR_LIST(1)(FUNCTOR_CALL_TYPE, int);
    10835  //! makes functions with two ints
    109   FUNCTOR_LIST(2)(l_INT, l_INT);
     36  FUNCTOR_LIST(2)(FUNCTOR_CALL_TYPE, int, int);
    11037  //! makes functions with three ints
    111   FUNCTOR_LIST(3)(l_INT, l_INT, l_INT);
     38  FUNCTOR_LIST(3)(FUNCTOR_CALL_TYPE, int, int, int);
    11239  //! makes functions with four ints
    113   FUNCTOR_LIST(4)(l_INT, l_INT, l_INT, l_INT);
     40  FUNCTOR_LIST(4)(FUNCTOR_CALL_TYPE, int, int, int, int);
    11441
    11542
    11643  //! makes functions with one unsigned int
    117   FUNCTOR_LIST(1)(l_UINT);
     44  FUNCTOR_LIST(1)(FUNCTOR_CALL_TYPE, unsigned int);
    11845  //! makes functions with two unsigned ints
    119   FUNCTOR_LIST(2)(l_UINT, l_UINT);
     46  FUNCTOR_LIST(2)(FUNCTOR_CALL_TYPE, unsigned int, unsigned int);
    12047  //! makes functions with three unsigned ints
    121   FUNCTOR_LIST(3)(l_UINT, l_UINT, l_UINT);
     48  FUNCTOR_LIST(3)(FUNCTOR_CALL_TYPE, unsigned int, unsigned int, unsigned int);
    12249  //! makes functions with four unsigned ints
    123   FUNCTOR_LIST(4)(l_UINT, l_UINT, l_UINT, l_UINT);
     50  FUNCTOR_LIST(4)(FUNCTOR_CALL_TYPE, unsigned int, unsigned int, unsigned int, unsigned int);
    12451
    12552  //! makes functions with one float
    126   FUNCTOR_LIST(1)(l_FLOAT);
     53  FUNCTOR_LIST(1)(FUNCTOR_CALL_TYPE, float);
    12754  //! makes functions with two floats
    128   FUNCTOR_LIST(2)(l_FLOAT, l_FLOAT);
     55  FUNCTOR_LIST(2)(FUNCTOR_CALL_TYPE, float, float);
    12956  //! makes functions with three floats
    130   FUNCTOR_LIST(3)(l_FLOAT, l_FLOAT, l_FLOAT);
     57  FUNCTOR_LIST(3)(FUNCTOR_CALL_TYPE, float, float, float);
    13158  //! makes functions with four floats
    132   FUNCTOR_LIST(4)(l_FLOAT, l_FLOAT, l_FLOAT, l_FLOAT);
     59  FUNCTOR_LIST(4)(FUNCTOR_CALL_TYPE, float, float, float, float);
    13360  //! makes functions with four floats
    134   FUNCTOR_LIST(5)(l_FLOAT, l_FLOAT, l_FLOAT, l_FLOAT, l_FLOAT);
     61  FUNCTOR_LIST(5)(FUNCTOR_CALL_TYPE, float, float, float, float, float);
    13562
    13663  //! mixed values:
    137   FUNCTOR_LIST(2)(l_STRING, l_INT);
    138   FUNCTOR_LIST(2)(l_STRING, l_FLOAT);
    139   FUNCTOR_LIST(2)(l_UINT, l_LONG);
    140   FUNCTOR_LIST(2)(l_STRING, l_UINT);
     64  FUNCTOR_LIST(2)(FUNCTOR_CALL_TYPE, const std::string&, bool);
     65  FUNCTOR_LIST(2)(FUNCTOR_CALL_TYPE, const std::string&, int);
     66  FUNCTOR_LIST(2)(FUNCTOR_CALL_TYPE, const std::string&, float);
     67  FUNCTOR_LIST(2)(FUNCTOR_CALL_TYPE, unsigned int, long);
     68  FUNCTOR_LIST(2)(FUNCTOR_CALL_TYPE, const std::string&, unsigned int);
    14169
    142   FUNCTOR_LIST(3)(l_STRING, l_FLOAT, l_UINT);
    143   FUNCTOR_LIST(4)(l_STRING, l_FLOAT, l_UINT, l_UINT);
    144   FUNCTOR_LIST(3)(l_STRING, l_INT, l_UINT);
    145   FUNCTOR_LIST(3)(l_STRING, l_UINT, l_UINT);
     70  FUNCTOR_LIST(3)(FUNCTOR_CALL_TYPE, const std::string&, float, unsigned int);
     71  FUNCTOR_LIST(4)(FUNCTOR_CALL_TYPE, const std::string&, float, unsigned int, unsigned int);
     72  FUNCTOR_LIST(3)(FUNCTOR_CALL_TYPE, const std::string&, int, unsigned int);
     73  FUNCTOR_LIST(3)(FUNCTOR_CALL_TYPE, const std::string&, unsigned int, unsigned int);
    14674
    147   FUNCTOR_LIST(5)(l_FLOAT, l_FLOAT, l_FLOAT, l_FLOAT, l_STRING);
     75  FUNCTOR_LIST(5)(FUNCTOR_CALL_TYPE, float, float, float, float, const std::string&);
    14876
    14977#endif /* FUNCTOR_LIST */
Note: See TracChangeset for help on using the changeset viewer.