Changeset 10624 for code/trunk/src/libraries/core/CoreIncludes.h

Timestamp:

Oct 4, 2015, 9:12:21 PM (9 years ago)

Author:

landauf

Message:

merged branch core7 back to trunk

Location:

code/trunk

Files:

• . (modified) (1 prop)
• src/libraries/core/CoreIncludes.h (modified) (6 diffs)

code/trunk/src/libraries/core/CoreIncludes.h

@@ -84 +84 @@
 #include "object/ClassFactory.h"
 #include "object/ObjectList.h"
+#include "module/StaticallyInitializedInstance.h"
 
 // resolve macro conflict on windows
@@ -126 +127 @@
 */
 #define RegisterClassWithFactory(ClassName, FactoryInstance, bLoadable) \
-    Identifier& _##ClassName##Identifier = orxonox::registerClass<ClassName>(#ClassName, FactoryInstance, bLoadable)
+    orxonox::SI_I& _##ClassName##Identifier = (*new orxonox::SI_I(orxonox::registerClass<ClassName>(#ClassName, FactoryInstance, bLoadable)))
 
 /**
@@ -133 +134 @@
 */
 #define RegisterObject(ClassName) \
-    if (ClassIdentifier<ClassName>::getIdentifier(#ClassName)->initializeObject(this)) \
+    if (ClassIdentifier<ClassName>::getIdentifier()->initializeObject(this)) \
         return; \
     else \
@@ -152 +153 @@
      */
     template <class T>
-    inline Identifier& registerClass(const std::string& name, ClassFactory<T>* factory, bool bLoadable = true)
+    inline Identifier* registerClass(const std::string& name, ClassFactory<T>* factory, bool bLoadable = true)
     {
         return registerClass<T>(name, static_cast<Factory*>(factory), bLoadable);
@@ -164 +165 @@
      */
     template <class T>
-    inline Identifier& registerClass(const std::string& name, Factory* factory, bool bLoadable = true)
-    {
-        orxout(verbose, context::misc::factory) << "Create entry for " << name << " in Factory." << endl;
-        Identifier* identifier = ClassIdentifier<T>::getIdentifier(name);
-        identifier->setFactory(factory);
-        identifier->setLoadable(bLoadable);
-        return *identifier;
+    inline Identifier* registerClass(const std::string& name, Factory* factory, bool bLoadable = true)
+    {
+        return new ClassIdentifier<T>(name, factory, bLoadable);
     }
 
@@ -211 +208 @@
         return ClassIdentifier<T>::getIdentifier();
     }
+
+
+
+
+    /**
+     * 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
+    {
+        template <class T>
+        struct InheritsFromClass : public Identifier::InheritsFrom
+        {
+            virtual Identifier* getParent() const { return Class(T); }
+        };
+
+        public:
+            StaticallyInitializedIdentifier(Identifier* identifier)
+                : StaticallyInitializedInstance(StaticInitialization::IDENTIFIER)
+                , identifier_(identifier)
+            {}
+            ~StaticallyInitializedIdentifier() { delete identifier_; }
+
+            virtual void load()
+            {
+                IdentifierManager::getInstance().addIdentifier(this->identifier_);
+            }
+
+            virtual void unload()
+            {
+                IdentifierManager::getInstance().removeIdentifier(this->identifier_);
+            }
+
+            inline Identifier& getIdentifier()
+                { return *this->identifier_; }
+
+            template <class T>
+            inline StaticallyInitializedIdentifier& inheritsFrom()
+                { this->identifier_->inheritsFrom(new InheritsFromClass<T>()); return *this; }
+
+            inline StaticallyInitializedIdentifier& virtualBase()
+                { this->identifier_->setVirtualBase(true); return *this; }
+
+        private:
+            Identifier* identifier_;
+    };
+
+    typedef StaticallyInitializedIdentifier SI_I;
 }