Changeset 9733 in orxonox.OLD for branches/new_class_id/src/lib/util/executor/executor.h

Timestamp:

Sep 15, 2006, 3:39:51 PM (18 years ago)

Author:

bensch

Message:

orxonox/new_class_id: removed all the base of Executor.
Now it is purely Templated , since it is not needed otherwise

@note: The Explicit Specializations may not be Templatet and defined in the header, that is why still there exist some cc-file

File:

• branches/new_class_id/src/lib/util/executor/executor.h (modified) (5 diffs)

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

@@ -9 +9 @@
 #include "base_object.h"
 
-#include "helper_functions.h"
 #include "multi_type.h"
-#include "functor_list.h" //< MUST BE INCLUDED HERE AT LEAST ONCE.
-
-//! an enumerator for the definition of the Type.
-typedef enum {
-  Executor_Objective,
-  Executor_Static,
-} Executor_Type;
 
 //! The maximum Count of Arguments of the Executor
@@ -47 +39 @@
  *  Functions with many types (@see functor_list.h)
  */
-class ExecutorBase
+template <typename CallType> class Executor
 {
 public:
+  //! an enumerator for the definition of the Type.
+  typedef enum {
+    FunctionDefault,
+    FunctionStatic,
+    FunctionConst,
+  } FunctionType;
+
+public:
+  virtual ~Executor() {};
+
+  // RETRIEVE INFORMATION
   /** @param i the i'th defaultValue, @returns reference to the MultiType */
   inline MultiType& getDefaultValue(unsigned int i) { return defaultValue[i]; };
+  /** @returns the default Values as a List */
+  inline const MultiType* const getDefaultValues() { return defaultValue; };
 
-  // RETRIEVE INFORMATION
   /** @returns the Type of this Function (either static or objective) */
-  inline Executor_Type getType() const { return this->functorType; };
+  inline FunctionType getType() const { return this->functionType; };
 
   /** @returns the Count of Parameters this Executor takes */
@@ -61 +65 @@
   /** @returns true if the Executor has a return Value. */
   inline bool hasRetVal() const { return bRetVal; };
-
-  static void debug();
-
-protected:
-  virtual ~ExecutorBase() {};
-  ExecutorBase(bool hasRetVal = false,
-               const MultiType& param0 = MT_NULL, const MultiType& param1 = MT_NULL,
-               const MultiType& param2 = MT_NULL, const MultiType& param3 = MT_NULL,
-               const MultiType& param4 = MT_NULL, const MultiType& param5 = MT_NULL,
-               const MultiType& param6 = MT_NULL);
-
-  // SETTING up the EXECUTOR
-  void defaultValues(const MultiType& value0 = MT_NULL, const MultiType& value1 = MT_NULL,
-                     const MultiType& value2 = MT_NULL, const MultiType& value3 = MT_NULL,
-                     const MultiType& value4 = MT_NULL, const MultiType& param5 = MT_NULL,
-                     const MultiType& param6 = MT_NULL);
-
-  void cloning(ExecutorBase* executor) const;
-
-protected:
-  Executor_Type               functorType;      //!< The type of Function we've got (either static or objective).
-  unsigned int                paramCount;       //!< the count of parameters.
-  MultiType                   defaultValue[7];  //!< Default Values.
-
-private:
-  const bool                  bRetVal;          //!< True if the Executor has a return Value.
-  const bool                  bStaticFunction;  //!< A Executor to a Static Function
-  const bool                  bConstFunction;   //!< A Executor to a Constant Function
-};
-
-template <typename CallType> class Executor : public ExecutorBase
-{
-public:
-  virtual Executor<CallType>* clone () const = 0;
 
   /** executes a Command. @param objec the Object, @param count how many values, @param values the Values */
@@ -114 +84 @@
                           const MultiType& value6 = MT_NULL)
   {
-    this->ExecutorBase::defaultValues(value0, value1, value2, value3, value4, value5, value6);
+    const MultiType* value[5];
+    value[0] = &value0;
+    value[1] = &value1;
+    value[2] = &value2;
+    value[3] = &value3;
+    value[4] = &value4;
+    value[5] = &value5;
+    value[6] = &value6;
+    for (unsigned int i = 0; i < this->paramCount; i++)
+    {
+      if (*value[i] != MT_NULL)
+      {
+        this->defaultValue[i].setValueOf(*value[i]);
+        this->defaultValue[i].storeString();
+      }
+    }
     return this;
   }
+
+  virtual Executor<CallType>* clone () const = 0;
 
 protected:
@@ -124 +111 @@
            const MultiType& param4 = MT_NULL, const MultiType& param5 = MT_NULL,
            const MultiType& param6 = MT_NULL)
-      : ExecutorBase(hasRetVal, param0, param1, param2, param3, param4, param5, param6)
-{}}
-;
+      : bRetVal(hasRetVal)
+  {
+    // What Parameters have we got
+    this->defaultValue[0] = param0;
+    this->defaultValue[1] = param1;
+    this->defaultValue[2] = param2;
+    this->defaultValue[3] = param3;
+    this->defaultValue[4] = param4;
+    this->defaultValue[5] = param5;
+    this->defaultValue[6] = param6;
+
+    this->paramCount = 0;
+    for (unsigned int i = 0; i <= EXECUTOR_MAX_ARGUMENTS; i++)
+    {
+      if (this->defaultValue[i] == MT_NULL || i == EXECUTOR_MAX_ARGUMENTS)
+      {
+        this->paramCount = i;
+        break;
+      }
+      else
+        this->defaultValue[i].storeString();
+    }
+  }
+
+
+
+protected:
+  unsigned int                paramCount;       //!< the count of parameters.
+  MultiType                   defaultValue[7];  //!< Default Values.
+
+  FunctionType          functionType;     //!< What Type of Function it is.
+private:
+  const bool                  bRetVal;          //!< True if the Executor has a return Value.
+};
 
 #endif /* _EXECUTOR_H */