Changeset 244 for code/branches/objecthierarchie/src

Timestamp:

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

Author:

landauf

Message:

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

Location:

code/branches/objecthierarchie/src

Files:

• BaseObject.cc (modified) (1 diff)
• CMakeLists.txt (modified) (1 diff)
• ClassFactory.h (added)
• Factory.cc (modified) (1 diff)
• Factory.h (modified) (1 diff)
• Identifier.cc (modified) (3 diffs)
• Identifier.h (modified) (10 diffs)
• IdentifierIncludes.h (modified) (3 diffs)
• Test.h (modified) (19 diffs)
• orxonox.cc (modified) (9 diffs)
• test1.cc (modified) (1 diff)
• test2.cc (modified) (1 diff)
• test3.cc (modified) (1 diff)

code/branches/objecthierarchie/src/BaseObject.cc

@@ -7 +7 @@
     BaseObject::BaseObject()
     {
-        registerRootObject(BaseObject);
+        RegisterRootObject(BaseObject);
     }
 
     BaseObject::~BaseObject()
     {
-        unregisterObject();
+        UnregisterObject();
     }
 }

code/branches/objecthierarchie/src/CMakeLists.txt

@@ -3 +3 @@
 # create a few variables to simplify life
 SET(SRC_FILES orxonox.cc IdentifierList.cc Identifier.cc Factory.cc OrxonoxClass.cc BaseObject.cc test1.cc test2.cc test3.cc)
-SET(INC_FILES IdentifierIncludes.h Identifier.h Factory.h IdentifierList.h ObjectList.h Iterator.h OrxonoxClass.h BaseObject.h Test.h test1.h test2.h test3.h)
+SET(INC_FILES IdentifierIncludes.h Identifier.h Factory.h ClassFactory.h IdentifierList.h ObjectList.h Iterator.h OrxonoxClass.h BaseObject.h Test.h test1.h test2.h test3.h)
 
 #Creates an executable

code/branches/objecthierarchie/src/Factory.cc

@@ -5 +5 @@
 namespace orxonox
 {
-    ClassFactory* ClassFactory::pointer_s = NULL;
+    Factory* Factory::pointer_s = NULL;
 
-    BaseObject* ClassFactory::fabricate(const std::string& name)
+    Identifier* Factory::getIdentifier(const std::string& name)
     {
         if (!pointer_s)
-            pointer_s = new ClassFactory;
+            pointer_s = new Factory;
 
-        return pointer_s->identifierMap_[name]->fabricate();
+        return pointer_s->identifierMap_[name];
     }
 
-    void ClassFactory::add(const std::string& name, Identifier* identifier)
+    void Factory::add(const std::string& name, Identifier* identifier)
     {
         if (!pointer_s)
-            pointer_s = new ClassFactory;
+            pointer_s = new Factory;
 
         pointer_s->identifierMap_[name] = identifier;

code/branches/objecthierarchie/src/Factory.h

@@ -7 +7 @@
 namespace orxonox
 {
+    class BaseObject;
     class Identifier;
-    class BaseObject;
 
-    class ClassFactory
+    // ###############################
+    // ###         Factory         ###
+    // ###############################
+    class Factory
     {
         public:
-            static BaseObject* fabricate(const std::string& name);
+            static Identifier* getIdentifier(const std::string& name);
             static void add(const std::string& name, Identifier* identifier);
 
         private:
-            ClassFactory() {}
-            ClassFactory(const ClassFactory& factory) {}
-            ~ClassFactory() {}
+            Factory() {}
+            Factory(const Factory& factory) {}
+            ~Factory() {}
 
-            static ClassFactory* pointer_s;
+            static Factory* pointer_s;
             std::map<std::string, Identifier*> identifierMap_;
+    };
+
+    // ###############################
+    // ###       BaseFactory       ###
+    // ###############################
+    class BaseFactory
+    {
+        public:
+            virtual BaseObject* fabricate() = 0;
     };
 }

code/branches/objecthierarchie/src/Identifier.cc

@@ -11 +11 @@
     {
         this->bCreatedOneObject_ = false;
+        this->factory_ = 0;
 
         this->children_ = new IdentifierList;
@@ -27 +28 @@
         std::cout << "*** Initialize " << this->name_ << "-Singleton.\n";
 #endif
+        this->bCreatedOneObject_ = true;
+
         if (parents)
         {
-            this->bCreatedOneObject_ = true;
-
             IdentifierListElement* temp1 = parents->first_;
             while (temp1)
@@ -39 +40 @@
                 temp1 = temp1->next_;
             }
+        }
+    }
+
+    BaseObject* Identifier::fabricate()
+    {
+        if (this->factory_)
+        {
+            return this->factory_->fabricate();
+        }
+        else
+        {
+            std::cout << "Error: Cannot create an object of type '" << this->name_ << "'. Class is abstract.\n";
+            std::cout << "Aborting...";
+            abort();
         }
     }

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();
         }
 

code/branches/objecthierarchie/src/IdentifierIncludes.h

@@ -1 +1 @@
 #include "Identifier.h"
 #include "Factory.h"
+#include "ClassFactory.h"
 #include "IdentifierList.h"
 #include "ObjectList.h"
@@ -7 +8 @@
 
 
-#define internRegisterRootObject(ClassName, bAbstract) \
-    if (Identifier::isCreatingHierarchy() && !this->getParents()) \
-        this->setParents(new IdentifierList()); \
-    this->setIdentifier(ClassIdentifier<ClassName>::registerClass(this->getParents(), #ClassName, true, bAbstract)); \
+#define InternRegisterObject(ClassName, bRootClass) \
+    this->setIdentifier(ClassIdentifier<ClassName>::registerClass(this->getParents(), #ClassName, bRootClass)); \
     if (Identifier::isCreatingHierarchy() && this->getParents()) \
         this->getParents()->add(this->getIdentifier()); \
     ClassIdentifier<ClassName>::addObject(this)
 
+#define InternRegisterRootObject(ClassName) \
+    if (Identifier::isCreatingHierarchy() && !this->getParents()) \
+        this->setParents(new IdentifierList()); \
+    InternRegisterObject(ClassName, true)
+
 #if HIERARCHY_VERBOSE
-#define registerRootObject(ClassName) \
-    std::cout << "*** Register Root-Object: " << #ClassName << "\n"; \
-    internRegisterRootObject(ClassName, false)
+#define RegisterObject(ClassName) \
+    std::cout << "*** Register Object: " << #ClassName << "\n"; \
+    InternRegisterObject(ClassName, false)
 #else
-#define registerRootObject(ClassName) \
-    internRegisterRootObject(ClassName, false)
+#define RegisterObject(ClassName) \
+    InternRegisterObject(ClassName, false)
 #endif
 
 #if HIERARCHY_VERBOSE
-#define registerAbstractRootObject(ClassName) \
-    std::cout << "*** Register abstract Root-Object: " << #ClassName << "\n"; \
-    internRegisterRootObject(ClassName, true)
+#define RegisterRootObject(ClassName) \
+    std::cout << "*** Register Root-Object: " << #ClassName << "\n"; \
+    InternRegisterRootObject(ClassName)
 #else
-#define registerAbstractRootObject(ClassName) \
-    internRegisterRootObject(ClassName, true)
+#define RegisterRootObject(ClassName) \
+    InternRegisterRootObject(ClassName)
 #endif
 
-#define internRegisterObject(ClassName, bAbstract) \
-    this->setIdentifier(ClassIdentifier<ClassName>::registerClass(this->getParents(), #ClassName, false, bAbstract)); \
-    if (Identifier::isCreatingHierarchy() && this->getParents()) \
-        this->getParents()->add(this->getIdentifier()); \
-    ClassIdentifier<ClassName>::addObject(this)
-
-#if HIERARCHY_VERBOSE
-#define registerObject(ClassName) \
-    std::cout << "*** Register Object: " << #ClassName << "\n"; \
-    internRegisterObject(ClassName, false)
-#else
-#define registerObject(ClassName) \
-    internRegisterObject(ClassName, false)
-#endif
-
-#if HIERARCHY_VERBOSE
-#define registerAbstractObject(ClassName) \
-    std::cout << "*** Register abstract Object: " << #ClassName << "\n"; \
-    internRegisterObject(ClassName, true)
-#else
-#define registerAbstractObject(ClassName) \
-    internRegisterObject(ClassName, true)
-#endif
-
-#define unregisterObject() \
+#define UnregisterObject() \
     this->getIdentifier()->removeObject(this)
 
@@ -64 +44 @@
 
 #define CreateFactory(ClassName) \
-    Identifier* global_##ClassName##_Identifier = ClassIdentifier<ClassName>::getIdentifier()
+    bool bCreated##ClassName##Factory = ClassFactory<ClassName>::create()
 
-#define Factory(Name) \
-    ClassFactory::fabricate(Name)
+#define ID(Name) \
+    Factory::getIdentifier(Name)

code/branches/objecthierarchie/src/Test.h

@@ -9 +9 @@
     class Interface1 : virtual public OrxonoxClass
     {
-        public:
-            Interface1() { registerAbstractRootObject(Interface1); }
+        protected:
+            Interface1() { RegisterRootObject(Interface1); }
     };
 
     class Interface2 : virtual public OrxonoxClass
     {
-        public:
-            Interface2() { registerAbstractRootObject(Interface2); }
+        protected:
+            Interface2() { RegisterRootObject(Interface2); }
     };
 
@@ -22 +22 @@
     {
         public:
-            A1() { registerObject(A1); }
+            A1() { RegisterObject(A1); }
     };
 
@@ -28 +28 @@
     {
         public:
-            A2() { registerObject(A2); }
+            A2() { RegisterObject(A2); }
     };
 
@@ -34 +34 @@
     {
         public:
-            A3() { registerObject(A3); }
+            A3() { RegisterObject(A3); }
     };
 
@@ -40 +40 @@
     {
         public:
-            A1B1() { registerObject(A1B1); }
+            A1B1() { RegisterObject(A1B1); }
     };
 
@@ -46 +46 @@
     {
         public:
-            A1B2() { registerObject(A1B2); }
+            A1B2() { RegisterObject(A1B2); }
     };
 
@@ -52 +52 @@
     {
         public:
-            A2B1() { registerObject(A2B1); }
+            A2B1() { RegisterObject(A2B1); }
     };
 
@@ -58 +58 @@
     {
         public:
-            A2B2() { registerObject(A2B2); }
+            A2B2() { RegisterObject(A2B2); }
     };
 
@@ -64 +64 @@
     {
         public:
-            A3B1() { registerObject(A3B1); }
+            A3B1() { RegisterObject(A3B1); }
     };
 
@@ -70 +70 @@
     {
         public:
-            A3B2() { registerObject(A3B2); }
+            A3B2() { RegisterObject(A3B2); }
     };
 
@@ -76 +76 @@
     {
         public:
-            A1B1C1() { registerObject(A1B1C1); }
+            A1B1C1() { RegisterObject(A1B1C1); }
     };
 
@@ -82 +82 @@
     {
         public:
-            A1B1C2() { registerObject(A1B1C2); }
+            A1B1C2() { RegisterObject(A1B1C2); }
     };
 
@@ -88 +88 @@
     {
         public:
-            A1B2C1() { registerObject(A1B2C1); }
+            A1B2C1() { RegisterObject(A1B2C1); }
     };
 
@@ -94 +94 @@
     {
         public:
-            A2B1C1() { registerObject(A2B1C1); }
+            A2B1C1() { RegisterObject(A2B1C1); }
     };
 
@@ -100 +100 @@
     {
         public:
-            A2B2C1() { registerObject(A2B2C1); }
+            A2B2C1() { RegisterObject(A2B2C1); }
     };
 
@@ -106 +106 @@
     {
         public:
-            A3B1C1() { registerObject(A3B1C1); }
+            A3B1C1() { RegisterObject(A3B1C1); }
     };
 
@@ -112 +112 @@
     {
         public:
-            A3B1C2() { registerObject(A3B1C2); }
+            A3B1C2() { RegisterObject(A3B1C2); }
     };
 
@@ -118 +118 @@
     {
         public:
-            A3B2C1() { registerObject(A3B2C1); }
+            A3B2C1() { RegisterObject(A3B2C1); }
     };
 
@@ -124 +124 @@
     {
         public:
-            A3B2C2() { registerObject(A3B2C2); }
+            A3B2C2() { RegisterObject(A3B2C2); }
     };
 

code/branches/objecthierarchie/src/orxonox.cc

@@ -102 +102 @@
         startRenderLoop();
 */
+
+        #define testandcout(code) \
+          std::cout << #code << " " << code << "\n"
+
 /*
         std::cout << "Test 1\n";
@@ -176 +180 @@
         }
 */
-
-        #define testandcout(code) \
-          std::cout << #code << " " << code << "\n"
-
 /*
         std::cout << "\n";
@@ -205 +205 @@
         testandcout(test5_03->isA(Class(BaseObject)));
         testandcout(test5_03->isA(Class(Interface1)));
-
 
         std::cout << "\n";
@@ -346 +345 @@
         std::cout << "\n";
         std::cout << "A2 parent of A2B1C1: " << Class(A2)->isParentOf(Class(A2B1C1)) << "\n";
-
-
+*/
+/*
         std::cout << "Test 7\n";
         std::cout << "1\n";
@@ -427 +426 @@
 
         std::cout << "\n4\n";
-        BaseObject* test9_06 = Factory("A2B2");
+        BaseObject* test9_06 = ID("A2B2")->fabricate();
         std::cout << test9_06->getIdentifier()->getName() << "\n";
 
@@ -436 +435 @@
         delete test9_06;
 */
-
+/*
         std::cout << "Test 10\n";
         Identifier* test10_01 = Class(A1B2);
@@ -449 +448 @@
         BaseObject* test10_07;
         for (int i = 0; i < 10; i++)
-            test10_07 = Factory("A1B1C1");
+            test10_07 = ID("A1B1C1")->fabricate();
 
         std::cout << "1\n";
@@ -484 +483 @@
         for (int i = 0; i < 10; i++)
         {
-            test10_08 = Factory("A2B1C1");
+            test10_08 = ID("A2B1C1")->fabricate();
             test10_08->name_ = "A2B1C1#";
             test10_08->name_ += ('0' + i);
@@ -534 +533 @@
         for (Iterator<A2B1C1> it; it; --it)
             std::cout << "Name: " << it->name_ << "\n";
-
+*/
 
       }

code/branches/objecthierarchie/src/test1.cc

@@ -9 +9 @@
     Test1::Test1()
     {
-        registerObject(Test1);
+        RegisterObject(Test1);
 
         this->usefullClass1_ = Class(Test1);

code/branches/objecthierarchie/src/test2.cc

@@ -9 +9 @@
     Test2::Test2()
     {
-        registerObject(Test2);
+        RegisterObject(Test2);
 
         this->usefullClass1_ = Class(Test1);

code/branches/objecthierarchie/src/test3.cc

@@ -9 +9 @@
     Test3::Test3()
     {
-        registerObject(Test3);
+        RegisterObject(Test3);
     }