synced_event.hxx

 
//
//  Copyright Phoenix Contact GmbH & Co. KG
//
#pragma once
#include "Arp/Base/Core/Arp.hpp"
#include "Arp/Base/Core/delegate.hxx"
#include "Arp/Base/Core/Exception.hpp"
#include <vector>
#include <algorithm>
namespace Arp { namespace Base { namespace Core
{
 
template<class M, class ...Args>
class synced_event
{
private: // usings
    using delegate_type = delegate<void(Args...)>;      
    using event_handlers = std::vector<delegate_type>;  
    using Exception = Arp::Base::Core::Exception;       
    using SyncRoot = M;                                 
    using SyncGuard = typename M::LockGuard;            
 
public:
    synced_event(void);
 
public: // add/remove operators
    synced_event& operator+=(delegate_type&& rhs);
    synced_event& operator+=(const delegate_type& rhs);
    synced_event& operator-=(const delegate_type& rhs);
 
public: // invocation operator, functor
    void operator()(Args... args)const;
 
public: // property operations
    bool    is_empty(void)const;
    size_t  count(void)const;
 
private:
    event_handlers      eventHandlers;
    mutable SyncRoot    syncRoot;
};
 
template<class M>
class synced_event<M>;
 
// specialized class synced_event<M> implementation
 
template<class M>
class synced_event<M, void>
{
public: // usings
    using delegate_type = delegate<void()>;     
    using SyncRoot = M;                         
    using SyncGuard = typename M::LockGuard;    
 
private: // usings
    using event_handlers = std::vector<delegate_type>;
 
public:
    synced_event(void);
 
public: // add/remove operators
    synced_event& operator+=(delegate_type&& rhs);
    synced_event& operator+=(const delegate_type& rhs);
    synced_event& operator-=(const delegate_type& rhs);
 
public: // invocation operator, functor
    void operator()(void)const;
 
public: // property operations
    bool    is_empty(void)const;
    size_t  count(void)const;
 
private: // fields
    event_handlers      eventHandlers;
    mutable SyncRoot    syncRoot;
};
 
}}} // end of namespace Arp::Base::Core
 
namespace Arp {
using Arp::Base::Core::synced_event;
}
#include "Arp/Base/Core/Detail/synced_event.ipp"