dali/internal/common/message.h

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