dali/public-api/signals/functor-delegate.h

   1 #ifndef __DALI_FUNCTOR_DELEGATE_H__
   2 #define __DALI_FUNCTOR_DELEGATE_H__
   3
   4 /*
   5  * Copyright (c) 2015 Samsung Electronics Co., Ltd.
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  * http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  */
  20
  21 // INTERNAL INCLUDES
  22 #include <dali/public-api/common/dali-common.h>
  23
  24 namespace Dali
  25 {
  26 /**
  27  * @addtogroup dali_core_signals
  28  * @{
  29  */
  30
  31 /**
  32  * @brief Dispatcher to call a functor
  33  * @SINCE_1_0.0
  34  */
  35 template< typename T >
  36 struct FunctorDispatcher
  37 {
  38   /**
  39    * @brief Call a function object.
  40    *
  41    * @SINCE_1_0.0
  42    * @param[in] functorPtr The functor to call.
  43    */
  44   static void Dispatch( void* functorPtr )
  45   {
  46     // "downcast" the functor type back to the correct one
  47     T* functor = reinterpret_cast< T* >( functorPtr );
  48     (*functor)();
  49   }
  50 };
  51
  52 /**
  53  * @brief Dispatcher to delete a functor object
  54  * @SINCE_1_0.0
  55  */
  56 template< typename T >
  57 struct FunctorDestroyer
  58 {
  59   /**
  60    * @brief Dispatcher to delete an object
  61    * @SINCE_1_0.0
  62    */
  63   static void Delete( void* functorPtr )
  64   {
  65     // FunctorDelegate owns the object but we're the only one who knows the real type so need
  66     // to delete by "downcasting" from void* to the correct type
  67     delete reinterpret_cast< T* >( functorPtr );
  68   }
  69 };
  70
  71 /**
  72  * @brief Used to connect a void() functor to a signal via BaseObject::SignalConnect()
  73  * @SINCE_1_0.0
  74  */
  75 class DALI_IMPORT_API FunctorDelegate
  76 {
  77 public:
  78
  79   /**
  80    * @brief Constructor which copies a function object.
  81    *
  82    * @SINCE_1_0.0
  83    * @param[in] functor The functor object to copy, either a class with operator() or a C function
  84    * @return A pointer to the new function object
  85    */
  86   template< typename T >
  87   static FunctorDelegate* New( const T& functor )
  88   {
  89     return new FunctorDelegate( reinterpret_cast< void* >( new T( functor ) ), // heap allocate the functor
  90                                 reinterpret_cast< FunctorDelegate::Dispatcher >( &FunctorDispatcher<T>::Dispatch ),
  91                                 reinterpret_cast< FunctorDelegate::Destructor >( &FunctorDestroyer<T>::Delete ) );
  92   }
  93
  94   /**
  95    * @brief Non-virtual destructor; not intended as a base class.
  96    * @SINCE_1_0.0
  97    */
  98   ~FunctorDelegate();
  99
 100   /**
 101    * @brief Function to call the function or member function dispatcher
 102    * @SINCE_1_0.0
 103    */
 104   void Execute();
 105
 106 private:
 107
 108   /**
 109    * @brief Used to call the correct function.
 110    * @SINCE_1_0.0
 111    */
 112   typedef void (*Dispatcher)( void* objectPtr );
 113
 114   /**
 115    * @brief Used to destroy mObjectPointer.
 116    * @SINCE_1_0.0
 117    */
 118   typedef void(*Destructor)( void* objectPtr );
 119
 120   /**
 121    * @brief Not defined
 122    * @SINCE_1_0.0
 123    */
 124   FunctorDelegate( const FunctorDelegate& rhs );
 125
 126   /**
 127    * @brief Not defined
 128    * @SINCE_1_0.0
 129    */
 130   const FunctorDelegate& operator=( const FunctorDelegate& rhs );
 131
 132   /**
 133    * @brief Private constructor.
 134    *
 135    * @SINCE_1_0.0
 136    * @param[in] functorPtr A newly allocated functor object (takes ownership)
 137    * @param dispatcher Used to call the actual function.
 138    * @param destructor Used to delete the owned functor object.
 139    */
 140   FunctorDelegate( void* functorPtr, Dispatcher dispatcher, Destructor destructor );
 141
 142 public: // Data for deriving classes & Dispatchers
 143
 144   void* mFunctorPointer;                ///< Functor that will be called
 145   Dispatcher mMemberFunctionDispatcher; ///< Dispatcher for member functions
 146   Destructor mDestructorDispatcher;     ///< Destructor for owned objects
 147 };
 148
 149 /**
 150  * @}
 151  */
 152 } // namespace DALI
 153
 154 #endif // __DALI_FUNCTOR_DELEGATE_H__