Changeset 10624 for code/trunk/src/libraries/core/object

Timestamp:

Oct 4, 2015, 9:12:21 PM (9 years ago)

Author:

landauf

Message:

merged branch core7 back to trunk

Location:

code/trunk

Files:

• . (modified) (1 prop)
• src/libraries/core/object/CMakeLists.txt (modified) (1 diff)
• src/libraries/core/object/Context.cc (modified) (2 diffs)
• src/libraries/core/object/Context.h (modified) (2 diffs)
• src/libraries/core/object/DestroyLaterManager.cc (copied) (copied from code/branches/core7/src/libraries/core/object/DestroyLaterManager.cc)
• src/libraries/core/object/DestroyLaterManager.h (copied) (copied from code/branches/core7/src/libraries/core/object/DestroyLaterManager.h)
• src/libraries/core/object/Destroyable.cc (modified) (3 diffs)
• src/libraries/core/object/Destroyable.h (modified) (4 diffs)
• src/libraries/core/object/Iterator.h (modified) (2 diffs)
• src/libraries/core/object/IteratorBase.h (modified) (2 diffs)
• src/libraries/core/object/Listable.cc (modified) (1 diff)
• src/libraries/core/object/ObjectList.h (modified) (2 diffs)
• src/libraries/core/object/ObjectListIterator.h (modified) (1 diff)
• src/libraries/core/object/SmartPtr.h (deleted)
• src/libraries/core/object/StrongPtr.h (copied) (copied from code/branches/core7/src/libraries/core/object/StrongPtr.h)
• src/libraries/core/object/WeakPtr.h (modified) (2 diffs)

code/trunk/src/libraries/core/object/CMakeLists.txt

@@ -2 +2 @@
   Context.cc
   Destroyable.cc
+  DestroyLaterManager.cc
   Listable.cc
   ObjectListBase.cc

code/trunk/src/libraries/core/object/Context.cc

@@ -76 +76 @@
     /*static*/ void Context::setRootContext(Context* context)
     {
-        if (Context::rootContext_s)
-            delete Context::rootContext_s;
         Context::rootContext_s = context;
+    }
+
+    /*static*/ void Context::destroyRootContext()
+    {
+        delete Context::rootContext_s;
+        Context::rootContext_s = NULL;
     }
 
     /*static*/ Context* Context::getRootContext()
     {
-        if (!Context::rootContext_s)
-            Context::rootContext_s = new Context(NULL);
+        OrxVerify(Context::rootContext_s != NULL, "Root Context is undefined");
         return Context::rootContext_s;
     }
@@ -97 +100 @@
         return this->objectLists_[classID];
     }
+
+    void Context::destroyObjectList(const Identifier* identifier)
+    {
+        ObjectListBase* objectList = this->getObjectList(identifier);
+        delete objectList;
+        this->objectLists_[identifier->getClassID()] = NULL;
+    }
 }

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

@@ -47 +47 @@
         public:
             static void setRootContext(Context* context);
+            static void destroyRootContext();
             static Context* getRootContext();
 
@@ -71 +72 @@
             }
 
+            void destroyObjectList(const Identifier* identifier);
+
         private:
             Context* parentContext_;

code/trunk/src/libraries/core/object/Destroyable.cc

@@ -33 +33 @@
 
 #include "Destroyable.h"
+#include "DestroyLaterManager.h"
 
 #include <cassert>
@@ -60 +61 @@
 
     /**
-        @brief Deletes the object if no @ref orxonox::SmartPtr "smart pointers" point to this object. Otherwise schedules the object to be deleted as soon as possible.
-        Always call destroy() instead of using 'delete' directly, otherwise smart pointers won't work.
+        @brief Deletes the object if no @ref orxonox::StrongPtr "strong pointers" point to this object. Otherwise schedules the object to be deleted as soon as possible.
+        Always call destroy() instead of using 'delete' directly, otherwise strong pointers won't work.
     */
     void Destroyable::destroy()
@@ -74 +75 @@
         }
     }
+
+    /**
+     * Works like @ref destroy() but doesn't destroy the object until the current tick has ended.
+     */
+    void Destroyable::destroyLater()
+    {
+        // register in DestroyLaterManager - this ensures that a strongPtr points to this object and keeps it alive for a while
+        DestroyLaterManager::getInstance().retain(this);
+
+        // request destruction -> object will be deleted after all strongPtrs (including the one in DestroyLaterManager) were destroyed.
+        this->destroy();
+    }
 }

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

@@ -30 +30 @@
     @file
     @ingroup Object
-    @brief Declaration of Destroyable, the base class of all objects which can be used with SmartPtr and WeakPtr.
+    @brief Declaration of Destroyable, the base class of all objects which can be used with StrongPtr and WeakPtr.
 */
 
@@ -43 +43 @@
 {
     /**
-        @brief Classes must inherit from this class if they should be used with SmartPtr or WeakPtr.
+        @brief Classes must inherit from this class if they should be used with StrongPtr or WeakPtr.
     */
     class _CoreExport Destroyable
     {
         template <class T>
-        friend class SmartPtr;
+        friend class StrongPtr;
 
         friend class DestructionListener;
@@ -57 +57 @@
 
             void destroy();
+            void destroyLater();
 
-            /// Returns the number of @ref orxonox::SmartPtr "smart pointers" that point to this object.
+            /// Returns the number of @ref orxonox::StrongPtr "strong pointers" that point to this object.
             inline unsigned int getReferenceCount() const
                 { return this->referenceCount_; }
 
         protected:
-            /// This virtual function is called if destroy() is called and no SmartPtr points to this object. Used in some cases to create a new SmartPtr to
+            /// This virtual function is called if destroy() is called and no StrongPtr points to this object. Used in some cases to create a new StrongPtr to
             /// prevent destruction. Don't call this function directly - use destroy() instead.
             virtual void preDestroy() {}
 
         private:
-            /// Increments the reference counter (for smart pointers).
+            /// Increments the reference counter (for strong pointers).
             inline void incrementReferenceCount()
                 { ++this->referenceCount_; }
-            /// Decrements the reference counter (for smart pointers).
+            /// Decrements the reference counter (for strong pointers).
             inline void decrementReferenceCount()
             {
@@ -86 +87 @@
                 { this->destructionListeners_.erase(pointer); }
 
-            int referenceCount_;                                    //!< Counts the references from smart pointers to this object
+            int referenceCount_;                                    //!< Counts the references from strong pointers to this object
             bool requestedDestruction_;                             //!< Becomes true after someone called delete on this object
             std::set<DestructionListener*> destructionListeners_;   //!< All destruction listeners (for example weak pointers which point to this object and like to get notified if it dies)

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

@@ -76 +76 @@
                 @brief Constructor: Sets the element, whereon the iterator points, to zero.
             */
-            inline Iterator() : IteratorBase<T, Iterator<T> >(NULL) {}
+            inline Iterator() : IteratorBase<T, Iterator<T> >() {}
 
             /**
@@ -88 +88 @@
                 @param other The other Iterator
             */
-            inline Iterator(const Iterator<T>& other) : IteratorBase<T, Iterator<T> >(other) {}
+            inline Iterator(const IteratorBase<T, Iterator<T> >& other) : IteratorBase<T, Iterator<T> >(other) {}
 
             /**

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

@@ -37 +37 @@
 
 #include "core/CorePrereqs.h"
+
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_base_of.hpp>
 
 #include "ObjectListBase.h"
@@ -49 +52 @@
     class IteratorBase : public ObjectListElementRemovalListener
     {
+        BOOST_STATIC_ASSERT((boost::is_base_of<Listable, T>::value));
+
+        protected:
+            /**
+                @brief Constructor: Sets the element, whereon the iterator points, to the given element.
+                This constructor is protected and only for internal usage (don't mess with the BaseElements directly).
+            */
+            inline IteratorBase(ObjectListBaseElement* element = NULL)
+            {
+                this->element_ = element;
+                this->registerIterator();
+            }
+
+
         public:
             /**
-                @brief Constructor: Sets the element, whereon the iterator points, to zero.
-            */
-            inline IteratorBase(ObjectListBaseElement* element)
-            {
+                @brief Constructor: Sets the element, whereon the iterator points, to the given element.
+            */
+            inline IteratorBase(ObjectListElement<T>* element)
+            {
+                this->element_ = element;
+                this->registerIterator();
+            }
+
+            /**
+                @brief Constructor: Sets the element, whereon the iterator points, to the given element of another type.
+                The element's type O must be a derivative of the Iterator's type T.
+            */
+            template <class O>
+            inline IteratorBase(ObjectListElement<O>* element)
+            {
+                (void)static_cast<T*>((O*)NULL); // Check type: The element's type O must be a derivative of the Iterator's type T.
                 this->element_ = element;
                 this->registerIterator();

code/trunk/src/libraries/core/object/Listable.cc

@@ -39 +39 @@
 namespace orxonox
 {
-    RegisterClass(Listable);
+    RegisterClass(Listable).virtualBase();
 
     /**

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

@@ -47 +47 @@
 #include "core/CorePrereqs.h"
 
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_base_of.hpp>
+
 #include "ObjectListBase.h"
 #include "ObjectListIterator.h"
@@ -66 +69 @@
     class ObjectList
     {
+        BOOST_STATIC_ASSERT((boost::is_base_of<Listable, T>::value));
+
         public:
             typedef ObjectListIterator<T> iterator;
 
+            /// Returns the size of the list (for the root context)
+            inline static size_t size()
+            {   return size(Context::getRootContext());   }
             /// Returns the size of the list
-            inline static size_t size()
+            inline static size_t size(Context* context)
             {
-                return Context::getRootContext()->getObjectList<T>()->size();
+                return context->getObjectList<T>()->size();
             }
 
+            /// Returns an Iterator to the first element in the list (for the root context).
+            inline static ObjectListElement<T>* begin()
+            {   return begin(Context::getRootContext());   }
             /// Returns an Iterator to the first element in the list.
-            inline static ObjectListElement<T>* begin()
+            inline static ObjectListElement<T>* begin(Context* context)
             {
-                ObjectListBase* list = Context::getRootContext()->getObjectList<T>();
+                ObjectListBase* list = context->getObjectList<T>();
                 return static_cast<ObjectListElement<T>*>(list->begin());
             }
 
+            /// Returns an Iterator to the element after the last element in the list (for the root context).
+            inline static ObjectListElement<T>* end()
+            {   return end(Context::getRootContext());   }
             /// Returns an Iterator to the element after the last element in the list.
-            inline static ObjectListElement<T>* end()
+            inline static ObjectListElement<T>* end(Context* context)
             {
-                ObjectListBase* list = Context::getRootContext()->getObjectList<T>();
+                ObjectListBase* list = context->getObjectList<T>();
                 return static_cast<ObjectListElement<T>*>(list->end());
             }
 
+            /// Returns an Iterator to the last element in the list (for the root context).
+            inline static ObjectListElement<T>* rbegin()
+            {   return rbegin(Context::getRootContext());   }
             /// Returns an Iterator to the last element in the list.
-            inline static ObjectListElement<T>* rbegin()
+            inline static ObjectListElement<T>* rbegin(Context* context)
             {
-                ObjectListBase* list = Context::getRootContext()->getObjectList<T>();
+                ObjectListBase* list = context->getObjectList<T>();
                 return static_cast<ObjectListElement<T>*>(list->rbegin());
             }
 
+            /// Returns an Iterator to the element before the first element in the list (for the root context).
+            inline static ObjectListElement<T>* rend()
+            {   return rend(Context::getRootContext());   }
             /// Returns an Iterator to the element before the first element in the list.
-            inline static ObjectListElement<T>* rend()
+            inline static ObjectListElement<T>* rend(Context* context)
             {
-                ObjectListBase* list = Context::getRootContext()->getObjectList<T>();
+                ObjectListBase* list = context->getObjectList<T>();
                 return static_cast<ObjectListElement<T>*>(list->rend());
             }

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

@@ -74 +74 @@
                 @brief Constructor: Sets the element, whereon the ObjectListIterator points, to zero.
             */
-            inline ObjectListIterator() : IteratorBase<T, ObjectListIterator<T> >(NULL) {}
+            inline ObjectListIterator() : IteratorBase<T, ObjectListIterator<T> >() {}
 
             /**

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

@@ -104 +104 @@
             }
 
-            /// Constructor: Used to explicitly initialize the weak pointer with a null pointer
-            inline WeakPtr(int) : pointer_(0), base_(0), callback_(0)
-            {
-            }
-
             /// Constructor: Initializes the weak pointer with a pointer to an object.
             inline WeakPtr(T* pointer) : pointer_(pointer), base_(pointer), callback_(0)
@@ -132 +127 @@
             {
                 this->unregisterAsDestructionListener(this->base_);
-            }
-
-            /// Used to assign a null pointer.
-            inline WeakPtr& operator=(int)
-            {
-                WeakPtr(0).swap(*this);
-                return *this;
             }