Changeset 9646 for code/branches/core6/src

Timestamp:

Aug 13, 2013, 11:35:26 PM (11 years ago)

Author:

landauf

Message:

implemented new concept to initialize the class hierarchy: each identifier is initialized individually by creating an object of the corresponding class. identifiers of abstract classes must be told explicitly about their direct parents. this allows to build the class tree correctly also for complicated setups like multiple inheritance of abstract classes.

Location:

code/branches/core6/src/libraries/core

Files:

• CoreIncludes.h (modified) (6 diffs)
• class/CMakeLists.txt (modified) (1 diff)
• class/Identifiable.cc (modified) (3 diffs)
• class/Identifiable.h (modified) (2 diffs)
• class/Identifier.cc (modified) (4 diffs)
• class/Identifier.h (modified) (6 diffs)
• class/IdentifierManager.cc (modified) (5 diffs)
• class/IdentifierManager.h (modified) (4 diffs)
• class/OrxonoxClass.cc (added)
• class/OrxonoxClass.h (modified) (1 diff)
• class/OrxonoxInterface.cc (added)
• class/OrxonoxInterface.h (modified) (1 diff)
• class/Super.h (modified) (2 diffs)

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

@@ -90 +90 @@
 
 /**
+    @brief Registers the class in the framework.
+    @param ClassName The name of the class
+*/
+#define RegisterClass(ClassName) \
+    RegisterClassWithFactory(ClassName, new orxonox::ClassFactoryWithContext<ClassName>(), true)
+
+/**
+    @brief Registers the class in the framework (for classes without arguments in their constructor).
+    @param ClassName The name of the class
+*/
+#define RegisterClassNoArgs(ClassName) \
+    RegisterClassWithFactory(ClassName, new orxonox::ClassFactoryNoArgs<ClassName>(), true)
+
+/**
+    @brief Registers the class in the framework (for classes which should not be loaded through XML).
+    @param ClassName The name of the class
+*/
+#define RegisterUnloadableClass(ClassName) \
+    RegisterClassWithFactory(ClassName, new orxonox::ClassFactoryWithContext<ClassName>(), false)
+
+/**
+    @brief Registers an abstract class in the framework.
+    @param ClassName The name of the class
+*/
+#define RegisterAbstractClass(ClassName) \
+    RegisterClassWithFactory(ClassName, static_cast<ClassFactory<ClassName>*>(NULL), false)
+
+/**
+    @brief Registers the class in the framework with a given Factory.
+    @param ClassName The name of the class
+*/
+#define RegisterClassWithFactory(ClassName, FactoryInstance, bLoadable) \
+    Identifier& _##ClassName##Identifier = orxonox::registerClass<ClassName>(#ClassName, FactoryInstance, bLoadable)
+
+/**
     @brief Intern macro, containing the common parts of @c RegisterObject and @c RegisterRootObject.
     @param ClassName The name of the class
     @param bRootClass True if the class is directly derived from orxonox::OrxonoxClass
 */
-#define InternRegisterObject(ClassName, bRootClass) \
-    if (ClassIdentifier<ClassName>::getIdentifier(#ClassName)->initializeObject(this, #ClassName, bRootClass)) \
+#define InternRegisterObject(ClassName) \
+    if (ClassIdentifier<ClassName>::getIdentifier(#ClassName)->initializeObject(this)) \
         return; \
     else \
@@ -105 +140 @@
 */
 #define RegisterObject(ClassName) \
-    InternRegisterObject(ClassName, false)
+    InternRegisterObject(ClassName)
 
 /**
@@ -115 +150 @@
 */
 #define RegisterRootObject(ClassName) \
-    InternRegisterObject(ClassName, true)
-
-/**
-    @brief Registers the class in the framework.
-    @param ClassName The name of the class
-*/
-#define RegisterClass(ClassName) \
-    RegisterClassWithFactory(ClassName, new orxonox::ClassFactoryWithContext<ClassName>(), true)
-
-/**
-    @brief Registers the class in the framework (for classes which should not be loaded through XML).
-    @param ClassName The name of the class
-*/
-#define RegisterUnloadableClass(ClassName) \
-    RegisterClassWithFactory(ClassName, new orxonox::ClassFactoryWithContext<ClassName>(), false)
-
-/**
-    @brief Registers the class in the framework with a given Factory.
-    @param ClassName The name of the class
-*/
-#define RegisterClassWithFactory(ClassName, FactoryInstance, bLoadable) \
-    Identifier* _##ClassName##Identifier = orxonox::registerClass<ClassName>(#ClassName, FactoryInstance, bLoadable)
+    InternRegisterObject(ClassName)
 
 /**
@@ -152 +166 @@
      */
     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 +178 @@
      */
     template <class T>
-    inline Identifier* registerClass(const std::string& name, Factory* factory, bool bLoadable = true)
+    inline Identifier& registerClass(const std::string& name, Factory* factory, bool bLoadable = true)
     {
         orxout(verbose, context::misc::factory) << "Create entry for " << name << " in Factory." << endl;
@@ -170 +184 @@
         identifier->setFactory(factory);
         identifier->setLoadable(bLoadable);
-        return identifier;
+        return *identifier;
     }
 

code/branches/core6/src/libraries/core/class/CMakeLists.txt

@@ -3 +3 @@
   Identifier.cc
   IdentifierManager.cc
+  OrxonoxClass.cc
+  OrxonoxInterface.cc
 )

code/branches/core6/src/libraries/core/class/Identifiable.cc

@@ -35 +35 @@
 
 #include <cassert>
+#include "core/CoreIncludes.h"
 #include "core/object/Context.h"
 #include "Identifier.h"
@@ -40 +41 @@
 namespace orxonox
 {
+    RegisterClassNoArgs(Identifiable);
+
     /**
         @brief Constructor: Sets the default values.
@@ -46 +49 @@
     {
         this->identifier_ = 0;
-        this->parents_ = 0;
-        // Optimisation
-        this->objectPointers_.reserve(6);
-    }
+        this->objectPointers_.reserve(6); // Optimisation
 
-    /**
-        @brief Destructor: Removes the object from the object-lists
-    */
-    Identifiable::~Identifiable()
-    {
-        // parents_ exists only if isCreatingHierarchy() of the associated Identifier returned true while creating the class
-        if (this->parents_)
-            delete this->parents_;
+        RegisterObject(Identifiable);
     }
 

code/branches/core6/src/libraries/core/class/Identifiable.h

@@ -55 +55 @@
         public:
             Identifiable();
-            virtual ~Identifiable();
+            virtual ~Identifiable() {}
 
             /// Returns the Identifier of the object.
@@ -119 +119 @@
         private:
             Identifier* identifier_;               //!< The Identifier of the object
-            std::set<const Identifier*>* parents_; //!< List of all parents of the object
 
             /// 'Fast map' that holds this-pointers of all derived types

code/branches/core6/src/libraries/core/class/Identifier.cc

@@ -37 +37 @@
 
 #include "util/StringUtils.h"
+#include "core/CoreIncludes.h"
 #include "core/config/ConfigValueContainer.h"
 #include "core/XMLPort.h"
@@ -52 +53 @@
         : classID_(IdentifierManager::getInstance().getUniqueClassId())
     {
-        this->bCreatedOneObject_ = false;
-        this->bSetName_ = false;
         this->factory_ = 0;
+        this->bInitialized_ = false;
         this->bLoadable_ = false;
 
@@ -80 +80 @@
 
     /**
-        @brief Registers a class, which means that the name and the parents get stored.
-        @param parents A list, containing the Identifiers of all parents of the class
-        @param bRootClass True if the class is either an Interface or the BaseObject itself
-    */
-    void Identifier::initializeClassHierarchy(std::set<const Identifier*>* parents, bool bRootClass)
-    {
-        // Check if at least one object of the given type was created
-        if (!this->bCreatedOneObject_ && IdentifierManager::getInstance().isCreatingHierarchy())
-        {
-            // If no: We have to store the information and initialize the Identifier
-            orxout(verbose, context::identifier) << "Register Class in ClassIdentifier<" << this->getName() << ">-Singleton -> Initialize Singleton." << endl;
-            if (bRootClass)
-                this->initialize(0); // If a class is derived from two interfaces, the second interface might think it's derived from the first because of the order of constructor-calls. Thats why we set parents to zero in that case.
-            else
-                this->initialize(parents);
-        }
-    }
-
-    /**
-        @brief Initializes the Identifier with a list containing all parents of the class the Identifier belongs to.
-        @param parents A list containing all parents
-    */
-    void Identifier::initialize(std::set<const Identifier*>* parents)
-    {
-        orxout(verbose, context::identifier) << "Initialize ClassIdentifier<" << this->name_ << ">-Singleton." << endl;
-        this->bCreatedOneObject_ = true;
-
-        if (parents)
-        {
-            this->parents_ = (*parents);
-            this->directParents_ = (*parents);
-
-            // Iterate through all parents
-            for (std::set<const Identifier*>::iterator it = parents->begin(); it != parents->end(); ++it)
-            {
-                // Tell the parent we're one of it's children
-                (*it)->children_.insert((*it)->children_.end(), this);
-
-                // Erase all parents of our parent from our direct-parent-list
-                for (std::set<const Identifier*>::const_iterator it1 = (*it)->getParents().begin(); it1 != (*it)->getParents().end(); ++it1)
-                {
-                    // Search for the parent's parent in our direct-parent-list
-                    for (std::set<const Identifier*>::iterator it2 = this->directParents_.begin(); it2 != this->directParents_.end(); ++it2)
-                    {
-                        if ((*it1) == (*it2))
-                        {
-                            // We've found a non-direct parent in our list: Erase it
-                            this->directParents_.erase(it2);
-                            break;
-                        }
-                    }
-                }
-            }
-
-            // Now iterate through all direct parents
-            for (std::set<const Identifier*>::iterator it = this->directParents_.begin(); it != this->directParents_.end(); ++it)
-            {
-                // Tell the parent we're one of it's direct children
-                (*it)->directChildren_.insert((*it)->directChildren_.end(), this);
-
-                // Create the super-function dependencies
-                (*it)->createSuperFunctionCaller();
-            }
-        }
-    }
-
-    /**
         @brief Sets the name of the class.
     */
     void Identifier::setName(const std::string& name)
     {
-        if (!this->bSetName_)
+        if (name != this->name_)
         {
             this->name_ = name;
-            this->bSetName_ = true;
-            IdentifierManager::getInstance().registerIdentifier(this);
+            IdentifierManager::getInstance().addIdentifierToLookupMaps(this);
         }
     }
@@ -194 +126 @@
     {
         this->networkID_ = id;
-        IdentifierManager::getInstance().registerIdentifier(this);
+        IdentifierManager::getInstance().addIdentifierToLookupMaps(this);
+    }
+
+    /**
+     * @brief Used to define the direct parents of an Identifier of an abstract class.
+     */
+    Identifier& Identifier::inheritsFrom(Identifier* directParent)
+    {
+        if (this->parents_.empty())
+            this->directParents_.insert(directParent);
+        else
+            orxout(internal_error) << "Trying to add " << directParent->getName() << " as a direct parent of " << this->getName() << " after the latter was already initialized" << endl;
+
+        return *this;
+    }
+
+    /**
+     * @brief Initializes the parents of this Identifier while creating the class hierarchy.
+     * @param identifiers All identifiers that were used to create an instance of this class (including this identifier itself)
+     */
+    void Identifier::initializeParents(const std::set<const Identifier*>& identifiers)
+    {
+        if (!IdentifierManager::getInstance().isCreatingHierarchy())
+        {
+            orxout(internal_warning) << "Identifier::initializeParents() created outside of class hierarchy creation" << endl;
+            return;
+        }
+
+        for (std::set<const Identifier*>::const_iterator it = identifiers.begin(); it != identifiers.end(); ++it)
+            if (*it != this)
+                this->parents_.insert(*it);
+    }
+
+    /**
+     * @brief Initializes the direct parents of this Identifier while creating the class hierarchy. This is only intended for abstract classes.
+     */
+    void Identifier::initializeDirectParentsOfAbstractClass()
+    {
+        if (!IdentifierManager::getInstance().isCreatingHierarchy())
+        {
+            orxout(internal_warning) << "Identifier::initializeDirectParentsOfAbstractClass() created outside of class hierarchy creation" << endl;
+            return;
+        }
+
+        // only Identifiable is allowed to have no parents (even tough it's currently not abstract)
+        if (this->directParents_.empty() && !this->isExactlyA(Class(Identifiable)))
+        {
+            orxout(internal_error) << "Identifier " << this->getName() << " / " << this->getTypeidName() << " is marked as abstract but has no direct parents defined" << endl;
+            orxout(internal_error) << "  If this class is not abstract, use RegisterClass(ThisClass);" << endl;
+            orxout(internal_error) << "  If this class is abstract, use RegisterAbstractClass(ThisClass).inheritsFrom(Class(BaseClass));" << endl;
+        }
+    }
+
+    /**
+     * @brief Finishes the initialization of this Identifier after creating the class hierarchy by wiring the (direct) parent/child references correctly.
+     */
+    void Identifier::finishInitialization()
+    {
+        if (!IdentifierManager::getInstance().isCreatingHierarchy())
+        {
+            orxout(internal_warning) << "Identifier::finishInitialization() created outside of class hierarchy creation" << endl;
+            return;
+        }
+
+        if (this->isInitialized())
+            return;
+
+        // if no direct parents were defined, initialize them with the set of all parents
+        if (this->directParents_.empty())
+            this->directParents_ = this->parents_;
+
+        // initialize all parents before continuing to initialize this identifier
+        for (std::set<const Identifier*>::const_iterator it = this->directParents_.begin(); it != this->directParents_.end(); ++it)
+        {
+            Identifier* directParent = const_cast<Identifier*>(*it);
+            directParent->finishInitialization(); // initialize parent
+            this->parents_.insert(directParent);  // direct parent is also a parent
+            this->parents_.insert(directParent->parents_.begin(), directParent->parents_.end()); // parents of direct parent are also parents
+        }
+
+        // parents of parents are no direct parents of this identifier
+        for (std::set<const Identifier*>::const_iterator it_parent = this->parents_.begin(); it_parent != this->parents_.end(); ++it_parent)
+            for (std::set<const Identifier*>::const_iterator it_parent_parent = const_cast<Identifier*>(*it_parent)->parents_.begin(); it_parent_parent != const_cast<Identifier*>(*it_parent)->parents_.end(); ++it_parent_parent)
+                this->directParents_.erase(*it_parent_parent);
+
+        // tell all parents that this identifier is a child
+        for (std::set<const Identifier*>::const_iterator it = this->parents_.begin(); it != this->parents_.end(); ++it)
+            const_cast<Identifier*>(*it)->children_.insert(this);
+
+        // tell all direct parents that this identifier is a direct child
+        for (std::set<const Identifier*>::const_iterator it = this->directParents_.begin(); it != this->directParents_.end(); ++it)
+        {
+            const_cast<Identifier*>(*it)->directChildren_.insert(this);
+
+            // Create the super-function dependencies
+            (*it)->createSuperFunctionCaller();
+        }
+
+        this->bInitialized_ = true;
     }
 

code/branches/core6/src/libraries/core/class/Identifier.h

@@ -139 +139 @@
             inline void setLoadable(bool bLoadable) { this->bLoadable_ = bLoadable; }
 
+            /// Returns true if the Identifier was completely initialized.
+            inline bool isInitialized() const { return this->bInitialized_; }
+
+
+            /////////////////////////////
+            ////// Class Hierarchy //////
+            /////////////////////////////
+            Identifier& inheritsFrom(Identifier* directParent);
+
+            void initializeParents(const std::set<const Identifier*>& identifiers);
+            void initializeDirectParentsOfAbstractClass();
+            void finishInitialization();
+
             bool isA(const Identifier* identifier) const;
             bool isExactlyA(const Identifier* identifier) const;
@@ -146 +159 @@
             bool isDirectParentOf(const Identifier* identifier) const;
 
-
-            /////////////////////////////
-            ////// Class Hierarchy //////
-            /////////////////////////////
             /// Returns the parents of the class the Identifier belongs to.
             inline const std::set<const Identifier*>& getParents() const { return this->parents_; }
@@ -218 +227 @@
             virtual void createSuperFunctionCaller() const = 0;
 
-            void initializeClassHierarchy(std::set<const Identifier*>* parents, bool bRootClass);
-
-            /// Returns the children of the class the Identifier belongs to.
-            inline std::set<const Identifier*>& getChildrenIntern() const { return this->children_; }
-            /// Returns the direct children of the class the Identifier belongs to.
-            inline std::set<const Identifier*>& getDirectChildrenIntern() const { return this->directChildren_; }
-
         private:
-            void initialize(std::set<const Identifier*>* parents);
-
             std::set<const Identifier*> parents_;                          //!< The parents of the class the Identifier belongs to
-            mutable std::set<const Identifier*> children_;                 //!< The children of the class the Identifier belongs to
+            std::set<const Identifier*> children_;                         //!< The children of the class the Identifier belongs to
 
             std::set<const Identifier*> directParents_;                    //!< The direct parents of the class the Identifier belongs to
-            mutable std::set<const Identifier*> directChildren_;           //!< The direct children of the class the Identifier belongs to
-
-            bool bCreatedOneObject_;                                       //!< True if at least one object of the given type was created (used to determine the need of storing the parents)
-            bool bSetName_;                                                //!< True if the name is set
+            std::set<const Identifier*> directChildren_;                   //!< The direct children of the class the Identifier belongs to
+
+            bool bInitialized_;                                            //!< Is true if the Identifier was completely initialized
             bool bLoadable_;                                               //!< False = it's not permitted to load the object through XML
             std::string name_;                                             //!< The name of the class the Identifier belongs to
@@ -277 +276 @@
             static ClassIdentifier<T>* getIdentifier(const std::string& name);
 
-            bool initializeObject(T* object, const std::string& className, bool bRootClass);
+            bool initializeObject(T* object);
 
             void setConfigValues(T* object, Configurable*) const;
@@ -351 +350 @@
 
         // Get the entry from the map
-        ClassIdentifier<T>::classIdentifier_s = (ClassIdentifier<T>*)IdentifierManager::getInstance().getIdentifierSingleton(proposal);
+        ClassIdentifier<T>::classIdentifier_s = (ClassIdentifier<T>*)IdentifierManager::getInstance().getGloballyUniqueIdentifier(proposal);
 
         if (ClassIdentifier<T>::classIdentifier_s == proposal)
@@ -365 +364 @@
         @brief Adds an object of the given type to the ObjectList.
         @param object The object to add
-        @param className The name of the class T
-        @param bRootClass True if this is a root class (i.e. it inherits directly from OrxonoxClass)
-    */
-    template <class T>
-    bool ClassIdentifier<T>::initializeObject(T* object, const std::string& className, bool bRootClass)
-    {
-        if (bRootClass)
-            orxout(verbose, context::object_list) << "Register Root-Object: " << className << endl;
-        else
-            orxout(verbose, context::object_list) << "Register Object: " << className << endl;
+    */
+    template <class T>
+    bool ClassIdentifier<T>::initializeObject(T* object)
+    {
+        orxout(verbose, context::object_list) << "Register Object: " << this->getName() << endl;
 
         object->identifier_ = this;
         if (IdentifierManager::getInstance().isCreatingHierarchy())
         {
-            if (bRootClass && !object->parents_)
-                object->parents_ = new std::set<const Identifier*>();
-
-            if (object->parents_)
-            {
-                this->initializeClassHierarchy(object->parents_, bRootClass);
-                object->parents_->insert(object->parents_->end(), this);
-            }
+            IdentifierManager::getInstance().createdObject(object);
 
             this->setConfigValues(object, object);

code/branches/core6/src/libraries/core/class/IdentifierManager.cc

@@ -37 +37 @@
 
 #include "util/StringUtils.h"
+#include "core/CoreIncludes.h"
 #include "core/config/ConfigValueContainer.h"
 #include "core/XMLPort.h"
@@ -60 +61 @@
         @return The identifier (unique instance)
     */
-    Identifier* IdentifierManager::getIdentifierSingleton(Identifier* proposal)
+    Identifier* IdentifierManager::getGloballyUniqueIdentifier(Identifier* proposal)
     {
         const std::string& typeidName = proposal->getTypeidName();
@@ -81 +82 @@
      * Registers the identifier in all maps of the IdentifierManager.
      */
-    void IdentifierManager::registerIdentifier(Identifier* identifier)
-    {
-        IdentifierManager::getInstance().identifierByString_[identifier->getName()] = identifier;
-        IdentifierManager::getInstance().identifierByLowercaseString_[getLowercase(identifier->getName())] = identifier;
-        IdentifierManager::getInstance().identifierByNetworkId_[identifier->getNetworkID()] = identifier;
+    void IdentifierManager::addIdentifierToLookupMaps(Identifier* identifier)
+    {
+        const std::string& typeidName = identifier->getTypeidName();
+        if (this->identifierByTypeidName_.find(typeidName) != this->identifierByTypeidName_.end())
+        {
+            this->identifierByString_[identifier->getName()] = identifier;
+            this->identifierByLowercaseString_[getLowercase(identifier->getName())] = identifier;
+            this->identifierByNetworkId_[identifier->getNetworkID()] = identifier;
+        }
+        else
+            orxout(internal_warning) << "Trying to add an identifier to lookup maps which is not known to IdentifierManager" << endl;
     }
 
@@ -95 +102 @@
         orxout(internal_status) << "Create class-hierarchy" << endl;
         this->startCreatingHierarchy();
+
+        std::set<Identifier*> initializedIdentifiers;
+
+        // iterate over all identifiers, create one instance of each class and initialize the identifiers
+        {
+            Context temporaryContext(NULL);
+            for (std::map<std::string, Identifier*>::const_iterator it = this->identifierByTypeidName_.begin(); it != this->identifierByTypeidName_.end(); ++it)
+            {
+                orxout(verbose, context::identifier) << "Initialize ClassIdentifier<" << it->second->getName() << ">-Singleton." << endl;
+                // To initialize the identifier, we create a new object and delete it afterwards.
+                if (it->second->hasFactory())
+                {
+                    this->identifiersOfNewObject_.clear();
+                    Identifiable* temp = it->second->fabricate(&temporaryContext);
+                    if (temp->getIdentifier() != it->second)
+                        orxout(internal_error) << "Newly created object has unexpected identifier" << endl;
+                    delete temp;
+
+                    it->second->initializeParents(this->identifiersOfNewObject_);
+                }
+                else
+                    it->second->initializeDirectParentsOfAbstractClass();
+
+                initializedIdentifiers.insert(it->second);
+            }
+        }
+
+        // finish the initialization of all identifiers
         for (std::map<std::string, Identifier*>::const_iterator it = this->identifierByTypeidName_.begin(); it != this->identifierByTypeidName_.end(); ++it)
         {
-            // To create the new branch of the class-hierarchy, we create a new object and delete it afterwards.
-            if (it->second->hasFactory())
-            {
-                Identifiable* temp = it->second->fabricate(0);
-                delete temp;
-            }
-        }
+            if (initializedIdentifiers.find(it->second) != initializedIdentifiers.end())
+                it->second->finishInitialization();
+            else
+                orxout(internal_error) << "Identifier was registered late and is not initialized: " << it->second->getName() << " / " << it->second->getTypeidName() << endl;
+        }
+
         this->stopCreatingHierarchy();
         orxout(internal_status) << "Finished class-hierarchy creation" << endl;
@@ -123 +157 @@
 
     /**
+     * @brief Notifies the IdentifierManager about a newly created object while creating the class hierarchy.
+     */
+    void IdentifierManager::createdObject(Identifiable* identifiable)
+    {
+        if (this->isCreatingHierarchy())
+            this->identifiersOfNewObject_.insert(identifiable->getIdentifier());
+        else
+            orxout(internal_warning) << "createdObject() called outside of class hierarchy creation" << endl;
+    }
+
+    /**
         @brief Returns the Identifier with a given name.
         @param name The name of the wanted Identifier

code/branches/core6/src/libraries/core/class/IdentifierManager.h

@@ -38 +38 @@
 
 #include <map>
+#include <set>
 #include <string>
 
@@ -47 +48 @@
             static IdentifierManager& getInstance();
 
-            Identifier* getIdentifierSingleton(Identifier* proposal);
-            void registerIdentifier(Identifier* identifier);
+            Identifier* getGloballyUniqueIdentifier(Identifier* proposal);
+            void addIdentifierToLookupMaps(Identifier* identifier);
 
             unsigned int getUniqueClassId()
@@ -59 +60 @@
             void createClassHierarchy();
             void destroyAllIdentifiers();
+
+            void createdObject(Identifiable* identifiable);
 
             /// Returns true, if a branch of the class-hierarchy is being created, causing all new objects to store their parents.
@@ -103 +106 @@
 
             int hierarchyCreatingCounter_s;                         //!< Bigger than zero if at least one Identifier stores its parents (its an int instead of a bool to avoid conflicts with multithreading)
+            std::set<const Identifier*> identifiersOfNewObject_;    //!< Used while creating the object hierarchy to keep track of the identifiers of a newly created object
             unsigned int classIDCounter_s;                          //!< counter for the unique classIDs
     };

code/branches/core6/src/libraries/core/class/OrxonoxClass.h

@@ -53 +53 @@
     class _CoreExport OrxonoxClass : virtual public Configurable, virtual public Destroyable
     {
+        public:
+            OrxonoxClass();
     };
 }

code/branches/core6/src/libraries/core/class/OrxonoxInterface.h

@@ -50 +50 @@
     class _CoreExport OrxonoxInterface : virtual public Configurable, virtual public Destroyable
     {
+        public:
+            OrxonoxInterface();
     };
 }

code/branches/core6/src/libraries/core/class/Super.h

@@ -103 +103 @@
             { \
                 ClassIdentifier<T>* identifier = ClassIdentifier<T>::getIdentifier(); \
-                for (std::set<const Identifier*>::iterator it = identifier->getDirectChildrenIntern().begin(); it != identifier->getDirectChildrenIntern().end(); ++it) \
+                for (std::set<const Identifier*>::iterator it = identifier->getDirectChildren().begin(); it != identifier->getDirectChildren().end(); ++it) \
                 { \
                     if (((ClassIdentifier<T>*)(*it))->bSuperFunctionCaller_##functionname##_isFallback_ && ((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_) \
@@ -171 +171 @@
 
                 // Iterate through all children
-                for (std::set<const Identifier*>::iterator it = identifier->getDirectChildrenIntern().begin(); it != identifier->getDirectChildrenIntern().end(); ++it)
+                for (std::set<const Identifier*>::iterator it = identifier->getDirectChildren().begin(); it != identifier->getDirectChildren().end(); ++it)
                 {
                     // Check if the caller is a fallback-caller