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
{
 
// class event is implemented completely implicit inline to avoid
// code bloat in commonly used Core classes and therefore reduce compile time
 
template<class ...Args>
class event
{
private: // usings
    using delegate_type = delegate<void(Args...)>;      
    using event_handlers = std::vector<delegate_type>;  
    using Exception = Arp::Base::Core::Exception;       
 
public:
    event(void);
 
public: // add/remove operators
    event& operator+=(delegate_type&& rhs);
    event& operator+=(const delegate_type& rhs);
    event& operator-=(const delegate_type& rhs);
 
public: // invocation operator, functor
    void operator()(Args... args)const;
    bool is_empty(void)const;
 
private:
    event_handlers eventHandlers;
};
 
// specialized class event<void> implementation
 
template<>
class event<void>
{
public: // usings
    using delegate_type = delegate<void()>; 
 
private: // usings
    using event_handlers = std::vector<delegate_type>;
 
public:
    event(void);
 
public: // add/remove operators
    event& operator+=(delegate_type&& rhs);
    event& operator+=(const delegate_type& rhs);
    event& operator-=(const delegate_type& rhs);
 
public: // invocation operator, functor
    void operator()(void)const;
 
public: // property operations
    bool is_empty(void)const;
 
private: // fields
    event_handlers eventHandlers;
};
 
}}} // end of namespace Arp::Base::Core
 
namespace Arp {
using Arp::Base::Core::event;
}
#include "Arp/Base/Core/Detail/event.ipp"