Index: /code/branches/objecthierarchie/src/BaseObject.h
===================================================================
--- /code/branches/objecthierarchie/src/BaseObject.h	(revision 238)
+++ /code/branches/objecthierarchie/src/BaseObject.h	(revision 239)
@@ -12,54 +12,54 @@
             virtual ~BaseObject();
 
-            inline bool isA(Identifier* identifier)
+            inline bool isA(const Identifier* identifier)
                 { this->getIdentifier()->isA(identifier); }
-            inline bool isDirectlyA(Identifier* identifier)
+            inline bool isDirectlyA(const Identifier* identifier)
                 { this->getIdentifier()->isDirectlyA(identifier); }
-            inline bool isChildOf(Identifier* identifier)
+            inline bool isChildOf(const Identifier* identifier)
                 { this->getIdentifier()->isChildOf(identifier); }
-            inline bool isDirectChildOf(Identifier* identifier)
+            inline bool isDirectChildOf(const Identifier* identifier)
                 { this->getIdentifier()->isDirectChildOf(identifier); }
-            inline bool isParentOf(Identifier* identifier)
+            inline bool isParentOf(const Identifier* identifier)
                 { this->getIdentifier()->isParentOf(identifier); }
-            inline bool isDirectParentOf(Identifier* identifier)
+            inline bool isDirectParentOf(const Identifier* identifier)
                 { this->getIdentifier()->isDirectParentOf(identifier); }
 
-            inline bool isA(BaseIdentifier<class B>* identifier)
+            inline bool isA(const BaseIdentifier<class B>* identifier)
                 { this->getIdentifier()->isA(identifier->getIdentifier()); }
-            inline bool isDirectlyA(BaseIdentifier<class B>* identifier)
+            inline bool isDirectlyA(const BaseIdentifier<class B>* identifier)
                 { this->getIdentifier()->isDirectlyA(identifier->getIdentifier()); }
-            inline bool isChildOf(BaseIdentifier<class B>* identifier)
+            inline bool isChildOf(const BaseIdentifier<class B>* identifier)
                 { this->getIdentifier()->isChildOf(identifier->getIdentifier()); }
-            inline bool isDirectChildOf(BaseIdentifier<class B>* identifier)
+            inline bool isDirectChildOf(const BaseIdentifier<class B>* identifier)
                 { this->getIdentifier()->isDirectChildOf(identifier->getIdentifier()); }
-            inline bool isParentOf(BaseIdentifier<class B>* identifier)
+            inline bool isParentOf(const BaseIdentifier<class B>* identifier)
                 { this->getIdentifier()->isParentOf(identifier->getIdentifier()); }
-            inline bool isDirectParentOf(BaseIdentifier<class B>* identifier)
+            inline bool isDirectParentOf(const BaseIdentifier<class B>* identifier)
                 { this->getIdentifier()->isDirectParentOf(identifier->getIdentifier()); }
 
-            inline bool isA(BaseIdentifier<class B> identifier)
+            inline bool isA(const BaseIdentifier<class B> identifier)
                 { this->getIdentifier()->isA(identifier.getIdentifier()); }
-            inline bool isDirectlyA(BaseIdentifier<class B> identifier)
+            inline bool isDirectlyA(const BaseIdentifier<class B> identifier)
                 { this->getIdentifier()->isDirectlyA(identifier.getIdentifier()); }
-            inline bool isChildOf(BaseIdentifier<class B> identifier)
+            inline bool isChildOf(const BaseIdentifier<class B> identifier)
                 { this->getIdentifier()->isChildOf(identifier.getIdentifier()); }
-            inline bool isDirectChildOf(BaseIdentifier<class B> identifier)
+            inline bool isDirectChildOf(const BaseIdentifier<class B> identifier)
                 { this->getIdentifier()->isDirectChildOf(identifier.getIdentifier()); }
-            inline bool isParentOf(BaseIdentifier<class B> identifier)
+            inline bool isParentOf(const BaseIdentifier<class B> identifier)
                 { this->getIdentifier()->isParentOf(identifier.getIdentifier()); }
-            inline bool isDirectParentOf(BaseIdentifier<class B> identifier)
+            inline bool isDirectParentOf(const BaseIdentifier<class B> identifier)
                 { this->getIdentifier()->isDirectParentOf(identifier.getIdentifier()); }
 
-            inline bool isA(OrxonoxClass* object)
+            inline bool isA(const OrxonoxClass* object)
                 { this->getIdentifier()->isA(object->getIdentifier()); }
-            inline bool isDirectlyA(OrxonoxClass* object)
+            inline bool isDirectlyA(const OrxonoxClass* object)
                 { this->getIdentifier()->isDirectlyA(object->getIdentifier()); }
-            inline bool isChildOf(OrxonoxClass* object)
+            inline bool isChildOf(const OrxonoxClass* object)
                 { this->getIdentifier()->isChildOf(object->getIdentifier()); }
-            inline bool isDirectChildOf(OrxonoxClass* object)
+            inline bool isDirectChildOf(const OrxonoxClass* object)
                 { this->getIdentifier()->isDirectChildOf(object->getIdentifier()); }
-            inline bool isParentOf(OrxonoxClass* object)
+            inline bool isParentOf(const OrxonoxClass* object)
                 { this->getIdentifier()->isParentOf(object->getIdentifier()); }
-            inline bool isDirectParentOf(OrxonoxClass* object)
+            inline bool isDirectParentOf(const OrxonoxClass* object)
                 { this->getIdentifier()->isDirectParentOf(object->getIdentifier()); }
 
Index: /code/branches/objecthierarchie/src/Identifier.cc
===================================================================
--- /code/branches/objecthierarchie/src/Identifier.cc	(revision 238)
+++ /code/branches/objecthierarchie/src/Identifier.cc	(revision 239)
@@ -11,4 +11,9 @@
     {
         this->bCreatedOneObject_ = false;
+
+        this->directChildren_ = new IdentifierList;
+        this->allChildren_ = new IdentifierList;
+        this->directParents_ = new IdentifierList;
+        this->allParents_ = new IdentifierList;
     }
 
@@ -16,7 +21,12 @@
     {
         delete &this->name_;
+
+        delete this->directChildren_;
+        delete this->allChildren_;
+        delete this->directParents_;
+        delete this->allParents_;
     }
 
-    void Identifier::initialize(IdentifierList* parents)
+    void Identifier::initialize(const IdentifierList* parents)
     {
 #if HIERARCHY_VERBOSE
@@ -34,5 +44,5 @@
             while (temp1)
             {
-                temp2 = temp1->identifier_->directParents_.first_;
+                temp2 = temp1->identifier_->directParents_->first_;
                 while (temp2)
                 {
@@ -56,10 +66,10 @@
                 if (temp1->bDirect_)
                 {
-                    this->directParents_.add(temp1->identifier_);
-                    temp1->identifier_->directChildren_.add(this);
+                    this->directParents_->add(temp1->identifier_);
+                    temp1->identifier_->directChildren_->add(this);
                 }
 
-                this->allParents_.add(temp1->identifier_);
-                temp1->identifier_->allChildren_.add(this);
+                this->allParents_->add(temp1->identifier_);
+                temp1->identifier_->allChildren_->add(this);
 
                 temp1 = temp1->next_;
@@ -68,32 +78,32 @@
     }
 
-    bool Identifier::isA(Identifier* identifier)
+    bool Identifier::isA(const Identifier* identifier) const
     {
-        return (identifier == this || this->allParents_.isInList(identifier));
+        return (identifier == this || this->allParents_->isInList(identifier));
     }
 
-    bool Identifier::isDirectlyA(Identifier* identifier)
+    bool Identifier::isDirectlyA(const Identifier* identifier) const
     {
         return (identifier == this);
     }
 
-    bool Identifier::isChildOf(Identifier* identifier)
+    bool Identifier::isChildOf(const Identifier* identifier) const
     {
-        return this->allParents_.isInList(identifier);
+        return this->allParents_->isInList(identifier);
     }
 
-    bool Identifier::isDirectChildOf(Identifier* identifier)
+    bool Identifier::isDirectChildOf(const Identifier* identifier) const
     {
-        return this->directParents_.isInList(identifier);
+        return this->directParents_->isInList(identifier);
     }
 
-    bool Identifier::isParentOf(Identifier* identifier)
+    bool Identifier::isParentOf(const Identifier* identifier) const
     {
-        return this->allChildren_.isInList(identifier);
+        return this->allChildren_->isInList(identifier);
     }
 
-    bool Identifier::isDirectParentOf(Identifier* identifier)
+    bool Identifier::isDirectParentOf(const Identifier* identifier) const
     {
-        return this->directChildren_.isInList(identifier);
+        return this->directChildren_->isInList(identifier);
     }
 }
Index: /code/branches/objecthierarchie/src/Identifier.h
===================================================================
--- /code/branches/objecthierarchie/src/Identifier.h	(revision 238)
+++ /code/branches/objecthierarchie/src/Identifier.h	(revision 239)
@@ -27,20 +27,20 @@
 
         public:
-            virtual void removeObject(OrxonoxClass* object) {};
-
-            virtual BaseObject* fabricate() {};
-
-            bool isA(Identifier* identifier);
-            bool isDirectlyA(Identifier* identifier);
-            bool isChildOf(Identifier* identifier);
-            bool isDirectChildOf(Identifier* identifier);
-            bool isParentOf(Identifier* identifier);
-            bool isDirectParentOf(Identifier* identifier);
-
-            std::string getName() { return this->name_; }
-            IdentifierList* getDirectParents() { return &(this->directParents_); }
-            IdentifierList* getAllParents() { return &(this->allParents_); }
-            IdentifierList* getDirectChildren() { return &(this->directChildren_); }
-            IdentifierList* getAllChildren() { return &(this->allChildren_); }
+            virtual void removeObject(OrxonoxClass* object) const = 0;
+
+            virtual BaseObject* fabricate() const = 0;
+
+            bool isA(const Identifier* identifier) const;
+            bool isDirectlyA(const Identifier* identifier) const;
+            bool isChildOf(const Identifier* identifier) const;
+            bool isDirectChildOf(const Identifier* identifier) const;
+            bool isParentOf(const Identifier* identifier) const;
+            bool isDirectParentOf(const Identifier* identifier) const;
+
+            const std::string& getName() const { return this->name_; }
+            const IdentifierList* getDirectParents() const { return this->directParents_; }
+            const IdentifierList* getAllParents() const { return this->allParents_; }
+            const IdentifierList* getDirectChildren() const { return this->directChildren_; }
+            const IdentifierList* getAllChildren() const { return this->allChildren_; }
 
             static bool isCreatingHierarchy() { return (hierarchyCreatingCounter_s > 0); }
@@ -50,5 +50,5 @@
             Identifier(const Identifier& identifier) {}
             virtual ~Identifier();
-            void initialize(IdentifierList* parents);
+            void initialize(const IdentifierList* parents);
 
             static void startCreatingHierarchy()
@@ -68,8 +68,8 @@
             }
 
-            IdentifierList directParents_;
-            IdentifierList allParents_;
-            IdentifierList directChildren_;
-            IdentifierList allChildren_;
+            IdentifierList* directParents_;
+            IdentifierList* allParents_;
+            IdentifierList* directChildren_;
+            IdentifierList* allChildren_;
 
             std::string name_;
@@ -92,10 +92,10 @@
 
         public:
-            static ClassIdentifier<T>* registerClass(IdentifierList* parents, std::string name, bool bRootClass, bool bIsAbstractClass);
+            static ClassIdentifier<T>* registerClass(const IdentifierList* parents, const std::string& name, bool bRootClass, bool bIsAbstractClass);
             static ClassIdentifier<T>* getIdentifier();
-            BaseObject* fabricate();
-            T* fabricateClass();
+            BaseObject* fabricate() const;
+            T* fabricateClass() const;
             static void addObject(T* object);
-            void removeObject(OrxonoxClass* object);
+            void removeObject(OrxonoxClass* object) const;
 
         private:
@@ -105,5 +105,5 @@
 
             static ClassIdentifier<T>* pointer_s;
-            ObjectList<T> objects_s;
+            ObjectList<T>* objects_;
     };
 
@@ -114,4 +114,5 @@
     ClassIdentifier<T>::ClassIdentifier()
     {
+        this->objects_ = new ObjectList<T>;
     }
 
@@ -119,9 +120,10 @@
     ClassIdentifier<T>::~ClassIdentifier()
     {
+        delete this->objects_;
         this->pointer_s = NULL;
     }
 
     template <class T>
-    BaseObject* ClassIdentifier<T>::fabricate()
+    BaseObject* ClassIdentifier<T>::fabricate() const
     {
         return dynamic_cast<BaseObject*>(this->fabricateClass());
@@ -129,5 +131,5 @@
 
     template <class T>
-    T* ClassIdentifier<T>::fabricateClass()
+    T* ClassIdentifier<T>::fabricateClass() const
     {
         if (!this->bIsAbstractClass_)
@@ -144,5 +146,5 @@
 
     template <class T>
-    ClassIdentifier<T>* ClassIdentifier<T>::registerClass(IdentifierList* parents, std::string name, bool bRootClass, bool bIsAbstractClass)
+    ClassIdentifier<T>* ClassIdentifier<T>::registerClass(const IdentifierList* parents, const std::string& name, bool bRootClass, bool bIsAbstractClass)
     {
 #if HIERARCHY_VERBOSE
@@ -202,9 +204,9 @@
         std::cout << "*** Added object to " << ClassIdentifier<T>::getIdentifier()->getName() << "-list.\n";
 #endif
-        ClassIdentifier<T>::getIdentifier()->objects_s.add(object);
-    }
-
-    template <class T>
-    void ClassIdentifier<T>::removeObject(OrxonoxClass* object)
+        ClassIdentifier<T>::getIdentifier()->objects_->add(object);
+    }
+
+    template <class T>
+    void ClassIdentifier<T>::removeObject(OrxonoxClass* object) const
     {
         bool bIterateForwards = !Identifier::isCreatingHierarchy();
@@ -217,7 +219,7 @@
 #endif
 
-        this->objects_s.remove(object, bIterateForwards);
-
-        IdentifierListElement* temp = this->directParents_.first_;
+        this->objects_->remove(object, bIterateForwards);
+
+        IdentifierListElement* temp = this->directParents_->first_;
         while (temp)
         {
@@ -285,17 +287,17 @@
             }
 
-            inline Identifier* getIdentifier()
+            inline const Identifier* getIdentifier() const
                 { return this->identifier_; }
-            inline bool isA(Identifier* identifier)
+            inline bool isA(const Identifier* identifier) const
                 { return this->identifier_->isA(identifier); }
-            inline bool isDirectlyA(Identifier* identifier)
+            inline bool isDirectlyA(const Identifier* identifier) const
                 { return this->identifier_->isDirectlyA(identifier); }
-            inline bool isChildOf(Identifier* identifier)
+            inline bool isChildOf(const Identifier* identifier) const
                 { return this->identifier_->isChildOf(identifier); }
-            inline bool isDirectChildOf(Identifier* identifier)
+            inline bool isDirectChildOf(const Identifier* identifier) const
                 { return this->identifier_->isDirectChildOf(identifier); }
-            inline bool isParentOf(Identifier* identifier)
+            inline bool isParentOf(const Identifier* identifier) const
                 { return this->identifier_->isParentOf(identifier); }
-            inline bool isDirectParentOf(Identifier* identifier)
+            inline bool isDirectParentOf(const Identifier* identifier) const
                 { return this->identifier_->isDirectParentOf(identifier); }
 
Index: /code/branches/objecthierarchie/src/IdentifierList.cc
===================================================================
--- /code/branches/objecthierarchie/src/IdentifierList.cc	(revision 238)
+++ /code/branches/objecthierarchie/src/IdentifierList.cc	(revision 239)
@@ -23,5 +23,5 @@
     }
 
-    void IdentifierList::add(Identifier* identifier)
+    void IdentifierList::add(const Identifier* identifier)
     {
         IdentifierListElement* temp = this->first_;
@@ -30,5 +30,5 @@
     }
 
-    void IdentifierList::remove(Identifier* identifier)
+    void IdentifierList::remove(const Identifier* identifier)
     {
         if (!identifier)
@@ -60,5 +60,5 @@
     }
 
-    bool IdentifierList::isInList(Identifier* identifier)
+    bool IdentifierList::isInList(const Identifier* identifier)
     {
         IdentifierListElement* temp = this->first_;
@@ -94,5 +94,5 @@
     // ###  IdentifierListElement  ###
     // ###############################
-    IdentifierListElement::IdentifierListElement(Identifier* identifier)
+    IdentifierListElement::IdentifierListElement(const Identifier* identifier)
     {
         this->identifier_ = identifier;
Index: /code/branches/objecthierarchie/src/IdentifierList.h
===================================================================
--- /code/branches/objecthierarchie/src/IdentifierList.h	(revision 238)
+++ /code/branches/objecthierarchie/src/IdentifierList.h	(revision 239)
@@ -11,8 +11,8 @@
     {
         public:
-            IdentifierListElement(Identifier* identifier);
+            IdentifierListElement(const Identifier* identifier);
             ~IdentifierListElement();
 
-            Identifier* identifier_;
+            const Identifier* identifier_;
             IdentifierListElement* next_;
             bool bDirect_;
@@ -24,7 +24,7 @@
             IdentifierList();
             ~IdentifierList();
-            void add(Identifier* identifier);
-            void remove(Identifier* identifier);
-            bool isInList(Identifier* identifier);
+            void add(const Identifier* identifier);
+            void remove(const Identifier* identifier);
+            bool isInList(const Identifier* identifier);
             std::string toString();
 
Index: /code/branches/objecthierarchie/src/Iterator.h
===================================================================
--- /code/branches/objecthierarchie/src/Iterator.h	(revision 238)
+++ /code/branches/objecthierarchie/src/Iterator.h	(revision 239)
@@ -10,6 +10,6 @@
             Iterator()
             {
-                this->elementForwards_ = ClassIdentifier<T>::getIdentifier()->objects_s.first_;
-                this->elementBackwards_ = ClassIdentifier<T>::getIdentifier()->objects_s.last_;
+                this->elementForwards_ = ClassIdentifier<T>::getIdentifier()->objects_->first_;
+                this->elementBackwards_ = ClassIdentifier<T>::getIdentifier()->objects_->last_;
                 this->iteratingForwards_ = true;
             }
Index: /code/branches/objecthierarchie/src/OrxonoxClass.h
===================================================================
--- /code/branches/objecthierarchie/src/OrxonoxClass.h	(revision 238)
+++ /code/branches/objecthierarchie/src/OrxonoxClass.h	(revision 239)
@@ -12,11 +12,11 @@
             OrxonoxClass();
             virtual ~OrxonoxClass();
-            Identifier* getIdentifier() { return this->identifier_; }
-            void setIdentifier(Identifier* identifier) { this->identifier_ = identifier; }
-            IdentifierList* getParents() { return this->parents_; }
+            const Identifier* getIdentifier() const { return this->identifier_; }
+            void setIdentifier(const Identifier* identifier) { this->identifier_ = identifier; }
+            IdentifierList* getParents() const { return this->parents_; }
             void setParents(IdentifierList* parents) { this->parents_ = parents; }
 
         private:
-            Identifier* identifier_;
+            const Identifier* identifier_;
             IdentifierList* parents_;
     };
