event.hxx

 
//
//  Copyright Phoenix Contact GmbH & Co. KG
//
#pragma once
 
#ifndef ARP_USE_ARP_SYSTEM_CORE
 
#include "Arp/Base/Core/event.hxx"
 
#else
 
#include "Arp/System/Core/Arp.h"
#include "Arp/System/Core/delegate.hxx"
#include "Arp/System/Core/slim_delegate.hxx"
#include "Arp/System/Core/Exception.hpp"
#include <forward_list>
 
namespace Arp
{
 
// class event is implemented completely implicite inline to avoid
// code bloat in commonly used Core classe and therefore reduce compile time
 
template<class ...TEventArgs>
class event
{
public: // typedefs/usings
    using delegate_type = delegate<void(TEventArgs...)>;
    using slim_delegate_type = slim_delegate<void(TEventArgs...)>;
 
public:
    event(void) = default;
    event(const event& arg) = default;
    event(event&& arg)noexcept = default;
    ~event(void) = default;
    event& operator=(const event& arg) = default;
    event& operator=(event&& arg)noexcept = default;
 
public: // add/remove operators
    event& operator+=(slim_delegate_type&& rhs)
    {
        if (!rhs)
        {
            throw Exception("As argument passed delegate is not valid.");
        }
        // else
        this->slimEventHandlers.push_front(std::move(rhs));
        return *this;
    }
 
 
    event& operator+=(const slim_delegate_type& rhs)
    {
        if (!rhs)
        {
            throw Exception("As argument passed delegate is not valid.");
        }
        // else
        this->slimEventHandlers.push_front(rhs);
        return *this;
    }
 
    event& operator-=(const slim_delegate_type& rhs)
    {
        this->slimEventHandlers.remove(rhs);
        return *this;
    }
 
    event& operator+=(delegate_type&& rhs)
    {
        if (!rhs)
        {
            throw Exception("As argument passed delegate is not valid.");
        }
        if(rhs.is_lambda())
        {
            throw Exception("Lambda delegates are not supported by events.");
        }
        // else
        this->eventHandlers.push_front(std::move(rhs));
        return *this;
    }
 
    event& operator+=(const delegate_type& rhs)
    {
        if (!rhs)
        {
            throw Exception("As argument passed delegate is not valid.");
        }
        if (rhs.is_lambda())
        {
            throw Exception("Lambda delegates are not supported by events.");
        }
        // else
        this->eventHandlers.push_front(rhs);
        return *this;
    }
 
    event& operator-=(const delegate_type& rhs)
    {
        this->eventHandlers.remove(rhs);
        return *this;
    }
 
public: // invokation operator, functor
    void operator()(TEventArgs... args) const
    {
        for (const slim_delegate_type& slimEventHandler : this->slimEventHandlers)
        {
            // invoke eventHandler/delegate
            slimEventHandler(args...);
        }
        for(const delegate_type& eventHandler : this->eventHandlers)
        {
            // invoke eventHandler/delegate
            eventHandler(args...);
        }
    }
 
public: // property operations
    bool is_empty(void)const
    {
        return this->slimEventHandlers.empty() && this->eventHandlers.empty();
    }
 
private:
    std::forward_list<slim_delegate_type>   slimEventHandlers;
    std::forward_list<delegate_type>        eventHandlers;
};
 
// spcialized class event<void> is implemented completely implicite inline because
// template class specializations cannot be implemented using explicite
// inlining (out of class definition)
 
template<>
class event<void>
{
public: // typedefs/usings
    using delegate_type = delegate<void()>;
    using slim_delegate_type = slim_delegate<void()>;
 
public:
    event(void) = default;
    event(const event& arg) = default;
    event(event&& arg) = default;
    ~event(void) = default;
    event& operator=(const event& arg) = default;
    event& operator=(event&& arg) = default;
 
public: // add/remove operators
    event& operator+=(slim_delegate_type&& rhs)
    {
        if (!rhs)
        {
            throw Exception("As argument passed delegate is not valid.");
        }
        // else
        this->slimEventHandlers.push_front(std::move(rhs));
        return *this;
    }
 
    event& operator+=(const slim_delegate_type& rhs)
    {
        if (!rhs)
        {
            throw Exception("As argument passed delegate is not valid.");
        }
        // else
        this->slimEventHandlers.push_front(rhs);
        return *this;
    }
 
    event& operator-=(const slim_delegate_type& rhs)
    {
        this->slimEventHandlers.remove(rhs);
        return *this;
    }
 
    event& operator+=(delegate_type&& rhs)
    {
        if (!rhs)
        {
            throw Exception("As argument passed delegate is not valid.");
        }
        if (rhs.is_lambda())
        {
            throw Exception("Lambda delegates are not supported by events.");
        }
        // else
        this->eventHandlers.push_front(std::move(rhs));
        return *this;
    }
 
    event& operator+=(const delegate_type& rhs)
    {
        if (!rhs)
        {
            throw Exception("As argument passed delegate is not valid.");
        }
        if (rhs.is_lambda())
        {
            throw Exception("Lambda delegates are not supported by events.");
        }
        // else
        this->eventHandlers.push_front(rhs);
        return *this;
    }
 
    event& operator-=(const delegate_type& rhs)
    {
        this->eventHandlers.remove(rhs);
        return *this;
    }
 
public: // invokation operator, functor
    void operator()(void) const
    {
        for (const slim_delegate_type& slimEventHandler : this->slimEventHandlers)
        {
            // invoke eventHandler/delegate
            slimEventHandler();
        }
        for (const delegate_type& eventHandler : this->eventHandlers)
        {
            // invoke eventHandler/delegate
            eventHandler();
        }
    }
 
public: // property operations
    bool is_empty(void)const
    {
        return this->slimEventHandlers.empty() && this->eventHandlers.empty();
    }
 
private:
    std::forward_list<slim_delegate_type>   slimEventHandlers;
    std::forward_list<delegate_type>        eventHandlers;
};
 
} // end of namespace Arp
 
#endif // ndef ARP_USE_ARP_SYSTEM_CORE