Changeset 162 for code/branches/objecthierarchie/src

Timestamp:

Nov 5, 2007, 12:52:26 AM (17 years ago)

Author:

landauf

Message:

it starts to work, but there is still much to do.

@bensch: thanks for you mail, but i can't tell you much at the moment - i'm still changing lots of things and i have no idea if everything will work as intendet, so i'll write you as soon as i have reliable informations
</abuse log for pms>

Location:

code/branches/objecthierarchie/src

Files:

• BaseObject.h (modified) (2 diffs)
• CMakeLists.txt (modified) (1 diff)
• ClassHierarchy.cc (modified) (5 diffs)
• ClassHierarchy.h (modified) (9 diffs)
• OrxonoxClass.cc (added)
• OrxonoxClass.h (added)
• Test.h (added)
• orxonox.cc (modified) (3 diffs)

code/branches/objecthierarchie/src/BaseObject.h

@@ -3 +3 @@
 
 #include "ClassHierarchy.h"
+#include "OrxonoxClass.h"
 
 namespace orxonox
 {
-    class BaseObject
+    class BaseObject : virtual public OrxonoxClass
     {
         public:
@@ -13 +14 @@
 
             inline bool isA(Identifier* identifier)
-                { this->identifier_->isA(identifier); }
+                { this->getIdentifier()->isA(identifier); }
             inline bool isDirectA(Identifier* identifier)
-                { this->identifier_->isDirectA(identifier); }
+                { this->getIdentifier()->isDirectA(identifier); }
             inline bool isChildOf(Identifier* identifier)
-                { this->identifier_->isChildOf(identifier); }
+                { this->getIdentifier()->isChildOf(identifier); }
             inline bool isDirectChildOf(Identifier* identifier)
-                { this->identifier_->isDirectChildOf(identifier); }
+                { this->getIdentifier()->isDirectChildOf(identifier); }
             inline bool isParentOf(Identifier* identifier)
-                { this->identifier_->isParentOf(identifier); }
+                { this->getIdentifier()->isParentOf(identifier); }
             inline bool isDirectParentOf(Identifier* identifier)
-                { this->identifier_->isDirectParentOf(identifier); }
+                { this->getIdentifier()->isDirectParentOf(identifier); }
 
-            ClassIdentifier<class BaseObject>* identifier_;
+//            Identifier* identifier_;
 
-        protected:
-            IdentifierList* parents_; // INTERN! Don't touch this!
-
-        private:
+//        protected:
+//            IdentifierList* parents_; // INTERN! Don't touch this!
 
     };

code/branches/objecthierarchie/src/CMakeLists.txt

@@ -2 +2 @@
 
 # create a few variables to simplify life
-SET(SRC_FILES orxonox.cc BaseObject.cc ClassHierarchy.cc)
-SET(INC_FILES BaseObject.h ClassHierarchy.h)
+SET(SRC_FILES orxonox.cc ClassHierarchy.cc OrxonoxClass.cc BaseObject.cc)
+SET(INC_FILES ClassHierarchy.h OrxonoxClass.h BaseObject.h Test.h)
 
 #Creates an executable

code/branches/objecthierarchie/src/ClassHierarchy.cc

@@ -31 +31 @@
     void Identifier::initialize(IdentifierList* parents)
     {
+        std::cout << "*** Initialize " << this->name_ << "-Singleton.\n";
         if (parents)
         {
@@ -76 +77 @@
     }
 
-    void Identifier::addObject(BaseObject* object)
-    {
+    void Identifier::addObject(OrxonoxClass* object)
+    {
+        std::cout << "*** Added " << this->name_ << " to list.\n";
         this->objects_->add(object);
     }
 
-    void Identifier::removeObject(BaseObject* object)
-    {
+    void Identifier::removeObject(OrxonoxClass* object)
+    {
+        std::cout << "*** Removed " << this->name_ << " from list.\n";
         this->objects_->remove(object);
     }
@@ -218 +221 @@
     }
 
-    void ObjectList::add(BaseObject* object)
+    void ObjectList::add(OrxonoxClass* object)
     {
         ObjectListElement* temp = this->first_;
@@ -225 +228 @@
     }
 
-    void ObjectList::remove(BaseObject* object)
+    void ObjectList::remove(OrxonoxClass* object)
     {
         if (!object)
@@ -259 +262 @@
     // ###    ObjectListElement    ###
     // ###############################
-    ObjectListElement::ObjectListElement(BaseObject* object)
+    ObjectListElement::ObjectListElement(OrxonoxClass* object)
     {
         this->object_ = object;
         this->next_ = NULL;
     }
+
+
+    // ###############################
+    // ###     ClassHierarchy      ###
+    // ###############################
+    ClassHierarchy* ClassHierarchy::pointer_ = NULL;
+
+    ClassHierarchy* ClassHierarchy::getSingleton()
+    {
+        if (!pointer_)
+            pointer_ = new ClassHierarchy();
+
+        return pointer_;
+    }
+
+    ClassHierarchy::ClassHierarchy()
+    {
+        this->bCreatingHierarchy_ = false;
+    }
 }

code/branches/objecthierarchie/src/ClassHierarchy.h

@@ -3 +3 @@
 
 #include <string>
+#include <iostream>
 
 // DONE:
@@ -18 +19 @@
 namespace orxonox
 {
+    // ##### ClassHierarchy #####
+    class ClassHierarchy
+    {
+        public:
+            static ClassHierarchy* getSingleton();
+            bool isCreatingHierarchy() { return this->bCreatingHierarchy_; }
+            void createHierarchy(bool bCreatingHierarchy) { this->bCreatingHierarchy_ = bCreatingHierarchy; std::cout << "*** Switched Hierarchy-Creating-Mode to" << bCreatingHierarchy << "\n"; }
+
+        private:
+            ClassHierarchy();
+
+            static ClassHierarchy* pointer_;
+            bool bCreatingHierarchy_;
+    };
+
     // ##### Identifier #####
     class IdentifierList;
     class ObjectList;
-    class BaseObject;
+    class OrxonoxClass;
     template <class T>
     class ClassIdentifier;
@@ -31 +47 @@
 
         public:
-            void addObject(BaseObject* object);
-            void removeObject(BaseObject* object);
+            void addObject(OrxonoxClass* object);
+            void removeObject(OrxonoxClass* object);
 
             bool isA(Identifier* identifier);
@@ -60 +76 @@
     {
         public:
-            static ClassIdentifier<T>* registerClass(IdentifierList* parents);
+            static ClassIdentifier<T>* registerClass(IdentifierList* parents, std::string name, bool bRootClass);
             static ClassIdentifier<T>* getIdentifier();
             static T* create();
@@ -71 +87 @@
     };
 
-    #define getStringFromClassName(ClassName) \
-        #ClassName
-
     template <class T>
     ClassIdentifier<T>* ClassIdentifier<T>::pointer_ = NULL;
@@ -83 +96 @@
 
     template <class T>
-    ClassIdentifier<T>* ClassIdentifier<T>::registerClass(IdentifierList* parents)
-    {
+    ClassIdentifier<T>* ClassIdentifier<T>::registerClass(IdentifierList* parents, std::string name, bool bRootClass)
+    {
+        std::cout << "*** Register Class in " << name << "-Singleton.\n";
         if (!pointer_)
         {
-            pointer_ = new ClassIdentifier();
-            pointer_->name_ = getStringFromClassName(T);
-            pointer_->initialize(parents);
+            std::cout << "*** Register Class in " << name << "-Singleton -> Create Singleton.\n";
+            if (parents || bRootClass)
+            {
+                pointer_ = new ClassIdentifier();
+                pointer_->name_ = name;
+                pointer_->initialize(parents);
+            }
+            else
+            {
+                pointer_ = getIdentifier();
+            }
         }
 
@@ -98 +120 @@
     ClassIdentifier<T>* ClassIdentifier<T>::getIdentifier()
     {
+        std::cout << "*** Get Identifier.\n";
         if (!pointer_)
         {
+            std::cout << "*** Get Identifier -> Create Class\n";
+            ClassHierarchy::getSingleton()->createHierarchy(true);
             T* temp = new T();
+            ClassHierarchy::getSingleton()->createHierarchy(false);
             delete temp;
         }
@@ -147 +173 @@
             ObjectList();
             ~ObjectList();
-            void add(BaseObject* object);
-            void remove(BaseObject* object);
+            void add(OrxonoxClass* object);
+            void remove(OrxonoxClass* object);
 
             ObjectListElement* first_;
@@ -156 +182 @@
     {
         public:
-            ObjectListElement(BaseObject* object);
-
-            BaseObject* object_;
+            ObjectListElement(OrxonoxClass* object);
+
+            OrxonoxClass* object_;
             ObjectListElement* next_;
     };
-
 
     // ##### Macros #####
     #define registerRootObject(ClassName) \
-        this->parents_ = new IdentifierList(); \
-        this->identifier_ = ClassIdentifier<ClassName>::registerClass(this->parents_); \
-        this->parents_->add(this->identifier_); \
-        this->identifier_->addObject(this)
+        std::cout << "*** Register Root-Object: " << #ClassName << "\n"; \
+        if (ClassHierarchy::getSingleton()->isCreatingHierarchy() && !this->getParents()) \
+            this->setParents(new IdentifierList()); \
+        if (this->getIdentifier()) \
+            this->getIdentifier()->removeObject(this); \
+        this->setIdentifier(ClassIdentifier<ClassName>::registerClass(this->getParents(), #ClassName, true)); \
+        if (ClassHierarchy::getSingleton()->isCreatingHierarchy() && this->getParents()) \
+            this->getParents()->add(this->getIdentifier()); \
+        this->getIdentifier()->addObject(this)
 
     #define registerObject(ClassName) \
-        this->identifier_->removeObject(this); \
-        this->identifier_ = ClassIdentifier<ClassName>::registerClass(this->parents_); \
-        this->parents_->add(this->identifier_); \
-        this->identifier_->addObject(this)
+        std::cout << "*** Register Object: " << #ClassName << "\n"; \
+        this->getIdentifier()->removeObject(this); \
+        this->setIdentifier(ClassIdentifier<ClassName>::registerClass(this->getParents(), #ClassName, false)); \
+        if (ClassHierarchy::getSingleton()->isCreatingHierarchy() && this->getParents()) \
+            this->getParents()->add(this->getIdentifier()); \
+        this->getIdentifier()->addObject(this)
 
     #define unregisterObject() \
-        delete this->parents_; \
-        this->identifier_->removeObject(this)
+        this->getIdentifier()->removeObject(this)
 
     #define Class(ClassName) \

code/branches/objecthierarchie/src/orxonox.cc

@@ -31 +31 @@
 #include <OgreCEGUIRenderer.h>
 
+#include "BaseObject.h"
+#include "Test.h"
+
 #if OGRE_PLATFORM == OGRE_PLATFORM_APPLE
 #include <CoreFoundation/CoreFoundation.h>
@@ -83 +86 @@
     void go()
     {
-      createRoot();
+/*      createRoot();
       defineResources();
       setupRenderSystem();
@@ -93 +96 @@
       createFrameListener();
       startRenderLoop();
+*/
+      std::cout << "Test 1\n";
+      orxonox::BaseObject* test1;
+      test1 = new orxonox::BaseObject();
+      test1 = new orxonox::BaseObject();
+      test1 = new orxonox::BaseObject();
+
+      std::cout << "Test 2\n";
+      orxonox::A1* test2;
+      test2 = new orxonox::A1();
+      test2 = new orxonox::A1();
+      test2 = new orxonox::A1();
+
+      std::cout << "Test 3\n";
+      orxonox::BaseObject* test3;
+      test3 = new orxonox::BaseObject();
+      test3 = new orxonox::BaseObject();
+      test3 = new orxonox::BaseObject();
+
+      std::cout << "Test 4\n";
+      orxonox::A3* test4;
+      test4 = new orxonox::A3();
+      test4 = new orxonox::A3();
+      test4 = new orxonox::A3();
+
     }