Event.h

Go to the documentation of this file.

#pragma once
 
#include <type_traits>
#include <vector>
#include <functional>
#include <mutex>
 
#include <atomic>
 
#include "Types.h"
#include "Containers/Collection.h"
#include "Utils/Assert.h"
#include "TMP.h"
 
 
namespace Gorgon {
 
    namespace internal { 
        namespace event {
            template<class Source_, typename... Params_>
            struct HandlerBase {
                virtual void Fire(std::mutex &locker, Source_ *, Params_...) = 0;
                
                virtual ~HandlerBase() {}
            };
 
            template<class Source_, typename... Params_>
            struct EmptyHandlerFn : public HandlerBase<Source_, Params_...> {
                EmptyHandlerFn(std::function<void()> fn) : fn(fn) { }
 
                virtual void Fire(std::mutex &locker, Source_ *, Params_...) {
                    auto f=fn;
                    locker.unlock();
                    f();
                }
 
                std::function<void()> fn;
            };
 
            template<class Source_, typename... Params_>
            struct ArgsHandlerFn : public HandlerBase<Source_, Params_...> {
                ArgsHandlerFn(std::function<void(Params_...)> fn) : fn(fn) { }
 
                virtual void Fire(std::mutex &locker, Source_ *, Params_... args) {
                    auto f=fn;
                    locker.unlock();
                    f(std::forward<Params_>(args)...);
                }
 
                std::function<void(Params_...)> fn;
            };
 
            template<class Source_, typename... Params_>
            struct FullHandlerFn : public HandlerBase<Source_, Params_...> {
                static_assert(!std::is_same<Source_, void>::value, "No source class exists for this event (void cannot be passed around)");
                
                FullHandlerFn(std::function<void(Source_&, Params_...)> fn) : fn(fn) { }
 
                virtual void Fire(std::mutex &locker, Source_ *source, Params_... args) {
                    auto f=fn;
                    locker.unlock();
                    f(*source, std::forward<Params_>(args)...);
                }
 
                std::function<void(Source_&, Params_...)> fn;
            };
 
            template<class Source_, class... Params_>
            static HandlerBase<Source_, Params_...>& createhandlerfn(void(*fn)()) {
                return *new EmptyHandlerFn<Source_, Params_...>(fn);
            }
 
            template<class Source_, class... Params_>
            static HandlerBase<Source_, Params_...>& createhandlerfn(void(*fn)(Params_...)) {
                return *new ArgsHandlerFn<Source_, Params_...>(fn);
            }
 
            template<class Source_, class... Params_>
            static HandlerBase<Source_, Params_...>& createhandlerfn(void(*fn)(Source_ &, Params_...)) {
                return *new FullHandlerFn<Source_, Params_...>(fn);
            }
 
            template<class F_, class Source_, int N, class... Params_>
            static typename std::enable_if<TMP::FunctionTraits<F_>::Arity==0, HandlerBase<Source_, Params_...>&>::type 
            createhandler_internal(F_ fn) {
                return *new EmptyHandlerFn<Source_, Params_...>(fn);
            }
 
            template<class F_, class Source_, int N, typename... Params_>
            static typename std::enable_if<TMP::FunctionTraits<F_>::Arity!=0 && TMP::FunctionTraits<F_>::Arity==N, HandlerBase<Source_, Params_...>&>::type
            createhandler_internal(F_ fn) {
                return *new ArgsHandlerFn<Source_, Params_...>(fn);
            }
 
            template<class F_, class Source_, int N, class... Params_>
            static typename std::enable_if<TMP::FunctionTraits<F_>::Arity==N+1, HandlerBase<Source_, Params_...>&>::type
            createhandler_internal(F_ fn) {
                return *new FullHandlerFn<Source_, Params_...>(fn);
            }
 
            template<class F_, class Source_, class... Params_>
            typename std::enable_if<TMP::HasParanthesisOperator<F_>::value, HandlerBase<Source_, Params_...>&>::type 
            create_handler(F_ fn) {
                return createhandler_internal<F_, Source_, sizeof...(Params_), Params_...>(fn);
            }
 
            template<class F_, class Source_, class... Params_, typename N=void>
            typename std::enable_if<!TMP::HasParanthesisOperator<F_>::value, HandlerBase<Source_, Params_...>&>::type 
            create_handler(F_ fn) {
                return createhandlerfn<Source_, Params_...>(fn);
            }
        }
    }
 
    
    
    typedef intptr_t EventToken;
    
    template<class Source_=void, typename... Params_>
    class Event {
    public:
 
        typedef intptr_t Token;
        
        Event() : source(nullptr) {
            fire.clear();
            static_assert( std::is_same<Source_, void>::value , "Empty constructor cannot be used." );
        }
        
        template <class S_ = Source_>
        explicit Event(typename std::enable_if<!std::is_same<S_, void>::value, S_>::type &source) : source(&source) {
            fire.clear();
            static_assert(!std::is_same<Source_, void>::value, "Filling constructor is not required, use the default.");
        }
        
        template <class S_ = Source_>
        explicit Event(typename std::enable_if<!std::is_same<S_, void>::value, S_>::type *source) : source(source) {
            ASSERT(source, "Source cannot be nullptr");
            fire.clear();
            static_assert(!std::is_same<Source_, void>::value, "Filling constructor is not required, use the default.");
        }
        
        Event(Event &&event) : source(nullptr) {
            fire.clear();
            Swap(event);
#ifndef NDEBUG
            event.movedout = true;
#endif
        }
        
 
        ~Event() {
            ASSERT(!fire.test_and_set(), "An event cannot be destroyed while its being fired.");
            std::lock_guard<std::mutex> g(access);
            
            handlers.Destroy();
        }
        
        Event(const Event &) = delete;
        
        Event &operator =(const Event &) = delete;
 
        Event &operator =(Event &&other) {
            if(&other==this) return *this;
 
            std::lock_guard<std::mutex> g(access);
 
            ASSERT(!fire.test_and_set(), "An event cannot be moved into while its being fired.");
 
            handlers.Destroy();
 
            source=nullptr;
            fire.clear();
            Swap(other);
            
            return *this;
        }
 
        void Swap(Event &other) {
            if(&other==this) return;
 
            using std::swap;
 
            ASSERT(!fire.test_and_set() && !other.fire.test_and_set(), "An event cannot be swapped while its being fired.");
 
            swap(source, other.source);
            swap(handlers, other.handlers);
 
            fire.clear();
            other.fire.clear();
        }
 
        template<class F_>
        Token Register(F_ fn) {
 
            ASSERT(!movedout, "This event is moved out of");
 
            auto &handler=internal::event::create_handler<F_, Source_, Params_...>(fn);
 
            std::lock_guard<std::mutex> g(access);
            handlers.Add(handler);
 
            return reinterpret_cast<Token>(&handler);
        }
 
        template<class C_, typename... A_>
        Token Register(C_ &c, void(C_::*fn)(A_...)) {
 
            ASSERT(!movedout, "This event is moved out of");
 
            std::function<void(A_...)> f=TMP::MakeFunctionFromMember(fn, &c);
 
            return Register(f);
        }
 
        void Unregister(Token token) {
 
            ASSERT(!movedout, "This event is moved out of");
            
            std::lock_guard<std::mutex> g(access);
 
            auto item=reinterpret_cast<internal::event::HandlerBase<Source_, Params_...>*>(token);
            
            auto l=handlers.FindLocation(item);
            if(l==-1) return;
            
            if(iterator.IsValid() && iterator.CurrentPtr()==item) {
                handlers.Delete(l);
                
                //Collection iterator can point element -1
                iterator.Previous(); 
            }
            else {
                handlers.Delete(l);
            }
        }
 
        void operator()(Params_... args) {
            //stops the request if it is received from a different thread.
            std::lock_guard<std::recursive_mutex> g(firemtx);
            
            ASSERT(!movedout, "This event is moved out of");
 
            try {
                for(iterator=handlers.begin(); iterator.IsValid(); iterator.Next()) {
                    access.lock();
                    // fire method will unlock access after it creates a local copy of the function
                    // this allows the fired object to be safely deleted.
                    iterator->Fire(access, source, std::forward<Params_>(args)...);
                }
            }
            catch(...) {
                //unlock everything if something goes bad
                
                //just in case
                access.unlock();
                
                fire.clear();
                
                throw;
            }
            
            fire.clear();
        }
        
        void Clear() {
            std::lock_guard<std::recursive_mutex> g1(firemtx);
            std::lock_guard<std::mutex> g2(access);
            
#ifndef NDEBUG
            ASSERT(!fire.test_and_set(), "Recursion detected during event execution.");
#else
            //prevent recursion
            if(fire.test_and_set()) return;
#endif
            
            fire.clear();
            
            handlers.DeleteAll();
        }
        
        static const Token EmptyToken;
        
    private:
 
#ifndef NDEBUG
        bool movedout = false;
#endif
 
 
        std::mutex access;
        std::atomic_flag fire;
        Source_ *source;
        Containers::Collection<internal::event::HandlerBase<Source_, Params_...>> handlers;
        typename Containers::Collection<internal::event::HandlerBase<Source_, Params_...>>::Iterator iterator;
        std::recursive_mutex firemtx;
    };
    
    template<class C_, class ...P_>
    const typename Event<C_, P_...>::Token Event<C_, P_...>::EmptyToken = 0;
    
    template<class Source_, class... Args_>
    void swap(Event<Source_, Args_...> &l, Event<Source_, Args_...> &r) {
        l.Swap(r);
    }
}