Changeset 9735 in orxonox.OLD for branches/new_class_id/src

Timestamp:

Sep 15, 2006, 4:16:06 PM (18 years ago)

Author:

bensch

Message:

orxonox/new_class_id: better usage of the FunctionType in the FunctionalExecutor

Location:

branches/new_class_id/src/lib/util/executor

Files:

• executor.h (modified) (4 diffs)
• executor_functional.h (modified) (23 diffs)
• executor_xml.h (modified) (1 diff)

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

@@ -39 +39 @@
  *  Functions with many types (@see functor_list.h)
  */
-template <typename CallType> class Executor
+template <typename CallType, class BaseClass = BaseObject> class Executor
 {
 public:
   //! an enumerator for the definition of the Type.
   typedef enum {
-    FunctionDefault,
-    FunctionStatic,
-    FunctionConst,
+    FunctionDefault,     //!< The function is neither Static nor Constant
+    FunctionStatic,      //!< The Function is Static and pointing to either a Static Member or a C-style function.
+    FunctionConst,       //!< The Function is Constant and pointing to a Member that does not change the Object.
   } FunctionType;
 
@@ -67 +67 @@
 
   /** executes a Command. @param objec the Object, @param count how many values, @param values the Values */
-  virtual void operator()(BaseObject* object, CallType& values) const = 0;
+  virtual void operator()(BaseClass* object, CallType& values) const = 0;
 
   /**
@@ -103 +103 @@
   }
 
+  /** @returns the Clone as a new Copy of the Executor. */
   virtual Executor<CallType>* clone () const = 0;
 
@@ -193 +194 @@
 protected:
   const bool                  bRetVal;          //!< True if the Executor has a return Value.
-  unsigned int                paramCount;       //!< the count of parameters.
+  const unsigned int          paramCount;       //!< the count of parameters.
   MultiType                   defaultValue[7];  //!< Default Values.
 

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

@@ -61 +61 @@
 {
 public:
+  /** @brief Executes the Evaluator
+   * @param CallValue the Value that should be converted
+   * @param defaults the default Values.
+   */
   ToType operator()(FromType& CallValue, const MultiType* const defaults)
   {
@@ -79 +83 @@
 //! The Function-Pointer, and how to save it internally.
 #define __EXECUTOR_FUNCTIONAL_FUNCTION_POINTER   T::*functionPointer
+#define __EXECUTOR_FUNCTIONAL_FUNCTIONTYPE       Executor<CallType, BaseClass>::FunctionDefault
 
 #ifdef EXECUTOR_FUNCTIONAL_USE_CONST            //! USING CONST FUNCTIONALS
@@ -88 +93 @@
  #undef __EXECUTOR_FUNCTIONAL_CONST
  #define __EXECUTOR_FUNCTIONAL_CONST const
+ #undef __EXECUTOR_FUNCTIONAL_FUNCTIONTYPE
+ #define __EXECUTOR_FUNCTIONAL_FUNCTIONTYPE       Executor<CallType, BaseClass>::FunctionConst
  #undef __EXECUTOR_FUNCTIONAL_NAME
  #define __EXECUTOR_FUNCTIONAL_NAME(ParamCount) Executor##ParamCount##Params_const
@@ -109 +116 @@
  #undef __EXECUTOR_FUNCTIONAL_FUNCTION_POINTER
  #define __EXECUTOR_FUNCTIONAL_FUNCTION_POINTER    *functionPointer
+ #undef __EXECUTOR_FUNCTIONAL_FUNCTIONTYPE
+ #define __EXECUTOR_FUNCTIONAL_FUNCTIONTYPE       Executor<CallType, BaseClass>::FunctionStatic
 
 //#endif /* EXECUTOR_FUNCTIONAL_USE_STATIC */
@@ -121 +130 @@
 #ifndef __EXECUTOR_FUNCTIONAL_NOT_INCLUDE_THIS
 
+
+
+
 ///////////
 //// 0 ////
 ///////////
 //! @brief ExecutorClass, that can execute Functions without any parameters.
-template<class T, typename CallType, template<typename, typename, int> class Evaluater = ExecutorEvaluater>
-class __EXECUTOR_FUNCTIONAL_NAME(0) :public Executor<CallType>
+template<class T, typename CallType, template<typename, typename, int> class Evaluater = ExecutorEvaluater, class BaseClass = BaseObject>
+class __EXECUTOR_FUNCTIONAL_NAME(0) :public Executor<CallType, BaseClass>
 {
 private:
@@ -138 +150 @@
    */
   __EXECUTOR_FUNCTIONAL_NAME(0) (void (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)() __EXECUTOR_FUNCTIONAL_CONST )
-      : Executor<CallType>(false)
+      : Executor<CallType, BaseClass>(false, __EXECUTOR_FUNCTIONAL_FUNCTIONTYPE)
   {
     this->functionPointer = functionPointer;
@@ -157 +169 @@
    * @returns a new Executor that's a copy of this one.
    */
-  virtual Executor<CallType>* clone() const
+  virtual Executor<CallType, BaseClass>* clone() const
   {
     return new __EXECUTOR_FUNCTIONAL_NAME(0)<T, CallType>(this->functionPointer);
@@ -165 +177 @@
 
 
+
+
 ///////////
 //// 1 ////
 ///////////
 //! @brief ExecutorClass, that can execute Functions with one parameter.
-template<class T, typename CallType, typename type0, template<typename, typename, int> class Evaluater = ExecutorEvaluater>
-class __EXECUTOR_FUNCTIONAL_NAME(1) : public Executor<CallType>
+template<class T, typename CallType, typename type0, template<typename, typename, int> class Evaluater = ExecutorEvaluater, class BaseClass = BaseObject>
+class __EXECUTOR_FUNCTIONAL_NAME(1) : public Executor<CallType, BaseClass>
 {
 private:
@@ -182 +196 @@
    */
   __EXECUTOR_FUNCTIONAL_NAME(1) (void (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)(type0) __EXECUTOR_FUNCTIONAL_CONST)
-      : Executor<CallType>(false, ExecutorParamType<type0>())
+      : Executor<CallType, BaseClass>(false, ExecutorParamType<type0>(), __EXECUTOR_FUNCTIONAL_FUNCTIONTYPE)
   {
     this->functionPointer = functionPointer;
@@ -202 +216 @@
    * @returns a new Executor that's a copy of this one.
    */
-  virtual Executor<CallType>* clone() const
+  virtual Executor<CallType, BaseClass>* clone() const
   {
     return  new __EXECUTOR_FUNCTIONAL_NAME(1)<T, CallType, type0>(this->functionPointer);
@@ -208 +222 @@
 };
 
+
+
+
+
 ///////////
 //// 2 ////
 ///////////
 //! @brief ExecutorClass, that can execute Functions with two parameters.
-template<class T, typename CallType, typename type0, typename type1, template<typename, typename, int> class Evaluater = ExecutorEvaluater>
-class __EXECUTOR_FUNCTIONAL_NAME(2) : public Executor<CallType>
+template<class T, typename CallType, typename type0, typename type1, template<typename, typename, int> class Evaluater = ExecutorEvaluater, class BaseClass = BaseObject>
+class __EXECUTOR_FUNCTIONAL_NAME(2) : public Executor<CallType, BaseClass>
 {
 private:
@@ -225 +243 @@
    */
   __EXECUTOR_FUNCTIONAL_NAME(2) (void (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)(type0, type1) __EXECUTOR_FUNCTIONAL_CONST)
-      : Executor<CallType>(false, ExecutorParamType<type0>(), ExecutorParamType<type1>())
+  : Executor<CallType, BaseClass>(false, ExecutorParamType<type0>(), ExecutorParamType<type1>(), __EXECUTOR_FUNCTIONAL_FUNCTIONTYPE)
   {
     this->functionPointer = functionPointer;
@@ -246 +264 @@
    * @returns a new Executor that's a copy of this one.
    */
-  virtual Executor<CallType>* clone() const
+  virtual Executor<CallType, BaseClass>* clone() const
   {
     return new __EXECUTOR_FUNCTIONAL_NAME(2)<T, CallType, type0, type1>(this->functionPointer);
@@ -253 +271 @@
 
 
+
+
+
 ///////////
 //// 3 ////
 ///////////
 //! @brief ExecutorClass, that can execute Functions with three parameters.
-template<class T, typename CallType, typename type0, typename type1, typename type2, template<typename, typename, int> class Evaluater = ExecutorEvaluater>
-class __EXECUTOR_FUNCTIONAL_NAME(3) : public Executor<CallType>
+template<class T, typename CallType, typename type0, typename type1, typename type2, template<typename, typename, int> class Evaluater = ExecutorEvaluater, class BaseClass = BaseObject>
+class __EXECUTOR_FUNCTIONAL_NAME(3) : public Executor<CallType, BaseClass>
 {
 private:
@@ -270 +291 @@
    */
   __EXECUTOR_FUNCTIONAL_NAME(3) (void (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)(type0, type1, type2) __EXECUTOR_FUNCTIONAL_CONST)
-      : Executor<CallType>(false, ExecutorParamType<type0>(), ExecutorParamType<type1>(), ExecutorParamType<type2>())
+  : Executor<CallType, BaseClass>(false, ExecutorParamType<type0>(), ExecutorParamType<type1>(), ExecutorParamType<type2>(), __EXECUTOR_FUNCTIONAL_FUNCTIONTYPE)
   {
     this->functionPointer = functionPointer;
@@ -292 +313 @@
    * @returns a new Executor that's a copy of this one.
    */
-  virtual Executor<CallType>* clone() const
+  virtual Executor<CallType, BaseClass>* clone() const
   {
     return new __EXECUTOR_FUNCTIONAL_NAME(3)<T, CallType, type0, type1, type2>(this->functionPointer);
@@ -300 +321 @@
 
 
+
+
 ///////////
 //// 4 ////
 ///////////
 //! @brief ExecutorClass, that can execute Functions with four parameters.
-template<class T, typename CallType, typename type0, typename type1, typename type2, typename type3, template<typename, typename, int> class Evaluater = ExecutorEvaluater>
-class __EXECUTOR_FUNCTIONAL_NAME(4) : public Executor<CallType>
+template<class T, typename CallType, typename type0, typename type1, typename type2, typename type3, template<typename, typename, int> class Evaluater = ExecutorEvaluater, class BaseClass = BaseObject>
+class __EXECUTOR_FUNCTIONAL_NAME(4) : public Executor<CallType, BaseClass>
 {
 private:
@@ -317 +340 @@
    */
   __EXECUTOR_FUNCTIONAL_NAME(4) (void (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)(type0, type1, type2, type3) __EXECUTOR_FUNCTIONAL_CONST)
-      : Executor<CallType>(false, ExecutorParamType<type0>(), ExecutorParamType<type1>(), ExecutorParamType<type2>(), ExecutorParamType<type3>())
+  : Executor<CallType, BaseClass>(false, ExecutorParamType<type0>(), ExecutorParamType<type1>(), ExecutorParamType<type2>(), ExecutorParamType<type3>(), __EXECUTOR_FUNCTIONAL_FUNCTIONTYPE)
   {
     this->functionPointer = functionPointer;
@@ -340 +363 @@
    * @returns a new Executor that's a copy of this one.
    */
-  virtual Executor<CallType>* clone() const
+  virtual Executor<CallType, BaseClass>* clone() const
   {
     return new __EXECUTOR_FUNCTIONAL_NAME(4)<T, CallType, type0, type1, type2, type3>(this->functionPointer);
@@ -348 +371 @@
 
 
+
+
+
 ///////////
 //// 5 ////
 ///////////
 //! @brief ExecutorClass, that can execute Functions with five parameters.
-template<class T, typename CallType, typename type0, typename type1, typename type2, typename type3, typename type4, template<typename, typename, int> class Evaluater = ExecutorEvaluater>
-class __EXECUTOR_FUNCTIONAL_NAME(5) : public Executor<CallType>
+template<class T, typename CallType, typename type0, typename type1, typename type2, typename type3, typename type4, template<typename, typename, int> class Evaluater = ExecutorEvaluater, class BaseClass = BaseObject>
+class __EXECUTOR_FUNCTIONAL_NAME(5) : public Executor<CallType, BaseClass>
 {
 private:
@@ -365 +391 @@
    */
   __EXECUTOR_FUNCTIONAL_NAME(5) (void (__EXECUTOR_FUNCTIONAL_FUNCTION_POINTER)(type0, type1, type2, type3, type4) __EXECUTOR_FUNCTIONAL_CONST)
-      : Executor<CallType>(false, ExecutorParamType<type0>(), ExecutorParamType<type1>(), ExecutorParamType<type2>(), ExecutorParamType<type3>(), ExecutorParamType<type4>())
+  : Executor<CallType, BaseClass>(false, ExecutorParamType<type0>(), ExecutorParamType<type1>(), ExecutorParamType<type2>(), ExecutorParamType<type3>(), ExecutorParamType<type4>(), __EXECUTOR_FUNCTIONAL_FUNCTIONTYPE)
   {
     this->functionPointer = functionPointer;
@@ -389 +415 @@
    * @returns a new Executor that's a copy of this one.
    */
-  virtual Executor<CallType>* clone() const
+  virtual Executor<CallType, BaseClass>* clone() const
   {
     return new __EXECUTOR_FUNCTIONAL_NAME(5)<T, CallType, type0, type1, type2, type3, type4>(this->functionPointer);
@@ -489 +515 @@
 #undef __EXECUTOR_FUNCTIONAL_FUNCTION_EXEC
 #undef __EXECUTOR_FUNCTIONAL_FUNCTION_POINTER
+#undef __EXECUTOR_FUNCTIONAL_FUNCTIONTYPE
 
 #ifdef EXECUTOR_FUNCTIONAL_USE_CONST

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

@@ -19 +19 @@
  * What must be defined is a XML-root to search the ParameterName under an  a Function to call.
  */
-template<class T> class ExecutorXML : public Executor<const TiXmlElement*>
+template<class T, class BaseClass = BaseObject> class ExecutorXML : public Executor<const TiXmlElement*>
 {
 public: