eventsharedmemmanager.h

Go to the documentation of this file.

//=============================================================================================================
 
#ifndef EVENTSHAREDMEMMANAGER_EVENTS_H
#define EVENTSHAREDMEMMANAGER_EVENTS_H
 
//=============================================================================================================
// STD INCLUDES
//=============================================================================================================
 
#include <string>
#include <memory>
#include <chrono>
#include <thread>
#include <mutex>
#include <atomic>
 
//=============================================================================================================
// Qt INCLUDES
//=============================================================================================================
 
#include <QSharedMemory>
 
//=============================================================================================================
// MNECPP INCLUDES
//=============================================================================================================
 
#include "event.h"
#include "eventgroup.h"
 
namespace EVENTSLIB {
 
//=============================================================================================================
// EVENTSLIB FORWARD DECLARATIONS
//=============================================================================================================
 
enum SharedMemoryMode { READ, WRITE, READWRITE };
class EventManager;
 
namespace EVENTSINTERNAL {
 
//=========================================================================================================
enum EventUpdateType{ NULL_EVENT, NEW_EVENT, DELETE_EVENT};
 
//=========================================================================================================
const std::string EventUpdateTypeString[3] = {"Null Event", "New Event", "Delete Event"};

struct EventUpdate
{
public:
    //=========================================================================================================
    EventUpdate();
 
    //=========================================================================================================
    EventUpdate(int sample, int creator, enum EventUpdateType t);
 
    //=========================================================================================================
    long long getCreationTime() const;
 
    //=========================================================================================================
    int getSample() const;
 
    //=========================================================================================================
    int getCreatorId() const;
 
    //=========================================================================================================
    enum EventUpdateType getType() const;
 
    //=========================================================================================================
    void setType(enum EventUpdateType t);
 
    //=========================================================================================================
    std::string eventTypeToText();
 
protected:
    int                     m_EventSample;  
    int                     m_CreatorId;    
    long long               m_CreationTime; 
    enum EventUpdateType    m_TypeOfUpdate; 
};

class EventSharedMemManager
{
public:
    //=========================================================================================================
    explicit EventSharedMemManager(EVENTSLIB::EventManager* parent = nullptr);
 
    //=========================================================================================================
    ~EventSharedMemManager();
 
    //=========================================================================================================
    void init(EVENTSLIB::SharedMemoryMode mode);
 
    //=========================================================================================================
    bool isInit() const;
 
    //=========================================================================================================
    void stop();
 
    //=========================================================================================================
    void addEvent(int sample);
 
    //=========================================================================================================
    void deleteEvent(int sample);
 
    //=========================================================================================================
    static long long getTimeNow();
 
    //=========================================================================================================
    void processEvent(const EventUpdate& ne);
 
private:
    //=========================================================================================================
    void attachToSharedSegment(QSharedMemory::AccessMode mode);
 
    //=========================================================================================================
    bool createSharedSegment(int bufferSize, QSharedMemory::AccessMode mode);
 
    //=========================================================================================================
    void launchSharedMemoryWatcherThread();
 
    //=========================================================================================================
    void attachToOrCreateSharedSegment(QSharedMemory::AccessMode mode);
 
    //=========================================================================================================
    void stopSharedMemoryWatcherThread();
 
    //=========================================================================================================
    void detachFromSharedMemory();
 
    //=========================================================================================================
    inline static int generateId();
 
    //=========================================================================================================
    void processNewEvent(const EventUpdate& n);
 
    //=========================================================================================================
    void processDeleteEvent(const EventUpdate& n);
 
    //=========================================================================================================
    void printLocalBuffer();
 
    //=========================================================================================================
    void copyNewUpdateToSharedMemory(EventUpdate& newUpdate);
 
    //=========================================================================================================
    void initializeSharedMemory();
 
    //=========================================================================================================
    void copySharedMemoryToLocalBuffer();
 
    //=========================================================================================================
    void processLocalBuffer();
 
    //=========================================================================================================
    void bufferWatcher();
 
    //=========================================================================================================
    void createGroupIfNeeded();
 
    static int                          m_iLastUpdateIndex;             
    EVENTSLIB::EventManager*            m_pEventManager;                
    QSharedMemory                       m_SharedMemory;                 
    std::atomic_bool                    m_IsInit;                       
    std::string                         m_sGroupName;                   
    bool                                m_bGroupCreated;                
    idNum                               m_GroupId;                      
    int                                 m_SharedMemorySize;             
    int                                 m_fTimerCheckBuffer;            
    std::thread                         m_BufferWatcherThread;          
    std::atomic_bool                    m_BufferWatcherThreadRunning;   
    std::atomic_bool                    m_WritingToSharedMemory;        
    long long                           m_lastCheckTime;                
    EventUpdate*                        m_LocalBuffer;                  
    EventUpdate*                        m_SharedBuffer;                 
    int                                 m_Id;                           
    enum EVENTSLIB::SharedMemoryMode    m_Mode;                         
};
 
//=========================================================================================================
inline int EventSharedMemManager::generateId()
{
    auto t = static_cast<int>(EventSharedMemManager::getTimeNow());
    return abs(t);
}
 
} //namespace EVENTSINTERNAL
}//namespace EVENTSLIB
#endif // EVENTSHAREDMEMMANAGER_EVENTS_H