source: orxonox.OLD/branches/new_class_id/src/lib/util/executor/executor.h @ 9732

/*!
 * @file executor.h
 * Definition of an Executor
 */

#ifndef _EXECUTOR_H
#define _EXECUTOR_H

#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
/** This is Hardcoded, for each Executor. */
#define EXECUTOR_MAX_ARGUMENTS                7



template<typename type> MT_Type ExecutorParamType() { return MT_EXT1; };
template<> MT_Type ExecutorParamType<bool>();
template<> MT_Type ExecutorParamType<int>();
template<> MT_Type ExecutorParamType<unsigned int>();
template<> MT_Type ExecutorParamType<float>();
template<> MT_Type ExecutorParamType<char>();
template<> MT_Type ExecutorParamType<const std::string&>();

////////////////
// BASE CLASS //
////////////////
//! a BaseClass for all possible Executors
/**
 * An Executor is an Object, that is able to call Objects of Any type (class)
 * and execute a function with given parameters on it.
 *
 * The Executor is able to handle:
 *  Objects of any Class (Templated)
 *  Default Values
 *  Functions with up to 5 parameters (more seems overhead, split up the function)
 *  Functions with many types (@see functor_list.h)
 */
class ExecutorBase
{
public:
  /** @param i the i'th defaultValue, @returns reference to the MultiType */
  inline MultiType& getDefaultValue(unsigned int i) { return defaultValue[i]; };

  // RETRIEVE INFORMATION
  /** @returns the Type of this Function (either static or objective) */
  inline Executor_Type getType() const { return this->functorType; };

  /** @returns the Count of Parameters this Executor takes */
  inline unsigned int getParamCount() const { return this->paramCount; };
  /** @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 */
  virtual void operator()(BaseObject* object, CallType& values) const = 0;

  /**
   * @brief set the default values of the executor
   * @param value0 the first default value
   * @param value1 the second default value
   * @param value2 the third default value
   * @param value3 the fourth default value
   * @param value4 the fifth default value
   * @returns itself
   * @note: THIS FUNCTION WILL BE REPLACED BY A CONFIGURATOR (most probably).
  */
  Executor* 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& value5 = MT_NULL,
                          const MultiType& value6 = MT_NULL)
  {
    this->ExecutorBase::defaultValues(value0, value1, value2, value3, value4, value5, value6);
    return this;
  }

protected:
  Executor(bool hasRetVal,
           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)
      : ExecutorBase(hasRetVal, param0, param1, param2, param3, param4, param5, param6)
{}}
;

#endif /* _EXECUTOR_H */