Changeset 5779 in orxonox.OLD for trunk/src/lib/shell

Timestamp:

Nov 26, 2005, 2:20:58 PM (19 years ago)

Author:

bensch

Message:

orxonox/trunk: ClassList is now in std::list style
ShellCommand is now in std::list style

Location:

trunk/src/lib/shell

Files:

• shell_command.cc (modified) (8 diffs)
• shell_command.h (modified) (1 diff)
• shell_command_class.cc (modified) (11 diffs)
• shell_command_class.h (modified) (3 diffs)
• shell_completion.cc (modified) (13 diffs)
• shell_completion.h (modified) (3 diffs)

trunk/src/lib/shell/shell_command.cc

@@ -47 +47 @@
   this->shellClass = ShellCommandClass::getCommandClass(className); //ClassList::IDToString(classID);
   if (this->shellClass != NULL)
-    this->shellClass->commandList->add(this);
+    this->shellClass->commandList.push_back(this);
 }
 
@@ -82 +82 @@
 void ShellCommand::unregisterCommand(const char* commandName, const char* className)
 {
-  if (ShellCommandClass::commandClassList == NULL)
+  /// FIXME
+/*  if (ShellCommandClass::commandClassList == NULL)
     ShellCommandClass::initCommandClassList();
 
@@ -89 +90 @@
  if (checkClass != NULL)
   {
-    tIterator<ShellCommand>* iterator = checkClass->commandList->getIterator();
-    ShellCommand* elem = iterator->firstElement();
-    while(elem != NULL)
-    {
-      if (!strcmp(commandName, elem->getName()))
-      {
-        checkClass->commandList->remove(elem);
-        delete elem;
+    std::list<ShellCommand*>::iterator elem;
+    for (elem = checkClass->commandList.begin(); elem != checkClass->commandList.end(); elem++)
+    {
+      if (!strcmp(commandName, (*elem)->getName()))
+      {
+        delete (*elem);
+        checkClass->commandList.remove(*elem);
         break;
       }
-      elem = iterator->nextElement();
-    }
-    delete iterator;
-
-    if (checkClass->commandList->getSize() == 0)
+    }
+
+    if (checkClass->commandList->size() == 0)
     {
       ShellCommandClass::commandClassList->remove(checkClass);
       delete checkClass;
     }
-  }
+  }*/
 }
 
@@ -132 +130 @@
   if (checkClass != NULL)
   {
-    tIterator<ShellCommand>* iterator = checkClass->commandList->getIterator();
-    ShellCommand* elem = iterator->firstElement();
-    while(elem != NULL)
-   {
-     if (!strcmp(commandName, elem->getName()))
-     {
-       PRINTF(2)("Command already registered\n");
-       delete iterator;
-       return true;
-      }
-     elem = iterator->nextElement();
-   }
-   delete iterator;
+    std::list<ShellCommand*>::const_iterator elem;
+    for (elem = checkClass->commandList.begin(); elem != checkClass->commandList.end(); elem++)
+    {
+      if (!strcmp(commandName, (*elem)->getName()))
+      {
+        PRINTF(2)("Command '%s::%s' already registered\n", className, commandName);
+        return true;
+      }
+    }
    return false;
   }
@@ -163 +157 @@
     return false;
 
-  long classID = CL_NULL;                 //< the classID retrieved from the Class.
-  ShellCommandClass* 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
-  bool emptyComplete = false;             //< if the completion input is empty string. e.g ""
-  unsigned int fktPos = 1;                //< the position of the function (needed for finding it)
-//  long completeType = SHELLC_NONE;      //< the Type we'd like to complete.
+  long classID = CL_NULL;                      //< the classID retrieved from the Class.
+  ShellCommandClass* commandClass = NULL;      //< the command class this command applies to.
+  std::list<BaseObject*>* objectList = NULL;   //< the list of Objects stored in classID
+  BaseObject* objectPointer = NULL;            //< a pointer to th Object to Execute the command on
+  bool emptyComplete = false;                  //< if the completion input is empty string. e.g ""
+  unsigned int fktPos = 1;                     //< the position of the function (needed for finding it)
+//  long completeType = SHELLC_NONE;           //< the Type we'd like to complete.
   SubString inputSplits(executionString, " \t\n,");
 
@@ -179 +173 @@
     if (ShellCommandClass::aliasList != NULL)
     {
-      tIterator<ShellCommandAlias>* itAL = ShellCommandClass::aliasList->getIterator();
-      ShellCommandAlias* elemAL = itAL->firstElement();
-      while(elemAL != NULL)
-      {
-        if (elemAL->getName() != NULL && !strcmp(elemAL->getName(), inputSplits.getString(0)) && elemAL->getCommand() != NULL &&
-            elemAL->getCommand()->shellClass != NULL )
+      list<ShellCommandAlias*>::iterator alias;
+      for (alias = ShellCommandClass::aliasList->begin(); alias != ShellCommandClass::aliasList->end(); alias++ )
+      {
+        if ((*alias)->getName() != NULL && !strcmp((*alias)->getName(), inputSplits.getString(0)) && (*alias)->getCommand() != NULL &&
+            (*alias)->getCommand()->shellClass != NULL )
         {
-          objectList = ClassList::getList(elemAL->getCommand()->shellClass->getName());
+          objectList = ClassList::getList((*alias)->getCommand()->shellClass->getName());
           if (objectList != NULL)
           {
             if (inputSplits.getCount() > 1)
-              elemAL->getCommand()->executor->execute(objectList->firstElement(), executionString+inputSplits.getOffset(1));
+              (*alias)->getCommand()->executor->execute(objectList->front(), executionString+inputSplits.getOffset(1));
             else
-              elemAL->getCommand()->executor->execute(objectList->firstElement(), "");
-            delete itAL;
+              (*alias)->getCommand()->executor->execute(objectList->front(), "");
+           return true;
+          }
+        }
+      }
+    }
+    // looking for a Matching Class
+    if (likely(ShellCommandClass::commandClassList != NULL))
+    {
+      list<ShellCommandClass*>::iterator commandClassIT;
+      for (commandClassIT = ShellCommandClass::commandClassList->begin(); commandClassIT != ShellCommandClass::commandClassList->end(); commandClassIT++)
+      {
+        if ((*commandClassIT)->getName() && !strcasecmp(inputSplits.getString(0), (*commandClassIT)->getName()))
+        {
+          //elemCL->getName();
+          classID = ClassList::StringToID((*commandClassIT)->getName());
+          commandClass = (*commandClassIT);
+          objectList = ClassList::getList(classID);
+          break;
+        }
+      }
+    }
+
+    if (commandClass != NULL && inputSplits.getCount() >= 2)
+    {
+      if (objectList != NULL)
+      {
+        // Checking for a Match in the Objects of classID (else take the first)
+        list<BaseObject*>::const_iterator object;
+        for (object = objectList->begin(); object != objectList->end(); object++)
+        {
+          if ((*object)->getName() != NULL && !strcasecmp((*object)->getName(), inputSplits.getString(1)))
+          {
+            objectPointer = (*object);
+            fktPos = 2;
+            break;
+          }
+         }
+
+      //
+        if (objectPointer == NULL)
+          objectPointer = objectList->front();
+      }
+      // match a function.
+      if (commandClass != NULL && (fktPos == 1 || (fktPos == 2 && inputSplits.getCount() >= 3)))
+      {
+        list<ShellCommand*>::iterator cmdIT;
+        for (cmdIT = commandClass->commandList.begin(); cmdIT != commandClass->commandList.end(); cmdIT++)
+        {
+          if (!strcmp((*cmdIT)->getName(), inputSplits.getString(fktPos)))
+          {
+            if (objectPointer == NULL && (*cmdIT)->executor->getType() & Executor_Objective)
+              return false;
+            if (inputSplits.getCount() > fktPos+1)
+              (*cmdIT)->executor->execute(objectPointer, executionString+inputSplits.getOffset(fktPos +1));
+            else
+              (*cmdIT)->executor->execute(objectPointer, "");
             return true;
           }
         }
-        elemAL = itAL->nextElement();
-      }
-      delete itAL;
-    }
-    // looking for a Matching Class
-    if (likely(ShellCommandClass::commandClassList != NULL))
-    {
-      tIterator<ShellCommandClass>* itCL = ShellCommandClass::commandClassList->getIterator();
-      ShellCommandClass* elemCL = itCL->firstElement();
-      while(elemCL != NULL)
-      {
-        if (elemCL->getName() && !strcasecmp(inputSplits.getString(0), elemCL->getName()))
-        {
-          //elemCL->getName();
-          classID = ClassList::StringToID(elemCL->getName());
-          commandClass = elemCL;
-          objectList = ClassList::getList(classID);
-          break;
-        }
-        elemCL = itCL->nextElement();
-      }
-      delete itCL;
-    }
-
-    if (commandClass != NULL && inputSplits.getCount() >= 2)
-    {
-      if (objectList != NULL)
-      {
-        // Checking for a Match in the Objects of classID (else take the first)
-        tIterator<BaseObject>* itBO = objectList->getIterator();
-        BaseObject* enumBO = itBO->firstElement();
-        while(enumBO)
-        {
-          if (enumBO->getName() != NULL && !strcasecmp(enumBO->getName(), inputSplits.getString(1)))
-          {
-            objectPointer = enumBO;
-            fktPos = 2;
-            break;
-          }
-          enumBO = itBO->nextElement();
-         }
-         delete itBO;
-
-      //
-        if (objectPointer == NULL)
-          objectPointer = objectList->firstElement();
-      }
-      // match a function.
-      if (commandClass != NULL && (fktPos == 1 || (fktPos == 2 && inputSplits.getCount() >= 3)))
-      {
-        tIterator<ShellCommand>* itCMD = commandClass->commandList->getIterator();
-        ShellCommand* enumCMD = itCMD->firstElement();
-        while (enumCMD != NULL)
-        {
-          if (!strcmp(enumCMD->getName(), inputSplits.getString(fktPos)))
-          {
-            if (objectPointer == NULL && enumCMD->executor->getType() & Executor_Objective)
-            {
-              delete itCMD;
-              return false;
-            }
-            if (inputSplits.getCount() > fktPos+1)
-              enumCMD->executor->execute(objectPointer, executionString+inputSplits.getOffset(fktPos +1));
-            else
-              enumCMD->executor->execute(objectPointer, "");
-            delete itCMD;
-            return true;
-          }
-
-          enumCMD = itCMD->nextElement();
-        }
-        delete itCMD;
       }
     }
@@ -306 +282 @@
   {
     if (ShellCommandClass::aliasList == NULL)
-      ShellCommandClass::aliasList = new tList<ShellCommandAlias>;
+      ShellCommandClass::aliasList = new std::list<ShellCommandAlias*>;
 
     ShellCommandAlias* aliasCMD = new ShellCommandAlias(alias, this);
-    ShellCommandClass::aliasList->add(aliasCMD);
+    ShellCommandClass::aliasList->push_back(aliasCMD);
     this->alias = aliasCMD;
   }
@@ -348 +324 @@
   }
 
-  tIterator<ShellCommandClass>* iteratorCL = ShellCommandClass::commandClassList->getIterator();
-  ShellCommandClass* elemCL = iteratorCL->firstElement();
-  while(elemCL != NULL)
-  {
-    PRINT(0)("Class:'%s' registered %d commands: \n", elemCL->className, elemCL->commandList->getSize());
-    tIterator<ShellCommand>* iterator = elemCL->commandList->getIterator();
-    const ShellCommand* elem = iterator->firstElement();
-    while(elem != NULL)
-    {
-      PRINT(0)("  command:'%s' : params:%d: ", elem->getName(), elem->executor->getParamCount());
+  list<ShellCommandClass*>::iterator classIT;
+  for (classIT = ShellCommandClass::commandClassList->begin(); classIT != ShellCommandClass::commandClassList->end(); classIT++)
+  {
+    PRINT(0)("Class:'%s' registered %d commands: \n", (*classIT)->className, (*classIT)->commandList.size());
+
+    list<ShellCommand*>::iterator cmdIT;
+    for (cmdIT = (*classIT)->commandList.begin(); cmdIT != (*classIT)->commandList.end(); cmdIT++)
+    {
+      PRINT(0)("  command:'%s' : params:%d: ", (*cmdIT)->getName(), (*cmdIT)->executor->getParamCount());
       /// FIXME
       /*      for (unsigned int i = 0; i< elem->paramCount; i++)
        printf("%s ", ShellCommand::paramToString(elem->parameters[i]));*/
-      if (elem->description != NULL)
-       printf("- %s", elem->description);
+      if ((*cmdIT)->description != NULL)
+       printf("- %s", (*cmdIT)->description);
       printf("\n");
 
-      elem = iterator->nextElement();
-    }
-    delete iterator;
-    elemCL = iteratorCL->nextElement();
-  }
-  delete iteratorCL;
+    }
+  }
 }
 

trunk/src/lib/shell/shell_command.h

@@ -108 +108 @@
 
   private:
-    const char*         aliasName;       //!< the name of the Alias
+    const char*     aliasName;       //!< the name of the Alias
     ShellCommand*   command;         //!< a pointer to the command, this alias executes.
 };

trunk/src/lib/shell/shell_command_class.cc

@@ -29 +29 @@
 using namespace std;
 
-tList<ShellCommandClass>* ShellCommandClass::commandClassList = NULL;
-tList<ShellCommandAlias>* ShellCommandClass::aliasList = NULL;
+std::list<ShellCommandClass*>* ShellCommandClass::commandClassList = NULL;
+std::list<ShellCommandAlias*>* ShellCommandClass::aliasList = NULL;
 
 /**
@@ -43 +43 @@
   this->className = className;
   this->classID = CL_NULL;
-  this->commandList = new tList<ShellCommand>;
-
-  ShellCommandClass::commandClassList->add(this);
+
+  ShellCommandClass::commandClassList->push_back(this);
 }
 
@@ -53 +52 @@
 ShellCommandClass::~ShellCommandClass()
 {
-  tIterator<ShellCommand>* iterator = this->commandList->getIterator();
-  ShellCommand* elem = iterator->firstElement();
-  while(elem != NULL)
-  {
-    delete elem;
-    elem = iterator->nextElement();
-  }
-  delete iterator;
-  delete this->commandList;
+  while(this->commandList.size() > 0)
+  {
+    delete this->commandList.front();
+    this->commandList.pop_front();
+  }
 }
 
@@ -70 +65 @@
  * @returns true on success, false otherwise
  */
-bool ShellCommandClass::getCommandListOfClass(const char* className, tList<const char>* stringList)
+bool ShellCommandClass::getCommandListOfClass(const char* className, std::list<const char*>* stringList)
 {
   if (stringList == NULL || className == NULL)
     return false;
 
-  tIterator<ShellCommandClass>* iterator = ShellCommandClass::commandClassList->getIterator();
-  ShellCommandClass* elem = iterator->firstElement();
-  while(elem != NULL)
-  {
-    if (!strcmp (elem->getName(), className))
-    {
-      tIterator<ShellCommand>* itFkt = elem->commandList->getIterator();
-      ShellCommand* command = itFkt->firstElement();
-      while (command != NULL)
-      {
-        stringList->add(command->getName());
-        command = itFkt->nextElement();
-      }
-      delete itFkt;
-    }
-
-    elem = iterator->nextElement();
-  }
-  delete iterator;
+  list<ShellCommandClass*>::iterator elem;
+  for(elem = ShellCommandClass::commandClassList->begin(); elem != ShellCommandClass::commandClassList->end(); elem++)
+  {
+    if (!strcmp ((*elem)->getName(), className))
+    {
+      list<ShellCommand*>::iterator command;
+      for(command = (*elem)->commandList.begin(); command != (*elem)->commandList.end(); command++)
+        stringList->push_back((*command)->getName());
+    }
+  }
   return true;
 }
@@ -102 +88 @@
  * @returns true on success, false otherwise
  */
-bool ShellCommandClass::getCommandListOfAlias(tList<const char>* stringList)
+bool ShellCommandClass::getCommandListOfAlias(std::list<const char*>* stringList)
 {
   if (stringList == NULL || ShellCommandClass::aliasList == NULL)
     return false;
 
-  tIterator<ShellCommandAlias>* iterator = ShellCommandClass::aliasList->getIterator();
-   ShellCommandAlias* elem = iterator->firstElement();
-   while(elem != NULL)
-   {
-     stringList->add(elem->getName());
-     elem = iterator->nextElement();
-   }
-   delete iterator;
-   return true;
+  list<ShellCommandAlias*>::iterator alias;
+  for (alias = ShellCommandClass::aliasList->begin(); alias != ShellCommandClass::aliasList->end(); alias++)
+    stringList->push_back((*alias)->getName());
+  return true;
 }
 
@@ -123 +104 @@
 void ShellCommandClass::unregisterAllCommands()
 {
-  if (ShellCommandClass::commandClassList != NULL)
+  /// FIXME
+
+  /*  if (ShellCommandClass::commandClassList != NULL)
   {
     // unregister all commands
@@ -153 +136 @@
     delete ShellCommandClass::aliasList;
     ShellCommandClass::aliasList = NULL;
-  }
+  }*/
 }
 
@@ -166 +149 @@
     initCommandClassList();
 
-  tIterator<ShellCommandClass>* iterator = ShellCommandClass::commandClassList->getIterator();
-  ShellCommandClass* elem = iterator->firstElement();
-  while(elem != NULL)
-  {
-    if (!strcmp(className, elem->className))
-    {
-      if (elem->classID == CL_NULL)
-        elem->classID = ClassList::StringToID(className);
-
-      delete iterator;
-      return elem;
-    }
-    elem = iterator->nextElement();
-  }
-  delete iterator;
+  list<ShellCommandClass*>::const_iterator classIT;
+  for (classIT = ShellCommandClass::commandClassList->begin(); classIT != ShellCommandClass::commandClassList->end(); classIT++)
+  {
+    if (!strcmp(className, (*classIT)->className))
+    {
+      if ((*classIT)->classID == CL_NULL)
+        (*classIT)->classID = ClassList::StringToID(className);
+
+      return (*classIT);
+    }
+  }
   return NULL;
 }
@@ -194 +173 @@
     initCommandClassList();
 
-  tIterator<ShellCommandClass>* iterator = ShellCommandClass::commandClassList->getIterator();
-  ShellCommandClass* elem = iterator->firstElement();
-  while(elem != NULL)
-  {
-    if (!strcmp(className, elem->className))
-    {
-      delete iterator;
-      return elem;
-    }
-    elem = iterator->nextElement();
-  }
-  delete iterator;
+  list<ShellCommandClass*>::iterator classIT;
+  for (classIT = ShellCommandClass::commandClassList->begin(); classIT != ShellCommandClass::commandClassList->end(); classIT++)
+  {
+    if (!strcmp(className, (*classIT)->className))
+    {
+      return (*classIT);
+    }
+  }
   return new ShellCommandClass(className);
 }
@@ -216 +191 @@
   if (ShellCommandClass::commandClassList == NULL)
   {
-    ShellCommandClass::commandClassList = new tList<ShellCommandClass>;
+    ShellCommandClass::commandClassList = new std::list<ShellCommandClass*>;
     ShellCommand::registerCommand("debug", "ShellCommand", ExecutorStatic<ShellCommand>(ShellCommand::debug));
   }
@@ -231 +206 @@
   if (likely(ShellCommandClass::commandClassList != NULL))
   {
-    tIterator<ShellCommandClass>* itCL = ShellCommandClass::commandClassList->getIterator();
-    ShellCommandClass* elemCL = itCL->firstElement();
-    while(elemCL != NULL)
-    {
-      if (elemCL->className && !strcasecmp(className, elemCL->className))
+    list<ShellCommandClass*>::iterator classIT;
+    for (classIT = ShellCommandClass::commandClassList->begin(); classIT != ShellCommandClass::commandClassList->end(); classIT++)
+    {
+      if ((*classIT)->className && !strcasecmp(className, (*classIT)->className))
       {
-        PRINT(0)("Class:'%s' registered %d commands: \n", elemCL->className, elemCL->commandList->getSize());
-        tIterator<ShellCommand>* iterator = elemCL->commandList->getIterator();
-        const ShellCommand* elem = iterator->firstElement();
-        while(elem != NULL)
+        PRINT(0)("Class:'%s' registered %d commands: \n", (*classIT)->className, (*classIT)->commandList.size());
+        list<ShellCommand*>::const_iterator cmdIT;
+        for (cmdIT = (*classIT)->commandList.begin(); cmdIT != (*classIT)->commandList.end(); cmdIT++)
         {
-          PRINT(0)("  command:'%s' : params:%d: ", elem->getName(), elem->executor->getParamCount());
+          PRINT(0)("  command:'%s' : params:%d: ", (*cmdIT)->getName(), (*cmdIT)->executor->getParamCount());
           /// FIXME
           /*          for (unsigned int i = 0; i< elem->paramCount; i++)
             PRINT(0)("%s ", ShellCommand::paramToString(elem->parameters[i]));*/
-          if (elem->description != NULL)
-            PRINT(0)("- %s", elem->description);
+          if ((*cmdIT)->description != NULL)
+            PRINT(0)("- %s", (*cmdIT)->description);
           PRINT(0)("\n");
-          elem = iterator->nextElement();
         }
-        delete iterator;
-
-        delete itCL;
         return;
       }
-      elemCL = itCL->nextElement();
-    }
-    delete itCL;
+    }
     PRINTF(3)("Class %s not found in Command's classes\n", className);
   }

trunk/src/lib/shell/shell_command_class.h

@@ -8 +8 @@
 
 #include "base_object.h"
+#include <list>
 
 
@@ -26 +27 @@
   public:
     /** @returns the CommandClassList */
-    static const tList<ShellCommandClass>* getCommandClassList() { return ShellCommandClass::commandClassList; };
-    static bool getCommandListOfClass(const char* className, tList<const char>* stringList);
-    static bool getCommandListOfAlias(tList<const char>* aliasList);
+    static const std::list<ShellCommandClass*>* getCommandClassList() { return ShellCommandClass::commandClassList; };
+    static bool getCommandListOfClass(const char* className, std::list<const char*>* stringList);
+    static bool getCommandListOfAlias(std::list<const char*>* aliasList);
 
     static ShellCommandClass* getCommandClass(const char* className);
@@ -43 +44 @@
 
   private:
-    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<ShellCommand>*             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)
+    const char*                            className;                 //!< The Name of the Class. This should match the ClassName of the Commands Class.
+    long                                   classID;                   //!< The classID of this Class
+    std::list<ShellCommand*>               commandList;               //!< A list of Commands from this Class
+    static std::list<ShellCommandClass*>*  commandClassList;          //!< A list of Classes
+    static std::list<ShellCommandAlias*>*  aliasList;                 //!< An Alias to A Command. (only for classes with one Instance)
 };
 

trunk/src/lib/shell/shell_completion.cc

@@ -63 +63 @@
 bool ShellCompletion::autoComplete(ShellInput* input)
 {
-  const char* completionLine;      //< the inputLine we complete.
-
-  long classID;                    //< the classID retrieved from the Class.
-  tList<BaseObject>* objectList;   //< the list of Objects stored in classID
-  bool emptyComplete = false;      //< if the completion input is empty string. e.g ""
-  long completeType = SHELLC_NONE; //< the Type we'd like to complete.
-  const char* completeString;      //< the string to complete.
+  const char* completionLine;           //< the inputLine we complete.
+
+  long classID;                         //< the classID retrieved from the Class.
+  std::list<BaseObject*>* objectList;   //< the list of Objects stored in classID
+  bool emptyComplete = false;           //< if the completion input is empty string. e.g ""
+  long completeType = SHELLC_NONE;      //< the Type we'd like to complete.
+  const char* completeString;           //< the string to complete.
 
 
@@ -159 +159 @@
   if (unlikely(classBegin == NULL))
     return false;
-  const tList<const char>* clList = ClassList::getClassList();
+  const std::list<const char*>* clList = ClassList::getClassList();
   if (clList != NULL)
   {
@@ -180 +180 @@
   if (unlikely(objectBegin == NULL))
     return false;
-  const tList<BaseObject>* boList = ClassList::getList(classID);
+  const std::list<BaseObject*>* boList = ClassList::getList(classID);
   if (boList != NULL)
   {
@@ -203 +203 @@
   if (unlikely(functionBegin == NULL))
     return false;
-  tList<const char> fktList;
+  std::list<const char*> fktList;
   ShellCommandClass::getCommandListOfClass(className, &fktList);
   //printf("%s\n", boList->firstElement()->getName());
@@ -220 +220 @@
   if (unlikely(aliasBegin == NULL))
     return false;
-  tList<const char> aliasList;
+  std::list<const char*> aliasList;
   ShellCommandClass::getCommandListOfAlias(&aliasList);
   //printf("%s\n", boList->firstElement()->getName());
@@ -241 +241 @@
   if (completionList == NULL || this->input == NULL )
     return false;
-  if (completionList->getSize() == 0)
-    return false;
-
-  ShellC_Element* addElem = completionList->firstElement();
+  if (completionList->size() == 0)
+    return false;
+
+  ShellC_Element* addElem = completionList->front();
   const char* addString = addElem->name;
   unsigned int addLength = 0;
@@ -252 +252 @@
   if (addString != NULL)
     addLength = strlen(addString);
-  tIterator<ShellC_Element>* charIterator = completionList->getIterator();
-  ShellC_Element* charElem = charIterator->firstElement();
+
   SHELLC_TYPE changeType = SHELLC_NONE;
-  while (charElem != NULL)
-  {
-    if (charElem->type != changeType)
+  list<ShellC_Element*>::iterator charIT;
+  for (charIT = completionList->begin(); charIT != completionList->end(); charIT++)
+  {
+    if ((*charIT)->type != changeType)
     {
       if (changeType != SHELLC_NONE)
         PRINT(0)("\n");
-      PRINT(0)("%s: ", ShellCompletion::typeToString(charElem->type));
-      changeType = charElem->type;
-    }
-    PRINTF(0)("%s ", charElem->name);
+      PRINT(0)("%s: ", ShellCompletion::typeToString((*charIT)->type));
+      changeType = (*charIT)->type;
+    }
+    PRINTF(0)("%s ", (*charIT)->name);
     for (unsigned int i = inputLenght; i < addLength; i++)
-      if (addString[i] != charElem->name[i])
+      if (addString[i] != (*charIT)->name[i])
       {
        addLength = i;
 //       break;
       }
-    charElem = charIterator->nextElement();
-  }
-  delete charIterator;
+  }
   PRINT(0)("\n");
 
@@ -287 +285 @@
      this->input->addCharacters(adder);
 
-      if (completionList->getSize() == 1)
+      if (completionList->size() == 1)
       {
         if ( addBack != NULL )
@@ -305 +303 @@
  * !! The strings MUST NOT be deleted !!
  */
-bool ShellCompletion::addToCompleteList(const tList<const char>* inputList, const char* completionBegin, SHELLC_TYPE type)
+bool ShellCompletion::addToCompleteList(const std::list<const char*>* inputList, const char* completionBegin, SHELLC_TYPE type)
 {
   if (inputList == NULL || completionBegin == NULL)
@@ -311 +309 @@
   unsigned int searchLength = strlen(completionBegin);
 
-  tIterator<const char>* iterator = inputList->getIterator();
-  const char* enumString = iterator->firstElement();
-  while (enumString != NULL)
-  {
-    if (strlen(enumString) >= searchLength &&
-        !strncasecmp(enumString, completionBegin, searchLength))
-    {
-      printf("%s\n", enumString);
+  list<const char*>::const_iterator string;
+  for (string = inputList->begin(); string != inputList->end(); string++)
+  {
+    if (strlen(*string) >= searchLength &&
+        !strncasecmp(*string, completionBegin, searchLength))
+    {
+      printf("%s\n", *string);
       ShellC_Element* newElem = new ShellC_Element;
-      newElem->name = enumString;
+      newElem->name = *string;
       newElem->type = type;
-      this->completionList->add(newElem);
-    }
-    enumString = iterator->nextElement();
-  }
-  delete iterator;
-
+      this->completionList->push_back(newElem);
+    }
+  }
   return true;
 }
@@ -337 +331 @@
  * !! The strings MUST NOT be deleted !!
  */
-bool ShellCompletion::addToCompleteList(const tList<BaseObject>* inputList, const char* completionBegin, SHELLC_TYPE type)
+bool ShellCompletion::addToCompleteList(const std::list<BaseObject*>* inputList, const char* completionBegin, SHELLC_TYPE type)
 {
   if (inputList == NULL || completionBegin == NULL)
@@ -343 +337 @@
   unsigned int searchLength = strlen(completionBegin);
 
-  tIterator<BaseObject>* iterator = inputList->getIterator();
-  BaseObject* enumBO = iterator->firstElement();
-  while (enumBO != NULL)
-  {
-    if (enumBO->getName() != NULL &&
-        strlen(enumBO->getName()) >= searchLength &&
-        !strncasecmp(enumBO->getName(), completionBegin, searchLength))
+  list<BaseObject*>::const_iterator bo;
+  for(bo = inputList->begin(); bo != inputList->end(); bo++)
+  {
+    if ((*bo)->getName() != NULL &&
+        strlen((*bo)->getName()) >= searchLength &&
+        !strncasecmp((*bo)->getName(), completionBegin, searchLength))
     {
       ShellC_Element* newElem = new ShellC_Element;
-      newElem->name = enumBO->getName();
+      newElem->name = (*bo)->getName();
       newElem->type = type;
-      this->completionList->add(newElem);
-    }
-    enumBO = iterator->nextElement();
-  }
-  delete iterator;
+      this->completionList->push_back(newElem);
+    }
+  }
 
   return true;
@@ -372 +363 @@
   if (this->completionList != NULL)
   {
-    tIterator<ShellC_Element>* elemIT = this->completionList->getIterator();
-    ShellC_Element* elem = elemIT->firstElement();
-    while (elem != NULL)
-    {
-      delete elem;
-      elem = elemIT->nextElement();
-    }
-    delete this->completionList;
-  }
-  this->completionList = new tList<ShellC_Element>;
+    while (this->completionList->size() > 0)
+    {
+      delete this->completionList->front();
+      this->completionList->pop_front();
+    }
+  }
 }
 

trunk/src/lib/shell/shell_completion.h

@@ -9 +9 @@
 #ifndef _SHELL_COMPLETION_H
 #define _SHELL_COMPLETION_H
+
+#include <list>
 
 // FORWARD DECLARATION
@@ -51 +53 @@
   bool generalComplete(const char* begin, const char* displayAs = "%s", const char* addBack = NULL, const char* addFront = NULL);
 
-  bool addToCompleteList(const tList<const char>* inputList, const char* completionBegin, SHELLC_TYPE type);
-  bool addToCompleteList(const tList<BaseObject>* inputList, const char* completionBegin, SHELLC_TYPE type);
+  bool addToCompleteList(const std::list<const char*>* inputList, const char* completionBegin, SHELLC_TYPE type);
+  bool addToCompleteList(const std::list<BaseObject*>* inputList, const char* completionBegin, SHELLC_TYPE type);
   void emptyCompletionList();
 
@@ -58 +60 @@
 
  private:
-   tList<ShellC_Element>*   completionList;          //!< A list of completions, that are io.
-   ShellInput*              input;                   //!< the input this completion works on.
+   std::list<ShellC_Element*>*  completionList;          //!< A list of completions, that are io.
+   ShellInput*                  input;                   //!< the input this completion works on.
 };