Changeset 10362 for code/branches/core7/src/libraries/core

Timestamp:

Apr 12, 2015, 11:07:14 PM (9 years ago)

Author:

landauf

Message:

use static identifier initializer to store the inheritance definition of abstract classes. this prevents that identifiers are used (via Class(Name)) before they are properly initialized.

Location:

code/branches/core7/src/libraries/core

Files:

• Core.cc (modified) (2 diffs)
• CoreIncludes.h (modified) (2 diffs)
• ViewportEventListener.cc (modified) (1 diff)
• WindowEventListener.cc (modified) (1 diff)
• XMLNameListener.cc (modified) (1 diff)

code/branches/core7/src/libraries/core/Core.cc

@@ -94 +94 @@
 
     // register Core as an abstract class to avoid problems if the class hierarchy is created within Core-constructor
-    RegisterAbstractClass(Core).inheritsFrom(Class(Configurable));
+    RegisterAbstractClass(Core).inheritsFrom<Configurable>();
 
     Core::Core(const std::string& cmdLine)
@@ -517 +517 @@
 
 
-    RegisterAbstractClass(DevModeListener).inheritsFrom(Class(Listable));
+    RegisterAbstractClass(DevModeListener).inheritsFrom<Listable>();
 
     DevModeListener::DevModeListener()

code/branches/core7/src/libraries/core/CoreIncludes.h

@@ -127 +127 @@
 */
 #define RegisterClassWithFactory(ClassName, FactoryInstance, bLoadable) \
-    Identifier& _##ClassName##Identifier = (new orxonox::SI_I(orxonox::registerClass<ClassName>(#ClassName, FactoryInstance, bLoadable)))->getIdentifier()
+    orxonox::SI_I& _##ClassName##Identifier = (*new orxonox::SI_I(orxonox::registerClass<ClassName>(#ClassName, FactoryInstance, bLoadable)))
 
 /**
@@ -213 +213 @@
     }
 
+
+
+
+    /**
+     * The static initializer stores the parent classes of this identifier. The corresponding identifiers are later loaded. This prevents identifiers from
+     * being used before they are completely initialized.
+     */
     class _CoreExport StaticallyInitializedIdentifier : public StaticallyInitializedInstance
     {
+        struct InheritsFrom
+        {
+            virtual ~InheritsFrom() {}
+            virtual Identifier* getParent() = 0;
+        };
+
+        template <class T>
+        struct InheritsFromClass : public InheritsFrom
+        {
+            virtual Identifier* getParent() { return Class(T); }
+        };
+
         public:
             StaticallyInitializedIdentifier(Identifier* identifier) : identifier_(identifier) {}
-
-            virtual void load() {}
+            ~StaticallyInitializedIdentifier()
+            {
+                for (size_t i = 0; i < this->parents_.size(); ++i)
+                    delete parents_[i];
+            }
+
+            virtual void load()
+            {
+                for (size_t i = 0; i < this->parents_.size(); ++i)
+                    this->identifier_->inheritsFrom(this->parents_[i]->getParent());
+            }
 
             inline Identifier& getIdentifier()
                 { return *this->identifier_; }
 
+            template <class T>
+            inline StaticallyInitializedIdentifier& inheritsFrom()
+                { this->parents_.push_back(new InheritsFromClass<T>()); return *this; }
+
         private:
             Identifier* identifier_;
+            std::vector<InheritsFrom*> parents_;
     };
 

code/branches/core7/src/libraries/core/ViewportEventListener.cc

@@ -32 +32 @@
 namespace orxonox
 {
-    RegisterAbstractClass(ViewportEventListener).inheritsFrom(Class(Listable));
+    RegisterAbstractClass(ViewportEventListener).inheritsFrom<Listable>();
 
     ViewportEventListener::ViewportEventListener()

code/branches/core7/src/libraries/core/WindowEventListener.cc

@@ -35 +35 @@
     unsigned int WindowEventListener::windowHeight_s = 0;
 
-    RegisterAbstractClass(WindowEventListener).inheritsFrom(Class(Listable));
+    RegisterAbstractClass(WindowEventListener).inheritsFrom<Listable>();
 
     WindowEventListener::WindowEventListener()

code/branches/core7/src/libraries/core/XMLNameListener.cc

@@ -32 +32 @@
 namespace orxonox
 {
-    RegisterAbstractClass(XMLNameListener).inheritsFrom(Class(Listable));
+    RegisterAbstractClass(XMLNameListener).inheritsFrom<Listable>();
 
     XMLNameListener::XMLNameListener()