Changeset 805

Timestamp:

Feb 12, 2008, 4:24:14 PM (17 years ago)

Author:

landauf

Message:

Added two new classes:

• ClassManager, a helper class for ClassIdentifier
• IdentifierDistributor, a class that hopefully allows unique ClassIdentifiers even with several libraries

In a first try it seemed to work, but it needs more testing. At least it solved a problem I discovered yesterday with multiple Identifiers for the type "BaseObject" on windows.

Location:

code/branches/core/src/orxonox/core

Files:

• CMakeLists.txt (modified) (1 diff)
• ClassFactory.h (modified) (1 diff)
• ClassManager.h (added)
• ClassTreeMask.cc (modified) (3 diffs)
• CoreIncludes.h (modified) (3 diffs)
• CorePrereqs.h (modified) (2 diffs)
• Identifier.cc (modified) (1 diff)
• Identifier.h (modified) (12 diffs)
• IdentifierDistributor.cc (added)
• IdentifierDistributor.h (added)
• Iterator.h (modified) (1 diff)
• MetaObjectList.h (modified) (1 diff)

code/branches/core/src/orxonox/core/CMakeLists.txt

@@ -14 +14 @@
   Language.cc
   ClassTreeMask.cc
+  IdentifierDistributor.cc
 )
 

code/branches/core/src/orxonox/core/ClassFactory.h

@@ -73 +73 @@
     {
         COUT(4) << "*** Create entry for " << name << " in Factory." << std::endl;
-        ClassIdentifier<T>::getIdentifier()->addFactory(new ClassFactory<T>);
-        Factory::add(name, ClassIdentifier<T>::getIdentifier());
+        ClassManager<T>::getIdentifier(name)->addFactory(new ClassFactory<T>);
+        Factory::add(name, ClassManager<T>::getIdentifier(name));
 
         return true;

code/branches/core/src/orxonox/core/ClassTreeMask.cc

@@ -156 +156 @@
     ClassTreeMask::ClassTreeMask()
     {
-        this->root_ = new ClassTreeMaskNode(ClassIdentifier<BaseObject>::getIdentifier(), true);
+        this->root_ = new ClassTreeMaskNode(ClassManager<BaseObject>::getIdentifier("BaseObject"), true);
     }
 
@@ -227 +227 @@
     {
         delete this->root_;
-        this->root_ = new ClassTreeMaskNode(ClassIdentifier<BaseObject>::getIdentifier(), true);
+        this->root_ = new ClassTreeMaskNode(ClassManager<BaseObject>::getIdentifier("BaseObject"), true);
     }
 
@@ -237 +237 @@
     bool ClassTreeMask::isIncluded(ClassTreeMaskNode* node, const Identifier* subclass) const
     {
-std::cout << "1_0: " << ClassIdentifier<BaseObject>::getIdentifier() << std::endl;
 std::cout << "1_1: " << subclass->getName() << " (" << subclass << ") / " << node->getClass()->getName() << " (" << node->getClass() << ")" << std::endl;
         // Check if the searched subclass is of the same type as the class in the current node or a derivative

code/branches/core/src/orxonox/core/CoreIncludes.h

@@ -44 +44 @@
 // All needed header-files
 #include "Identifier.h"
+#include "ClassManager.h"
 #include "Factory.h"
 #include "ClassFactory.h"
@@ -57 +58 @@
 */
 #define InternRegisterObject(ClassName, bRootClass) \
-    this->setIdentifier(orxonox::ClassIdentifier<ClassName>::registerClass(this->getParents(), #ClassName, bRootClass)); \
+    this->setIdentifier(orxonox::ClassManager<ClassName>::getIdentifier(#ClassName)->registerClass(this->getParents(), #ClassName, bRootClass)); \
     if (orxonox::Identifier::isCreatingHierarchy() && this->getParents()) \
         this->getParents()->add(this->getIdentifier()); \
-    orxonox::ClassIdentifier<ClassName>::addObject(this)
+    orxonox::ClassManager<ClassName>::getIdentifier(#ClassName)->addObject(this)
 
 /**
@@ -111 +112 @@
 */
 #define Class(ClassName) \
-    ClassIdentifier<ClassName>::getIdentifier()
+    ClassManager<ClassName>::getIdentifier(#ClassName)
 
 /**

code/branches/core/src/orxonox/core/CorePrereqs.h

@@ -70 +70 @@
   template <class T>
   class ClassIdentifier;
+  template <class T>
+  class ClassManager;
   class ConfigValueContainer;
   class DebugLevel;
@@ -75 +77 @@
   class Factory;
   class Identifier;
+  class IdentifierDistributor;
   class IdentifierList;
   class IdentifierListElement;

code/branches/core/src/orxonox/core/Identifier.cc

@@ -118 +118 @@
     /**
         @returns a reference to the Identifier map, containing all Identifiers.
-    */
+    *//*
     std::map<std::string, Identifier*>& Identifier::getIdentifierMap()
     {
         static std::map<std::string, Identifier*> identifierMapStaticReference = std::map<std::string, Identifier*>();
         return identifierMapStaticReference;
-    }
+    }*/
 
     /**

code/branches/core/src/orxonox/core/Identifier.h

@@ -89 +89 @@
     {
         template <class T>
-        friend class ClassIdentifier; // Forward declaration
+        friend class ClassIdentifier;
 
         template <class T>
-        friend class SubclassIdentifier; // Forward declaration
-
-        friend class Factory; // Forward declaration
+        friend class SubclassIdentifier;
+
+        friend class Factory;
 
         public:
@@ -106 +106 @@
             bool isParentOf(const Identifier* identifier) const;
 
-            static std::map<std::string, Identifier*>& getIdentifierMap();
+//            static std::map<std::string, Identifier*>& getIdentifierMap();
 
             /** @brief Removes all objects of the corresponding class. */
@@ -186 +186 @@
     class ClassIdentifier : public Identifier
     {
+        template <class TT>
+        friend class ClassManager;
+
         public:
-            static ClassIdentifier<T>* registerClass(const IdentifierList* parents, const std::string& name, bool bRootClass);
-            static void addObject(T* object);
-            static ClassIdentifier<T>* getIdentifier();
+            ClassIdentifier<T>* registerClass(const IdentifierList* parents, const std::string& name, bool bRootClass);
+            void addObject(T* object);
+//            static ClassIdentifier<T>* getIdentifier();
             void removeObjects() const;
             void setName(const std::string& name);
@@ -225 +228 @@
 
         // Check if at least one object of the given type was created
-        if (!getIdentifier()->bCreatedOneObject_)
+        if (!this->bCreatedOneObject_)
         {
             // If no: We have to store the informations and initialize the Identifier
-            getIdentifier()->setName(name);
+            this->setName(name);
 
             COUT(4) << "*** Register Class in " << name << "-Singleton -> Initialize Singleton." << std::endl;
             if (bRootClass)
-                getIdentifier()->initialize(NULL); // If a class is derived from two interfaces, the second interface might think it's derived from the first because of the order of constructor-calls. Thats why we set parents to zero in that case.
+                this->initialize(NULL); // If a class is derived from two interfaces, the second interface might think it's derived from the first because of the order of constructor-calls. Thats why we set parents to zero in that case.
             else
-                getIdentifier()->initialize(parents);
+                this->initialize(parents);
         }
 
-        return getIdentifier();
+        return this;
     }
 
@@ -243 +246 @@
         @brief Creates the only instance of this class for the template class T.
         @return The Identifier itself
-    */
+    *//*
     template <class T>
     ClassIdentifier<T>* ClassIdentifier<T>::getIdentifier()
@@ -258 +261 @@
         return &theOneAndOnlyInstance;
     }
-
+*/
     /**
         @brief Sets the name of the class.
@@ -266 +269 @@
     void ClassIdentifier<T>::setName(const std::string& name)
     {
-        // Make sure we didn't already set the name, to avoid duplicate entries in the Identifier map
+//        // Make sure we didn't already set the name, to avoid duplicate entries in the Identifier map
         if (!this->bSetName_)
         {
             this->name_ = name;
-            this->getIdentifierMap().insert(std::pair<std::string, Identifier*>(name, this));
+//            this->getIdentifierMap().insert(std::pair<std::string, Identifier*>(name, this));
             this->bSetName_ = true;
         }
@@ -282 +285 @@
     void ClassIdentifier<T>::addObject(T* object)
     {
-        COUT(4) << "*** Added object to " << ClassIdentifier<T>::getIdentifier()->getName() << "-list." << std::endl;
-        object->getMetaList().add(ClassIdentifier<T>::getIdentifier()->objects_, ClassIdentifier<T>::getIdentifier()->objects_->add(object));
+        COUT(4) << "*** Added object to " << this->getName() << "-list." << std::endl;
+        object->getMetaList().add(this->objects_, this->objects_->add(object));
     }
 
@@ -314 +317 @@
             SubclassIdentifier()
             {
-                this->identifier_ = ClassIdentifier<T>::getIdentifier();
+                T* temp = new T;
+                this->subclassIdentifier_ = temp->getIdentifier();
+                delete temp;
+
+                this->identifier_ = this->subclassIdentifier_;
             }
 
@@ -324 +331 @@
             SubclassIdentifier<T>& operator=(Identifier* identifier)
             {
-                if (!identifier->isA(ClassIdentifier<T>::getIdentifier()))
+                if (!identifier->isA(this->subclassIdentifier_))
                 {
-                    COUT(1) << "Error: Class " << identifier->getName() << " is not a " << ClassIdentifier<T>::getIdentifier()->getName() << "!" << std::endl;
-                    COUT(1) << "Error: SubclassIdentifier<" << ClassIdentifier<T>::getIdentifier()->getName() << "> = Class(" << identifier->getName() << ") is forbidden." << std::endl;
+                    COUT(1) << "Error: Class " << identifier->getName() << " is not a " << this->subclassIdentifier_->getName() << "!" << std::endl;
+                    COUT(1) << "Error: SubclassIdentifier<" << this->subclassIdentifier_->getName() << "> = Class(" << identifier->getName() << ") is forbidden." << std::endl;
                     COUT(1) << "Aborting..." << std::endl;
                     abort();
@@ -372 +379 @@
                     if (this->identifier_)
                     {
-                        COUT(1) << "Error: Class " << this->identifier_->getName() << " is not a " << ClassIdentifier<T>::getIdentifier()->getName() << "!" << std::endl;
+                        COUT(1) << "Error: Class " << this->identifier_->getName() << " is not a " << this->subclassIdentifier_->getName() << "!" << std::endl;
                         COUT(1) << "Error: Couldn't fabricate a new Object." << std::endl;
                         COUT(1) << "Aborting..." << std::endl;
@@ -407 +414 @@
 
         private:
-            Identifier* identifier_;        //!< The assigned identifier
+            Identifier* identifier_;            //!< The assigned identifier
+            Identifier* subclassIdentifier_;    //!< The identifier of the subclass
     };
 }

code/branches/core/src/orxonox/core/Iterator.h

@@ -150 +150 @@
                 @return True if the iterator points to an existing object.
             */
-            bool operator!=(int compare)
+            bool operator!=(ObjectListElement<T>* compare)
             {
-                // Comparing with anything except zero makes no sense
-                if (compare != 0)
-                    COUT(2) << "Warning: Comparing the " << ClassIdentifier<T>::getIdentifier()->getName() << "-List-Iterator with " << compare << " has no effect. Only comparison with 0 works." << std::endl;
-
-                return (this->element_ != 0);
+                return (this->element_ != compare);
             }
 

code/branches/core/src/orxonox/core/MetaObjectList.h

@@ -99 +99 @@
 
 
-        COUT(4) << "*** Removing Object from " << ClassIdentifier<T>::getIdentifier()->getName() << "-list." << std::endl;
+        COUT(4) << "*** Removing Object from " << this->element_->object_->getIdentifier()->getName() << "-list." << std::endl;
         delete this->element_;
     }