Changeset 5823 for code/branches/core5

Timestamp:

Sep 28, 2009, 5:16:36 PM (15 years ago)

Author:

landauf

Message:

added WeakPtr (a pointer which becomes 0 if the target object is deleted)

Location:

code/branches/core5/src/libraries/core

Files:

• OrxonoxClass.cc (modified) (2 diffs)
• OrxonoxClass.h (modified) (3 diffs)
• SmartPtr.h (modified) (5 diffs)
• WeakPtr.h (added)

code/branches/core5/src/libraries/core/OrxonoxClass.cc

@@ -36 +36 @@
 #include "MetaObjectList.h"
 #include "Identifier.h"
+#include "WeakPtr.h"
 
 namespace orxonox
@@ -62 +63 @@
         if (this->parents_)
             delete this->parents_;
+            
+        // reset all weak pointers pointing to this object
+        for (std::set<WeakPtr<OrxonoxClass>*>::iterator it = this->weakPointers_.begin(); it != this->weakPointers_.end(); )
+            (*(it++))->reset();
     }
 

code/branches/core5/src/libraries/core/OrxonoxClass.h

@@ -57 +57 @@
         template <class T>
         friend class SmartPtr;
+
+        template <class T>
+        friend class WeakPtr;
 
         public:
@@ -131 +134 @@
             inline void decrementReferenceCount()
                 { --this->referenceCount_; if (this->referenceCount_ == 0 && this->requestedDestruction_) { delete this; } }
+                
+            /** @brief Register a weak pointer which points to this object. */
+            template <class T>
+            inline void registerWeakPtr(WeakPtr<T>* pointer)
+                { this->weakPointers_.insert(reinterpret_cast<WeakPtr<OrxonoxClass>*>(pointer)); }
+            /** @brief Unegister a weak pointer which pointed to this object before. */
+            template <class T>
+            inline void unregisterWeakPtr(WeakPtr<T>* pointer)
+                { this->weakPointers_.erase(reinterpret_cast<WeakPtr<OrxonoxClass>*>(pointer)); }
 
             Identifier* identifier_;                   //!< The Identifier of the object
@@ -137 +149 @@
             int referenceCount_;                       //!< Counts the references from smart pointers to this object
             bool requestedDestruction_;                //!< Becomes true after someone called delete on this object
+            std::set<WeakPtr<OrxonoxClass>*> weakPointers_; //!< All weak pointers which point to this object (and like to get notified if it dies)
 
             //! 'Fast map' that holds this-pointers of all derived types

code/branches/core5/src/libraries/core/SmartPtr.h

@@ -35 +35 @@
 
 #include <cassert>
-#include <ostream>
+
 #include "OrxonoxClass.h"
+#include "WeakPtr.h"
 
 namespace orxonox
@@ -71 +72 @@
             }
 
+            template <class O>
+            inline SmartPtr(const WeakPtr<O>& other) : pointer_(other.get()), base_(other.getBase())
+            {
+                if (this->base_)
+                    this->base_->incrementReferenceCount();
+            }
+
             inline ~SmartPtr()
             {
@@ -102 +110 @@
             }
 
+            template <class O>
+            inline const SmartPtr& operator=(const WeakPtr<O>& other)
+            {
+                SmartPtr(other).swap(*this);
+                return *this;
+            }
+
             inline T* get() const
             {
                 return this->pointer_;
+            }
+
+            inline OrxonoxClass* getBase() const
+            {
+                return this->base_;
             }
 
@@ -153 +173 @@
     };
 
-    template <class A, class B>
-    inline bool operator==(const SmartPtr<A>& a, const SmartPtr<B>& b)
-    {
-        return (a.get() == b.get());
-    }
-
-    template <class A, class B>
-    inline bool operator!=(const SmartPtr<A>& a, const SmartPtr<B>& b)
-    {
-        return (a.get() != b.get());
-    }
-
-    template <class T>
-    inline bool operator<(const SmartPtr<T>& a, const SmartPtr<T>& b)
-    {
-        return std::less<T*>()(a.get(), b.get());
-    }
-
     template <class T>
     void swap(SmartPtr<T>& a, SmartPtr<T>& b)
@@ -194 +196 @@
         return dynamic_cast<T*>(p.get());
     }
-
-    template <class T>
-    std::ostream& operator<<(std::ostream& os, const SmartPtr<T>& p)
-    {
-        os << p.get();
-        return os;
-    }
 }