EventMap Class Reference

#include <EventMap.h>

Public Member Functions
	EventMap ()
Reset
Removes all scheduled events and resets time and phase.
void	Reset ()
Update
Updates the timer of the event map. Parameters time Value in ms to be added to time.
void	Update (uint32 time)
GetTimer
Returns Current timer in ms value.
uint32	GetTimer () const
GetPhaseMask
Returns Active phases as mask.
uint8	GetPhaseMask () const
Empty
Returns True, if there are no events scheduled.
bool	Empty () const
SetPhase
Sets the phase of the map (absolute). Parameters phase Phase which should be set. Values: 1 - 8. 0 resets phase.
void	SetPhase (uint8 phase)
AddPhase
Activates the given phase (bitwise). Parameters phase Phase which should be activated. Values: 1 - 8
void	AddPhase (uint8 phase)
RemovePhase
Deactivates the given phase (bitwise). Parameters phase Phase which should be deactivated. Values: 1 - 8.
void	RemovePhase (uint8 phase)
ScheduleEvent
Creates new event entry in map. Parameters eventId The id of the new event. time The time in milliseconds until the event occurs. group The group which the event is associated to. Has to be between 1 and 8. 0 means it has no group. phase The phase in which the event can occur. Has to be between 1 and 8. 0 means it can occur in all phases.
void	ScheduleEvent (uint32 eventId, Milliseconds const &time, uint32 group=0, uint8 phase=0)
void	ScheduleEvent (uint32 eventId, uint32 time, uint32 group=0, uint8 phase=0)
RescheduleEvent
Cancels the given event and reschedules it. Parameters eventId The id of the event. time The time in milliseconds until the event occurs. group The group which the event is associated to. Has to be between 1 and 8. 0 means it has no group. phase The phase in which the event can occur. Has to be between 1 and 8. 0 means it can occur in all phases.
void	RescheduleEvent (uint32 eventId, Milliseconds const &time, uint32 group=0, uint8 phase=0)
void	RescheduleEvent (uint32 eventId, uint32 time, uint32 group=0, uint8 phase=0)
RepeatEvent
Repeats the mostly recently executed event, Equivalent to Repeat(urand(minTime, maxTime). Parameters minTime Minimum time until the event occurs. maxTime Maximum time until the event occurs.
void	Repeat (Milliseconds const &time)
void	Repeat (uint32 time)
void	Repeat (Milliseconds const &minTime, Milliseconds const &maxTime)
void	Repeat (uint32 minTime, uint32 maxTime)
ExecuteEvent
Returns the next event to execute and removes it from map. Returns Id of the event to execute.
uint32	ExecuteEvent ()
DelayEvents
Delay all events of the same group. Parameters delay Amount of delay. group Group of the events.
void	DelayEvents (Milliseconds const &delay)
void	DelayEvents (uint32 delay)
void	DelayEvents (Milliseconds const &delay, uint32 group)
void	DelayEvents (uint32 delay, uint32 group)
CancelEvent
Cancels all events of the specified id. Parameters eventId Event id to cancel.
void	CancelEvent (uint32 eventId)
CancelEventGroup
Cancel events belonging to specified group. Parameters group Group to cancel.
void	CancelEventGroup (uint32 group)
GetNextEventTime
Returns Time of next event.
uint32	GetNextEventTime (uint32 eventId) const
uint32	GetNextEventTime () const
IsInPhase
Returns whether event map is in specified phase or not. Parameters phase Wanted phase. Returns True, if phase of event map contains specified phase.
bool	IsInPhase (uint8 phase) const
GetTimeUntilEvent
Returns time in milliseconds until next event. Parameters eventId of the event. Returns Time of next event.
uint32	GetTimeUntilEvent (uint32 eventId) const

Private Types
typedef std::multimap< uint32, uint32 >	EventStore

Private Attributes
_time
Internal timer. This does not represent the real date/time value. It's more like a stopwatch: It can run, it can be stopped, it can be resetted and so on. Events occur when this timer has reached their time value. Its value is changed in the Update method.
uint32	_time
_phase
Phase mask of the event map. Contains the phases the event map is in. Multiple phases from 1 to 8 can be set with SetPhase or AddPhase. RemovePhase deactives a phase.
uint8	_phase
_eventMap
Internal event storage map. Contains the scheduled events. See typedef at the beginning of the class for more details.
EventStore	_eventMap
_lastEvent
Stores information on the most recently executed event
uint32	_lastEvent

Member Typedef Documentation

typedef std::multimap<uint32, uint32> EventMap::EventStore

private

Internal storage type. Key: Time as uint32 when the event should occur. Value: The event data as uint32.

Structure of event data:

• Bit 0 - 15: Event Id.
• Bit 16 - 23: Group
• Bit 24 - 31: Phase
• Pattern: 0xPPGGEEEE

Constructor & Destructor Documentation

EventMap::EventMap ( )

inline

: _time(0), _phase(0), _lastEvent(0) { }

Member Function Documentation

void EventMap::AddPhase ( uint8  phase )

inline

 {
 if (phase && phase <= 8)
 _phase |= uint8(1 << (phase - 1));
 }

void EventMap::CancelEvent

(

uint32

eventId

)

{
 if (Empty())
 return;

 for (EventStore::iterator itr = _eventMap.begin(); itr != _eventMap.end();)
 {
 if (eventId == (itr->second & 0x0000FFFF))
 _eventMap.erase(itr++);
 else
 ++itr;
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void EventMap::CancelEventGroup

(

uint32

group

)

{
 if (!group || group > 8 || Empty())
 return;

 for (EventStore::iterator itr = _eventMap.begin(); itr != _eventMap.end();)
 {
 if (itr->second & (1 << (group + 15)))
 _eventMap.erase(itr++);
 else
 ++itr;
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void EventMap::DelayEvents ( Milliseconds const &  delay )

inline

 {
 DelayEvents(uint32(delay.count()));
 }

Here is the caller graph for this function:

void EventMap::DelayEvents ( uint32  delay )

inline

 {
 _time = delay < _time ? _time - delay : 0;
 }

void EventMap::DelayEvents ( Milliseconds const &  delay, uint32  group  )

inline

 {
 DelayEvents(uint32(delay.count()), group);
 }

void EventMap::DelayEvents	(	uint32	delay,
		uint32	group
	)

{
 if (!group || group > 8 || Empty())
 return;

 EventStore delayed;

 for (EventStore::iterator itr = _eventMap.begin(); itr != _eventMap.end();)
 {
 if (itr->second & (1 << (group + 15)))
 {
 delayed.insert(EventStore::value_type(itr->first + delay, itr->second));
 _eventMap.erase(itr++);
 }
 else
 ++itr;
 }

 _eventMap.insert(delayed.begin(), delayed.end());
}

Here is the call graph for this function:

bool EventMap::Empty ( ) const

inline

 {
 return _eventMap.empty();
 }

Here is the caller graph for this function:

uint32 EventMap::ExecuteEvent

(

)

{
 while (!Empty())
 {
 EventStore::iterator itr = _eventMap.begin();

 if (itr->first > _time)
 return 0;
 else if (_phase && (itr->second & 0xFF000000) && !((itr->second >> 24) & _phase))
 _eventMap.erase(itr);
 else
 {
 uint32 eventId = (itr->second & 0x0000FFFF);
 _lastEvent = itr->second; // include phase/group
 _eventMap.erase(itr);
 return eventId;
 }
 }

 return 0;
}

Here is the call graph for this function:

uint32 EventMap::GetNextEventTime

(

uint32

eventId

)

const

{
 if (Empty())
 return 0;

 for (EventStore::const_iterator itr = _eventMap.begin(); itr != _eventMap.end(); ++itr)
 if (eventId == (itr->second & 0x0000FFFF))
 return itr->first;

 return 0;
}

Here is the call graph for this function:

uint32 EventMap::GetNextEventTime ( ) const

inline

 {
 return Empty() ? 0 : _eventMap.begin()->first;
 }

uint8 EventMap::GetPhaseMask ( ) const

inline

 {
 return _phase;
 }

Here is the caller graph for this function:

uint32 EventMap::GetTimer ( ) const

inline

 {
 return _time;
 }

uint32 EventMap::GetTimeUntilEvent

(

uint32

eventId

)

const

{
 for (EventStore::const_iterator itr = _eventMap.begin(); itr != _eventMap.end(); ++itr)
 if (eventId == (itr->second & 0x0000FFFF))
 return itr->first - _time;

 return std::numeric_limits<uint32>::max();
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool EventMap::IsInPhase ( uint8  phase ) const

inline

 {
 return phase <= 8 && (!phase || _phase & (1 << (phase - 1)));
 }

void EventMap::RemovePhase ( uint8  phase )

inline

 {
 if (phase && phase <= 8)
 _phase &= uint8(~(1 << (phase - 1)));
 }

void EventMap::Repeat ( Milliseconds const &  time )

inline

 {
 Repeat(uint32(time.count()));
 }

Here is the caller graph for this function:

void EventMap::Repeat ( uint32  time )

inline

 {
 _eventMap.insert(EventStore::value_type(_time + time, _lastEvent));
 }

void EventMap::Repeat ( Milliseconds const &  minTime, Milliseconds const &  maxTime  )

inline

 {
 Repeat(uint32(minTime.count()), uint32(maxTime.count()));
 }

void EventMap::Repeat ( uint32  minTime, uint32  maxTime  )

inline

 {
 Repeat(urand(minTime, maxTime));
 }

Here is the call graph for this function:

void EventMap::RescheduleEvent ( uint32  eventId, Milliseconds const &  time, uint32  group = 0, uint8  phase = 0  )

inline

 {
 RescheduleEvent(eventId, uint32(time.count()), group, phase);
 }

Here is the caller graph for this function:

void EventMap::RescheduleEvent ( uint32  eventId, uint32  time, uint32  group = 0, uint8  phase = 0  )

inline

 {
 CancelEvent(eventId);
 ScheduleEvent(eventId, time, group, phase);
 }

void EventMap::Reset

(

)

{
 _eventMap.clear();
 _time = 0;
 _phase = 0;
}

void EventMap::ScheduleEvent ( uint32  eventId, Milliseconds const &  time, uint32  group = 0, uint8  phase = 0  )

inline

 {
 ScheduleEvent(eventId, uint32(time.count()), group, phase);
 }

void EventMap::ScheduleEvent	(	uint32	eventId,
		uint32	time,
		uint32	group = 0,
		uint8	phase = 0
	)

{
 if (group && group <= 8)
 eventId |= (1 << (group + 15));

 if (phase && phase <= 8)
 eventId |= (1 << (phase + 23));

 _eventMap.insert(EventStore::value_type(_time + time, eventId));
}

void EventMap::SetPhase

(

uint8

phase

)

{
 if (!phase)
 _phase = 0;
 else if (phase <= 8)
 _phase = uint8(1 << (phase - 1));
}

void EventMap::Update ( uint32  time )

inline

 {
 _time += time;
 }

Member Data Documentation

EventStore EventMap::_eventMap

private

uint32 EventMap::_lastEvent

private

uint8 EventMap::_phase

private

uint32 EventMap::_time

private

---

The documentation for this class was generated from the following files:

• src/common/Utilities/EventMap.h
• src/common/Utilities/EventMap.cpp