Changeset 1747 for code/trunk/src/core/Iterator.h

Timestamp:

Sep 9, 2008, 4:25:52 AM (17 years ago)

Author:

landauf

Message:

merged core3 back to trunk

Location:

code/trunk

Files:

• . (modified) (1 prop)
• src/core/Iterator.h (modified) (11 diffs)

code/trunk/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<class> it = ObjectList<class>::start(); it != 0; ++it)
+    for (Iterator<myClass> it = anyidentifier->getObjects().begin(); it != anyidentifier->getObjects().end(); ++it)
     {
         it->someFunction(...);
-        class* myObject = *it;
+        myClass* myObject = *it;
     }
-
-    Warning: Don't delete objects directly through the iterator.
 */
 
@@ -49 +47 @@
 #include "CorePrereqs.h"
 
-#include "ObjectList.h"
+#include "ObjectListBase.h"
+#include "ObjectListIterator.h"
+#include "OrxonoxClass.h"
 
 namespace orxonox
 {
-    //! The iterator allows to iterate through an ObjectList of a given class.
-    template <class T>
+    //! The Iterator allows to iterate through a given ObjectList
+    template <class T = OrxonoxClass>
     class Iterator
     {
@@ -61 +61 @@
                 @brief Constructor: Sets the element, whereon the iterator points, to zero.
             */
-            Iterator()
+            inline Iterator()
             {
                 this->element_ = 0;
-                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
-            */
-            Iterator(ObjectListElement<T>* element)
-            {
-                this->element_ = element;
-                ClassIdentifier<T>::getIdentifier()->getObjects()->registerIterator(this);
+                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);
             }
 
@@ -80 +116 @@
                 @brief Unregisters the Iterator from the ObjectList.
             */
-            ~Iterator()
-            {
-                ClassIdentifier<T>::getIdentifier()->getObjects()->unregisterIterator(this);
-            }
-
-            /**
-                @brief Assigns an element to the iterator.
+            inline ~Iterator()
+            {
+                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
             */
-            Iterator<T> operator=(ObjectListElement<T>* element)
-            {
-                this->element_ = 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);
                 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);
             }
 
@@ -99 +192 @@
                 @return The Iterator itself
             */
-            Iterator<T> operator++()
+            inline const Iterator<T>& operator++()
             {
                 if (this->element_)
@@ -110 +203 @@
                 @return The Iterator itself
             */
-            Iterator<T> operator++(int i)
+            inline Iterator<T> operator++(int i)
             {
                 Iterator<T> copy = *this;
@@ -122 +215 @@
                 @return The Iterator itself
             */
-            Iterator<T> operator--()
+            inline const Iterator<T>& operator--()
             {
                 if (this->element_)
@@ -133 +226 @@
                 @return The Iterator itself
             */
-            Iterator<T> operator--(int i)
+            inline Iterator<T> operator--(int i)
             {
                 Iterator<T> copy = *this;
@@ -145 +238 @@
                 @return The object the Iterator points at
             */
-            T* operator*()
-            {
-                if (this->element_)
-                    return this->element_->object_;
+            inline T* operator*() const
+            {
+                if (this->element_)
+                    return dynamic_cast<T*>(this->element_->objectBase_);
                 else
                     return 0;
@@ -157 +250 @@
                 @return The object the Iterator points at
             */
-            T* operator->() const
-            {
-                if (this->element_)
-                    return this->element_->object_;
+            inline T* operator->() const
+            {
+                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.
-            */
-            operator bool()
+                @return True if the Iterator points to an existing object.
+            */
+            inline operator bool() const
             {
                 return (this->element_ != 0);
@@ -176 +268 @@
 
             /**
-                @brief Overloading of the (it != int) operator: Used for (it != 0) instead of typecast-operator to bool.
-                @param compare The integer (must be zero, everything else makes no sense).
-                @return True if the iterator points to an existing object.
-            */
-            bool operator!=(ObjectListElement<T>* compare)
-            {
-                return (this->element_ != compare);
-            }
-
-        private:
-            ObjectListElement<T>* element_;     //!< The element the Iterator points at
+                @brief Overloading of the == operator to compare with another Iterator.
+                @param compare The other Iterator
+                @return True if the iterators point to the same element
+            */
+            inline bool operator==(const Iterator<T>& compare) const
+            {
+                return (this->element_ == compare.element_);
+            }
+
+            /**
+                @brief Overloading of the != operator to compare with another Iterator.
+                @param compare The other Iterator
+                @return True if the iterators point to different elements
+            */
+            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;
 }
 
+// Include ObjectList.h so the user only has to include one file: Iterator.h
+#include "ObjectList.h"
+
 #endif /* _Iterator_H__ */