Changeset 5461 in orxonox.OLD for trunk/src/lib/event

Timestamp:

Oct 30, 2005, 10:37:14 AM (19 years ago)

Author:

bensch

Message:

orxonox/trunk: command-chain (copy and renaming of shell_command) added to project … think some more

Location:

trunk/src/lib/event

Files:

• command_chain.cc (modified) (30 diffs)
• command_chain.h (modified) (32 diffs)

trunk/src/lib/event/command_chain.cc

@@ -30 +30 @@
 
 /**
- * creates a new ShellCommandClass
+ * creates a new CommandChainClass
  * @param className the Name of the command-class to create
  */
-ShellCommandClass::ShellCommandClass(const char* className)
-{
-  this->setClassID(CL_SHELL_COMMAND_CLASS, "ShellCommandClass");
+CommandChainClass::CommandChainClass(const char* className)
+{
+  this->setClassID(CL_COMMAND_CHAIN_CLASS, "CommandChainClass");
   this->setName(className);
 
   this->className = className;
   this->classID = CL_NULL;
-  this->commandList = new tList<ShellCommandBase>;
-
-  ShellCommandClass::commandClassList->add(this);
+  this->commandList = new tList<CommandChainBase>;
+
+  CommandChainClass::commandClassList->add(this);
 }
 
@@ -48 +48 @@
  * destructs the shellCommandClass again
  */
-ShellCommandClass::~ShellCommandClass()
-{
-  tIterator<ShellCommandBase>* iterator = this->commandList->getIterator();
-  ShellCommandBase* elem = iterator->firstElement();
+CommandChainClass::~CommandChainClass()
+{
+  tIterator<CommandChainBase>* iterator = this->commandList->getIterator();
+  CommandChainBase* elem = iterator->firstElement();
   while(elem != NULL)
   {
@@ -67 +67 @@
  * @returns true on success, false otherwise
  */
-bool ShellCommandClass::getCommandListOfClass(const char* className, tList<const char>* stringList)
+bool CommandChainClass::getCommandListOfClass(const char* className, tList<const char>* stringList)
 {
   if (stringList == NULL || className == NULL)
     return false;
 
-  tIterator<ShellCommandClass>* iterator = ShellCommandClass::commandClassList->getIterator();
-  ShellCommandClass* elem = iterator->firstElement();
+  tIterator<CommandChainClass>* iterator = CommandChainClass::commandClassList->getIterator();
+  CommandChainClass* elem = iterator->firstElement();
   while(elem != NULL)
   {
     if (!strcmp (elem->getName(), className))
     {
-      tIterator<ShellCommandBase>* itFkt = elem->commandList->getIterator();
-      ShellCommandBase* command = itFkt->firstElement();
+      tIterator<CommandChainBase>* itFkt = elem->commandList->getIterator();
+      CommandChainBase* command = itFkt->firstElement();
       while (command != NULL)
       {
@@ -95 +95 @@
 
 /**
- * collects the Aliases registered to the ShellCommands
+ * collects the Aliases registered to the CommandChains
  * @param stringList a List to paste the Aliases into.
  * @returns true on success, false otherwise
  */
-bool ShellCommandClass::getCommandListOfAlias(tList<const char>* stringList)
-{
-  if (stringList == NULL || ShellCommandClass::aliasList == NULL)
+bool CommandChainClass::getCommandListOfAlias(tList<const char>* stringList)
+{
+  if (stringList == NULL || CommandChainClass::aliasList == NULL)
     return false;
 
-  tIterator<ShellCommandAlias>* iterator = ShellCommandClass::aliasList->getIterator();
-   ShellCommandAlias* elem = iterator->firstElement();
+  tIterator<CommandChainAlias>* iterator = CommandChainClass::aliasList->getIterator();
+   CommandChainAlias* elem = iterator->firstElement();
    while(elem != NULL)
    {
@@ -118 +118 @@
  * unregisters all Commands that exist
  */
-void ShellCommandClass::unregisterAllCommands()
+void CommandChainClass::unregisterAllCommands()
 {
   // unregister all commands
-  tIterator<ShellCommandClass>* iterator = ShellCommandClass::commandClassList->getIterator();
-  ShellCommandClass* elem = iterator->firstElement();
+  tIterator<CommandChainClass>* iterator = CommandChainClass::commandClassList->getIterator();
+  CommandChainClass* elem = iterator->firstElement();
   while(elem != NULL)
   {
@@ -131 +131 @@
   delete iterator;
 
-  delete ShellCommandClass::commandClassList;
-  ShellCommandClass::commandClassList = NULL;
+  delete CommandChainClass::commandClassList;
+  CommandChainClass::commandClassList = NULL;
 
   // unregister all aliases (there should be nothing to do here :))
-  if (ShellCommandClass::aliasList != NULL)
-  {
-    tIterator<ShellCommandAlias>* itAL = ShellCommandClass::aliasList->getIterator();
-    ShellCommandAlias* elemAL = itAL->firstElement();
+  if (CommandChainClass::aliasList != NULL)
+  {
+    tIterator<CommandChainAlias>* itAL = CommandChainClass::aliasList->getIterator();
+    CommandChainAlias* elemAL = itAL->firstElement();
     while(elemAL != NULL)
     {
@@ -145 +145 @@
     }
     delete itAL;
-    delete ShellCommandClass::aliasList;
-    ShellCommandClass::aliasList = NULL;
+    delete CommandChainClass::aliasList;
+    CommandChainClass::aliasList = NULL;
   }
 }
@@ -155 +155 @@
  * @returns the CommandClass if found, NULL otherwise
  */
-const ShellCommandClass* ShellCommandClass::isRegistered(const char* className)
-{
-  if (ShellCommandClass::commandClassList == NULL)
+const CommandChainClass* CommandChainClass::isRegistered(const char* className)
+{
+  if (CommandChainClass::commandClassList == NULL)
     initCommandClassList();
 
-  tIterator<ShellCommandClass>* iterator = ShellCommandClass::commandClassList->getIterator();
-  ShellCommandClass* elem = iterator->firstElement();
+  tIterator<CommandChainClass>* iterator = CommandChainClass::commandClassList->getIterator();
+  CommandChainClass* elem = iterator->firstElement();
   while(elem != NULL)
   {
@@ -183 +183 @@
  * @returns the CommandClass if found, or a new CommandClass if not
  */
-ShellCommandClass* ShellCommandClass::getCommandClass(const char* className)
-{
-  if (ShellCommandClass::commandClassList == NULL)
+CommandChainClass* CommandChainClass::getCommandClass(const char* className)
+{
+  if (CommandChainClass::commandClassList == NULL)
     initCommandClassList();
 
-  tIterator<ShellCommandClass>* iterator = ShellCommandClass::commandClassList->getIterator();
-  ShellCommandClass* elem = iterator->firstElement();
+  tIterator<CommandChainClass>* iterator = CommandChainClass::commandClassList->getIterator();
+  CommandChainClass* elem = iterator->firstElement();
   while(elem != NULL)
   {
@@ -200 +200 @@
   }
   delete iterator;
-  return new ShellCommandClass(className);
+  return new CommandChainClass(className);
 }
 
@@ -206 +206 @@
  * initializes the CommandList (if it is NULL)
  */
-void ShellCommandClass::initCommandClassList()
-{
-  if (ShellCommandClass::commandClassList == NULL)
-  {
-    ShellCommandClass::commandClassList = new tList<ShellCommandClass>;
-    ShellCommandStatic<ShellCommandBase>::registerCommand("debug", "ShellCommand", ShellCommandBase::debug);
-  }
-}
-
-void ShellCommandClass::help(const char* className)
+void CommandChainClass::initCommandClassList()
+{
+  if (CommandChainClass::commandClassList == NULL)
+  {
+    CommandChainClass::commandClassList = new tList<CommandChainClass>;
+    CommandChainStatic<CommandChainBase>::registerCommand("debug", "CommandChain", CommandChainBase::debug);
+  }
+}
+
+void CommandChainClass::help(const char* className)
 {
   if (className == NULL)
     return;
-  if (likely(ShellCommandClass::commandClassList != NULL))
-  {
-    tIterator<ShellCommandClass>* itCL = ShellCommandClass::commandClassList->getIterator();
-    ShellCommandClass* elemCL = itCL->firstElement();
+  if (likely(CommandChainClass::commandClassList != NULL))
+  {
+    tIterator<CommandChainClass>* itCL = CommandChainClass::commandClassList->getIterator();
+    CommandChainClass* elemCL = itCL->firstElement();
     while(elemCL != NULL)
     {
@@ -228 +228 @@
       {
         PRINT(0)("Class:'%s' registered %d commands: \n", elemCL->className, elemCL->commandList->getSize());
-        tIterator<ShellCommandBase>* iterator = elemCL->commandList->getIterator();
-        const ShellCommandBase* elem = iterator->firstElement();
+        tIterator<CommandChainBase>* iterator = elemCL->commandList->getIterator();
+        const CommandChainBase* elem = iterator->firstElement();
         while(elem != NULL)
         {
           PRINT(0)("  command:'%s' : params:%d: ", elem->getName(), elem->paramCount);
           for (unsigned int i = 0; i< elem->paramCount; i++)
-            PRINT(0)("%s ", ShellCommandBase::paramToString(elem->parameters[i]));
+            PRINT(0)("%s ", CommandChainBase::paramToString(elem->parameters[i]));
           if (elem->description != NULL)
             PRINT(0)("- %s", elem->description);
@@ -256 +256 @@
 }
 
-tList<ShellCommandClass>* ShellCommandClass::commandClassList = NULL;
-tList<ShellCommandAlias>* ShellCommandClass::aliasList = NULL;
+tList<CommandChainClass>* CommandChainClass::commandClassList = NULL;
+tList<CommandChainAlias>* CommandChainClass::aliasList = NULL;
 
 /**
@@ -266 +266 @@
  * @return self
  */
-ShellCommandBase::ShellCommandBase(const char* commandName, const char* className, unsigned int paramCount, ...)
-{
-  this->setClassID(CL_SHELL_COMMAND, "ShellCommand");
+CommandChainBase::CommandChainBase(const char* commandName, const char* className, unsigned int paramCount, ...)
+{
+  this->setClassID(CL_COMMAND_CHAIN, "CommandChain");
   this->setName(commandName);
   this->description = NULL;
@@ -274 +274 @@
 
 //  this->classID = classID;
-  this->shellClass = ShellCommandClass::getCommandClass(className); //ClassList::IDToString(classID);
+  this->shellClass = CommandChainClass::getCommandClass(className); //ClassList::IDToString(classID);
   if (this->shellClass != NULL)
     this->shellClass->commandList->add(this);
@@ -321 +321 @@
 
 /**
- * deconstructs a ShellCommand
+ * deconstructs a CommandChain
  * @return
  */
-ShellCommandBase::~ShellCommandBase()
+CommandChainBase::~CommandChainBase()
 {
   delete[] this->parameters;
-  if (this->alias != NULL && ShellCommandClass::aliasList != NULL)
-  {
-    ShellCommandClass::aliasList->remove(this->alias);
+  if (this->alias != NULL && CommandChainClass::aliasList != NULL)
+  {
+    CommandChainClass::aliasList->remove(this->alias);
     delete this->alias;
   }
@@ -339 +339 @@
  * @param commandName the name of the command itself
  */
-void ShellCommandBase::unregisterCommand(const char* commandName, const char* className)
-{
-  if (ShellCommandClass::commandClassList == NULL)
-    ShellCommandClass::initCommandClassList();
-
- const ShellCommandClass* checkClass = ShellCommandClass::isRegistered(className);
+void CommandChainBase::unregisterCommand(const char* commandName, const char* className)
+{
+  if (CommandChainClass::commandClassList == NULL)
+    CommandChainClass::initCommandClassList();
+
+ const CommandChainClass* checkClass = CommandChainClass::isRegistered(className);
 
  if (checkClass != NULL)
   {
-    tIterator<ShellCommandBase>* iterator = checkClass->commandList->getIterator();
-    ShellCommandBase* elem = iterator->firstElement();
+    tIterator<CommandChainBase>* iterator = checkClass->commandList->getIterator();
+    CommandChainBase* elem = iterator->firstElement();
     while(elem != NULL)
     {
@@ -364 +364 @@
     if (checkClass->commandList->getSize() == 0)
     {
-      ShellCommandClass::commandClassList->remove(checkClass);
+      CommandChainClass::commandClassList->remove(checkClass);
       delete checkClass;
     }
@@ -380 +380 @@
  * This is checked in the registerCommand-function.
  */
-bool ShellCommandBase::isRegistered(const char* commandName, const char* className, unsigned int paramCount, ...)
-{
-  if (ShellCommandClass::commandClassList == NULL)
-  {
-    ShellCommandClass::initCommandClassList();
+bool CommandChainBase::isRegistered(const char* commandName, const char* className, unsigned int paramCount, ...)
+{
+  if (CommandChainClass::commandClassList == NULL)
+  {
+    CommandChainClass::initCommandClassList();
     return false;
   }
 
-  const ShellCommandClass* checkClass = ShellCommandClass::isRegistered(className);
+  const CommandChainClass* checkClass = CommandChainClass::isRegistered(className);
   if (checkClass != NULL)
   {
-    tIterator<ShellCommandBase>* iterator = checkClass->commandList->getIterator();
-    ShellCommandBase* elem = iterator->firstElement();
+    tIterator<CommandChainBase>* iterator = checkClass->commandList->getIterator();
+    CommandChainBase* elem = iterator->firstElement();
     while(elem != NULL)
    {
@@ -418 +418 @@
  */
 #include  "stdlibincl.h"
-bool ShellCommandBase::execute(const char* executionString)
-{
-  if (ShellCommandClass::commandClassList == NULL)
+bool CommandChainBase::execute(const char* executionString)
+{
+  if (CommandChainClass::commandClassList == NULL)
     return false;
 
   long classID = CL_NULL;                 //< the classID retrieved from the Class.
-  ShellCommandClass* commandClass = NULL; //< the command class this command applies to.
+  CommandChainClass* commandClass = NULL; //< the command class this command applies to.
   tList<BaseObject>* objectList = NULL;   //< the list of Objects stored in classID
   BaseObject* objectPointer = NULL;       //< a pointer to th Object to Execute the command on
@@ -437 +437 @@
   {
     // CHECK FOR ALIAS
-    if (ShellCommandClass::aliasList != NULL)
-    {
-      tIterator<ShellCommandAlias>* itAL = ShellCommandClass::aliasList->getIterator();
-      ShellCommandAlias* elemAL = itAL->firstElement();
+    if (CommandChainClass::aliasList != NULL)
+    {
+      tIterator<CommandChainAlias>* itAL = CommandChainClass::aliasList->getIterator();
+      CommandChainAlias* elemAL = itAL->firstElement();
       while(elemAL != NULL)
       {
@@ -462 +462 @@
     }
     // looking for a Matching Class
-    if (likely(ShellCommandClass::commandClassList != NULL))
-    {
-      tIterator<ShellCommandClass>* itCL = ShellCommandClass::commandClassList->getIterator();
-      ShellCommandClass* elemCL = itCL->firstElement();
+    if (likely(CommandChainClass::commandClassList != NULL))
+    {
+      tIterator<CommandChainClass>* itCL = CommandChainClass::commandClassList->getIterator();
+      CommandChainClass* elemCL = itCL->firstElement();
       while(elemCL != NULL)
       {
@@ -507 +507 @@
       if (commandClass != NULL && (fktPos == 1 || (fktPos == 2 && inputSplits.getCount() >= 3)))
       {
-        tIterator<ShellCommandBase>* itCMD = commandClass->commandList->getIterator();
-        ShellCommandBase* enumCMD = itCMD->firstElement();
+        tIterator<CommandChainBase>* itCMD = commandClass->commandList->getIterator();
+        CommandChainBase* enumCMD = itCMD->firstElement();
         while (enumCMD != NULL)
         {
           if (!strcmp(enumCMD->getName(), inputSplits.getString(fktPos)))
           {
-            if (objectPointer == NULL && enumCMD->functorType == ShellCommand_Objective)
+            if (objectPointer == NULL && enumCMD->functorType == CommandChain_Objective)
             {
               delete itCMD;
@@ -538 +538 @@
  * @param description the description of the Given command
  */
-ShellCommandBase* ShellCommandBase::describe(const char* description)
+CommandChainBase* CommandChainBase::describe(const char* description)
 {
   if (this == NULL)
@@ -554 +554 @@
  * @returns itself
  */
-ShellCommandBase* ShellCommandBase::setAlias(const char* alias)
+CommandChainBase* CommandChainBase::setAlias(const char* alias)
 {
   if (this == NULL)
@@ -565 +565 @@
   else
   {
-    if (ShellCommandClass::aliasList == NULL)
-      ShellCommandClass::aliasList = new tList<ShellCommandAlias>;
-
-    ShellCommandAlias* aliasCMD = new ShellCommandAlias(alias, this);
-    ShellCommandClass::aliasList->add(aliasCMD);
+    if (CommandChainClass::aliasList == NULL)
+      CommandChainClass::aliasList = new tList<CommandChainAlias>;
+
+    CommandChainAlias* aliasCMD = new CommandChainAlias(alias, this);
+    CommandChainClass::aliasList->add(aliasCMD);
     this->alias = aliasCMD;
   }
@@ -584 +584 @@
  * count, [EXACTLY THE SAME AS IF YOU WOULD CALL THE FUNCTION UP TO count ARGUMENTS]
  */
-ShellCommandBase* ShellCommandBase::defaultValues(unsigned int count, ...)
+CommandChainBase* CommandChainBase::defaultValues(unsigned int count, ...)
 {
   if (this == NULL)
@@ -633 +633 @@
  * prints out nice information about the Shells Commands
  */
-void ShellCommandBase::debug()
-{
-  if (ShellCommandClass::commandClassList == NULL)
+void CommandChainBase::debug()
+{
+  if (CommandChainClass::commandClassList == NULL)
   {
     PRINT(0)("No Command registered.\n");
@@ -641 +641 @@
   }
 
-  tIterator<ShellCommandClass>* iteratorCL = ShellCommandClass::commandClassList->getIterator();
-  ShellCommandClass* elemCL = iteratorCL->firstElement();
+  tIterator<CommandChainClass>* iteratorCL = CommandChainClass::commandClassList->getIterator();
+  CommandChainClass* elemCL = iteratorCL->firstElement();
   while(elemCL != NULL)
   {
     PRINT(0)("Class:'%s' registered %d commands: \n", elemCL->className, elemCL->commandList->getSize());
-    tIterator<ShellCommandBase>* iterator = elemCL->commandList->getIterator();
-    const ShellCommandBase* elem = iterator->firstElement();
+    tIterator<CommandChainBase>* iterator = elemCL->commandList->getIterator();
+    const CommandChainBase* elem = iterator->firstElement();
     while(elem != NULL)
     {
       PRINT(0)("  command:'%s' : params:%d: ", elem->getName(), elem->paramCount);
       for (unsigned int i = 0; i< elem->paramCount; i++)
-       printf("%s ", ShellCommandBase::paramToString(elem->parameters[i]));
+       printf("%s ", CommandChainBase::paramToString(elem->parameters[i]));
       if (elem->description != NULL)
        printf("- %s", elem->description);
@@ -670 +670 @@
  * @returns the Name of the Parameter at Hand
  */
-const char* ShellCommandBase::paramToString(long parameter)
+const char* CommandChainBase::paramToString(long parameter)
 {
   switch (parameter)

trunk/src/lib/event/command_chain.h

@@ -1 +1 @@
 /*!
- * @file shell_command.h
+ * @file command_chain.h
  * Definition of a on-screen-shell
  */
 
-#ifndef _SHELL_COMMAND_H
-#define _SHELL_COMMAND_H
+#ifndef _COMMAND_CHAIN_H
+#define _COMMAND_CHAIN_H
 
 #include "base_object.h"
@@ -15 +15 @@
 #include <stdarg.h>
 
-#define     SHELL_COMMAND_MAX_SIZE      //!< The maximum size of a Shell Command
+#define     COMMAND_CHAIN_MAX_SIZE      //!< The maximum size of a Shell Command
 
 
@@ -29 +29 @@
  *
  * MEANING:
- *  ShellCommandBase* someUniqueVarName =
- *       ShellCommand<ClassName>::registerCommand("commandNameInShell", "ClassName", &ClassName::FunctionToCall);
+ *  CommandChainBase* someUniqueVarName =
+ *       CommandChain<ClassName>::registerCommand("commandNameInShell", "ClassName", &ClassName::FunctionToCall);
  *
  * In the Shell you would call this Command using:
  * $ ClassName [ObjectName] commandNameInShell [parameters]
  */
-#define SHELL_COMMAND(command, class, function) \
-        ShellCommandBase* shell_command_##class##_##command = ShellCommand<class>::registerCommand(#command, #class, &class::function)
+#define COMMAND_CHAIN(command, class, function) \
+        CommandChainBase* command_chain_##class##_##command = CommandChain<class>::registerCommand(#command, #class, &class::function)
 /**
  * an easy to use Macro to create a Command
@@ -44 +44 @@
  *
  * MEANING:
- *  ShellCommandBase* someUniqueVarName =
- *       ShellCommand<ClassName>::registerCommand("commandNameInShell", "ClassName", &ClassName::FunctionToCall);
+ *  CommandChainBase* someUniqueVarName =
+ *       CommandChain<ClassName>::registerCommand("commandNameInShell", "ClassName", &ClassName::FunctionToCall);
  *
  * In the Shell you would call this Command using:
  * $ ClassName [ObjectName] commandNameInShell [parameters]
  */
-#define SHELL_COMMAND_STATIC(command, class, function) \
-                         ShellCommandBase* shell_command_##class##_##command = ShellCommandStatic<class>::registerCommand(#command, #class, function)
+#define COMMAND_CHAIN_STATIC(command, class, function) \
+                         CommandChainBase* command_chain_##class##_##command = CommandChainStatic<class>::registerCommand(#command, #class, function)
 
 
 //! an enumerator for the definition of the Type.
 typedef enum {
-  ShellCommand_Objective = 1,
-  ShellCommand_Static    = 2,
-} ShellCommand_Type;
+  CommandChain_Objective = 1,
+  CommandChain_Static    = 2,
+} CommandChain_Type;
 
 ////////////////
 // BASE CLASS //
 ////////////////
-class ShellCommandBase;
-class ShellCommandAlias;
+class CommandChainBase;
+class CommandChainAlias;
 
 //! A class to hold all Classes that have (once) registered Commands.
-class ShellCommandClass : public BaseObject
+class CommandChainClass : public BaseObject
 {
-  friend class ShellCommandBase;
+  friend class CommandChainBase;
 
   public:
     /** @returns the CommandClassList */
-    static const tList<ShellCommandClass>* getCommandClassList() { return ShellCommandClass::commandClassList; };
+    static const tList<CommandChainClass>* getCommandClassList() { return CommandChainClass::commandClassList; };
     static bool getCommandListOfClass(const char* className, tList<const char>* stringList);
     static bool getCommandListOfAlias(tList<const char>* aliasList);
 
-    static ShellCommandClass* getCommandClass(const char* className);
+    static CommandChainClass* getCommandClass(const char* className);
     static void unregisterAllCommands();
 
@@ -83 +83 @@
 
   private:
-    ShellCommandClass(const char* className);
-    ~ShellCommandClass();
-
-    static const ShellCommandClass* isRegistered(const char* className);
+    CommandChainClass(const char* className);
+    ~CommandChainClass();
+
+    static const CommandChainClass* isRegistered(const char* className);
     static void initCommandClassList();
 
@@ -92 +92 @@
     const char*                      className;                 //!< The Name of the Class. This should match the ClassName of the Commands Class.
     long                             classID;                   //!< The classID of this Class
-    tList<ShellCommandBase>*         commandList;               //!< A list of Commands from this Class
-    static tList<ShellCommandClass>* commandClassList;          //!< A list of Classes
-    static tList<ShellCommandAlias>* aliasList;                 //!< An Alias to A Command. (only for classes with one Instance)
+    tList<CommandChainBase>*         commandList;               //!< A list of Commands from this Class
+    static tList<CommandChainClass>* commandClassList;          //!< A list of Classes
+    static tList<CommandChainAlias>* aliasList;                 //!< An Alias to A Command. (only for classes with one Instance)
 };
 
 
-//! a baseClass for all possible ShellCommands
-class ShellCommandBase : public BaseObject
+//! a baseClass for all possible CommandChains
+class CommandChainBase : public BaseObject
 {
-  friend class ShellCommandClass;
+  friend class CommandChainClass;
   public:
     static bool execute (const char* executionString);
 
-    ShellCommandBase* describe(const char* description);
-    ShellCommandBase* setAlias(const char* alias);
-    ShellCommandBase* defaultValues(unsigned int count, ...);
+    CommandChainBase* describe(const char* description);
+    CommandChainBase* setAlias(const char* alias);
+    CommandChainBase* defaultValues(unsigned int count, ...);
 
     /** @returns the CommandList of the Shell */
@@ -115 +115 @@
 
   protected:
-    ShellCommandBase(const char* commandName, const char* className, unsigned int paramCount, ...);
-    ~ShellCommandBase();
+    CommandChainBase(const char* commandName, const char* className, unsigned int paramCount, ...);
+    ~CommandChainBase();
 
     /** @returns the Type of this Function (either static or objective) */
-    inline ShellCommand_Type getType() { return this->functorType; };
+    inline CommandChain_Type getType() { return this->functorType; };
 
     static bool isRegistered(const char* commandName, const char* className, unsigned int paramCount, ...);
@@ -129 +129 @@
 
   protected:
-    ShellCommand_Type                functorType;                          //!< The type of Function we've got (either static or objective).
+    CommandChain_Type                functorType;                          //!< The type of Function we've got (either static or objective).
     void*                            functionPointer;                      //!< The pointeer to the function of the Class (or static pointer if ClassID == CL_NULL )
     unsigned int                     paramCount;                           //!< the count of parameters.
@@ -140 +140 @@
 
   private:
-    ShellCommandClass*               shellClass;                           //!< A Pointer to the Shell-Class this Command belongs to.
-    ShellCommandAlias*               alias;                                //!< An Alias for the Class.
+    CommandChainClass*               shellClass;                           //!< A Pointer to the Shell-Class this Command belongs to.
+    CommandChainAlias*               alias;                                //!< An Alias for the Class.
 
     const char*                      description;                          //!< A description for this commnand. (initially NULL). Assigned with (create)->describe("blablabla");
@@ -168 +168 @@
 // COMMAND REGISTRATION //
 //////////////////////////
-// SHELLCOMMAND can be redefined as ShellCommand or ShellCommandStatic
+// SHELLCOMMAND can be redefined as CommandChain or CommandChainStatic
 // SHELLCOMMANDEXECUTER can be redefined too.
 // SHELLCOMMANDINCLASS
 // SHELLCOMMANDTYPE
 //! registers a command without any parameters
-#define ShellCommandRegister0() \
+#define CommandChainRegister0() \
   static SHELLCOMMAND<T>* registerCommand(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)()) \
   { \
@@ -182 +182 @@
 
 //! registers a command with 1 parameter
-#define ShellCommandRegister1(t1) \
+#define CommandChainRegister1(t1) \
   static SHELLCOMMAND<T>* registerCommand(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE), t1##_TYPE d1 = t1##_DEFAULT) \
   { \
@@ -191 +191 @@
 
 //! registers a command with 2 parameters
-#define ShellCommandRegister2(t1,t2) \
+#define CommandChainRegister2(t1,t2) \
   static SHELLCOMMAND<T>* registerCommand(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE, t2##_TYPE), t1##_TYPE d1 = t1##_DEFAULT, t2##_TYPE d2 = t2##_DEFAULT) \
   { \
@@ -200 +200 @@
 
 //! registers a command with 3 parameters
-#define ShellCommandRegister3(t1,t2,t3) \
+#define CommandChainRegister3(t1,t2,t3) \
   static SHELLCOMMAND<T>* registerCommand(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE), t1##_TYPE d1 = t1##_DEFAULT, t2##_TYPE d2 = t2##_DEFAULT, t3##_TYPE d3 = t3##_DEFAULT) \
   { \
@@ -209 +209 @@
 
 //! registers a command with 4 parameters
-#define ShellCommandRegister4(t1,t2,t3,t4) \
+#define CommandChainRegister4(t1,t2,t3,t4) \
   static SHELLCOMMAND<T>* registerCommand(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE), t1##_TYPE d1 = t1##_DEFAULT, t2##_TYPE d2 = t2##_DEFAULT, t3##_TYPE d3 = t3##_DEFAULT, t4##_TYPE d4 = t4##_DEFAULT) \
   { \
@@ -218 +218 @@
 
 //! registers a command with 5 parameters
-#define ShellCommandRegister5(t1,t2,t3,t4,t5) \
+#define CommandChainRegister5(t1,t2,t3,t4,t5) \
   static SHELLCOMMAND<T>* registerCommand(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE, t5##_TYPE), t1##_TYPE d1 = t1##_DEFAULT, t2##_TYPE d2 = t2##_DEFAULT, t3##_TYPE d3 = t3##_DEFAULT, t4##_TYPE d4 = t4##_DEFAULT, t5##_TYPE d5 = t5##_DEFAULT) \
   { \
     if (isRegistered(commandName, className, 5, t1##_PARAM, t2##_PARAM, t3##_PARAM, t4##_PARAM, t5##_PARAM)== true) \
       return NULL; \
-    return new ShellCommand<T>(commandName, className, function, d1, d2, d3, d4, d5); \
+    return new CommandChain<T>(commandName, className, function, d1, d2, d3, d4, d5); \
   }
 
@@ -230 +230 @@
 /////////////////
 //! creates a command that takes no parameters
-#define ShellCommandConstructor0() \
+#define CommandChainConstructor0() \
   void SHELLCOMMANDINCLASS(*functionPointer_0)(); \
   SHELLCOMMAND(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)()) \
-  : ShellCommandBase(commandName, className, 0) \
+  : CommandChainBase(commandName, className, 0) \
   { \
     this->functorType = SHELLCOMMANDTYPE; \
@@ -240 +240 @@
 
 //! creates a command that takes one parameter
-#define ShellCommandConstructor1(t1) \
+#define CommandChainConstructor1(t1) \
   void SHELLCOMMANDINCLASS(*functionPointer_1_##t1)(t1##_TYPE); \
   SHELLCOMMAND(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE), t1##_TYPE d1) \
-  : ShellCommandBase(commandName, className, 1, t1##_PARAM, d1) \
+  : CommandChainBase(commandName, className, 1, t1##_PARAM, d1) \
   { \
     this->functorType = SHELLCOMMANDTYPE; \
@@ -250 +250 @@
 
 //! creates a command that takes two parameters
-#define ShellCommandConstructor2(t1,t2) \
+#define CommandChainConstructor2(t1,t2) \
   void SHELLCOMMANDINCLASS(*functionPointer_2_##t1##_##t2)(t1##_TYPE, t2##_TYPE); \
   SHELLCOMMAND(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE, t2##_TYPE), t1##_TYPE d1, t2##_TYPE d2) \
-  : ShellCommandBase(commandName, className, 2, t1##_PARAM, d1, t2##_PARAM, d2) \
+  : CommandChainBase(commandName, className, 2, t1##_PARAM, d1, t2##_PARAM, d2) \
   { \
     this->functorType = SHELLCOMMANDTYPE; \
@@ -260 +260 @@
 
 //! creates a command that takes three parameter
-#define ShellCommandConstructor3(t1,t2,t3) \
+#define CommandChainConstructor3(t1,t2,t3) \
   void SHELLCOMMANDINCLASS(*functionPointer_3_##t1##_##t2##_##t3)(t1##_TYPE, t2##_TYPE, t3##_TYPE); \
   SHELLCOMMAND(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE), t1##_TYPE d1, t2##_TYPE d2, t3##_TYPE d3) \
-  : ShellCommandBase(commandName, className, 3, t1##_PARAM, d1, t2##_PARAM, d2, t3##_PARAM, d3) \
+  : CommandChainBase(commandName, className, 3, t1##_PARAM, d1, t2##_PARAM, d2, t3##_PARAM, d3) \
   { \
     this->functorType = SHELLCOMMANDTYPE; \
@@ -270 +270 @@
 
 //! creates a command that takes four parameter
-#define ShellCommandConstructor4(t1,t2,t3,t4) \
+#define CommandChainConstructor4(t1,t2,t3,t4) \
   void SHELLCOMMANDINCLASS(*functionPointer_4_##t1##_##t2##_##t3##_##t4)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE); \
   SHELLCOMMAND(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE), t1##_TYPE d1, t2##_TYPE d2, t3##_TYPE d3, t4##_TYPE d4) \
-  : ShellCommandBase(commandName, className, 4, t1##_PARAM, d1, t2##_PARAM, d2, t3##_PARAM, d3, t4##_PARAM, d4) \
+  : CommandChainBase(commandName, className, 4, t1##_PARAM, d1, t2##_PARAM, d2, t3##_PARAM, d3, t4##_PARAM, d4) \
   { \
     this->functorType = SHELLCOMMANDTYPE; \
@@ -280 +280 @@
 
 //! creates a command that takes five parameter
-#define ShellCommandConstructor5(t1,t2,t3,t4,t5) \
+#define CommandChainConstructor5(t1,t2,t3,t4,t5) \
   void SHELLCOMMANDINCLASS(*functionPointer_5_##t1##_##t2##_##t3##_##t4##_##t5)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE, t5##_TYPE); \
   SHELLCOMMAND(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE, t5##_TYPE), t1##_TYPE d1, t2##_TYPE d2, t3##_TYPE d3, t4##_TYPE d4, t5##_TYPE d5) \
-  : ShellCommandBase(commandName, className, 5, t1##_PARAM, d1, t2##_PARAM, d2, t3##_PARAM, d3, t4##_PARAM, d4, t5##_PARAM, d5) \
+  : CommandChainBase(commandName, className, 5, t1##_PARAM, d1, t2##_PARAM, d2, t3##_PARAM, d3, t4##_PARAM, d4, t5##_PARAM, d5) \
   { \
     this->functorType = SHELLCOMMANDTYPE; \
@@ -293 +293 @@
 ///////////////
 //! execute-macro for functions with no parameters
-#define ShellCommandExecute0() \
+#define CommandChainExecute0() \
   if (this->paramCount == 0) \
     SHELLCOMMANDEXECUTER(_0)()
 
 //! execute-macro for functions with one parameter
-#define ShellCommandExecute1(t1) \
+#define CommandChainExecute1(t1) \
    else if (this->paramCount == 1 && this->parameters[0] == t1##_PARAM) \
     SHELLCOMMANDEXECUTER(_1_##t1)(t1##_FUNC(parameters, t1##_DEFGRAB(0)))
 
 //! execute-macro for functions with two parameters
-#define ShellCommandExecute2(t1,t2) \
+#define CommandChainExecute2(t1,t2) \
    else if (this->paramCount == 2 && this->parameters[0] == t1##_PARAM && this->parameters[1] == t2##_PARAM) \
     SHELLCOMMANDEXECUTER(_2_##t1##_##t2)(t1##_FUNC(sub.getString(0), t1##_DEFGRAB(0)), t2##_FUNC(sub.getString(1), t2##_DEFGRAB(1)))
 
 //! execute-macro for functions with three parameters
-#define ShellCommandExecute3(t1,t2,t3) \
+#define CommandChainExecute3(t1,t2,t3) \
    else if (this->paramCount == 3 && this->parameters[0] == t1##_PARAM && this->parameters[1] == t2##_PARAM && this->parameters[2] == t3##_PARAM) \
     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)))
 
 //! execute-macro for functions with four parameters
-#define ShellCommandExecute4(t1,t2,t3,t4) \
+#define CommandChainExecute4(t1,t2,t3,t4) \
    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) \
     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)))
 
 //! execute-macro for functions with five parameters
-#define ShellCommandExecute5(t1,t2,t3,t4,t5) \
+#define CommandChainExecute5(t1,t2,t3,t4,t5) \
    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) \
     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)))
 
 
-//! keeps information about a ShellCommand
-template<class T> class ShellCommand : public ShellCommandBase
+//! keeps information about a CommandChain
+template<class T> class CommandChain : public CommandChainBase
 {
   public:
@@ -333 +333 @@
 #undef SHELLCOMMAND
 #endif
-#define SHELLCOMMAND                       ShellCommand
+#define SHELLCOMMAND                       CommandChain
 #ifdef SHELLCOMMANDEXECUTER
 #undef SHELLCOMMANDEXECUTER
@@ -345 +345 @@
 #undef SHELLCOMMANDTYPE
 #endif
-#define SHELLCOMMANDTYPE                   ShellCommand_Objective
+#define SHELLCOMMANDTYPE                   CommandChain_Objective
 //! FUNCTOR_LIST is the List of command-registerers
-#define FUNCTOR_LIST(x) ShellCommandRegister ## x
+#define FUNCTOR_LIST(x) CommandChainRegister ## x
 #include "functor_list.h"
 #undef FUNCTOR_LIST
@@ -354 +354 @@
   private:
 //! FUNCTOR_LIST is the List of CommandConstructors
-#define FUNCTOR_LIST(x) ShellCommandConstructor ## x
+#define FUNCTOR_LIST(x) CommandChainConstructor ## x
 #include "functor_list.h"
 #undef FUNCTOR_LIST
@@ -362 +362 @@
       SubString sub(parameters, true);
 //! FUNCTOR_LIST is the List of Executive Functions
-#define FUNCTOR_LIST(x) ShellCommandExecute ## x
+#define FUNCTOR_LIST(x) CommandChainExecute ## x
 #include "functor_list.h"
 #undef FUNCTOR_LIST
@@ -368 +368 @@
 };
 
-//! keeps information about a ShellCommand, that points to a Static Function
-template<class T> class ShellCommandStatic : public ShellCommandBase
+//! keeps information about a CommandChain, that points to a Static Function
+template<class T> class CommandChainStatic : public CommandChainBase
 {
   public:
@@ -378 +378 @@
 #undef SHELLCOMMAND
 #endif
-#define SHELLCOMMAND                      ShellCommandStatic
+#define SHELLCOMMAND                      CommandChainStatic
 #ifdef SHELLCOMMANDEXECUTER
 #undef SHELLCOMMANDEXECUTER
@@ -390 +390 @@
 #undef SHELLCOMMANDTYPE
 #endif
-#define SHELLCOMMANDTYPE                   ShellCommand_Static
+#define SHELLCOMMANDTYPE                   CommandChain_Static
 
 //! FUNCTOR_LIST is the List of command-registerers
-#define FUNCTOR_LIST(x) ShellCommandRegister ## x
+#define FUNCTOR_LIST(x) CommandChainRegister ## x
 #include "functor_list.h"
 #undef FUNCTOR_LIST
@@ -399 +399 @@
   private:
 //! FUNCTOR_LIST is the List of CommandConstructors
-#define FUNCTOR_LIST(x) ShellCommandConstructor ## x
+#define FUNCTOR_LIST(x) CommandChainConstructor ## x
 #include "functor_list.h"
 #undef FUNCTOR_LIST
@@ -407 +407 @@
   SubString sub(parameters, true);
 //! FUNCTOR_LIST is the List of Executive Functions
-#define FUNCTOR_LIST(x) ShellCommandExecute ## x
+#define FUNCTOR_LIST(x) CommandChainExecute ## x
 #include "functor_list.h"
 #undef FUNCTOR_LIST
@@ -414 +414 @@
 
 //! A Class, that handles aliases.
-class ShellCommandAlias
+class CommandChainAlias
 {
-  friend class ShellCommandBase;
+  friend class CommandChainBase;
   public:
     /** @returns the Name of the Alias. */
     const char* getName() const { return this->aliasName; };
     /** @returns the Command, this Alias is asociated with */
-    ShellCommandBase* getCommand() const { return this->command; };
+    CommandChainBase* getCommand() const { return this->command; };
 
   private:
     /** @param aliasName the name of the Alias @param command the Command, to associate this alias with */
-    ShellCommandAlias(const char* aliasName, ShellCommandBase* command) { this->aliasName = aliasName; this->command = command; };
+    CommandChainAlias(const char* aliasName, CommandChainBase* command) { this->aliasName = aliasName; this->command = command; };
 
   private:
     const char*         aliasName;       //!< the name of the Alias
-    ShellCommandBase*   command;         //!< a pointer to the command, this alias executes.
+    CommandChainBase*   command;         //!< a pointer to the command, this alias executes.
 };
 
-#endif /* _SHELL_COMMAND_H */
+#endif /* _COMMAND_CHAIN_H */