use modern construct 'override' in the derive class.

[platform/core/uifw/dali-core.git] / dali / internal / common / message.h

diff --git a/dali/internal/common/message.h b/dali/internal/common/message.h
index a1068ae..382aa9d 100644 (file)
--- a/dali/internal/common/message.h
+++ b/dali/internal/common/message.h
@@ -1,8 +1,8 @@
-#ifndef __DALI_INTERNAL_MESSAGE_H__
-#define __DALI_INTERNAL_MESSAGE_H__
+#ifndef DALI_INTERNAL_MESSAGE_H
+#define DALI_INTERNAL_MESSAGE_H
 
 /*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2019 Samsung Electronics Co., Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -70,8 +70,7 @@ template< typename T >
 class Message : public MessageBase
 {
 public:
-
-  typedef void(T::*MemberFunction)();
+  using MemberFunction = void ( T::* )();
 
   /**
    * Create a message.
@@ -85,21 +84,21 @@ public:
     object( const_cast< T* >( obj ) ),
     memberFunction( member )
   {
+    DALI_ASSERT_DEBUG( object && "nullptr passed into message as object" );
   }
 
   /**
    * Virtual destructor
    */
-  virtual ~Message()
+  ~Message() override
   {
   }
 
   /**
    * @copydoc MessageBase::Process
    */
-  virtual void Process( BufferIndex /*bufferIndex*/ )
+  void Process( BufferIndex /*bufferIndex*/ ) override
   {
-    DALI_ASSERT_DEBUG( object && "Message does not have an object" );
     (object->*memberFunction)();
   }
 
@@ -120,8 +119,7 @@ template< typename T, typename P >
 class MessageValue1 : public MessageBase
 {
 public:
-
-  typedef void(T::*MemberFunction)( typename ParameterType< P >::PassingType );
+  using MemberFunction = void ( T::* )( typename ParameterType<P>::PassingType );
 
   /**
    * Create a message.
@@ -139,22 +137,22 @@ public:
     memberFunction( member ),
     param1( p1 )
   {
+    DALI_ASSERT_DEBUG( object && "nullptr passed into message as object" );
   }
 
   /**
    * Virtual destructor
    */
-  virtual ~MessageValue1()
+  ~MessageValue1() override
   {
   }
 
   /**
    * @copydoc MessageBase::Process
    */
-  virtual void Process( BufferIndex /*bufferIndex*/ )
+  void Process( BufferIndex /*bufferIndex*/ ) override
   {
-    DALI_ASSERT_DEBUG( object && "Message does not have an object" );
-    (object->*memberFunction)( ParameterType< P >::PassObject( param1 ) );
+    (object->*memberFunction)( param1 );
   }
 
 private:
@@ -176,10 +174,7 @@ template< typename T, typename P1, typename P2 >
 class MessageValue2 : public MessageBase
 {
 public:
-
-  typedef void(T::*MemberFunction)(
-      typename ParameterType< P1 >::PassingType,
-      typename ParameterType< P2 >::PassingType );
+  using MemberFunction = void ( T::* )( typename ParameterType<P1>::PassingType, typename ParameterType<P2>::PassingType );
 
   /**
    * Create a message.
@@ -200,24 +195,22 @@ public:
     param1( p1 ),
     param2( p2 )
   {
+    DALI_ASSERT_DEBUG( object && "nullptr passed into message as object" );
   }
 
   /**
    * Virtual destructor
    */
-  virtual ~MessageValue2()
+  ~MessageValue2() override
   {
   }
 
   /**
    * @copydoc MessageBase::Process
    */
-  virtual void Process( BufferIndex /*bufferIndex*/ )
+  void Process( BufferIndex /*bufferIndex*/ ) override
   {
-    DALI_ASSERT_DEBUG( object && "Message does not have an object" );
-    (object->*memberFunction)(
-        ParameterType< P1 >::PassObject( param1 ),
-        ParameterType< P2 >::PassObject( param2 ) );
+    (object->*memberFunction)( param1, param2 );
   }
 
 private:
@@ -239,11 +232,7 @@ template< typename T, typename P1, typename P2, typename P3 >
 class MessageValue3 : public MessageBase
 {
 public:
-
-  typedef void(T::*MemberFunction)(
-      typename ParameterType< P1 >::PassingType,
-      typename ParameterType< P2 >::PassingType,
-      typename ParameterType< P3 >::PassingType );
+  using MemberFunction = void ( T::* )( typename ParameterType<P1>::PassingType, typename ParameterType<P2>::PassingType, typename ParameterType<P3>::PassingType );
 
   /**
    * Create a message.
@@ -267,25 +256,22 @@ public:
     param2( p2 ),
     param3( p3 )
   {
+    DALI_ASSERT_DEBUG( object && "nullptr passed into message as object" );
   }
 
   /**
    * Virtual destructor
    */
-  virtual ~MessageValue3()
+  ~MessageValue3() override
   {
   }
 
   /**
    * @copydoc MessageBase::Process
    */
-  virtual void Process( BufferIndex /*bufferIndex*/ )
+  void Process( BufferIndex /*bufferIndex*/ ) override
   {
-    DALI_ASSERT_DEBUG( object && "Message does not have an object" );
-    (object->*memberFunction)(
-        ParameterType< P1 >::PassObject( param1 ),
-        ParameterType< P2 >::PassObject( param2 ),
-        ParameterType< P3 >::PassObject( param3 ) );
+    (object->*memberFunction)( param1, param2, param3 );
   }
 
 private:
@@ -308,12 +294,7 @@ template< typename T, typename P1, typename P2, typename P3, typename P4 >
 class MessageValue4 : public MessageBase
 {
 public:
-
-  typedef void(T::*MemberFunction)(
-      typename ParameterType< P1 >::PassingType,
-      typename ParameterType< P2 >::PassingType,
-      typename ParameterType< P3 >::PassingType,
-      typename ParameterType< P4 >::PassingType );
+  using MemberFunction = void ( T::* )( typename ParameterType<P1>::PassingType, typename ParameterType<P2>::PassingType, typename ParameterType<P3>::PassingType, typename ParameterType<P4>::PassingType );
 
   /**
    * Create a message.
@@ -340,26 +321,22 @@ public:
     param3( p3 ),
     param4( p4 )
   {
+    DALI_ASSERT_DEBUG( object && "nullptr passed into message as object" );
   }
 
   /**
    * Virtual destructor
    */
-  virtual ~MessageValue4()
+  ~MessageValue4() override
   {
   }
 
   /**
    * @copydoc MessageBase::Process
    */
-  virtual void Process( BufferIndex /*bufferIndex*/ )
+  void Process( BufferIndex /*bufferIndex*/ ) override
   {
-    DALI_ASSERT_DEBUG( object && "Message does not have an object" );
-    (object->*memberFunction)(
-        ParameterType< P1 >::PassObject( param1 ),
-        ParameterType< P2 >::PassObject( param2 ),
-        ParameterType< P3 >::PassObject( param3 ),
-        ParameterType< P4 >::PassObject( param4 ) );
+    (object->*memberFunction)( param1, param2, param3, param4 );
   }
 
 private:
@@ -383,13 +360,7 @@ template< typename T, typename P1, typename P2, typename P3, typename P4, typena
 class MessageValue5 : public MessageBase
 {
 public:
-
-  typedef void(T::*MemberFunction)(
-      typename ParameterType< P1 >::PassingType,
-      typename ParameterType< P2 >::PassingType,
-      typename ParameterType< P3 >::PassingType,
-      typename ParameterType< P4 >::PassingType,
-      typename ParameterType< P5 >::PassingType );
+  using MemberFunction = void ( T::* )( typename ParameterType<P1>::PassingType, typename ParameterType<P2>::PassingType, typename ParameterType<P3>::PassingType, typename ParameterType<P4>::PassingType, typename ParameterType<P5>::PassingType );
 
   /**
    * Create a message.
@@ -419,28 +390,95 @@ public:
     param4( p4 ),
     param5( p5 )
   {
+    DALI_ASSERT_DEBUG( object && "nullptr passed into message as object" );
   }
 
   /**
    * Virtual destructor
    */
-  virtual ~MessageValue5()
+  ~MessageValue5() override
   {
   }
 
   /**
    * @copydoc MessageBase::Process
    */
-  virtual void Process( BufferIndex /*bufferIndex*/ )
+  void Process( BufferIndex /*bufferIndex*/ ) override
+  {
+    (object->*memberFunction)( param1, param2, param3, param4, param5 );
+  }
+
+private:
+
+  T* object;
+  MemberFunction memberFunction;
+  typename ParameterType< P1 >::HolderType param1;
+  typename ParameterType< P2 >::HolderType param2;
+  typename ParameterType< P3 >::HolderType param3;
+  typename ParameterType< P4 >::HolderType param4;
+  typename ParameterType< P5 >::HolderType param5;
+
+};
+
+/**
+ * Templated message which calls a member function of an object.
+ * This overload passes six value-type parameters.
+ * Template parameters need to match the MemberFunction!
+ * The message will contain copy of the value (in case of & or const&)
+ */
+template< typename T, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6 >
+class MessageValue6 : public MessageBase
+{
+public:
+  using MemberFunction = void ( T::* )( typename ParameterType<P1>::PassingType, typename ParameterType<P2>::PassingType, typename ParameterType<P3>::PassingType, typename ParameterType<P4>::PassingType, typename ParameterType<P5>::PassingType, typename ParameterType<P6>::PassingType );
+
+  /**
+   * Create a message.
+   * @note The object is expected to be const in the thread which sends this message.
+   * However it can be modified when Process() is called in a different thread.
+   * @param[in] obj The object.
+   * @param[in] member The member function of the object.
+   * @param[in] p1 The first parameter to pass to the member function.
+   * @param[in] p2 The second parameter to pass to the member function.
+   * @param[in] p3 The third parameter to pass to the member function.
+   * @param[in] p4 The fourth parameter to pass to the member function.
+   * @param[in] p5 The fifth parameter to pass to the member function.
+   * @param[in] p6 The sixth parameter to pass to the member function.
+   */
+  MessageValue6( const T* obj,
+                 MemberFunction member,
+                 typename ParameterType< P1 >::PassingType p1,
+                 typename ParameterType< P2 >::PassingType p2,
+                 typename ParameterType< P3 >::PassingType p3,
+                 typename ParameterType< P4 >::PassingType p4,
+                 typename ParameterType< P5 >::PassingType p5,
+                 typename ParameterType< P6 >::PassingType p6 )
+  : MessageBase(),
+    object( const_cast< T* >( obj ) ),
+    memberFunction( member ),
+    param1( p1 ),
+    param2( p2 ),
+    param3( p3 ),
+    param4( p4 ),
+    param5( p5 ),
+    param6( p6 )
+  {
+    DALI_ASSERT_DEBUG( object && "nullptr passed into message as object" );
+  }
+
+  /**
+   * Virtual destructor
+   */
+  ~MessageValue6() override
   {
-    DALI_ASSERT_DEBUG( object && "Message does not have an object" );
-    (object->*memberFunction)(
-        ParameterType< P1 >::PassObject( param1 ),
-        ParameterType< P2 >::PassObject( param2 ),
-        ParameterType< P3 >::PassObject( param3 ),
-        ParameterType< P4 >::PassObject( param4 ),
-        ParameterType< P5 >::PassObject( param5 ) );
+  }
 
+  /**
+   * @copydoc MessageBase::Process
+   */
+  void Process( BufferIndex /*bufferIndex*/ ) override
+  {
+    (object->*memberFunction)( param1, param2, param3, param4, param5, param6 );
   }
 
 private:
@@ -452,9 +490,58 @@ private:
   typename ParameterType< P3 >::HolderType param3;
   typename ParameterType< P4 >::HolderType param4;
   typename ParameterType< P5 >::HolderType param5;
+  typename ParameterType< P6 >::HolderType param6;
+
+};
+
+/**
+ * Templated message which calls a member function of an object.
+ * This overload passes just the buffer index to the method, no parameters.
+ */
+template< typename T >
+class MessageDoubleBuffered0 : public MessageBase
+{
+public:
+  using MemberFunction = void ( T::* )( BufferIndex );
+
+  /**
+   * Create a message.
+   * @note The object is expected to be const in the thread which sends this message.
+   * However it can be modified when Process() is called in a different thread.
+   * @param[in] obj The object.
+   * @param[in] member The member function of the object.
+   */
+  MessageDoubleBuffered0( const T* obj, MemberFunction member )
+  : MessageBase(),
+    object( const_cast< T* >( obj ) ),
+    memberFunction( member )
+  {
+    DALI_ASSERT_DEBUG( object && "nullptr passed into message as object" );
+  }
+
+  /**
+   * Virtual destructor
+   */
+  ~MessageDoubleBuffered0() override
+  {
+  }
+
+  /**
+   * @copydoc MessageBase::Process
+   */
+  void Process( BufferIndex bufferIndex ) override
+  {
+    (object->*memberFunction)( bufferIndex );
+  }
+
+private:
+
+  T* object;
+  MemberFunction memberFunction;
 
 };
 
+
 /**
  * Templated message which calls a member function of an object.
  * This overload passes a value-type to set a double-buffered property.
@@ -465,10 +552,7 @@ template< typename T, typename P >
 class MessageDoubleBuffered1 : public MessageBase
 {
 public:
-
-  typedef void(T::*MemberFunction)(
-      BufferIndex,
-      typename ParameterType< P >::PassingType );
+  using MemberFunction = void ( T::* )( BufferIndex, typename ParameterType<P>::PassingType );
 
   /**
    * Create a message.
@@ -486,24 +570,22 @@ public:
     memberFunction( member ),
     param( p )
   {
+    DALI_ASSERT_DEBUG( object && "nullptr passed into message as object" );
   }
 
   /**
    * Virtual destructor
    */
-  virtual ~MessageDoubleBuffered1()
+  ~MessageDoubleBuffered1() override
   {
   }
 
   /**
    * @copydoc MessageBase::Process
    */
-  virtual void Process( BufferIndex bufferIndex )
+  void Process( BufferIndex bufferIndex ) override
   {
-    DALI_ASSERT_DEBUG( object && "Message does not have an object" );
-    (object->*memberFunction)(
-        bufferIndex,
-        ParameterType< P >::PassObject( param ) );
+    (object->*memberFunction)( bufferIndex,  param );
   }
 
 private:
@@ -524,11 +606,7 @@ template< typename T, typename P2, typename P3 >
 class MessageDoubleBuffered2 : public MessageBase
 {
 public:
-
-  typedef void(T::*MemberFunction)(
-      BufferIndex,
-      typename ParameterType< P2 >::PassingType,
-      typename ParameterType< P3 >::PassingType );
+  using MemberFunction = void ( T::* )( BufferIndex, typename ParameterType<P2>::PassingType, typename ParameterType<P3>::PassingType );
 
   /**
    * Create a message.
@@ -549,25 +627,22 @@ public:
     param2( p2 ),
     param3( p3 )
   {
+    DALI_ASSERT_DEBUG( object && "nullptr passed into message as object" );
   }
 
   /**
    * Virtual destructor
    */
-  virtual ~MessageDoubleBuffered2()
+  ~MessageDoubleBuffered2() override
   {
   }
 
   /**
    * @copydoc MessageBase::Process
    */
-  virtual void Process( BufferIndex bufferIndex )
+  void Process( BufferIndex bufferIndex ) override
   {
-    DALI_ASSERT_DEBUG( object && "Message does not have an object" );
-    (object->*memberFunction)(
-        bufferIndex,
-        ParameterType< P2 >::PassObject( param2 ),
-        ParameterType< P3 >::PassObject( param3 ) );
+    (object->*memberFunction)( bufferIndex, param2, param3 );
   }
 
 private:
@@ -590,12 +665,7 @@ template< typename T, typename P2, typename P3, typename P4 >
 class MessageDoubleBuffered3 : public MessageBase
 {
 public:
-
-  typedef void(T::*MemberFunction)(
-      BufferIndex,
-      typename ParameterType< P2 >::PassingType,
-      typename ParameterType< P3 >::PassingType,
-      typename ParameterType< P4 >::PassingType );
+  using MemberFunction = void ( T::* )( BufferIndex, typename ParameterType<P2>::PassingType, typename ParameterType<P3>::PassingType, typename ParameterType<P4>::PassingType );
 
   /**
    * Create a message.
@@ -619,26 +689,22 @@ public:
     param3( p3 ),
     param4( p4 )
   {
+    DALI_ASSERT_DEBUG( object && "nullptr passed into message as object" );
   }
 
   /**
    * Virtual destructor
    */
-  virtual ~MessageDoubleBuffered3()
+  ~MessageDoubleBuffered3() override
   {
   }
 
   /**
    * @copydoc MessageBase::Process
    */
-  virtual void Process( BufferIndex bufferIndex )
+  void Process( BufferIndex bufferIndex ) override
   {
-    DALI_ASSERT_DEBUG( object && "Message does not have an object" );
-    (object->*memberFunction)(
-        bufferIndex,
-        ParameterType< P2 >::PassObject( param2 ),
-        ParameterType< P3 >::PassObject( param3 ),
-        ParameterType< P4 >::PassObject( param4 ) );
+    (object->*memberFunction)( bufferIndex, param2, param3, param4 );
   }
 
 private:
@@ -661,13 +727,7 @@ template< typename T, typename P2, typename P3, typename P4, typename P5 >
 class MessageDoubleBuffered4 : public MessageBase
 {
 public:
-
-  typedef void(T::*MemberFunction)(
-      BufferIndex,
-      typename ParameterType< P2 >::PassingType,
-      typename ParameterType< P3 >::PassingType,
-      typename ParameterType< P4 >::PassingType,
-      typename ParameterType< P5 >::PassingType );
+  using MemberFunction = void ( T::* )( BufferIndex, typename ParameterType<P2>::PassingType, typename ParameterType<P3>::PassingType, typename ParameterType<P4>::PassingType, typename ParameterType<P5>::PassingType );
 
   /**
    * Create a message.
@@ -694,27 +754,22 @@ public:
     param4( p4 ),
     param5( p5 )
   {
+    DALI_ASSERT_DEBUG( object && "nullptr passed into message as object" );
   }
 
   /**
    * Virtual destructor
    */
-  virtual ~MessageDoubleBuffered4()
+  ~MessageDoubleBuffered4() override
   {
   }
 
   /**
    * @copydoc MessageBase::Process
    */
-  virtual void Process( BufferIndex bufferIndex )
+  void Process( BufferIndex bufferIndex ) override
   {
-    DALI_ASSERT_DEBUG( object && "Message does not have an object" );
-    (object->*memberFunction)(
-        bufferIndex,
-        ParameterType< P2 >::PassObject( param2 ),
-        ParameterType< P3 >::PassObject( param3 ),
-        ParameterType< P4 >::PassObject( param4 ),
-        ParameterType< P5 >::PassObject( param5 ) );
+    (object->*memberFunction)( bufferIndex, param2, param3, param4, param5 );
   }
 
 private:
@@ -732,4 +787,4 @@ private:
 
 } // namespace Dali
 
-#endif // __DALI_INTERNAL_MESSAGE_H__
+#endif // DALI_INTERNAL_MESSAGE_H