Changeset 1591

Timestamp:

Jun 12, 2008, 2:00:15 AM (17 years ago)

Author:

landauf

Message:

Again some heavy changes in ObjectList and Iterator:
there are now two types of iterators:

Iterator<ClassName> can iterate through any objectlist, either given by ObjectList<AnyClassName>::begin() or anyidentifier→getObjects()→begin(). Important note Iterator<ClassName> uses dynamic_cast.
And yes, it's possible to do this: Iterator<WorldEntity> it = ObjectList<SpaceShip>::begin()

ObjectList<ClassName>::iterator is the second iterator - it uses the ObjectList in a templated manner and therefore doesn't need dynamic_cast. But the only thing you can do is iterating through exactly the right ObjectList: ObjectList<ClassName>::iterator it = ObjectList<ClassName>::begin(). Anything else fails.

Those changes bring, at my system, something around +12% FPS compared with trunk and +25% FPS compared with the last revision of core3. Although I have to admit the FPS gain is only that high because iterating through objects is the main thing we're doing ingame right now. It would look totally different with physics, sound, AI, scripts, triggers and so on.

Location:

code/branches/core3/src

Files:

• core/CorePrereqs.h (modified) (2 diffs)
• core/Identifier.cc (modified) (2 diffs)
• core/Identifier.h (modified) (7 diffs)
• core/Iterator.h (modified) (12 diffs)
• core/IteratorBase.h (deleted)
• core/MetaObjectList.cc (modified) (2 diffs)
• core/MetaObjectList.h (modified) (1 diff)
• core/ObjectList.h (modified) (3 diffs)
• core/ObjectListBase.cc (modified) (4 diffs)
• core/ObjectListBase.h (modified) (3 diffs)
• core/ObjectListIterator.h (added)
• core/Shell.cc (modified) (1 diff)
• network/ConnectionManager.cc (modified) (2 diffs)
• network/GameStateClient.cc (modified) (4 diffs)
• network/GameStateClient.h (modified) (4 diffs)
• network/GameStateManager.cc (modified) (3 diffs)
• network/Server.cc (modified) (3 diffs)
• network/Synchronisable.h (modified) (1 diff)
• orxonox/GraphicsEngine.cc (modified) (2 diffs)
• orxonox/Orxonox.cc (modified) (4 diffs)
• orxonox/objects/NPC.cc (modified) (4 diffs)
• orxonox/objects/Projectile.cc (modified) (2 diffs)
• orxonox/objects/SpaceShip.cc (modified) (2 diffs)
• orxonox/objects/SpaceShipAI.cc (modified) (3 diffs)

code/branches/core3/src/core/CorePrereqs.h

@@ -138 +138 @@
   class ObjectListBase;
   class ObjectListBaseElement;
+  template <class T>
+  class ObjectListElement;
+  template <class T>
+  class ObjectListIterator;
   class OrxonoxClass;
   class Shell;
@@ -153 +157 @@
   class XMLPortObjectContainer;
   class XMLPortParamContainer;
+
+  struct ObjectListBase::Export;
 
   // input

code/branches/core3/src/core/Identifier.cc

@@ -39 +39 @@
 #include "ConsoleCommand.h"
 #include "CommandExecutor.h"
-#include "MetaObjectList.h"
+#include "Iterator.h"
 #include "ObjectList.h"
 #include "OrxonoxClass.h"
@@ -197 +197 @@
 
     /**
-        @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();
     }
 

code/branches/core3/src/core/Identifier.h

@@ -60 +60 @@
 #include <utility>
 
-#include "Iterator.h"
+#include "MetaObjectList.h"
+#include "ObjectListBase.h"
 #include "util/Debug.h"
 #include "util/String.h"
@@ -103 +104 @@
             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 +112 @@
             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 +230 @@
 
             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 +264 @@
             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 +300 @@
             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 +409 @@
 
     /**
-        @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)));
     }
 

code/branches/core3/src/core/Iterator.h

@@ -31 +31 @@
     @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 +47 @@
 #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 +63 @@
             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 +118 @@
             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 +191 @@
                 @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 +205 @@
             {
                 Iterator<T> copy = *this;
-                IteratorBase::operator++();
+                if (this->element_)
+                    this->element_ = this->element_->next_;
                 return copy;
             }
@@ -106 +214 @@
                 @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 +228 @@
             {
                 Iterator<T> copy = *this;
-                IteratorBase::operator--();
+                if (this->element_)
+                    this->element_ = this->element_->prev_;
                 return copy;
             }
@@ -127 +237 @@
                 @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 +251 @@
             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 +271 @@
                 @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 +281 @@
                 @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;
 }
 

code/branches/core3/src/core/MetaObjectList.cc

@@ -33 +33 @@
 
 #include "MetaObjectList.h"
+#include "ObjectListBase.h"
+#include "Identifier.h"
 #include "util/Debug.h"
 
@@ -46 +48 @@
     {
         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_)

code/branches/core3/src/core/MetaObjectList.h

@@ -40 +40 @@
 
 #include "CorePrereqs.h"
-
-#include "ObjectListBase.h"
-#include "Identifier.h"
 
 namespace orxonox

code/branches/core3/src/core/ObjectList.h

@@ -41 +41 @@
 
 #include "Identifier.h"
-#include "Iterator.h"
+#include "ObjectListIterator.h"
 
 namespace orxonox
@@ -51 +51 @@
     /**
         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 +57 @@
     {
         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_); }
     };
 }

code/branches/core3/src/core/ObjectListBase.cc

@@ -41 +41 @@
 #include "ObjectListBase.h"
 #include "Identifier.h"
-#include "IteratorBase.h"
+#include "Iterator.h"
 
 namespace orxonox
@@ -73 +73 @@
         @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 +86 @@
         @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 +98 @@
             // 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_;

code/branches/core3/src/core/ObjectListBase.h

@@ -38 +38 @@
 #define _ObjectListBase_H__
 
-#include <set>
+#include <list>
 
 #include "CorePrereqs.h"
@@ -55 +55 @@
                 @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 +92 @@
             ~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
     };
 }

code/branches/core3/src/core/Shell.cc

@@ -68 +68 @@
 
         this->outputBuffer_.registerListener(this);
+        OutputHandler::getOutStream().setOutputBuffer(this->outputBuffer_);
 
         this->setConfigValues();

code/branches/core3/src/network/ConnectionManager.cc

@@ -44 +44 @@
 #include "core/CoreIncludes.h"
 #include "core/BaseObject.h"
+#include "core/Iterator.h"
 #include "objects/SpaceShip.h"
 #include "util/Math.h"
@@ -337 +338 @@
   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)

code/branches/core3/src/network/GameStateClient.cc

@@ -33 +33 @@
 #include "core/CoreIncludes.h"
 #include "core/BaseObject.h"
+#include "core/Iterator.h"
 #include "Synchronisable.h"
 
@@ -137 +138 @@
   * @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 +152 @@
     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 +223 @@
     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;

code/branches/core3/src/network/GameStateClient.h

@@ -42 +42 @@
 
 #include <map>
-// 
+//
 #include "NetworkPrereqs.h"
 #include "core/CorePrereqs.h"
@@ -58 +58 @@
     GameStateClient();
     ~GameStateClient();
-    
+
     void addGameState(GameStateCompressed *gs);
     int processGameState();
@@ -72 +72 @@
     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 +83 @@
     orxonox::SpaceShip *myShip_;
     syncData shipCache_;
-    
-    
-    
-    
+
+
+
+
   public:
     //#### ADDED FOR TESTING PURPOSE ####

code/branches/core3/src/network/GameStateManager.cc

@@ -48 +48 @@
 #include "core/CoreIncludes.h"
 #include "core/BaseObject.h"
+#include "core/Iterator.h"
 #include "ClientInformation.h"
 #include "Synchronisable.h"
@@ -180 +181 @@
     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 +247 @@
     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);

code/branches/core3/src/network/Server.cc

@@ -52 +52 @@
 #include "objects/SpaceShip.h"
 #include "core/ConsoleCommand.h"
+#include "core/Iterator.h"
 
 namespace network
@@ -400 +401 @@
 
     //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 +410 @@
         continue;
       }
-      orxonox::Iterator<orxonox::SpaceShip> temp=it;
+      orxonox::ObjectList<orxonox::SpaceShip>::iterator temp=it;
       ++it;
       delete  *temp;

code/branches/core3/src/network/Synchronisable.h

@@ -85 +85 @@
     Synchronisable();
   private:
-    /*  bool removeObject(Iterator<Synchronisable> it);*/
+    /*  bool removeObject(ObjectList<Synchronisable>::iterator it);*/
 
     std::list<synchronisableVariable *> *syncList;

code/branches/core3/src/orxonox/GraphicsEngine.cc

@@ -47 +47 @@
 #include "core/CoreIncludes.h"
 #include "core/ConfigValueIncludes.h"
+#include "core/Iterator.h"
 #include "core/CommandExecutor.h"
 #include "core/ConsoleCommand.h"
@@ -100 +101 @@
 
     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_);
   }

code/branches/core3/src/orxonox/Orxonox.cc

@@ -54 +54 @@
 // core
 #include "core/ConfigFileManager.h"
+#include "core/Iterator.h"
 #include "core/ConsoleCommand.h"
 #include "core/Loader.h"
@@ -75 +76 @@
 #include "GraphicsEngine.h"
 #include "Settings.h"
+
 
 // FIXME: is this really file scope?
@@ -169 +171 @@
     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 +464 @@
       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();

code/branches/core3/src/orxonox/objects/NPC.cc

@@ -31 +31 @@
 
 #include "core/CoreIncludes.h"
+#include "core/Iterator.h"
 
 namespace orxonox {
@@ -117 +118 @@
     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 +145 @@
     //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 +165 @@
     //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

code/branches/core3/src/orxonox/objects/Projectile.cc

@@ -35 +35 @@
 #include "core/Executor.h"
 #include "core/ConfigValueIncludes.h"
+#include "core/Iterator.h"
 #include "tools/ParticleInterface.h"
 
@@ -87 +88 @@
 
         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_)

code/branches/core3/src/orxonox/objects/SpaceShip.cc

@@ -41 +41 @@
 #include "core/CoreIncludes.h"
 #include "core/ConfigValueIncludes.h"
+#include "core/Iterator.h"
 #include "core/input/InputManager.h"
 #include "core/XMLPort.h"
@@ -71 +72 @@
 
     SpaceShip *SpaceShip::getLocalShip(){
-      Iterator<SpaceShip> it;
+      ObjectList<SpaceShip>::iterator it;
       for(it = ObjectList<SpaceShip>::begin(); it; ++it){
         if( (it)->myShip_ )

code/branches/core3/src/orxonox/objects/SpaceShipAI.cc

@@ -72 +72 @@
     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 +111 @@
     {
         int i = 0;
-        for (Iterator<SpaceShipAI> it = ObjectList<SpaceShipAI>::begin(); it; )
+        for (ObjectList<SpaceShipAI>::iterator it = ObjectList<SpaceShipAI>::begin(); it; )
         {
             (it++)->kill();
@@ -259 +259 @@
         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())