Index: code/branches/core3/src/core/CorePrereqs.h
===================================================================
--- code/branches/core3/src/core/CorePrereqs.h	(revision 1590)
+++ code/branches/core3/src/core/CorePrereqs.h	(revision 1591)
@@ -138,4 +138,8 @@
   class ObjectListBase;
   class ObjectListBaseElement;
+  template <class T>
+  class ObjectListElement;
+  template <class T>
+  class ObjectListIterator;
   class OrxonoxClass;
   class Shell;
@@ -153,4 +157,6 @@
   class XMLPortObjectContainer;
   class XMLPortParamContainer;
+
+  struct ObjectListBase::Export;
 
   // input
Index: code/branches/core3/src/core/Identifier.cc
===================================================================
--- code/branches/core3/src/core/Identifier.cc	(revision 1590)
+++ code/branches/core3/src/core/Identifier.cc	(revision 1591)
@@ -39,5 +39,5 @@
 #include "ConsoleCommand.h"
 #include "CommandExecutor.h"
-#include "MetaObjectList.h"
+#include "Iterator.h"
 #include "ObjectList.h"
 #include "OrxonoxClass.h"
@@ -197,11 +197,10 @@
 
     /**
-        @brief Adds an object of the given type to the ObjectList.
-        @param object The object to add
-    */
-    void Identifier::addObject(OrxonoxClass* object)
-    {
-        COUT(5) << "*** ClassIdentifier: Added object to " << this->getName() << "-list." << std::endl;
-        object->getMetaList().add(this->objects_, this->objects_->add(object));
+        @brief Updates the config-values of all existing objects of this class by calling their setConfigValues() function.
+    */
+    void Identifier::updateConfigValues() const
+    {
+        for (BaseIterator it = this->getObjects()->begin(); it; ++it)
+            (*it)->setConfigValues();
     }
 
Index: code/branches/core3/src/core/Identifier.h
===================================================================
--- code/branches/core3/src/core/Identifier.h	(revision 1590)
+++ code/branches/core3/src/core/Identifier.h	(revision 1591)
@@ -60,5 +60,6 @@
 #include <utility>
 
-#include "Iterator.h"
+#include "MetaObjectList.h"
+#include "ObjectListBase.h"
 #include "util/Debug.h"
 #include "util/String.h"
@@ -103,6 +104,4 @@
             bool isDirectParentOf(const Identifier* identifier) const;
 
-            void addObject(OrxonoxClass* object);
-
             /** @brief Returns the list of all existing objects of this class. @return The list */
             inline ObjectListBase* getObjects() const
@@ -113,5 +112,5 @@
             void setName(const std::string& name);
 
-            virtual void updateConfigValues() const = 0;
+            void updateConfigValues() const;
 
             /** @brief Returns the parents of the class the Identifier belongs to. @return The list of all parents */
@@ -231,4 +230,5 @@
 
             bool bCreatedOneObject_;                                       //!< True if at least one object of the given type was created (used to determine the need of storing the parents)
+            ObjectListBase* objects_;                                      //!< The list of all objects of this class
 
         private:
@@ -264,5 +264,4 @@
             bool bSetName_;                                                //!< True if the name is set
             std::string name_;                                             //!< The name of the class the Identifier belongs to
-            ObjectListBase* objects_;                                      //!< The list of all objects of this class
             BaseFactory* factory_;                                         //!< The Factory, able to create new objects of the given class (if available)
             static 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)
@@ -301,6 +300,5 @@
             void initializeClassHierarchy(std::set<const Identifier*>* parents, bool bRootClass);
             static bool isFirstCall();
-
-            void updateConfigValues() const;
+            void addObject(T* object);
 
             XMLPortParamContainer* getXMLPortParamContainer(const std::string& paramname);
@@ -411,11 +409,12 @@
 
     /**
-        @brief Updates the config-values of all existing objects of this class by calling their setConfigValues() function.
-    */
-    template <class T>
-    void ClassIdentifier<T>::updateConfigValues() const
-    {
-        for (Iterator<T> it = this->getObjects()->begin(); it; ++it)
-            (*it)->setConfigValues();
+        @brief Adds an object of the given type to the ObjectList.
+        @param object The object to add
+    */
+    template <class T>
+    void ClassIdentifier<T>::addObject(T* object)
+    {
+        COUT(5) << "*** ClassIdentifier: Added object to " << this->getName() << "-list." << std::endl;
+        object->getMetaList().add(this->objects_, this->objects_->add(new ObjectListElement<T>(object)));
     }
 
Index: code/branches/core3/src/core/Iterator.h
===================================================================
--- code/branches/core3/src/core/Iterator.h	(revision 1590)
+++ code/branches/core3/src/core/Iterator.h	(revision 1591)
@@ -31,9 +31,9 @@
     @brief Definition and implementation of the Iterator class.
 
-    The Iterator of a given class allows to iterate through an ObjectList, containing all objects of that type.
-    This is the only way to access the objects stored in an ObjectList.
+    The Iterator of a given class allows to iterate through an ObjectList. Objects in
+    this list are casted to the template argument of the Iterator.
 
     Usage:
-    for (Iterator<myClass> it = ObjectList<myClass>::begin(); it != ObjectList<myClass>::end(); ++it)
+    for (Iterator<myClass> it = anyidentifier->getObjects().begin(); it != anyidentifier->getObjects().end(); ++it)
     {
         it->someFunction(...);
@@ -47,11 +47,13 @@
 #include "CorePrereqs.h"
 
-#include "IteratorBase.h"
+#include "ObjectListBase.h"
+#include "ObjectListIterator.h"
+#include "OrxonoxClass.h"
 
 namespace orxonox
 {
-    //! The Iterator allows to iterate through the ObjectList of a given class.
-    template <class T>
-    class Iterator : public IteratorBase
+    //! The Iterator allows to iterate through a given ObjectList
+    template <class T = OrxonoxClass>
+    class Iterator
     {
         public:
@@ -61,14 +63,52 @@
             inline Iterator()
             {
-                ClassIdentifier<T>::getIdentifier()->getObjects()->registerIterator(this);
-            }
-
-            /**
-                @brief Constructor: Sets the element, whereon the iterator points, to a given element.
-                @param element The element to start with
-            */
-            inline Iterator(ObjectListBaseElement* element) : IteratorBase((ObjectListBaseElement*)element)
-            {
-                ClassIdentifier<T>::getIdentifier()->getObjects()->registerIterator(this);
+                this->element_ = 0;
+                this->list_ = 0;
+            }
+
+            /**
+                @brief Constructor: Sets this element to the exported element.
+                @param exp The exported element
+            */
+            inline Iterator(const ObjectListBase::Export& exp)
+            {
+                this->element_ = exp.element_;
+                this->list_ = exp.list_;
+                this->iterator_ = this->list_->registerIterator(this);
+            }
+
+            /**
+                @brief Constructor: Sets this element to the element of another Iterator.
+                @param other The other Iterator
+            */
+            inline Iterator(const Iterator<T>& other)
+            {
+                this->element_ = other.element_;
+                this->list_ = other.list_;
+                this->iterator_ = this->list_->registerIterator(this);
+            }
+
+            /**
+                @brief Constructor: Sets this element to a given element
+                @param element The element
+            */
+            template <class O>
+            inline Iterator(ObjectListElement<O>* element)
+            {
+                this->element_ = (element) ? (ObjectListBaseElement*)element : 0;
+                this->list_ = ClassIdentifier<O>::getIdentifier()->getObjects();
+                this->iterator_ = this->list_->registerIterator(this);
+            }
+
+            /**
+                @brief Constructor: Sets this element to the element an ObjectListIterator.
+                @param other The ObjectListIterator
+            */
+            template <class O>
+            inline Iterator(const ObjectListIterator<O>& other)
+            {
+                this->element_ = (other.element_) ? (ObjectListBaseElement*)other.element_ : 0;
+                this->list_ = ClassIdentifier<O>::getIdentifier()->getObjects();
+                this->iterator_ = this->list_->registerIterator(this);
             }
 
@@ -78,5 +118,71 @@
             inline ~Iterator()
             {
-                ClassIdentifier<T>::getIdentifier()->getObjects()->unregisterIterator(this);
+                this->list_->unregisterIterator(this->iterator_);
+            }
+
+            /**
+                @brief Assigns an exported element.
+                @param exp The exported element
+            */
+            inline const Iterator<T>& operator=(const ObjectListBase::Export& exp)
+            {
+                if (this->list_)
+                    this->list_->unregisterIterator(this->iterator_);
+
+                this->element_ = exp.element_;
+                this->list_ = exp.list_;
+                this->iterator_ = this->list_->registerIterator(this);
+
+                return (*this);
+            }
+
+            /**
+                @brief Assigns the element of another Iterator.
+                @param other The other Iterator
+            */
+            inline const Iterator<T>& operator=(const Iterator<T>& other)
+            {
+                if (this->list_)
+                    this->list_->unregisterIterator(this->iterator_);
+
+                this->element_ = other.element_;
+                this->list_ = other.list_;
+                this->iterator_ = this->list_->registerIterator(this);
+
+                return (*this);
+            }
+
+            /**
+                @brief Assigns a given element.
+                @param element The element
+            */
+            template <class O>
+            inline const Iterator<T>& operator=(ObjectListElement<O>* element)
+            {
+                if (this->list_)
+                    this->list_->unregisterIterator(this->iterator_);
+
+                this->element_ = (element) ? (ObjectListBaseElement*)element : 0;
+                this->list_ = ClassIdentifier<O>::getIdentifier()->getObjects();
+                this->iterator_ = this->list_->registerIterator(this);
+
+                return (*this);
+            }
+
+            /**
+                @brief Assigns the element of an ObjectListIterator.
+                @param other The ObjectListIterator
+            */
+            template <class O>
+            inline const Iterator<T>& operator=(const ObjectListIterator<O>& other)
+            {
+                if (this->list_)
+                    this->list_->unregisterIterator(this->iterator_);
+
+                this->element_ = (other.element_) ? (ObjectListBaseElement*)other.element_ : 0;
+                this->list_ = ClassIdentifier<O>::getIdentifier()->getObjects();
+                this->iterator_ = this->list_->registerIterator(this);
+
+                return (*this);
             }
 
@@ -85,7 +191,8 @@
                 @return The Iterator itself
             */
-            inline Iterator<T> operator++()
-            {
-                IteratorBase::operator++();
+            inline const Iterator<T>& operator++()
+            {
+                if (this->element_)
+                    this->element_ = this->element_->next_;
                 return *this;
             }
@@ -98,5 +205,6 @@
             {
                 Iterator<T> copy = *this;
-                IteratorBase::operator++();
+                if (this->element_)
+                    this->element_ = this->element_->next_;
                 return copy;
             }
@@ -106,7 +214,8 @@
                 @return The Iterator itself
             */
-            inline Iterator<T> operator--()
-            {
-                IteratorBase::operator--();
+            inline const Iterator<T>& operator--()
+            {
+                if (this->element_)
+                    this->element_ = this->element_->prev_;
                 return *this;
             }
@@ -119,5 +228,6 @@
             {
                 Iterator<T> copy = *this;
-                IteratorBase::operator--();
+                if (this->element_)
+                    this->element_ = this->element_->prev_;
                 return copy;
             }
@@ -127,7 +237,10 @@
                 @return The object the Iterator points at
             */
-            inline T* operator*()
-            {
-                return dynamic_cast<T*>(IteratorBase::operator*());
+            inline T* operator*() const
+            {
+                if (this->element_)
+                    return dynamic_cast<T*>(this->element_->objectBase_);
+                else
+                    return 0;
             }
 
@@ -138,5 +251,17 @@
             inline T* operator->() const
             {
-                return dynamic_cast<T*>(IteratorBase::operator->());
+                if (this->element_)
+                    return dynamic_cast<T*>(this->element_->objectBase_);
+                else
+                    return 0;
+            }
+
+            /**
+                @brief Overloading of the typecast-operator to bool: returns true if the iterator points to an existing object.
+                @return True if the Iterator points to an existing object.
+            */
+            inline operator bool() const
+            {
+                return (this->element_ != 0);
             }
 
@@ -146,5 +271,5 @@
                 @return True if the iterators point to the same element
             */
-            inline bool operator==(const Iterator<T>& compare)
+            inline bool operator==(const Iterator<T>& compare) const
             {
                 return (this->element_ == compare.element_);
@@ -156,9 +281,26 @@
                 @return True if the iterators point to different elements
             */
-            inline bool operator!=(const Iterator<T>& compare)
+            inline bool operator!=(const Iterator<T>& compare) const
             {
                 return (this->element_ != compare.element_);
             }
+
+            /**
+                @brief Increments the Iterator if it points at the given object.
+                @param object The object to compare with
+            */
+            inline void incrementIfEqual(OrxonoxClass* object)
+            {
+                if (this->element_ && this->element_->objectBase_ == object)
+                    this->operator++();
+            }
+
+        protected:
+            ObjectListBaseElement* element_;       //!< The element the Iterator points at
+            ObjectListBase* list_;                 //!< The list wherein the element is
+            std::list<void*>::iterator iterator_;  //!< The iterator in the notifying list of the ObjectList
     };
+
+    typedef Iterator<OrxonoxClass> BaseIterator;
 }
 
Index: code/branches/core3/src/core/IteratorBase.h
===================================================================
--- code/branches/core3/src/core/IteratorBase.h	(revision 1590)
+++ 	(revision )
@@ -1,190 +1,0 @@
-/*
- *   ORXONOX - the hottest 3D action shooter ever to exist
- *                    > www.orxonox.net <
- *
- *
- *   License notice:
- *
- *   This program is free software; you can redistribute it and/or
- *   modify it under the terms of the GNU General Public License
- *   as published by the Free Software Foundation; either version 2
- *   of the License, or (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- *   Author:
- *      Fabian 'x3n' Landau
- *   Co-authors:
- *      ...
- *
- */
-
-/**
-    @file IteratorBase.h
-    @brief Definition and implementation of the Iterator class.
-
-    The Iterator of a given class allows to iterate through an ObjectListBase, containing all objects of that type.
-    This is the only way to access the objects stored in an ObjectListBase.
-*/
-
-#ifndef _IteratorBase_H__
-#define _IteratorBase_H__
-
-#include "CorePrereqs.h"
-
-#include "ObjectListBase.h"
-
-namespace orxonox
-{
-    //! The IteratorBase allows to iterate through an ObjectListBase
-    class _CoreExport IteratorBase
-    {
-        public:
-            /**
-                @brief Default Constructor: Sets the element to zero.
-            */
-            inline IteratorBase()
-            {
-                this->element_ = 0;
-            }
-
-            /**
-                @brief Constructor: Sets the element, whereon the iterator points, to a given element.
-                @param element The element to start with
-            */
-            inline IteratorBase(ObjectListBaseElement* element)
-            {
-                this->element_ = element;
-            }
-
-            /**
-                @brief Constructor: Sets this element to the element of the other IteratorBase.
-                @param other The other IteratorBase
-            */
-            inline IteratorBase(const IteratorBase& other)
-            {
-                this->element_ = other.element_;
-            }
-
-            /**
-                @brief Assigns the element of another IteratorBase.
-                @param element The other IteratorBase
-            */
-            inline IteratorBase operator=(const IteratorBase& other)
-            {
-                this->element_ = other.element_;
-                return (*this);
-            }
-
-            /**
-                @brief Overloading of the ++it operator: IteratorBase points to the next object in the list.
-                @return The IteratorBase itself
-            */
-            inline IteratorBase operator++()
-            {
-                if (this->element_)
-                    this->element_ = this->element_->next_;
-                return (*this);
-            }
-
-            /**
-                @brief Overloading of the it++ operator: IteratorBase points to the next object in the list.
-                @return The IteratorBase itself
-            */
-            inline IteratorBase operator++(int i)
-            {
-                IteratorBase copy = *this;
-                if (this->element_)
-                    this->element_ = this->element_->next_;
-                return copy;
-            }
-
-            /**
-                @brief Overloading of the --it operator: IteratorBase points to the previous object in the list.
-                @return The IteratorBase itself
-            */
-            inline IteratorBase operator--()
-            {
-                if (this->element_)
-                    this->element_ = this->element_->prev_;
-                return (*this);
-            }
-
-            /**
-                @brief Overloading of the it-- operator: IteratorBase points to the previous object in the list.
-                @return The IteratorBase itself
-            */
-            inline IteratorBase operator--(int i)
-            {
-                IteratorBase copy = *this;
-                if (this->element_)
-                    this->element_ = this->element_->prev_;
-                return copy;
-            }
-
-            /**
-                @brief Overloading of the *it operator: returns the pointer to the object.
-                @return The object the IteratorBase points at
-            */
-            inline OrxonoxClass* operator*()
-            {
-                if (this->element_)
-                    return this->element_->object_;
-                else
-                    return 0;
-            }
-
-            /**
-                @brief Overloading of the it-> operator: returns the pointer to the object.
-                @return The object the IteratorBase points at
-            */
-            inline OrxonoxClass* operator->() const
-            {
-                if (this->element_)
-                    return this->element_->object_;
-                else
-                    return 0;
-            }
-
-            /**
-                @brief Overloading of the typecast-operator to bool: returns true if the iterator points to an existing object.
-                @return True if the IteratorBase points to an existing object.
-            */
-            inline operator bool()
-            {
-                return (this->element_ != 0);
-            }
-
-            /**
-                @brief Overloading of the == operator to compare with another IteratorBase.
-                @param compare The other IteratorBase
-                @return True if the iterators point to the same element
-            */
-            inline bool operator==(const IteratorBase& compare)
-            {
-                return (this->element_ == compare.element_);
-            }
-
-            /**
-                @brief Overloading of the != operator to compare with another IteratorBase.
-                @param compare The other IteratorBase
-                @return True if the iterators point to different elements
-            */
-            inline bool operator!=(const IteratorBase& compare)
-            {
-                return (this->element_ != compare.element_);
-            }
-
-        protected:
-            ObjectListBaseElement* element_;     //!< The element the Iterator points at
-    };
-}
-
-#endif /* _IteratorBase_H__ */
Index: code/branches/core3/src/core/MetaObjectList.cc
===================================================================
--- code/branches/core3/src/core/MetaObjectList.cc	(revision 1590)
+++ code/branches/core3/src/core/MetaObjectList.cc	(revision 1591)
@@ -33,4 +33,6 @@
 
 #include "MetaObjectList.h"
+#include "ObjectListBase.h"
+#include "Identifier.h"
 #include "util/Debug.h"
 
@@ -46,5 +48,5 @@
     {
         COUT(5) << "*** MetaObjectList: Removing Object from " << this->list_->getIdentifier()->getName() << "-list." << std::endl;
-        this->list_->notifyIterators(this->element_);
+        this->list_->notifyIterators(this->element_->objectBase_);
 
         if (this->element_->next_)
Index: code/branches/core3/src/core/MetaObjectList.h
===================================================================
--- code/branches/core3/src/core/MetaObjectList.h	(revision 1590)
+++ code/branches/core3/src/core/MetaObjectList.h	(revision 1591)
@@ -40,7 +40,4 @@
 
 #include "CorePrereqs.h"
-
-#include "ObjectListBase.h"
-#include "Identifier.h"
 
 namespace orxonox
Index: code/branches/core3/src/core/ObjectList.h
===================================================================
--- code/branches/core3/src/core/ObjectList.h	(revision 1590)
+++ code/branches/core3/src/core/ObjectList.h	(revision 1591)
@@ -41,5 +41,5 @@
 
 #include "Identifier.h"
-#include "Iterator.h"
+#include "ObjectListIterator.h"
 
 namespace orxonox
@@ -51,5 +51,5 @@
     /**
         Wraps the ObjectListBase of the corresponding Identifier.
-        Use Iterator<class> to iterate through all objects in the list.
+        Use ObjectListIterator<class> to iterate through all objects in the list.
     */
     template <class T>
@@ -57,19 +57,21 @@
     {
         public:
+            typedef ObjectListIterator<T> iterator;
+
             /** @brief Returns an Iterator to the first element in the list. @return The Iterator */
-            inline static Iterator<T> begin()
-                { return Iterator<T>(ClassIdentifier<T>::getIdentifier()->getObjects()->begin()); }
+            inline static ObjectListElement<T>* begin()
+                { return ((ObjectListElement<T>*)ClassIdentifier<T>::getIdentifier()->getObjects()->begin().element_); }
 
             /** @brief Returns an Iterator to the element after the last element in the list. @return The Iterator */
-            inline static Iterator<T> end()
-                { return Iterator<T>(ClassIdentifier<T>::getIdentifier()->getObjects()->end()); }
+            inline static ObjectListElement<T>* end()
+                { return ((ObjectListElement<T>*)ClassIdentifier<T>::getIdentifier()->getObjects()->end().element_); }
 
             /** @brief Returns an Iterator to the last element in the list. @return The Iterator */
-            inline static Iterator<T> rbegin()
-                { return Iterator<T>(ClassIdentifier<T>::getIdentifier()->getObjects()->rbegin()); }
+            inline static ObjectListElement<T>* rbegin()
+                { return ((ObjectListElement<T>*)ClassIdentifier<T>::getIdentifier()->getObjects()->rbegin().element_); }
 
             /** @brief Returns an Iterator to the element before the first element in the list. @return The Iterator */
-            inline static Iterator<T> rend()
-                { return Iterator<T>(ClassIdentifier<T>::getIdentifier()->getObjects()->rend()); }
+            inline static ObjectListElement<T>* rend()
+                { return ((ObjectListElement<T>*)ClassIdentifier<T>::getIdentifier()->getObjects()->rend().element_); }
     };
 }
Index: code/branches/core3/src/core/ObjectListBase.cc
===================================================================
--- code/branches/core3/src/core/ObjectListBase.cc	(revision 1590)
+++ code/branches/core3/src/core/ObjectListBase.cc	(revision 1591)
@@ -41,5 +41,5 @@
 #include "ObjectListBase.h"
 #include "Identifier.h"
-#include "IteratorBase.h"
+#include "Iterator.h"
 
 namespace orxonox
@@ -73,9 +73,10 @@
         @param element The element that gets removed
     */
-    void ObjectListBase::notifyIterators(ObjectListBaseElement* element)
+    void ObjectListBase::notifyIterators(OrxonoxClass* object) const
     {
-        for (std::set<IteratorBase*>::iterator it = this->iterators_.begin(); it != this->iterators_.end(); ++it)
-            if ((*(*(*it))) == element->object_)
-                ++(*(*it));
+        for (std::list<void*>::const_iterator it = this->iterators_.begin(); it != this->iterators_.end(); ++it)
+            ((Iterator<OrxonoxClass>*)(*it))->incrementIfEqual(object);
+        for (std::list<void*>::const_iterator it = this->objectListIterators_.begin(); it != this->objectListIterators_.end(); ++it)
+            ((ObjectListIterator<OrxonoxClass>*)(*it))->incrementIfEqual(object);
     }
 
@@ -85,10 +86,10 @@
         @return The pointer to the new ObjectListBaseElement, needed by the MetaObjectList of the added object
     */
-    ObjectListBaseElement* ObjectListBase::add(OrxonoxClass* object)
+    ObjectListBaseElement* ObjectListBase::add(ObjectListBaseElement* element)
     {
         if (!this->last_)
         {
             // If the list is empty
-            this->last_ = new ObjectListBaseElement(object);
+            this->last_ = element;
             this->first_ = this->last_; // There's only one object in the list now
         }
@@ -97,5 +98,5 @@
             // If the list isn't empty
             ObjectListBaseElement* temp = this->last_;
-            this->last_ = new ObjectListBaseElement(object);
+            this->last_ = element;
             this->last_->prev_ = temp;
             temp->next_ = this->last_;
Index: code/branches/core3/src/core/ObjectListBase.h
===================================================================
--- code/branches/core3/src/core/ObjectListBase.h	(revision 1590)
+++ code/branches/core3/src/core/ObjectListBase.h	(revision 1591)
@@ -38,5 +38,5 @@
 #define _ObjectListBase_H__
 
-#include <set>
+#include <list>
 
 #include "CorePrereqs.h"
@@ -55,9 +55,22 @@
                 @param object The object to store
             */
-            ObjectListBaseElement(OrxonoxClass* object) : object_(object), next_(0), prev_(0) {}
+            ObjectListBaseElement(OrxonoxClass* objectBase) : next_(0), prev_(0), objectBase_(objectBase) {}
 
-            OrxonoxClass* object_;              //!< The object
             ObjectListBaseElement* next_;       //!< The next element in the list
             ObjectListBaseElement* prev_;       //!< The previous element in the list
+            OrxonoxClass* objectBase_;
+    };
+
+
+    // ###############################
+    // ###    ObjectListElement    ###
+    // ###############################
+    //! The list-element that actually contains the object
+    template <class T>
+    class ObjectListElement : public ObjectListBaseElement
+    {
+        public:
+            ObjectListElement(T* object) : ObjectListBaseElement(object), object_(object) {}
+            T* object_;              //!< The object
     };
 
@@ -79,28 +92,36 @@
             ~ObjectListBase();
 
-            ObjectListBaseElement* add(OrxonoxClass* object);
+            ObjectListBaseElement* add(ObjectListBaseElement* element);
+
+            struct Export
+            {
+                Export(ObjectListBase* list, ObjectListBaseElement* element) : list_(list), element_(element) {}
+                ObjectListBase* list_;
+                ObjectListBaseElement* element_;
+            };
 
             /** @brief Returns a pointer to the first element in the list. @return The element */
-            inline ObjectListBaseElement* begin() const { return this->first_; }
+            inline Export begin() { return ObjectListBase::Export(this, this->first_); }
             /** @brief Returns a pointer to the element after the last element in the list. @return The element */
-            inline ObjectListBaseElement* end() const { return 0; }
+            inline Export end() { return ObjectListBase::Export(this, 0); }
             /** @brief Returns a pointer to the last element in the list. @return The element */
-            inline ObjectListBaseElement* rbegin() const { return this->last_; }
+            inline Export rbegin() { return ObjectListBase::Export(this, this->last_); }
             /** @brief Returns a pointer to the element in front of the first element in the list. @return The element */
-            inline ObjectListBaseElement* rend() const { return 0; }
+            inline Export rend() { return ObjectListBase::Export(this, 0); }
 
-            inline void registerIterator(IteratorBase* iterator)
-                { this->iterators_.insert(this->iterators_.end(), iterator); }
-            inline void unregisterIterator(IteratorBase* iterator)
-                { this->iterators_.erase(iterator); }
-            void notifyIterators(ObjectListBaseElement* element);
+            inline std::list<void*>::iterator registerIterator(void* iterator) { return this->iterators_.insert(this->iterators_.begin(), iterator); }
+            inline void unregisterIterator(const std::list<void*>::iterator& iterator) { this->iterators_.erase(iterator); }
+            inline std::list<void*>::iterator registerObjectListIterator(void* iterator) { return this->objectListIterators_.insert(this->iterators_.begin(), iterator); }
+            inline void unregisterObjectListIterator(const std::list<void*>::iterator& iterator) { this->objectListIterators_.erase(iterator); }
+            void notifyIterators(OrxonoxClass* object) const;
 
             inline Identifier* getIdentifier() const { return this->identifier_; }
 
         private:
-            Identifier* identifier_;             //!< The Iterator owning this list
-            ObjectListBaseElement* first_;       //!< The first element in the list
-            ObjectListBaseElement* last_;        //!< The last element in the list
-            std::set<IteratorBase*> iterators_;  //!< A list of iterators pointing on an element in this list
+            Identifier* identifier_;               //!< The Iterator owning this list
+            ObjectListBaseElement* first_;         //!< The first element in the list
+            ObjectListBaseElement* last_;          //!< The last element in the list
+            std::list<void*> iterators_;           //!< A list of Iterators pointing on an element in this list
+            std::list<void*> objectListIterators_; //!< A list of ObjectListIterators pointing on an element in this list
     };
 }
Index: code/branches/core3/src/core/ObjectListIterator.h
===================================================================
--- code/branches/core3/src/core/ObjectListIterator.h	(revision 1591)
+++ code/branches/core3/src/core/ObjectListIterator.h	(revision 1591)
@@ -0,0 +1,236 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *                    > www.orxonox.net <
+ *
+ *
+ *   License notice:
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation; either version 2
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Fabian 'x3n' Landau
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+/**
+    @file Iterator.h
+    @brief Definition and implementation of the Iterator class.
+
+    The ObjectListIterator of a given class allows to iterate through the
+    ObjectList of this class, containing all objects of that type.
+    This is the only way to access the objects stored in an ObjectList.
+
+    Usage:
+    for (Iterator<myClass> it = ObjectList<myClass>::begin(); it != ObjectList<myClass>::end(); ++it)
+    {
+        it->someFunction(...);
+        myClass* myObject = *it;
+    }
+*/
+
+#ifndef _ObjectListIterator_H__
+#define _ObjectListIterator_H__
+
+#include "CorePrereqs.h"
+#include "ObjectListBase.h"
+
+namespace orxonox
+{
+    //! The Iterator allows to iterate through the ObjectList of a given class.
+    template <class T>
+    class ObjectListIterator
+    {
+        template <class I>
+        friend class Iterator;
+
+        public:
+            /**
+                @brief Constructor: Sets the element, whereon the ObjectListIterator points, to zero.
+            */
+            inline ObjectListIterator()
+            {
+                this->element_ = 0;
+                this->iterator_ = ClassIdentifier<T>::getIdentifier()->getObjects()->registerObjectListIterator(this);
+            }
+
+            /**
+                @brief Constructor: Sets this element to a given element.
+                @param element The element to start with
+            */
+            inline ObjectListIterator(ObjectListElement<T>* element)
+            {
+                this->element_ = element;
+                this->iterator_ = ClassIdentifier<T>::getIdentifier()->getObjects()->registerObjectListIterator(this);
+            }
+
+            /**
+                @brief Constructor: Sets this element to the element of another ObjectListIterator.
+                @param other The other ObjectListIterator
+            */
+            inline ObjectListIterator(const ObjectListIterator<T>& other)
+            {
+                this->element_ = other.element_;
+                this->iterator_ = ClassIdentifier<T>::getIdentifier()->getObjects()->registerObjectListIterator(this);
+            }
+
+            /**
+                @brief Unregisters the ObjectListIterator from the ObjectList.
+            */
+            inline ~ObjectListIterator()
+            {
+                ClassIdentifier<T>::getIdentifier()->getObjects()->unregisterObjectListIterator(this->iterator_);
+            }
+
+            /**
+                @brief Assigns an ObjectListElement.
+                @param element The ObjectListElement
+            */
+            inline const ObjectListIterator<T>& operator=(ObjectListElement<T>* element)
+            {
+                this->element_ = element;
+                return (*this);
+            }
+
+            /**
+                @brief Assigns the element of another ObjectListIterator.
+                @param element The other ObjectListIterator
+            */
+            inline const ObjectListIterator<T>& operator=(const ObjectListIterator<T>& other)
+            {
+                this->element_ = other.element_;
+                return (*this);
+            }
+
+            /**
+                @brief Overloading of the ++it operator: ObjectListIterator points to the next object in the list.
+                @return The ObjectListIterator itself
+            */
+            inline const ObjectListIterator<T>& operator++()
+            {
+                if (this->element_)
+                    this->element_ = (ObjectListElement<T>*)this->element_->next_;
+                return *this;
+            }
+
+            /**
+                @brief Overloading of the it++ operator: ObjectListIterator points to the next object in the list.
+                @return The ObjectListIterator itself
+            */
+            inline ObjectListIterator<T> operator++(int i)
+            {
+                ObjectListIterator<T> copy = *this;
+                if (this->element_)
+                    this->element_ = (ObjectListElement<T>*)this->element_->next_;
+                return copy;
+            }
+
+            /**
+                @brief Overloading of the --it operator: ObjectListIterator points to the previous object in the list.
+                @return The ObjectListIterator itself
+            */
+            inline const ObjectListIterator<T>& operator--()
+            {
+                if (this->element_)
+                    this->element_ = (ObjectListElement<T>*)this->element_->prev_;
+                return *this;
+            }
+
+            /**
+                @brief Overloading of the it-- operator: ObjectListIterator points to the previous object in the list.
+                @return The ObjectListIterator itself
+            */
+            inline ObjectListIterator<T> operator--(int i)
+            {
+                ObjectListIterator<T> copy = *this;
+                if (this->element_)
+                    this->element_ = (ObjectListElement<T>*)this->element_->prev_;
+                return copy;
+            }
+
+            /**
+                @brief Overloading of the *it operator: returns the pointer to the object.
+                @return The object the ObjectListIterator points at
+            */
+            inline T* operator*() const
+            {
+                if (this->element_)
+                    return this->element_->object_;
+                else
+                    return 0;
+            }
+
+            /**
+                @brief Overloading of the it-> operator: returns the pointer to the object.
+                @return The object the ObjectListIterator points at
+            */
+            inline T* operator->() const
+            {
+                if (this->element_)
+                    return this->element_->object_;
+                else
+                    return 0;
+            }
+
+            /**
+                @brief Overloading of the typecast-operator to bool: returns true if the ObjectListIterator points to an existing object.
+                @return True if the ObjectListIterator points to an existing object.
+            */
+            inline operator bool() const
+            {
+                return (this->element_ != 0);
+            }
+
+            /**
+                @brief Overloading of the == operator to compare with another ObjectListIterator.
+                @param compare The other ObjectListIterator
+                @return True if the ObjectListIterator point to the same element
+            */
+            inline bool operator==(const ObjectListIterator<T>& compare) const
+            {
+                return (this->element_ == compare.element_);
+            }
+
+            /**
+                @brief Overloading of the != operator to compare with another ObjectListIterator.
+                @param compare The other ObjectListIterator
+                @return True if the ObjectListIterator point to different elements
+            */
+            inline bool operator!=(const ObjectListIterator<T>& compare) const
+            {
+                return (this->element_ != compare.element_);
+            }
+
+            /**
+                @brief Increments the ObjectListIterator if it points at the given object.
+                @param object The object to compare with
+            */
+            inline void incrementIfEqual(OrxonoxClass* object)
+            {
+                if (this->element_ && this->element_->objectBase_ == object)
+                    this->operator++();
+            }
+
+        private:
+            ObjectListElement<T>* element_;        //!< The element the Iterator points at
+            std::list<void*>::iterator iterator_;  //!< The iterator in the notifying list of the ObjectList
+    };
+}
+
+// Include ObjectList.h so the user only has to include one file: Iterator.h
+#include "ObjectList.h"
+
+#endif /* _ObjectListIterator_H__ */
Index: code/branches/core3/src/core/Shell.cc
===================================================================
--- code/branches/core3/src/core/Shell.cc	(revision 1590)
+++ code/branches/core3/src/core/Shell.cc	(revision 1591)
@@ -68,4 +68,5 @@
 
         this->outputBuffer_.registerListener(this);
+        OutputHandler::getOutStream().setOutputBuffer(this->outputBuffer_);
 
         this->setConfigValues();
Index: code/branches/core3/src/network/ConnectionManager.cc
===================================================================
--- code/branches/core3/src/network/ConnectionManager.cc	(revision 1590)
+++ code/branches/core3/src/network/ConnectionManager.cc	(revision 1591)
@@ -44,4 +44,5 @@
 #include "core/CoreIncludes.h"
 #include "core/BaseObject.h"
+#include "core/Iterator.h"
 #include "objects/SpaceShip.h"
 #include "util/Math.h"
@@ -337,5 +338,5 @@
   bool ConnectionManager::removeShip(ClientInformation *client){
     int id=client->getShipID();
-    orxonox::Iterator<orxonox::SpaceShip> it;
+    orxonox::ObjectList<orxonox::SpaceShip>::iterator it;
     for(it = orxonox::ObjectList<orxonox::SpaceShip>::begin(); it; ++it){
       if(it->objectID!=id)
Index: code/branches/core3/src/network/GameStateClient.cc
===================================================================
--- code/branches/core3/src/network/GameStateClient.cc	(revision 1590)
+++ code/branches/core3/src/network/GameStateClient.cc	(revision 1591)
@@ -33,4 +33,5 @@
 #include "core/CoreIncludes.h"
 #include "core/BaseObject.h"
+#include "core/Iterator.h"
 #include "Synchronisable.h"
 
@@ -137,6 +138,6 @@
   * @return iterator pointing to the next object in the list
   */
-  void GameStateClient::removeObject(orxonox::Iterator<Synchronisable> &it) {
-    orxonox::Iterator<Synchronisable> temp=it;
+  void GameStateClient::removeObject(orxonox::ObjectList<Synchronisable>::iterator &it) {
+    orxonox::ObjectList<Synchronisable>::iterator temp=it;
     ++it;
     delete  *temp;
@@ -151,5 +152,5 @@
     COUT(4) << "loadSnapshot: loading gs: " << state->id << std::endl;
     // get the start of the Synchronisable list
-    orxonox::Iterator<Synchronisable> it=orxonox::ObjectList<Synchronisable>::begin();
+    orxonox::ObjectList<Synchronisable>::iterator it=orxonox::ObjectList<Synchronisable>::begin();
     syncData sync;
     // loop as long as we have some data ;)
@@ -222,5 +223,5 @@
     int tempsize=0;
     // get the start of the Synchronisable list
-    orxonox::Iterator<Synchronisable> it;
+    orxonox::ObjectList<Synchronisable>::iterator it;
     // struct for return value of Synchronisable::getData()
     syncData sync;
Index: code/branches/core3/src/network/GameStateClient.h
===================================================================
--- code/branches/core3/src/network/GameStateClient.h	(revision 1590)
+++ code/branches/core3/src/network/GameStateClient.h	(revision 1591)
@@ -42,5 +42,5 @@
 
 #include <map>
-// 
+//
 #include "NetworkPrereqs.h"
 #include "core/CorePrereqs.h"
@@ -58,5 +58,5 @@
     GameStateClient();
     ~GameStateClient();
-    
+
     void addGameState(GameStateCompressed *gs);
     int processGameState();
@@ -72,5 +72,5 @@
     GameState *decode(GameState *old, GameStateCompressed *diff);
     GameState *decode(GameStateCompressed *x);
-    void removeObject(orxonox::Iterator<Synchronisable> &it);
+    void removeObject(orxonox::ObjectListIterator<Synchronisable> &it);
     void printGameStateMap();
     bool saveShipCache();
@@ -83,8 +83,8 @@
     orxonox::SpaceShip *myShip_;
     syncData shipCache_;
-    
-    
-    
-    
+
+
+
+
   public:
     //#### ADDED FOR TESTING PURPOSE ####
Index: code/branches/core3/src/network/GameStateManager.cc
===================================================================
--- code/branches/core3/src/network/GameStateManager.cc	(revision 1590)
+++ code/branches/core3/src/network/GameStateManager.cc	(revision 1591)
@@ -48,4 +48,5 @@
 #include "core/CoreIncludes.h"
 #include "core/BaseObject.h"
+#include "core/Iterator.h"
 #include "ClientInformation.h"
 #include "Synchronisable.h"
@@ -180,5 +181,5 @@
     int tempsize=0;
     // get the start of the Synchronisable list
-    orxonox::Iterator<Synchronisable> it;
+    orxonox::ObjectList<Synchronisable>::iterator it;
     // struct for return value of Synchronisable::getData()
     syncData sync;
@@ -246,5 +247,5 @@
     COUT(4) << "loadSnapshot: loading gs: " << state->id << std::endl;
     // get the start of the Synchronisable list
-    orxonox::Iterator<Synchronisable> it=orxonox::ObjectList<Synchronisable>::begin();
+    orxonox::ObjectList<Synchronisable>::iterator it=orxonox::ObjectList<Synchronisable>::begin();
     syncData sync;
     /*ClientInformation *client = head_->findClient(clientID);
Index: code/branches/core3/src/network/Server.cc
===================================================================
--- code/branches/core3/src/network/Server.cc	(revision 1590)
+++ code/branches/core3/src/network/Server.cc	(revision 1591)
@@ -52,4 +52,5 @@
 #include "objects/SpaceShip.h"
 #include "core/ConsoleCommand.h"
+#include "core/Iterator.h"
 
 namespace network
@@ -400,5 +401,5 @@
 
     //boost::recursive_mutex::scoped_lock lock(head_->mutex_);
-    orxonox::Iterator<orxonox::SpaceShip> it = orxonox::ObjectList<orxonox::SpaceShip>::begin();
+    orxonox::ObjectList<orxonox::SpaceShip>::iterator it = orxonox::ObjectList<orxonox::SpaceShip>::begin();
     ClientInformation *client = clients->findClient(&event->peer->address);
     if(!client)
@@ -409,5 +410,5 @@
         continue;
       }
-      orxonox::Iterator<orxonox::SpaceShip> temp=it;
+      orxonox::ObjectList<orxonox::SpaceShip>::iterator temp=it;
       ++it;
       delete  *temp;
Index: code/branches/core3/src/network/Synchronisable.h
===================================================================
--- code/branches/core3/src/network/Synchronisable.h	(revision 1590)
+++ code/branches/core3/src/network/Synchronisable.h	(revision 1591)
@@ -85,5 +85,5 @@
     Synchronisable();
   private:
-    /*  bool removeObject(Iterator<Synchronisable> it);*/
+    /*  bool removeObject(ObjectList<Synchronisable>::iterator it);*/
 
     std::list<synchronisableVariable *> *syncList;
Index: code/branches/core3/src/orxonox/GraphicsEngine.cc
===================================================================
--- code/branches/core3/src/orxonox/GraphicsEngine.cc	(revision 1590)
+++ code/branches/core3/src/orxonox/GraphicsEngine.cc	(revision 1591)
@@ -47,4 +47,5 @@
 #include "core/CoreIncludes.h"
 #include "core/ConfigValueIncludes.h"
+#include "core/Iterator.h"
 #include "core/CommandExecutor.h"
 #include "core/ConsoleCommand.h"
@@ -100,5 +101,5 @@
 
     if (this->detailLevelParticle_ != old)
-      for (Iterator<ParticleInterface> it = ObjectList<ParticleInterface>::begin(); it; ++it)
+      for (ObjectList<ParticleInterface>::iterator it = ObjectList<ParticleInterface>::begin(); it; ++it)
         it->detailLevelChanged(this->detailLevelParticle_);
   }
Index: code/branches/core3/src/orxonox/Orxonox.cc
===================================================================
--- code/branches/core3/src/orxonox/Orxonox.cc	(revision 1590)
+++ code/branches/core3/src/orxonox/Orxonox.cc	(revision 1591)
@@ -54,4 +54,5 @@
 // core
 #include "core/ConfigFileManager.h"
+#include "core/Iterator.h"
 #include "core/ConsoleCommand.h"
 #include "core/Loader.h"
@@ -75,4 +76,5 @@
 #include "GraphicsEngine.h"
 #include "Settings.h"
+
 
 // FIXME: is this really file scope?
@@ -169,5 +171,5 @@
     Orxonox::getSingleton()->timefactor_ = factor;
 
-    for (Iterator<ParticleInterface> it = ObjectList<ParticleInterface>::begin(); it; ++it)
+    for (ObjectList<ParticleInterface>::iterator it = ObjectList<ParticleInterface>::begin(); it; ++it)
         it->setSpeedFactor(it->getSpeedFactor() * change);
   }
@@ -462,8 +464,8 @@
       Core::tick((float)evt.timeSinceLastFrame);
       // Call those objects that need the real time
-      for (Iterator<TickableReal> it = ObjectList<TickableReal>::begin(); it; ++it)
+      for (ObjectList<TickableReal>::iterator it = ObjectList<TickableReal>::begin(); it; ++it)
         it->tick((float)evt.timeSinceLastFrame);
       // Call the scene objects
-      for (Iterator<Tickable> it = ObjectList<Tickable>::begin(); it; ++it)
+      for (ObjectList<Tickable>::iterator it = ObjectList<Tickable>::begin(); it; ++it)
         it->tick((float)evt.timeSinceLastFrame * this->timefactor_);
       //AudioManager::tick();
Index: code/branches/core3/src/orxonox/objects/NPC.cc
===================================================================
--- code/branches/core3/src/orxonox/objects/NPC.cc	(revision 1590)
+++ code/branches/core3/src/orxonox/objects/NPC.cc	(revision 1591)
@@ -31,4 +31,5 @@
 
 #include "core/CoreIncludes.h"
+#include "core/Iterator.h"
 
 namespace orxonox {
@@ -117,5 +118,5 @@
     int numberOfNeighbour = 0;  //number of observed neighbours
     float distance = 0;  // distance to the actual element
-    for(Iterator<WorldEntity> it = ObjectList<WorldEntity>::begin(); it; ++it) {  //go through all elements
+    for(ObjectList<WorldEntity>::iterator it = ObjectList<WorldEntity>::begin(); it; ++it) {  //go through all elements
       distance = getDistance(*it);  //get distance between this and actual
       if ((distance > 0) && (distance < SEPERATIONDISTANCE)) {  //do only if actual is inside detectionradius
@@ -144,5 +145,5 @@
     //float distance = 0;
     //go through all elements
-    for(Iterator<NPC> it = ObjectList<NPC>::begin(); it; ++it) {  //just working with 3 elements at the moment
+    for(ObjectList<NPC>::iterator it = ObjectList<NPC>::begin(); it; ++it) {  //just working with 3 elements at the moment
       float distance = getDistance(*it);  //get distance between this and actual
       if ((distance > 0) && (distance < ALIGNMENTDISTANCE)) {  //check if actual element is inside detectionradius
@@ -164,5 +165,5 @@
     //float distance = 0;
     //go through all elements
-    for(Iterator<NPC> it = ObjectList<NPC>::begin(); it; ++it) {  //just working with 3 elements at the moment
+    for(ObjectList<NPC>::iterator it = ObjectList<NPC>::begin(); it; ++it) {  //just working with 3 elements at the moment
       float distance = getDistance(*it);  //get distance between this and actual
       if ((distance > 0) && (distance < COHESIONDISTANCE)) {  //check if actual element is inside detectionradius
Index: code/branches/core3/src/orxonox/objects/Projectile.cc
===================================================================
--- code/branches/core3/src/orxonox/objects/Projectile.cc	(revision 1590)
+++ code/branches/core3/src/orxonox/objects/Projectile.cc	(revision 1591)
@@ -35,4 +35,5 @@
 #include "core/Executor.h"
 #include "core/ConfigValueIncludes.h"
+#include "core/Iterator.h"
 #include "tools/ParticleInterface.h"
 
@@ -87,5 +88,5 @@
 
         float radius;
-        for (Iterator<Model> it = ObjectList<Model>::begin(); it; ++it)
+        for (ObjectList<Model>::iterator it = ObjectList<Model>::begin(); it; ++it)
         {
             if ((*it) != this->owner_)
Index: code/branches/core3/src/orxonox/objects/SpaceShip.cc
===================================================================
--- code/branches/core3/src/orxonox/objects/SpaceShip.cc	(revision 1590)
+++ code/branches/core3/src/orxonox/objects/SpaceShip.cc	(revision 1591)
@@ -41,4 +41,5 @@
 #include "core/CoreIncludes.h"
 #include "core/ConfigValueIncludes.h"
+#include "core/Iterator.h"
 #include "core/input/InputManager.h"
 #include "core/XMLPort.h"
@@ -71,5 +72,5 @@
 
     SpaceShip *SpaceShip::getLocalShip(){
-      Iterator<SpaceShip> it;
+      ObjectList<SpaceShip>::iterator it;
       for(it = ObjectList<SpaceShip>::begin(); it; ++it){
         if( (it)->myShip_ )
Index: code/branches/core3/src/orxonox/objects/SpaceShipAI.cc
===================================================================
--- code/branches/core3/src/orxonox/objects/SpaceShipAI.cc	(revision 1590)
+++ code/branches/core3/src/orxonox/objects/SpaceShipAI.cc	(revision 1591)
@@ -72,5 +72,5 @@
     SpaceShipAI::~SpaceShipAI()
     {
-        for (Iterator<SpaceShipAI> it = ObjectList<SpaceShipAI>::begin(); it; ++it)
+        for (ObjectList<SpaceShipAI>::iterator it = ObjectList<SpaceShipAI>::begin(); it; ++it)
             it->shipDied(this);
     }
@@ -111,5 +111,5 @@
     {
         int i = 0;
-        for (Iterator<SpaceShipAI> it = ObjectList<SpaceShipAI>::begin(); it; )
+        for (ObjectList<SpaceShipAI>::iterator it = ObjectList<SpaceShipAI>::begin(); it; )
         {
             (it++)->kill();
@@ -259,5 +259,5 @@
         this->forgetTarget();
 
-        for (Iterator<SpaceShip> it = ObjectList<SpaceShip>::begin(); it; ++it)
+        for (ObjectList<SpaceShip>::iterator it = ObjectList<SpaceShip>::begin(); it; ++it)
         {
             if (it->getTeamNr() != this->getTeamNr())
