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

Timestamp:

Nov 19, 2007, 10:10:11 PM (18 years ago)

Author:

landauf

Message:

• removed the "ClassHierarchy" manager-class and put its sole feature (bIsCreatingClassHierarchy_) directly into the Identifier.

• added a dynamic_cast from OrxonoxClass to BaseObject to the Factory. OrxonoxClass is needed because several classes use Interfaces, but all classes are derived at least from BaseObject, so the cast will work.

File:

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

code/branches/objecthierarchie/src/Identifier.h

@@ -2 +2 @@
 #define _Identifier_H__
 
-#include "ClassHierarchy.h"
+#include <iostream>
+
 #include "IdentifierList.h"
 #include "ObjectList.h"
-#include "OrxonoxClass.h"
+//#include "OrxonoxClass.h"
 #include "Factory.h"
+
+// DONE AND TESTED:
+// - build class hierarchy
+// - isA, isChildOf, ...
+// - insert into class-lists
+// - ClassIdentifier
+// - BaseIdentifier
+// - Factory
+
+// IN WORK:
+
+// TO DO:
+// - iterate through lists
 
 namespace orxonox
 {
+    class BaseObject;
+
     // ##### Identifier #####
     class Identifier
@@ -23 +39 @@
             void removeObject(OrxonoxClass* object);
 
-            virtual OrxonoxClass* fabricate() {};
+            virtual BaseObject* fabricate() {};
 
             bool isA(Identifier* identifier);
@@ -33 +49 @@
 
             std::string getName() { return this->name_; }
-            IdentifierList* getDirectParents() { return this->directParents_; }
-            IdentifierList* getAllParents() { return this->allParents_; }
-            IdentifierList* getDirectChildren() { return this->directChildren_; }
-            IdentifierList* getAllChildren() { return this->allChildren_; }
+            IdentifierList* getDirectParents() { return &(this->directParents_); }
+            IdentifierList* getAllParents() { return &(this->allParents_); }
+            IdentifierList* getDirectChildren() { return &(this->directChildren_); }
+            IdentifierList* getAllChildren() { return &(this->allChildren_); }
+
+            static bool isCreatingHierarchy() { return (hierarchyCreatingCounter_s > 0); }
 
         private:
@@ -44 +62 @@
             void initialize(IdentifierList* parents);
 
-            IdentifierList* directParents_;
-            IdentifierList* allParents_;
-            IdentifierList* directChildren_;
-            IdentifierList* allChildren_;
-
-            ObjectList* objects_;
+            static void startCreatingHierarchy() { hierarchyCreatingCounter_s++; std::cout << "*** Increased Hierarchy-Creating-Counter to " << hierarchyCreatingCounter_s << "\n"; }
+            static void stopCreatingHierarchy() { hierarchyCreatingCounter_s--; std::cout << "*** Decreased Hierarchy-Creating-Counter to " << hierarchyCreatingCounter_s << "\n"; }
+
+            IdentifierList directParents_;
+            IdentifierList allParents_;
+            IdentifierList directChildren_;
+            IdentifierList allChildren_;
+
+            ObjectList objects_;
             std::string name_;
 
             bool bIsAbstractClass_;
             bool bCreatedOneObject_;
+
+            static int hierarchyCreatingCounter_s;
     };
 
@@ -64 +87 @@
             static ClassIdentifier<T>* registerClass(IdentifierList* parents, std::string name, bool bRootClass, bool bIsAbstractClass);
             static ClassIdentifier<T>* getIdentifier();
-            OrxonoxClass* fabricate();
+            BaseObject* fabricate();
             T* fabricateClass();
 
@@ -72 +95 @@
             ~ClassIdentifier();
 
-            static ClassIdentifier<T>* pointer_;
+            static ClassIdentifier<T>* pointer_s;
 
     };
 
     template <class T>
-    ClassIdentifier<T>* ClassIdentifier<T>::pointer_ = NULL;
+    ClassIdentifier<T>* ClassIdentifier<T>::pointer_s = NULL;
 
     template <class T>
@@ -87 +110 @@
     ClassIdentifier<T>::~ClassIdentifier()
     {
-        this->pointer_ = NULL;
-    }
-
-    template <class T>
-    OrxonoxClass* ClassIdentifier<T>::fabricate()
-    {
-        return this->fabricateClass();
+        this->pointer_s = NULL;
+    }
+
+    template <class T>
+    BaseObject* ClassIdentifier<T>::fabricate()
+    {
+        return dynamic_cast<BaseObject*>(this->fabricateClass());
     }
 
@@ -99 +122 @@
     T* ClassIdentifier<T>::fabricateClass()
     {
-        return new T;
+        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();
+        }
     }
 
@@ -106 +138 @@
     {
         std::cout << "*** Register Class in " << name << "-Singleton.\n";
-        if (!pointer_)
+        if (!pointer_s)
         {
             std::cout << "*** Register Class in " << name << "-Singleton -> Create Singleton.\n";
             if (parents || bRootClass)
             {
-                pointer_ = new ClassIdentifier();
-                pointer_->name_ = name;
-                pointer_->bIsAbstractClass_ = bIsAbstractClass;
-
-                ClassFactory::add(name, pointer_);
-
-                pointer_->initialize(parents);
+                pointer_s = new ClassIdentifier();
+                pointer_s->name_ = name;
+                pointer_s->bIsAbstractClass_ = bIsAbstractClass;
+
+                ClassFactory::add(name, pointer_s);
+
+                pointer_s->initialize(parents);
             }
             else
             {
-                pointer_ = getIdentifier();
-            }
-        }
-
-        return pointer_;
+                pointer_s = getIdentifier();
+            }
+        }
+
+        return pointer_s;
     }
 
@@ -132 +164 @@
     {
 //        std::cout << "*** Get Identifier.\n";
-        if (!pointer_)
+        if (!pointer_s)
         {
             std::cout << "*** Get Identifier -> Create Class\n";
-            ClassHierarchy::getSingleton()->startCreatingHierarchy();
+            Identifier::startCreatingHierarchy();
             T* temp = new T();
-            ClassHierarchy::getSingleton()->stopCreatingHierarchy();
+            Identifier::stopCreatingHierarchy();
             delete temp;
         }
 
-        return pointer_;
+        return pointer_s;
     }
 
@@ -176 +208 @@
             B* fabricate()
             {
-                OrxonoxClass* newObject = this->identifier_->fabricate();
+                BaseObject* newObject = this->identifier_->fabricate();
                 if (newObject)
                 {