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