Changeset 10825 for code/branches

Timestamp:

Nov 22, 2015, 4:55:02 PM (9 years ago)

Author:

landauf

Message:

use std::shared_ptr instead of orxonox::SharedPtr for FunctorPtr and ExecutorPtr

Location:

code/branches/cpp11_v2

Files:

• src/libraries/core/EventIncludes.h (modified) (1 diff)
• src/libraries/core/command/CommandExecutor.cc (modified) (1 diff)
• src/libraries/core/command/ConsoleCommand.cc (modified) (1 diff)
• src/libraries/core/command/Executor.h (modified) (3 diffs)
• src/libraries/core/command/ExecutorPtr.h (modified) (1 diff)
• src/libraries/core/command/Functor.h (modified) (2 diffs)
• src/libraries/core/command/FunctorPtr.h (modified) (1 diff)
• src/libraries/core/input/KeyBinderManager.h (modified) (1 diff)
• src/libraries/core/object/Listable.h (modified) (1 diff)
• test/core/command/ExecutorPtrTest.cc (modified) (2 diffs)
• test/core/command/FunctorPtrTest.cc (modified) (2 diffs)

code/branches/cpp11_v2/src/libraries/core/EventIncludes.h

@@ -86 +86 @@
 
 #define XMLPortEventStateIntern(name, classname, statename, xmlelement, mode) \
-    static orxonox::ExecutorMemberPtr<classname> xmlsetfunctor##name = orxonox::createExecutor(orxonox::createFunctor(&classname::addEventSource), std::string( #classname ) + "::" + "addEventSource" + '(' + statename + ')').cast<orxonox::ExecutorMember<classname>>(); \
-    static orxonox::ExecutorMemberPtr<classname> xmlgetfunctor##name = orxonox::createExecutor(orxonox::createFunctor(&classname::getEventSource), std::string( #classname ) + "::" + "getEventSource" + '(' + statename + ')').cast<orxonox::ExecutorMember<classname>>(); \
+    static orxonox::ExecutorPtr xmlsetfunctorbase##name = orxonox::createExecutor(orxonox::createFunctor(&classname::addEventSource), std::string( #classname ) + "::" + "addEventSource" + '(' + statename + ')'); \
+    static orxonox::ExecutorPtr xmlgetfunctorbase##name = orxonox::createExecutor(orxonox::createFunctor(&classname::getEventSource), std::string( #classname ) + "::" + "getEventSource" + '(' + statename + ')'); \
+    static orxonox::ExecutorMemberPtr<classname> xmlsetfunctor##name = std::static_pointer_cast<orxonox::ExecutorMember<classname>>(xmlsetfunctorbase##name); \
+    static orxonox::ExecutorMemberPtr<classname> xmlgetfunctor##name = std::static_pointer_cast<orxonox::ExecutorMember<classname>>(xmlgetfunctorbase##name); \
     xmlsetfunctor##name->setDefaultValue(1, statename); \
     xmlgetfunctor##name->setDefaultValue(1, statename); \

code/branches/cpp11_v2/src/libraries/core/command/CommandExecutor.cc

@@ -275 +275 @@
         {
             // it is valid - copy the executor of this command
-            ExecutorPtr executor = new Executor(*evaluation.getConsoleCommand()->getExecutor().get());
+            ExecutorPtr executor = std::make_shared<Executor>(*evaluation.getConsoleCommand()->getExecutor().get());
 
             // evaluate the arguments and if this returns no error, store them as default values

code/branches/cpp11_v2/src/libraries/core/command/ConsoleCommand.cc

@@ -320 +320 @@
     {
         if (this->executor_)
-            this->pushFunction(new Executor(*this->executor_.get()));
+            this->pushFunction(std::make_shared<Executor>(*this->executor_.get()));
         else
             orxout(internal_error, context::commands) << "Couldn't push copy of executor in console command \"" << this->baseName_ << "\", no executor set." << endl;

code/branches/cpp11_v2/src/libraries/core/command/Executor.h

@@ -267 +267 @@
     inline ExecutorPtr createExecutor(const FunctorPtr& functor, const std::string& name = "")
     {
-        return new Executor(functor, name);
+        return std::make_shared<Executor>(functor, name);
     }
 
@@ -274 +274 @@
     inline ExecutorMemberPtr<T> createExecutor(const FunctorMemberPtr<T>& functor, const std::string& name = "")
     {
-        return new ExecutorMember<T>(functor, name);
+        return std::make_shared<ExecutorMember<T>>(functor, name);
     }
 
@@ -280 +280 @@
     inline ExecutorStaticPtr createExecutor(const FunctorStaticPtr& functor, const std::string& name = "")
     {
-        return new ExecutorStatic(functor, name);
+        return std::make_shared<ExecutorStatic>(functor, name);
     }
 }

code/branches/cpp11_v2/src/libraries/core/command/ExecutorPtr.h

@@ -49 +49 @@
 
 #include "core/CorePrereqs.h"
-#include "util/SharedPtr.h"
+#include <memory>
 
 namespace orxonox
 {
-    using ExecutorPtr = SharedPtr<Executor>;
-    using ExecutorStaticPtr = SharedChildPtr<ExecutorStatic, ExecutorPtr>;
+    using ExecutorPtr = std::shared_ptr<Executor>;
+    using ExecutorStaticPtr = std::shared_ptr<ExecutorStatic>;
     template <class T>
-    using ExecutorMemberPtr = SharedChildPtr<ExecutorMember<T>, ExecutorPtr>;
+    using ExecutorMemberPtr = std::shared_ptr<ExecutorMember<T>>;
 }
 

code/branches/cpp11_v2/src/libraries/core/command/Functor.h

@@ -505 +505 @@
             FunctorPtr clone()
             {
-                return new FunctorTemplate(*this);
+                return std::make_shared<FunctorTemplate>(*this);
             }
 
@@ -574 +574 @@
     };
 
-    template <class R, class O, class OO, class P1, class P2, class P3, class P4, class P5> inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3, P4, P5), OO* object) { return new FunctorTemplate<R, O, false, P1, P2, P3, P4, P5>(functionPointer, object); }   ///< Creates a new FunctorMember with the given function-pointer and an assigned object
-    template <class R, class O, class OO, class P1, class P2, class P3, class P4>           inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3, P4), OO* object)     { return new FunctorTemplate<R, O, false, P1, P2, P3, P4, void>(functionPointer, object); }   ///< Creates a new FunctorMember with the given function-pointer and an assigned object
-    template <class R, class O, class OO, class P1, class P2, class P3>                     inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3), OO* object)         { return new FunctorTemplate<R, O, false, P1, P2, P3, void, void>(functionPointer, object); }   ///< Creates a new FunctorMember with the given function-pointer and an assigned object
-    template <class R, class O, class OO, class P1, class P2>                               inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2), OO* object)             { return new FunctorTemplate<R, O, false, P1, P2, void, void, void>(functionPointer, object); }   ///< Creates a new FunctorMember with the given function-pointer and an assigned object
-    template <class R, class O, class OO, class P1>                                         inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1), OO* object)                 { return new FunctorTemplate<R, O, false, P1, void, void, void, void>(functionPointer, object); }   ///< Creates a new FunctorMember with the given function-pointer and an assigned object
-    template <class R, class O, class OO>                                                   inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(), OO* object)                   { return new FunctorTemplate<R, O, false, void, void, void, void, void>(functionPointer, object); }   ///< Creates a new FunctorMember with the given function-pointer and an assigned object
-    template <class R, class O, class OO, class P1, class P2, class P3, class P4, class P5> inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3, P4, P5) const, OO* object) { return new FunctorTemplate<R, O, true, P1, P2, P3, P4, P5>(functionPointer, object); }   ///< Creates a new FunctorMember with the given function-pointer and an assigned object
-    template <class R, class O, class OO, class P1, class P2, class P3, class P4>           inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3, P4) const, OO* object)     { return new FunctorTemplate<R, O, true, P1, P2, P3, P4, void>(functionPointer, object); }   ///< Creates a new FunctorMember with the given function-pointer and an assigned object
-    template <class R, class O, class OO, class P1, class P2, class P3>                     inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3) const, OO* object)         { return new FunctorTemplate<R, O, true, P1, P2, P3, void, void>(functionPointer, object); }   ///< Creates a new FunctorMember with the given function-pointer and an assigned object
-    template <class R, class O, class OO, class P1, class P2>                               inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2) const, OO* object)             { return new FunctorTemplate<R, O, true, P1, P2, void, void, void>(functionPointer, object); }   ///< Creates a new FunctorMember with the given function-pointer and an assigned object
-    template <class R, class O, class OO, class P1>                                         inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1) const, OO* object)                 { return new FunctorTemplate<R, O, true, P1, void, void, void, void>(functionPointer, object); }   ///< Creates a new FunctorMember with the given function-pointer and an assigned object
-    template <class R, class O, class OO>                                                   inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)() const, OO* object)                   { return new FunctorTemplate<R, O, true, void, void, void, void, void>(functionPointer, object); }   ///< Creates a new FunctorMember with the given function-pointer and an assigned object
-
-    template <class R, class O, class P1, class P2, class P3, class P4, class P5> inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3, P4, P5)) { return new FunctorTemplate<R, O, false, P1, P2, P3, P4, P5>(functionPointer); }   ///< Creates a new FunctorMember with the given function-pointer
-    template <class R, class O, class P1, class P2, class P3, class P4>           inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3, P4))     { return new FunctorTemplate<R, O, false, P1, P2, P3, P4, void>(functionPointer); }   ///< Creates a new FunctorMember with the given function-pointer
-    template <class R, class O, class P1, class P2, class P3>                     inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3))         { return new FunctorTemplate<R, O, false, P1, P2, P3, void, void>(functionPointer); }   ///< Creates a new FunctorMember with the given function-pointer
-    template <class R, class O, class P1, class P2>                               inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2))             { return new FunctorTemplate<R, O, false, P1, P2, void, void, void>(functionPointer); }   ///< Creates a new FunctorMember with the given function-pointer
-    template <class R, class O, class P1>                                         inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1))                 { return new FunctorTemplate<R, O, false, P1, void, void, void, void>(functionPointer); }   ///< Creates a new FunctorMember with the given function-pointer
-    template <class R, class O>                                                   inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)())                   { return new FunctorTemplate<R, O, false, void, void, void, void, void>(functionPointer); }   ///< Creates a new FunctorMember with the given function-pointer
-    template <class R, class O, class P1, class P2, class P3, class P4, class P5> inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3, P4, P5) const) { return new FunctorTemplate<R, O, true, P1, P2, P3, P4, P5>(functionPointer); }   ///< Creates a new FunctorMember with the given function-pointer
-    template <class R, class O, class P1, class P2, class P3, class P4>           inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3, P4) const)     { return new FunctorTemplate<R, O, true, P1, P2, P3, P4, void>(functionPointer); }   ///< Creates a new FunctorMember with the given function-pointer
-    template <class R, class O, class P1, class P2, class P3>                     inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3) const)         { return new FunctorTemplate<R, O, true, P1, P2, P3, void, void>(functionPointer); }   ///< Creates a new FunctorMember with the given function-pointer
-    template <class R, class O, class P1, class P2>                               inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2) const)             { return new FunctorTemplate<R, O, true, P1, P2, void, void, void>(functionPointer); }   ///< Creates a new FunctorMember with the given function-pointer
-    template <class R, class O, class P1>                                         inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1) const)                 { return new FunctorTemplate<R, O, true, P1, void, void, void, void>(functionPointer); }   ///< Creates a new FunctorMember with the given function-pointer
-    template <class R, class O>                                                   inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)() const)                   { return new FunctorTemplate<R, O, true, void, void, void, void, void>(functionPointer); }   ///< Creates a new FunctorMember with the given function-pointer
-
-    template <class R, class P1, class P2, class P3, class P4, class P5> inline FunctorStaticPtr createFunctor(R (*functionPointer)(P1, P2, P3, P4, P5)) { return new FunctorTemplate<R, void, false, P1, P2, P3, P4, P5>(functionPointer); }   ///< Creates a new Functor with the given function-pointer
-    template <class R, class P1, class P2, class P3, class P4>           inline FunctorStaticPtr createFunctor(R (*functionPointer)(P1, P2, P3, P4))     { return new FunctorTemplate<R, void, false, P1, P2, P3, P4, void>(functionPointer); }   ///< Creates a new Functor with the given function-pointer
-    template <class R, class P1, class P2, class P3>                     inline FunctorStaticPtr createFunctor(R (*functionPointer)(P1, P2, P3))         { return new FunctorTemplate<R, void, false, P1, P2, P3, void, void>(functionPointer); }   ///< Creates a new Functor with the given function-pointer
-    template <class R, class P1, class P2>                               inline FunctorStaticPtr createFunctor(R (*functionPointer)(P1, P2))             { return new FunctorTemplate<R, void, false, P1, P2, void, void, void>(functionPointer); }   ///< Creates a new Functor with the given function-pointer
-    template <class R, class P1>                                         inline FunctorStaticPtr createFunctor(R (*functionPointer)(P1))                 { return new FunctorTemplate<R, void, false, P1, void, void, void, void>(functionPointer); }   ///< Creates a new Functor with the given function-pointer
-    template <class R>                                                   inline FunctorStaticPtr createFunctor(R (*functionPointer)())                   { return new FunctorTemplate<R, void, false, void, void, void, void, void>(functionPointer); }   ///< Creates a new Functor with the given function-pointer
+    template <class R, class O, class OO, class P1, class P2, class P3, class P4, class P5> inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3, P4, P5), OO* object) { return std::make_shared<FunctorTemplate<R, O, false, P1, P2, P3, P4, P5>>(functionPointer, object); }   ///< Creates a new FunctorMember with the given function-pointer and an assigned object
+    template <class R, class O, class OO, class P1, class P2, class P3, class P4>           inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3, P4), OO* object)     { return std::make_shared<FunctorTemplate<R, O, false, P1, P2, P3, P4, void>>(functionPointer, object); }   ///< Creates a new FunctorMember with the given function-pointer and an assigned object
+    template <class R, class O, class OO, class P1, class P2, class P3>                     inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3), OO* object)         { return std::make_shared<FunctorTemplate<R, O, false, P1, P2, P3, void, void>>(functionPointer, object); }   ///< Creates a new FunctorMember with the given function-pointer and an assigned object
+    template <class R, class O, class OO, class P1, class P2>                               inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2), OO* object)             { return std::make_shared<FunctorTemplate<R, O, false, P1, P2, void, void, void>>(functionPointer, object); }   ///< Creates a new FunctorMember with the given function-pointer and an assigned object
+    template <class R, class O, class OO, class P1>                                         inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1), OO* object)                 { return std::make_shared<FunctorTemplate<R, O, false, P1, void, void, void, void>>(functionPointer, object); }   ///< Creates a new FunctorMember with the given function-pointer and an assigned object
+    template <class R, class O, class OO>                                                   inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(), OO* object)                   { return std::make_shared<FunctorTemplate<R, O, false, void, void, void, void, void>>(functionPointer, object); }   ///< Creates a new FunctorMember with the given function-pointer and an assigned object
+    template <class R, class O, class OO, class P1, class P2, class P3, class P4, class P5> inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3, P4, P5) const, OO* object) { return std::make_shared<FunctorTemplate<R, O, true, P1, P2, P3, P4, P5>>(functionPointer, object); }   ///< Creates a new FunctorMember with the given function-pointer and an assigned object
+    template <class R, class O, class OO, class P1, class P2, class P3, class P4>           inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3, P4) const, OO* object)     { return std::make_shared<FunctorTemplate<R, O, true, P1, P2, P3, P4, void>>(functionPointer, object); }   ///< Creates a new FunctorMember with the given function-pointer and an assigned object
+    template <class R, class O, class OO, class P1, class P2, class P3>                     inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3) const, OO* object)         { return std::make_shared<FunctorTemplate<R, O, true, P1, P2, P3, void, void>>(functionPointer, object); }   ///< Creates a new FunctorMember with the given function-pointer and an assigned object
+    template <class R, class O, class OO, class P1, class P2>                               inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2) const, OO* object)             { return std::make_shared<FunctorTemplate<R, O, true, P1, P2, void, void, void>>(functionPointer, object); }   ///< Creates a new FunctorMember with the given function-pointer and an assigned object
+    template <class R, class O, class OO, class P1>                                         inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1) const, OO* object)                 { return std::make_shared<FunctorTemplate<R, O, true, P1, void, void, void, void>>(functionPointer, object); }   ///< Creates a new FunctorMember with the given function-pointer and an assigned object
+    template <class R, class O, class OO>                                                   inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)() const, OO* object)                   { return std::make_shared<FunctorTemplate<R, O, true, void, void, void, void, void>>(functionPointer, object); }   ///< Creates a new FunctorMember with the given function-pointer and an assigned object
+
+    template <class R, class O, class P1, class P2, class P3, class P4, class P5> inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3, P4, P5)) { return std::make_shared<FunctorTemplate<R, O, false, P1, P2, P3, P4, P5>>(functionPointer); }   ///< Creates a new FunctorMember with the given function-pointer
+    template <class R, class O, class P1, class P2, class P3, class P4>           inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3, P4))     { return std::make_shared<FunctorTemplate<R, O, false, P1, P2, P3, P4, void>>(functionPointer); }   ///< Creates a new FunctorMember with the given function-pointer
+    template <class R, class O, class P1, class P2, class P3>                     inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3))         { return std::make_shared<FunctorTemplate<R, O, false, P1, P2, P3, void, void>>(functionPointer); }   ///< Creates a new FunctorMember with the given function-pointer
+    template <class R, class O, class P1, class P2>                               inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2))             { return std::make_shared<FunctorTemplate<R, O, false, P1, P2, void, void, void>>(functionPointer); }   ///< Creates a new FunctorMember with the given function-pointer
+    template <class R, class O, class P1>                                         inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1))                 { return std::make_shared<FunctorTemplate<R, O, false, P1, void, void, void, void>>(functionPointer); }   ///< Creates a new FunctorMember with the given function-pointer
+    template <class R, class O>                                                   inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)())                   { return std::make_shared<FunctorTemplate<R, O, false, void, void, void, void, void>>(functionPointer); }   ///< Creates a new FunctorMember with the given function-pointer
+    template <class R, class O, class P1, class P2, class P3, class P4, class P5> inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3, P4, P5) const) { return std::make_shared<FunctorTemplate<R, O, true, P1, P2, P3, P4, P5>>(functionPointer); }   ///< Creates a new FunctorMember with the given function-pointer
+    template <class R, class O, class P1, class P2, class P3, class P4>           inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3, P4) const)     { return std::make_shared<FunctorTemplate<R, O, true, P1, P2, P3, P4, void>>(functionPointer); }   ///< Creates a new FunctorMember with the given function-pointer
+    template <class R, class O, class P1, class P2, class P3>                     inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3) const)         { return std::make_shared<FunctorTemplate<R, O, true, P1, P2, P3, void, void>>(functionPointer); }   ///< Creates a new FunctorMember with the given function-pointer
+    template <class R, class O, class P1, class P2>                               inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2) const)             { return std::make_shared<FunctorTemplate<R, O, true, P1, P2, void, void, void>>(functionPointer); }   ///< Creates a new FunctorMember with the given function-pointer
+    template <class R, class O, class P1>                                         inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1) const)                 { return std::make_shared<FunctorTemplate<R, O, true, P1, void, void, void, void>>(functionPointer); }   ///< Creates a new FunctorMember with the given function-pointer
+    template <class R, class O>                                                   inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)() const)                   { return std::make_shared<FunctorTemplate<R, O, true, void, void, void, void, void>>(functionPointer); }   ///< Creates a new FunctorMember with the given function-pointer
+
+    template <class R, class P1, class P2, class P3, class P4, class P5> inline FunctorStaticPtr createFunctor(R (*functionPointer)(P1, P2, P3, P4, P5)) { return std::make_shared<FunctorTemplate<R, void, false, P1, P2, P3, P4, P5>>(functionPointer); }   ///< Creates a new Functor with the given function-pointer
+    template <class R, class P1, class P2, class P3, class P4>           inline FunctorStaticPtr createFunctor(R (*functionPointer)(P1, P2, P3, P4))     { return std::make_shared<FunctorTemplate<R, void, false, P1, P2, P3, P4, void>>(functionPointer); }   ///< Creates a new Functor with the given function-pointer
+    template <class R, class P1, class P2, class P3>                     inline FunctorStaticPtr createFunctor(R (*functionPointer)(P1, P2, P3))         { return std::make_shared<FunctorTemplate<R, void, false, P1, P2, P3, void, void>>(functionPointer); }   ///< Creates a new Functor with the given function-pointer
+    template <class R, class P1, class P2>                               inline FunctorStaticPtr createFunctor(R (*functionPointer)(P1, P2))             { return std::make_shared<FunctorTemplate<R, void, false, P1, P2, void, void, void>>(functionPointer); }   ///< Creates a new Functor with the given function-pointer
+    template <class R, class P1>                                         inline FunctorStaticPtr createFunctor(R (*functionPointer)(P1))                 { return std::make_shared<FunctorTemplate<R, void, false, P1, void, void, void, void>>(functionPointer); }   ///< Creates a new Functor with the given function-pointer
+    template <class R>                                                   inline FunctorStaticPtr createFunctor(R (*functionPointer)())                   { return std::make_shared<FunctorTemplate<R, void, false, void, void, void, void, void>>(functionPointer); }   ///< Creates a new Functor with the given function-pointer
 }
 

code/branches/cpp11_v2/src/libraries/core/command/FunctorPtr.h

@@ -51 +51 @@
 
 #include "core/CorePrereqs.h"
-#include "util/SharedPtr.h"
+#include <memory>
 
 namespace orxonox
 {
-    using FunctorPtr = SharedPtr<Functor>;
+    using FunctorPtr = std::shared_ptr<Functor>;
     template <class T>
-    using FunctorMemberPtr = SharedChildPtr<FunctorMember<T>, FunctorPtr>;
-    using FunctorStaticPtr = FunctorMemberPtr<void>;
+    using FunctorMemberPtr = std::shared_ptr<FunctorMember<T>>;
+    using FunctorStaticPtr = std::shared_ptr<FunctorMember<void>>;
     template <class F, class T>
-    using FunctorPointerPtr = SharedChildPtr<FunctorPointer<F, T>, FunctorMemberPtr<T>>;
+    using FunctorPointerPtr = std::shared_ptr<FunctorPointer<F, T>>;
 }
 

code/branches/cpp11_v2/src/libraries/core/input/KeyBinderManager.h

@@ -36 +36 @@
 
 #include "util/Singleton.h"
+#include "util/SharedPtr.h"
 #include "core/config/Configurable.h"
 

code/branches/cpp11_v2/src/libraries/core/object/Listable.h

@@ -40 +40 @@
 #include <vector>
 
+#include "util/SmallObjectAllocator.h"
 #include "core/class/Identifiable.h"
 

code/branches/cpp11_v2/test/core/command/ExecutorPtrTest.cc

@@ -11 +11 @@
                 void testMember() {}
                 static void testStatic() {}
+        };
+
+        class Subclass : public Testclass
+        {
         };
 
@@ -71 +75 @@
         ASSERT_TRUE(static_cast<bool>(ptr2));
     }
+
+    TEST_F(ExecutorPtrTest, canCastToExecutorMemberOfSubclass)
+    {
+        ExecutorPtr ptr1 = createExecutor(createFunctor(&Subclass::testMember));
+        ExecutorMemberPtr<Subclass> ptr2 = std::static_pointer_cast<ExecutorMember<Subclass>>(ptr1);
+        ASSERT_TRUE(static_cast<bool>(ptr2));
+    }
 }

code/branches/cpp11_v2/test/core/command/FunctorPtrTest.cc

@@ -11 +11 @@
                 void testMember() {}
                 static void testStatic() {}
+        };
+
+        class Subclass : public Testclass
+        {
         };
 
@@ -71 +75 @@
         ASSERT_TRUE(static_cast<bool>(ptr2));
     }
+
+    TEST_F(FunctorPtrTest, canCastToFunctorMemberOfSubclass)
+    {
+        FunctorPtr ptr1 = createFunctor(&Subclass::testMember);
+        FunctorMemberPtr<Subclass> ptr2 = std::static_pointer_cast<FunctorMember<Subclass>>(ptr1);
+        ASSERT_TRUE(static_cast<bool>(ptr2));
+    }
 }