Index: code/trunk/src/libraries/core/class/Identifier.h
===================================================================
--- code/trunk/src/libraries/core/class/Identifier.h	(revision 10624)
+++ code/trunk/src/libraries/core/class/Identifier.h	(revision 11071)
@@ -56,5 +56,5 @@
     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,6 +80,4 @@
 #include <typeinfo>
 #include <loki/TypeTraits.h>
-#include <boost/static_assert.hpp>
-#include <boost/type_traits/is_base_of.hpp>
 
 #include "util/Output.h"
@@ -120,6 +118,9 @@
         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,5 +138,5 @@
 
             /// 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,15 +204,7 @@
             /// 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,5 +262,5 @@
     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,5 +272,5 @@
             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,18 +284,20 @@
             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,9 +316,9 @@
             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,8 +329,8 @@
     /*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,5 +360,5 @@
 
             // 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,5 +403,5 @@
     void ClassIdentifier<T>::destroyObjects()
     {
-        this->destroyObjects((T*)0);
+        this->destroyObjects((T*)nullptr);
     }
 
@@ -417,8 +412,6 @@
     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,5 +444,5 @@
     void ClassIdentifier<T>::updateConfigValues(bool updateChildren) const
     {
-        this->updateConfigValues(updateChildren, static_cast<T*>(NULL));
+        this->updateConfigValues(updateChildren, static_cast<T*>(nullptr));
     }
 
@@ -460,10 +453,10 @@
             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,7 +476,7 @@
         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,8 +487,8 @@
 #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);
