Changeset 9667 for code/trunk/src/libraries/core/object/ObjectListBase.h

Timestamp:

Aug 25, 2013, 9:08:42 PM (12 years ago)

Author:

landauf

Message:

merged core6 back to trunk

Location:

code/trunk

Files:

• . (modified) (1 prop)
• src/libraries/core/object (copied) (copied from code/branches/core6/src/libraries/core/object)
• src/libraries/core/object/ObjectListBase.h (modified) (4 diffs)

code/trunk/src/libraries/core/object/ObjectListBase.h

@@ -42 +42 @@
 #include "core/CorePrereqs.h"
 #include <vector>
+#include "Context.h"
 
 namespace orxonox
@@ -56 +57 @@
                 @param objectBase The object to store
             */
-            ObjectListBaseElement(Listable* objectBase) : next_(0), prev_(0), objectBase_(objectBase) {}
+            ObjectListBaseElement(Listable* object) : next_(0), prev_(0), objectBase_(object), list_(0) {}
+            virtual ~ObjectListBaseElement() { this->removeFromList(); }
+
+            virtual void changeContext(Context* oldContext, Context* newContext) = 0;
 
             ObjectListBaseElement* next_;       //!< The next element in the list
             ObjectListBaseElement* prev_;       //!< The previous element in the list
-            Listable* objectBase_;
+            Listable* objectBase_;              //!< The object
+            ObjectListBase* list_;              //!< The list
+
+        protected:
+            void removeFromList();
     };
 
@@ -73 +81 @@
         public:
             ObjectListElement(T* object) : ObjectListBaseElement(static_cast<Listable*>(object)), object_(object) {}
+
+            virtual void changeContext(Context* oldContext, Context* newContext)
+            {
+                // add object to new context, but only if this element belongs exactly to the old context (and not to a sub-context to avoid re-adding objects
+                // multiple times if they are in multiple contexts)
+                if (oldContext->getObjectList<T>() == this->list_)
+                    newContext->addObject(this->object_);
+
+                // remove from old list
+                this->removeFromList();
+            }
+
             T* object_;              //!< The object
     };
 
+
+    // ########################################
+    // ### ObjectListElementRemovalListener ###
+    // ########################################
+    /// Gets called by the object list if an element is removed
+    class _CoreExport ObjectListElementRemovalListener
+    {
+        public:
+            virtual ~ObjectListElementRemovalListener() {}
+            virtual void removedElement(ObjectListBaseElement* element) = 0;
+    };
 
     // ###############################
@@ -97 +128 @@
             ~ObjectListBase();
 
-            template <class T>
-            inline ObjectListBaseElement* add(T* object)
-                { return this->addElement(new ObjectListElement<T>(object)); }
-
-            ObjectListBaseElement* addElement(ObjectListBaseElement* element);
+            void addElement(ObjectListBaseElement* element);
             void removeElement(ObjectListBaseElement* element);
 
-            /// Helper struct, used to export an element and the list to an instance of Iterator.
-            struct Export
-            {
-                Export(ObjectListBase* list, ObjectListBaseElement* element) : list_(list), element_(element) {}
-                ObjectListBase* list_;
-                ObjectListBaseElement* element_;
-            };
+            size_t size() const { return this->size_; }
 
             /// Returns a pointer to the first element in the list. Works only with Iterator.
-            inline Export begin() { return ObjectListBase::Export(this, this->first_); }
+            inline ObjectListBaseElement* begin() const { return this->first_; }
             /// Returns a pointer to the element after the last element in the list. Works only with Iterator.
-            inline Export end() { return ObjectListBase::Export(this, 0); }
+            inline ObjectListBaseElement* end() const { return 0; }
             /// Returns a pointer to the last element in the list. Works only with Iterator.
-            inline Export rbegin() { return ObjectListBase::Export(this, this->last_); }
+            inline ObjectListBaseElement* rbegin() const { return this->last_; }
             /// Returns a pointer to the element in front of the first element in the list. Works only with Iterator.
-            inline Export rend() { return ObjectListBase::Export(this, 0); }
+            inline ObjectListBaseElement* rend() const { return 0; }
 
-            inline void registerIterator(void* iterator) { this->iterators_.push_back(iterator); }
-            inline void unregisterIterator(void* iterator)
+            inline void registerRemovalListener(ObjectListElementRemovalListener* listener) { this->listeners_.push_back(listener); }
+            inline void unregisterRemovalListener(ObjectListElementRemovalListener* listener)
             {
-                for (unsigned int i = 0; i < this->iterators_.size(); ++i)
+                for (unsigned int i = 0; i < this->listeners_.size(); ++i)
                 {
-                    if (iterators_[i] == iterator)
+                    if (listeners_[i] == listener)
                     {
-                        iterators_.erase(iterators_.begin() + i);
+                        listeners_.erase(listeners_.begin() + i);
                         break;
                     }
                 }
             }
-            inline void registerObjectListIterator(void* iterator) { this->objectListIterators_.push_back(iterator); }
-            inline void unregisterObjectListIterator(void* iterator)
-            {
-                for (unsigned int i = 0; i < this->objectListIterators_.size(); ++i)
-                {
-                    if (objectListIterators_[i] == iterator)
-                    {
-                        objectListIterators_.erase(objectListIterators_.begin() + i);
-                        break;
-                    }
-                }
-            }
-            void notifyIterators(Listable* object) const;
 
         private:
-            ObjectListBaseElement* first_;           //!< The first element in the list
-            ObjectListBaseElement* last_;            //!< The last element in the list
-            std::vector<void*> iterators_;           //!< A list of Iterators pointing on an element in this list
-            std::vector<void*> objectListIterators_; //!< A list of ObjectListIterators pointing on an element in this list
+            void notifyRemovalListeners(ObjectListBaseElement* element) const;
+
+            ObjectListBaseElement* first_;                              //!< The first element in the list
+            ObjectListBaseElement* last_;                               //!< The last element in the list
+            size_t size_;                                               //!< The number of elements in the list
+            std::vector<ObjectListElementRemovalListener*> listeners_;  //!< A list of Iterators pointing on an element in this list
     };
 }