event.h

Go to the documentation of this file.

//=============================================================================================================
 
#ifndef EVENT_EVENTSINTERNAL_H
#define EVENT_EVENTSINTERNAL_H
 
//=============================================================================================================
// INCLUDES
//=============================================================================================================
 
#include "events_global.h"
#include "eventgroup.h"
 
//=============================================================================================================
// STD INCLUDES
//=============================================================================================================
 
#include <string>
 
//=============================================================================================================
// NAMESPACE EVENTSLIB
//=============================================================================================================
 
namespace EVENTSLIB {
 
//=============================================================================================================
// EVENTSINTERNAL FORWARD DECLARATIONS
//=============================================================================================================
 
namespace EVENTSINTERNAL {
    class EventINT;
}
 
//=============================================================================================================
struct EVENTS_EXPORT Event
{
    //=========================================================================================================
    Event();
 
    //=========================================================================================================
    Event(const idNum id,const  int sample, const idNum groupId);
 
    //=========================================================================================================
    Event(const EVENTSINTERNAL::EventINT& e);
 
    idNum  id;      
    int  sample;    
    idNum  groupId; 
};
 
namespace EVENTSINTERNAL {
// The fact that we go with int for sample is a fundamental limitation of this
// whole architecture. With a Fs = 1kHz, we could have a maximum of aprox. 25 days.
// Yes not a big limitation... if we keep using 1kHz...
// If we were to go for long longs for sample... with that same 1kHz, we could go
// recording, single file... for about 300 million years. That's that...
// at some point we can substitute int and idNum with std::int64_t. That will take that limitation away.
// I don't see how I should ever think of this again.
class EventINT
{
public:
    //=========================================================================================================
    EventINT(idNum id);
 
    //=========================================================================================================
    EventINT(idNum id, int iSample, idNum groupId);
 
    //=========================================================================================================
    EventINT(const EventINT& rhs);
 
    //=========================================================================================================
    EventINT(EventINT&& other);
 
    //=========================================================================================================
    static inline EventINT fromSample(int iSample);
 
    //=========================================================================================================
    int getSample() const;
 
    //=========================================================================================================
    void setSample(int iSample);
 
    //=========================================================================================================
    idNum getGroupId() const;
 
    //=========================================================================================================
    void setGroupId(idNum iGroup);
 
    //=========================================================================================================
    idNum getId() const;
 
    //=========================================================================================================
    std::string getDescription() const;
 
    //=========================================================================================================
    void setDescription(const std::string& description);
 
    //=========================================================================================================
    void setDescription(std::string&& description);
 
    //=========================================================================================================
    bool operator<(const EventINT& rhs) const;
 
    //=========================================================================================================
    bool operator==(const EventINT& rhs) const;
 
    //=========================================================================================================
    EventINT operator=(const EventINT& rhs);
 
private:
    idNum       m_iId;                      
    int         m_iSample;                  
    idNum       m_iGroup;                   
    std::string m_sDescription;             
};
 
//=========================================================================================================
inline EventINT EventINT::fromSample(int sample)
{
    return EventINT(0, sample, 0);
}
 
}//namespace EVENTSINTERNAL
}//namespace EVENTSLIB
 
//=========================================================================================================

namespace std {
template<>
struct hash<EVENTSLIB::EVENTSINTERNAL::EventINT>
{
    size_t operator()(const EVENTSLIB::EVENTSINTERNAL::EventINT& rhs) const
    {
        return hash<int>()(rhs.getId());
    }
};
 
}
 
#endif // EVENT_H