dali/internal/common/message.h

   1 #ifndef DALI_INTERNAL_MESSAGE_H
   2 #define DALI_INTERNAL_MESSAGE_H
   3
   4 /*
   5  * Copyright (c) 2019 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/internal/common/buffer-index.h>
  23 #include <dali/internal/common/type-abstraction.h>
  24 #include <dali/internal/update/common/scene-graph-buffers.h>
  25
  26 namespace Dali
  27 {
  28
  29 namespace Internal
  30 {
  31
  32 /**
  33  * An abstract base class for messages queued across threads.
  34  * Messages are only allowed to contain value objects, either copies of the parameters or pointers
  35  * If message parameter type is & or const& the message will try to take a copy of the actual type
  36  */
  37 class MessageBase
  38 {
  39 public:
  40
  41   /**
  42    * Construct the message base.
  43    */
  44   MessageBase( )
  45   {
  46   }
  47
  48   /**
  49    * Virtual destructor
  50    */
  51   virtual ~MessageBase()
  52   {
  53   }
  54
  55   /**
  56    * Called to process the message.
  57    * @param [in] bufferIndex The current update/render buffer index (depending on which thread processes the message).
  58    */
  59   virtual void Process( BufferIndex bufferIndex ) = 0;
  60
  61 private:
  62 };
  63
  64 /**
  65  * Templated message which calls a member function of an object.
  66  * This allows nodes etc. to be modified in a thread-safe manner, when the update occurs in a separate thread.
  67  * The object lifetime must controlled i.e. not destroyed before the message is processed.
  68  */
  69 template< typename T >
  70 class Message : public MessageBase
  71 {
  72 public:
  73   using MemberFunction = void ( T::* )();
  74
  75   /**
  76    * Create a message.
  77    * @note The object is expected to be const in the thread which sends this message.
  78    * However it can be modified when Process() is called in a different thread.
  79    * @param[in] obj The object to be updated in a separate thread.
  80    * @param[in] member The member function of the object.
  81    */
  82   Message( const T* obj, MemberFunction member )
  83   : MessageBase(),
  84     object( const_cast< T* >( obj ) ),
  85     memberFunction( member )
  86   {
  87     DALI_ASSERT_DEBUG( object && "nullptr passed into message as object" );
  88   }
  89
  90   /**
  91    * Virtual destructor
  92    */
  93   ~Message() override
  94   {
  95   }
  96
  97   /**
  98    * @copydoc MessageBase::Process
  99    */
 100   void Process( BufferIndex /*bufferIndex*/ ) override
 101   {
 102     (object->*memberFunction)();
 103   }
 104
 105 private:
 106
 107   T* object;
 108   MemberFunction memberFunction;
 109
 110 };
 111
 112 /**
 113  * Templated message which calls a member function of an object.
 114  * This overload passes one value-type parameter.
 115  * Template parameters need to match the MemberFunction!
 116  * The message will contain copy of the value (in case of & or const&)
 117  */
 118 template< typename T, typename P >
 119 class MessageValue1 : public MessageBase
 120 {
 121 public:
 122   using MemberFunction = void ( T::* )( typename ParameterType<P>::PassingType );
 123
 124   /**
 125    * Create a message.
 126    * @note The object is expected to be const in the thread which sends this message.
 127    * However it can be modified when Process() is called in a different thread.
 128    * @param[in] obj The object.
 129    * @param[in] member The member function of the object.
 130    * @param[in] p1 The first value-type parameter to pass to the member function.
 131    */
 132   MessageValue1( const T* obj,
 133                  MemberFunction member,
 134                  typename ParameterType< P >::PassingType p1 )
 135   : MessageBase(),
 136     object( const_cast< T* >( obj ) ),
 137     memberFunction( member ),
 138     param1( p1 )
 139   {
 140     DALI_ASSERT_DEBUG( object && "nullptr passed into message as object" );
 141   }
 142
 143   /**
 144    * Virtual destructor
 145    */
 146   ~MessageValue1() override
 147   {
 148   }
 149
 150   /**
 151    * @copydoc MessageBase::Process
 152    */
 153   void Process( BufferIndex /*bufferIndex*/ ) override
 154   {
 155     (object->*memberFunction)( param1 );
 156   }
 157
 158 private:
 159
 160   T* object;
 161   MemberFunction memberFunction;
 162   typename ParameterType< P >::HolderType param1;
 163
 164 };
 165
 166 /**
 167  * Templated message which calls a member function of an object.
 168  * This overload passes two value-type parameters.
 169  * Template parameters need to match the MemberFunction!
 170  * The message will contain copy of the value (in case of & or const&)
 171  */
 172
 173 template< typename T, typename P1, typename P2 >
 174 class MessageValue2 : public MessageBase
 175 {
 176 public:
 177   using MemberFunction = void ( T::* )( typename ParameterType<P1>::PassingType, typename ParameterType<P2>::PassingType );
 178
 179   /**
 180    * Create a message.
 181    * @note The object is expected to be const in the thread which sends this message.
 182    * However it can be modified when Process() is called in a different thread.
 183    * @param[in] obj The object.
 184    * @param[in] member The member function of the object.
 185    * @param[in] p1 The first parameter to pass to the member function.
 186    * @param[in] p2 The second parameter to pass to the member function.
 187    */
 188   MessageValue2( const T* obj,
 189                  MemberFunction member,
 190                  typename ParameterType< P1 >::PassingType p1,
 191                  typename ParameterType< P2 >::PassingType p2 )
 192   : MessageBase(),
 193     object( const_cast< T* >( obj ) ),
 194     memberFunction( member ),
 195     param1( p1 ),
 196     param2( p2 )
 197   {
 198     DALI_ASSERT_DEBUG( object && "nullptr passed into message as object" );
 199   }
 200
 201   /**
 202    * Virtual destructor
 203    */
 204   ~MessageValue2() override
 205   {
 206   }
 207
 208   /**
 209    * @copydoc MessageBase::Process
 210    */
 211   void Process( BufferIndex /*bufferIndex*/ ) override
 212   {
 213     (object->*memberFunction)( param1, param2 );
 214   }
 215
 216 private:
 217
 218   T* object;
 219   MemberFunction memberFunction;
 220   typename ParameterType< P1 >::HolderType param1;
 221   typename ParameterType< P2 >::HolderType param2;
 222
 223 };
 224
 225 /**
 226  * Templated message which calls a member function of an object.
 227  * This overload passes three value-type parameters.
 228  * Template parameters need to match the MemberFunction!
 229  * The message will contain copy of the value (in case of & or const&)
 230  */
 231 template< typename T, typename P1, typename P2, typename P3 >
 232 class MessageValue3 : public MessageBase
 233 {
 234 public:
 235   using MemberFunction = void ( T::* )( typename ParameterType<P1>::PassingType, typename ParameterType<P2>::PassingType, typename ParameterType<P3>::PassingType );
 236
 237   /**
 238    * Create a message.
 239    * @note The object is expected to be const in the thread which sends this message.
 240    * However it can be modified when Process() is called in a different thread.
 241    * @param[in] obj The object.
 242    * @param[in] member The member function of the object.
 243    * @param[in] p1 The first parameter to pass to the member function.
 244    * @param[in] p2 The second parameter to pass to the member function.
 245    * @param[in] p3 The third parameter to pass to the member function.
 246    */
 247   MessageValue3( const T* obj,
 248                  MemberFunction member,
 249                  typename ParameterType< P1 >::PassingType p1,
 250                  typename ParameterType< P2 >::PassingType p2,
 251                  typename ParameterType< P3 >::PassingType p3 )
 252   : MessageBase(),
 253     object( const_cast< T* >( obj ) ),
 254     memberFunction( member ),
 255     param1( p1 ),
 256     param2( p2 ),
 257     param3( p3 )
 258   {
 259     DALI_ASSERT_DEBUG( object && "nullptr passed into message as object" );
 260   }
 261
 262   /**
 263    * Virtual destructor
 264    */
 265   ~MessageValue3() override
 266   {
 267   }
 268
 269   /**
 270    * @copydoc MessageBase::Process
 271    */
 272   void Process( BufferIndex /*bufferIndex*/ ) override
 273   {
 274     (object->*memberFunction)( param1, param2, param3 );
 275   }
 276
 277 private:
 278
 279   T* object;
 280   MemberFunction memberFunction;
 281   typename ParameterType< P1 >::HolderType param1;
 282   typename ParameterType< P2 >::HolderType param2;
 283   typename ParameterType< P3 >::HolderType param3;
 284
 285 };
 286
 287 /**
 288  * Templated message which calls a member function of an object.
 289  * This overload passes four value-type parameters.
 290  * Template parameters need to match the MemberFunction!
 291  * The message will contain copy of the value (in case of & or const&)
 292  */
 293 template< typename T, typename P1, typename P2, typename P3, typename P4 >
 294 class MessageValue4 : public MessageBase
 295 {
 296 public:
 297   using MemberFunction = void ( T::* )( typename ParameterType<P1>::PassingType, typename ParameterType<P2>::PassingType, typename ParameterType<P3>::PassingType, typename ParameterType<P4>::PassingType );
 298
 299   /**
 300    * Create a message.
 301    * @note The object is expected to be const in the thread which sends this message.
 302    * However it can be modified when Process() is called in a different thread.
 303    * @param[in] obj The object.
 304    * @param[in] member The member function of the object.
 305    * @param[in] p1 The first parameter to pass to the member function.
 306    * @param[in] p2 The second parameter to pass to the member function.
 307    * @param[in] p3 The third parameter to pass to the member function.
 308    * @param[in] p4 The fourth parameter to pass to the member function.
 309    */
 310   MessageValue4( const T* obj,
 311                  MemberFunction member,
 312                  typename ParameterType< P1 >::PassingType p1,
 313                  typename ParameterType< P2 >::PassingType p2,
 314                  typename ParameterType< P3 >::PassingType p3,
 315                  typename ParameterType< P4 >::PassingType p4 )
 316   : MessageBase(),
 317     object( const_cast< T* >( obj ) ),
 318     memberFunction( member ),
 319     param1( p1 ),
 320     param2( p2 ),
 321     param3( p3 ),
 322     param4( p4 )
 323   {
 324     DALI_ASSERT_DEBUG( object && "nullptr passed into message as object" );
 325   }
 326
 327   /**
 328    * Virtual destructor
 329    */
 330   ~MessageValue4() override
 331   {
 332   }
 333
 334   /**
 335    * @copydoc MessageBase::Process
 336    */
 337   void Process( BufferIndex /*bufferIndex*/ ) override
 338   {
 339     (object->*memberFunction)( param1, param2, param3, param4 );
 340   }
 341
 342 private:
 343
 344   T* object;
 345   MemberFunction memberFunction;
 346   typename ParameterType< P1 >::HolderType param1;
 347   typename ParameterType< P2 >::HolderType param2;
 348   typename ParameterType< P3 >::HolderType param3;
 349   typename ParameterType< P4 >::HolderType param4;
 350
 351 };
 352
 353 /**
 354  * Templated message which calls a member function of an object.
 355  * This overload passes five value-type parameters.
 356  * Template parameters need to match the MemberFunction!
 357  * The message will contain copy of the value (in case of & or const&)
 358  */
 359 template< typename T, typename P1, typename P2, typename P3, typename P4, typename P5 >
 360 class MessageValue5 : public MessageBase
 361 {
 362 public:
 363   using MemberFunction = void ( T::* )( typename ParameterType<P1>::PassingType, typename ParameterType<P2>::PassingType, typename ParameterType<P3>::PassingType, typename ParameterType<P4>::PassingType, typename ParameterType<P5>::PassingType );
 364
 365   /**
 366    * Create a message.
 367    * @note The object is expected to be const in the thread which sends this message.
 368    * However it can be modified when Process() is called in a different thread.
 369    * @param[in] obj The object.
 370    * @param[in] member The member function of the object.
 371    * @param[in] p1 The first parameter to pass to the member function.
 372    * @param[in] p2 The second parameter to pass to the member function.
 373    * @param[in] p3 The third parameter to pass to the member function.
 374    * @param[in] p4 The fourth parameter to pass to the member function.
 375    * @param[in] p5 The fifth parameter to pass to the member function.
 376    */
 377   MessageValue5( const T* obj,
 378                  MemberFunction member,
 379                  typename ParameterType< P1 >::PassingType p1,
 380                  typename ParameterType< P2 >::PassingType p2,
 381                  typename ParameterType< P3 >::PassingType p3,
 382                  typename ParameterType< P4 >::PassingType p4,
 383                  typename ParameterType< P5 >::PassingType p5 )
 384   : MessageBase(),
 385     object( const_cast< T* >( obj ) ),
 386     memberFunction( member ),
 387     param1( p1 ),
 388     param2( p2 ),
 389     param3( p3 ),
 390     param4( p4 ),
 391     param5( p5 )
 392   {
 393     DALI_ASSERT_DEBUG( object && "nullptr passed into message as object" );
 394   }
 395
 396   /**
 397    * Virtual destructor
 398    */
 399   ~MessageValue5() override
 400   {
 401   }
 402
 403   /**
 404    * @copydoc MessageBase::Process
 405    */
 406   void Process( BufferIndex /*bufferIndex*/ ) override
 407   {
 408     (object->*memberFunction)( param1, param2, param3, param4, param5 );
 409   }
 410
 411 private:
 412
 413   T* object;
 414   MemberFunction memberFunction;
 415   typename ParameterType< P1 >::HolderType param1;
 416   typename ParameterType< P2 >::HolderType param2;
 417   typename ParameterType< P3 >::HolderType param3;
 418   typename ParameterType< P4 >::HolderType param4;
 419   typename ParameterType< P5 >::HolderType param5;
 420
 421 };
 422
 423 /**
 424  * Templated message which calls a member function of an object.
 425  * This overload passes six value-type parameters.
 426  * Template parameters need to match the MemberFunction!
 427  * The message will contain copy of the value (in case of & or const&)
 428  */
 429 template< typename T, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6 >
 430 class MessageValue6 : public MessageBase
 431 {
 432 public:
 433   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 );
 434
 435   /**
 436    * Create a message.
 437    * @note The object is expected to be const in the thread which sends this message.
 438    * However it can be modified when Process() is called in a different thread.
 439    * @param[in] obj The object.
 440    * @param[in] member The member function of the object.
 441    * @param[in] p1 The first parameter to pass to the member function.
 442    * @param[in] p2 The second parameter to pass to the member function.
 443    * @param[in] p3 The third parameter to pass to the member function.
 444    * @param[in] p4 The fourth parameter to pass to the member function.
 445    * @param[in] p5 The fifth parameter to pass to the member function.
 446    * @param[in] p6 The sixth parameter to pass to the member function.
 447    */
 448   MessageValue6( const T* obj,
 449                  MemberFunction member,
 450                  typename ParameterType< P1 >::PassingType p1,
 451                  typename ParameterType< P2 >::PassingType p2,
 452                  typename ParameterType< P3 >::PassingType p3,
 453                  typename ParameterType< P4 >::PassingType p4,
 454                  typename ParameterType< P5 >::PassingType p5,
 455                  typename ParameterType< P6 >::PassingType p6 )
 456   : MessageBase(),
 457     object( const_cast< T* >( obj ) ),
 458     memberFunction( member ),
 459     param1( p1 ),
 460     param2( p2 ),
 461     param3( p3 ),
 462     param4( p4 ),
 463     param5( p5 ),
 464     param6( p6 )
 465   {
 466     DALI_ASSERT_DEBUG( object && "nullptr passed into message as object" );
 467   }
 468
 469   /**
 470    * Virtual destructor
 471    */
 472   ~MessageValue6() override
 473   {
 474   }
 475
 476   /**
 477    * @copydoc MessageBase::Process
 478    */
 479   void Process( BufferIndex /*bufferIndex*/ ) override
 480   {
 481     (object->*memberFunction)( param1, param2, param3, param4, param5, param6 );
 482   }
 483
 484 private:
 485
 486   T* object;
 487   MemberFunction memberFunction;
 488   typename ParameterType< P1 >::HolderType param1;
 489   typename ParameterType< P2 >::HolderType param2;
 490   typename ParameterType< P3 >::HolderType param3;
 491   typename ParameterType< P4 >::HolderType param4;
 492   typename ParameterType< P5 >::HolderType param5;
 493   typename ParameterType< P6 >::HolderType param6;
 494
 495 };
 496
 497 /**
 498  * Templated message which calls a member function of an object.
 499  * This overload passes just the buffer index to the method, no parameters.
 500  */
 501 template< typename T >
 502 class MessageDoubleBuffered0 : public MessageBase
 503 {
 504 public:
 505   using MemberFunction = void ( T::* )( BufferIndex );
 506
 507   /**
 508    * Create a message.
 509    * @note The object is expected to be const in the thread which sends this message.
 510    * However it can be modified when Process() is called in a different thread.
 511    * @param[in] obj The object.
 512    * @param[in] member The member function of the object.
 513    */
 514   MessageDoubleBuffered0( const T* obj, MemberFunction member )
 515   : MessageBase(),
 516     object( const_cast< T* >( obj ) ),
 517     memberFunction( member )
 518   {
 519     DALI_ASSERT_DEBUG( object && "nullptr passed into message as object" );
 520   }
 521
 522   /**
 523    * Virtual destructor
 524    */
 525   ~MessageDoubleBuffered0() override
 526   {
 527   }
 528
 529   /**
 530    * @copydoc MessageBase::Process
 531    */
 532   void Process( BufferIndex bufferIndex ) override
 533   {
 534     (object->*memberFunction)( bufferIndex );
 535   }
 536
 537 private:
 538
 539   T* object;
 540   MemberFunction memberFunction;
 541
 542 };
 543
 544
 545 /**
 546  * Templated message which calls a member function of an object.
 547  * This overload passes a value-type to set a double-buffered property.
 548  * Template parameters need to match the MemberFunction!
 549  * The message will contain copy of the value (in case of & or const&)
 550  */
 551 template< typename T, typename P >
 552 class MessageDoubleBuffered1 : public MessageBase
 553 {
 554 public:
 555   using MemberFunction = void ( T::* )( BufferIndex, typename ParameterType<P>::PassingType );
 556
 557   /**
 558    * Create a message.
 559    * @note The object is expected to be const in the thread which sends this message.
 560    * However it can be modified when Process() is called in a different thread.
 561    * @param[in] obj The object.
 562    * @param[in] member The member function of the object.
 563    * @param[in] p The second parameter to pass.
 564    */
 565   MessageDoubleBuffered1( const T* obj,
 566                           MemberFunction member,
 567                           typename ParameterType< P >::PassingType p )
 568   : MessageBase(),
 569     object( const_cast< T* >( obj ) ),
 570     memberFunction( member ),
 571     param( p )
 572   {
 573     DALI_ASSERT_DEBUG( object && "nullptr passed into message as object" );
 574   }
 575
 576   /**
 577    * Virtual destructor
 578    */
 579   ~MessageDoubleBuffered1() override
 580   {
 581   }
 582
 583   /**
 584    * @copydoc MessageBase::Process
 585    */
 586   void Process( BufferIndex bufferIndex ) override
 587   {
 588     (object->*memberFunction)( bufferIndex,  param );
 589   }
 590
 591 private:
 592
 593   T* object;
 594   MemberFunction memberFunction;
 595   typename ParameterType< P >::HolderType param;
 596
 597 };
 598
 599 /**
 600  * Templated message which calls a member function of an object.
 601  * This overload passes two value-types to set double-buffered properties.
 602  * Template parameters need to match the MemberFunction!
 603  * The message will contain copy of the value (in case of & or const&)
 604  */
 605 template< typename T, typename P2, typename P3 >
 606 class MessageDoubleBuffered2 : public MessageBase
 607 {
 608 public:
 609   using MemberFunction = void ( T::* )( BufferIndex, typename ParameterType<P2>::PassingType, typename ParameterType<P3>::PassingType );
 610
 611   /**
 612    * Create a message.
 613    * @note The object is expected to be const in the thread which sends this message.
 614    * However it can be modified when Process() is called in a different thread.
 615    * @param[in] obj The object.
 616    * @param[in] member The member function of the object.
 617    * @param[in] p2 The second parameter to pass to the function.
 618    * @param[in] p3 The third parameter to pass to the function.
 619    */
 620   MessageDoubleBuffered2( const T* obj,
 621                           MemberFunction member,
 622                           typename ParameterType< P2 >::PassingType p2,
 623                           typename ParameterType< P3 >::PassingType p3 )
 624   : MessageBase(),
 625     object( const_cast< T* >( obj ) ),
 626     memberFunction( member ),
 627     param2( p2 ),
 628     param3( p3 )
 629   {
 630     DALI_ASSERT_DEBUG( object && "nullptr passed into message as object" );
 631   }
 632
 633   /**
 634    * Virtual destructor
 635    */
 636   ~MessageDoubleBuffered2() override
 637   {
 638   }
 639
 640   /**
 641    * @copydoc MessageBase::Process
 642    */
 643   void Process( BufferIndex bufferIndex ) override
 644   {
 645     (object->*memberFunction)( bufferIndex, param2, param3 );
 646   }
 647
 648 private:
 649
 650   T* object;
 651   MemberFunction memberFunction;
 652   typename ParameterType< P2 >::HolderType param2;
 653   typename ParameterType< P3 >::HolderType param3;
 654
 655 };
 656
 657
 658 /**
 659  * Templated message which calls a member function of an object.
 660  * This overload passes three value-types to set double-buffered properties.
 661  * Template parameters need to match the MemberFunction!
 662  * The message will contain copy of the value (in case of & or const&)
 663  */
 664 template< typename T, typename P2, typename P3, typename P4 >
 665 class MessageDoubleBuffered3 : public MessageBase
 666 {
 667 public:
 668   using MemberFunction = void ( T::* )( BufferIndex, typename ParameterType<P2>::PassingType, typename ParameterType<P3>::PassingType, typename ParameterType<P4>::PassingType );
 669
 670   /**
 671    * Create a message.
 672    * @note The object is expected to be const in the thread which sends this message.
 673    * However it can be modified when Process() is called in a different thread.
 674    * @param[in] obj The object.
 675    * @param[in] member The member function of the object.
 676    * @param[in] p2 The second parameter to pass.
 677    * @param[in] p3 The third parameter to pass.
 678    * @param[in] p4 The forth parameter to pass.
 679    */
 680   MessageDoubleBuffered3( const T* obj,
 681                           MemberFunction member,
 682                           typename ParameterType< P2 >::PassingType p2,
 683                           typename ParameterType< P3 >::PassingType p3,
 684                           typename ParameterType< P4 >::PassingType p4 )
 685   : MessageBase(),
 686     object( const_cast< T* >( obj ) ),
 687     memberFunction( member ),
 688     param2( p2 ),
 689     param3( p3 ),
 690     param4( p4 )
 691   {
 692     DALI_ASSERT_DEBUG( object && "nullptr passed into message as object" );
 693   }
 694
 695   /**
 696    * Virtual destructor
 697    */
 698   ~MessageDoubleBuffered3() override
 699   {
 700   }
 701
 702   /**
 703    * @copydoc MessageBase::Process
 704    */
 705   void Process( BufferIndex bufferIndex ) override
 706   {
 707     (object->*memberFunction)( bufferIndex, param2, param3, param4 );
 708   }
 709
 710 private:
 711
 712   T* object;
 713   MemberFunction memberFunction;
 714   typename ParameterType< P2 >::HolderType param2;
 715   typename ParameterType< P3 >::HolderType param3;
 716   typename ParameterType< P4 >::HolderType param4;
 717
 718 };
 719
 720 /**
 721  * Templated message which calls a member function of an object.
 722  * This overload passes four value-types to set double-buffered properties.
 723  * Template parameters need to match the MemberFunction!
 724  * The message will contain copy of the value (in case of & or const&)
 725  */
 726 template< typename T, typename P2, typename P3, typename P4, typename P5 >
 727 class MessageDoubleBuffered4 : public MessageBase
 728 {
 729 public:
 730   using MemberFunction = void ( T::* )( BufferIndex, typename ParameterType<P2>::PassingType, typename ParameterType<P3>::PassingType, typename ParameterType<P4>::PassingType, typename ParameterType<P5>::PassingType );
 731
 732   /**
 733    * Create a message.
 734    * @note The object is expected to be const in the thread which sends this message.
 735    * However it can be modified when Process() is called in a different thread.
 736    * @param[in] obj The object.
 737    * @param[in] member The member function of the object.
 738    * @param[in] p2 The second parameter to pass.
 739    * @param[in] p3 The third parameter to pass.
 740    * @param[in] p4 The forth parameter to pass.
 741    * @param[in] p5 The fifth parameter to pass.
 742    */
 743   MessageDoubleBuffered4( const T* obj,
 744                           MemberFunction member,
 745                           typename ParameterType< P2 >::PassingType p2,
 746                           typename ParameterType< P3 >::PassingType p3,
 747                           typename ParameterType< P4 >::PassingType p4,
 748                           typename ParameterType< P5 >::PassingType p5 )
 749   : MessageBase(),
 750     object( const_cast< T* >( obj ) ),
 751     memberFunction( member ),
 752     param2( p2 ),
 753     param3( p3 ),
 754     param4( p4 ),
 755     param5( p5 )
 756   {
 757     DALI_ASSERT_DEBUG( object && "nullptr passed into message as object" );
 758   }
 759
 760   /**
 761    * Virtual destructor
 762    */
 763   ~MessageDoubleBuffered4() override
 764   {
 765   }
 766
 767   /**
 768    * @copydoc MessageBase::Process
 769    */
 770   void Process( BufferIndex bufferIndex ) override
 771   {
 772     (object->*memberFunction)( bufferIndex, param2, param3, param4, param5 );
 773   }
 774
 775 private:
 776
 777   T* object;
 778   MemberFunction memberFunction;
 779   typename ParameterType< P2 >::HolderType param2;
 780   typename ParameterType< P3 >::HolderType param3;
 781   typename ParameterType< P4 >::HolderType param4;
 782   typename ParameterType< P5 >::HolderType param5;
 783
 784 };
 785
 786 } // namespace Internal
 787
 788 } // namespace Dali
 789
 790 #endif // DALI_INTERNAL_MESSAGE_H