Changeset 244 for code/branches/objecthierarchie/src/Identifier.h

Timestamp:

Nov 25, 2007, 5:21:53 PM (16 years ago)

Author:

landauf

Message:

reimplementation of the factory and parts of the class-hierarchy-generating-algorithm. interfaces with protected constructors are now allowed.

File:

• code/branches/objecthierarchie/src/Identifier.h (modified) (10 diffs)

code/branches/objecthierarchie/src/Identifier.h

@@ -8 +8 @@
 #include "Factory.h"
 
-#define HIERARCHY_VERBOSE false
+#define HIERARCHY_VERBOSE true
 
 
@@ -26 +26 @@
         friend class SubclassIdentifier;
 
+        template <class T>
+        friend class ClassFactory;
+
         public:
             virtual void removeObject(OrxonoxClass* object) const = 0;
             virtual void removeObjectIntern(OrxonoxClass* object, bool bIterateForwards) const = 0;
 
-            virtual BaseObject* fabricate() const = 0;
+            inline void addFactory(BaseFactory* factory) { this->factory_ = factory; }
+            BaseObject* fabricate();
 
             bool isA(const Identifier* identifier) const;
@@ -37 +41 @@
             bool isParentOf(const Identifier* identifier) const;
 
-            const std::string& getName() const { return this->name_; }
-            const IdentifierList& getParents() const { return this->parents_; }
-            IdentifierList& getChildren() const { return *this->children_; }
-
-            static bool isCreatingHierarchy() { return (hierarchyCreatingCounter_s > 0); }
+            inline const std::string& getName() const { return this->name_; }
+            inline const IdentifierList& getParents() const { return this->parents_; }
+            inline IdentifierList& getChildren() const { return *this->children_; }
+
+            inline static bool isCreatingHierarchy() { return (hierarchyCreatingCounter_s > 0); }
 
         private:
@@ -49 +53 @@
             void initialize(const IdentifierList* parents);
 
-            static void startCreatingHierarchy()
+            inline static void startCreatingHierarchy()
             {
                 hierarchyCreatingCounter_s++;
@@ -57 +61 @@
             }
 
-            static void stopCreatingHierarchy()
+            inline static void stopCreatingHierarchy()
             {
                 hierarchyCreatingCounter_s--;
@@ -70 +74 @@
             std::string name_;
 
-            bool bIsAbstractClass_;
+            BaseFactory* factory_;
             bool bCreatedOneObject_;
-
             static int hierarchyCreatingCounter_s;
     };
@@ -87 +90 @@
 
         public:
-            static ClassIdentifier<T>* registerClass(const IdentifierList* parents, const std::string& name, bool bRootClass, bool bIsAbstractClass);
+            static ClassIdentifier<T>* registerClass(const IdentifierList* parents, const std::string& name, bool bRootClass);
             static ClassIdentifier<T>* getIdentifier();
-            BaseObject* fabricate() const;
-            T* fabricateClass() const;
             static void addObject(T* object);
             void removeObject(OrxonoxClass* object) const;
@@ -121 +122 @@
 
     template <class T>
-    BaseObject* ClassIdentifier<T>::fabricate() const
-    {
-        return dynamic_cast<BaseObject*>(this->fabricateClass());
-    }
-
-    template <class T>
-    T* ClassIdentifier<T>::fabricateClass() const
-    {
-        if (!this->bIsAbstractClass_)
-        {
-            return new T;
-        }
-        else
-        {
-            std::cout << "Error: Couldn't create a new Object - Class " << this->name_ << " is abstract!\n";
-            std::cout << "Aborting...\n";
-            abort();
-        }
-    }
-
-    template <class T>
-    ClassIdentifier<T>* ClassIdentifier<T>::registerClass(const IdentifierList* parents, const std::string& name, bool bRootClass, bool bIsAbstractClass)
+    ClassIdentifier<T>* ClassIdentifier<T>::registerClass(const IdentifierList* parents, const std::string& name, bool bRootClass)
     {
 #if HIERARCHY_VERBOSE
@@ -152 +132 @@
             std::cout << "*** Register Class in " << name << "-Singleton -> Create Singleton.\n";
 #endif
-            if (parents || bRootClass)
-            {
-                pointer_s = new ClassIdentifier();
-                pointer_s->name_ = name;
-                pointer_s->bIsAbstractClass_ = bIsAbstractClass;
-
-                ClassFactory::add(name, pointer_s);
-
-                if (!bRootClass)
-                    pointer_s->initialize(parents);
-                else
-                    pointer_s->initialize(NULL);
-            }
+            pointer_s = new ClassIdentifier();
+        }
+
+        if (!pointer_s->bCreatedOneObject_)
+        {
+#if HIERARCHY_VERBOSE
+            std::cout << "*** Register Class in " << name << "-Singleton -> Initialize Singleton.\n";
+#endif
+            pointer_s->name_ = name;
+            Factory::add(name, pointer_s);
+
+            if (bRootClass)
+                pointer_s->initialize(NULL);
             else
-            {
-                pointer_s = getIdentifier();
-            }
+                pointer_s->initialize(parents);
         }
 
@@ -177 +155 @@
     ClassIdentifier<T>* ClassIdentifier<T>::getIdentifier()
     {
-#if HIERARCHY_VERBOSE
-//        std::cout << "*** Get Identifier.\n";
-#endif
         if (!pointer_s)
         {
 #if HIERARCHY_VERBOSE
-            std::cout << "*** Get Identifier -> Create Class\n";
-#endif
-            Identifier::startCreatingHierarchy();
-            T* temp = new T();
-            delete temp;
-            Identifier::stopCreatingHierarchy();
+            std::cout << "*** Create Singleton.\n";
+#endif
+            pointer_s = new ClassIdentifier();
         }