Changeset 10975 for code/branches/cpp11_v2/src

Timestamp:

Dec 23, 2015, 7:16:33 PM (9 years ago)

Author:

muemart

Message:

Extend Functor to handle any callable objects (lambdas!). Had to modify (un)registerObject, because apparently you can't dynamic_cast lambdas. Also wanted to perfect forward the object from createFunctor until obj_, but MSVC didn't like that.
Including new and improved Functor tests.

File:

• code/branches/cpp11_v2/src/libraries/core/command/Functor.h (modified) (5 diffs)

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

@@ -118 +118 @@
 #include <array>
 #include <typeindex>
+#include <type_traits>
 #include <tuple>
 
@@ -303 +304 @@
 
         protected:
-            /// Casts the object and registers as destruction listener.
+            /// Casts the object and registers as destruction listener if the object is a Destroyable.
+            template<bool = std::is_base_of<Destroyable, O>::value>
             inline void registerObject(O* object)
-                { Destroyable* base = dynamic_cast<Destroyable*>(object); if (base) { this->registerAsDestructionListener(base); } }
-            /// Casts the object and unregisters as destruction listener.
+                { this->registerAsDestructionListener(static_cast<Destroyable*>(object)); }
+
+            template<>
+            inline void registerObject<false>(O* object) {}
+
+            /// Casts the object and unregisters as destruction listener if the object is a Destroyable.
+            template<bool = std::is_base_of<Destroyable, O>::value>
             inline void unregisterObject(O* object)
-                { Destroyable* base = dynamic_cast<Destroyable*>(object); if (base) { this->unregisterAsDestructionListener(base); } }
-
-            /// Will be called by Destroyable::~Destroyable() if the stored object is deleted and the Functor is in safe mode.
+                { this->unregisterAsDestructionListener(static_cast<Destroyable*>(object)); }
+
+            template<>
+            inline void unregisterObject<false>(O* object) {}
+
+            /// Will be called by Destroyable::~Destroyable() if the stored object is a Destroyable and deleted and the Functor is in safe mode.
             virtual inline void objectDeleted() override
                 { this->object_ = nullptr; }
@@ -450 +460 @@
         @param O The class of the function
         @param isconst True if the function is a const member-function
-        @param P1 The type of the first parameter
-        @param P2 The type of the second parameter
-        @param P3 The type of the third parameter
-        @param P4 The type of the fourth parameter
-        @param P5 The type of the fifth parameter
+        @param Params The types of the parameters
 
         This template has many parameters and is usually not used directly. It is created by
@@ -566 +572 @@
     };
 
+
+    /**
+    @brief FunctorCallable is a child class of FunctorTemplate. It stores a callable
+    object (e.g. a lambda or a class with operator()) inside and acts like any
+    other functor. Note that it stores a \em copy of the object, not a reference or a pointer.
+    Take care that this functor does not outlive objects that have been captured by reference
+    in a lambda.
+
+    @param F The type of the callable object
+    @param R The type of the return-value of the function
+    @param isconst True if operator() is const
+    @param Params The types of the parameters
+
+    This template can not be used directly when using lambdas - the type of a lambda
+    is not specified. It can only really be used through the base-class Functor.
+    */
+    template <class F, class R, bool isconst, class... Params>
+    class FunctorCallable : public FunctorTemplate<R, F, isconst, Params...>
+    {
+    public:
+        FunctorCallable(const F& obj): FunctorTemplate<R, F, isconst, Params...>(&F::operator(), &obj_)
+            , obj_(obj)
+        {}
+
+    private:
+        F obj_; ///< The callable object
+    };
+
+    namespace detail
+    {
+        //Helper functions to deduce types and constness of operator() and return the correct FunctorCallable
+        template <class F, class R, class... Params> inline FunctorMemberPtr<F> callableHelper(const F& obj, R(F::*func)(Params...) const) { return std::make_shared<FunctorCallable<F, R, true, Params...>>(obj); }
+        template <class F, class R, class... Params> inline FunctorMemberPtr<F> callableHelper(const F& obj, R(F::*func)(Params...)) { return std::make_shared<FunctorCallable<F, R, false, Params...>>(obj); }
+    }
+
     template <class R, class O, class OO, class... Params> inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(Params...), OO* object) { return std::make_shared<FunctorTemplate<R, O, false, Params...>>(functionPointer, object); }   ///< Creates a new FunctorMember with the given function-pointer and an assigned object
     template <class R, class O, class OO, class... Params> inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(Params...) const, OO* object) { return std::make_shared<FunctorTemplate<R, O, true, Params...>>(functionPointer, object); }   ///< Creates a new FunctorMember with the given function-pointer and an assigned object
@@ -573 +614 @@
 
     template <class R, class... Params> inline FunctorStaticPtr createFunctor(R (*functionPointer)(Params...)) { return std::make_shared<FunctorTemplate<R, void, false, Params...>>(functionPointer); }   ///< Creates a new Functor with the given function-pointer
+    
+    template <class F> inline FunctorMemberPtr<F> createFunctor(const F& obj) { return detail::callableHelper(obj, &F::operator()); } ///< Creates a new Functor with a callable object
 }