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

/*!
 * @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<lua_State*>
{
public:
  /**
  * @brief Constructor of a ExecutorXML
  * @param function a Function to call
   */
  ExecutorLua0(void(T::*function)())
      : Executor<lua_State*>(false)
  {
    this->functionPointer = function;
    this->functionType = Executor<lua_State*>::FunctionDefault;
  }


  virtual void operator()(BaseObject* object, lua_State*& state) const
  {
    (dynamic_cast<T*>(object)->*(functionPointer))();
  }

  /**
   * @returns a _new_ Copy of this Executor
   */
  virtual Executor<lua_State*>* 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<lua_State*>
{
public:
  /**
  * @brief Constructor of a ExecutorXML
  * @param function a Function to call
   */
  ExecutorLua1(void(T::*function)(type0))
      : Executor<lua_State*>(false, ExecutorParamType<type0>())
  {
    this->functionPointer = function;
    this->functionType = Executor<lua_State*>::FunctionDefault;
  }

  virtual void operator()(BaseObject* object, lua_State*& state) const
  {
    (dynamic_cast<T*>(object)->*(functionPointer))(fromLua<type0>(state, 1));
  }

  /**
   * @returns a _new_ Copy of this Executor
   */
  virtual Executor<lua_State*>* 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<lua_State*>
{
public:
  /**
  * @brief Constructor of a ExecutorXML
  * @param function a Function to call
   */
  ExecutorLua2(void(T::*function)(type0, type1))
      : Executor<lua_State*>(false, ExecutorParamType<type0>(), ExecutorParamType<type1>())
  {
    this->functionPointer = function;
    this->functionType = Executor<lua_State*>::FunctionDefault;
  }

  virtual void operator()(BaseObject* object, lua_State*& state) const
  {
    (dynamic_cast<T*>(object)->*(functionPointer))(
      fromLua<type0>(state, 1),
      fromLua<type1>(state, 2) );
  }

  /**
   * @returns a _new_ Copy of this Executor
   */
  virtual Executor<lua_State*>* 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<lua_State*>
{
public:
  /**
  * @brief Constructor of a ExecutorXML
  * @param function a Function to call
   */
  ExecutorLua3(void(T::*function)(type0, type1, type2))
      : Executor<lua_State*>(false, ExecutorParamType<type0>(), ExecutorParamType<type1>(), ExecutorParamType<type2>())
  {
    this->functionPointer = function;
    this->functionType = Executor<lua_State*>::FunctionDefault;
  }


  virtual void operator()(BaseObject* object, lua_State*& state) const
  {
    (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<lua_State*>* 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<lua_State*>
{
public:
  /**
  * @brief Constructor of a ExecutorXML
  * @param function a Function to call
   */
  ExecutorLua4(void(T::*function)(type0, type1, type2, type3))
      : Executor<lua_State*>(false, ExecutorParamType<type0>(), ExecutorParamType<type1>(), ExecutorParamType<type2>(), ExecutorParamType<type3>())
  {
    this->functionPointer = function;
    this->functionType = Executor<lua_State*>::FunctionDefault;
  }

  virtual void operator()(BaseObject* object, lua_State*& state) const
  {
    (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<lua_State*>* 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<lua_State*>
{
public:
  /**
  * @brief Constructor of a ExecutorXML
  * @param function a Function to call
   */
  ExecutorLua0ret(ret (T::*function)())
      : Executor<lua_State*>(true)
  {
    this->functionPointer = function;
    this->functionType = Executor<lua_State*>::FunctionDefault;
  }

  virtual void operator()(BaseObject* object, lua_State*& state) const
  {
    toLua<ret>(state, (dynamic_cast<T*>(object)->*(functionPointer))());
  }

  /**
   * @returns a _new_ Copy of this Executor
   */
  virtual Executor<lua_State*>* 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<lua_State*>
{
public:
  /**
  * @brief Constructor of a ExecutorXML
  * @param function a Function to call
   */
  ExecutorLua1ret(ret (T::*function)(type0))
      : Executor<lua_State*>(true, ExecutorParamType<type0>())
  {
    this->functionPointer = function;
    this->functionType = Executor<lua_State*>::FunctionDefault;
  }

  virtual void operator()(BaseObject* object, lua_State*& state) const
  {
    toLua<ret>(state, (dynamic_cast<T*>(object)->*(functionPointer))(
                 fromLua<type0>(state, 1)));
  }

  /**
   * @returns a _new_ Copy of this Executor
   */
  virtual Executor<lua_State*>* 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<lua_State*>
{
public:
  /**
  * @brief Constructor of a ExecutorXML
  * @param function a Function to call
   */
  ExecutorLua2ret(ret (T::*function)(type0, type1))
      : Executor<lua_State*>(true, ExecutorParamType<type0>(), ExecutorParamType<type1>())
  {
    this->functionPointer = function;
    this->functionType = Executor<lua_State*>::FunctionDefault;
  }

  virtual void operator()(BaseObject* object, lua_State*& state) const
  {
    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<lua_State*>* 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<lua_State*>
{
public:
  /**
  * @brief Constructor of a ExecutorXML
  * @param function a Function to call
   */
  ExecutorLua3ret(ret (T::*function)(type0, type1, type2))
      : Executor<lua_State*>(true, ExecutorParamType<type0>(), ExecutorParamType<type1>(), ExecutorParamType<type2>())
  {
    this->functionPointer = function;
    this->functionType = Executor<lua_State*>::FunctionDefault;
  }

  virtual void operator()(BaseObject* object, lua_State*& state) const
  {
    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<lua_State*>* 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<lua_State*>
{
public:
  /**
  * @brief Constructor of a ExecutorXML
  * @param function a Function to call
   */
  ExecutorLua4ret(ret (T::*function)(type0, type1, type2, type3))
      : Executor<lua_State*>(true, ExecutorParamType<type0>(), ExecutorParamType<type1>(), ExecutorParamType<type2>(), ExecutorParamType<type3>())
  {
    this->functionPointer = function;
    this->functionType = Executor<lua_State*>::FunctionDefault;
  }

  virtual void operator()(BaseObject* object, lua_State*& state) const
  {
    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<lua_State*>* 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<lua_State*>
{
public:
  /**
  * @brief Constructor of a ExecutorXML
  * @param function a Function to call
   */
  ExecutorLua5ret(ret (T::*function)(type0, type1, type2, type3, type4))
      : Executor<lua_State*>(true, ExecutorParamType<type0>(), ExecutorParamType<type1>(), ExecutorParamType<type2>(), ExecutorParamType<type3>(), ExecutorParamType<type4>())
  {
    this->functionPointer = function;
    this->functionType = Executor<lua_State*>::FunctionDefault;
  }

  virtual void operator()(BaseObject* object, lua_State*& state) const
  {
    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<lua_State*>* 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<lua_State*>
{
public:
  /**
  * @brief Constructor of a ExecutorXML
  * @param function a Function to call
   */
  ExecutorLua6ret(ret (T::*function)(type0, type1, type2, type3, type4, type5))
      : Executor<lua_State*>(true, ExecutorParamType<type0>(), ExecutorParamType<type1>(),
                             ExecutorParamType<type2>(), ExecutorParamType<type3>(),
                             ExecutorParamType<type4>(), ExecutorParamType<type5>())
  {
    this->functionPointer = function;
    this->functionType = Executor<lua_State*>::FunctionDefault;
  }

  virtual void operator()(BaseObject* object, lua_State*& state) const
  {
    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<lua_State*>* 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<lua_State*>
{
public:
  /**
  * @brief Constructor of a ExecutorXML
  * @param function a Function to call
   */
  ExecutorLua7ret(ret (T::*function)(type0, type1, type2, type3, type4, type5, type6))
      : Executor<lua_State*>(true, ExecutorParamType<type0>(), ExecutorParamType<type1>(),
                             ExecutorParamType<type2>(), ExecutorParamType<type3>(),
                             ExecutorParamType<type4>(), ExecutorParamType<type5>(),
                             ExecutorParamType<type6>())
  {
    this->functionPointer = function;
    this->functionType = Executor<lua_State*>::FunctionDefault;
  }

  virtual void operator()(BaseObject* object, lua_State*& state) const
  {
    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<lua_State*>* 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 */