Changeset 9697 in orxonox.OLD

Timestamp:

Aug 25, 2006, 12:03:08 AM (18 years ago)

Author:

bensch

Message:

adapted shell

Location:

branches/new_class_id/src/lib/shell

Files:

• shell_command.cc (modified) (2 diffs)
• shell_command_class.cc (modified) (11 diffs)
• shell_command_class.h (modified) (1 diff)
• shell_completion.cc (modified) (7 diffs)
• shell_completion.h (modified) (2 diffs)
• shell_completion_plugin.cc (modified) (1 diff)

branches/new_class_id/src/lib/shell/shell_command.cc

@@ -241 +241 @@
       return false;
 
-    const std::list<BaseObject*>* objectList = ClassList::getList(cmd->shellClass->getName());
+    const NewObjectListBase* const objectList = NewObjectListBase::getObjectList(cmd->shellClass->getName());
     if (objectList != NULL)
     {
-      std::list<BaseObject*>::const_iterator bo;
+      NewObjectListBase::base_iterator bo(objectList->base_begin());
 
       // No Description given (only for speedup)
       if (objectDescriptor.empty())
       {
-        for (bo = objectList->begin(); bo != objectList->end(); bo++)
+        for (; bo != objectList->base_end(); bo++)
           boList->push_back(*bo);
       }
@@ -255 +255 @@
       else
       {
-        for (bo = objectList->begin(); bo != objectList->end(); bo++)
+        for (bo = objectList->base_begin(); bo != objectList->base_end(); bo++)
           if (!nocaseCmp(objectDescriptor, (*bo)->getName(), objectDescriptor.size()))
             boList->push_back(*bo);

branches/new_class_id/src/lib/shell/shell_command_class.cc

@@ -29 +29 @@
   NewObjectListDefinition(ShellCommandClass);
 
-  CmdClassList* ShellCommandClass::commandClassList = NULL;
+  CmdClassList* ShellCommandClass::_commandClassList = NULL;
 
   /**
@@ -41 +41 @@
     this->setName(className);
 
-    this->classID = CL_NULL;
-
-    if (ShellCommandClass::commandClassList == NULL)
-      ShellCommandClass::commandClassList = new CmdClassList;
-    ShellCommandClass::commandClassList->push_back(this);
+    if (ShellCommandClass::_commandClassList == NULL)
+      ShellCommandClass::_commandClassList = new CmdClassList;
+    ShellCommandClass::_commandClassList->push_back(this);
   }
 
@@ -53 +51 @@
   ShellCommandClass::~ShellCommandClass()
   {
-    while(!this->commandList.empty())
-      delete this->commandList.back();
-
-    if (ShellCommandClass::commandClassList != NULL)
-    {
-      CmdClassList::iterator delClass = std::find(ShellCommandClass::commandClassList->begin(), ShellCommandClass::commandClassList->end(), this);
-      if (delClass != ShellCommandClass::commandClassList->end())
-        ShellCommandClass::commandClassList->erase(delClass);
+    while(!this->_commandList.empty())
+      delete this->_commandList.back();
+
+    if (ShellCommandClass::_commandClassList != NULL)
+    {
+      CmdClassList::iterator delClass = std::find(ShellCommandClass::_commandClassList->begin(), ShellCommandClass::_commandClassList->end(), this);
+      if (delClass != ShellCommandClass::_commandClassList->end())
+        ShellCommandClass::_commandClassList->erase(delClass);
     }
   }
@@ -69 +67 @@
   void ShellCommandClass::registerCommand(ShellCommand* command)
   {
-    this->commandList.push_back(command);
+    this->_commandList.push_back(command);
   }
 
@@ -78 +76 @@
   void ShellCommandClass::unregisterCommand(ShellCommand* command)
   {
-    CmdList::iterator delC = std::find(this->commandList.begin(), this->commandList.end(), command);
-    if (delC != this->commandList.end())
-      this->commandList.erase(delC);
+    CmdList::iterator delC = std::find(this->_commandList.begin(), this->_commandList.end(), command);
+    if (delC != this->_commandList.end())
+      this->_commandList.erase(delC);
   }
 
@@ -90 +88 @@
     // unregister all commands and Classes
     CmdClassList::iterator classIT;
-    if (ShellCommandClass::commandClassList == NULL)
+    if (ShellCommandClass::_commandClassList == NULL)
       return;
 
-    while (!ShellCommandClass::commandClassList->empty())
-      delete ShellCommandClass::commandClassList->back();
-    delete ShellCommandClass::commandClassList;
-    ShellCommandClass::commandClassList = NULL;
+    while (!ShellCommandClass::_commandClassList->empty())
+      delete ShellCommandClass::_commandClassList->back();
+    delete ShellCommandClass::_commandClassList;
+    ShellCommandClass::_commandClassList = NULL;
   }
 
@@ -108 +106 @@
   bool ShellCommandClass::getCommandListOfClass(const std::string& className, std::list<std::string>& stringList)
   {
-    if (ShellCommandClass::commandClassList == NULL)
+    if (ShellCommandClass::_commandClassList == NULL)
       return false;
 
 
     CmdClassList::const_iterator elem;
-    for(elem = ShellCommandClass::commandClassList->begin(); elem != ShellCommandClass::commandClassList->end(); elem++)
+    for(elem = ShellCommandClass::_commandClassList->begin(); elem != ShellCommandClass::_commandClassList->end(); elem++)
     {
       if (className == (*elem)->getName())
       {
         CmdList::iterator command;
-        for(command = (*elem)->commandList.begin(); command != (*elem)->commandList.end(); command++)
+        for(command = (*elem)->_commandList.begin(); command != (*elem)->_commandList.end(); command++)
           stringList.push_back((*command)->getName());
         return true;
@@ -134 +132 @@
   ShellCommandClass* ShellCommandClass::getCommandClass(const std::string& className)
   {
-    if (ShellCommandClass::commandClassList == NULL)
+    if (ShellCommandClass::_commandClassList == NULL)
       return false;
 
 
     CmdClassList::const_iterator classIT;
-    for (classIT = ShellCommandClass::commandClassList->begin(); classIT != ShellCommandClass::commandClassList->end(); classIT++)
-      if (className == (*classIT)->className)
+    for (classIT = ShellCommandClass::_commandClassList->begin(); classIT != ShellCommandClass::_commandClassList->end(); classIT++)
+      if (className == (*classIT)->_className)
         return (*classIT);
     return NULL;
@@ -153 +151 @@
   {
     return (ShellCommandClass::getCommandClass(className) != NULL);
-  }
-
-  ClassID ShellCommandClass::getClassID()
-  {
-    if (this->classID == CL_NULL)
-      this->classID = ClassList::StringToID(this->className);
-    return this->classID;
   }
 
@@ -182 +173 @@
   void ShellCommandClass::help(const std::string& className)
   {
-    if (ShellCommandClass::commandClassList == NULL)
+    if (ShellCommandClass::_commandClassList == NULL)
     {
       PRINT(0)("No Commands Registered\n");
@@ -188 +179 @@
     }
     if (className.empty())
-      PRINT(0)("===== Displaying %d registered Classes:\n", ShellCommandClass::commandClassList->size());
+      PRINT(0)("===== Displaying %d registered Classes:\n", ShellCommandClass::_commandClassList->size());
 
 
     CmdClassList::iterator classIT;
-    for (classIT = ShellCommandClass::commandClassList->begin(); classIT != ShellCommandClass::commandClassList->end(); classIT++)
-    {
-      if (className.empty() || className == (*classIT)->className)
+    for (classIT = ShellCommandClass::_commandClassList->begin(); classIT != ShellCommandClass::_commandClassList->end(); classIT++)
+    {
+      if (className.empty() || className == (*classIT)->_className)
       {
-        PRINT(0)("Class:'%s' registered %d commands: \n", (*classIT)->className.c_str(), (*classIT)->commandList.size());
+        PRINT(0)("Class:'%s' registered %d commands: \n", (*classIT)->_className.c_str(), (*classIT)->_commandList.size());
         CmdList::const_iterator cmdIT;
-        for (cmdIT = (*classIT)->commandList.begin(); cmdIT != (*classIT)->commandList.end(); cmdIT++)
+        for (cmdIT = (*classIT)->_commandList.begin(); cmdIT != (*classIT)->_commandList.end(); cmdIT++)
         {
           PRINT(0)("  command:'%s' : params:%d: ", (*cmdIT)->getCName(), (*cmdIT)->executor->getParamCount());

branches/new_class_id/src/lib/shell/shell_command_class.h

@@ -54 +54 @@
   private:
     const std::string                      _className;                 //!< The Name of the Class. This should match the ClassName of the Commands Class.
-    NewClassID                             _classID;                   //!< The classID of this Class
     CmdList                                _commandList;               //!< A list of Commands from this Class
 

branches/new_class_id/src/lib/shell/shell_completion.cc

@@ -23 +23 @@
 
 #include "substring.h"
-#include "class_list.h"
 #include "debug.h"
 
@@ -51 +50 @@
   bool ShellCompletion::autoComplete(std::string& input)
   {
-    long classID = CL_NULL;                          //< the classID retrieved from the Class.
-    const std::list<BaseObject*>* objectList = NULL; //< the list of Objects stored in classID's ClassList
+    NewClassID classID;
+    const NewObjectListBase* objectList = NULL;      //< the list of Objects stored in classID's ClassList
     bool emptyComplete = false;                      //< if the completion input is empty string. e.g ""
     long completeType = NullCompletion;              //< the Type we'd like to complete.
@@ -85 +84 @@
              (!emptyComplete && inputSplits.size() == 2))
     {
-      classID = ClassList::StringToID(inputSplits.getString(0));
-      objectList = ClassList::getList((ClassID)classID);
-      if (classID != CL_NULL)
+      objectList = NewObjectListBase::getObjectList(inputSplits[0]);
+      if (objectList != NULL)
+        classID = objectList->identity();
+      if (classID != NullClass::classID())
         completeType |= ObjectCompletion;
       completeType |= FunctionCompletion;
@@ -95 +95 @@
              (!emptyComplete && inputSplits.size() == 3))
     {
-      if (ClassList::exists(inputSplits[0], inputSplits[1]))
+      if (NewObjectListBase::getBaseObject(inputSplits[0], inputSplits[1]))
         completeType |= FunctionCompletion;
     }
@@ -113 +113 @@
 
     if (completeType & ClassCompletion)
-      this->objectComplete(completeString, CL_SHELL_COMMAND_CLASS);
+      this->objectComplete(completeString, &ShellCommandClass::objectList());
     if (completeType & ObjectCompletion)
-      this->objectComplete(completeString, classID);
+      this->objectComplete(completeString, objectList);
     if (completeType & FunctionCompletion)
       this->commandComplete(completeString, inputSplits[0]);
@@ -133 +133 @@
    * @return true on success, false otherwise
    */
-  bool ShellCompletion::objectComplete(const std::string& objectBegin, long classID)
-  {
-    const std::list<BaseObject*>* boList = ClassList::getList((ClassID)classID);
-    if (boList != NULL)
-    {
-      CompletionType type = ObjectCompletion;
-      if (classID == CL_SHELL_COMMAND_CLASS)
-        type = ClassCompletion;
-      if (!this->addToCompleteList(*boList, objectBegin, type))
-        return false;
-    }
-    else
-      return false;
+  bool ShellCompletion::objectComplete(const std::string& objectBegin, const NewObjectListBase* objectList)
+  {
+    assert (objectList != NULL);
+
+    CompletionType type = ObjectCompletion;
+    if (objectList == &ShellCommandClass::objectList())
+      type = ClassCompletion;
+
+    /// FIXME
+//     if (!this->addToCompleteList(*boList, objectBegin, type))
+//       return false;
+
     return true;
   }
@@ -321 +320 @@
     switch (type)
     {
-        default:// SHELLC_NONE
-        return typeNames[0];
-        case  ClassCompletion:
-        return typeNames[1];
-        case ObjectCompletion:
-        return typeNames[2];
-        case FunctionCompletion:
-        return typeNames[3];
-        case AliasCompletion:
-        return typeNames[4];
-        case ParamCompletion:
-        return typeNames[5];
+      default:// SHELLC_NONE
+      return typeNames[0];
+      case  ClassCompletion:
+      return typeNames[1];
+      case ObjectCompletion:
+      return typeNames[2];
+      case FunctionCompletion:
+      return typeNames[3];
+      case AliasCompletion:
+      return typeNames[4];
+      case ParamCompletion:
+      return typeNames[5];
     }
   }

branches/new_class_id/src/lib/shell/shell_completion.h

@@ -16 +16 @@
 // FORWARD DECLARATION
 class BaseObject;
+class NewObjectListBase;
 
 namespace OrxShell
@@ -53 +54 @@
 
     private:
-      bool objectComplete(const std::string& objectBegin, long classID);
+      bool objectComplete(const std::string& objectBegin, const NewObjectListBase* const objectList);
       bool commandComplete(const std::string& commandBegin, const std::string& className);
       bool aliasComplete(const std::string& aliasBegin);

branches/new_class_id/src/lib/shell/shell_completion_plugin.cc

@@ -22 +22 @@
 
 #include "substring.h"
-#include "class_list.h"
 #include "loading/resource_manager.h"