Line data    Source code

       1              : // Copyright 2024 Accenture.
       2              : 
       3              : /**
       4              :  * \ingroup async
       5              :  */
       6              : #pragma once
       7              : 
       8              : #include "async/Types.h"
       9              : 
      10              : namespace async
      11              : {
      12              : /**
      13              :  * A template class that encapsulates specific event behavior, allowing setEvent to be used without
      14              :  * explicitly specifying the eventMask.
      15              :  *
      16              :  * \tparam EventDispatcher EventDispatcher class, from which the Event is encapsulated.
      17              :  * \tparam Event Event number to encapsulate.
      18              :  */
      19              : template<typename EventDispatcher, size_t Event>
      20              : class EventPolicy
      21              : {
      22              : public:
      23              :     using EventDispatcherType = EventDispatcher;
      24              :     using HandlerFunctionType = typename EventDispatcher::HandlerFunctionType;
      25              : 
      26              :     static EventMaskType const EVENT_MASK = static_cast<EventMaskType>(1U << Event);
      27              : 
      28              :     explicit EventPolicy(EventDispatcher& eventDispatcher);
      29              : 
      30              :     void setEventHandler(HandlerFunctionType handlerFunction);
      31              :     void removeEventHandler();
      32              : 
      33              :     void setEvent();
      34              : 
      35              : private:
      36              :     EventDispatcher& _eventDispatcher;
      37              : };
      38              : 
      39              : /**
      40              :  * Inline implementations.
      41              :  */
      42              : template<typename EventDispatcher, size_t Event>
      43          364 : inline EventPolicy<EventDispatcher, Event>::EventPolicy(EventDispatcher& eventDispatcher)
      44          364 : : _eventDispatcher(eventDispatcher)
      45          364 : {}
      46              : 
      47              : template<typename EventDispatcher, size_t Event>
      48              : inline void
      49          364 : EventPolicy<EventDispatcher, Event>::setEventHandler(HandlerFunctionType const handlerFunction)
      50              : {
      51          364 :     _eventDispatcher.setEventHandler(Event, handlerFunction);
      52          364 : }
      53              : 
      54              : template<typename EventDispatcher, size_t Event>
      55            2 : inline void EventPolicy<EventDispatcher, Event>::removeEventHandler()
      56              : {
      57            2 :     _eventDispatcher.removeEventHandler(Event);
      58            2 : }
      59              : 
      60              : template<typename EventDispatcher, size_t Event>
      61           19 : inline void EventPolicy<EventDispatcher, Event>::setEvent()
      62              : {
      63           19 :     _eventDispatcher.setEvents(EVENT_MASK);
      64           19 : }
      65              : 
      66              : } // namespace async