Changeset 9675 in orxonox.OLD for trunk

Timestamp:

Aug 21, 2006, 10:57:35 PM (18 years ago)

Author:

bensch

Message:

orxonox/trunk: more Implementation of Functionality.
Introduced map for fast search of ID/Name pairs.
This will also be used to speedup the Factory create-process

Location:

trunk/src/lib

Files:

• lang/new_object_list.cc (modified) (2 diffs)
• lang/new_object_list.h (modified) (4 diffs)
• lang/test_object_list.cc (modified) (5 diffs)
• util/loading/factory.cc (modified) (6 diffs)

trunk/src/lib/lang/new_object_list.cc

@@ -23 +23 @@
     : _id(-1), _name(className)
 {
-  if (NewObjectListBase::_classes == NULL)
-    NewObjectListBase::_classes = new cSet;
+  if (NewObjectListBase::_classesByID == NULL)
+  {
+    NewObjectListBase::_classesByID = new classIDMap;
+    assert (NewObjectListBase::_classesByName == NULL);
+    NewObjectListBase::_classesByName = new classNameMap;
+  }
+  assert(!NewObjectListBase::classNameExists(className) && "Classes should only be included once, and no two classes should have the same name/ID (key value)");
 
-
-  assert(!NewObjectListBase::classNameExists(className) && "Classes should not be included once, and no two classes should have the same name (key value)");
 
   this->_id = NewObjectListBase::_idCounter++;
 
+  (*NewObjectListBase::_classesByID)[this->_id] = this;
+  (*NewObjectListBase::_classesByName)[this->_name] = this;
 }
 
 NewObjectListBase::~NewObjectListBase()
 {
+  NewObjectListBase::_classesByName->erase(this->_name);
+  NewObjectListBase::_classesByID->erase(this->_id);
 
+  if (NewObjectListBase::_classesByID->empty())
+  {
+    delete NewObjectListBase::_classesByID;
+    NewObjectListBase::_classesByID = NULL;
+    assert(NewObjectListBase::_classesByName != NULL);
+    delete NewObjectListBase::_classesByName;
+    NewObjectListBase::_classesByName = NULL;
+  }
 }
 
 int NewObjectListBase::_idCounter = 0;
-NewObjectListBase::cSet* NewObjectListBase::_classes = NULL;
+NewObjectListBase::classIDMap* NewObjectListBase::_classesByID = NULL;
+NewObjectListBase::classNameMap* NewObjectListBase::_classesByName = NULL;
 
 
@@ -50 +66 @@
 bool NewObjectListBase::classNameExists(const std::string& name)
 {
-  cSet::iterator it;
-  for (it = NewObjectListBase::_classes->begin(); it != NewObjectListBase::_classes->end(); it++)
-    if(*it != NULL && (*it)->name() != name)
-      return true;
-  return false;
+  return (NewObjectListBase::_classesByName->find(name) != NewObjectListBase::_classesByName->end());
+  //  classNameMap::iterator it;
+  //   for (it = NewObjectListBase::_classesByID->begin(); it != NewObjectListBase::_classesByID->end(); it++)
+  //     if(*it != NULL && (*it)->name() != name)
+  //       return true;
+  //   return false;
 }
+
+
+/**
+ * @brief Converts an ID into a ClassName String.
+ * @param classID The ID to convert.
+ * @return The ClassName or an empty string if the ID was not found.
+ */
+const std::string& NewObjectListBase::IDToString(int classID)
+{
+  assert (NewObjectListBase::_classesByID != NULL);
+  NewObjectListBase::classIDMap::iterator it = NewObjectListBase::_classesByID->find(classID);
+  if (it != NewObjectListBase::_classesByID->end())
+    return (*it).second->name();
+  else
+  {
+    static std::string empty;
+    return empty;
+  }
+}
+
+
+/**
+ * @brief Converts a String into an ID
+ * @param className the Name of the Class to search for
+ * @return The Classes ID if found, -1 otherwise.
+ */
+int NewObjectListBase::StringToID(const std::string& className)
+{
+  assert (NewObjectListBase::_classesByName != NULL);
+  NewObjectListBase::classNameMap::iterator it = NewObjectListBase::_classesByName->find(className);
+  if (it != NewObjectListBase::_classesByName->end())
+    return (*it).second->id();
+  else
+    return -1;
+}
+

trunk/src/lib/lang/new_object_list.h

@@ -9 +9 @@
 
 #include "type_info.h"
-#include <set>
+#include <map>
 #include <list>
-#include <vector>
 #include <string>
 
@@ -33 +32 @@
 
 public:
-  int id() const { return _id; };
-  const std::string& name() const { return _name; };
+  inline int id() const { return _id; };
+  inline const std::string& name() const { return _name; };
   bool operator==(int id) const { return _id == id; };
   bool operator==(const std::string& name) const { return _name == name; };
@@ -40 +39 @@
 
   /// Comparing operators.
-  bool compareName(const NewObjectListBase& more) const { return this->_name < more.name(); };
-  bool compareID(const NewObjectListBase& more) const { return this->_id < more.id(); };
+//   struct CompareID  {
+//     bool operator()(const NewObjectListBase* less, const NewObjectListBase* more) { return less->id() < more->id(); };
+//   };
+//   struct CompareName{
+//     bool operator()(const NewObjectListBase* less, const NewObjectListBase* more) { return less->name() < more->name(); };
+//   };
 
   virtual void debug() const = 0;
@@ -63 +66 @@
 
 protected:
-  typedef std::set<NewObjectListBase*>     cSet;    //!< The Generic Set.
-  typedef std::vector<NewObjectListBase*>  cVector; //!< The
+  typedef std::map<int, NewObjectListBase*> classIDMap;    //!< The Generic Map.
+  typedef std::map<std::string, NewObjectListBase*> classNameMap;//!< The Generic Map.
 
   int                           _id;                //!< The ID of the class.
   std::string                   _name;              //!< The Name of the Class.
 
-  cVector                       _typeOfList;        //!< A List of all classes this class is derived of, and the class itself, ordered by age of addition.
-  cSet                          _typeOfSet;         //!< A Set of all classes this is derived from and the class itself (for isA).
 private:
 
   static int                    _idCounter;         //!< A counter, that gives all classes a Unique ClassID. Access to this Variable is to be Thread-Safe.
-  static cSet*                  _classes;           //!< A Set of all the classes in existance.
+  static classIDMap*            _classesByID;       //!< A Map of all the classes in existance.
+  static classNameMap*          _classesByName;     //!< A Map of all the classes in existance.
   static std::list<std::string> _classNames;        //!< A list of all the registered ClassNames.
 };

trunk/src/lib/lang/test_object_list.cc

@@ -8 +8 @@
 {
 public:
-  void setName(const std::string& name) { this->_objectName = name; };
-  const std::string& getName() const { return _objectName; };
-  bool operator==(const std::string& name) const { return _objectName == name; };
+  //   void setName(const std::string& name) { this->_objectName = name; };
+     const std::string& getName() const { return _objectName; };
+  //   bool operator==(const std::string& name) const { return _objectName == name; };
 
-  NewObjectListDeclaration(NewBaseObject);
+  //  NewObjectListDeclaration(NewBaseObject);
 
 protected:
   NewBaseObject(const std::string& objectName = "") : _objectName(objectName)
   {
-    this->registerObject(this, objectList);
+    //    this->registerObject(this, objectList);
   };
   template<class T>
@@ -27 +27 @@
 
 };
-NewObjectListDefinition(NewBaseObject);
+//NewObjectListDefinition(NewBaseObject);
 
 
-class Test : public NewBaseObject
+class Test :
+      public   NewBaseObject
+//    ,
+//      public BaseObject
 {
 public:
@@ -44 +47 @@
 Test::Test()
 {
+  this->registerObject(this, Test::objectList);
 //  this->setClassID(CL_PARENT_NODE, "Test");
-  this->registerObject(this, Test::objectList);
   // std::cout << "Test()\n";
 };
@@ -58 +61 @@
   Bone()
   {
-//    this->registerObject(this, Bone::objectList);
+    //    this->registerObject(this, Bone::objectList);
     //std::cout << "Bone()\n";
   };
@@ -75 +78 @@
     std::cout<< i << std::endl;
     Test* test = new Test[10000];
-    delete[]test;
+    // delete[]test;
   }
   //   char tmp[100];

trunk/src/lib/util/loading/factory.cc

@@ -29 +29 @@
  */
 Factory::Factory (const std::string& factoryName, ClassID classID)
-  : classID(classID), className(factoryName)
+    : classID(classID), className(factoryName)
 {
   this->setClassID(CL_FACTORY, "Factory");
@@ -86 +86 @@
 bool Factory::operator==(const char* className) const
 {
-  return(className != NULL && this->className == className);
+  return (className != NULL && this->className == className);
 }
 
@@ -96 +96 @@
 bool Factory::operator==(const std::string& className) const
 {
-  return(this->className == className);
+  return (this->className == className);
 }
 
@@ -105 +105 @@
  * @returns a new Object of Type root->Value() on match, NULL otherwise
  */
- BaseObject* Factory::fabricate(const TiXmlElement* root)
+BaseObject* Factory::fabricate(const TiXmlElement* root)
 {
-  if (root == NULL || Factory::factoryList == NULL)
-    return NULL;
+  assert (root != NULL && Factory::factoryList != NULL);
 
   std::list<Factory*>::const_iterator factory;
   for (factory = Factory::factoryList->begin(); factory != Factory::factoryList->end(); factory++)
     if (*(*factory) == root->Value())
-      break;
+    {
+      PRINTF(2)("Create a new Object of type %s\n", (*factory)->getCName());
+      return (*factory)->fabricateObject(root);
+    }
 
-  if (factory != Factory::factoryList->end())
-  {
-    PRINTF(2)("Create a new Object of type %s\n", (*factory)->getCName());
-    return (*factory)->fabricateObject(root);
-  }
-  else
-  {
-    PRINTF(2)("Could not Fabricate an Object of Class '%s'\n", root->Value());
-    return NULL;
-  }
+  PRINTF(2)("Could not Fabricate an Object of Class '%s'\n", root->Value());
+  return NULL;
 }
 
 
 /**
- * Creates a new Object of type className
+ * @brief Creates a new Object of type className
  * @param className the ClassName to match for the newly created Object
  * @returns a new Object of Type className on match, NULL otherwise
  */
- BaseObject* Factory::fabricate(const std::string& className)
+BaseObject* Factory::fabricate(const std::string& className)
 {
   if (Factory::factoryList == NULL)
@@ -141 +135 @@
   for (factory = Factory::factoryList->begin(); factory != Factory::factoryList->end(); factory++)
     if (*(*factory) == className)
-      break;
-
-  if (factory != Factory::factoryList->end())
-  {
-    PRINTF(4)("Create a new Object of type %s\n", (*factory)->getCName());
-    return (*factory)->fabricateObject(NULL);
-  }
-  else
-  {
-    PRINTF(2)("Could not Fabricate an Object of Class '%s'\n", className.c_str());
-    return NULL;
-  }
+    {
+      PRINTF(4)("Create a new Object of type %s\n", (*factory)->getCName());
+      return (*factory)->fabricateObject(NULL);
+    }
+  PRINTF(2)("Could not Fabricate an Object of Class '%s'\n", className.c_str());
+  return NULL;
 }
 
 
 /**
- * Creates a new Object of type classID
+ * @brief Creates a new Object of type classID
  * @param classID the ClassID to match for the newly created Object
  * @returns a new Object of Type classID on match, NULL otherwise
@@ -169 +157 @@
   for (factory = Factory::factoryList->begin(); factory != Factory::factoryList->end(); factory++)
     if (*(*factory) == classID)
-      break;
+    {
+      PRINTF(4)("Create a new Object of type %s\n", (*factory)->getCName());
+      return (*factory)->fabricateObject(NULL);
 
-  if (factory != Factory::factoryList->end())
-  {
-    PRINTF(4)("Create a new Object of type %s\n", (*factory)->getCName());
-    return (*factory)->fabricateObject(NULL);
-  }
-  else
-  {
-    PRINTF(2)("Could not Fabricate an Object of ClassID '0x%h'\n", classID);
-    return NULL;
-  }
+    }
+  PRINTF(2)("Could not Fabricate an Object of ClassID '0x%h'\n", classID);
+  return NULL;
 }