IEvent.h

#pragma once

#include "ICallback.h"
#include "Types.h"

#include <vector>
#include <algorithm>

namespace Eegeo
{
    namespace Helpers
    {
        template <typename TCallbackType>
        class IEventBase
        {
        public:
            typedef TCallbackType CallbackType;
            
            virtual void Register(CallbackType& callback) = 0;
            
            virtual void Unregister(CallbackType& callback) = 0;
        };
        
        class IEvent0 : public IEventBase< Helpers::ICallback0 >
        {
        public:
            typedef IEventBase< Helpers::ICallback0 > BaseType;
            
            virtual ~IEvent0() {}
            
            virtual void Raise() const = 0;
        };
        
        template <typename TParam0>
        class IEvent1 : public IEventBase< Helpers::ICallback1<TParam0> >
        {
        public:
            typedef TParam0 Param0;
            typedef IEventBase< Helpers::ICallback1<Param0> > BaseType;
            
            virtual ~IEvent1() {}
            
            virtual void Raise(Param0& param0) const = 0;
        };
        
        
        
        template <typename TEventInterface>
        class TEventBase : public TEventInterface, private Eegeo::NonCopyable
        {
        public:
            typedef typename TEventInterface::CallbackType CallbackType;
            typedef std::vector<CallbackType*> CallbackVector;
            
            void Register(CallbackType& callback)
            {
                m_callbacks.push_back(&callback);
            }
            
            void Unregister(CallbackType& callback)
            {
                m_callbacks.erase(std::remove(m_callbacks.begin(), m_callbacks.end(), &callback), m_callbacks.end());
            }
            
        protected:
            TEventBase() {}
            
            CallbackVector m_callbacks;
        };
        
        template <typename TInterface>
        class TEvent0 : public TEventBase< TInterface >
        {
        public:
            typedef TInterface InterfaceType;
            typedef TEvent0<TInterface> ThisType;
            
            void Raise() const
            {
                for (auto callback : this->m_callbacks)
                {
                    (*callback)();
                }
            }
        };
        
        template <typename TInterface>
        class TEvent1 : public TEventBase<TInterface>
        {
        public:
            typedef TInterface InterfaceType;
            typedef TEvent1<TInterface> ThisType;
            
            void Raise(typename TInterface::Param0& param0) const
            {
                for (auto callback : this->m_callbacks)
                {
                    (*callback)(param0);
                }
            }
        };
        
        
        
        template <typename TInterface>
        class TSingleObserverEventBase : public TInterface, private Eegeo::NonCopyable
        {
        public:
            typedef typename TInterface::CallbackType CallbackType;
            typedef TInterface InterfaceType;
            
            TSingleObserverEventBase()
            : m_callback(nullptr)
            {}
            
            void Register(CallbackType& callback)
            {
                Eegeo_ASSERT(m_callback == nullptr);
                m_callback = &callback;
            }
            
            void Unregister(CallbackType& callback)
            {
                Eegeo_ASSERT(m_callback == &callback);
                m_callback = nullptr;
            }
            
        protected:
            
            CallbackType* m_callback;
        };
        
        template <typename TInterface>
        class TSingleObserverEvent0 : public TSingleObserverEventBase<TInterface>
        {
        public:
            typedef TInterface InterfaceType;
            
            void Raise() const
            {
                if (this->m_callback != nullptr)
                {
                    (*this->m_callback)();
                }
            }
        };
        
        template <typename TInterface>
        class TSingleObserverEvent1 : public TSingleObserverEventBase<TInterface>
        {
        public:
            typedef TInterface InterfaceType;
            
            void Raise(typename TInterface::Param0& param0) const
            {
                if (this->m_callback != nullptr)
                {
                    (*this->m_callback)(param0);
                }
            }
        };

    }
}