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

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)                                                             { assert(m_eventID < 0); assert(id >= 0); m_eventID = id; }
        int64_t getEventID() const                                                              { return m_eventID; }

        int getNumberOfPersons() const                                                          { assert(m_numPersons >= 0 && m_numPersons <= POPULATIONEVENT_MAXPERSONS); return (int)m_numPersons; }

        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();
protected:
        virtual bool isUseless()                                                                { 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;
};

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

#endif // POPULATIONEVENT_H