CscCoreEvents.h

Go to the documentation of this file.

//
//  CscCoreEvents.h
//  ConscienceRobotManager
//
//  Created by Louis Grignon on 26/04/2023.
//  Copyright © 2019 IliesZaoui. All rights reserved.
//
 
#ifndef CscCoreEvents_h
#define CscCoreEvents_h
 
#include "CscCommon.h"
#include <mutex>
#include <typeinfo>
#include <unordered_map>
#include <functional>
#include <condition_variable>
 
using std::unordered_map, std::type_info, std::reference_wrapper, std::function, std::mutex, std::unique_lock, std::condition_variable;
 
namespace conscience_core::core_objects::events {
 
class CscCoreEvent {
public:
    virtual ~CscCoreEvent();
};
 
class HandlerFunctionBase {
public:
    virtual ~HandlerFunctionBase();
    
    virtual void exec(const CscCoreEvent* event, bool &unregisterAfter) = 0;
};
 
template <class THandlerClass, class TEvent>
class MemberFunctionHandler : public HandlerFunctionBase {
public:
    typedef void (THandlerClass::*MemberFunc)(const TEvent *, bool &unregisterAfter);
    MemberFunctionHandler(THandlerClass *handlerInstance, MemberFunc handlerMethod, bool deleteObjectOnDestruct);
    ~MemberFunctionHandler();
    
    virtual void exec(const CscCoreEvent* event, bool &unregisterAfter) override;
private:
    THandlerClass* handlerInstance;
    MemberFunc handlerMethod;
    bool deleteObjectOnDestruct;
};
 
template <class THandlerClass, class TEvent>
void MemberFunctionHandler<THandlerClass, TEvent>::exec(const CscCoreEvent* event, bool &unregisterAfter) {
    (handlerInstance->*handlerMethod)(static_cast<const TEvent*>(event), unregisterAfter);
}
 
 
template <class THandlerClass, class TEvent>
MemberFunctionHandler<THandlerClass, TEvent>::MemberFunctionHandler(THandlerClass *handlerInstance, MemberFunc handlerMethod, bool deleteObjectOnDestruct) :
    handlerInstance(handlerInstance), handlerMethod(handlerMethod), deleteObjectOnDestruct(deleteObjectOnDestruct) {
}
 
template <class THandlerClass, class TEvent>
MemberFunctionHandler<THandlerClass, TEvent>::~MemberFunctionHandler() {
    if (deleteObjectOnDestruct) {
        delete handlerInstance;
    }
}
 
using TypeInfoRef = reference_wrapper<const type_info>;
struct TypeInfoMapHasher {
    size_t operator()(TypeInfoRef code) const;
};
struct TypeInfoMapEqualTo {
    bool operator()(TypeInfoRef lhs, TypeInfoRef rhs) const;
};
 
template <class TEvent>
using HandleEventFunction = function<void(const TEvent *event, bool &unregisterAfter)>;
 
template <class TEvent>
class LambdaHandlerWrapper {
public:
    void handle(const TEvent* theEvent, bool &unregisterAfter);
    LambdaHandlerWrapper(HandleEventFunction<TEvent> call);
private:
    HandleEventFunction<TEvent> call;
};
 
template <class TEvent>
void LambdaHandlerWrapper<TEvent>::handle(const TEvent *theEvent, bool &unregisterAfter) {
    call(theEvent, unregisterAfter);
}
    
template <class TEvent>
LambdaHandlerWrapper<TEvent>::LambdaHandlerWrapper(HandleEventFunction<TEvent> call): call(call) {
}
 
class CscCoreEvents {
public:
    void publish(const CscCoreEvent *event);
    
    template <class TObject, class TEvent>
    void registerHandler(const string &handlerId, TObject *handlerObject, void (TObject::*handlerMethod)(const TEvent *event, bool &unregisterAfter), bool deleteObjectOnDestruct = false) {
        TypeInfoRef eventType = typeid(TEvent);
        handlersMutex.lock();
        map<string, HandlerFunctionBase*> &eventHandlersById = handlers[eventType];
        if (eventHandlersById.find(handlerId) != eventHandlersById.end()) {
            logger->warn("event handler " + handlerId + ", already exists - force unregister first");
            delete eventHandlersById[handlerId];
            eventHandlersById.erase(handlerId);
        }
        eventHandlersById[handlerId] = new MemberFunctionHandler<TObject, TEvent>(handlerObject, handlerMethod, deleteObjectOnDestruct);
        handlersMutex.unlock();
    }
    
    template <class TEvent>
    void registerHandler(const string &handlerId, HandleEventFunction<TEvent> call) {
        auto obj = new LambdaHandlerWrapper(call);
        registerHandler<LambdaHandlerWrapper<TEvent>, TEvent>(handlerId, obj, &LambdaHandlerWrapper<TEvent>::handle, true);
    }
    
    template <class TEvent>
    void unregister(const string &handlerId) {
        TypeInfoRef eventType = typeid(TEvent);
        unregister(eventType, handlerId);
    }
    
    static CscCoreEvents *getInstance();
private:
    unordered_map<TypeInfoRef, map<string, HandlerFunctionBase*>, TypeInfoMapHasher, TypeInfoMapEqualTo> handlers;
    mutex handlersMutex;
    
    mutex eventQueueMutex;
    condition_variable eventQueueConditionVariable;
    vector<const CscCoreEvent *> eventQueue;
    void notifyHandlersThread();
    
    void unregister(TypeInfoRef eventType, const string &handlerId);
    
    CscCoreEvents();
    inline static CscCoreEvents *instance = nullptr;
    
    std::unique_ptr<CscLogger> logger;
};
 
}
 
#endif