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

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

#ifndef _EXECUTOR_LUA_H
#define _EXECUTOR_LUA_H

#include "executor.h"
#include "compiler.h"
#include "debug.h"
#include "luaincl.h"



template<typename type> type fromLua(lua_State* state, int index);
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);
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

///////////////////////
///// WITHOUT RET /////
///////////////////////

///////////
//// 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, int& count, void* values) const
    {
      (dynamic_cast<T*>(object)->*(functionPointer))();
      count = 0;
    }

    /**
     * @returns a _new_ Copy of this Executor
     */
    virtual Executor* clone () const
    {
      return new ExecutorLua0<T>(ExecutorLua0<T>(this->functionPointer));
    }
  private:
    void          (T::*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
     */
    ExecutorLua1(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, int& count, void* values) const
    {
      lua_State* state = (lua_State*)values;
      count = 0;

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

    /**
     * @returns a _new_ Copy of this Executor
     */
    virtual Executor* clone () const
    {
      return new ExecutorLua1<T, type0>((this->functionPointer));
    }
  private:
    void          (T::*functionPointer)(type0);
};



///////////
//// 2 ////
///////////
//! Executes a Function with a lua_State* parameter.
template<class T, typename type0, typename type1> class ExecutorLua2 : public Executor
{
  public:
    /**
   * @brief Constructor of a ExecutorXML
   * @param function a Function to call
     */
    ExecutorLua2(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, int& count, void* values) const
    {
      lua_State* state = (lua_State*)values;
      count = 0;

      (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 ExecutorLua2<T, type0, type1>(this->functionPointer);
    }
  private:
    void          (T::*functionPointer)(type0, type1);
};


///////////
//// 3 ////
///////////
//! Executes a Function with a lua_State* parameter.
template<class T, typename type0, typename type1, typename type2> class ExecutorLua3 : public Executor
{
  public:
    /**
   * @brief Constructor of a ExecutorXML
   * @param function a Function to call
     */
    ExecutorLua3(void(T::*function)(type0, type1, type2))
  : Executor(ExecutorParamType<type0>(), ExecutorParamType<type1>(), ExecutorParamType<type2>())
    {
      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, int& count, void* values) const
    {
      lua_State* state = (lua_State*)values;
      count = 0;

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

    /**
     * @returns a _new_ Copy of this Executor
     */
    virtual Executor* clone () const
    {
      return new ExecutorLua3<T, type0, type1, type2>(this->functionPointer);
    }
  private:
    void          (T::*functionPointer)(type0, type1, type2);
};


///////////
//// 4 ////
///////////
//! Executes a Function with a lua_State* parameter.
template<class T, typename type0, typename type1, typename type2, typename type3> class ExecutorLua4 : public Executor
{
  public:
    /**
   * @brief Constructor of a ExecutorXML
   * @param function a Function to call
     */
    ExecutorLua4(void(T::*function)(type0, type1, type2, type3))
  : Executor(ExecutorParamType<type0>(), ExecutorParamType<type1>(), ExecutorParamType<type2>(), ExecutorParamType<type3>())
    {
      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, int& count, void* values) const
    {
      lua_State* state = (lua_State*)values;
      count = 0;

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

    /**
     * @returns a _new_ Copy of this Executor
     */
    virtual Executor* clone () const
    {
      return new ExecutorLua4<T, type0, type1, type2, type3>(this->functionPointer);
    }
  private:
    void          (T::*functionPointer)(type0, type1, type2, type3);
};




////////////////////
///// WITH RET /////
////////////////////


///////////
//// 0 ////
///////////
//! Executes a Function with a lua_State* parameter.
template<class T, typename ret> class ExecutorLua0ret : public Executor
{
  public:
    /**
   * @brief Constructor of a ExecutorXML
   * @param function a Function to call
     */
    ExecutorLua0ret(ret (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, int& count, void* values) const
    {
      lua_State* state = (lua_State*)values;
      count = 1;

      toLua<ret>(state, (dynamic_cast<T*>(object)->*(functionPointer))());
    }

    /**
     * @returns a _new_ Copy of this Executor
     */
    virtual Executor* clone () const
    {
      return new ExecutorLua0ret<T, ret>(this->functionPointer);
    }
  private:
    ret           (T::*functionPointer)();
};



///////////
//// 1 ////
///////////
//! Executes a Function with a lua_State* parameter.
template<class T, typename ret, typename type0> class ExecutorLua1ret : public Executor
{
  public:
    /**
   * @brief Constructor of a ExecutorXML
   * @param function a Function to call
     */
    ExecutorLua1ret(ret (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, int& count, void* values) const
    {
      lua_State* state = (lua_State*)values;
      count = 1;

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

    /**
     * @returns a _new_ Copy of this Executor
     */
    virtual Executor* clone () const
    {
      return new ExecutorLua1ret<T, ret, type0>(this->functionPointer);
    }
  private:
    ret           (T::*functionPointer)(type0);
};

///////////
//// 2 ////
///////////
//! Executes a Function with a lua_State* parameter.
template<class T, typename ret, typename type0, typename type1> class ExecutorLua2ret : public Executor
{
  public:
    /**
   * @brief Constructor of a ExecutorXML
   * @param function a Function to call
     */
    ExecutorLua2ret(ret (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, int& count, void* values) const
    {
      lua_State* state = (lua_State*)values;
      count = 1;

      toLua<ret>(state, (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 ExecutorLua2ret<T, ret, type0, type1>(this->functionPointer);
    }
  private:
    ret           (T::*functionPointer)(type0, type1);
};


///////////
//// 3 ////
///////////
//! Executes a Function with a lua_State* parameter.
template<class T, typename ret, typename type0, typename type1, typename type2> class ExecutorLua3ret : public Executor
{
  public:
    /**
   * @brief Constructor of a ExecutorXML
   * @param function a Function to call
     */
    ExecutorLua3ret(ret (T::*function)(type0, type1, type2))
  : Executor(ExecutorParamType<type0>(), ExecutorParamType<type1>(), ExecutorParamType<type2>())
    {
      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, int& count, void* values) const
    {
      lua_State* state = (lua_State*)values;
      count = 1;

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

    /**
     * @returns a _new_ Copy of this Executor
     */
    virtual Executor* clone () const
    {
      return new ExecutorLua3ret<T, ret, type0, type1, type2>(this->functionPointer);
    }
  private:
    ret          (T::*functionPointer)(type0, type1, type2);
};


///////////
//// 4 ////
///////////
//! Executes a Function with a lua_State* parameter.
template<class T, typename ret, typename type0, typename type1, typename type2, typename type3> class ExecutorLua4ret : public Executor
{
  public:
    /**
   * @brief Constructor of a ExecutorXML
   * @param function a Function to call
     */
    ExecutorLua4ret(ret (T::*function)(type0, type1, type2, type3))
  : Executor(ExecutorParamType<type0>(), ExecutorParamType<type1>(), ExecutorParamType<type2>(), ExecutorParamType<type3>())
    {
      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, int& count, void* values) const
    {
      lua_State* state = (lua_State*)values;
      count = 1;

      toLua<ret>(state, (dynamic_cast<T*>(object)->*(functionPointer))(
          fromLua<type0>(state, 1),
          fromLua<type1>(state, 2),
          fromLua<type2>(state, 3),
          fromLua<type3>(state, 4) ));
    }

    /**
     * @returns a _new_ Copy of this Executor
     */
    virtual Executor* clone () const
    {
      return new ExecutorLua4ret<T, ret, type0, type1, type2, type3>(this->functionPointer);
    }
  private:
    ret          (T::*functionPointer)(type0, type1, type2, type3);
};

///////////
//// 5 ////
///////////
//! Executes a Function with a lua_State* parameter.
template<class T, typename ret, typename type0, typename type1, typename type2, typename type3, typename type4> class ExecutorLua5ret : public Executor
{
  public:
    /**
   * @brief Constructor of a ExecutorXML
   * @param function a Function to call
     */
    ExecutorLua5ret(ret (T::*function)(type0, type1, type2, type3, type4))
  : Executor(ExecutorParamType<type0>(), ExecutorParamType<type1>(), ExecutorParamType<type2>(), ExecutorParamType<type3>(), ExecutorParamType<type4>())
    {
      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, int& count, void* values) const
    {
      lua_State* state = (lua_State*)values;
      count = 1;

      toLua<ret>(state, (dynamic_cast<T*>(object)->*(functionPointer))(
          fromLua<type0>(state, 1),
          fromLua<type1>(state, 2),
          fromLua<type2>(state, 3),
          fromLua<type3>(state, 4),
          fromLua<type4>(state, 5) ));
    }

    /**
     * @returns a _new_ Copy of this Executor
     */
    virtual Executor* clone () const
    {
      return new ExecutorLua5ret<T, ret, type0, type1, type2, type3, type4>(this->functionPointer);
    }
  private:
    ret          (T::*functionPointer)(type0, type1, type2, type3, type4);
};

///////////
//// 6 ////
///////////
//! Executes a Function with a lua_State* parameter.
template<class T, typename ret, typename type0, typename type1, typename type2, typename type3, typename type4, typename type5> class ExecutorLua6ret : public Executor
{
  public:
    /**
   * @brief Constructor of a ExecutorXML
   * @param function a Function to call
     */
    ExecutorLua6ret(ret (T::*function)(type0, type1, type2, type3, type4, type5))
  : Executor(ExecutorParamType<type0>(), ExecutorParamType<type1>(),
             ExecutorParamType<type2>(), ExecutorParamType<type3>(),
             ExecutorParamType<type4>(), ExecutorParamType<type5>())
             {
               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, int& count, void* values) const
             {
               lua_State* state = (lua_State*)values;
               count = 1;

               toLua<ret>(state, (dynamic_cast<T*>(object)->*(functionPointer))(
                   fromLua<type0>(state, 1),
                   fromLua<type1>(state, 2),
                   fromLua<type2>(state, 3),
                   fromLua<type3>(state, 4),
                   fromLua<type4>(state, 5),
                   fromLua<type5>(state, 6) ));
             }

    /**
              * @returns a _new_ Copy of this Executor
     */
             virtual Executor* clone () const
             {
               return new ExecutorLua6ret<T, ret, type0, type1, type2, type3, type4, type5>(this->functionPointer);
             }
  private:
    ret           (T::*functionPointer)(type0, type1, type2, type3, type4, type5);
};

///////////
//// 7 ////
///////////
//! Executes a Function with a lua_State* parameter.
template<class T, typename ret, typename type0, typename type1, typename type2, typename type3, typename type4, typename type5, typename type6> class ExecutorLua7ret : public Executor
{
  public:
    /**
   * @brief Constructor of a ExecutorXML
   * @param function a Function to call
     */
    ExecutorLua7ret(ret (T::*function)(type0, type1, type2, type3, type4, type5, type6))
  : Executor(ExecutorParamType<type0>(), ExecutorParamType<type1>(),
             ExecutorParamType<type2>(), ExecutorParamType<type3>(),
             ExecutorParamType<type4>(), ExecutorParamType<type5>(),
             ExecutorParamType<type6>())
             {
               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, int& count, void* values) const
             {
               lua_State* state = (lua_State*)values;
               count = 1;

               toLua<ret>(state, (dynamic_cast<T*>(object)->*(functionPointer))(
                   fromLua<type0>(state, 1),
                   fromLua<type1>(state, 2),
                   fromLua<type2>(state, 3),
                   fromLua<type3>(state, 4),
                   fromLua<type4>(state, 5),
                   fromLua<type5>(state, 6),
                   fromLua<type6>(state, 7) ));
             }

    /**
              * @returns a _new_ Copy of this Executor
     */
             virtual Executor* clone () const
             {
               return new ExecutorLua7ret<T, ret, type0, type1, type2, type3, type4, type5, type6>(this->functionPointer);
             }
  private:
    ret           (T::*functionPointer)(type0, type1, type2, type3, type4, type5, type6);
};


#endif /* _EXECUTOR_LUA_H */