Changeset 11071 for code/trunk/src/libraries/core/class

Timestamp:

Jan 17, 2016, 10:29:21 PM (9 years ago)

Author:

landauf

Message:

merged branch cpp11_v3 back to trunk

Location:

code/trunk

Files:

• . (modified) (1 prop)
• src/libraries/core/class/Identifiable.cc (modified) (1 diff)
• src/libraries/core/class/Identifiable.h (modified) (3 diffs)
• src/libraries/core/class/Identifier.cc (modified) (12 diffs)
• src/libraries/core/class/Identifier.h (modified) (17 diffs)
• src/libraries/core/class/IdentifierManager.cc (modified) (12 diffs)
• src/libraries/core/class/IdentifierManager.h (modified) (5 diffs)
• src/libraries/core/class/SubclassIdentifier.h (modified) (2 diffs)
• src/libraries/core/class/Super.h (modified) (5 diffs)

code/trunk/src/libraries/core/class/Identifiable.cc

@@ -48 +48 @@
     Identifiable::Identifiable()
     {
-        this->identifier_ = 0;
+        this->identifier_ = nullptr;
         this->objectPointers_.reserve(6); // Optimisation
 

code/trunk/src/libraries/core/class/Identifiable.h

@@ -98 +98 @@
                 registered in the class hierarchy.
             @return
-                Returns NULL if the no pointer was found.
+                Returns nullptr if the no pointer was found.
             */
             ORX_FORCEINLINE void* getDerivedPointer(unsigned int classID)
@@ -107 +107 @@
                         return this->objectPointers_[i].second;
                 }
-                return NULL;
+                return nullptr;
             }
 
@@ -121 +121 @@
 
             /// 'Fast map' that holds this-pointers of all derived types
-            std::vector<std::pair<unsigned int, void*> > objectPointers_;
+            std::vector<std::pair<unsigned int, void*>> objectPointers_;
     };
 }

code/trunk/src/libraries/core/class/Identifier.cc

@@ -79 +79 @@
             delete this->factory_;
 
-        for (std::list<const InheritsFrom*>::const_iterator it = this->manualDirectParents_.begin(); it != this->manualDirectParents_.end(); ++it)
-            delete (*it);
+        for (const InheritsFrom* manualDirectParent : this->manualDirectParents_)
+            delete manualDirectParent;
 
         // erase this Identifier from all related identifiers
-        for (std::list<const Identifier*>::const_iterator it = this->parents_.begin(); it != this->parents_.end(); ++it)
-            const_cast<Identifier*>(*it)->children_.erase(this);
-        for (std::list<const Identifier*>::const_iterator it = this->directParents_.begin(); it != this->directParents_.end(); ++it)
-            const_cast<Identifier*>(*it)->directChildren_.erase(this);
-        for (std::set<const Identifier*>::const_iterator it = this->children_.begin(); it != this->children_.end(); ++it)
-            const_cast<Identifier*>(*it)->parents_.remove(this);
-        for (std::set<const Identifier*>::const_iterator it = this->directChildren_.begin(); it != this->directChildren_.end(); ++it)
-            const_cast<Identifier*>(*it)->directParents_.remove(this);
-
-        for (std::map<std::string, ConfigValueContainer*>::iterator it = this->configValues_.begin(); it != this->configValues_.end(); ++it)
-            delete (it->second);
-        for (std::map<std::string, XMLPortParamContainer*>::iterator it = this->xmlportParamContainers_.begin(); it != this->xmlportParamContainers_.end(); ++it)
-            delete (it->second);
-        for (std::map<std::string, XMLPortObjectContainer*>::iterator it = this->xmlportObjectContainers_.begin(); it != this->xmlportObjectContainers_.end(); ++it)
-            delete (it->second);
+        for (const Identifier* parent : this->parents_)
+            const_cast<Identifier*>(parent)->children_.erase(this);
+        for (const Identifier* directParent : this->directParents_)
+            const_cast<Identifier*>(directParent)->directChildren_.erase(this);
+        for (const Identifier* child : this->children_)
+            const_cast<Identifier*>(child)->parents_.remove(this);
+        for (const Identifier* directChild : this->directChildren_)
+            const_cast<Identifier*>(directChild)->directParents_.remove(this);
+
+        for (const auto& mapEntry : this->configValues_)
+            delete (mapEntry.second);
+        for (const auto& mapEntry : this->xmlportParamContainers_)
+            delete (mapEntry.second);
+        for (const auto& mapEntry : this->xmlportObjectContainers_)
+            delete (mapEntry.second);
     }
 
@@ -117 +117 @@
             orxout(user_error) << "Aborting..." << endl;
             abort();
-            return 0;
+            return nullptr;
         }
     }
@@ -157 +157 @@
         if (this->directParents_.empty())
         {
-            for (std::list<const Identifier*>::const_iterator it = initializationTrace.begin(); it != initializationTrace.end(); ++it)
-                if (*it != this)
-                    this->parents_.push_back(*it);
+            for (const Identifier* identifier : initializationTrace)
+                if (identifier != this)
+                    this->parents_.push_back(identifier);
         }
         else
@@ -184 +184 @@
 
             // initialize all parents
-            for (std::list<const Identifier*>::const_iterator it = this->parents_.begin(); it != this->parents_.end(); ++it)
-                const_cast<Identifier*>(*it)->finishInitialization(); // initialize parent
+            for (const Identifier* parent : this->parents_)
+                const_cast<Identifier*>(parent)->finishInitialization(); // initialize parent
 
             // parents of parents are no direct parents of this identifier
             this->directParents_ = this->parents_;
-            for (std::list<const Identifier*>::const_iterator it_parent = this->parents_.begin(); it_parent != this->parents_.end(); ++it_parent)
-                for (std::list<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_.remove(*it_parent_parent);
+            for (const Identifier* parent : this->parents_)
+                for (const Identifier* parent_parent : const_cast<Identifier*>(parent)->parents_)
+                    this->directParents_.remove(parent_parent);
 
             this->verifyIdentifierTrace();
@@ -200 +200 @@
 
             // initialize all direct parents
-            for (std::list<const InheritsFrom*>::const_iterator it = this->manualDirectParents_.begin(); it != this->manualDirectParents_.end(); ++it)
+            for (const InheritsFrom* manualDirectParent : this->manualDirectParents_)
             {
-                Identifier* directParent = (*it)->getParent();
+                Identifier* directParent = manualDirectParent->getParent();
                 this->directParents_.push_back(directParent);
                 directParent->finishInitialization(); // initialize parent
@@ -208 +208 @@
 
             // direct parents and their parents are also parents of this identifier (but only add them once)
-            for (std::list<const Identifier*>::const_iterator it_parent = this->directParents_.begin(); it_parent != this->directParents_.end(); ++it_parent)
+            for (const Identifier* parent : this->directParents_)
             {
-                for (std::list<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->addIfNotExists(this->parents_, *it_parent_parent);
-                this->addIfNotExists(this->parents_, *it_parent);
+                for (const Identifier* parent_parent : const_cast<Identifier*>(parent)->parents_)
+                    this->addIfNotExists(this->parents_, parent_parent);
+                this->addIfNotExists(this->parents_, parent);
             }
         }
@@ -224 +224 @@
 
         // tell all parents that this identifier is a child
-        for (std::list<const Identifier*>::const_iterator it = this->parents_.begin(); it != this->parents_.end(); ++it)
-            const_cast<Identifier*>(*it)->children_.insert(this);
+        for (const Identifier* parent : this->parents_)
+            const_cast<Identifier*>(parent)->children_.insert(this);
 
         // tell all direct parents that this identifier is a direct child
-        for (std::list<const Identifier*>::const_iterator it = this->directParents_.begin(); it != this->directParents_.end(); ++it)
-        {
-            const_cast<Identifier*>(*it)->directChildren_.insert(this);
+        for (const Identifier* directChild : this->directParents_)
+        {
+            const_cast<Identifier*>(directChild)->directChildren_.insert(this);
 
             // Create the super-function dependencies
-            (*it)->createSuperFunctionCaller();
+            directChild->createSuperFunctionCaller();
         }
 
@@ -261 +261 @@
 
         // if any parent class is virtual, it will be instantiated first, so we need to add them first.
-        for (std::list<const Identifier*>::const_iterator it_parent = this->parents_.begin(); it_parent != this->parents_.end(); ++it_parent)
-        {
-            if ((*it_parent)->isVirtualBase())
+        for (const Identifier* parent : this->parents_)
+        {
+            if (parent->isVirtualBase())
             {
-                for (std::list<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->addIfNotExists(expectedIdentifierTrace, *it_parent_parent);
-                this->addIfNotExists(expectedIdentifierTrace, *it_parent);
+                for (const Identifier* parent_parent : const_cast<Identifier*>(parent)->parents_)
+                    this->addIfNotExists(expectedIdentifierTrace, parent_parent);
+                this->addIfNotExists(expectedIdentifierTrace, parent);
             }
         }
 
         // now all direct parents get created recursively. already added identifiers (e.g. virtual base classes) are not added again.
-        for (std::list<const Identifier*>::const_iterator it_parent = this->directParents_.begin(); it_parent != this->directParents_.end(); ++it_parent)
-        {
-            for (std::list<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->addIfNotExists(expectedIdentifierTrace, *it_parent_parent);
-            this->addIfNotExists(expectedIdentifierTrace, *it_parent);
+        for (const Identifier* directParent : this->directParents_)
+        {
+            for (const Identifier* parent_parent : const_cast<Identifier*>(directParent)->parents_)
+                this->addIfNotExists(expectedIdentifierTrace, parent_parent);
+            this->addIfNotExists(expectedIdentifierTrace, directParent);
         }
 
@@ -285 +285 @@
 
             orxout(internal_warning) << "  Actual trace (after creating a sample instance):" << endl << "    ";
-            for (std::list<const Identifier*>::const_iterator it_parent = this->parents_.begin(); it_parent != this->parents_.end(); ++it_parent)
-                orxout(internal_warning) << " " << (*it_parent)->getName();
+            for (const Identifier* parent : this->parents_)
+                orxout(internal_warning) << " " << parent->getName();
             orxout(internal_warning) << endl;
 
             orxout(internal_warning) << "  Expected trace (according to class hierarchy definitions):" << endl << "    ";
-            for (std::list<const Identifier*>::const_iterator it_parent = expectedIdentifierTrace.begin(); it_parent != expectedIdentifierTrace.end(); ++it_parent)
-                orxout(internal_warning) << " " << (*it_parent)->getName();
+            for (const Identifier* parent : expectedIdentifierTrace)
+                orxout(internal_warning) << " " << parent->getName();
             orxout(internal_warning) << endl;
 
             orxout(internal_warning) << "  Direct parents (according to class hierarchy definitions):" << endl << "    ";
-            for (std::list<const Identifier*>::const_iterator it_parent = this->directParents_.begin(); it_parent != this->directParents_.end(); ++it_parent)
-                orxout(internal_warning) << " " << (*it_parent)->getName();
+            for (const Identifier* directParent : this->directParents_)
+                orxout(internal_warning) << " " << directParent->getName();
             orxout(internal_warning) << endl;
         }
@@ -393 +393 @@
             return it->second;
         else
-            return 0;
+            return nullptr;
     }
 
@@ -407 +407 @@
             return it->second;
         else
-            return 0;
+            return nullptr;
     }
 
@@ -438 +438 @@
             return it->second;
         else
-            return 0;
+            return nullptr;
     }
 

code/trunk/src/libraries/core/class/Identifier.h

@@ -56 +56 @@
     object->getIdentifier()->getName();                                         // returns "MyClass"
 
-    Identifiable* other = object->getIdentifier()->fabricate(0);                // fabricates a new instance of MyClass
+    Identifiable* other = object->getIdentifier()->fabricate(nullptr);                // fabricates a new instance of MyClass
 
 
@@ -80 +80 @@
 #include <typeinfo>
 #include <loki/TypeTraits.h>
-#include <boost/static_assert.hpp>
-#include <boost/type_traits/is_base_of.hpp>
 
 #include "util/Output.h"
@@ -120 +118 @@
         public:
             Identifier(const std::string& name, Factory* factory, bool bLoadable);
-            Identifier(const Identifier& identifier); // don't copy
             virtual ~Identifier();
+
+            // non-copyable:
+            Identifier(const Identifier&) = delete;
+            Identifier& operator=(const Identifier&) = delete;
 
             /// Returns the name of the class the Identifier belongs to.
@@ -137 +138 @@
 
             /// Returns true if the Identifier has a Factory.
-            inline bool hasFactory() const { return (this->factory_ != 0); }
+            inline bool hasFactory() const { return (this->factory_ != nullptr); }
 
             Identifiable* fabricate(Context* context);
@@ -203 +204 @@
             /// Returns the map that stores all XMLPort params.
             inline const std::map<std::string, XMLPortParamContainer*>& getXMLPortParamMap() const { return this->xmlportParamContainers_; }
-            /// Returns a const_iterator to the beginning of the map that stores all XMLPort params.
-            inline std::map<std::string, XMLPortParamContainer*>::const_iterator getXMLPortParamMapBegin() const { return this->xmlportParamContainers_.begin(); }
-            /// Returns a const_iterator to the end of the map that stores all XMLPort params.
-            inline std::map<std::string, XMLPortParamContainer*>::const_iterator getXMLPortParamMapEnd() const { return this->xmlportParamContainers_.end(); }
 
             /// Returns the map that stores all XMLPort objects.
             inline const std::map<std::string, XMLPortObjectContainer*>& getXMLPortObjectMap() const { return this->xmlportObjectContainers_; }
-            /// Returns a const_iterator to the beginning of the map that stores all XMLPort objects.
-            inline std::map<std::string, XMLPortObjectContainer*>::const_iterator getXMLPortObjectMapBegin() const { return this->xmlportObjectContainers_.begin(); }
-            /// Returns a const_iterator to the end of the map that stores all XMLPort objects.
-            inline std::map<std::string, XMLPortObjectContainer*>::const_iterator getXMLPortObjectMapEnd() const { return this->xmlportObjectContainers_.end(); }
 
             void addXMLPortParamContainer(const std::string& paramname, XMLPortParamContainer* container);
@@ -269 +262 @@
     class ClassIdentifier : public Identifier
     {
-        BOOST_STATIC_ASSERT((boost::is_base_of<Identifiable, T>::value));
+        static_assert(std::is_base_of<Identifiable, T>::value, "ClassIdentifier can only be used with Identifiables");
 
         #ifndef DOXYGEN_SHOULD_SKIP_THIS
@@ -279 +272 @@
             ClassIdentifier(const std::string& name, Factory* factory, bool bLoadable) : Identifier(name, factory, bLoadable)
             {
-                OrxVerify(ClassIdentifier<T>::classIdentifier_s == NULL, "Assertion failed in ClassIdentifier of type " << typeid(T).name());
+                OrxVerify(ClassIdentifier<T>::classIdentifier_s == nullptr, "Assertion failed in ClassIdentifier of type " << typeid(T).name());
                 ClassIdentifier<T>::classIdentifier_s = this;
 
@@ -291 +284 @@
             bool initializeObject(T* object);
 
-            virtual void updateConfigValues(bool updateChildren = true) const;
-
-            virtual const std::type_info& getTypeInfo()
+            virtual void updateConfigValues(bool updateChildren = true) const override;
+
+            virtual const std::type_info& getTypeInfo() override
                 { return typeid(T); }
 
-            virtual bool canDynamicCastObjectToIdentifierClass(Identifiable* object) const
-                { return dynamic_cast<T*>(object) != 0; }
-
-            virtual void destroyObjects();
+            virtual bool canDynamicCastObjectToIdentifierClass(Identifiable* object) const override
+                { return dynamic_cast<T*>(object) != nullptr; }
+
+            virtual void destroyObjects() override;
 
             static ClassIdentifier<T>* getIdentifier();
 
         private:
-            ClassIdentifier(const ClassIdentifier<T>& identifier) {}    // don't copy
+            // non-copyable:
+            ClassIdentifier(const ClassIdentifier<T>&) = delete;
+            ClassIdentifier& operator=(const ClassIdentifier<T>&) = delete;
 
             void setConfigValues(T* object, Configurable*) const;
@@ -321 +316 @@
             void updateConfigValues(bool updateChildren, Identifiable*) const;
 
-            static WeakPtr<ClassIdentifier<T> > classIdentifier_s;
+            static WeakPtr<ClassIdentifier<T>> classIdentifier_s;
     };
 
     template <class T>
-    WeakPtr<ClassIdentifier<T> > ClassIdentifier<T>::classIdentifier_s;
+    WeakPtr<ClassIdentifier<T>> ClassIdentifier<T>::classIdentifier_s;
 
     /**
@@ -334 +329 @@
     /*static*/ inline ClassIdentifier<T>* ClassIdentifier<T>::getIdentifier()
     {
-        if (ClassIdentifier<T>::classIdentifier_s == NULL)
+        if (ClassIdentifier<T>::classIdentifier_s == nullptr)
             ClassIdentifier<T>::classIdentifier_s = (ClassIdentifier<T>*) IdentifierManager::getInstance().getIdentifierByTypeInfo(typeid(T));
 
-        OrxVerify(ClassIdentifier<T>::classIdentifier_s != NULL, "Did you forget to register the class of type " << typeid(T).name() << "?");
+        OrxVerify(ClassIdentifier<T>::classIdentifier_s != nullptr, "Did you forget to register the class of type " << typeid(T).name() << "?");
         return ClassIdentifier<T>::classIdentifier_s;
     }
@@ -365 +360 @@
 
             // Add pointer of type T to the map in the Identifiable instance that enables "dynamic_casts"
-            object->objectPointers_.push_back(std::make_pair(this->getClassID(), static_cast<void*>(object)));
+            object->objectPointers_.emplace_back(this->getClassID(), static_cast<void*>(object));
             return false;
         }
@@ -408 +403 @@
     void ClassIdentifier<T>::destroyObjects()
     {
-        this->destroyObjects((T*)0);
+        this->destroyObjects((T*)nullptr);
     }
 
@@ -417 +412 @@
     void ClassIdentifier<T>::destroyObjects(Listable*)
     {
-        ObjectListBase* objectList = Context::getRootContext()->getObjectList(this);
-        ObjectListElement<T>* begin = static_cast<ObjectListElement<T>*>(objectList->begin());
-        ObjectListElement<T>* end = static_cast<ObjectListElement<T>*>(objectList->end());
-        for (typename ObjectList<T>::iterator it = begin; it != end; )
+        ObjectList<T> list(Context::getRootContext()->getObjectList(this));
+        for (typename ObjectList<T>::iterator it = list.begin(); it != list.end(); )
             this->destroyObject(*(it++));
     }
@@ -451 +444 @@
     void ClassIdentifier<T>::updateConfigValues(bool updateChildren) const
     {
-        this->updateConfigValues(updateChildren, static_cast<T*>(NULL));
+        this->updateConfigValues(updateChildren, static_cast<T*>(nullptr));
     }
 
@@ -460 +453 @@
             return;
 
-        for (ObjectListIterator<T> it = ObjectList<T>::begin(); it; ++it)
-            this->setConfigValues(*it, *it);
+        for (T* object : ObjectList<T>())
+            this->setConfigValues(object, object);
 
         if (updateChildren)
-            for (std::set<const Identifier*>::const_iterator it = this->getChildren().begin(); it != this->getChildren().end(); ++it)
-                (*it)->updateConfigValues(false);
+            for (const Identifier* child : this->getChildren())
+                child->updateConfigValues(false);
     }
 
@@ -483 +476 @@
         registered in the class hierarchy.
     @return
-        Returns NULL if the cast is not possible
+        Returns nullptr if the cast is not possible
     @note
-        In case of NULL return (and using MSVC), a dynamic_cast might still be possible if
+        In case of nullptr return (and using MSVC), a dynamic_cast might still be possible if
         a class forgot to register its objects.
         Also note that the function is implemented differently for GCC/MSVC.
@@ -494 +487 @@
 #ifdef ORXONOX_COMPILER_MSVC
         typedef Loki::TypeTraits<typename Loki::TypeTraits<T>::PointeeType>::NonConstType ClassType;
-        if (source != NULL)
+        if (source != nullptr)
             return source->template getDerivedPointer<ClassType>(ClassIdentifier<ClassType>::getIdentifier()->getClassID());
         else
-            return NULL;
+            return nullptr;
 #else
         return dynamic_cast<T>(source);

code/trunk/src/libraries/core/class/IdentifierManager.cc

@@ -44 +44 @@
 namespace orxonox
 {
-    IdentifierManager* IdentifierManager::singletonPtr_s = 0;
+    IdentifierManager* IdentifierManager::singletonPtr_s = nullptr;
 
     IdentifierManager::IdentifierManager()
     {
         this->hierarchyCreatingCounter_s = 0;
-        this->recordTraceForIdentifier_ = NULL;
+        this->recordTraceForIdentifier_ = nullptr;
     }
 
@@ -60 +60 @@
 
         this->identifiers_.insert(identifier);
+        this->identifierByTypeIndex_[identifier->getTypeInfo()] = identifier;
         this->identifierByString_[identifier->getName()] = identifier;
         this->identifierByLowercaseString_[getLowercase(identifier->getName())] = identifier;
@@ -71 +72 @@
     {
         this->identifiers_.erase(identifier);
+        this->identifierByTypeIndex_.erase(identifier->getTypeInfo());
         this->identifierByString_.erase(identifier->getName());
         this->identifierByLowercaseString_.erase(getLowercase(identifier->getName()));
@@ -92 +94 @@
         // iterate over all identifiers, create one instance of each class and initialize the identifiers
         {
-            Context temporaryContext(NULL);
-            for (std::set<Identifier*>::const_iterator it = this->identifiers_.begin(); it != this->identifiers_.end(); ++it)
+            Context temporaryContext(nullptr);
+            for (Identifier* identifier : this->identifiers_)
             {
-                Identifier* identifier = (*it);
                 if (identifier->isInitialized())
                     continue;
@@ -108 +109 @@
                     Identifiable* temp = identifier->fabricate(&temporaryContext);
 
-                    this->recordTraceForIdentifier_ = NULL;
+                    this->recordTraceForIdentifier_ = nullptr;
 
                     if (temp->getIdentifier() != identifier)
@@ -127 +128 @@
 
         // finish the initialization of all identifiers
-        for (std::set<Identifier*>::const_iterator it = initializedIdentifiers.begin(); it != initializedIdentifiers.end(); ++it)
-            (*it)->finishInitialization();
+        for (Identifier* initializedIdentifier : initializedIdentifiers)
+            initializedIdentifier->finishInitialization();
 
         // only check class hierarchy in dev mode because it's an expensive operation and it requires a developer to fix detected problems anyway.
@@ -144 +145 @@
     {
         // check if there are any uninitialized identifiers remaining
-        for (std::set<Identifier*>::const_iterator it = this->identifiers_.begin(); it != this->identifiers_.end(); ++it)
-            if (!(*it)->isInitialized())
-                orxout(internal_error) << "Identifier was registered late and is not initialized: " << (*it)->getName() << " / " << (*it)->getTypeInfo().name() << endl;
+        for (Identifier* identifier : this->identifiers_)
+            if (!identifier->isInitialized())
+                orxout(internal_error) << "Identifier was registered late and is not initialized: " << identifier->getName() << " / " << identifier->getTypeInfo().name() << endl;
 
         // for all initialized identifiers, check if a sample instance behaves as expected according to the class hierarchy
-        Context temporaryContext(NULL);
-        for (std::set<Identifier*>::const_iterator it1 = initializedIdentifiers.begin(); it1 != initializedIdentifiers.end(); ++it1)
+        Context temporaryContext(nullptr);
+        for (Identifier* initializedIdentifier : initializedIdentifiers)
         {
-            if (!(*it1)->hasFactory())
+            if (!initializedIdentifier->hasFactory())
                 continue;
 
-            Identifiable* temp = (*it1)->fabricate(&temporaryContext);
-
-            for (std::set<Identifier*>::const_iterator it2 = this->identifiers_.begin(); it2 != this->identifiers_.end(); ++it2)
+            Identifiable* temp = initializedIdentifier->fabricate(&temporaryContext);
+
+            for (Identifier* identifier : this->identifiers_)
             {
-                bool isA_AccordingToRtti = (*it2)->canDynamicCastObjectToIdentifierClass(temp);
-                bool isA_AccordingToClassHierarchy = temp->isA((*it2));
+                bool isA_AccordingToRtti = identifier->canDynamicCastObjectToIdentifierClass(temp);
+                bool isA_AccordingToClassHierarchy = temp->isA(identifier);
 
                 if (isA_AccordingToRtti != isA_AccordingToClassHierarchy)
                 {
-                    orxout(internal_error) << "Class hierarchy does not match RTTI: Class hierarchy claims that " << (*it1)->getName() <<
-                        (isA_AccordingToClassHierarchy ? " is a " : " is not a ") << (*it2)->getName() << " but RTTI says the opposite." << endl;
+                    orxout(internal_error) << "Class hierarchy does not match RTTI: Class hierarchy claims that " << initializedIdentifier->getName() <<
+                        (isA_AccordingToClassHierarchy ? " is a " : " is not a ") << identifier->getName() << " but RTTI says the opposite." << endl;
                 }
             }
@@ -184 +185 @@
     {
         orxout(internal_status) << "Destroy class-hierarchy" << endl;
-        for (std::set<Identifier*>::const_iterator it = this->identifiers_.begin(); it != this->identifiers_.end(); ++it)
-            (*it)->reset();
+        for (Identifier* identifier : this->identifiers_)
+            identifier->reset();
     }
 
@@ -221 +222 @@
             return it->second;
         else
-            return 0;
+            return nullptr;
     }
 
@@ -235 +236 @@
             return it->second;
         else
-            return 0;
+            return nullptr;
     }
 
@@ -249 +250 @@
             return it->second;
         else
-            return 0;
+            return nullptr;
     }
 
@@ -259 +260 @@
     Identifier* IdentifierManager::getIdentifierByTypeInfo(const std::type_info& typeInfo)
     {
-        // TODO: use std::type_index and a map to find identifiers by type_info (only with c++11)
-        for (std::set<Identifier*>::iterator it = this->identifiers_.begin(); it != this->identifiers_.end(); ++it)
-            if ((*it)->getTypeInfo() == typeInfo)
-                return (*it);
-        return 0;
+        auto it = this->identifierByTypeIndex_.find(typeInfo);
+        if (it != this->identifierByTypeIndex_.end())
+            return it->second;
+        else
+            return nullptr;
     }
 

code/trunk/src/libraries/core/class/IdentifierManager.h

@@ -37 +37 @@
 #include "core/CorePrereqs.h"
 
+#include <typeindex>
 #include <map>
+#include <unordered_map>
 #include <set>
 #include <list>
@@ -52 +54 @@
         public:
             IdentifierManager();
-            ~IdentifierManager() {}
+            ~IdentifierManager() = default;
 
             void addIdentifier(Identifier* identifier);
@@ -93 +95 @@
 
         private:
-            IdentifierManager(const IdentifierManager&); // not implemented
+            // non-copyable:
+            IdentifierManager(const IdentifierManager&) = delete;
+            IdentifierManager& operator=(const IdentifierManager&) = delete;
 
             /// Increases the hierarchyCreatingCounter_s variable, causing all new objects to store their parents.
@@ -102 +106 @@
                 { hierarchyCreatingCounter_s--; }
 
-            std::set<Identifier*> identifiers_;                              //!< All identifiers. This is only used internally.
-            std::map<std::string, Identifier*> identifierByString_;          //!< Map that stores all Identifiers with their names.
-            std::map<std::string, Identifier*> identifierByLowercaseString_; //!< Map that stores all Identifiers with their names in lowercase.
-            std::map<uint32_t, Identifier*> identifierByNetworkId_;          //!< Returns the map that stores all Identifiers with their network IDs.
+            std::set<Identifier*> identifiers_;                                      //!< All identifiers. This is only used internally.
+            std::unordered_map<std::type_index, Identifier*> identifierByTypeIndex_; //!< Map that stores all Identifiers with their type_index.
+            std::map<std::string, Identifier*> identifierByString_;                  //!< Map that stores all Identifiers with their names.
+            std::map<std::string, Identifier*> identifierByLowercaseString_;         //!< Map that stores all Identifiers with their names in lowercase.
+            std::map<uint32_t, Identifier*> identifierByNetworkId_;                  //!< Returns the map that stores all Identifiers with their network IDs.
 
             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)
@@ -111 +116 @@
             /// Used while creating the object hierarchy to keep track of the identifiers of a newly created object (and all other objects that get created as
             /// a consequence of this, e.g. nested member objects).
-            std::map<Identifiable*, std::list<const Identifier*> > identifierTraceOfNewObject_;
+            std::map<Identifiable*, std::list<const Identifier*>> identifierTraceOfNewObject_;
             Identifier* recordTraceForIdentifier_; //!< The identifier for which we want to record the trace of identifiers during object creation. If null, no trace is recorded.
 

code/trunk/src/libraries/core/class/SubclassIdentifier.h

@@ -127 +127 @@
                     else
                     {
-                        orxout(internal_error) << "Can't assign NULL identifier" << endl;
+                        orxout(internal_error) << "Can't assign nullptr identifier" << endl;
                     }
                 }
@@ -189 +189 @@
                     orxout(user_error) << "Aborting..." << endl;
                     abort();
-                    return 0;
+                    return nullptr;
                 }
             }

code/trunk/src/libraries/core/class/Super.h

@@ -94 +94 @@
             static void superCheck() \
             { \
-                SuperFunctionCondition<functionnumber, T, 0, templatehack2>::apply(static_cast<T*>(0)); \
+                SuperFunctionCondition<functionnumber, T, 0, templatehack2>::apply(static_cast<T*>(nullptr)); \
                 SuperFunctionCondition<functionnumber + 1, T, 0, templatehack2>::superCheck(); \
             } \
@@ -103 +103 @@
             { \
                 ClassIdentifier<T>* identifier = ClassIdentifier<T>::getIdentifier(); \
-                for (std::set<const Identifier*>::iterator it = identifier->getDirectChildren().begin(); it != identifier->getDirectChildren().end(); ++it) \
+                for (const Identifier* child : identifier->getDirectChildren()) \
                 { \
-                    if (((ClassIdentifier<T>*)(*it))->bSuperFunctionCaller_##functionname##_isFallback_ && ((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_) \
+                    if (((ClassIdentifier<T>*)child)->bSuperFunctionCaller_##functionname##_isFallback_ && ((ClassIdentifier<T>*)child)->superFunctionCaller_##functionname##_) \
                     { \
-                        delete ((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_; \
-                        ((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_ = 0; \
-                        ((ClassIdentifier<T>*)(*it))->bSuperFunctionCaller_##functionname##_isFallback_ = false; \
+                        delete ((ClassIdentifier<T>*)child)->superFunctionCaller_##functionname##_; \
+                        ((ClassIdentifier<T>*)child)->superFunctionCaller_##functionname##_ = nullptr; \
+                        ((ClassIdentifier<T>*)child)->bSuperFunctionCaller_##functionname##_isFallback_ = false; \
                     } \
                     \
-                    if (!((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_) \
+                    if (!((ClassIdentifier<T>*)child)->superFunctionCaller_##functionname##_) \
                     { \
-                        orxout(verbose, context::super) << "Added SuperFunctionCaller for " << #functionname << ": " << ClassIdentifier<T>::getIdentifier()->getName() << " <- " << ((ClassIdentifier<T>*)(*it))->getName() << endl; \
-                        ((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_ = new SuperFunctionClassCaller_##functionname <T>; \
+                        orxout(verbose, context::super) << "Added SuperFunctionCaller for " << #functionname << ": " << ClassIdentifier<T>::getIdentifier()->getName() << " <- " << ((ClassIdentifier<T>*)child)->getName() << endl; \
+                        ((ClassIdentifier<T>*)child)->superFunctionCaller_##functionname##_ = new SuperFunctionClassCaller_##functionname <T>; \
                     } \
-                    else if (((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_->getParentIdentifier() != ClassIdentifier<T>::getIdentifier()) \
-                        orxout(internal_warning, context::super) << "SuperFunctionCaller for " << #functionname << " in " << ((ClassIdentifier<T>*)(*it))->getName() << " calls function of " << ((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_->getParentIdentifier()->getName() << " but " << ClassIdentifier<T>::getIdentifier()->getName() << " is also possible (do you use multiple inheritance?)" << endl; \
+                    else if (((ClassIdentifier<T>*)child)->superFunctionCaller_##functionname##_->getParentIdentifier() != ClassIdentifier<T>::getIdentifier()) \
+                        orxout(internal_warning, context::super) << "SuperFunctionCaller for " << #functionname << " in " << ((ClassIdentifier<T>*)child)->getName() << " calls function of " << ((ClassIdentifier<T>*)child)->superFunctionCaller_##functionname##_->getParentIdentifier()->getName() << " but " << ClassIdentifier<T>::getIdentifier()->getName() << " is also possible (do you use multiple inheritance?)" << endl; \
                 } \
             } \
@@ -154 +154 @@
                 // This call to the apply-function is the whole check. By calling the function with
                 // a T* pointer, the right function get's called.
-                SuperFunctionCondition<functionnumber, T, 0, templatehack2>::apply(static_cast<T*>(0));
+                SuperFunctionCondition<functionnumber, T, 0, templatehack2>::apply(static_cast<T*>(nullptr));
 
                 // Go go the superCheck for of next super-function (functionnumber + 1)
@@ -171 +171 @@
 
                 // Iterate through all children
-                for (std::set<const Identifier*>::iterator it = identifier->getDirectChildren().begin(); it != identifier->getDirectChildren().end(); ++it)
+                for (const Identifier* child : identifier->getDirectChildren())
                 {
                     // Check if the caller is a fallback-caller
-                    if (((ClassIdentifier<T>*)(*it))->bSuperFunctionCaller_##functionname##_isFallback_ && ((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_)
+                    if (((ClassIdentifier<T>*)child)->bSuperFunctionCaller_##functionname##_isFallback_ && ((ClassIdentifier<T>*)child)->superFunctionCaller_##functionname##_)
                     {
                         // Delete the fallback caller an prepare to get a real caller
-                        delete ((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_;
-                        ((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_ = 0;
-                        ((ClassIdentifier<T>*)(*it))->bSuperFunctionCaller_##functionname##_isFallback_ = false;
+                        delete ((ClassIdentifier<T>*)child)->superFunctionCaller_##functionname##_;
+                        ((ClassIdentifier<T>*)child)->superFunctionCaller_##functionname##_ = nullptr;
+                        ((ClassIdentifier<T>*)child)->bSuperFunctionCaller_##functionname##_isFallback_ = false;
                     }
 
                     // Check if there's not already a caller
-                    if (!((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_)
+                    if (!((ClassIdentifier<T>*)child)->superFunctionCaller_##functionname##_)
                     {
                         // Add the SuperFunctionCaller
-                        orxout(verbose, context::super) << "adding functionpointer to " << ((ClassIdentifier<T>*)(*it))->getName() << endl;
-                        ((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_ = new SuperFunctionClassCaller_##functionname <T>;
+                        orxout(verbose, context::super) << "adding functionpointer to " << ((ClassIdentifier<T>*)child)->getName() << endl;
+                        ((ClassIdentifier<T>*)child)->superFunctionCaller_##functionname##_ = new SuperFunctionClassCaller_##functionname <T>;
                     }
 
                     // If there is already a caller, but for another parent, print a warning
-                    else if (((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_->getParentIdentifier() != ClassIdentifier<T>::getIdentifier())
-                        orxout(internal_warning, context::super) << "SuperFunctionCaller for " << #functionname << " in " << ((ClassIdentifier<T>*)(*it))->getName() << " calls function of " << ((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_->getParentIdentifier()->getName() << " but " << ClassIdentifier<T>::getIdentifier()->getName() << " is also possible (do you use multiple inheritance?)" << endl;
+                    else if (((ClassIdentifier<T>*)child)->superFunctionCaller_##functionname##_->getParentIdentifier() != ClassIdentifier<T>::getIdentifier())
+                        orxout(internal_warning, context::super) << "SuperFunctionCaller for " << #functionname << " in " << ((ClassIdentifier<T>*)child)->getName() << " calls function of " << ((ClassIdentifier<T>*)child)->superFunctionCaller_##functionname##_->getParentIdentifier()->getName() << " but " << ClassIdentifier<T>::getIdentifier()->getName() << " is also possible (do you use multiple inheritance?)" << endl;
                 }
             }
@@ -584 +584 @@
         // Creates the super-function-callers by calling the first SuperFunctionCondition check
         // This get's called within the initialization of an Identifier
-        virtual void createSuperFunctionCaller() const
+        virtual void createSuperFunctionCaller() const override
         {
             SuperFunctionCondition<0, T, 0, 0>::superCheck();