Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Changeset 8271 in orxonox.OLD for trunk/src/lib/util/executor


Ignore:
Timestamp:
Jun 8, 2006, 4:50:50 PM (18 years ago)
Author:
bensch
Message:

merge

Location:
trunk/src/lib/util/executor
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/lib/util/executor/executor.h

    r8048 r8271  
    5353    // EXECUTE
    5454    /** executes a Command. @param objec the Object, @param count how many values, @param values the Values */
    55     virtual void operator()(BaseObject* object, unsigned int count, void* values) const = 0;
     55    virtual void operator()(BaseObject* object, int& count, void* values) const = 0;
    5656    /** executes a Command @param object the object to apply this to @param parameters the parameters the command takes */
    5757    virtual void operator()(BaseObject* object, const SubString& sub = SubString()) const = 0;

  • trunk/src/lib/util/executor/executor_functional.h

    r8048 r8271  
    123123
    124124  /** executes a Command. @param objec the Object, @param count how many values, @param values the Values */
    125   virtual void operator()(BaseObject* object, unsigned int count, void* values) const
     125  virtual void operator()(BaseObject* object, int& count, void* values) const
    126126  {
    127127    (__EXECUTOR_FUNCTIONAL_FUNCTION_EXEC)();
    … …  
    163163
    164164  /** executes a Command. @param objec the Object, @param count how many values, @param values the Values */
    165   virtual void operator()(BaseObject* object, unsigned int count, void* values) const
     165  virtual void operator()(BaseObject* object, int& count, void* values) const
    166166  {
    167167    const MultiType* mt = (const MultiType*)values;
    … …  
    227227
    228228  /** executes a Command. @param objec the Object, @param count how many values, @param values the Values */
    229   virtual void operator()(BaseObject* object, unsigned int count, void* values) const
     229  virtual void operator()(BaseObject* object, int& count, void* values) const
    230230  {
    231231    const MultiType* mt = (const MultiType*)values;
    … …  
    282282
    283283  /** executes a Command. @param objec the Object, @param count how many values, @param values the Values */
    284   virtual void operator()(BaseObject* object, unsigned int count, void* values) const
     284  virtual void operator()(BaseObject* object, int& count, void* values) const
    285285  {
    286286    const MultiType* mt = (const MultiType*)values;
    … …  
    340340
    341341  /** executes a Command. @param objec the Object, @param count how many values, @param values the Values */
    342   virtual void operator()(BaseObject* object, unsigned int count, void* values) const
     342  virtual void operator()(BaseObject* object, int& count, void* values) const
    343343  {
    344344    const MultiType* mt = (const MultiType*)values;
    … …  
    400400
    401401  /** executes a Command. @param objec the Object, @param count how many values, @param values the Values */
    402   virtual void operator()(BaseObject* object, unsigned int count, void* values) const
     402  virtual void operator()(BaseObject* object, int& count, void* values) const
    403403  {
    404404    const MultiType* mt = (const MultiType*)values;

  • trunk/src/lib/util/executor/executor_lua.cc

    r8057 r8271  
    1818#include "executor_lua.h"
    1919
    20 template<> bool fromLua<bool>(lua_state* state, int index) { return lua_toboolean(state, index); };
    21 template<> int fromLua<int>(lua_state* state, int index) { return (int)lua_toumber(state, index); };
    22 template<> unsigned int fromLua<unsigned int>(lua_state* state, int index) { return (unsigned int)lua_tonumber(state, index); };
    23 template<> float fromLua<float>(lua_state* state, int index) { return (float)lua_tonumber(state, index); };
    24 template<> char fromLua<char>(lua_state* state, int index) { reutnr (char)lua_tonumber(state, index); };
    25 template<> const std::string& fromLua<const std::string&>(lua_state* state, int index) { return lua_tostring(state, index); };
     20std::string temp;
     21
     22template<> bool fromLua<bool>(lua_State* state, int index) { return lua_toboolean(state, index); };
     23template<> int fromLua<int>(lua_State* state, int index) { return (int)lua_tonumber(state, index); };
     24template<> unsigned int fromLua<unsigned int>(lua_State* state, int index) { return (unsigned int)lua_tonumber(state, index); };
     25template<> float fromLua<float>(lua_State* state, int index) { return (float)lua_tonumber(state, index); };
     26template<> char fromLua<char>(lua_State* state, int index) { return (char)lua_tonumber(state, index); };
     27template<> const std::string& fromLua<const std::string&>(lua_State* state, int index) { temp = lua_tostring(state, index); return temp; };
    2628
    2729
    2830
    29 template<> void toLua<bool>(lua_state* state, bool value) { lua_pushboolean(state, (int) value); };
    30 template<> void toLua<int>(lua_state* state, int value)  { lua_pushnumber(state, (lua_Number) value); };
    31 template<> void toLua<unsigned int>(lua_state* state, unsigned int value){ lua_pushnumber(state, (lua_Number) value); };
    32 template<> void toLua<float>(lua_state* state, float value) { lua_pushnumber(state, (lua_Number) value); };
    33 template<> void toLua<char>(lua_state* state, char value) { lua_pushnumber(state, (lua_Number) value); };
    34 template<> void toLua<const std::string&>(lua_state* state, const std::string& value) {lua_pushstring (state, value.c_str()); }
     31template<> void toLua<bool>(lua_State* state, bool value) { lua_pushboolean(state, (int) value); };
     32template<> void toLua<int>(lua_State* state, int value)  { lua_pushnumber(state, (lua_Number) value); };
     33template<> void toLua<unsigned int>(lua_State* state, unsigned int value){ lua_pushnumber(state, (lua_Number) value); };
     34template<> void toLua<float>(lua_State* state, float value) { lua_pushnumber(state, (lua_Number) value); };
     35template<> void toLua<char>(lua_State* state, char value) { lua_pushnumber(state, (lua_Number) value); };
     36template<> void toLua<const std::string&>(lua_State* state, const std::string& value) {lua_pushstring (state, value.c_str()); }

  • trunk/src/lib/util/executor/executor_lua.h

    r8057 r8271  
    44 */
    55
    6 #ifndef _EXECUTOR_SPECIALS_H
    7 #define _EXECUTOR_SPECIALS_H
     6#ifndef _EXECUTOR_LUA_H
     7#define _EXECUTOR_LUA_H
    88
    99#include "executor.h"
    1010#include "compiler.h"
    11 
     11#include "debug.h"
    1212#include "luaincl.h"
    1313
    1414
    1515
    16 template<typename type> type fromLua(lua_state* state, int index) { PRINTF(1)("NOT IMPLEMENTED\n"); };
    17 template<> bool fromLua<bool>(lua_state* state, int index);
    18 template<> int fromLua<int>(lua_state* state, int index);
    19 template<> unsigned int fromLua<unsigned int>(lua_state* state, int index);
    20 template<> float fromLua<float>(lua_state* state, int index);
    21 template<> char fromLua<char>(lua_state* state, int index);
    22 template<> const std::string& fromLua<const std::string&>(lua_state* state, int index);
    23 
    24 
    25 template<typename type> void toLua(lua_state* state, type value) { PRINTF(1)("NOT IMPLEMENTED\n"); };
    26 template<> void toLua<bool>(lua_state* state, bool value);
    27 template<> void toLua<int>(lua_state* state, int value);
    28 template<> void toLua<unsigned int>(lua_state* state, unsigned int value);
    29 template<> void toLua<float>(lua_state* state, float value);
    30 template<> void toLua<char>(lua_state* state, char value);
    31 template<> void toLua<const std::string&>(lua_state* state, const std::string& value);
     16template<typename type> type fromLua(lua_State* state, int index) { PRINTF(1)("NOT IMPLEMENTED\n"); };
     17template<> bool fromLua<bool>(lua_State* state, int index);
     18template<> int fromLua<int>(lua_State* state, int index);
     19template<> unsigned int fromLua<unsigned int>(lua_State* state, int index);
     20template<> float fromLua<float>(lua_State* state, int index);
     21template<> char fromLua<char>(lua_State* state, int index);
     22template<> const std::string& fromLua<const std::string&>(lua_State* state, int index);
     23
     24
     25template<typename type> void toLua(lua_State* state, type value) { PRINTF(1)("NOT IMPLEMENTED\n"); };
     26template<> void toLua<bool>(lua_State* state, bool value);
     27template<> void toLua<int>(lua_State* state, int value);
     28template<> void toLua<unsigned int>(lua_State* state, unsigned int value);
     29template<> void toLua<float>(lua_State* state, float value);
     30template<> void toLua<char>(lua_State* state, char value);
     31template<> void toLua<const std::string&>(lua_State* state, const std::string& value);
    3232
    3333// FORWARD DECLARATION
    3434
     35///////////////////////
     36///// WITHOUT RET /////
     37///////////////////////
    3538
    3639///////////
    3740//// 0 ////
    3841///////////
    39 //! Executes a Function with a lua_state* parameter.
     42//! Executes a Function with a lua_State* parameter.
    4043template<class T> class ExecutorLua0 : public Executor
    4144{
    … …  
    6265    }
    6366
    64     virtual void operator()(BaseObject* object, unsigned int count, void* values) const
     67    virtual void operator()(BaseObject* object, int& count, void* values) const
    6568    {
    6669      (dynamic_cast<T*>(object)->*(functionPointer))();
     70      count = 0;
    6771    }
    6872
    … …  
    7276    virtual Executor* clone () const
    7377    {
    74       return = new ExecutorLua0<T>(ExecutorLua0<T>(this->functionPointer));
    75     }
     78      return new ExecutorLua0<T>(ExecutorLua0<T>(this->functionPointer));
     79    }
     80  private:
     81    void          (T::*functionPointer)();
    7682};
    7783
    … …  
    8187//// 1 ////
    8288///////////
    83 //! Executes a Function with a lua_state* parameter.
     89//! Executes a Function with a lua_State* parameter.
    8490template<class T, typename type0> class ExecutorLua1 : public Executor
    8591{
    … …  
    8995     * @param function a Function to call
    9096     */
    91     ExecutorLua0(void(T::*function)(type0))
     97    ExecutorLua1(void(T::*function)(type0))
    9298        : Executor(ExecutorParamType<type0>())
    9399    {
    … …  
    106112    }
    107113
    108     virtual void operator()(BaseObject* object, unsigned int count, void* values) const
    109     {
    110       lua_state* state = (lua_state*)values;
     114    virtual void operator()(BaseObject* object, int& count, void* values) const
     115    {
     116      lua_State* state = (lua_State*)values;
     117      count = 0;
    111118
    112119      (dynamic_cast<T*>(object)->*(functionPointer))(fromLua<type0>(state, 1));
    … …  
    118125    virtual Executor* clone () const
    119126    {
    120       return = new ExecutorLua0<T>(ExecutorLua0<T>(this->functionPointer));
    121     }
     127      return new ExecutorLua1<T, type0>((this->functionPointer));
     128    }
     129  private:
     130    void          (T::*functionPointer)(type0);
    122131};
    123132
    … …  
    127136//// 2 ////
    128137///////////
    129 //! Executes a Function with a lua_state* parameter.
    130 template<class T, typename type0, typename type1> class ExecutorLua1 : public Executor
    131 {
    132   public:
    133     /**
    134      * @brief Constructor of a ExecutorXML
    135      * @param function a Function to call
    136      */
    137     ExecutorLua0(void(T::*function)(type0, type1))
     138//! Executes a Function with a lua_State* parameter.
     139template<class T, typename type0, typename type1> class ExecutorLua2 : public Executor
     140{
     141  public:
     142    /**
     143     * @brief Constructor of a ExecutorXML
     144     * @param function a Function to call
     145     */
     146    ExecutorLua2(void(T::*function)(type0, type1))
    138147        : Executor(ExecutorParamType<type0>(), ExecutorParamType<type1>())
    139148    {
    … …  
    152161    }
    153162
    154     virtual void operator()(BaseObject* object, unsigned int count, void* values) const
    155     {
    156       lua_state* state = (lua_state*)values;
     163    virtual void operator()(BaseObject* object, int& count, void* values) const
     164    {
     165      lua_State* state = (lua_State*)values;
     166      count = 0;
    157167
    158168      (dynamic_cast<T*>(object)->*(functionPointer))(
    … …  
    166176    virtual Executor* clone () const
    167177    {
    168       return = new ExecutorLua0<T>(ExecutorLua0<T>(this->functionPointer));
    169     }
    170 };
    171 
    172 
    173 
    174 #endif /* _EXECUTOR_SPECIALS_H */
     178      return new ExecutorLua2<T, type0, type1>(this->functionPointer);
     179    }
     180  private:
     181    void          (T::*functionPointer)(type0, type1);
     182};
     183
     184
     185
     186
     187
     188
     189
     190////////////////////
     191///// WITH RET /////
     192////////////////////
     193
     194
     195///////////
     196//// 0 ////
     197///////////
     198//! Executes a Function with a lua_State* parameter.
     199template<class T, typename ret> class ExecutorLua0ret : public Executor
     200{
     201  public:
     202    /**
     203     * @brief Constructor of a ExecutorXML
     204     * @param function a Function to call
     205     */
     206    ExecutorLua0ret(ret (T::*function)())
     207        : Executor()
     208    {
     209      this->functionPointer = function;
     210      this->functorType = Executor_Objective | Executor_NoLoadString;
     211    }
     212
     213    /**
     214     * @brief executes the Command on BaseObject
     215     * @param object the BaseObject to execute this Executor on
     216     * @param loadString ignored in this case
     217     */
     218    virtual void operator()(BaseObject* object, const SubString& = SubString()) const
     219    {
     220      PRINTF(1)("no usefull executor\n");
     221    }
     222
     223    virtual void operator()(BaseObject* object, int& count, void* values) const
     224    {
     225      lua_State* state = (lua_State*)values;
     226      count = 1;
     227
     228      toLua<ret>(state, (dynamic_cast<T*>(object)->*(functionPointer))());
     229    }
     230
     231    /**
     232                       * @returns a _new_ Copy of this Executor
     233     */
     234    virtual Executor* clone () const
     235    {
     236      return new ExecutorLua0ret<T, ret>(this->functionPointer);
     237    }
     238  private:
     239    ret           (T::*functionPointer)();
     240};
     241
     242
     243
     244///////////
     245//// 1 ////
     246///////////
     247//! Executes a Function with a lua_State* parameter.
     248template<class T, typename ret, typename type0> class ExecutorLua1ret : public Executor
     249{
     250  public:
     251    /**
     252     * @brief Constructor of a ExecutorXML
     253     * @param function a Function to call
     254     */
     255    ExecutorLua1ret(ret (T::*function)(type0))
     256        : Executor(ExecutorParamType<type0>())
     257    {
     258      this->functionPointer = function;
     259      this->functorType = Executor_Objective | Executor_NoLoadString;
     260    }
     261
     262    /**
     263     * @brief executes the Command on BaseObject
     264     * @param object the BaseObject to execute this Executor on
     265     * @param loadString ignored in this case
     266     */
     267    virtual void operator()(BaseObject* object, const SubString& = SubString()) const
     268    {
     269      PRINTF(1)("no usefull executor\n");
     270    }
     271
     272    virtual void operator()(BaseObject* object, int& count, void* values) const
     273    {
     274      lua_State* state = (lua_State*)values;
     275      count = 1;
     276
     277      toLua<ret>(state, (dynamic_cast<T*>(object)->*(functionPointer))(
     278                   fromLua<type0>(state, 1)));
     279    }
     280
     281    /**
     282     * @returns a _new_ Copy of this Executor
     283     */
     284    virtual Executor* clone () const
     285    {
     286      return new ExecutorLua1ret<T, ret, type0>(this->functionPointer);
     287    }
     288  private:
     289    ret           (T::*functionPointer)(type0);
     290};
     291
     292///////////
     293//// 2 ////
     294///////////
     295//! Executes a Function with a lua_State* parameter.
     296template<class T, typename ret, typename type0, typename type1> class ExecutorLua2ret : public Executor
     297{
     298  public:
     299    /**
     300     * @brief Constructor of a ExecutorXML
     301     * @param function a Function to call
     302     */
     303    ExecutorLua2ret(ret (T::*function)(type0, type1))
     304        : Executor(ExecutorParamType<type0>(), ExecutorParamType<type1>())
     305    {
     306      this->functionPointer = function;
     307      this->functorType = Executor_Objective | Executor_NoLoadString;
     308    }
     309
     310    /**
     311     * @brief executes the Command on BaseObject
     312     * @param object the BaseObject to execute this Executor on
     313     * @param loadString ignored in this case
     314     */
     315    virtual void operator()(BaseObject* object, const SubString& = SubString()) const
     316    {
     317      PRINTF(1)("no usefull executor\n");
     318    }
     319
     320    virtual void operator()(BaseObject* object, int& count, void* values) const
     321    {
     322      lua_State* state = (lua_State*)values;
     323      count = 1;
     324
     325      toLua<ret>(state, (dynamic_cast<T*>(object)->*(functionPointer))(
     326                   fromLua<type0>(state, 1),
     327                   fromLua<type1>(state, 2) ));
     328    }
     329
     330    /**
     331     * @returns a _new_ Copy of this Executor
     332     */
     333    virtual Executor* clone () const
     334    {
     335      return new ExecutorLua2ret<T, ret, type0, type1>(this->functionPointer);
     336    }
     337  private:
     338    ret           (T::*functionPointer)(type0, type1);
     339};
     340
     341
     342
     343
     344
     345
     346
     347#endif /* _EXECUTOR_LUA_H */

  • trunk/src/lib/util/executor/executor_xml.h

    r8051 r8271  
    11/*!
    2  * @file executor.h
     2 * @file executor_xml.h
    33 * Definition of a on-screen-shell
    44 */
    55
    6 #ifndef _EXECUTOR_SPECIALS_H
    7 #define _EXECUTOR_SPECIALS_H
     6#ifndef _EXECUTOR_XML_H
     7#define _EXECUTOR_XML_H
    88
    99#include "executor.h"
    … …  
    6565    }
    6666
    67     virtual void operator()(BaseObject* object, unsigned int count, void* values) const
     67    virtual void operator()(BaseObject* object, int& count, void* values) const
    6868    {
    6969      PRINTF(1)("missuse of XML-operator, OR IMPLEMENT.\n");
    … …  
    8282};
    8383
    84 #endif /* _EXECUTOR_SPECIALS_H */
     84#endif /* _EXECUTOR_XML_H */
Note: See TracChangeset for help on using the changeset viewer.