populationevent.h

Go to the documentation of this file.

#ifndef POPULATIONEVENT_H
 
#define POPULATIONEVENT_H
 
#include "eventbase.h"
#include <assert.h>
#include <stdlib.h>
#include <string>
#include <iostream>
 
#define POPULATIONEVENT_MAXPERSONS                                                              2
 
//#define POPULATIONEVENT_FAKEDELETE
 
class PersonBase;
class PopulationStateInterface;
 
class PopulationEvent : public EventBase
{
public:
        PopulationEvent();
 
        PopulationEvent(PersonBase *pPerson);
 
        PopulationEvent(PersonBase *pPerson1, PersonBase *pPerson2);
        ~PopulationEvent();
 
        // These are for internal use
        void setGlobalEventPerson(PersonBase *pDummyPerson);
        void setEventID(int64_t id);
        int64_t getEventID() const;
 
        int getNumberOfPersons() const;
 
        PersonBase *getPerson(int idx) const;
 
        virtual bool isEveryoneAffected() const                                                 { return false; }
 
        virtual void markOtherAffectedPeople(const PopulationStateInterface &population)                        { }
 
        virtual bool areGlobalEventsAffected() const                                            { return false; }
 
        virtual std::string getDescription(double tNow) const                                   { return std::string("No description given"); }
 
        // TODO: shield these from the user somehow? These functions are used internally
        //       by the algorithm and should not be called directly by the user. */
        void setEventIndex(PersonBase *pPerson, int idx);
        int getEventIndex(PersonBase *pPerson) const;
 
        void setScheduledForRemoval()                                                           { m_scheduledForRemoval = true; }
        bool isScheduledForRemoval() const                                                      { return m_scheduledForRemoval; }
 
        bool isNoLongerUseful(const PopulationStateInterface &population);
 
        // For debugging
#if !defined(NDEBUG) && defined(POPULATIONEVENT_FAKEDELETE)
        void setDeleted()                                                                                       { m_deleted = true; }
        bool isDeleted() const                                                                          { return m_deleted; }
#else
        void setDeleted()                                                                                       {  }
        bool isDeleted() const                                                                          { return false; }
#endif
        PersonBase *getPersonWithoutChecking(int idx) const;
protected:
        virtual bool isUseless(const PopulationStateInterface &population)              { return false; } 
private:
        void commonConstructor();
 
        PersonBase *m_pPersons[POPULATIONEVENT_MAXPERSONS];
        int m_eventIndex[POPULATIONEVENT_MAXPERSONS];
        int8_t m_numPersons; 
 
        bool m_scheduledForRemoval;
        int64_t m_eventID;
 
#ifdef POPULATIONEVENT_FAKEDELETE
        bool m_deleted;
#endif // POPULATIONEVENT_FAKEDELETE
};
 
inline void PopulationEvent::setEventIndex(PersonBase *pPerson, int idx)
{
        assert(pPerson != 0);
        int num = m_numPersons;
 
        for (int i = 0 ; i < num ; i++)
        {
                assert(m_pPersons[i] != 0);
 
                if (pPerson == m_pPersons[i])
                {
                        m_eventIndex[i] = idx;
                        return;
                }
        }
        
        std::cerr << "PopulationEvent::setEventIndex: Consistency error: invalid Person object in setEventIndex" << std::endl;
        abort();
}
 
inline int PopulationEvent::getEventIndex(PersonBase *pPerson) const
{
        assert(pPerson != 0);
        int num = m_numPersons;
 
        for (int i = 0 ; i < num ; i++)
        {
                assert(m_pPersons[i] != 0);
 
                if (pPerson == m_pPersons[i])
                        return m_eventIndex[i];
        }
 
        std::cerr << "PopulationEvent::getEventIndex: Consistency error: invalid Person object in getEventIndex" << std::endl;
        abort();
}
 
#ifdef NDEBUG
inline PersonBase *PopulationEvent::getPerson(int idx) const
{ 
        return m_pPersons[idx];
}
#endif
 
inline PersonBase *PopulationEvent::getPersonWithoutChecking(int idx) const
{ 
        return m_pPersons[idx];
}
 
inline void PopulationEvent::setEventID(int64_t id)
{ 
#ifdef POPULATIONEVENT_FAKEDELETE
        assert(!m_deleted);
#endif
        assert(m_eventID < 0); 
        assert(id >= 0); 
        m_eventID = id; 
}
 
inline int64_t PopulationEvent::getEventID() const                                                              
{ 
#ifdef POPULATIONEVENT_FAKEDELETE
        assert(!m_deleted);
#endif
        return m_eventID; 
}
 
inline int PopulationEvent::getNumberOfPersons() const
{ 
#ifdef POPULATIONEVENT_FAKEDELETE
        assert(!m_deleted);
#endif
        assert(m_numPersons >= 0 && m_numPersons <= POPULATIONEVENT_MAXPERSONS); 
        return (int)m_numPersons; 
}
 
#endif // POPULATIONEVENT_H