Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Changeset 5636 in orxonox.OLD for trunk/src/lib/shell/shell_command.h


Ignore:
Timestamp:
Nov 18, 2005, 6:55:18 PM (19 years ago)
Author:
bensch
Message:

orxonox/trunk: adapting ShellCommand to use Executor.
On the go

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/lib/shell/shell_command.h

    r5552 r5636  
    1313#include "substring.h"
    1414#include "functor_list.h"
    15 
     15#include "executor/executor.h"
    1616#include <stdarg.h>
    1717
    … …  
    3030 *
    3131 * MEANING:
    32  *  ShellCommandBase* someUniqueVarName =
     32 *  ShellCommand* someUniqueVarName =
    3333 *       ShellCommand<ClassName>::registerCommand("commandNameInShell", "ClassName", &ClassName::FunctionToCall);
    3434 *
    … …  
    3636 * $ ClassName [ObjectName] commandNameInShell [parameters]
    3737 */
     38//#define SHELL_COMMAND(command, class, function) \
     39//        ShellCommand* shell_command_##class##_##command = ShellCommand<class>::registerCommand(#command, #class, &class::function)
    3840#define SHELL_COMMAND(command, class, function) \
    39         ShellCommandBase* shell_command_##class##_##command = ShellCommand<class>::registerCommand(#command, #class, &class::function)
     41           ShellCommand* shell_command_##class##_##command = ShellCommand::registerCommand(#command, #class, new ExecutorObjective<class>(&class::function))
     42
    4043/**
    4144 * an easy to use Macro to create a Command
    … …  
    4548 *
    4649 * MEANING:
    47  *  ShellCommandBase* someUniqueVarName =
     50 *  ShellCommand* someUniqueVarName =
    4851 *       ShellCommand<ClassName>::registerCommand("commandNameInShell", "ClassName", &ClassName::FunctionToCall);
    4952 *
    … …  
    5255 */
    5356#define SHELL_COMMAND_STATIC(command, class, function) \
    54                          ShellCommandBase* shell_command_##class##_##command = ShellCommandStatic<class>::registerCommand(#command, #class, function)
     57           ShellCommand* shell_command_##class##_##command = ShellCommand::registerCommand(#command, #class, new ExecutorStatic<class>(function))
    5558
    5659
    … …  
    6467// BASE CLASS //
    6568////////////////
    66 class ShellCommandBase;
     69class ShellCommand;
    6770class ShellCommandAlias;
    6871
    … …  
    7073class ShellCommandClass : public BaseObject
    7174{
    72   friend class ShellCommandBase;
     75  friend class ShellCommand;
    7376
    7477  public:
    … …  
    9396    const char*                      className;                 //!< The Name of the Class. This should match the ClassName of the Commands Class.
    9497    long                             classID;                   //!< The classID of this Class
    95     tList<ShellCommandBase>*         commandList;               //!< A list of Commands from this Class
     98    tList<ShellCommand>*         commandList;               //!< A list of Commands from this Class
    9699    static tList<ShellCommandClass>* commandClassList;          //!< A list of Classes
    97100    static tList<ShellCommandAlias>* aliasList;                 //!< An Alias to A Command. (only for classes with one Instance)
    … …  
    100103
    101104//! a baseClass for all possible ShellCommands
    102 class ShellCommandBase : public BaseObject
     105class ShellCommand : public BaseObject
    103106{
    104107  friend class ShellCommandClass;
    … …  
    106109    static bool execute (const char* executionString);
    107110
    108     ShellCommandBase* describe(const char* description);
    109     ShellCommandBase* setAlias(const char* alias);
    110     ShellCommandBase* defaultValues(unsigned int count, ...);
     111    ShellCommand* describe(const char* description);
     112    ShellCommand* setAlias(const char* alias);
     113    ShellCommand* defaultValues(unsigned int count, ...);
    111114
    112     /** @returns the CommandList of the Shell */
     115    static ShellCommand* registerCommand(const char* commandName, const char* className, Executor* executor);
     116
    113117    static void unregisterCommand(const char* commandName, const char* className);
    114118
    … …  
    116120
    117121  protected:
    118     ShellCommandBase(const char* commandName, const char* className, unsigned int paramCount, ...);
    119     ~ShellCommandBase();
     122    ShellCommand(const char* commandName, const char* className, unsigned int paramCount, ...);
     123    ~ShellCommand();
    120124
    121125    /** @returns the Type of this Function (either static or objective) */
    … …  
    141145
    142146    const char*                      description;                          //!< A description for this commnand. (initially NULL). Assigned with (create)->describe("blablabla");
    143 };
     147    Executor*                        executor;
    144148
    145 ///////////////////////////////////////////////////
    146 ///////////////////////////////////////////////////
    147 
    148 /////////////////////////////////
    149 // MACRO DEFINITION EXTENSIONS //
    150 /////////////////////////////////
    151 //! where to chek for default BOOL values
    152 #define   l_BOOL_DEFGRAB(i)         this->defaultValue[i].getBool()
    153 //! where to chek for default INT values
    154 #define   l_INT_DEFGRAB(i)          this->defaultValue[i].getInt()
    155 //! where to chek for default UINT values
    156 #define   l_UINT_DEFGRAB(i)         (unsigned int)this->defaultValue[i].getInt()
    157 //! where to chek for default LONG values
    158 #define   l_LONG_DEFGRAB(i)         (long)this->defaultValue[i].getInt()
    159 //! where to chek for default FLOAT values
    160 #define   l_FLOAT_DEFGRAB(i)        this->defaultValue[i].getFloat()
    161 //! where to chek for default STRING values
    162 #define   l_STRING_DEFGRAB(i)       this->defaultValue[i].getString()
    163 
    164 //////////////////////////
    165 // COMMAND REGISTRATION //
    166 //////////////////////////
    167 // SHELLCOMMAND can be redefined as ShellCommand or ShellCommandStatic
    168 // SHELLCOMMANDEXECUTER can be redefined too.
    169 // SHELLCOMMANDINCLASS
    170 // SHELLCOMMANDTYPE
    171 //! registers a command without any parameters
    172 #define ShellCommandRegister0() \
    173   static SHELLCOMMAND<T>* registerCommand(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)()) \
    174   { \
    175     if (isRegistered(commandName, className, 0)== true) \
    176       return NULL; \
    177     return new SHELLCOMMAND<T>(commandName, className, function); \
    178   }
    179 
    180 //! registers a command with 1 parameter
    181 #define ShellCommandRegister1(t1) \
    182   static SHELLCOMMAND<T>* registerCommand(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE)) \
    183   { \
    184     if (isRegistered(commandName, className, 1, t1##_PARAM)== true) \
    185       return NULL; \
    186     return new SHELLCOMMAND<T>(commandName, className, function); \
    187   }
    188 
    189 //! registers a command with 2 parameters
    190 #define ShellCommandRegister2(t1,t2) \
    191   static SHELLCOMMAND<T>* registerCommand(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE, t2##_TYPE)) \
    192   { \
    193     if (isRegistered(commandName, className, 2, t1##_PARAM, t2##_PARAM)== true) \
    194       return NULL; \
    195     return new SHELLCOMMAND<T>(commandName, className, function); \
    196   }
    197 
    198 //! registers a command with 3 parameters
    199 #define ShellCommandRegister3(t1,t2,t3) \
    200   static SHELLCOMMAND<T>* registerCommand(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE)) \
    201   { \
    202     if (isRegistered(commandName, className, 3, t1##_PARAM, t2##_PARAM, t3##_PARAM)== true) \
    203       return NULL; \
    204     return new SHELLCOMMAND<T>(commandName, className, function); \
    205   }
    206 
    207 //! registers a command with 4 parameters
    208 #define ShellCommandRegister4(t1,t2,t3,t4) \
    209   static SHELLCOMMAND<T>* registerCommand(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE)) \
    210   { \
    211     if (isRegistered(commandName, className, 4, t1##_PARAM, t2##_PARAM, t3##_PARAM, t4##_PARAM)== true) \
    212       return NULL; \
    213     return new SHELLCOMMAND<T>(commandName, className, function); \
    214   }
    215 
    216 //! registers a command with 5 parameters
    217 #define ShellCommandRegister5(t1,t2,t3,t4,t5) \
    218   static SHELLCOMMAND<T>* registerCommand(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE, t5##_TYPE)) \
    219   { \
    220     if (isRegistered(commandName, className, 5, t1##_PARAM, t2##_PARAM, t3##_PARAM, t4##_PARAM, t5##_PARAM)== true) \
    221       return NULL; \
    222     return new ShellCommand<T>(commandName, className, function); \
    223   }
    224 
    225 ///////////////////////
    226 // FUNCTION POINTERS //
    227 ///////////////////////
    228 #define ShellCommandFunctionPoiter0() \
    229   void SHELLCOMMANDINCLASS(*functionPointer_0)();
    230 
    231 #define ShellCommandFunctionPoiter1(t1) \
    232   void SHELLCOMMANDINCLASS(*functionPointer_1_##t1)(t1##_TYPE);
    233 
    234 #define ShellCommandFunctionPoiter2(t1, t2) \
    235   void SHELLCOMMANDINCLASS(*functionPointer_2_##t1##_##t2)(t1##_TYPE, t2##_TYPE);
    236 
    237 
    238 #define ShellCommandFunctionPoiter3(t1, t2, t3) \
    239   void SHELLCOMMANDINCLASS(*functionPointer_3_##t1##_##t2##_##t3)(t1##_TYPE, t2##_TYPE, t3##_TYPE);
    240 
    241 #define ShellCommandFunctionPoiter4(t1, t2, t3, t4) \
    242   void SHELLCOMMANDINCLASS(*functionPointer_4_##t1##_##t2##_##t3##_##t4)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE);
    243 
    244 
    245 #define ShellCommandFunctionPoiter5(t1, t2, t3, t4, t5) \
    246   void SHELLCOMMANDINCLASS(*functionPointer_5_##t1##_##t2##_##t3##_##t4##_##t5)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE, t5##_TYPE); \
    247 
    248 
    249 //////////////////
    250 // CONSTRUCTORS //
    251 /////////////////
    252 //! creates a command that takes no parameters
    253 #define ShellCommandConstructor0() \
    254   SHELLCOMMAND(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)()) \
    255   : ShellCommandBase(commandName, className, 0) \
    256   { \
    257     this->functorType = SHELLCOMMANDTYPE; \
    258     this->fp.functionPointer_0 = function; \
    259   }
    260 
    261 //! creates a command that takes one parameter
    262 #define ShellCommandConstructor1(t1) \
    263   SHELLCOMMAND(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE)) \
    264   : ShellCommandBase(commandName, className, 1, t1##_PARAM) \
    265   { \
    266     this->functorType = SHELLCOMMANDTYPE; \
    267     this->fp.functionPointer_1_##t1 = function; \
    268   }
    269 
    270 //! creates a command that takes two parameters
    271 #define ShellCommandConstructor2(t1,t2) \
    272   SHELLCOMMAND(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE, t2##_TYPE)) \
    273   : ShellCommandBase(commandName, className, 2, t1##_PARAM, t2##_PARAM) \
    274   { \
    275     this->functorType = SHELLCOMMANDTYPE; \
    276     this->fp.functionPointer_2_##t1##_##t2 = function; \
    277   }
    278 
    279 //! creates a command that takes three parameter
    280 #define ShellCommandConstructor3(t1,t2,t3) \
    281   SHELLCOMMAND(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE)) \
    282   : ShellCommandBase(commandName, className, 3, t1##_PARAM, t2##_PARAM, t3##_PARAM) \
    283   { \
    284     this->functorType = SHELLCOMMANDTYPE; \
    285     this->fp.functionPointer_3_##t1##_##t2##_##t3 = function; \
    286   }
    287 
    288 //! creates a command that takes four parameter
    289 #define ShellCommandConstructor4(t1,t2,t3,t4) \
    290   SHELLCOMMAND(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE)) \
    291   : ShellCommandBase(commandName, className, 4, t1##_PARAM, t2##_PARAM, t3##_PARAM, t4##_PARAM) \
    292   { \
    293     this->functorType = SHELLCOMMANDTYPE; \
    294     this->fp.functionPointer_4_##t1##_##t2##_##t3##_##t4 = function; \
    295   }
    296 
    297 //! creates a command that takes five parameter
    298 #define ShellCommandConstructor5(t1,t2,t3,t4,t5) \
    299   SHELLCOMMAND(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE, t5##_TYPE)) \
    300   : ShellCommandBase(commandName, className, 5, t1##_PARAM, t2##_PARAM, t3##_PARAM, t4##_PARAM, t5##_PARAM) \
    301   { \
    302     this->functorType = SHELLCOMMANDTYPE; \
    303     this->fp.functionPointer_5_##t1##_##t2##_##t3##_##t4##_##t5 = function; \
    304   }
    305 
    306 ///////////////
    307 // EXECUTION //
    308 ///////////////
    309 //! execute-macro for functions with no parameters
    310 #define ShellCommandExecute0() \
    311   if (this->paramCount == 0) \
    312     SHELLCOMMANDEXECUTER(_0)()
    313 
    314 //! execute-macro for functions with one parameter
    315 #define ShellCommandExecute1(t1) \
    316    else if (this->paramCount == 1 && this->parameters[0] == t1##_PARAM) \
    317     SHELLCOMMANDEXECUTER(_1_##t1)(t1##_FUNC(parameters, t1##_DEFGRAB(0)))
    318 
    319 //! execute-macro for functions with two parameters
    320 #define ShellCommandExecute2(t1,t2) \
    321    else if (this->paramCount == 2 && this->parameters[0] == t1##_PARAM && this->parameters[1] == t2##_PARAM) \
    322     SHELLCOMMANDEXECUTER(_2_##t1##_##t2)(t1##_FUNC(sub.getString(0), t1##_DEFGRAB(0)), t2##_FUNC(sub.getString(1), t2##_DEFGRAB(1)))
    323 
    324 //! execute-macro for functions with three parameters
    325 #define ShellCommandExecute3(t1,t2,t3) \
    326    else if (this->paramCount == 3 && this->parameters[0] == t1##_PARAM && this->parameters[1] == t2##_PARAM && this->parameters[2] == t3##_PARAM) \
    327     SHELLCOMMANDEXECUTER(_3_##t1##_##t2##_##t3)(t1##_FUNC(sub.getString(0), t1##_DEFGRAB(0)), t2##_FUNC(sub.getString(1), t2##_DEFGRAB(1)), t3##_FUNC(sub.getString(2), t3##_DEFGRAB(2)))
    328 
    329 //! execute-macro for functions with four parameters
    330 #define ShellCommandExecute4(t1,t2,t3,t4) \
    331    else if (this->paramCount == 4 && this->parameters[0] == t1##_PARAM && this->parameters[1] == t2##_PARAM && this->parameters[2] == t3##_PARAM && this->parameters[3] == t4##_PARAM) \
    332     SHELLCOMMANDEXECUTER(_4_##t1##_##t2##_##t3##_##t4)(t1##_FUNC(sub.getString(0), t1##_DEFGRAB(0)), t2##_FUNC(sub.getString(1), t2##_DEFGRAB(1)), t3##_FUNC(sub.getString(2), t3##_DEFGRAB(2)), t4##_FUNC(sub.getString(3), t4##_DEFGRAB(3)))
    333 
    334 //! execute-macro for functions with five parameters
    335 #define ShellCommandExecute5(t1,t2,t3,t4,t5) \
    336    else if (this->paramCount == 5 && this->parameters[0] == t1##_PARAM && this->parameters[1] == t2##_PARAM && this->parameters[2] == t3##_PARAM && this->parameters[3] == t4##_PARAM && this->parameters[4] == t5##_PARAM) \
    337     SHELLCOMMANDEXECUTER(_5_##t1##_##t2##_##t3##_##t4##_##t5)(t1##_FUNC(sub.getString(0), t1##_DEFGRAB(0)), t2##_FUNC(sub.getString(1), t2##_DEFGRAB(1)), t3##_FUNC(sub.getString(2), t3##_DEFGRAB(2)), t4##_FUNC(sub.getString(3), t4##_DEFGRAB(3)), t5##_FUNC(sub.getString(4), t5##_DEFGRAB(4)))
    338 
    339 
    340 //! keeps information about a ShellCommand
    341 template<class T> class ShellCommand : public ShellCommandBase
    342 {
    343   public:
    344 #ifdef FUNCTOR_LIST
    345 #undef FUNCTOR_LIST
    346 #endif
    347 #ifdef SHELLCOMMAND
    348 #undef SHELLCOMMAND
    349 #endif
    350 #define SHELLCOMMAND                       ShellCommand
    351 #ifdef SHELLCOMMANDEXECUTER
    352 #undef SHELLCOMMANDEXECUTER
    353 #endif
    354 #define SHELLCOMMANDEXECUTER(nameExt)      (dynamic_cast<T*>(object)->*(fp.functionPointer##nameExt))
    355 #ifdef SHELLCOMMANDINCLASS
    356 #undef SHELLCOMMANDINCLASS
    357 #endif
    358 #define SHELLCOMMANDINCLASS(FUNCTION)      (T::FUNCTION)
    359 #ifdef SHELLCOMMANDTYPE
    360 #undef SHELLCOMMANDTYPE
    361 #endif
    362 #define SHELLCOMMANDTYPE                   ShellCommand_Objective
    363 //! FUNCTOR_LIST is the List of command-registerers
    364 #define FUNCTOR_LIST(x) ShellCommandRegister ## x
    365 #include "functor_list.h"
    366 #undef FUNCTOR_LIST
    367 
    368 
    369   private:
    370 //! FUNCTOR_LIST is the List of FunctionPointers
    371     union FunctionPointers {
    372 #define FUNCTOR_LIST(x) ShellCommandFunctionPoiter ## x
    373 #include "functor_list.h"
    374 #undef FUNCTOR_LIST
    375     } fp;
    376 
    377 //! FUNCTOR_LIST is the List of CommandConstructors
    378 #define FUNCTOR_LIST(x) ShellCommandConstructor ## x
    379 #include "functor_list.h"
    380 #undef FUNCTOR_LIST
    381 
    382     virtual void executeCommand (BaseObject* object, const char* parameters)
    383     {
    384       SubString sub(parameters, true);
    385 //! FUNCTOR_LIST is the List of Executive Functions
    386 #define FUNCTOR_LIST(x) ShellCommandExecute ## x
    387 #include "functor_list.h"
    388 #undef FUNCTOR_LIST
    389     }
    390 };
    391 
    392 //! keeps information about a ShellCommand, that points to a Static Function
    393 template<class T> class ShellCommandStatic : public ShellCommandBase
    394 {
    395   public:
    396 #ifdef FUNCTOR_LIST
    397 #undef FUNCTOR_LIST
    398 #endif
    399 #ifdef SHELLCOMMAND
    400 #undef SHELLCOMMAND
    401 #endif
    402 #define SHELLCOMMAND                      ShellCommandStatic
    403 #ifdef SHELLCOMMANDEXECUTER
    404 #undef SHELLCOMMANDEXECUTER
    405 #endif
    406 #define SHELLCOMMANDEXECUTER(nameExt)     fp.functionPointer##nameExt
    407 #ifdef SHELLCOMMANDINCLASS
    408 #undef SHELLCOMMANDINCLASS
    409 #endif
    410 #define SHELLCOMMANDINCLASS(FUNCTION)     (FUNCTION)
    411 #ifdef SHELLCOMMANDTYPE
    412 #undef SHELLCOMMANDTYPE
    413 #endif
    414 #define SHELLCOMMANDTYPE                   ShellCommand_Static
    415 
    416 //! FUNCTOR_LIST is the List of command-registerers
    417 #define FUNCTOR_LIST(x) ShellCommandRegister ## x
    418 #include "functor_list.h"
    419 #undef FUNCTOR_LIST
    420 
    421   private:
    422 //! FUNCTOR_LIST is the List of FunctionPointers
    423     union FunctionPointers {
    424 #define FUNCTOR_LIST(x) ShellCommandFunctionPoiter ## x
    425 #include "functor_list.h"
    426 #undef FUNCTOR_LIST
    427     } fp;
    428 
    429 //! FUNCTOR_LIST is the List of CommandConstructors
    430 #define FUNCTOR_LIST(x) ShellCommandConstructor ## x
    431 #include "functor_list.h"
    432 #undef FUNCTOR_LIST
    433 
    434     virtual void executeCommand (BaseObject* object, const char* parameters)
    435     {
    436   SubString sub(parameters, true);
    437 //! FUNCTOR_LIST is the List of Executive Functions
    438 #define FUNCTOR_LIST(x) ShellCommandExecute ## x
    439 #include "functor_list.h"
    440 #undef FUNCTOR_LIST
    441     }
    442149};
    443150
    … …  
    445152class ShellCommandAlias
    446153{
    447   friend class ShellCommandBase;
     154  friend class ShellCommand;
    448155  public:
    449156    /** @returns the Name of the Alias. */
    450157    const char* getName() const { return this->aliasName; };
    451158    /** @returns the Command, this Alias is asociated with */
    452     ShellCommandBase* getCommand() const { return this->command; };
     159    ShellCommand* getCommand() const { return this->command; };
    453160
    454161  private:
    455162    /** @param aliasName the name of the Alias @param command the Command, to associate this alias with */
    456     ShellCommandAlias(const char* aliasName, ShellCommandBase* command) { this->aliasName = aliasName; this->command = command; };
     163    ShellCommandAlias(const char* aliasName, ShellCommand* command) { this->aliasName = aliasName; this->command = command; };
    457164
    458165  private:
    459166    const char*         aliasName;       //!< the name of the Alias
    460     ShellCommandBase*   command;         //!< a pointer to the command, this alias executes.
     167    ShellCommand*   command;         //!< a pointer to the command, this alias executes.
    461168};
    462169
Note: See TracChangeset for help on using the changeset viewer.