Changeset 7196 for code/branches/consolecommands3/src/libraries/core

Timestamp:

Aug 21, 2010, 4:54:29 PM (14 years ago)

Author:

landauf

Message:

Changed implementation of SharedPtr, it's now non-intrusive and uses an allocated counter instead. Hence it's possible to create an instance of SharedPtr<T> even if T is only known from a forward declaration. Also changed some parts of the code to reflect the inheritance of the underlying object pointers without using inheritance in the SharedPtr itself.

Location:

code/branches/consolecommands3/src/libraries/core

Files:

• Executor.cc (modified) (1 diff)
• Executor.h (modified) (3 diffs)
• ExecutorPtr.h (added)
• Functor.h (modified) (4 diffs)
• FunctorPtr.h (added)
• SharedPtr.h (modified) (4 diffs)

code/branches/consolecommands3/src/libraries/core/Executor.cc

@@ -44 +44 @@
     Executor::Executor(Functor* functor, const std::string& name)
     {
-        this->references_ = 0;
         this->functor_ = functor;
         this->name_ = name;

code/branches/consolecommands3/src/libraries/core/Executor.h

@@ -36 +36 @@
 #include "util/MultiType.h"
 #include "Functor.h"
+#include "ExecutorPtr.h"
 
 namespace orxonox
@@ -112 +113 @@
 
         private:
-            inline void incrementReferenceCount()
-                { ++this->references_; }
-            inline void decrementReferenceCount()
-                { --this->references_; if (this->references_ == 0) delete this; }
-
-            int references_;
             static int instances_s;
     };
@@ -198 +193 @@
     };
 
-
-
-    typedef SharedPtr<Executor> ExecutorPtr;
-
-    typedef SharedChildPtr<ExecutorStatic, Executor> ExecutorStaticPtr;
-
-    template <class T>
-    class ExecutorMemberPtr : public SharedChildPtr<ExecutorMember<T>, Executor>
-    {
-        public:
-            inline ExecutorMemberPtr() : SharedChildPtr<ExecutorMember<T>, Executor>() {}
-            inline ExecutorMemberPtr(ExecutorMember<T>* pointer) : SharedChildPtr<ExecutorMember<T>, Executor>(pointer) {}
-//            inline ExecutorMemberPtr(const ExecutorMemberPtr& other) : SharedChildPtr<ExecutorMember<T>, Executor>(other) {}
-    };
-
-
-
     inline Executor* createExecutor(Functor* functor, const std::string& name = "")
     {

code/branches/consolecommands3/src/libraries/core/Functor.h

@@ -38 +38 @@
 #include "util/Debug.h"
 #include "util/MultiType.h"
-#include "SharedPtr.h"
+#include "FunctorPtr.h"
 
 namespace orxonox
@@ -104 +104 @@
 
         public:
-            Functor() : references_(0) { ++instances_s; COUT(0) << "functor ++: " << instances_s << std::endl; }
+            Functor() { ++instances_s; COUT(0) << "functor ++: " << instances_s << std::endl; }
             virtual ~Functor() { --instances_s; COUT(0) << "functor --: " << instances_s << std::endl; }
 
@@ -124 +124 @@
 
         private:
-            inline void incrementReferenceCount()
-                { ++this->references_; }
-            inline void decrementReferenceCount()
-                { --this->references_; if (this->references_ == 0) delete this; }
-
-            int references_;
             static int instances_s;
     };
@@ -212 +206 @@
             T* object_;
             const T* constObject_;
-    };
-
-
-
-    typedef SharedPtr<Functor> FunctorPtr;
-
-    typedef SharedChildPtr<FunctorStatic, Functor> FunctorStaticPtr;
-
-    template <class T>
-    class FunctorMemberPtr : public SharedChildPtr<FunctorMember<T>, Functor>
-    {
-        public:
-            inline FunctorMemberPtr() : SharedChildPtr<FunctorMember<T>, Functor>() {}
-            inline FunctorMemberPtr(FunctorMember<T>* pointer) : SharedChildPtr<FunctorMember<T>, Functor>(pointer) {}
-//            inline FunctorMemberPtr(const FunctorMemberPtr& other) : SharedChildPtr<FunctorMember<T>, Functor>(other) {}
     };
 

code/branches/consolecommands3/src/libraries/core/SharedPtr.h

@@ -31 +31 @@
 
 #include "CorePrereqs.h"
+#include <algorithm>
 
 namespace orxonox
 {
+    class SharedPtrDestroyer
+    {
+        public:
+            virtual void destroy() = 0;
+    };
+
+    template <class T>
+    class SharedPtrDestroyerImpl : public SharedPtrDestroyer
+    {
+        public:
+            SharedPtrDestroyerImpl(T* pointer) : pointer_(pointer) {}
+
+            void destroy()
+            {
+//                COUT(0) << "delete " << this->pointer_ << std::endl;
+                delete this->pointer_;
+            }
+
+        private:
+            T* pointer_;
+    };
+
     template <class T>
     class SharedPtr
     {
+        template <class O>
+        friend class SharedPtr;
+
         public:
-            inline SharedPtr() : pointer_(0)
+            inline SharedPtr() : pointer_(0), counter_(0), destroyer_(0)
             {
 //                COUT(0) << "SharedPtr (1): " << this->pointer_ << std::endl;
             }
 
-            inline SharedPtr(T* pointer) : pointer_(pointer)
+            inline SharedPtr(T* pointer) : pointer_(pointer), counter_(0), destroyer_(0)
             {
 //                COUT(0) << "SharedPtr (2): " << this->pointer_ << std::endl;
                 if (this->pointer_)
-                    this->pointer_->incrementReferenceCount();
+                {
+                    this->counter_ = new int(1);
+                    this->destroyer_ = new SharedPtrDestroyerImpl<T>(this->pointer_);
+                }
             }
 
-            inline SharedPtr(const SharedPtr& other) : pointer_(other.pointer_)
+            inline SharedPtr(const SharedPtr& other) : pointer_(other.pointer_), counter_(other.counter_), destroyer_(other.destroyer_)
             {
 //                COUT(0) << "SharedPtr (3): " << this->pointer_ << std::endl;
                 if (this->pointer_)
-                    this->pointer_->incrementReferenceCount();
+                    ++(*this->counter_);
+            }
+
+            template <class O>
+            inline SharedPtr(const SharedPtr<O>& other) : pointer_(other.pointer_), counter_(other.counter_), destroyer_(other.destroyer_)
+            {
+//                COUT(0) << "SharedPtr (4): " << this->pointer_ << std::endl;
+                if (this->pointer_)
+                    ++(*this->counter_);
             }
 
@@ -61 +98 @@
 //                COUT(0) << "~SharedPtr: " << this->pointer_ << std::endl;
                 if (this->pointer_)
-                    this->pointer_->decrementReferenceCount();
+                {
+                    --(*this->counter_);
+
+                    if (*this->counter_ == 0)
+                    {
+                        this->destroyer_->destroy();
+                        delete this->destroyer_;
+                        delete this->counter_;
+                    }
+                }
             }
 
             inline const SharedPtr& operator=(const SharedPtr& other)
             {
-//                COUT(0) << "SharedPtr=" << std::endl;
+//                COUT(0) << "SharedPtr= (1)" << std::endl;
                 SharedPtr(other).swap(*this);
                 return *this;
             }
 
-            inline void cast(const SharedPtr& other)
+            template <class O>
+            inline const SharedPtr& operator=(const SharedPtr<O>& other)
             {
-//                COUT(0) << "SharedPtr cast" << std::endl;
+//                COUT(0) << "SharedPtr= (2)" << std::endl;
                 SharedPtr(other).swap(*this);
+                return *this;
+            }
+
+            template <class O>
+            inline SharedPtr<O> cast() const
+            {
+                O* temp = static_cast<O*>(this->pointer_); // temp value for prettier compiler error in case of an invalid static_cast
+                return SharedPtr<O>(temp, this->counter_, this->destroyer_);
             }
 
@@ -96 +151 @@
             inline void swap(SharedPtr& other)
             {
-                T* temp = this->pointer_;
-                this->pointer_ = other.pointer_;
-                other.pointer_ = temp;
+                std::swap(this->pointer_, other.pointer_);
+                std::swap(this->counter_, other.counter_);
+                std::swap(this->destroyer_, other.destroyer_);
             }
 
         private:
+            inline SharedPtr(T* pointer, int* counter, SharedPtrDestroyer* destroyer) : pointer_(pointer), counter_(counter), destroyer_(destroyer)
+            {
+//                COUT(0) << "SharedPtr (5): " << this->pointer_ << std::endl;
+                if (this->pointer_)
+                    ++(*this->counter_);
+            }
+
             T* pointer_;
+            int* counter_;
+            SharedPtrDestroyer* destroyer_;
     };
-
+/*
     template <class T, class Parent>
     class SharedChildPtr : public SharedPtr<Parent>
@@ -116 +180 @@
             inline T& operator*() const { return *static_cast<T*>(SharedPtr<Parent>::operator->()); }
     };
+*/
 }