eventmanager.h

Go to the documentation of this file.

//=============================================================================================================
 
#ifndef EVENTMANAGER_EVENTS_H
#define EVENTMANAGER_EVENTS_H
 
//=============================================================================================================
// INCLUDES
//=============================================================================================================
 
#include "events_global.h"
#include "event.h"
#include "eventgroup.h"
 
#ifndef NO_IPC
#include "eventsharedmemmanager.h"
#else
namespace EVENTSLIB{
    enum SharedMemoryMode { READ, WRITE, READWRITE };
}
#endif
//=============================================================================================================
// STD INCLUDES
//=============================================================================================================
 
#include <string>
#include <map>
#include <unordered_map>
#include <vector>
#include <memory>
 
//=============================================================================================================
// NAMESPACE EVENTSLIB
//=============================================================================================================
 
namespace EVENTSLIB {
 
//=============================================================================================================
// EVENTSINTERNAL FORWARD DECLARATIONS
//=============================================================================================================
 
namespace EVENTSINTERNAL {
    class EventSharedMemManager;
}
 
//=============================================================================================================
class EVENTS_EXPORT EventManager
{
public:
    //=========================================================================================================
    EventManager();
 
    //=========================================================================================================
    size_t getNumEvents() const;
 
    //=========================================================================================================
    Event getEvent(idNum eventId) const;
 
    //=========================================================================================================
    std::unique_ptr<std::vector<Event> > getEvents(const std::vector<idNum> eventIds) const ;
 
    //=========================================================================================================
    std::unique_ptr<std::vector<Event> > getAllEvents() const ;
 
    //=========================================================================================================
    std::unique_ptr<std::vector<Event> > getEventsInSample(int sample) const ;
 
    //=========================================================================================================
    std::unique_ptr<std::vector<Event> > getEventsBetween(int sampleStart, int sampleEnd) const ;
 
    //=========================================================================================================
    std::unique_ptr<std::vector<Event> > getEventsBetween(int sampleStart, int sampleEnd, idNum groupid) const ;
 
    //=========================================================================================================
    std::unique_ptr<std::vector<Event> > getEventsBetween(int sampleStart, int sampleEnd, const std::vector<idNum>& groupIdsList) const ;
 
    //=========================================================================================================
    std::unique_ptr<std::vector<Event> > getEventsInGroup(const idNum groupId) const;
 
    //=========================================================================================================
    std::unique_ptr<std::vector<Event> > getEventsInGroups(const std::vector<idNum>& groupIdsList) const;
 
    //=========================================================================================================
    Event addEvent(int sample);
 
    //=========================================================================================================
    Event addEvent(int sample, idNum groupId);
 
    //=========================================================================================================
    bool moveEvent(idNum eventId, int newSample);
 
    //=========================================================================================================
    bool deleteEvent(idNum eventId) noexcept;
 
    //=========================================================================================================
    bool deleteEvents(const std::vector<idNum>& eventIds);
 
    //=========================================================================================================
    bool deleteEvents(std::unique_ptr<std::vector<Event> > eventIds);
 
    //=========================================================================================================
    bool deleteEventsInGroup(idNum groupId);
 
    //=========================================================================================================
    int getNumGroups() const;
 
    //=========================================================================================================
    EventGroup getGroup(idNum groupId) const;
 
    //=========================================================================================================
    std::unique_ptr<std::vector<EventGroup> > getAllGroups() const ;
 
    //=========================================================================================================
    std::unique_ptr<std::vector<EventGroup> > getGroups(const std::vector<idNum>& groupIds) const ;
 
    //=========================================================================================================
    EventGroup addGroup(const std::string& sGroupName);
 
    //=========================================================================================================
    EventGroup addGroup(const std::string& sGroupName, const RgbColor& color);
 
    //=========================================================================================================
    bool deleteGroup(const idNum groupId);
 
    //=========================================================================================================
    bool deleteGroups(const std::vector<idNum>& groupIds);
 
    //=========================================================================================================
    void renameGroup(const idNum groupId, const std::string& newName);
 
    //=========================================================================================================
    void setGroupColor(const idNum groupId, const RgbColor& color);
 
    //=========================================================================================================
    EventGroup mergeGroups(const std::vector<idNum>& groupIds, const std::string& newName);
 
    //=========================================================================================================
    EventGroup duplicateGroup(const idNum groupId, const std::string& newName);
 
    //=========================================================================================================
    bool addEventToGroup(const idNum eventId, const idNum groupId);
 
    //=========================================================================================================
    bool addEventsToGroup(const std::vector<idNum>& eventIds, const idNum groupId);
 
    //=========================================================================================================
    void initSharedMemory();
 
    //=========================================================================================================
    void initSharedMemory(SharedMemoryMode mode);
 
    //=========================================================================================================
    void stopSharedMemory();
 
    //=========================================================================================================
    bool isSharedMemoryInit();
 
private:
    //=========================================================================================================
    idNum generateNewEventId();
 
    //=========================================================================================================
    idNum generateNewGroupId();
 
    //=========================================================================================================
    void insertEvent(const EVENTSINTERNAL::EventINT& e);
 
    //=========================================================================================================
    bool eraseEvent(idNum eventId);
 
    //=========================================================================================================
    std::multimap<int, EVENTSINTERNAL::EventINT>::const_iterator findEventINT(idNum id) const;
 
    //=========================================================================================================
    void createDefaultGroupIfNeeded();
 
    std::multimap<int, EVENTSINTERNAL::EventINT>    m_EventsListBySample;           
    std::unordered_map<idNum, int>                  m_MapIdToSample;                
    std::map<idNum, EVENTSINTERNAL::EventGroupINT>  m_GroupsList;                   
 
#ifndef NO_IPC
    std::unique_ptr<EVENTSINTERNAL::EventSharedMemManager>  m_pSharedMemManager;    
    friend class EVENTSINTERNAL::EventSharedMemManager;
#endif
 
    idNum   m_iEventIdCounter;          
    idNum   m_iGroupIdCounter;          
    bool    m_bDefaultGroupNotCreated;  
    idNum   m_DefaultGroupId;           
 
};
 
//=============================================================================================================
template<typename T>
inline std::unique_ptr<std::vector<T> > allocateOutputContainer() noexcept
{
    return std::make_unique<std::vector<T> >();
};
 
//=============================================================================================================
template<typename T>
inline std::unique_ptr<std::vector<T> > allocateOutputContainer(size_t size) noexcept
{
    auto v = std::make_unique<std::vector<T> >();
    if(size > 0)
    {
        v->reserve(size);
    }
 
    return v;
};
 
}//namespace EVENTSLIB
#endif // EVENTS_H