Changeset 11071 for code/trunk/src/libraries/core/command/FunctorPtr.h

Timestamp:

Jan 17, 2016, 10:29:21 PM (9 years ago)

Author:

landauf

Message:

merged branch cpp11_v3 back to trunk

Location:

code/trunk

Files:

• . (modified) (1 prop)
• src/libraries/core/command/FunctorPtr.h (modified) (2 diffs)

code/trunk/src/libraries/core/command/FunctorPtr.h

@@ -32 +32 @@
     @brief Typedefs and definitions of FunctorPtr, FunctorMemberPtr, FunctorStaticPtr, and FunctorPointerPtr
 
-    Instances of orxonox::Functor are usually managed by an orxonox::SharedPtr. This ensures
+    Instances of orxonox::Functor are usually managed by an std::shared_ptr. This ensures
     that Functors will be destroyed after usage. To make things easier, there's a typedef
-    that defines FunctorPtr as SharedPtr<Functor>.
+    that defines FunctorPtr as std::shared_ptr<Functor>.
 
     Because there's not only orxonox::Functor, but also orxonox::FunctorStatic, and
@@ -51 +51 @@
 
 #include "core/CorePrereqs.h"
-#include "util/SharedPtr.h"
+#include <memory>
 
 namespace orxonox
 {
-    /// FunctorPtr is just a typedef of SharedPtr
-    typedef SharedPtr<Functor> FunctorPtr;
-
-    /// It's not possible to use a typedef for FunctorMemberPtr<T>, so we have to create a child-class instead. It inherits all functions from SharedChildPtr, but needs to (re-)implement some constructors.
+    using FunctorPtr = std::shared_ptr<Functor>;
     template <class T>
-    class FunctorMemberPtr : public SharedChildPtr<FunctorMember<T>, FunctorPtr>
-    {
-        public:
-            inline FunctorMemberPtr() : SharedChildPtr<FunctorMember<T>, FunctorPtr>() {}
-            inline FunctorMemberPtr(FunctorMember<T>* pointer) : SharedChildPtr<FunctorMember<T>, FunctorPtr>(pointer) {}
-            inline FunctorMemberPtr(const SharedPtr<FunctorMember<T> >& other) : SharedChildPtr<FunctorMember<T>, FunctorPtr>(other) {}
-    };
-
-    /// FunctorStaticPtr is just FunctorMemberPtr with @a T = void
-    typedef FunctorMemberPtr<void> FunctorStaticPtr;
-
-    /// It's not possible to use a typedef for FunctorPointerPtr<T>, so we have to create a child-class instead. It inherits all functions from SharedChildPtr, but needs to (re-)implement some constructors.
+    using FunctorMemberPtr = std::shared_ptr<FunctorMember<T>>;
+    using FunctorStaticPtr = std::shared_ptr<FunctorMember<void>>;
     template <class F, class T>
-    class FunctorPointerPtr : public SharedChildPtr<FunctorPointer<F, T>, FunctorMemberPtr<T> >
-    {
-        public:
-            inline FunctorPointerPtr() : SharedChildPtr<FunctorPointer<F, T>, FunctorMemberPtr<T> >() {}
-            inline FunctorPointerPtr(FunctorPointer<F, T>* pointer) : SharedChildPtr<FunctorPointer<F, T>, FunctorMemberPtr<T> >(pointer) {}
-            inline FunctorPointerPtr(const SharedPtr<FunctorPointer<F, T> >& other) : SharedChildPtr<FunctorPointer<F, T>, FunctorMemberPtr<T> >(other) {}
-    };
+    using FunctorPointerPtr = std::shared_ptr<FunctorPointer<F, T>>;
 }