source: orxonox.OLD/trunk/src/lib/util/executor/executor_lua.h @ 8079

/*!
 * @file executor.h
 * Definition of a on-screen-shell
 */

#ifndef _EXECUTOR_SPECIALS_H
#define _EXECUTOR_SPECIALS_H

#include "executor.h"
#include "compiler.h"

#include "luaincl.h"



template<typename type> type fromLua(lua_state* state, int index) { PRINTF(1)("NOT IMPLEMENTED\n"); };
template<> bool fromLua<bool>(lua_state* state, int index);
template<> int fromLua<int>(lua_state* state, int index);
template<> unsigned int fromLua<unsigned int>(lua_state* state, int index);
template<> float fromLua<float>(lua_state* state, int index);
template<> char fromLua<char>(lua_state* state, int index);
template<> const std::string& fromLua<const std::string&>(lua_state* state, int index);


template<typename type> void toLua(lua_state* state, type value) { PRINTF(1)("NOT IMPLEMENTED\n"); };
template<> void toLua<bool>(lua_state* state, bool value);
template<> void toLua<int>(lua_state* state, int value);
template<> void toLua<unsigned int>(lua_state* state, unsigned int value);
template<> void toLua<float>(lua_state* state, float value);
template<> void toLua<char>(lua_state* state, char value);
template<> void toLua<const std::string&>(lua_state* state, const std::string& value);

// FORWARD DECLARATION


///////////
//// 0 ////
///////////
//! Executes a Function with a lua_state* parameter.
template<class T> class ExecutorLua0 : public Executor
{
  public:
    /**
     * @brief Constructor of a ExecutorXML
     * @param function a Function to call
     */
    ExecutorLua0(void(T::*function)())
        : Executor()
    {
      this->functionPointer = function;
      this->functorType = Executor_Objective | Executor_NoLoadString;
    }

    /**
     * @brief executes the Command on BaseObject
     * @param object the BaseObject to execute this Executor on
     * @param loadString ignored in this case
     */
    virtual void operator()(BaseObject* object, const SubString& = SubString()) const
    {
      PRINTF(1)("no usefull executor\n");
    }

    virtual void operator()(BaseObject* object, unsigned int count, void* values) const
    {
      (dynamic_cast<T*>(object)->*(functionPointer))();
    }

    /**
     * @returns a _new_ Copy of this Executor
     */
    virtual Executor* clone () const
    {
      return = new ExecutorLua0<T>(ExecutorLua0<T>(this->functionPointer));
    }
};



///////////
//// 1 ////
///////////
//! Executes a Function with a lua_state* parameter.
template<class T, typename type0> class ExecutorLua1 : public Executor
{
  public:
    /**
     * @brief Constructor of a ExecutorXML
     * @param function a Function to call
     */
    ExecutorLua0(void(T::*function)(type0))
        : Executor(ExecutorParamType<type0>())
    {
      this->functionPointer = function;
      this->functorType = Executor_Objective | Executor_NoLoadString;
    }

    /**
       * @brief executes the Command on BaseObject
       * @param object the BaseObject to execute this Executor on
       * @param loadString ignored in this case
     */
    virtual void operator()(BaseObject* object, const SubString& = SubString()) const
    {
      PRINTF(1)("no usefull executor\n");
    }

    virtual void operator()(BaseObject* object, unsigned int count, void* values) const
    {
      lua_state* state = (lua_state*)values;

      (dynamic_cast<T*>(object)->*(functionPointer))(fromLua<type0>(state, 1));
    }

    /**
       * @returns a _new_ Copy of this Executor
     */
    virtual Executor* clone () const
    {
      return = new ExecutorLua0<T>(ExecutorLua0<T>(this->functionPointer));
    }
};



///////////
//// 2 ////
///////////
//! Executes a Function with a lua_state* parameter.
template<class T, typename type0, typename type1> class ExecutorLua1 : public Executor
{
  public:
    /**
     * @brief Constructor of a ExecutorXML
     * @param function a Function to call
     */
    ExecutorLua0(void(T::*function)(type0, type1))
        : Executor(ExecutorParamType<type0>(), ExecutorParamType<type1>())
    {
      this->functionPointer = function;
      this->functorType = Executor_Objective | Executor_NoLoadString;
    }

    /**
     * @brief executes the Command on BaseObject
     * @param object the BaseObject to execute this Executor on
     * @param loadString ignored in this case
     */
    virtual void operator()(BaseObject* object, const SubString& = SubString()) const
    {
      PRINTF(1)("no usefull executor\n");
    }

    virtual void operator()(BaseObject* object, unsigned int count, void* values) const
    {
      lua_state* state = (lua_state*)values;

      (dynamic_cast<T*>(object)->*(functionPointer))(
        fromLua<type0>(state, 1),
        fromLua<type1>(state, 2) );
    }

    /**
     * @returns a _new_ Copy of this Executor
     */
    virtual Executor* clone () const
    {
      return = new ExecutorLua0<T>(ExecutorLua0<T>(this->functionPointer));
    }
};



#endif /* _EXECUTOR_SPECIALS_H */