Changeset 5632 in orxonox.OLD for trunk/src/lib/util
- Timestamp:
- Nov 18, 2005, 4:58:01 PM (19 years ago)
- Location:
- trunk/src/lib/util/executor
- Files:
-
- 1 added
- 2 copied
Legend:
- Unmodified
- Added
- Removed
-
trunk/src/lib/util/executor/executor.cc
r5628 r5632 16 16 //#define DEBUG_SPECIAL_MODULE DEBUG_MODULE_ 17 17 18 #include " shell_command.h"18 #include "executor.h" 19 19 20 20 #include "list.h" … … 29 29 using namespace std; 30 30 31 /**32 * creates a new ShellCommandClass33 * @param className the Name of the command-class to create34 */35 ShellCommandClass::ShellCommandClass(const char* className)36 {37 this->setClassID(CL_SHELL_COMMAND_CLASS, "ShellCommandClass");38 this->setName(className);39 40 this->className = className;41 this->classID = CL_NULL;42 this->commandList = new tList<ShellCommandBase>;43 44 ShellCommandClass::commandClassList->add(this);45 }46 47 /**48 * destructs the shellCommandClass again49 */50 ShellCommandClass::~ShellCommandClass()51 {52 tIterator<ShellCommandBase>* iterator = this->commandList->getIterator();53 ShellCommandBase* elem = iterator->firstElement();54 while(elem != NULL)55 {56 delete elem;57 elem = iterator->nextElement();58 }59 delete iterator;60 delete this->commandList;61 }62 63 /**64 * collects the Commands registered to some class.65 * @param className the name of the Class to collect the Commands from.66 * @param stringList a List to paste the Commands into.67 * @returns true on success, false otherwise68 */69 bool ShellCommandClass::getCommandListOfClass(const char* className, tList<const char>* stringList)70 {71 if (stringList == NULL || className == NULL)72 return false;73 74 tIterator<ShellCommandClass>* iterator = ShellCommandClass::commandClassList->getIterator();75 ShellCommandClass* elem = iterator->firstElement();76 while(elem != NULL)77 {78 if (!strcmp (elem->getName(), className))79 {80 tIterator<ShellCommandBase>* itFkt = elem->commandList->getIterator();81 ShellCommandBase* command = itFkt->firstElement();82 while (command != NULL)83 {84 stringList->add(command->getName());85 command = itFkt->nextElement();86 }87 delete itFkt;88 }89 90 elem = iterator->nextElement();91 }92 delete iterator;93 return true;94 }95 96 /**97 * collects the Aliases registered to the ShellCommands98 * @param stringList a List to paste the Aliases into.99 * @returns true on success, false otherwise100 */101 bool ShellCommandClass::getCommandListOfAlias(tList<const char>* stringList)102 {103 if (stringList == NULL || ShellCommandClass::aliasList == NULL)104 return false;105 106 tIterator<ShellCommandAlias>* iterator = ShellCommandClass::aliasList->getIterator();107 ShellCommandAlias* elem = iterator->firstElement();108 while(elem != NULL)109 {110 stringList->add(elem->getName());111 elem = iterator->nextElement();112 }113 delete iterator;114 return true;115 }116 117 /**118 * unregisters all Commands that exist119 */120 void ShellCommandClass::unregisterAllCommands()121 {122 // unregister all commands123 tIterator<ShellCommandClass>* iterator = ShellCommandClass::commandClassList->getIterator();124 ShellCommandClass* elem = iterator->firstElement();125 while(elem != NULL)126 {127 delete elem;128 129 elem = iterator->nextElement();130 }131 delete iterator;132 133 delete ShellCommandClass::commandClassList;134 ShellCommandClass::commandClassList = NULL;135 136 // unregister all aliases (there should be nothing to do here :))137 if (ShellCommandClass::aliasList != NULL)138 {139 tIterator<ShellCommandAlias>* itAL = ShellCommandClass::aliasList->getIterator();140 ShellCommandAlias* elemAL = itAL->firstElement();141 while(elemAL != NULL)142 {143 delete elemAL;144 elemAL = itAL->nextElement();145 }146 delete itAL;147 delete ShellCommandClass::aliasList;148 ShellCommandClass::aliasList = NULL;149 }150 }151 152 /**153 * checks if a Class is already registered to the Commands' class-stack154 * @param className the Name of the Class to check for155 * @returns the CommandClass if found, NULL otherwise156 */157 const ShellCommandClass* ShellCommandClass::isRegistered(const char* className)158 {159 if (ShellCommandClass::commandClassList == NULL)160 initCommandClassList();161 162 tIterator<ShellCommandClass>* iterator = ShellCommandClass::commandClassList->getIterator();163 ShellCommandClass* elem = iterator->firstElement();164 while(elem != NULL)165 {166 if (!strcmp(className, elem->className))167 {168 if (elem->classID == CL_NULL)169 elem->classID = ClassList::StringToID(className);170 171 delete iterator;172 return elem;173 }174 elem = iterator->nextElement();175 }176 delete iterator;177 return NULL;178 }179 180 /**181 * searches for a CommandClass182 * @param className the name of the CommandClass183 * @returns the CommandClass if found, or a new CommandClass if not184 */185 ShellCommandClass* ShellCommandClass::getCommandClass(const char* className)186 {187 if (ShellCommandClass::commandClassList == NULL)188 initCommandClassList();189 190 tIterator<ShellCommandClass>* iterator = ShellCommandClass::commandClassList->getIterator();191 ShellCommandClass* elem = iterator->firstElement();192 while(elem != NULL)193 {194 if (!strcmp(className, elem->className))195 {196 delete iterator;197 return elem;198 }199 elem = iterator->nextElement();200 }201 delete iterator;202 return new ShellCommandClass(className);203 }204 205 /**206 * initializes the CommandList (if it is NULL)207 */208 void ShellCommandClass::initCommandClassList()209 {210 if (ShellCommandClass::commandClassList == NULL)211 {212 ShellCommandClass::commandClassList = new tList<ShellCommandClass>;213 ShellCommandStatic<ShellCommandBase>::registerCommand("debug", "ShellCommand", ShellCommandBase::debug);214 }215 }216 217 void ShellCommandClass::help(const char* className)218 {219 if (className == NULL)220 return;221 if (likely(ShellCommandClass::commandClassList != NULL))222 {223 tIterator<ShellCommandClass>* itCL = ShellCommandClass::commandClassList->getIterator();224 ShellCommandClass* elemCL = itCL->firstElement();225 while(elemCL != NULL)226 {227 if (elemCL->className && !strcasecmp(className, elemCL->className))228 {229 PRINT(0)("Class:'%s' registered %d commands: \n", elemCL->className, elemCL->commandList->getSize());230 tIterator<ShellCommandBase>* iterator = elemCL->commandList->getIterator();231 const ShellCommandBase* elem = iterator->firstElement();232 while(elem != NULL)233 {234 PRINT(0)(" command:'%s' : params:%d: ", elem->getName(), elem->paramCount);235 for (unsigned int i = 0; i< elem->paramCount; i++)236 PRINT(0)("%s ", ShellCommandBase::paramToString(elem->parameters[i]));237 if (elem->description != NULL)238 PRINT(0)("- %s", elem->description);239 PRINT(0)("\n");240 elem = iterator->nextElement();241 }242 delete iterator;243 244 delete itCL;245 return;246 }247 elemCL = itCL->nextElement();248 }249 delete itCL;250 PRINTF(3)("Class %s not found in Command's classes\n", className);251 }252 else253 {254 PRINTF(1)("List of commandClasses does not exist");255 }256 }257 258 tList<ShellCommandClass>* ShellCommandClass::commandClassList = NULL;259 tList<ShellCommandAlias>* ShellCommandClass::aliasList = NULL;260 261 262 263 264 265 266 267 268 269 270 31 //////////////////////// 271 32 // SHELL COMMAND BASE // … … 277 38 * @param paramCount the count of parameters this command takes 278 39 */ 279 ShellCommandBase::ShellCommandBase(const char* commandName, const char* className, unsigned int paramCount, ...)40 Executor::Executor(const char* commandName, const char* className, unsigned int paramCount, ...) 280 41 { 281 this->setClassID(CL_ SHELL_COMMAND, "ShellCommand");42 this->setClassID(CL_EXECUTOR, "Executor"); 282 43 this->setName(commandName); 283 this->description = NULL;284 this->alias = NULL;285 44 286 45 // this->classID = classID; 287 this->shellClass = ShellCommandClass::getCommandClass(className); //ClassList::IDToString(classID);288 if (this->shellClass != NULL)289 this->shellClass->commandList->add(this);290 46 // handling parameters, and storing them: 291 47 if (paramCount > FUNCTOR_MAX_ARGUMENTS) … … 304 60 305 61 /** 306 * deconstructs a ShellCommand62 * deconstructs a Executor 307 63 */ 308 ShellCommandBase::~ShellCommandBase()64 Executor::~Executor() 309 65 { 310 66 delete[] this->parameters; 311 67 delete[] this->defaultValue; 312 if (this->alias != NULL && ShellCommandClass::aliasList != NULL)313 {314 ShellCommandClass::aliasList->remove(this->alias);315 delete this->alias;316 }317 }318 319 /**320 * unregister an existing commandName321 * @param className the name of the Class the command belongs to.322 * @param commandName the name of the command itself323 */324 void ShellCommandBase::unregisterCommand(const char* commandName, const char* className)325 {326 if (ShellCommandClass::commandClassList == NULL)327 ShellCommandClass::initCommandClassList();328 329 const ShellCommandClass* checkClass = ShellCommandClass::isRegistered(className);330 331 if (checkClass != NULL)332 {333 tIterator<ShellCommandBase>* iterator = checkClass->commandList->getIterator();334 ShellCommandBase* elem = iterator->firstElement();335 while(elem != NULL)336 {337 if (!strcmp(commandName, elem->getName()))338 {339 checkClass->commandList->remove(elem);340 delete elem;341 break;342 }343 elem = iterator->nextElement();344 }345 delete iterator;346 347 if (checkClass->commandList->getSize() == 0)348 {349 ShellCommandClass::commandClassList->remove(checkClass);350 delete checkClass;351 }352 }353 }354 355 /**356 * checks if a command has already been registered.357 * @param commandName the name of the Command358 * @param className the name of the Class the command should apply to.359 * @param paramCount how many arguments the Command takes360 * @returns true, if the command is registered/false otherwise361 *362 * This is used internally, to see, if we have multiple command subscriptions.363 * This is checked in the registerCommand-function.364 */365 bool ShellCommandBase::isRegistered(const char* commandName, const char* className, unsigned int paramCount, ...)366 {367 if (ShellCommandClass::commandClassList == NULL)368 {369 ShellCommandClass::initCommandClassList();370 return false;371 }372 373 const ShellCommandClass* checkClass = ShellCommandClass::isRegistered(className);374 if (checkClass != NULL)375 {376 tIterator<ShellCommandBase>* iterator = checkClass->commandList->getIterator();377 ShellCommandBase* elem = iterator->firstElement();378 while(elem != NULL)379 {380 if (!strcmp(commandName, elem->getName()))381 {382 PRINTF(2)("Command already registered\n");383 delete iterator;384 return true;385 }386 elem = iterator->nextElement();387 }388 delete iterator;389 return false;390 }391 else392 return false;393 }394 395 396 /**397 * executes commands398 * @param executionString the string containing the following input399 * ClassName [ObjectName] functionName [parameter1[,parameter2[,...]]]400 * @return true on success, false otherwise.401 */402 bool ShellCommandBase::execute(const char* executionString)403 {404 if (ShellCommandClass::commandClassList == NULL)405 return false;406 407 long classID = CL_NULL; //< the classID retrieved from the Class.408 ShellCommandClass* commandClass = NULL; //< the command class this command applies to.409 tList<BaseObject>* objectList = NULL; //< the list of Objects stored in classID410 BaseObject* objectPointer = NULL; //< a pointer to th Object to Execute the command on411 bool emptyComplete = false; //< if the completion input is empty string. e.g ""412 unsigned int fktPos = 1; //< the position of the function (needed for finding it)413 // long completeType = SHELLC_NONE; //< the Type we'd like to complete.414 SubString inputSplits(executionString, true);415 416 if (inputSplits.getCount() == 0)417 return false;418 if (inputSplits.getCount() >= 1)419 {420 // CHECK FOR ALIAS421 if (ShellCommandClass::aliasList != NULL)422 {423 tIterator<ShellCommandAlias>* itAL = ShellCommandClass::aliasList->getIterator();424 ShellCommandAlias* elemAL = itAL->firstElement();425 while(elemAL != NULL)426 {427 if (elemAL->getName() != NULL && !strcmp(elemAL->getName(), inputSplits.getString(0)) && elemAL->getCommand() != NULL &&428 elemAL->getCommand()->shellClass != NULL )429 {430 objectList = ClassList::getList(elemAL->getCommand()->shellClass->getName());431 if (objectList != NULL)432 {433 if (inputSplits.getCount() > 1)434 elemAL->getCommand()->executeCommand(objectList->firstElement(), executionString+inputSplits.getOffset(1));435 else436 elemAL->getCommand()->executeCommand(objectList->firstElement(), "");437 delete itAL;438 return true;439 }440 }441 elemAL = itAL->nextElement();442 }443 delete itAL;444 }445 // looking for a Matching Class446 if (likely(ShellCommandClass::commandClassList != NULL))447 {448 tIterator<ShellCommandClass>* itCL = ShellCommandClass::commandClassList->getIterator();449 ShellCommandClass* elemCL = itCL->firstElement();450 while(elemCL != NULL)451 {452 if (elemCL->getName() && !strcasecmp(inputSplits.getString(0), elemCL->getName()))453 {454 //elemCL->getName();455 classID = ClassList::StringToID(elemCL->getName());456 commandClass = elemCL;457 objectList = ClassList::getList(classID);458 break;459 }460 elemCL = itCL->nextElement();461 }462 delete itCL;463 }464 465 if (commandClass != NULL && inputSplits.getCount() >= 2)466 {467 if (objectList != NULL)468 {469 // Checking for a Match in the Objects of classID (else take the first)470 tIterator<BaseObject>* itBO = objectList->getIterator();471 BaseObject* enumBO = itBO->firstElement();472 while(enumBO)473 {474 if (enumBO->getName() != NULL && !strcasecmp(enumBO->getName(), inputSplits.getString(1)))475 {476 objectPointer = enumBO;477 fktPos = 2;478 break;479 }480 enumBO = itBO->nextElement();481 }482 delete itBO;483 484 //485 if (objectPointer == NULL)486 objectPointer = objectList->firstElement();487 }488 // match a function.489 if (commandClass != NULL && (fktPos == 1 || (fktPos == 2 && inputSplits.getCount() >= 3)))490 {491 tIterator<ShellCommandBase>* itCMD = commandClass->commandList->getIterator();492 ShellCommandBase* enumCMD = itCMD->firstElement();493 while (enumCMD != NULL)494 {495 if (!strcmp(enumCMD->getName(), inputSplits.getString(fktPos)))496 {497 if (objectPointer == NULL && enumCMD->functorType == ShellCommand_Objective)498 {499 delete itCMD;500 return false;501 }502 if (inputSplits.getCount() > fktPos+1)503 enumCMD->executeCommand(objectPointer, executionString+inputSplits.getOffset(fktPos +1));504 else505 enumCMD->executeCommand(objectPointer, "");506 delete itCMD;507 return true;508 }509 510 enumCMD = itCMD->nextElement();511 }512 delete itCMD;513 }514 }515 }516 68 } 517 69 … … 520 72 * @param description the description of the Given command 521 73 */ 522 ShellCommandBase* ShellCommandBase::describe(const char* description)74 Executor* Executor::describe(const char* description) 523 75 { 524 76 if (this == NULL) … … 532 84 533 85 /** 534 * adds an Alias to this Command535 * @param alias the name of the Alias to set536 * @returns itself537 */538 ShellCommandBase* ShellCommandBase::setAlias(const char* alias)539 {540 if (this == NULL)541 return NULL;542 543 if (this->alias != NULL)544 {545 PRINTF(2)("not more than one Alias allowed for functions (%s::%s)\n", this->getName(), this->shellClass->getName());546 }547 else548 {549 if (ShellCommandClass::aliasList == NULL)550 ShellCommandClass::aliasList = new tList<ShellCommandAlias>;551 552 ShellCommandAlias* aliasCMD = new ShellCommandAlias(alias, this);553 ShellCommandClass::aliasList->add(aliasCMD);554 this->alias = aliasCMD;555 }556 return this;557 }558 559 /**560 86 * sets default Values of the Commands 561 87 * @param count how many default Values to set. … … 566 92 * count, [EXACTLY THE SAME AS IF YOU WOULD CALL THE FUNCTION UP TO count ARGUMENTS] 567 93 */ 568 ShellCommandBase* ShellCommandBase::defaultValues(unsigned int count, ...)94 Executor* Executor::defaultValues(unsigned int count, ...) 569 95 { 570 96 if (this == NULL) … … 613 139 614 140 /** 615 * prints out nice information about the Shells Commands141 * prints out nice information about the Executor 616 142 */ 617 void ShellCommandBase::debug()143 void Executor::debug() 618 144 { 619 if (ShellCommandClass::commandClassList == NULL) 620 { 621 PRINT(0)("No Command registered.\n"); 622 return; 623 } 624 625 tIterator<ShellCommandClass>* iteratorCL = ShellCommandClass::commandClassList->getIterator(); 626 ShellCommandClass* elemCL = iteratorCL->firstElement(); 145 /* tIterator<ExecutorClass>* iteratorCL = ExecutorClass::commandClassList->getIterator(); 146 ExecutorClass* elemCL = iteratorCL->firstElement(); 627 147 while(elemCL != NULL) 628 148 { 629 149 PRINT(0)("Class:'%s' registered %d commands: \n", elemCL->className, elemCL->commandList->getSize()); 630 tIterator< ShellCommandBase>* iterator = elemCL->commandList->getIterator();631 const ShellCommandBase* elem = iterator->firstElement();150 tIterator<Executor>* iterator = elemCL->commandList->getIterator(); 151 const Executor* elem = iterator->firstElement(); 632 152 while(elem != NULL) 633 153 { 634 154 PRINT(0)(" command:'%s' : params:%d: ", elem->getName(), elem->paramCount); 635 155 for (unsigned int i = 0; i< elem->paramCount; i++) 636 printf("%s ", ShellCommandBase::paramToString(elem->parameters[i]));156 printf("%s ", Executor::paramToString(elem->parameters[i])); 637 157 if (elem->description != NULL) 638 158 printf("- %s", elem->description); … … 644 164 elemCL = iteratorCL->nextElement(); 645 165 } 646 delete iteratorCL; 166 delete iteratorCL;*/ 647 167 } 648 649 /**650 * converts a Parameter to a String651 * @param parameter the Parameter we have.652 * @returns the Name of the Parameter at Hand653 */654 const char* ShellCommandBase::paramToString(long parameter)655 {656 switch (parameter)657 {658 case ParameterBool:659 return "BOOL";660 break;661 case ParameterChar:662 return "CHAR";663 break;664 case ParameterString:665 return "STRING";666 break;667 case ParameterInt:668 return "INT";669 break;670 case ParameterUInt:671 return "UINT";672 break;673 case ParameterFloat:674 return "FLOAT";675 break;676 case ParameterLong:677 return "LONG";678 break;679 default:680 return "NULL";681 break;682 }683 } -
trunk/src/lib/util/executor/executor.h
r5628 r5632 1 1 /*! 2 * @file shell_command.h2 * @file executor.h 3 3 * Definition of a on-screen-shell 4 4 */ 5 5 6 #ifndef _ SHELL_COMMAND_H7 #define _ SHELL_COMMAND_H6 #ifndef _EXECUTOR_H 7 #define _EXECUTOR_H 8 8 9 9 #include "base_object.h" … … 16 16 #include <stdarg.h> 17 17 18 #define SHELL_COMMAND_MAX_SIZE //!< The maximum size of a Shell Command19 20 21 22 18 // FORWARD DECLARATION 23 19 template<class T> class tList; 24 20 25 /**26 * an easy to use Macro to create a Command27 * @param command the name of the command (without "" around the string)28 * @param class the name of the class to apply this command to (without the "" around the string)29 * @param function the function to call30 *31 * MEANING:32 * ShellCommandBase* someUniqueVarName =33 * ShellCommand<ClassName>::registerCommand("commandNameInShell", "ClassName", &ClassName::FunctionToCall);34 *35 * In the Shell you would call this Command using:36 * $ ClassName [ObjectName] commandNameInShell [parameters]37 */38 #define SHELL_COMMAND(command, class, function) \39 ShellCommandBase* shell_command_##class##_##command = ShellCommand<class>::registerCommand(#command, #class, &class::function)40 /**41 * an easy to use Macro to create a Command42 * @param command the name of the command (without "" around the string)43 * @param class the name of the class to apply this command to (without the "" around the string)44 * @param function the function to call45 *46 * MEANING:47 * ShellCommandBase* someUniqueVarName =48 * ShellCommand<ClassName>::registerCommand("commandNameInShell", "ClassName", &ClassName::FunctionToCall);49 *50 * In the Shell you would call this Command using:51 * $ ClassName [ObjectName] commandNameInShell [parameters]52 */53 #define SHELL_COMMAND_STATIC(command, class, function) \54 ShellCommandBase* shell_command_##class##_##command = ShellCommandStatic<class>::registerCommand(#command, #class, function)55 56 57 21 //! an enumerator for the definition of the Type. 58 22 typedef enum { 59 ShellCommand_Objective= 1,60 ShellCommand_Static = 2,61 } ShellCommand_Type;23 Executor_Objective = 1, 24 Executor_Static = 2, 25 } Executor_Type; 62 26 63 27 //////////////// 64 28 // BASE CLASS // 65 29 //////////////// 66 class ShellCommandBase; 67 class ShellCommandAlias; 68 69 //! A class to hold all Classes that have (once) registered Commands. 70 class ShellCommandClass : public BaseObject 30 //! a baseClass for all possible Executors 31 class Executor: public BaseObject 71 32 { 72 friend class ShellCommandBase;73 74 public:75 /** @returns the CommandClassList */76 static const tList<ShellCommandClass>* getCommandClassList() { return ShellCommandClass::commandClassList; };77 static bool getCommandListOfClass(const char* className, tList<const char>* stringList);78 static bool getCommandListOfAlias(tList<const char>* aliasList);79 80 static ShellCommandClass* getCommandClass(const char* className);81 static void unregisterAllCommands();82 83 static void help (const char* className);84 85 private:86 ShellCommandClass(const char* className);87 ~ShellCommandClass();88 89 static const ShellCommandClass* isRegistered(const char* className);90 static void initCommandClassList();91 92 private:93 const char* className; //!< The Name of the Class. This should match the ClassName of the Commands Class.94 long classID; //!< The classID of this Class95 tList<ShellCommandBase>* commandList; //!< A list of Commands from this Class96 static tList<ShellCommandClass>* commandClassList; //!< A list of Classes97 static tList<ShellCommandAlias>* aliasList; //!< An Alias to A Command. (only for classes with one Instance)98 };99 100 101 //! a baseClass for all possible ShellCommands102 class ShellCommandBase : public BaseObject103 {104 friend class ShellCommandClass;105 33 public: 106 34 static bool execute (const char* executionString); 107 35 108 ShellCommandBase* describe(const char* description); 109 ShellCommandBase* setAlias(const char* alias); 110 ShellCommandBase* defaultValues(unsigned int count, ...); 36 Executor* describe(const char* description); 37 Executor* defaultValues(unsigned int count, ...); 111 38 112 39 /** @returns the CommandList of the Shell */ … … 116 43 117 44 protected: 118 ShellCommandBase(const char* commandName, const char* className, unsigned int paramCount, ...);119 ~ ShellCommandBase();45 Executor(const char* commandName, const char* className, unsigned int paramCount, ...); 46 ~Executor(); 120 47 121 48 /** @returns the Type of this Function (either static or objective) */ 122 inline ShellCommand_Type getType() { return this->functorType; };49 inline Executor_Type getType() { return this->functorType; }; 123 50 124 51 static bool isRegistered(const char* commandName, const char* className, unsigned int paramCount, ...); … … 130 57 131 58 protected: 132 ShellCommand_TypefunctorType; //!< The type of Function we've got (either static or objective).59 Executor_Type functorType; //!< The type of Function we've got (either static or objective). 133 60 void* functionPointer; //!< The pointeer to the function of the Class (or static pointer if ClassID == CL_NULL ) 134 61 unsigned int paramCount; //!< the count of parameters. … … 137 64 138 65 private: 139 ShellCommandClass* shellClass; //!< A Pointer to the Shell-Class this Command belongs to.140 ShellCommandAlias* alias; //!< An Alias for the Class.141 142 66 const char* description; //!< A description for this commnand. (initially NULL). Assigned with (create)->describe("blablabla"); 143 67 }; … … 165 89 // COMMAND REGISTRATION // 166 90 ////////////////////////// 167 // SHELLCOMMAND can be redefined as ShellCommand or ShellCommandStatic168 // SHELLCOMMANDEXECUTER can be redefined too.169 // SHELLCOMMANDINCLASS170 // SHELLCOMMANDTYPE91 // EXECUTOR can be redefined as Executor or ExecutorStatic 92 // EXECUTOREXECUTER can be redefined too. 93 // EXECUTORINCLASS 94 // EXECUTORTYPE 171 95 //! registers a command without any parameters 172 #define ShellCommandRegister0() \173 static SHELLCOMMAND<T>* registerCommand(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)()) \96 #define ExecutorRegister0() \ 97 static EXECUTOR<T>* registerCommand(const char* commandName, const char* className, void EXECUTORINCLASS(*function)()) \ 174 98 { \ 175 99 if (isRegistered(commandName, className, 0)== true) \ 176 100 return NULL; \ 177 return new SHELLCOMMAND<T>(commandName, className, function); \101 return new EXECUTOR<T>(commandName, className, function); \ 178 102 } 179 103 180 104 //! 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)) \105 #define ExecutorRegister1(t1) \ 106 static EXECUTOR<T>* registerCommand(const char* commandName, const char* className, void EXECUTORINCLASS(*function)(t1##_TYPE)) \ 183 107 { \ 184 108 if (isRegistered(commandName, className, 1, t1##_PARAM)== true) \ 185 109 return NULL; \ 186 return new SHELLCOMMAND<T>(commandName, className, function); \110 return new EXECUTOR<T>(commandName, className, function); \ 187 111 } 188 112 189 113 //! 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)) \114 #define ExecutorRegister2(t1,t2) \ 115 static EXECUTOR<T>* registerCommand(const char* commandName, const char* className, void EXECUTORINCLASS(*function)(t1##_TYPE, t2##_TYPE)) \ 192 116 { \ 193 117 if (isRegistered(commandName, className, 2, t1##_PARAM, t2##_PARAM)== true) \ 194 118 return NULL; \ 195 return new SHELLCOMMAND<T>(commandName, className, function); \119 return new EXECUTOR<T>(commandName, className, function); \ 196 120 } 197 121 198 122 //! 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)) \123 #define ExecutorRegister3(t1,t2,t3) \ 124 static EXECUTOR<T>* registerCommand(const char* commandName, const char* className, void EXECUTORINCLASS(*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE)) \ 201 125 { \ 202 126 if (isRegistered(commandName, className, 3, t1##_PARAM, t2##_PARAM, t3##_PARAM)== true) \ 203 127 return NULL; \ 204 return new SHELLCOMMAND<T>(commandName, className, function); \128 return new EXECUTOR<T>(commandName, className, function); \ 205 129 } 206 130 207 131 //! 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)) \132 #define ExecutorRegister4(t1,t2,t3,t4) \ 133 static EXECUTOR<T>* registerCommand(const char* commandName, const char* className, void EXECUTORINCLASS(*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE)) \ 210 134 { \ 211 135 if (isRegistered(commandName, className, 4, t1##_PARAM, t2##_PARAM, t3##_PARAM, t4##_PARAM)== true) \ 212 136 return NULL; \ 213 return new SHELLCOMMAND<T>(commandName, className, function); \137 return new EXECUTOR<T>(commandName, className, function); \ 214 138 } 215 139 216 140 //! 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)) \141 #define ExecutorRegister5(t1,t2,t3,t4,t5) \ 142 static EXECUTOR<T>* registerCommand(const char* commandName, const char* className, void EXECUTORINCLASS(*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE, t5##_TYPE)) \ 219 143 { \ 220 144 if (isRegistered(commandName, className, 5, t1##_PARAM, t2##_PARAM, t3##_PARAM, t4##_PARAM, t5##_PARAM)== true) \ 221 145 return NULL; \ 222 return new ShellCommand<T>(commandName, className, function); \146 return new EXECUTOR<T>(commandName, className, function); \ 223 147 } 224 148 … … 226 150 // FUNCTION POINTERS // 227 151 /////////////////////// 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); \152 #define ExecutorFunctionPoiter0() \ 153 void EXECUTORINCLASS(*functionPointer_0)(); 154 155 #define ExecutorFunctionPoiter1(t1) \ 156 void EXECUTORINCLASS(*functionPointer_1_##t1)(t1##_TYPE); 157 158 #define ExecutorFunctionPoiter2(t1, t2) \ 159 void EXECUTORINCLASS(*functionPointer_2_##t1##_##t2)(t1##_TYPE, t2##_TYPE); 160 161 162 #define ExecutorFunctionPoiter3(t1, t2, t3) \ 163 void EXECUTORINCLASS(*functionPointer_3_##t1##_##t2##_##t3)(t1##_TYPE, t2##_TYPE, t3##_TYPE); 164 165 #define ExecutorFunctionPoiter4(t1, t2, t3, t4) \ 166 void EXECUTORINCLASS(*functionPointer_4_##t1##_##t2##_##t3##_##t4)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE); 167 168 169 #define ExecutorFunctionPoiter5(t1, t2, t3, t4, t5) \ 170 void EXECUTORINCLASS(*functionPointer_5_##t1##_##t2##_##t3##_##t4##_##t5)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE, t5##_TYPE); \ 247 171 248 172 … … 251 175 ///////////////// 252 176 //! 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; \177 #define ExecutorConstructor0() \ 178 EXECUTOR(const char* commandName, const char* className, void EXECUTORINCLASS(*function)()) \ 179 : Executor(commandName, className, 0) \ 180 { \ 181 this->functorType = EXECUTORTYPE; \ 258 182 this->fp.functionPointer_0 = function; \ 259 183 } 260 184 261 185 //! 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; \186 #define ExecutorConstructor1(t1) \ 187 EXECUTOR(const char* commandName, const char* className, void EXECUTORINCLASS(*function)(t1##_TYPE)) \ 188 : Executor(commandName, className, 1, t1##_PARAM) \ 189 { \ 190 this->functorType = EXECUTORTYPE; \ 267 191 this->fp.functionPointer_1_##t1 = function; \ 268 192 } 269 193 270 194 //! 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; \195 #define ExecutorConstructor2(t1,t2) \ 196 EXECUTOR(const char* commandName, const char* className, void EXECUTORINCLASS(*function)(t1##_TYPE, t2##_TYPE)) \ 197 : Executor(commandName, className, 2, t1##_PARAM, t2##_PARAM) \ 198 { \ 199 this->functorType = EXECUTORTYPE; \ 276 200 this->fp.functionPointer_2_##t1##_##t2 = function; \ 277 201 } 278 202 279 203 //! 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; \204 #define ExecutorConstructor3(t1,t2,t3) \ 205 EXECUTOR(const char* commandName, const char* className, void EXECUTORINCLASS(*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE)) \ 206 : Executor(commandName, className, 3, t1##_PARAM, t2##_PARAM, t3##_PARAM) \ 207 { \ 208 this->functorType = EXECUTORTYPE; \ 285 209 this->fp.functionPointer_3_##t1##_##t2##_##t3 = function; \ 286 210 } 287 211 288 212 //! 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; \213 #define ExecutorConstructor4(t1,t2,t3,t4) \ 214 EXECUTOR(const char* commandName, const char* className, void EXECUTORINCLASS(*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE)) \ 215 : Executor(commandName, className, 4, t1##_PARAM, t2##_PARAM, t3##_PARAM, t4##_PARAM) \ 216 { \ 217 this->functorType = EXECUTORTYPE; \ 294 218 this->fp.functionPointer_4_##t1##_##t2##_##t3##_##t4 = function; \ 295 219 } 296 220 297 221 //! 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; \222 #define ExecutorConstructor5(t1,t2,t3,t4,t5) \ 223 EXECUTOR(const char* commandName, const char* className, void EXECUTORINCLASS(*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE, t5##_TYPE)) \ 224 : Executor(commandName, className, 5, t1##_PARAM, t2##_PARAM, t3##_PARAM, t4##_PARAM, t5##_PARAM) \ 225 { \ 226 this->functorType = EXECUTORTYPE; \ 303 227 this->fp.functionPointer_5_##t1##_##t2##_##t3##_##t4##_##t5 = function; \ 304 228 } … … 308 232 /////////////// 309 233 //! execute-macro for functions with no parameters 310 #define ShellCommandExecute0() \234 #define ExecutorExecute0() \ 311 235 if (this->paramCount == 0) \ 312 SHELLCOMMANDEXECUTER(_0)()236 EXECUTOREXECUTER(_0)() 313 237 314 238 //! execute-macro for functions with one parameter 315 #define ShellCommandExecute1(t1) \239 #define ExecutorExecute1(t1) \ 316 240 else if (this->paramCount == 1 && this->parameters[0] == t1##_PARAM) \ 317 SHELLCOMMANDEXECUTER(_1_##t1)(t1##_FUNC(parameters, t1##_DEFGRAB(0)))241 EXECUTOREXECUTER(_1_##t1)(t1##_FUNC(parameters, t1##_DEFGRAB(0))) 318 242 319 243 //! execute-macro for functions with two parameters 320 #define ShellCommandExecute2(t1,t2) \244 #define ExecutorExecute2(t1,t2) \ 321 245 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)))246 EXECUTOREXECUTER(_2_##t1##_##t2)(t1##_FUNC(sub.getString(0), t1##_DEFGRAB(0)), t2##_FUNC(sub.getString(1), t2##_DEFGRAB(1))) 323 247 324 248 //! execute-macro for functions with three parameters 325 #define ShellCommandExecute3(t1,t2,t3) \249 #define ExecutorExecute3(t1,t2,t3) \ 326 250 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)))251 EXECUTOREXECUTER(_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 252 329 253 //! execute-macro for functions with four parameters 330 #define ShellCommandExecute4(t1,t2,t3,t4) \254 #define ExecutorExecute4(t1,t2,t3,t4) \ 331 255 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)))256 EXECUTOREXECUTER(_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 257 334 258 //! execute-macro for functions with five parameters 335 #define ShellCommandExecute5(t1,t2,t3,t4,t5) \259 #define ExecutorExecute5(t1,t2,t3,t4,t5) \ 336 260 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 261 EXECUTOREXECUTER(_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))) 262 263 264 265 266 267 //////////\////////// 268 // DYNAMIC FUNCTOR // 269 ///////////\///////// 270 //! keeps information about a Executor 271 template<class T> class ExecutorObjective : public Executor 342 272 { 343 273 public: … … 345 275 #undef FUNCTOR_LIST 346 276 #endif 347 #ifdef SHELLCOMMAND348 #undef SHELLCOMMAND349 #endif 350 #define SHELLCOMMAND ShellCommand351 #ifdef SHELLCOMMANDEXECUTER352 #undef SHELLCOMMANDEXECUTER353 #endif 354 #define SHELLCOMMANDEXECUTER(nameExt) (dynamic_cast<T*>(object)->*(fp.functionPointer##nameExt))355 #ifdef SHELLCOMMANDINCLASS356 #undef SHELLCOMMANDINCLASS357 #endif 358 #define SHELLCOMMANDINCLASS(FUNCTION) (T::FUNCTION)359 #ifdef SHELLCOMMANDTYPE360 #undef SHELLCOMMANDTYPE361 #endif 362 #define SHELLCOMMANDTYPE ShellCommand_Objective277 #ifdef EXECUTOR 278 #undef EXECUTOR 279 #endif 280 #define EXECUTOR ExecutorObjective 281 #ifdef EXECUTOREXECUTER 282 #undef EXECUTOREXECUTER 283 #endif 284 #define EXECUTOREXECUTER(nameExt) (dynamic_cast<T*>(object)->*(fp.functionPointer##nameExt)) 285 #ifdef EXECUTORINCLASS 286 #undef EXECUTORINCLASS 287 #endif 288 #define EXECUTORINCLASS(FUNCTION) (T::FUNCTION) 289 #ifdef EXECUTORTYPE 290 #undef EXECUTORTYPE 291 #endif 292 #define EXECUTORTYPE Executor_Objective 363 293 //! FUNCTOR_LIST is the List of command-registerers 364 #define FUNCTOR_LIST(x) ShellCommandRegister ## x294 #define FUNCTOR_LIST(x) ExecutorRegister ## x 365 295 #include "functor_list.h" 366 296 #undef FUNCTOR_LIST … … 370 300 //! FUNCTOR_LIST is the List of FunctionPointers 371 301 union FunctionPointers { 372 #define FUNCTOR_LIST(x) ShellCommandFunctionPoiter ## x302 #define FUNCTOR_LIST(x) ExecutorFunctionPoiter ## x 373 303 #include "functor_list.h" 374 304 #undef FUNCTOR_LIST … … 376 306 377 307 //! FUNCTOR_LIST is the List of CommandConstructors 378 #define FUNCTOR_LIST(x) ShellCommandConstructor ## x308 #define FUNCTOR_LIST(x) ExecutorConstructor ## x 379 309 #include "functor_list.h" 380 310 #undef FUNCTOR_LIST … … 384 314 SubString sub(parameters, true); 385 315 //! FUNCTOR_LIST is the List of Executive Functions 386 #define FUNCTOR_LIST(x) ShellCommandExecute ## x316 #define FUNCTOR_LIST(x) ExecutorExecute ## x 387 317 #include "functor_list.h" 388 318 #undef FUNCTOR_LIST … … 390 320 }; 391 321 392 //! keeps information about a ShellCommand, that points to a Static Function 393 template<class T> class ShellCommandStatic : public ShellCommandBase 322 323 324 //////////////////// 325 // STATIC FUNCTOR // 326 //////////////////// 327 //! keeps information about a Executor, that points to a Static Function 328 template<class T> class ExecutorStatic : public Executor 394 329 { 395 330 public: … … 397 332 #undef FUNCTOR_LIST 398 333 #endif 399 #ifdef SHELLCOMMAND400 #undef SHELLCOMMAND401 #endif 402 #define SHELLCOMMAND ShellCommandStatic403 #ifdef SHELLCOMMANDEXECUTER404 #undef SHELLCOMMANDEXECUTER405 #endif 406 #define SHELLCOMMANDEXECUTER(nameExt) fp.functionPointer##nameExt407 #ifdef SHELLCOMMANDINCLASS408 #undef SHELLCOMMANDINCLASS409 #endif 410 #define SHELLCOMMANDINCLASS(FUNCTION) (FUNCTION)411 #ifdef SHELLCOMMANDTYPE412 #undef SHELLCOMMANDTYPE413 #endif 414 #define SHELLCOMMANDTYPE ShellCommand_Static334 #ifdef EXECUTOR 335 #undef EXECUTOR 336 #endif 337 #define EXECUTOR ExecutorStatic 338 #ifdef EXECUTOREXECUTER 339 #undef EXECUTOREXECUTER 340 #endif 341 #define EXECUTOREXECUTER(nameExt) fp.functionPointer##nameExt 342 #ifdef EXECUTORINCLASS 343 #undef EXECUTORINCLASS 344 #endif 345 #define EXECUTORINCLASS(FUNCTION) (FUNCTION) 346 #ifdef EXECUTORTYPE 347 #undef EXECUTORTYPE 348 #endif 349 #define EXECUTORTYPE Executor_Static 415 350 416 351 //! FUNCTOR_LIST is the List of command-registerers 417 #define FUNCTOR_LIST(x) ShellCommandRegister ## x352 #define FUNCTOR_LIST(x) ExecutorRegister ## x 418 353 #include "functor_list.h" 419 354 #undef FUNCTOR_LIST … … 422 357 //! FUNCTOR_LIST is the List of FunctionPointers 423 358 union FunctionPointers { 424 #define FUNCTOR_LIST(x) ShellCommandFunctionPoiter ## x359 #define FUNCTOR_LIST(x) ExecutorFunctionPoiter ## x 425 360 #include "functor_list.h" 426 361 #undef FUNCTOR_LIST … … 428 363 429 364 //! FUNCTOR_LIST is the List of CommandConstructors 430 #define FUNCTOR_LIST(x) ShellCommandConstructor ## x365 #define FUNCTOR_LIST(x) ExecutorConstructor ## x 431 366 #include "functor_list.h" 432 367 #undef FUNCTOR_LIST … … 436 371 SubString sub(parameters, true); 437 372 //! FUNCTOR_LIST is the List of Executive Functions 438 #define FUNCTOR_LIST(x) ShellCommandExecute ## x373 #define FUNCTOR_LIST(x) ExecutorExecute ## x 439 374 #include "functor_list.h" 440 375 #undef FUNCTOR_LIST … … 443 378 444 379 //! A Class, that handles aliases. 445 class ShellCommandAlias380 class ExecutorAlias 446 381 { 447 friend class ShellCommandBase;382 friend class ExecutorBase; 448 383 public: 449 384 /** @returns the Name of the Alias. */ 450 385 const char* getName() const { return this->aliasName; }; 451 386 /** @returns the Command, this Alias is asociated with */ 452 ShellCommandBase* getCommand() const { return this->command; };387 ExecutorBase* getCommand() const { return this->command; }; 453 388 454 389 private: 455 390 /** @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; };391 ExecutorAlias(const char* aliasName, ExecutorBase* command) { this->aliasName = aliasName; this->command = command; }; 457 392 458 393 private: 459 394 const char* aliasName; //!< the name of the Alias 460 ShellCommandBase*command; //!< a pointer to the command, this alias executes.395 ExecutorBase* command; //!< a pointer to the command, this alias executes. 461 396 }; 462 397 463 #endif /* _ SHELL_COMMAND_H */398 #endif /* _EXECUTOR_H */
Note: See TracChangeset
for help on using the changeset viewer.